HEGII.gt.mes.wcf/DK.Service/PMModuleService/PMModuleLogic.cs

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

using Curtain.DataAccess;
using Dongke.IBOSS.PRD.Basics.BaseResources;
using Dongke.IBOSS.PRD.Basics.DataAccess;
using Dongke.IBOSS.PRD.Service.CMNModuleService;
using Dongke.IBOSS.PRD.Service.DataModels;
using Dongke.IBOSS.PRD.WCF.DataModels;
using Oracle.ManagedDataAccess.Client;
using System;
using System.Collections.Generic;
using System.Data;
using System.Text;
using DataBaseType = Curtain.DataAccess.DataBaseType;
using System.Linq;

namespace Dongke.IBOSS.PRD.Service.PMModuleService
{
	/// <summary>
	/// 生产管理服务端业务逻辑
	/// </summary>
	public static class PMModuleLogic
	{
		#region 注浆管理

		#region 注浆登记一览

		/// <summary>
		/// 取得FPM0101画面（注浆登记）的初始化数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <returns>初始化数据</returns>
		public static ServiceResultEntity GetFPM0101IData(SUserInfo user)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				DataTable dataTable = CMNModuleLogic.GetTP_MST_GMouldType(conn, user, Constant.ValueFlag.Effective);
				ServiceResultEntity sre = new ServiceResultEntity();
				sre.Data = new DataSet();
				sre.Data.Tables.Add(dataTable);
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 取得FPM0101画面（注浆登记）的查询数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="ids">多个注浆id（用[,]分开）</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetFPM0101SData(SUserInfo user, string ids)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				List<OracleParameter> parameters = new List<OracleParameter>();
				StringBuilder sql = new StringBuilder(PMModuleLogic.GetFPM0101SSQL());
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":UPUserId", OracleDbType.Int32, user.UserID, ParameterDirection.Input));

				//if (!string.IsNullOrWhiteSpace(ids))
				{
					//ids = "," + ids + ",";
					//sql.Append(" AND INSTR(:GroutingDailyIDs, ',' || GD.GroutingDailyID || ',') > 0");
					sql.Append(" AND  GD.GroutingDailyID in ( " + ids + " )");
					parameters.Add(new OracleParameter(":GroutingDailyIDs", OracleDbType.Varchar2, ids, ParameterDirection.Input));
				}

				sql.Append(" ORDER BY GDD.GroutingLineCode, GDD.GroutingDate, GDD.GroutingDailyID, GDD.GroutingMouldCode");
				DataTable data = conn.GetSqlResultToDt(sql.ToString(), parameters.ToArray());

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
					return sre;
				}
				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 取得FPM0101画面（注浆登记）的查询数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetFPM0101SData(SUserInfo user, FPM0101_SE se)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				List<OracleParameter> parameters = new List<OracleParameter>();
				StringBuilder sql = new StringBuilder(PMModuleLogic.GetFPM0101SSQL());
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":UPUserId", OracleDbType.Int32, user.UserID, ParameterDirection.Input));

				if (se != null)
				{
					// 成型线编码
					if (!string.IsNullOrEmpty(se.GroutingLineCode))
					{
						sql.Append(" AND INSTR(GD.GroutingLineCode, :GroutingLineCode) > 0");
						parameters.Add(new OracleParameter(":GroutingLineCode", OracleDbType.NVarchar2, se.GroutingLineCode, ParameterDirection.Input));
					}
					// 成型线名称
					if (!string.IsNullOrEmpty(se.GroutingLineName))
					{
						sql.Append(" AND INSTR(GD.GroutingLineName, :GroutingLineName) > 0");
						parameters.Add(new OracleParameter(":GroutingLineName", OracleDbType.NVarchar2, se.GroutingLineName, ParameterDirection.Input));
					}
					// 成型线类别
					if (se.GMouldTypeID.HasValue)
					{
						sql.Append(" AND GD.GMouldTypeID = :GMouldTypeID");
						parameters.Add(new OracleParameter(":GMouldTypeID", OracleDbType.Int32, se.GMouldTypeID.Value, ParameterDirection.Input));
					}
					// 注浆日期-开始
					if (se.GroutingDateBegin.HasValue)
					{
						sql.Append(" AND GD.GroutingDate >= :GroutingDateBegin");
						parameters.Add(new OracleParameter(":GroutingDateBegin", OracleDbType.Date, se.GroutingDateBegin.Value, ParameterDirection.Input));
					}
					// 注浆日期-结束
					if (se.GroutingDateEnd.HasValue)
					{
						sql.Append(" AND GD.GroutingDate <= :GroutingDateEnd");
						parameters.Add(new OracleParameter(":GroutingDateEnd", OracleDbType.Date, se.GroutingDateEnd.Value, ParameterDirection.Input));
					}
					// 注浆批次
					if (se.GroutingBatchNo.HasValue)
					{
						sql.Append(" AND GD.GroutingBatchNo = :GroutingBatchNo");
						parameters.Add(new OracleParameter(":GroutingBatchNo", OracleDbType.Int32, se.GroutingBatchNo.Value, ParameterDirection.Input));
					}
					// 注浆模具编号
					if (!string.IsNullOrEmpty(se.GroutingMouldCode))
					{
						sql.Append(" AND INSTR(GDD.GroutingMouldCode, :GroutingMouldCode) > 0");
						parameters.Add(new OracleParameter(":GroutingMouldCode", OracleDbType.NVarchar2, se.GroutingMouldCode, ParameterDirection.Input));
					}
					// 产品编号
					if (!string.IsNullOrEmpty(se.GoodsCode))
					{
						sql.Append(" AND INSTR(GDD.GoodsCode, :GoodsCode) > 0");
						parameters.Add(new OracleParameter(":GoodsCode", OracleDbType.NVarchar2, se.GoodsCode, ParameterDirection.Input));
					}
					// 产品名称
					if (!string.IsNullOrEmpty(se.GoodsName))
					{
						sql.Append(" AND INSTR(GDD.GoodsName, :GoodsName) > 0");
						parameters.Add(new OracleParameter(":GoodsName", OracleDbType.NVarchar2, se.GoodsName, ParameterDirection.Input));
					}
					// 备注
					if (!string.IsNullOrEmpty(se.Remarks))
					{
						sql.Append(" AND INSTR(GDD.Remarks, :Remarks) > 0");
						parameters.Add(new OracleParameter(":Remarks", OracleDbType.NVarchar2, se.Remarks, ParameterDirection.Input));
					}
					// 注浆标识
					if (!string.IsNullOrEmpty(se.GroutingFlag))
					{
						sql.Append(" AND GDD.GroutingFlag = :GroutingFlag");
						parameters.Add(new OracleParameter(":GroutingFlag", OracleDbType.Char, se.GroutingFlag, ParameterDirection.Input));
					}
					// 损坯标识
					if (!string.IsNullOrEmpty(se.ScrapFlag))
					{
						sql.Append(" AND GDD.ScrapFlag = :ScrapFlag");
						parameters.Add(new OracleParameter(":ScrapFlag", OracleDbType.Char, se.ScrapFlag, ParameterDirection.Input));
					}
					// 成型工号
					if (!string.IsNullOrEmpty(se.GroutingUserCode))
					{
						sql.Append(" AND INSTR(GDD.UserCode, :GroutingUserCode) > 0");
						parameters.Add(new OracleParameter(":GroutingUserCode", OracleDbType.NVarchar2, se.GroutingUserCode, ParameterDirection.Input));
					}
					// 条码
					if (!string.IsNullOrEmpty(se.BarCode))
					{
						sql.Append(" AND INSTR(GDD.BarCode, :BarCode) > 0");
						parameters.Add(new OracleParameter(":BarCode", OracleDbType.NVarchar2, se.BarCode, ParameterDirection.Input));
					}
					// 绑定条码
					if (!string.IsNullOrEmpty(se.BarCodeFlag))
					{
						if ("1" == se.BarCodeFlag)
						{
							sql.Append(" AND LENGTH(GDD.BarCode) > 0");
						}
						else
						{
							sql.Append(" AND (GDD.BarCode IS NULL OR LENGTH(GDD.BarCode) = 0)");
						}
					}
					// 交坯日期-开始
					if (se.DeliverTimeBegin.HasValue)
					{
						sql.Append(" AND GDD.DeliverTime >= :DeliverTimeBegin");
						parameters.Add(new OracleParameter(":DeliverTimeBegin", OracleDbType.Date, se.DeliverTimeBegin.Value, ParameterDirection.Input));
					}
					// 交坯日期-结束
					if (se.DeliverTimeEnd.HasValue)
					{
						sql.Append(" AND GDD.DeliverTime < :DeliverTimeEnd");
						parameters.Add(new OracleParameter(":DeliverTimeEnd", OracleDbType.Date, se.DeliverTimeEnd.Value.AddDays(1), ParameterDirection.Input));
					}
					// 交坯标识
					if (!string.IsNullOrEmpty(se.DeliverFlag))
					{
						sql.Append(" AND GDD.DeliverFlag = :DeliverFlag");
						parameters.Add(new OracleParameter(":DeliverFlag", OracleDbType.Char, se.DeliverFlag, ParameterDirection.Input));
					}
				}

				sql.Append(" ORDER BY GDD.GroutingDate, GDD.GroutingLineCode, GDD.GroutingDailyID, GDD.GroutingMouldCode");
				DataTable data = conn.GetSqlResultToDt(sql.ToString(), parameters.ToArray());

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
					return sre;
				}
				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 获取查询sql
		/// </summary>
		/// <returns>sql</returns>
		private static string GetFPM0101SSQL()
		{
			string selSql =
				"SELECT GDD.GroutingDailyDetailID," +
				"       GDD.GroutingDailyID," +
				"       GDD.GroutingLineDetailID," +
				"       GDD.GroutingLineID," +
				// 成型线编码
				"       GDD.GroutingLineCode," +
				// 成型线名称
				"       GDD.GroutingLineName," +
				// 注浆日期
				"       GDD.GroutingDate," +
				// 注浆批次
				"       GDD.GroutingBatchNo," +
				// 成型工号
				"       GDD.UserCode," +
				// 产品编码
				"       GDD.GoodsCode," +
				// 产品名称
				"       GDD.GoodsName," +
				// 注浆线模具编码
				"       GDD.GroutingMouldCode," +
				// 模具状态
				"       GMS.GMouldStatusName," +
				// 注浆标识
				"       GDD.GroutingFlag," +
				// 注浆标识
				"       decode(ML.LogoID, null, null,to_char( ML.LogoName || '[' || ML.LogoCode || ']')) LogoNameCode," +
				// 未注浆原因
				"       DD.DictionaryValue AS NoGroutingRreason," +
				// 注浆次数
				"       GDD.GroutingCount," +
				// 损坯标识
				"       GDD.ScrapFlag," +
				// 备注
				"       GDD.Remarks," +
				// 成型线类型
				"       GMT.GMouldTypeName," +
				// 绑定条码
				"       GDD.BarCode," +
				// 交坯时间
				"       GDD.DeliverTime," +
				// 交坯标识
				"       GDD.DeliverFlag," +
				// 成型班长
				"       MU.UserName AS MONITORName," +
				// 创建时间
				"       GDD.CreateTime," +
				// 创建工号
				"       U.UserName AS Createuser" +
				// 注浆日报
				"  FROM TP_PM_GroutingDaily GD" +
				// 注浆日报明细表
				" INNER JOIN TP_PM_GroutingDailyDetail GDD" +
				"    ON GD.GroutingDailyID = GDD.GroutingDailyID" +
				// 成型线类型
				" INNER JOIN TP_MST_GMouldType GMT" +
				"    ON GD.GMouldTypeID = GMT.GMouldTypeID" +
				// 模具状态
				" INNER JOIN TP_SYS_GMouldStatus GMS" +
				"    ON GMS.GMouldStatusID = GDD.GMouldStatus" +
				// 创建工号
				" INNER JOIN TP_MST_User U" +
				"    ON U.UserID = GDD.CreateUserID" +
				// 成型线
				" LEFT JOIN tp_pc_groutingline gl" +
				"    ON gl.groutinglineid = GDD.GroutingLineID" +
				// 成型班长
				" LEFT JOIN tp_mst_user mu" +
				"    ON mu.userid = gl.MONITORID" +
				// 未注浆原因
				"  LEFT JOIN TP_MST_DataDictionary DD" +
				"    ON DD.DictionaryID = GDD.NoGroutingRreason" +
				// 商标
				"  LEFT JOIN TP_MST_Logo ML" +
				"    ON ML.LogoID = GDD.LogoID" +
				// 账套
				" WHERE GD.AccountID = :AccountID" +
				"   AND GD.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
			// 成型线操作权限
			"   AND EXISTS (SELECT UP.PurviewID" +
			"          FROM TP_MST_UserPurview UP" +
			"         WHERE UP.PurviewType = '" + (int)Constant.PurviewType.OperateGroutingLine + "'" +
			"           AND (UP.PurviewID = -1 OR UP.PurviewID = GD.GroutingLineID)" +
			"           AND UP.UserId = :UPUserId)";
			return selSql;
		}

		#endregion 注浆登记一览

		#region 注浆登记

		/// <summary>
		/// 取得FPM0102画面（注浆登记）的初始化数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="groutingDailyID">注浆日报ID</param>
		/// <returns>
		/// 初始化数据
		/// 注浆数据
		/// OtherStatus = 1:没有可编辑的注浆信息
		/// OtherStatus = 2:没有可编辑的注浆明细信息
		/// </returns>
		public static ServiceResultEntity GetFPM0102IData(SUserInfo user, int groutingDailyID)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				ServiceResultEntity sre = new ServiceResultEntity();
				DataTable dataTable = CMNModuleLogic.GetTP_MST_DataDictionary(conn, user, Constant.DictionaryType.TPC004, Constant.ValueFlag.Effective);
				// 账务日期
				object date = CMNModuleLogic.GetAccountDate(conn, user);
				if (date == null || date == DBNull.Value)
				{
					// 服务器时间错误
					//throw new Exception("SystemDateTimeError");
					sre.Status = Constant.ServiceResultStatus.AccountDateError;
					return sre;
				}
				sre.Data = new DataSet();
				dataTable.TableName = Constant.DictionaryType.TPC004.ToString();
				sre.Data.Tables.Add(dataTable);
				sre.Result = date;

				// 编辑时，取得注浆日报信息
				if (groutingDailyID > 0)
				{
					StringBuilder sql = new StringBuilder();
					List<OracleParameter> parameters = new List<OracleParameter>();

					string gdSql =
						"SELECT GD.GroutingDailyID," +
						"       GD.GroutingLineID," +
						"       GD.GroutingLineCode," +
						"       GD.GroutingLineName," +
						"       GD.MouldQuantity," +
						"       GD.GroutingDate," +
						"       GD.OPTimeStamp" +
						"  FROM TP_PM_GroutingDaily GD" +
						" WHERE GD.AccountID = :AccountID" +
						"   AND GD.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
						// 成型线操作权限
						"   AND EXISTS (SELECT UP.PurviewID" +
						"                 FROM TP_MST_UserPurview UP" +
						"                WHERE UP.PurviewType = '" + (int)Constant.PurviewType.OperateGroutingLine + "'" +
						"                  AND (UP.PurviewID = -1 OR UP.PurviewID = GD.GroutingLineID)" +
						"                  AND UP.UserId = :UPUserId)" +
						"   AND GD.GroutingDailyID = :GroutingDailyID";

					parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));
					parameters.Add(new OracleParameter(":UPUserId", OracleDbType.Int32, user.UserID, ParameterDirection.Input));
					parameters.Add(new OracleParameter(":GroutingDailyID", OracleDbType.Int32, groutingDailyID, ParameterDirection.Input));

					DataTable gdData = conn.GetSqlResultToDt(gdSql, parameters.ToArray());
					if (gdData == null || gdData.Rows.Count == 0)
					{
						// 没有可编辑的注浆信息
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = 1;
						sre.Message = "没有可编辑的注浆信息";
						return sre;
					}
					gdData.TableName = "TP_PM_GroutingDaily";
					sre.Data.Tables.Add(gdData);

					string gddSql =
						"SELECT GDD.GroutingDailyID," +
						"       GDD.GroutingDailyDetailID," +
						"       GDD.GroutingLineID," +
						"       GDD.GroutingLineDetailID," +
						"       GDD.GroutingLineCode," +
						"       GDD.GroutingLineName," +
						"       GDD.GroutingDate," +
						"       GDD.GroutingBatchNo," +
						"       GDD.GroutingMouldCode," +
						//"       GDD.MouldCode," +
						//"       GDD.UserID as GroutingUserID," +
						"       GDD.UserCode as GroutingUserCode," +
						"       GDD.GoodsCode," +
						"       GDD.GoodsName," +
						//"       GDD.GMouldStatus," +
						"       GMS.GMouldStatusName," +
						"       GDD.GroutingFlag," +
						"       GDD.NoGroutingRreason," +
						"       GDD.Remarks," +
						"       GDD.ScrapFlag," +
						"       GDD.LogoID," +
						"       GDD.DeliverFlag," +
						"       GDD.BarCode" +
						"  FROM TP_PM_GroutingDailyDetail GDD" +
						" INNER JOIN TP_SYS_GMouldStatus GMS" +
						"    ON GMS.GMouldStatusID = GDD.GMouldStatus" +
						//" INNER JOIN TP_MST_Goods MG" +
						//"    ON MG.Goodsid = GLD.GoodsID" +
						//" INNER JOIN TP_MST_User U" +
						//"    ON U.Userid = GDD.Userid" +
						" WHERE GDD.AccountID = :AccountID" +
						"   AND GDD.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
						"   AND GDD.GroutingDailyID = :GroutingDailyID" +
						" ORDER BY GDD.GroutingMouldCode";
					parameters.Clear();
					parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));
					parameters.Add(new OracleParameter(":GroutingDailyID", OracleDbType.Int32, groutingDailyID, ParameterDirection.Input));

					DataTable gddData = conn.GetSqlResultToDt(gddSql, parameters.ToArray());
					if (gddData == null || gddData.Rows.Count == 0)
					{
						// 没有可注浆的模具
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = 2;
						sre.Message = "没有可编辑的注浆明细信息";
						return sre;
					}

					gddData.TableName = "TP_PM_GroutingDailyDetail";
					sre.Data.Tables.Add(gddData);

					// 'S_PM_022', '注浆编辑限制天数' add by chenxy 2018-12-15 begin
					sre.Result = 1;
					string spm022 = conn.GetSqlResultToStr("select ss.SETTINGVALUE from tp_mst_systemsetting ss where ss.SETTINGCODE = 'S_PM_022' and ss.AccountID = " + user.AccountID);
					int spm022Value = 0;
					if (!string.IsNullOrWhiteSpace(spm022) && int.TryParse(spm022, out spm022Value) && spm022Value > 0)
					{
						DateTime tDate = DateTime.Now.Date;
						DateTime lastDate = tDate.AddDays(1 - spm022Value);
						DateTime gData = (DateTime)gdData.Rows[0]["GroutingDate"];
						if (gData < lastDate || gData > tDate)
						{
							sre.Result = 0;
							sre.Message = string.Format("允许注浆编辑的日期范围【{0:yyyy-MM-dd}】-【{1:yyyy-MM-dd}】", lastDate, tDate);
						}
					}
					// 'S_PM_022', '注浆编辑限制天数' add by chenxy 2018-12-15 end
				}

				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 取得FPM0102画面（注浆登记）的成型线数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="groutingDate">注浆日期</param>
		/// <param name="groutingIDs">成型线ID（多个用【，】隔开）</param>
		/// <returns>
		/// 成型线数据
		/// OtherStatus = 1：注浆日期大于账务日期
		/// OtherStatus = 2：没有可注浆的成型线
		/// OtherStatus = 3：没有可注浆的模具
		/// </returns>
		public static ServiceResultEntity GetFPM0102_GroutingLine(SUserInfo user, DateTime? groutingDate, string groutingIDs)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				ServiceResultEntity sre = new ServiceResultEntity();
				// 账务日期
				object date = CMNModuleLogic.GetAccountDate(conn, user);
				if (date == null || date == DBNull.Value)
				{
					// 服务器时间错误
					//throw new Exception("SystemDateTimeError");
					sre.Status = Constant.ServiceResultStatus.AccountDateError;
					return sre;
				}
				DateTime accountDate = Convert.ToDateTime(date);

				// 成型线变更 ver41 by chenxy begin
				/* 注浆日期大于此成型线最后一次注浆日期
                if (groutingDate.HasValue && groutingDate > accountDate)
                {
                    // 注浆日期大于账务日期
                    sre.Status = Constant.ServiceResultStatus.Other;
                    sre.OtherStatus = 1;
                    sre.Message = string.Format("注浆日期({0})大于账务日期({1})",
                        groutingDate.Value.ToString(Constant.S_DATE_YYYY_MM_DD),
                        accountDate.ToString(Constant.S_DATE_YYYY_MM_DD));
                    return sre;
                }
                */
				// 成型线变更 ver41 by chenxy end

				if (!groutingDate.HasValue)
				{
					groutingDate = accountDate;
				}
				sre.Result = groutingDate;

				// 'S_PM_021', '注浆登记限制天数' add by chenxy 2018-12-15 begin
				string spm021 = conn.GetSqlResultToStr("select ss.SETTINGVALUE from tp_mst_systemsetting ss where ss.SETTINGCODE = 'S_PM_021' and ss.AccountID = " + user.AccountID);
				int spm021Value = 0;
				if (!string.IsNullOrWhiteSpace(spm021) && int.TryParse(spm021, out spm021Value) && spm021Value > 0)
				{
					DateTime tDate = DateTime.Now.Date;
					DateTime lastDate = tDate.AddDays(1 - spm021Value);
					if (groutingDate < lastDate || groutingDate > tDate)
					{
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = 1;
						sre.Message = string.Format("允许注浆登记的日期范围【{0:yyyy-MM-dd}】-【{1:yyyy-MM-dd}】", lastDate, tDate);
						return sre;
					}
				}
				// 'S_PM_021', '注浆登记限制天数' add by chenxy 2018-12-15 end

				StringBuilder sql = new StringBuilder();
				List<OracleParameter> parameters = new List<OracleParameter>();

				string glSql =
					"SELECT GL.GroutingLineID," +
					"       GL.GroutingLineCode," +
					"       GL.GroutingLineName," +
					"       GL.MouldQuantity," +
					"       GL.UserID," +
					"       U.UserCode," +
					"       GL.monitorid," +
					"       mu.usercode monitorcode," +
					//"       mu.username || '[' || mu.usercode || ']' monitorcode," +
					// 成型线变更 ver41 by chenxy begin
					/*
                    "       GL.UserCount," +
                    "       decode((GL.UserCount, 1, GL.UserID, NULL) GroutingUserID," +
                    "       decode((GL.UserCount, 1, U.UserCode, NULL) GroutingUserCode," +
                    //"       GL.LastGroutingDate," +
                    "       GL.LastGroutingBatchNo," +
                    "       decode((GMT.CanManyTimes, '1', NULL, 1) GroutingNum," +
                    "       GMT.CanManyTimes," +
                    */
					"       decode(GMT.CanManyTimes, '1', decode(GL.LastGroutingDate, null, 1, :GroutingDate, NVL(GL.LastGroutingBatchNo, 1) + 1, 1), 1) GroutingBatchNo," +
					"       GMT.CanManyTimes," +
					"       GMT.GMouldTypeID," +
					"       GMT.GMouldTypeName," +
					// 成型线变更 ver41 by chenxy end
					"       GL.OPTimeStamp" +
					"  FROM TP_PC_GroutingLine GL" +
					" INNER JOIN TP_MST_User U" +
					"    ON U.UserID = GL.UserID " +
					" left JOIN TP_MST_User mU" +
					"    ON mU.UserID = GL.monitorid" +
					"  LEFT JOIN TP_MST_GMouldType GMT" +
					"    ON GMT.GMouldTypeID = GL.GMouldTypeID " +
					//// 成型线操作权限
					//" INNER JOIN (SELECT UP.PurviewID" +
					//"               FROM TP_MST_UserPurview UP" +
					//"              WHERE UP.PurviewType = '" + (int)Constant.PurviewType.OperateGroutingLine + "'" +
					//"                AND UP.UserId = :UPUserId) UP" +
					//"    ON UP.PurviewID = GL.GroutingLineID" +
					" WHERE GL.AccountID = :AccountID" +
					"   AND GL.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
					"   AND GL.GMouldStatus = '" + (int)Constant.GMouldStatus.Normal + "'" +
					// 成型线操作权限
					"   AND EXISTS (SELECT UP.PurviewID" +
					"                 FROM TP_MST_UserPurview UP" +
					"                WHERE UP.PurviewType = '" + (int)Constant.PurviewType.OperateGroutingLine + "'" +
					"                  AND (UP.PurviewID = -1 OR UP.PurviewID = GL.GroutingLineID)" +
					"                  AND UP.UserId = :UPUserId)" +
					// 未注浆
					// 成型线变更 ver41 by chenxy begin
					/*
                    "   AND NOT EXISTS (SELECT GD.GroutingDailyID" +
                    "                     FROM TP_PM_GroutingDaily GD" +
                    "                    WHERE GD.GroutingLineID = GL.GroutingLineID" +
                    "                      AND GD.GroutingDate = :GroutingDate)"
                     */
					// 注浆日期必须小于等于账务日期
					"   AND :GroutingDate <= FUN_CMN_GetAccountDate(:AccountID)" +
					"   AND (GL.LastGroutingDate IS NULL OR (GMT.CanManyTimes = '1' AND GL.LastGroutingDate <= :GroutingDate) OR (GMT.CanManyTimes <> '1' AND GL.LastGroutingDate < :GroutingDate))"
					// 成型线变更 ver41 by chenxy end
					// 有正常状态的模具
					+ " AND EXISTS (SELECT 1 FROM TP_PC_GroutingLineDetail GLD WHERE GL.GroutingLineID = GLD.GroutingLineID AND GLD.ValueFlag = '1' AND GLD.GMouldStatus=1)"
					;

				sql.Append(glSql);
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":UPUserId", OracleDbType.Int32, user.UserID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":GroutingDate", OracleDbType.Date, groutingDate.Value.Date, ParameterDirection.Input));

				if (!string.IsNullOrWhiteSpace(groutingIDs))
				{
					groutingIDs = "," + groutingIDs + ",";
					sql.Append(" AND INSTR(:GroutingLineIDs, ',' || GL.GroutingLineID || ',') > 0");
					parameters.Add(new OracleParameter(":GroutingLineIDs", OracleDbType.Varchar2, groutingIDs, ParameterDirection.Input));
				}
				else
				{
					sql.Append(" AND GL.UserCount = 1");
				}
				sql.Append(" ORDER BY GroutingLineCode");

				DataTable glData = conn.GetSqlResultToDt(sql.ToString(), parameters.ToArray());
				if (glData == null || glData.Rows.Count == 0)
				{
					// 没有可注浆的成型线
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 2;
					sre.Message = string.Format("注浆日期({0})没有可注浆的成型线",
						groutingDate.Value.ToString(Constant.S_DATE_YYYY_MM_DD));
					return sre;
				}
				sre.Data = new DataSet();
				glData.TableName = "TP_PC_GroutingLine";
				sre.Data.Tables.Add(glData);

				groutingIDs = ",";
				foreach (DataRow row in glData.Rows)
				{
					groutingIDs += row["GroutingLineID"] + ",";
				}

				string gldSql =
					"SELECT GLD.GroutingLineID," +
					"       GL.GroutingLineCode," +
					"       GL.GroutingLineName," +
					"       GLD.GroutingLineDetailID," +
					"       GLD.GroutingMouldCode," +
					// 成型线变更 ver41 by chenxy begin
					//"       GL.UserID," +
					//"       U.UserCode," +
					//"       GL.UserCount," +
					"       decode(GL.UserCount, 1, GL.UserID, NULL) GroutingUserID," +
					"       decode(GL.UserCount, 1, U.UserCode, NULL) GroutingUserCode," +
					"       decode(GMT.CanManyTimes, '1', decode(GL.LastGroutingDate, null, 1, :GroutingDate, NVL(GL.LastGroutingBatchNo, 1) + 1, 1), 1) GroutingBatchNo," +
					//"       GMT.CanManyTimes," +
					"       GL.monitorid," +
					"       decode(mu.userid,null,'', mu.username || '[' || mu.usercode || ']') monitorcode," +
					"       GMT.GMouldTypeID," +
					"       GMT.GMouldTypeName," +
					// 成型线变更 ver41 by chenxy end
					"       MG.GoodsCode," +
					"       MG.GoodsName," +
					"       MG.LogoID," +
					"       GLD.GMouldStatus," +
					"       GMS.GMouldStatusName," +
					"       CASE WHEN GLD.GMouldStatus = '" + (int)Constant.GMouldStatus.Normal + "' THEN '" + (int)Constant.GroutingFlag.Yes + "'" +
					"            ELSE '" + (int)Constant.GroutingFlag.No + "'" +
					"            END AS GroutingFlag" +
					"  FROM TP_PC_GroutingLine GL" +
					" left JOIN TP_MST_User mU" +
					"    ON mU.UserID = GL.monitorid" +
					" INNER JOIN TP_PC_GroutingLineDetail GLD" +
					"    ON GL.GroutingLineID = GLD.GroutingLineID" +
					" INNER JOIN TP_SYS_GMouldStatus GMS" +
					"    ON GMS.GMouldStatusID = GLD.GMouldStatus" +
					" INNER JOIN TP_MST_Goods MG" +
					"    ON MG.Goodsid = GLD.GoodsID" +
					" INNER JOIN TP_MST_User U" +
					"    ON U.Userid = GL.Userid" +
					"  LEFT JOIN TP_MST_GMouldType GMT" +
					"    ON GMT.GMouldTypeID = GL.GMouldTypeID " +
					" WHERE GL.AccountID = :AccountID" +
					"   AND GLD.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
					"   AND GLD.GMouldStatus = '" + (int)Constant.GMouldStatus.Normal + "'" +
					"   AND INSTR(:GroutingLineIDs, ',' || GL.GroutingLineID || ',') > 0" +
					" ORDER BY GL.GroutingLineCode, GLD.GroutingMouldCode";
				parameters.Clear();
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":GroutingLineIDs", OracleDbType.Varchar2, groutingIDs, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":GroutingDate", OracleDbType.Date, groutingDate.Value.Date, ParameterDirection.Input));

				DataTable gldData = conn.GetSqlResultToDt(gldSql, parameters.ToArray());
				if (gldData == null || gldData.Rows.Count == 0)
				{
					// 没有可注浆的模具
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 3;
					sre.Message = string.Format("注浆日期({0})没有可注浆的模具",
						groutingDate.Value.ToString(Constant.S_DATE_YYYY_MM_DD));
					return sre;
				}

				gldData.TableName = "TP_PC_GroutingLineDetail";
				sre.Data.Tables.Add(gldData);

				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 取得FPM0104画面（选择成型线）的查询数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetFPM0104SData(SUserInfo user, FPM0104_SE se)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				ServiceResultEntity sre = new ServiceResultEntity();

				// 'S_PM_021', '注浆登记限制天数' add by chenxy 2018-12-15 begin
				string spm021 = conn.GetSqlResultToStr("select ss.SETTINGVALUE from tp_mst_systemsetting ss where ss.SETTINGCODE = 'S_PM_021' and ss.AccountID = " + user.AccountID);
				int spm021Value = 0;
				if (!string.IsNullOrWhiteSpace(spm021) && int.TryParse(spm021, out spm021Value) && spm021Value > 0)
				{
					DateTime tDate = DateTime.Now.Date;
					DateTime lastDate = tDate.AddDays(1 - spm021Value);
					if (se.GroutingDate < lastDate || se.GroutingDate > tDate)
					{
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = -1;
						sre.Message = string.Format("允许注浆登记的日期范围【{0:yyyy-MM-dd}】-【{1:yyyy-MM-dd}】", lastDate, tDate);
						return sre;
					}
				}
				// 'S_PM_021', '注浆登记限制天数' add by chenxy 2018-12-15 end

				string sqlString =
					"SELECT " +
					"       GL.GroutingLineID," +
					"       GL.GroutingLineCode," +
					"       GL.GroutingLineName," +
					"       GMS.GMouldStatusName," +
					"       GMT.GMouldTypeName," +
					"       GL.MouldQuantity," +
					// 成型线变更 ver41 by chenxy begin
					//"       U.UserCode AS GroutingUserCode," +
					//"       WMSYS.WM_CONCAT(DISTINCT TO_CHAR(GS.GoodsCode)) AS GoodsCode" +
					"       (select WM_CONCAT(DISTINCT TO_CHAR(gs.GoodsCode)) GoodsCode" +
					"          from tp_pc_groutinglinedetail gld" +
					"          left join tp_mst_goods gs" +
					"            on gs.goodsid = gld.goodsid" +
					"         where gld.groutinglineid = gl.groutinglineid" +
					"           AND gld.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
					"           AND gld.GMouldStatus = '" + (int)Constant.GMouldStatus.Normal + "') GoodsCode," +
					//"       GL.UserID," +
					//"       U.UserCode," +
					"       GL.UserCount," +
					"       decode(GL.UserCount, 1, GL.UserID, NULL) GroutingUserID," +
					"       decode(GL.UserCount, 1, U.UserCode, NULL) GroutingUserCode," +
					"       GL.LastGroutingDate," +
					"       GL.LastGroutingBatchNo," +
					"       GL.monitorid," +
					//"       mu.usercode monitorcode," +
					"       decode(mu.userid,null,'', mu.username || '[' || mu.usercode || ']') monitorcode," +
					"       decode(GMT.CanManyTimes, '1', NULL, 1) GroutingNum," +
					"       GMT.CanManyTimes" +
					// 成型线变更 ver41 by chenxy end
					"  FROM TP_PC_GroutingLine GL" +
					// 成型线变更 ver41 by chenxy begin
					//" INNER JOIN TP_PC_GroutingLineDetail GLD" +
					//"    ON GLD.GroutingLineID = GL.GroutingLineID" +
					// 成型线变更 ver41 by chenxy end
					" INNER JOIN TP_SYS_GMouldStatus GMS" +
					"    ON GMS.GMouldStatusID = GL.GMouldStatus" +
					" INNER JOIN TP_MST_GMouldType GMT" +
					"    ON GMT.GMouldTypeID = GL.GMouldTypeID" +
					// 成型线变更 ver41 by chenxy begin
					//" INNER JOIN TP_MST_Goods GS" +
					//"    ON GS.GoodsID = GLD.GoodsID" +
					// 成型线变更 ver41 by chenxy end
					" INNER JOIN TP_MST_User U" +
					"    ON U.UserID = GL.UserID" +
					" left JOIN TP_MST_User mU" +
					"    ON mU.UserID = GL.monitorid" +
					" WHERE GL.AccountID = :AccountID" +
					"   AND GL.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
					"   AND GL.GMouldStatus = '" + (int)Constant.GMouldStatus.Normal + "'" +
					//// 成型线操作权限
					"   AND EXISTS (SELECT UP.PurviewID" +
					"                 FROM TP_MST_UserPurview UP" +
					"                WHERE UP.PurviewType = '" + (int)Constant.PurviewType.OperateGroutingLine + "'" +
					"                  AND (UP.PurviewID = -1 OR UP.PurviewID = GL.GroutingLineID)" +
					"                  AND UP.UserId = :UPUserId)" +
					// 未注浆
					// 成型线变更 ver41 by chenxy begin
					//"   AND NOT EXISTS (SELECT GD.GroutingDailyID" +
					//"                     FROM TP_PM_GroutingDaily GD" +
					//"                    WHERE GD.GroutingLineID = GL.GroutingLineID" +
					//"                      AND GD.GroutingDate = :GroutingDate)" +
					// 注浆日期必须小于等于账务日期
					"   AND :GroutingDate <= FUN_CMN_GetAccountDate(:AccountID)" +
					"   AND (GL.LastGroutingDate IS NULL OR (GMT.CanManyTimes = '1' AND GL.LastGroutingDate <= :GroutingDate) OR (GMT.CanManyTimes <> '1' AND GL.LastGroutingDate < :GroutingDate))"
					// 成型线变更 ver41 by chenxy end
					// 有正常状态的模具
					+ " AND EXISTS (SELECT 1 FROM TP_PC_GroutingLineDetail GLD WHERE GL.GroutingLineID = GLD.GroutingLineID AND GLD.ValueFlag = '1' AND GLD.GMouldStatus=1)"
					;

				StringBuilder sql = new StringBuilder(sqlString);
				List<OracleParameter> parameters = new List<OracleParameter>();
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":UPUserId", OracleDbType.Int32, user.UserID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":GroutingDate", OracleDbType.Date, se.GroutingDate, ParameterDirection.Input));

				if (se != null)
				{
					// 成型线编码
					if (!string.IsNullOrEmpty(se.GroutingLineCode))
					{
						sql.Append(" AND INSTR(GL.GroutingLineCode, :GroutingLineCode) > 0");
						parameters.Add(new OracleParameter(":GroutingLineCode", OracleDbType.NVarchar2, se.GroutingLineCode, ParameterDirection.Input));
					}
					// 成型线名称
					if (!string.IsNullOrEmpty(se.GroutingLineName))
					{
						sql.Append(" AND INSTR(GL.GroutingLineName, :GroutingLineName) > 0");
						parameters.Add(new OracleParameter(":GroutingLineName", OracleDbType.NVarchar2, se.GroutingLineName, ParameterDirection.Input));
					}
					// 成型工号
					if (!string.IsNullOrEmpty(se.GroutingUserCode))
					{
						sql.Append(" AND INSTR(U.UserCode, :GroutingUserCode) > 0");
						parameters.Add(new OracleParameter(":GroutingUserCode", OracleDbType.NVarchar2, se.GroutingUserCode, ParameterDirection.Input));
					}
					// 成型班长
					if (!string.IsNullOrEmpty(se.Monitorcode))
					{
						sql.Append(" AND INSTR(mu.UserCode, :Monitorcode) > 0");
						parameters.Add(new OracleParameter(":Monitorcode", OracleDbType.NVarchar2, se.Monitorcode, ParameterDirection.Input));
					}
					// 成型线类别
					if (se.GMouldTypeID.HasValue)
					{
						sql.Append(" AND GL.GMouldTypeID = :GMouldTypeID");
						parameters.Add(new OracleParameter(":GMouldTypeID", OracleDbType.Int32, se.GMouldTypeID.Value, ParameterDirection.Input));
					}
					// 备注
					if (!string.IsNullOrEmpty(se.Remarks))
					{
						sql.Append(" AND INSTR(GL.Remarks, :Remarks) > 0");
						parameters.Add(new OracleParameter(":Remarks", OracleDbType.NVarchar2, se.Remarks, ParameterDirection.Input));
					}
				}

				sqlString = sql.ToString() +
					// 成型线变更 ver41 by chenxy begin
					//" GROUP BY" +
					//"       GL.GroutingLineID," +
					//"       GL.GroutingLineCode," +
					//"       GL.GroutingLineName," +
					//"       GMS.GMouldStatusName," +
					//"       GMT.GMouldTypeName," +
					//"       GL.MouldQuantity," +
					//"       U.UserCode" +
					// 成型线变更 ver41 by chenxy end
					" ORDER BY GL.GroutingLineCode";

				DataTable data = conn.GetSqlResultToDt(sqlString, parameters.ToArray());

				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
					return sre;
				}
				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);

				// 成型线变更 ver41 by chenxy begin
				string groutingIDs = ",";
				foreach (DataRow row in data.Rows)
				{
					groutingIDs += row["GroutingLineID"] + ",";
				}

				string guSql = "select gu.groutinglineid, gu.remarks, u.userid groutinguserid, u.usercode groutingusercode" +
							   "  from TP_PC_GroutingUser gu" +
							   "  left join tp_mst_user u" +
							   "    on u.userid = gu.userid where INSTR(:GroutingLineIDs, ',' || gu.GroutingLineID || ',') > 0";
				parameters.Clear();
				parameters.Add(new OracleParameter(":GroutingLineIDs", OracleDbType.Varchar2, groutingIDs, ParameterDirection.Input));
				DataTable guData = conn.GetSqlResultToDt(guSql, parameters.ToArray());
				//if (guData == null || guData.Rows.Count == 0)
				//{
				//	// 没有可注浆的模具
				//	sre.Status = Constant.ServiceResultStatus.Other;
				//	sre.OtherStatus = 3;
				//	sre.Message = string.Format("注浆日期({0})没有可注浆的模具",
				//		groutingDate.Value.ToString(Constant.S_DATE_YYYY_MM_DD));
				//	return sre;
				//}
				guData.TableName = "TP_PC_GroutingUser";
				sre.Data.Tables.Add(guData);
				// 成型线变更 ver41 by chenxy end

				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 返回班次配置信息
		/// </summary>
		/// <param name="sUserInfo"></param>
		/// <returns></returns>
		private static int? getClassesSettingID(IDBTransaction oracleTrConn, int userID, DateTime accountDate)
		{
			#region 将班次配置表中的数据插入生产者表中
			string sql = "select max(ClassesSettingID) as ClassesSettingID"
											   + " from TP_PC_ClassesSetting"
											   + " where ValueFlag = 1 and AccountDate=:accountDate"
												+ " and UserID = :userID";

			OracleParameter[] paras = new OracleParameter[] {
					new OracleParameter(":accountDate",OracleDbType.Date,accountDate,ParameterDirection.Input),
					new OracleParameter(":userID",OracleDbType.Int32,userID,ParameterDirection.Input),
				};
			DataSet ds = oracleTrConn.GetSqlResultToDs(sql, paras);
			if (ds != null && ds.Tables[0].Rows.Count > 0)
			{
				return Convert.ToInt32(ds.Tables[0].Rows[0]["ClassesSettingID"]);
			}
			return null;
			#endregion
		}

		/// <summary>
		/// 保存FPM0102画面（注浆登记）的注浆数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="groutingDate">注浆日期(null：编辑；非null：新建)</param>
		/// <param name="groutingInfo">注浆数据</param>
		/// <returns>保存结果
		/// OtherStatus = 1: 没有以下成型线的操作权限
		/// OtherStatus = 2: 以下成型线已做过注浆
		/// OtherStatus = 3: 以下成型工号已被停用
		/// OtherStatus = 4: 补注浆，成型工号没有班次配置
		/// OtherStatus = 5: 以下成型工号没有配置员工关联
		/// </returns>
		public static ServiceResultEntity SetFPM0102Data(SUserInfo user, DateTime? groutingDate, DataSet groutingInfo)
		{
			IDBTransaction tran = null;
			try
			{
				ServiceResultEntity sre = new ServiceResultEntity();
				if (groutingInfo == null ||
					groutingInfo.Tables.Count != 2 ||
					groutingInfo.Tables[0].Rows.Count < 1 ||
					groutingInfo.Tables[1].Rows.Count < 1)
				{
					sre.Status = Constant.ServiceResultStatus.NoModifyData;
					return sre;
				}

				tran = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				int executeResult = 0;

				DataTable dtGroutingLine = groutingInfo.Tables[0];
				DataTable dtGroutingDetail = groutingInfo.Tables[1];

				// 新建注浆登记
				if (groutingDate.HasValue)
				{
					#region 新建注浆登记
					groutingDate = groutingDate.Value.Date;

					#region 取得账务日期
					// 账务日期
					object date = CMNModuleLogic.GetAccountDate(tran, user);
					if (date == null || date == DBNull.Value)
					{
						// 服务器时间错误
						//throw new Exception("SystemDateTimeError");
						sre.Status = Constant.ServiceResultStatus.AccountDateError;
						return sre;
					}
					DateTime accountDate = Convert.ToDateTime(date).Date;

					// 注浆日期不能大于账务日期
					if (groutingDate > accountDate)
					{
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = 1;
						sre.Message = string.Format("注浆日期({0})不能大于账务日期({1})",
							groutingDate.Value.ToString(Constant.S_DATE_YYYY_MM_DD),
							accountDate.ToString(Constant.S_DATE_YYYY_MM_DD));
						return sre;
					}
					#endregion 取得账务日期

					#region 验证成型线时间戳
					StringBuilder checkGLSql = new StringBuilder("select GroutingLineCode from TP_PC_GroutingLine where valueflag = '1' and (");
					int index = 0;
					foreach (DataRow item in dtGroutingLine.Rows)
					{
						if (index > 0)
						{
							checkGLSql.AppendLine(" or ");
						}
						checkGLSql.AppendFormat(" (GroutingLineID = {0} and OPTimeStamp <> to_timestamp('{1}','yyyy-mm-dd hh24:mi:ss.ff'))", item["GroutingLineID"], ((System.DateTime)item["OPTimeStamp"]).ToString("yyyy-MM-dd HH:mm:ss.ffffff"));
						index++;
					}
					checkGLSql.AppendLine(")");

					DataTable checkGLDataTable = tran.GetSqlResultToDt(checkGLSql.ToString());
					if (checkGLDataTable != null && checkGLDataTable.Rows.Count > 0)
					{
						string code = null;
						foreach (DataRow item in checkGLDataTable.Rows)
						{
							if (code == null)
							{
								code = item["GroutingLineCode"].ToString();
							}
							else
							{
								code += "," + item["GroutingLineCode"].ToString();
							}
						}

						// 成型线信息被修改
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = 1;
						sre.Message = "以下成形线数据已被修改，请重新选择成型线。" + System.Environment.NewLine + code;
						return sre;
					}
					#endregion 验证成型线时间戳

					#region 数据校验 插入班次配置
					// 成型工ID
					List<string> userIDs = new List<string>();
					List<string> userCodes = new List<string>();
					// 成型线ID
					List<string> lineIDs = new List<string>();
					List<string> lineCodes = new List<string>();
					foreach (DataRow gdd in dtGroutingDetail.Rows)
					{
						string userID = gdd["GroutingUserID"].ToString();
						if (!userIDs.Contains(userID))
						{
							userIDs.Add(userID);
							userCodes.Add(gdd["GroutingUserCode"].ToString());
						}
						string lineID = gdd["GroutingLineID"].ToString();
						if (!lineIDs.Contains(lineID))
						{
							lineIDs.Add(lineID);
							lineCodes.Add(gdd["GroutingLineCode"].ToString());
						}
					}

					#region 成型线校验
					string strLineIDs = "," + string.Join(",", lineIDs) + ",";
					string strNoLineCodes = null;
					// 校验成型线操作权限
					string checkPurviewSql =
						"SELECT UP.PurviewID" +
						"  FROM TP_MST_UserPurview UP" +
						" WHERE UP.PurviewType = '" + (int)Constant.PurviewType.OperateGroutingLine + "'" +
						"   AND (UP.PurviewID = -1 OR INSTR(:GroutingLineIDs, ',' || UP.PurviewID || ',') > 0)" +
						"   AND UP.UserId = :UPUserId Order by UP.PurviewID";
					OracleParameter[] checkPurviewParas = new OracleParameter[]
					{
						new OracleParameter(":GroutingLineIDs", OracleDbType.Varchar2, strLineIDs, ParameterDirection.Input),
						new OracleParameter(":UPUserId", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
					};
					DataTable purviewData = tran.GetSqlResultToDt(checkPurviewSql, checkPurviewParas);
					if (purviewData == null || purviewData.Rows.Count == 0)
					{
						strNoLineCodes = string.Join(",", lineCodes);
					}
					else if ("-1" == purviewData.Rows[0][0].ToString())
					{
						strNoLineCodes = null;
					}
					else if (lineIDs.Count != purviewData.Rows.Count)
					{
						for (int i = 0; i < lineIDs.Count; i++)
						{
							DataRow[] drs = purviewData.Select("PurviewID = " + lineIDs[i]);
							if (drs == null || drs.Length == 0)
							{
								if (strNoLineCodes != null)
								{
									strNoLineCodes += "," + lineCodes[i];
								}
								else
								{
									strNoLineCodes += lineCodes[i];
								}
							}
						}
					}
					if (strNoLineCodes != null)
					{
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = 1;
						sre.Message = "当前用户没有以下成型线的操作权限。"
							+ System.Environment.NewLine + strNoLineCodes;
						return sre;
					}

					/* 已验证成型线时间戳，注浆时会修改成型线的最后注浆日期，时间戳会变。
                    // 校验成型线是否已注浆
                    string checkGroutingDailySql =
                        "SELECT GD.GroutingLineCode" +
                        "  FROM TP_PM_GroutingDaily GD" +
                        " WHERE GD.AccountID = :AccountID" +
                        "   AND GD.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
                        "   AND GD.GroutingDate = :GroutingDate" +
                        "   AND INSTR(:GroutingLineIDs, ',' || GD.GroutingLineID || ',') > 0";
                    OracleParameter[] checkGroutingDailyParas = new OracleParameter[]
                    {
                        new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input),
                        new OracleParameter(":GroutingDate", OracleDbType.Date, groutingDate.Value, ParameterDirection.Input),
                        new OracleParameter(":GroutingLineIDs", OracleDbType.Varchar2, strLineIDs, ParameterDirection.Input),
                    };
                    DataTable groutingDailyData = tran.GetSqlResultToDt(checkGroutingDailySql, checkGroutingDailyParas);
                    strNoLineCodes = null;
                    if (groutingDailyData != null && groutingDailyData.Rows.Count > 0)
                    {
                        foreach (DataRow item in groutingDailyData.Rows)
                        {
                            if (strNoLineCodes != null)
                            {
                                strNoLineCodes += "," + item["GroutingLineCode"];
                            }
                            else
                            {
                                strNoLineCodes += item["GroutingLineCode"];
                            }
                        }
                    }
                    if (strNoLineCodes != null)
                    {
                        sre.Status = Constant.ServiceResultStatus.Other;
                        sre.OtherStatus = 2;
                        sre.Message = groutingDate.Value.ToString(Constant.S_DATE_YYYY_MM_DD)
                            + "，以下成型线已做过注浆登记。"
                            + System.Environment.NewLine + strNoLineCodes;
                        return sre;
                    }
                    */

					#endregion 成型线校验

					string strNoUserCodes = null;

					#region 校验成型工号是否有效
					// 校验成型工号是否有效
					string checkUserSql =
						"SELECT UserID" +
						"  FROM TP_MST_User" +
						" WHERE AccountID = :AccountID" +
						"   AND ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
						"   AND INSTR(:UserIDs, ',' || UserID || ',') > 0";
					string strUserIDs = "," + string.Join(",", userIDs) + ",";
					OracleParameter[] checkUserParas = new OracleParameter[]
					{
						new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input),
						new OracleParameter(":UserIDs", OracleDbType.Varchar2, strUserIDs, ParameterDirection.Input),
					};
					DataTable userData = tran.GetSqlResultToDt(checkUserSql, checkUserParas);
					strNoUserCodes = null;
					if (userData == null || userData.Rows.Count == 0)
					{
						strNoUserCodes = string.Join(",", userCodes);
					}
					else if (userIDs.Count != userData.Rows.Count)
					{
						for (int i = 0; i < userIDs.Count; i++)
						{
							DataRow[] drs = userData.Select("UserID = " + userIDs[i]);
							if (drs == null || drs.Length == 0)
							{
								if (strNoUserCodes != null)
								{
									strNoUserCodes += "," + userCodes[i];
								}
								else
								{
									strNoUserCodes += userCodes[i];
								}
							}
						}
					}
					if (strNoUserCodes != null)
					{
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = 3;
						sre.Message = "以下成型工号已被停用，不能注浆。"
							+ System.Environment.NewLine + strNoUserCodes;
						return sre;
					}
					#endregion 校验成型工号是否有效

					#region 校验成型工是否有班次配置
					// 校验成型工是否有班次配置
					string checkClassesSettingSql =
						"SELECT UserID, Max(ClassesSettingID) as ClassesSettingID" +
						"  FROM TP_PC_ClassesSetting CS " +
						" WHERE CS.AccountID = :AccountID" +
						"   AND CS.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
						"   AND CS.AccountDate = :AccountDate" +
						"   AND INSTR(:UserIDs, ',' || CS.UserID || ',') > 0 group by UserID";
					OracleParameter[] checkClassesSettingParas = new OracleParameter[]
					{
						new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input),
						new OracleParameter(":AccountDate", OracleDbType.Date, groutingDate.Value, ParameterDirection.Input),
						new OracleParameter(":UserIDs", OracleDbType.Varchar2, strUserIDs, ParameterDirection.Input),
					};
					DataTable classesSettingData = tran.GetSqlResultToDt(checkClassesSettingSql, checkClassesSettingParas);

					Dictionary<string, string> userClassID = new Dictionary<string, string>();
					// 补注浆日报
					if (groutingDate.Value < accountDate)
					{
						#region 补注浆日报，校验班次配置
						strNoUserCodes = null;
						if (classesSettingData == null || classesSettingData.Rows.Count == 0)
						{
							strNoUserCodes = string.Join(",", userCodes);
						}
						else if (userIDs.Count != classesSettingData.Rows.Count)
						{
							for (int i = 0; i < userIDs.Count; i++)
							{
								DataRow[] drs = classesSettingData.Select("UserID = " + userIDs[i]);
								if (drs == null || drs.Length == 0)
								{
									if (strNoUserCodes != null)
									{
										strNoUserCodes += "," + userCodes[i];
									}
									else
									{
										strNoUserCodes += userCodes[i];
									}
								}
							}
						}
						else
						{
							foreach (DataRow item in classesSettingData.Rows)
							{
								userClassID.Add(item["UserID"].ToString(), item["ClassesSettingID"].ToString());
							}
						}
						if (strNoUserCodes != null)
						{
							sre.Status = Constant.ServiceResultStatus.Other;
							sre.OtherStatus = 4;
							sre.Message = string.Format("以下成型工号在日期【{0}】没有配置班次，请确认后再注浆。", groutingDate.Value.ToString(Constant.S_DATE_YYYY_MM_DD))
								+ System.Environment.NewLine + strNoUserCodes;
							return sre;
						}
						#endregion 补注浆日报，校验班次配置
					}
					else
					{
						// 无班次配置的成型工ID
						List<string> userStaffIDs = new List<string>();
						List<string> userStaffCodes = new List<string>();
						strUserIDs = null;
						if (classesSettingData != null && userIDs.Count != classesSettingData.Rows.Count)
						{
							//strUserIDs = null;
							for (int i = 0; i < userIDs.Count; i++)
							{
								DataRow[] drs = classesSettingData.Select("UserID = " + userIDs[i]);
								if (drs == null || drs.Length == 0)
								{
									strUserIDs += "," + userIDs[i];
									userStaffIDs.Add(userIDs[i]);
									userStaffCodes.Add(userCodes[i]);
								}
								else
								{
									userClassID.Add(drs[0]["UserID"].ToString(), drs[0]["ClassesSettingID"].ToString());
								}
							}
							if (strUserIDs != null)
							{
								strUserIDs += ",";
							}
						}

						if (strUserIDs != null)
						{
							#region 无班次配置的工号，校验员工关联（成型工号是否有员工）
							// 无班次配置的工号，校验员工关联（成型工号是否有员工）
							string checkUserStaffSql =
								"SELECT DISTINCT U.UserID, U.UserCode, U.OrganizationID" +
								"  FROM TP_MST_User U " +
								" INNER JOIN TP_MST_UserStaff US" +
								"    ON U.UserID = US.UserID " +
								" WHERE U.AccountID = :AccountID" +
								"   AND INSTR(:UserIDs, ',' || U.UserID || ',') > 0";
							OracleParameter[] checkUserStaffParas = new OracleParameter[]
							{
								new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input),
								new OracleParameter(":UserIDs", OracleDbType.Varchar2, strUserIDs, ParameterDirection.Input),
							};
							DataTable userStaffData = tran.GetSqlResultToDt(checkUserStaffSql, checkUserStaffParas);
							strNoUserCodes = null;
							if (userStaffData == null || userStaffData.Rows.Count == 0)
							{
								strNoUserCodes = string.Join(",", userStaffCodes);
							}
							else
							{
								//for (int i = 0; i < userIDs.Count; i++)
								for (int i = 0; i < userStaffIDs.Count; i++)
								{
									DataRow[] drs = userStaffData.Select("UserID = " + userStaffIDs[i]);
									if (drs == null || drs.Length == 0)
									{
										if (strNoUserCodes != null)
										{
											strNoUserCodes += "," + userStaffCodes[i];
										}
										else
										{
											strNoUserCodes += userStaffCodes[i];
										}
									}
								}
							}
							if (strNoUserCodes != null)
							{
								sre.Status = Constant.ServiceResultStatus.Other;
								sre.OtherStatus = 5;
								sre.Message = "以下成型工号没有配置员工关联，请确认后再注浆。"
									+ System.Environment.NewLine + strNoUserCodes;
								return sre;
							}
							#endregion 无班次配置的工号，校验员工关联（成型工号是否有员工）

							#region 插入班次配置
							#region SQL
							string seqClassesSettingSql = "SELECT SEQ_PC_ClassesSetting_ID.Nextval FROM DUAL";
							string insertClassesSettingSql =
								"INSERT INTO TP_PC_ClassesSetting" +
								"     (ClassesSettingID, AccountDate, UserID, UserCode, OrganizationID, AccountID, CreateUserID, UpdateUserID)" +
								"   VALUES" +
								"     (:ClassesSettingID, :AccountDate, :UserID, :UserCode, :OrganizationID, :AccountID, :CUserID, :CUserID)";
							string insertClassesDetailSql =
								"INSERT INTO TP_PC_ClassesDetail" +
								"  (ClassesSettingID, AccountDate, UserID, UserCode, UOrganizationID, UJobsID, StaffID, SOrganizationID, SJobsID, StaffStatus, AccountID, CreateUserID, UpdateUserID)" +
								"  SELECT :ClassesSettingID, :AccountDate, :UserID, :UserCode, :UOrganizationID, US.UJobsID, S.StaffID, S.OrganizationID, S.Jobs, S.StaffStatus, :AccountID, :CUserID, :CUserID" +
								"    FROM TP_MST_UserStaff US" +
								"   INNER JOIN TP_HR_Staff S" +
								"      ON S.StaffID = US.StaffID" +
								"   WHERE US.UserID = :UserID";
							#endregion SQL
							// 插入班次配置
							foreach (DataRow userStaffRow in userStaffData.Rows)
							{
								object csSeq = tran.GetSqlResultToObj(seqClassesSettingSql);
								// 插入班次配置
								OracleParameter[] insertClassesSettingParas = new OracleParameter[]
								{
									new OracleParameter(":ClassesSettingID", OracleDbType.Int32, csSeq, ParameterDirection.Input),
									new OracleParameter(":AccountDate", OracleDbType.Date, accountDate, ParameterDirection.Input),
									new OracleParameter(":UserID", OracleDbType.Int32, userStaffRow["UserID"], ParameterDirection.Input),
									new OracleParameter(":UserCode", OracleDbType.NVarchar2, userStaffRow["UserCode"], ParameterDirection.Input),
									new OracleParameter(":OrganizationID", OracleDbType.Int32, userStaffRow["OrganizationID"], ParameterDirection.Input),
									new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input),
									new OracleParameter(":CUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
								};
								executeResult = tran.ExecuteNonQuery(insertClassesSettingSql, insertClassesSettingParas);
								if (executeResult <= 0)
								{
									sre.Status = Constant.ServiceResultStatus.NoModifyData;
									return sre;
								}
								// 插入班次配置明细
								OracleParameter[] insertClassesDetailParas = new OracleParameter[]
								{
									new OracleParameter(":ClassesSettingID", OracleDbType.Int32, csSeq, ParameterDirection.Input),
									new OracleParameter(":AccountDate", OracleDbType.Date, accountDate, ParameterDirection.Input),
									new OracleParameter(":UserID", OracleDbType.Int32, userStaffRow["UserID"], ParameterDirection.Input),
									new OracleParameter(":UserCode", OracleDbType.NVarchar2, userStaffRow["UserCode"], ParameterDirection.Input),
									new OracleParameter(":UOrganizationID", OracleDbType.Int32, userStaffRow["OrganizationID"], ParameterDirection.Input),
									new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input),
									new OracleParameter(":CUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
								};
								executeResult = tran.ExecuteNonQuery(insertClassesDetailSql, insertClassesDetailParas);
								if (executeResult <= 0)
								{
									sre.Status = Constant.ServiceResultStatus.NoModifyData;
									return sre;
								}

								userClassID.Add(userStaffRow["UserID"].ToString(), csSeq.ToString());
							}
							#endregion 插入班次配置
						}
						else
						{
							foreach (DataRow item in classesSettingData.Rows)
							{
								userClassID.Add(item["UserID"].ToString(), item["ClassesSettingID"].ToString());
							}
						}
					}
					#endregion 校验成型工是否有班次配置

					#endregion 数据校验

					#region 取得默认商标
					string logoSql = "select t.LogoID from TP_MST_Logo t where t.AccountID = :AccountID and t.ValueFlag ='1'" +
						" order by t.IsDefault desc, t.DISPLAYNO";
					OracleParameter[] logoParas = new OracleParameter[]
					{
						new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input)
					};
					DataTable logoDataTable = tran.GetSqlResultToDt(logoSql, logoParas);
					object logoID = null;
					if (logoDataTable != null && logoDataTable.Rows.Count > 0)
					{
						logoID = logoDataTable.Rows[0]["LogoID"];
					}
					#endregion 取得默认商标

					// 插入注浆日报
					#region SQL
					string seqGroutingDailySql = "SELECT SEQ_PM_GroutingDaily_ID.Nextval FROM DUAL";
					string insertGroutingDailySql =
						"INSERT INTO TP_PM_GroutingDaily " +
						"  (GroutingDailyID, " +
						"   GroutingLineID, " +
						"   GroutingLineCode, " +
						"   GroutingLineName, " +
						"   GroutingDate, " +
						"   UserID, " +
						"   UserCode, " +
						"   monitorid, " +
						"   monitorcode, " +
						"   MouldQuantity, " +
						"   GMouldTypeID, " +
						"   GMouldStatus, " +
						"   CanManyTimes, " +
						"   HighPressureFlag, " + //xuwei add 2019-11-14 高压注浆标识
						"   AccountID, " +
						"   ClassesSettingID, " +
						"   GroutingBatchNo, " +
						"   CreateUserID, " +
						"   UpdateUserID) " +
						"  SELECT :GroutingDailyID, " +
						"         :GroutingLineID, " +
						"         GL.GroutingLineCode, " +
						"         GL.GroutingLineName, " +
						"         :GroutingDate, " +
						"         :UserID, " +
						"         :UserCode, " +
						"         :monitorid, " +
						"         :monitorcode, " +
						"         GL.MouldQuantity, " +
						"         GL.GMouldTypeID, " +
						"         GL.GMouldStatus, " +
						"         :CanManyTimes, " +
						"         GL.HighPressureFlag, " + //xuwei add 2019-11-14 高压注浆标识
						"         :AccountID, " +
						"         :ClassesSettingID, " +
						"         :GroutingBatchNo, " +
						"         :CUserID, " +
						"         :CUserID " +
						"    FROM TP_PC_GroutingLine GL " +
						"   INNER JOIN TP_MST_GMouldType GMT " +
						"      ON GMT.GMouldTypeID = GL.GMouldTypeID " +
						"   WHERE GL.GroutingLineID = :GroutingLineID";
					#endregion SQL
					#region DetailSQL
					string insertGroutingDailyDetailSql =
						"INSERT INTO TP_PM_GroutingDailyDetail " +
						"  (GroutingDailyID, " +
						"   GroutingLineID, " +
						"   GroutingLineCode, " +
						"   GroutingLineName, " +
						"   GroutingLineDetailID, " +
						"   GroutingDate, " +
						"   GroutingMouldCode, " +
						"   MouldID, " +
						"   MouldCode, " +
						"   UserID, " +
						"   UserCode, " +
						//"   monitorid, " +
						//"   monitorcode, " +
						"   GoodsID, " +
						"   GoodsCode, " +
						"   GoodsName, " +
						"   GMouldStatus, " +
						"   GroutingCount, " +
						"   GroutingFlag, " +
						//"   BarCode, " +
						"   NoGroutingRreason, " +
						"   ScrapFlag, " +
						"   Remarks, " +
						"   AccountID, " +
						"   ClassesSettingID, " +
						"   GroutingBatchNo, " +
						"   LogoID, " +
						"   glazetypeid, " +
						"   CreateUserID, " +
						"   GMouldTypeID, " +
						"   CanManyTimes, " +
						"   UpdateUserID) " +
						"  SELECT :GroutingDailyID, " +
						"         :GroutingLineID, " +
						"         GL.GroutingLineCode, " +
						"         GL.GroutingLineName, " +
						"         :GroutingLineDetailID, " +
						"         :GroutingDate, " +
						"         GLD.GroutingMouldCode, " +
						"         GLD.MouldID, " +
						"         GLD.MouldCode, " +
						"         :UserID, " +
						"         :UserCode, " +
						//"   :monitorid, " +
						//"   :monitorcode, " +
						"         GLD.GoodsID, " +
						"         G.GoodsCode, " +
						"         G.GoodsName, " +
						"         GLD.GMouldStatus, " +
						"         CASE WHEN :GroutingFlag = '" + (int)Constant.GroutingFlag.Yes + "'" +
						"              THEN GLD.GroutingCount + 1 " +
						"              ELSE GLD.GroutingCount END," +
						"         :GroutingFlag, " +
						"         :NoGroutingRreason, " +
						"         :ScrapFlag, " +
						"         :Remarks, " +
						"         :AccountID, " +
						//"   (select max(ClassesSettingID) from TP_PC_ClassesSetting where AccountDate=:GroutingDate and UserID = :UserID ), " +
						"         :ClassesSettingID, " +
						"         :GroutingBatchNo, " +
						"         :LogoID, " +
						"         g.glazetypeid, " +
						"         :CUserID, " +
						"         :GMouldTypeID, " +
						"         :CanManyTimes, " +
						"         :CUserID " +
						"    FROM TP_PC_GroutingLine GL " +
						"   INNER JOIN TP_PC_GroutingLineDetail GLD " +
						"      ON GL.GroutingLineID = :GroutingLineID " +
						"     AND GLD.GroutingLineID = :GroutingLineID " +
						"     AND GLD.GroutingLineDetailID = :GroutingLineDetailID " +
						"   INNER JOIN TP_MST_Goods G " +
						"      ON G.GoodsID = GLD.GoodsID";
					#endregion DetailSQL
					#region LineDetailSQL
					string updateGroutingLineDetailSql =
						"UPDATE TP_PC_GroutingLineDetail" +
						"   SET GroutingCount = GroutingCount + 1," +
						"       UpdateUserID = :UpdateUserID" +
						" WHERE GroutingLineDetailID = :GroutingLineDetailID";
					#endregion LineDetailSQL
					#region LineSQL
					string updateGroutingLineSql =
						"UPDATE TP_PC_GroutingLine" +
						"   SET LastGroutingDate = :LastGroutingDate," +
						"       LastGroutingBatchNo = :LastGroutingBatchNo," +
						"       UpdateUserID = :UpdateUserID" +
						" WHERE GroutingLineID = :GroutingLineID";
					#endregion LineSQL
					#region ProducerSQL
					//string insertGroutingProducerSql =
					//    "INSERT INTO TP_PM_GroutingProducer " +
					//    "  (GroutingDailyID, " +
					//    "   StaffID, " +
					//    "   StaffCode, " +
					//    "   StaffStatus, " +
					//    "   UserID, " +
					//    "   UserCode, " +
					//    "   UJobsID, " +
					//    "   SJobsID, " +
					//    "   ClassesSettingID) " +
					//    //"   AccountID, " +
					//    //"   CreateUserID, " +
					//    //"   UpdateUserID) " +
					//    "  SELECT :GroutingDailyID, " +
					//    "         CD.StaffID, " +
					//    "         HS.StaffCode, " +
					//    "         CD.StaffStatus, " +
					//    "         :UserID, " +
					//    "         CD.UserCode, " +
					//    "         CD.UJobsID, " +
					//    "         CD.SJobsID, " +
					//    "         CD.ClassesSettingID " +
					//    //"         :AccountID, " +
					//    //"         :CUserID, " +
					//    //"         :CUserID " +
					//    "    FROM TP_PC_ClassesDetail CD " +
					//    "   INNER JOIN TP_HR_Staff HS" +
					//    "      ON HS.StaffID = CD.StaffID" +
					//    "   WHERE CD.ClassesSettingID = " +
					//    "         (SELECT MAX(ClassesSettingID) " +
					//    "            FROM TP_PC_ClassesSetting " +
					//    "           WHERE UserID = :UserID " +
					//    "             AND AccountDate = :GroutingDate)";
					#endregion ProducerSQL

					string groutingDailyIDs = null;
					foreach (DataRow lineRow in dtGroutingLine.Rows)
					{
						#region 插入注浆日报
						// 插入注浆日报
						object gdSeq = tran.GetSqlResultToObj(seqGroutingDailySql);

						if (groutingDailyIDs == null)
						{
							groutingDailyIDs = gdSeq.ToString();
						}
						else
						{
							groutingDailyIDs += "," + gdSeq.ToString();
						}
						//int? ClassesSettingID = null;
						//ClassesSettingID = getClassesSettingID(tran, Convert.ToInt32(lineRow["UserID"]), groutingDate.Value);
						int ClassesSettingID = Convert.ToInt32(userClassID[lineRow["UserID"].ToString()]);

						OracleParameter[] insertGroutingDailyParas = new OracleParameter[]
						{
							new OracleParameter(":ClassesSettingID", OracleDbType.Int32, ClassesSettingID, ParameterDirection.Input),
							new OracleParameter(":GroutingBatchNo", OracleDbType.Int32, lineRow["GroutingBatchNo"], ParameterDirection.Input),
							new OracleParameter(":CanManyTimes", OracleDbType.Char, lineRow["CanManyTimes"], ParameterDirection.Input),
							new OracleParameter(":GroutingDailyID", OracleDbType.Int32, gdSeq, ParameterDirection.Input),
							new OracleParameter(":GroutingLineID", OracleDbType.Int32, lineRow["GroutingLineID"], ParameterDirection.Input),
							new OracleParameter(":GroutingDate", OracleDbType.Date, groutingDate.Value, ParameterDirection.Input),
							new OracleParameter(":UserID", OracleDbType.Int32, lineRow["UserID"], ParameterDirection.Input),
							new OracleParameter(":UserCode", OracleDbType.NVarchar2, lineRow["UserCode"], ParameterDirection.Input),
							new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input),
							new OracleParameter(":CUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
							new OracleParameter(":monitorid", OracleDbType.Int32, lineRow["monitorid"], ParameterDirection.Input),
							new OracleParameter(":monitorcode", OracleDbType.NVarchar2, lineRow["monitorcode"], ParameterDirection.Input),
						};
						executeResult = tran.ExecuteNonQuery(insertGroutingDailySql, insertGroutingDailyParas);
						if (executeResult <= 0)
						{
							sre.Status = Constant.ServiceResultStatus.NoModifyData;
							return sre;
						}
						#endregion 插入注浆日报

						#region 更新成型线注浆日期
						OracleParameter[] updateGroutingLineParas = new OracleParameter[]
						{
							new OracleParameter(":LastGroutingDate", OracleDbType.Date, groutingDate.Value, ParameterDirection.Input),
							new OracleParameter(":LastGroutingBatchNo", OracleDbType.Int32, lineRow["GroutingBatchNo"], ParameterDirection.Input),
							new OracleParameter(":UpdateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
							new OracleParameter(":GroutingLineID", OracleDbType.Int32, lineRow["GroutingLineID"], ParameterDirection.Input),
						};
						executeResult = tran.ExecuteNonQuery(updateGroutingLineSql, updateGroutingLineParas);
						if (executeResult <= 0)
						{
							sre.Status = Constant.ServiceResultStatus.NoModifyData;
							return sre;
						}
						#endregion 更新成型线注浆日期

						// 插入注浆日报明细
						DataRow[] groutingLineDetailRows = dtGroutingDetail.Select("GroutingLineID = " + lineRow["GroutingLineID"].ToString()
							+ " and GroutingBatchNo = " + lineRow["GroutingBatchNo"].ToString());
						foreach (DataRow detailDataRow in groutingLineDetailRows)
						{
							object drLogoID = detailDataRow["logoID"];
							if (drLogoID == null || drLogoID == DBNull.Value)
							{
								drLogoID = logoID;
							}

							#region 插入注浆日报明细
							OracleParameter[] insertGroutingDailyDetailParas = new OracleParameter[]
							{
								new OracleParameter(":ClassesSettingID", OracleDbType.Int32, ClassesSettingID, ParameterDirection.Input),
								new OracleParameter(":GroutingBatchNo", OracleDbType.Int32, detailDataRow["GroutingBatchNo"], ParameterDirection.Input),
								//new OracleParameter(":LogoID", OracleDbType.Int32, logoID, ParameterDirection.Input),
                                new OracleParameter(":LogoID", OracleDbType.Int32,  drLogoID, ParameterDirection.Input),
								new OracleParameter(":GroutingDailyID", OracleDbType.Int32, gdSeq, ParameterDirection.Input),
								new OracleParameter(":GroutingLineID", OracleDbType.Int32, detailDataRow["GroutingLineID"], ParameterDirection.Input),
								new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32, detailDataRow["GroutingLineDetailID"], ParameterDirection.Input),
								new OracleParameter(":GroutingDate", OracleDbType.Date, groutingDate.Value, ParameterDirection.Input),
								new OracleParameter(":UserID", OracleDbType.Int32, detailDataRow["GroutingUserID"], ParameterDirection.Input),
								new OracleParameter(":UserCode", OracleDbType.NVarchar2, detailDataRow["GroutingUserCode"], ParameterDirection.Input),
                                //new OracleParameter(":monitorid", OracleDbType.Int32, detailDataRow["monitorid"], ParameterDirection.Input),
                                //new OracleParameter(":monitorcode", OracleDbType.NVarchar2, detailDataRow["monitorcode"], ParameterDirection.Input),
                                new OracleParameter(":GroutingFlag", OracleDbType.Char, detailDataRow["GroutingFlag"], ParameterDirection.Input),
								new OracleParameter(":NoGroutingRreason", OracleDbType.Int32, detailDataRow["NoGroutingRreason"], ParameterDirection.Input),
								new OracleParameter(":ScrapFlag", OracleDbType.Char, (int)Constant.GroutingScrapFlag.No, ParameterDirection.Input),
								new OracleParameter(":Remarks", OracleDbType.NVarchar2, detailDataRow["Remarks"], ParameterDirection.Input),
								new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input),
								new OracleParameter(":CUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
								new OracleParameter(":GMouldTypeID", OracleDbType.Int32, detailDataRow["GMouldTypeID"], ParameterDirection.Input),
								new OracleParameter(":CanManyTimes", OracleDbType.Char, lineRow["CanManyTimes"], ParameterDirection.Input),
							};
							executeResult = tran.ExecuteNonQuery(insertGroutingDailyDetailSql, insertGroutingDailyDetailParas);
							if (executeResult <= 0)
							{
								sre.Status = Constant.ServiceResultStatus.NoModifyData;
								return sre;
							}
							#endregion 插入注浆日报明细

							#region 更新成型线明细注浆次数
							if (((int)Constant.GroutingFlag.Yes).ToString() == detailDataRow["GroutingFlag"].ToString())
							{
								OracleParameter[] updateGroutingLineDetailParas = new OracleParameter[]
								{
									new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32, detailDataRow["GroutingLineDetailID"], ParameterDirection.Input),
									new OracleParameter(":UpdateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
								};
								executeResult = tran.ExecuteNonQuery(updateGroutingLineDetailSql, updateGroutingLineDetailParas);
								if (executeResult <= 0)
								{
									sre.Status = Constant.ServiceResultStatus.NoModifyData;
									return sre;
								}
							}
							#endregion 更新成型线明细注浆次数
						}

						#region 插入注浆者
						//// 插入注浆者
						//OracleParameter[] InsertGroutingProducerParas = new OracleParameter[]
						//{
						//    new OracleParameter(":GroutingDailyID", OracleDbType.Int32, gdSeq, ParameterDirection.Input),
						//    new OracleParameter(":UserID", OracleDbType.Int32, lineRow["UserID"], ParameterDirection.Input),
						//    //new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input),
						//    //new OracleParameter(":CUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
						//    new OracleParameter(":GroutingDate", OracleDbType.Date, groutingDate.Value, ParameterDirection.Input),
						//};
						//executeResult = tran.ExecuteNonQuery(insertGroutingProducerSql, InsertGroutingProducerParas);
						//if (executeResult <= 0)
						//{
						//    sre.Status = Constant.ServiceResultStatus.NoModifyData;
						//    return sre;
						//}
						#endregion 插入注浆者
					}

					// TODO 补录注浆日报时，是否更新大于注浆日期的注浆日报明细和生产数据中的注浆次数？

					sre.Result = groutingDailyIDs;
					#endregion 新建注浆登记
				}
				// 编辑注浆日报
				else
				{
					#region 编辑注浆日报

					#region 校验时间戳
					// 校验时间戳
					DataRow gdDataRow = dtGroutingLine.Rows[0];
					string checkSql = "SELECT GroutingDailyID" +
									"  FROM TP_PM_GroutingDaily" +
									" WHERE GroutingDailyID = :GroutingDailyID" +
									"   AND OPTimeStamp = :OPTimeStamp" +
									"   AND ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'";
					OracleParameter[] checkParas = new OracleParameter[]
					{
						new OracleParameter(":GroutingDailyID", OracleDbType.Int32, gdDataRow["GroutingDailyID"], ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp", OracleDbType.TimeStamp, gdDataRow["OPTimeStamp"], ParameterDirection.Input),
					};
					object checkResult = tran.GetSqlResultToObj(checkSql, checkParas);
					if (checkResult == null)
					{
						sre.Status = Constant.ServiceResultStatus.DataChanged;
						return sre;
					}
					#endregion 校验时间戳

					// 更新注浆日报表
					string upgdSql = "UPDATE TP_PM_GroutingDaily SET UpdateUserID = :UpdateUserID WHERE GroutingDailyID = :GroutingDailyID";
					OracleParameter[] upgdParas = new OracleParameter[]
					{
						new OracleParameter(":GroutingDailyID", OracleDbType.Int32, gdDataRow["GroutingDailyID"], ParameterDirection.Input),
						new OracleParameter(":UpdateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
					};
					executeResult = tran.ExecuteNonQuery(upgdSql, upgdParas);
					if (executeResult <= 0)
					{
						sre.Status = Constant.ServiceResultStatus.NoModifyData;
						return sre;
					}

					#region SQL
					string updateGroutingDailyDetailSql =
						"UPDATE TP_PM_GroutingDailyDetail" +
						"   SET GroutingCount = CASE" +
						"                       WHEN GroutingFlag <> :GroutingFlag AND GroutingFlag = '" + (int)Constant.GroutingFlag.Yes + "'" +
						"                       THEN GroutingCount - 1" +
						"                       WHEN GroutingFlag <> :GroutingFlag AND GroutingFlag = '" + (int)Constant.GroutingFlag.No + "'" +
						"                       THEN GroutingCount + 1" +
						"                       ELSE GroutingCount END," +
						"       GroutingFlag = :GroutingFlag," +
						"       NoGroutingRreason = :NoGroutingRreason," +
						"       Remarks = :Remarks," +
						"       LogoID = :LogoID," +
						"       UpdateUserID = :UpdateUserID" +
						" WHERE GroutingDailyDetailID = :GroutingDailyDetailID";

					string updateGroutingDailyDetailLogoSql =
						"UPDATE TP_PM_GroutingDailyDetail" +
						"   SET Remarks = :Remarks," +
						"       LogoID = :LogoID," +
						"       UpdateUserID = :UpdateUserID" +
						" WHERE GroutingDailyDetailID = :GroutingDailyDetailID";

					string updateGroutingDailyDetailRemarksSql =
						"UPDATE TP_PM_GroutingDailyDetail" +
						"   SET Remarks = :Remarks," +
						"       UpdateUserID = :UpdateUserID" +
						" WHERE GroutingDailyDetailID = :GroutingDailyDetailID";

					string updateGroutingLineDetailSql =
						"UPDATE TP_PC_GroutingLineDetail" +
						"   SET GroutingCount = CASE" +
						"                       WHEN :cGroutingFlag = '" + (int)Constant.GroutingFlag.Yes + "'" +
						"                       THEN GroutingCount + 1" +
						"                       WHEN :cGroutingFlag = '" + (int)Constant.GroutingFlag.No + "'" +
						"                       THEN GroutingCount - 1" +
						"                       ELSE GroutingCount END," +
						"       UpdateUserID = :UpdateUserID" +
						" WHERE GroutingLineDetailID = :GroutingLineDetailID /*AND :oGroutingFlag <> :cGroutingFlag*/";
					#endregion SQL
					// 更新注浆日报明细表
					foreach (DataRow detailDataRow in dtGroutingDetail.Rows)
					{
						if (detailDataRow.RowState != DataRowState.Modified)
						{
							continue;
						}

						// 已交坯，不能修改注浆信息
						if ("1" == detailDataRow["DeliverFlag"].ToString())
						{
							OracleParameter[] updateGroutingDailyDetailRemarksParas = new OracleParameter[]
							{
								new OracleParameter(":GroutingDailyDetailID", OracleDbType.Int32, detailDataRow["GroutingDailyDetailID"], ParameterDirection.Input),
								new OracleParameter(":Remarks", OracleDbType.NVarchar2, detailDataRow["Remarks"], ParameterDirection.Input),
								new OracleParameter(":UpdateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
							};
							executeResult = tran.ExecuteNonQuery(updateGroutingDailyDetailRemarksSql, updateGroutingDailyDetailRemarksParas);
							if (executeResult <= 0)
							{
								sre.Status = Constant.ServiceResultStatus.NoModifyData;
								return sre;
							}
							continue;
						}

						// 已绑定条码、损坯，不能修改注浆信息，可以修改商标
						if ((detailDataRow["BarCode"] != DBNull.Value && !string.IsNullOrWhiteSpace(detailDataRow["BarCode"].ToString())) ||
							((int)Constant.GroutingScrapFlag.Yes).ToString() == detailDataRow["ScrapFlag"].ToString())
						{
							OracleParameter[] updateGroutingDailyDetailLogoParas = new OracleParameter[]
							{
								new OracleParameter(":LogoID", OracleDbType.Int32, detailDataRow["LogoID"], ParameterDirection.Input),
								new OracleParameter(":GroutingDailyDetailID", OracleDbType.Int32, detailDataRow["GroutingDailyDetailID"], ParameterDirection.Input),
								new OracleParameter(":Remarks", OracleDbType.NVarchar2, detailDataRow["Remarks"], ParameterDirection.Input),
								new OracleParameter(":UpdateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
							};
							executeResult = tran.ExecuteNonQuery(updateGroutingDailyDetailLogoSql, updateGroutingDailyDetailLogoParas);
							if (executeResult <= 0)
							{
								sre.Status = Constant.ServiceResultStatus.NoModifyData;
								return sre;
							}
							continue;
						}

						OracleParameter[] updateGroutingDailyDetailParas = new OracleParameter[]
						{
							new OracleParameter(":LogoID", OracleDbType.Int32, detailDataRow["LogoID"], ParameterDirection.Input),
							new OracleParameter(":GroutingDailyDetailID", OracleDbType.Int32, detailDataRow["GroutingDailyDetailID"], ParameterDirection.Input),
							new OracleParameter(":GroutingFlag", OracleDbType.Char, detailDataRow["GroutingFlag"], ParameterDirection.Input),
							new OracleParameter(":NoGroutingRreason", OracleDbType.Int32, detailDataRow["NoGroutingRreason"], ParameterDirection.Input),
							new OracleParameter(":Remarks", OracleDbType.NVarchar2, detailDataRow["Remarks"], ParameterDirection.Input),
							new OracleParameter(":UpdateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
						};
						executeResult = tran.ExecuteNonQuery(updateGroutingDailyDetailSql, updateGroutingDailyDetailParas);
						if (executeResult <= 0)
						{
							sre.Status = Constant.ServiceResultStatus.NoModifyData;
							return sre;
						}

						// 更新成型线明细的注浆次数
						string oGroutingFlag = detailDataRow["GroutingFlag", DataRowVersion.Original].ToString();
						string cGroutingFlag = detailDataRow["GroutingFlag", DataRowVersion.Current].ToString();
						if (oGroutingFlag != cGroutingFlag)
						{
							OracleParameter[] updateGroutingLineDetailParas = new OracleParameter[]
							{
								new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32, detailDataRow["GroutingLineDetailID"], ParameterDirection.Input),
								new OracleParameter(":cGroutingFlag", OracleDbType.Char, cGroutingFlag, ParameterDirection.Input),
								new OracleParameter(":UpdateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
							};
							executeResult = tran.ExecuteNonQuery(updateGroutingLineDetailSql, updateGroutingLineDetailParas);
							if (executeResult <= 0)
							{
								sre.Status = Constant.ServiceResultStatus.NoModifyData;
								return sre;
							}
						}

						// TODO 修改以前记录时，是否更新大于注浆日期的注浆日报明细和生产数据中的注浆次数？
					}
					#endregion 编辑注浆日报
				}

				tran.Commit();
				return sre;
			}
			catch (Exception ex)
			{
				if (tran != null &&
					tran.ConnState == ConnectionState.Open)
				{
					tran.Rollback();
				}
				throw ex;
			}
			finally
			{
				if (tran != null &&
					tran.ConnState == ConnectionState.Open)
				{
					tran.Disconnect();
				}
			}
		}

		#endregion 注浆登记

		#region 条码绑定

		/// <summary>
		/// 取得FPM0105画面（选择能绑定条码的注浆登记）的查询数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetFPM0105SData(SUserInfo user, FPM0104_SE se)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				ServiceResultEntity sre = new ServiceResultEntity();

				// 'S_PM_023', '注浆绑码限制天数' add by chenxy 2019-05-07 begin
				string spm023 = conn.GetSqlResultToStr("select ss.SETTINGVALUE from tp_mst_systemsetting ss where ss.SETTINGCODE = 'S_PM_023' and ss.AccountID = " + user.AccountID);
				int spm023Value = 0;
				if (!string.IsNullOrWhiteSpace(spm023) && int.TryParse(spm023, out spm023Value) && spm023Value > 0)
				{
					DateTime tDate = DateTime.Now.Date;
					DateTime lastDate = tDate.AddDays(1 - spm023Value);
					if (se.GroutingDate < lastDate || se.GroutingDate > tDate)
					{
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = -1;
						sre.Message = string.Format("允许注浆绑码的日期范围【{0:yyyy-MM-dd}】-【{1:yyyy-MM-dd}】", lastDate, tDate);
						return sre;
					}
				}
				// 'S_PM_023', '注浆绑码限制天数' add by chenxy 2019-05-07 end

				string sqlString =
					"SELECT " +
					"       GD.GroutingDailyID," +
					"       GD.GroutingLineCode," +
					"       GD.GroutingLineName," +
					"       GMS.GMouldStatusName," +
					"       GMT.GMouldTypeName," +
					"       GD.MouldQuantity," +
					"       GD.GroutingBatchNo," +
					"       GD.UserCode AS GroutingUserCode," +
					"       WMSYS.WM_CONCAT(DISTINCT TO_CHAR(GDD.GoodsCode)) AS GoodsCode" +
					"  FROM TP_PM_GroutingDaily GD" +
					" INNER JOIN TP_PM_GroutingDailyDetail GDD" +
					"    ON GDD.GroutingDailyID = GD.GroutingDailyID" +
					" INNER JOIN TP_SYS_GMouldStatus GMS" +
					"    ON GMS.GMouldStatusID = GD.GMouldStatus" +
					" INNER JOIN TP_MST_GMouldType GMT" +
					"    ON GMT.GMouldTypeID = GD.GMouldTypeID" +
					" WHERE GD.AccountID = :AccountID" +
					"   AND GD.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
					// 成型线操作权限
					"   AND EXISTS (SELECT UP.PurviewID" +
					"                 FROM TP_MST_UserPurview UP" +
					"                WHERE UP.PurviewType = '" + (int)Constant.PurviewType.OperateGroutingLine + "'" +
					"                  AND (UP.PurviewID = -1 OR UP.PurviewID = GD.GroutingLineID)" +
					"                  AND UP.UserId = :UPUserId)" +
					// 注浆，未绑定条码
					"   AND GD.GroutingDate = :GroutingDate" +
					"   AND GDD.GroutingFlag = '" + (int)Constant.GroutingFlag.Yes + "'" +
					"   AND GDD.ScrapFlag = '" + (int)Constant.GroutingScrapFlag.No + "'";
				// 周兴 2018-4-2 增加
				if (!se.IsBarCodeScrapReasonUseFlag)
				{
					sqlString += "   AND (GDD.BARCODE IS NULL OR LENGTH(GDD.BARCODE) = 0)";
				}
				//"   AND (GDD.BARCODE IS NULL OR GDD.BARCODE = '')"
				sqlString += "   AND GDD.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'"
					;

				StringBuilder sql = new StringBuilder(sqlString);
				List<OracleParameter> parameters = new List<OracleParameter>();
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":UPUserId", OracleDbType.Int32, user.UserID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":GroutingDate", OracleDbType.Date, se.GroutingDate, ParameterDirection.Input));

				if (se != null)
				{
					// 成型线编码
					if (!string.IsNullOrEmpty(se.GroutingLineCode))
					{
						sql.Append(" AND INSTR(GD.GroutingLineCode, :GroutingLineCode) > 0");
						parameters.Add(new OracleParameter(":GroutingLineCode", OracleDbType.NVarchar2, se.GroutingLineCode, ParameterDirection.Input));
					}
					// 成型线名称
					if (!string.IsNullOrEmpty(se.GroutingLineName))
					{
						sql.Append(" AND INSTR(GD.GroutingLineName, :GroutingLineName) > 0");
						parameters.Add(new OracleParameter(":GroutingLineName", OracleDbType.NVarchar2, se.GroutingLineName, ParameterDirection.Input));
					}
					// 成型工号
					if (!string.IsNullOrEmpty(se.GroutingUserCode))
					{
						sql.Append(" AND INSTR(GDD.UserCode, :GroutingUserCode) > 0");
						parameters.Add(new OracleParameter(":GroutingUserCode", OracleDbType.NVarchar2, se.GroutingUserCode, ParameterDirection.Input));
					}
					// 注浆批次
					if (se.GroutingBatchNo.HasValue)
					{
						sql.Append(" AND GD.GroutingBatchNo = :GroutingBatchNo");
						parameters.Add(new OracleParameter(":GroutingBatchNo", OracleDbType.Int32, se.GroutingBatchNo, ParameterDirection.Input));
					}
					// 成型线类别
					if (se.GMouldTypeID.HasValue)
					{
						sql.Append(" AND GD.GMouldTypeID = :GMouldTypeID");
						parameters.Add(new OracleParameter(":GMouldTypeID", OracleDbType.Int32, se.GMouldTypeID.Value, ParameterDirection.Input));
					}
					// 备注
					if (!string.IsNullOrEmpty(se.Remarks))
					{
						sql.Append(" AND INSTR(GDD.Remarks, :Remarks) > 0");
						parameters.Add(new OracleParameter(":Remarks", OracleDbType.NVarchar2, se.Remarks, ParameterDirection.Input));
					}
				}

				sqlString = sql.ToString() +
					" GROUP BY " +
					"       GD.GroutingDailyID," +
					"       GD.GroutingLineCode," +
					"       GD.GroutingLineName," +
					"       GMS.GMouldStatusName," +
					"       GMT.GMouldTypeName," +
					"       GD.MouldQuantity," +
					"       GD.GroutingBatchNo," +
					"       GD.UserCode" +
					" ORDER BY GD.GroutingLineCode";

				DataTable data = conn.GetSqlResultToDt(sqlString, parameters.ToArray());

				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
					return sre;
				}
				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 取得FPM0103画面（绑定条码）的注浆数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="groutingDailyID">注浆日报ID</param>
		/// <returns>
		/// 注浆数据
		/// OtherStatus = 1:没有可编辑的注浆信息
		/// OtherStatus = 2:没有可编辑的注浆明细信息
		/// </returns>
		public static ServiceResultEntity GetFPM0103Data(SUserInfo user, int groutingDailyID)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			if (groutingDailyID < 1)
			{
				sre.Status = Constant.ServiceResultStatus.NoSearchResults;
				return sre;
			}

			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);

				StringBuilder sql = new StringBuilder();
				List<OracleParameter> parameters = new List<OracleParameter>();

				string gdSql =
					"SELECT GD.GroutingDailyID," +
					"       GD.GroutingLineID," +
					"       GD.GroutingLineCode," +
					"       GD.GroutingLineName," +
					"       GD.MouldQuantity," +
					"       GD.GroutingDate," +
					//"       GD.GroutingBatchNo," +
					"       GD.OPTimeStamp" +
					"  FROM TP_PM_GroutingDaily GD" +
					// 成型线操作权限
					//" INNER JOIN (SELECT UP.PurviewID" +
					//"               FROM TP_MST_UserPurview UP" +
					//"              WHERE UP.PurviewType = '" + (int)Constant.PurviewType.OperateGroutingLine + "'" +
					//"                AND UP.UserId = :UPUserId) UP" +
					//"    ON UP.PurviewID = GD.GroutingLineID" +
					" WHERE GD.AccountID = :AccountID" +
					"   AND GD.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
					// 成型线操作权限
					"   AND EXISTS (SELECT UP.PurviewID" +
					"                 FROM TP_MST_UserPurview UP" +
					"                WHERE UP.PurviewType = '" + (int)Constant.PurviewType.OperateGroutingLine + "'" +
					"                  AND (UP.PurviewID = -1 OR UP.PurviewID = GD.GroutingLineID)" +
					"                  AND UP.UserId = :UPUserId)" +
					"   AND GD.GroutingDailyID = :GroutingDailyID";

				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":UPUserId", OracleDbType.Int32, user.UserID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":GroutingDailyID", OracleDbType.Int32, groutingDailyID, ParameterDirection.Input));

				DataTable gdData = conn.GetSqlResultToDt(gdSql, parameters.ToArray());
				if (gdData == null || gdData.Rows.Count == 0)
				{
					// 没有可编辑的注浆信息
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 1;
					sre.Message = "没有可编辑的注浆信息";
					return sre;
				}
				gdData.TableName = "TP_PM_GroutingDaily";
				sre.Data = new DataSet();
				sre.Data.Tables.Add(gdData);

				string gddSql =
					"SELECT GDD.GroutingDailyID," +
					"       GDD.GroutingDailyDetailID," +
					"       GDD.GroutingLineID," +
					"       GDD.GroutingLineDetailID," +
					"       GDD.GroutingLineCode," +
					"       GDD.GroutingLineName," +
					"       GDD.GroutingDate," +
					"       GDD.GroutingBatchNo," +
					"       GDD.GroutingMouldCode," +
					"       GDD.UserCode," +
					"       GDD.GoodsCode," +
					"       GDD.GoodsName," +
					"       GMS.GMouldStatusName," +
					"       GDD.GroutingFlag," +
					"       GDD.LogoID," +
					//"       GDD.NoGroutingRreason," +
					"       DD.DictionaryValue AS NoGroutingRreason," +
					"       GDD.Remarks," +
					//"       GDD.ScrapFlag," +			 //	容错处理 2024-03-20
					"       NVL(GDD.ScrapFlag,'0') AS ScrapFlag," +
					"       GDD.DeliverFlag," +
					//"       GP.BarCode," +
					//"       GP.BarCode AS OBarCode," +
					"       GDD.SReasonID," +
					"       GDD.SReasonID ScrapReasonID," +
					"       SR.ScrapReason SReason," +
					"       GDD.BarCode," +
					"       GDD.BarCode AS OBarCode," +
					"       GDD.ScrapFlag AS OScrapFlag" +
					"  FROM TP_PM_GroutingDailyDetail GDD" +
					"  LEFT JOIN TP_MST_ScrapReason SR " +
					"    ON GDD.SReasonID = SR.ScrapReasonID " +
					" INNER JOIN TP_SYS_GMouldStatus GMS" +
					"    ON GMS.GMouldStatusID = GDD.GMouldStatus" +
					"  LEFT JOIN TP_MST_DataDictionary DD" +
					"    ON DD.DictionaryID = GDD.NoGroutingRreason" +
					//"  LEFT JOIN TP_PM_GroutingProduct GP" +
					//"    ON GP.GroutingDailyDetailID = GDD.GroutingDailyDetailID" +
					" WHERE GDD.AccountID = :AccountID" +
					"   AND GDD.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
					"   AND GDD.GroutingDailyID = :GroutingDailyID" +
					" ORDER BY GDD.GroutingMouldCode";
				parameters.Clear();
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":GroutingDailyID", OracleDbType.Int32, groutingDailyID, ParameterDirection.Input));

				DataTable gddData = conn.GetSqlResultToDt(gddSql, parameters.ToArray());
				if (gddData == null || gddData.Rows.Count == 0)
				{
					// 没有可注浆的模具
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 2;
					sre.Message = "没有可编辑的注浆明细信息";
					return sre;
				}

				gddData.TableName = "TP_PM_GroutingDailyDetail";
				sre.Data.Tables.Add(gddData);

				// 获取成型报损原因
				string sqlString = "SELECT ScrapReasonID,ScrapReason,DisplayNo,ScrapType,Remarks,ValueFlag FROM TP_MST_ScrapReason "
								+ " WHERE AccountID = :AccountID AND ScrapType ='0'  Order By DisplayNo";
				parameters.Clear();
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));

				DataTable returnTable = conn.GetSqlResultToDt(sqlString, parameters.ToArray());
				if (returnTable == null || returnTable.Rows.Count == 0)
				{
					// 没有可注浆的模具
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 3;
					sre.Message = "没有获取到成型报损原因";
					return sre;
				}

				// 'S_PM_023', '注浆绑码限制天数' add by chenxy 2019-05-07 begin
				sre.Result = 1;
				string spm023 = conn.GetSqlResultToStr("select ss.SETTINGVALUE from tp_mst_systemsetting ss where ss.SETTINGCODE = 'S_PM_023' and ss.AccountID = " + user.AccountID);
				int spm023Value = 0;
				if (!string.IsNullOrWhiteSpace(spm023) && int.TryParse(spm023, out spm023Value) && spm023Value > 0)
				{
					DateTime tDate = DateTime.Now.Date;
					DateTime lastDate = tDate.AddDays(1 - spm023Value);
					DateTime gData = (DateTime)gdData.Rows[0]["GroutingDate"];
					if (gData < lastDate || gData > tDate)
					{
						sre.Result = 0;
						sre.Message = string.Format("允许注浆绑码的日期范围【{0:yyyy-MM-dd}】-【{1:yyyy-MM-dd}】", lastDate, tDate);
					}
				}
				// 'S_PM_023', '注浆绑码限制天数' add by chenxy 2019-05-07 end

				returnTable.TableName = "TP_MST_ScrapReason";
				sre.Data.Tables.Add(returnTable);

				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 保存FPM0103画面（绑定条码）的注浆数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="groutingInfo">注浆数据</param>
		/// <returns>保存结果
		/// OtherStatus = 1: 没有以下成型线的操作权限
		/// </returns>
		public static ServiceResultEntity SetFPM0103Data(SUserInfo user, DataSet groutingInfo)
		{
			IDBTransaction tran = null;
			try
			{
				ServiceResultEntity sre = new ServiceResultEntity();
				if (groutingInfo == null ||
					groutingInfo.Tables.Count < 2 ||										   
					groutingInfo.Tables[0].Rows.Count < 1 ||
					groutingInfo.Tables[1].Rows.Count < 1)
				{
					sre.Status = Constant.ServiceResultStatus.NoModifyData;
					return sre;
				}

				tran = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				int executeResult = 0;

				// 绑定条码

				#region 校验时间戳
				// 校验时间戳
				DataRow gdDataRow = groutingInfo.Tables[0].Rows[0];
				string checkSql =
					"SELECT GroutingDailyID" +
					"  FROM TP_PM_GroutingDaily" +
					" WHERE GroutingDailyID = :GroutingDailyID" +
					"   AND OPTimeStamp = :OPTimeStamp" +
					"   AND ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'";
				OracleParameter[] checkParas = new OracleParameter[]
				{
					new OracleParameter(":GroutingDailyID", OracleDbType.Int32, gdDataRow["GroutingDailyID"], ParameterDirection.Input),
					new OracleParameter(":OPTimeStamp", OracleDbType.TimeStamp, gdDataRow["OPTimeStamp"], ParameterDirection.Input),
				};
				object checkResult = tran.GetSqlResultToObj(checkSql, checkParas);
				if (checkResult == null)
				{
					sre.Status = Constant.ServiceResultStatus.DataChanged;
					return sre;
				}
				#endregion 校验时间戳

				#region 校验条码
				//StringBuilder barcodes = new StringBuilder(",");
				//foreach (DataRow row in groutingInfo.Tables[1].Rows)
				//{
				//    if ((row["OBarCode"] == null || row["OBarCode"] == DBNull.Value) &&
				//        (row["BarCode"] != null && row["BarCode"] != DBNull.Value))
				//    {
				//        barcodes.Append(row["BarCode"].ToString() + ",");
				//    }
				//}
				//// todo 条码状态表
				//string checkBarcodeSql =
				//    "SELECT UBC.BarCode FROM TP_PM_UsedBarCode UBC " +
				//    " WHERE INSTR(:BarCodes, ',' || UBC.BarCode || ',') > 0";
				//OracleParameter[] checkBarcodeParas = new OracleParameter[]
				//{
				//    new OracleParameter(":BarCodes", OracleDbType.NVarchar2, barcodes.ToString(), ParameterDirection.Input),
				//};
				StringBuilder barcodes = new StringBuilder();
				foreach (DataRow row in groutingInfo.Tables[1].Rows)
				{
					if ((row["OBarCode"] == null || row["OBarCode"] == DBNull.Value) &&
						(row["BarCode"] != null && row["BarCode"] != DBNull.Value))
					{
						if (barcodes.Length > 0)
						{
							barcodes.Append($" OR BarCode='{row["BarCode"]}'");
						}
						else
						{
							barcodes.Append($" BarCode='{row["BarCode"]}'");
						}
					}
				}
				if (barcodes.Length > 0)
				{
					// 条码状态表
					DataTable barCodeDataTable = tran.GetSqlResultToDt($"SELECT UBC.BarCode FROM TP_PM_UsedBarCode UBC WHERE {barcodes}");
					if (barCodeDataTable != null && barCodeDataTable.Rows.Count > 0)
					{
						barcodes.Clear();
						//foreach (DataRow row in groutingInfo.Tables[1].Rows)
						foreach (DataRow row in barCodeDataTable.Rows)
						{
							if (barcodes.Length > 0)
							{
								barcodes.Append(",");
							}
							barcodes.Append(row["BarCode"].ToString());
						}

						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = 1;
						//sre.Message = string.Format("条码（{0}）已被使用", barcode);
						sre.Message = "以下条码已被使用" + System.Environment.NewLine + barcodes.ToString();
						return sre;
					}
				}
				#endregion 校验条码

				#region 更新注浆日报表
				string upgdSql = "UPDATE TP_PM_GroutingDaily SET UpdateUserID = :UpdateUserID WHERE GroutingDailyID = :GroutingDailyID";
				OracleParameter[] upgdParas = new OracleParameter[]
				{
					new OracleParameter(":GroutingDailyID", OracleDbType.Int32, gdDataRow["GroutingDailyID"], ParameterDirection.Input),
					new OracleParameter(":UpdateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
				};
				executeResult = tran.ExecuteNonQuery(upgdSql, upgdParas);
				if (executeResult <= 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoModifyData;
					return sre;
				}
				#endregion 更新注浆日报表

				#region 更新注浆日报明细表
				#region SQL
				string updateGroutingDailyDetailLogoSql =
					"UPDATE TP_PM_GroutingDailyDetail" +
					"   SET Remarks = :Remarks," +
					"       UpdateUserID = :UpdateUserID, LogoID = :LogoID" +
					" WHERE GroutingDailyDetailID = :GroutingDailyDetailID";

				string updateGroutingDailyDetailRemarksSql =
					"UPDATE TP_PM_GroutingDailyDetail" +
					"   SET ScrapFlag = :ScrapFlag, Remarks = :Remarks, " +
					"       ScrapTime = case when :ScrapFlag= '1' and ScrapFlag = '0' then sysdate when :ScrapFlag= '0' then null else ScrapTime end, " +
					"       ScrapUser = case when :ScrapFlag= '1' and ScrapFlag = '0' then :UpdateUserID when :ScrapFlag= '0' then null else ScrapUser end, " +
					"       UpdateUserID = :UpdateUserID, LogoID = :LogoID" +
					" WHERE GroutingDailyDetailID = :GroutingDailyDetailID";

				string updateGroutingDailyDetailScrapFlagSql =
					"UPDATE TP_PM_GroutingDailyDetail" +
					"   SET ScrapFlag = :ScrapFlag, " +
					"       ScrapTime = case when :ScrapFlag= '1' and ScrapFlag = '0' then sysdate when :ScrapFlag= '0' then null else ScrapTime end, " +
					"       ScrapUser = case when :ScrapFlag= '1' and ScrapFlag = '0' then :UpdateUserID when :ScrapFlag= '0' then null else ScrapUser end, " +
					"       Remarks = :Remarks," +
					"       LogoID = :LogoID," +
					"       UpdateUserID = :UpdateUserID" +
					" WHERE GroutingDailyDetailID = :GroutingDailyDetailID";

				string updateGroutingDailyDetailSql =
					"UPDATE TP_PM_GroutingDailyDetail" +
					"   SET BarCode = :BarCode, " +
					"       ScrapFlag = '" + (int)Constant.GroutingScrapFlag.No + "'," +
					"       Remarks = :Remarks," +
					"       LogoID = :LogoID," +
					"       UpdateUserID = :UpdateUserID" +
					" WHERE GroutingDailyDetailID = :GroutingDailyDetailID";
				#endregion SQL
				foreach (DataRow detailDataRow in groutingInfo.Tables[1].Rows)
				{
					if (detailDataRow.RowState != DataRowState.Modified)
					{
						continue;
					}

					// 未注浆不用更新
					if (((int)Constant.GroutingFlag.Yes).ToString() != detailDataRow["GroutingFlag"].ToString())
					{
						//OracleParameter[] updateGroutingDailyDetailLogoParas = new OracleParameter[]
						//{
						//    new OracleParameter(":LogoID", OracleDbType.Int32, detailDataRow["LogoID"], ParameterDirection.Input),
						//    new OracleParameter(":GroutingDailyDetailID", OracleDbType.Int32, detailDataRow["GroutingDailyDetailID"], ParameterDirection.Input),
						//    new OracleParameter(":Remarks", OracleDbType.NVarchar2, detailDataRow["Remarks"], ParameterDirection.Input),
						//    new OracleParameter(":UpdateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
						//};
						//executeResult = tran.ExecuteNonQuery(updateGroutingDailyDetailLogoSql, updateGroutingDailyDetailLogoParas);
						//if (executeResult <= 0)
						//{
						//    sre.Status = Constant.ServiceResultStatus.NoModifyData;
						//    return sre;
						//}
						continue;
					}

					// 已交坯不用更新
					if ("1" == detailDataRow["DeliverFlag"].ToString())
					{
						//OracleParameter[] updateGroutingDailyDetailLogoParas = new OracleParameter[]
						//{
						//    new OracleParameter(":LogoID", OracleDbType.Int32, detailDataRow["LogoID"], ParameterDirection.Input),
						//    new OracleParameter(":GroutingDailyDetailID", OracleDbType.Int32, detailDataRow["GroutingDailyDetailID"], ParameterDirection.Input),
						//    new OracleParameter(":Remarks", OracleDbType.NVarchar2, detailDataRow["Remarks"], ParameterDirection.Input),
						//    new OracleParameter(":UpdateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
						//};
						//executeResult = tran.ExecuteNonQuery(updateGroutingDailyDetailLogoSql, updateGroutingDailyDetailLogoParas);
						//if (executeResult <= 0)
						//{
						//    sre.Status = Constant.ServiceResultStatus.NoModifyData;
						//    return sre;
						//}
						continue;
					}

					// 已绑定条码，不能修改条码，绑定条码后损坯
					string oBarcode = detailDataRow["OBarcode"].ToString();
					if (!string.IsNullOrEmpty(oBarcode))
					{
						OracleParameter[] updateGroutingDailyDetailRemarksParas = new OracleParameter[]
						{
							new OracleParameter(":LogoID", OracleDbType.Int32, detailDataRow["LogoID"], ParameterDirection.Input),
							new OracleParameter(":ScrapFlag", OracleDbType.Char, detailDataRow["ScrapFlag"], ParameterDirection.Input),
							new OracleParameter(":GroutingDailyDetailID", OracleDbType.Int32, detailDataRow["GroutingDailyDetailID"], ParameterDirection.Input),
							new OracleParameter(":Remarks", OracleDbType.NVarchar2, detailDataRow["Remarks"], ParameterDirection.Input),
							new OracleParameter(":UpdateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
						};
						executeResult = tran.ExecuteNonQuery(updateGroutingDailyDetailRemarksSql, updateGroutingDailyDetailRemarksParas);
						if (executeResult <= 0)
						{
							sre.Status = Constant.ServiceResultStatus.NoModifyData;
							return sre;
						}

						//更新使用条码 2015/7/14
						string sqlUpdateUsedBarCode = "update TP_PM_UsedBarCode set BarCodeStatus=:BarCodeStatus where barcode=:barcode";
						OracleParameter[] UpdateUsedBarCodeParas = new OracleParameter[]
						{
							new OracleParameter(":BarCodeStatus", OracleDbType.Char, detailDataRow["ScrapFlag"].ToString()=="0"?"1":"2", ParameterDirection.Input),
							new OracleParameter(":barcode", OracleDbType.NVarchar2, detailDataRow["BarCode"], ParameterDirection.Input),
						};
						executeResult = tran.ExecuteNonQuery(sqlUpdateUsedBarCode, UpdateUsedBarCodeParas);
						if (executeResult <= 0)
						{
							sre.Status = Constant.ServiceResultStatus.NoModifyData;
							return sre;
						}
						//更新使用条码 2015/7/14 end

						continue;
					}

					// 损坯
					string barcode = detailDataRow["Barcode"].ToString();
					if (((int)Constant.GroutingScrapFlag.Yes).ToString() == detailDataRow["ScrapFlag"].ToString() ||
						string.IsNullOrWhiteSpace(barcode))
					{
						OracleParameter[] updateGroutingDailyDetailScrapFlagParas = new OracleParameter[]
						{
							new OracleParameter(":LogoID", OracleDbType.Int32, detailDataRow["LogoID"], ParameterDirection.Input),
							new OracleParameter(":GroutingDailyDetailID", OracleDbType.Int32, detailDataRow["GroutingDailyDetailID"], ParameterDirection.Input),
							new OracleParameter(":Remarks", OracleDbType.NVarchar2, detailDataRow["Remarks"], ParameterDirection.Input),
							new OracleParameter(":UpdateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
							new OracleParameter(":ScrapFlag", OracleDbType.Char, detailDataRow["ScrapFlag"], ParameterDirection.Input),
						};

						executeResult = tran.ExecuteNonQuery(updateGroutingDailyDetailScrapFlagSql, updateGroutingDailyDetailScrapFlagParas);
						if (executeResult <= 0)
						{
							sre.Status = Constant.ServiceResultStatus.NoModifyData;
							return sre;
						}
						//更新使用条码 2015/7/14
						if (!string.IsNullOrEmpty(detailDataRow["BarCode"].ToString()))
						{
							string sqlUpdateUsedBarCode = "update TP_PM_UsedBarCode set BarCodeStatus=:BarCodeStatus where barcode=:barcode";
							OracleParameter[] UpdateUsedBarCodeParas = new OracleParameter[]
							{
								new OracleParameter(":BarCodeStatus", OracleDbType.Char, detailDataRow["ScrapFlag"].ToString()=="0"?"1":"2", ParameterDirection.Input),
								new OracleParameter(":barcode", OracleDbType.NVarchar2, detailDataRow["BarCode"], ParameterDirection.Input),
							};
							executeResult = tran.ExecuteNonQuery(sqlUpdateUsedBarCode, UpdateUsedBarCodeParas);
							if (executeResult <= 0)
							{
								sre.Status = Constant.ServiceResultStatus.NoModifyData;
								return sre;
							}
						}
						//更新使用条码 2015/7/14 end

						continue;
					}

					// 验证条码
					// todo 条码状态表
					//string checkBarcodeSql =
					//	"SELECT 1 FROM TP_PM_UsedBarCode WHERE BarCode = :BarCode";
					//OracleParameter[] checkBarcodeParas = new OracleParameter[]
					//{
					//	new OracleParameter(":BarCode", OracleDbType.NVarchar2, barcode, ParameterDirection.Input),
					//};
					//object result = tran.GetSqlResultToObj(checkBarcodeSql, checkBarcodeParas);
					//if (result != null)
					//{
					//	sre.Status = Constant.ServiceResultStatus.Other;
					//	sre.OtherStatus = 1;
					//	sre.Message = string.Format("条码（{0}）已被使用", barcode);
					//	return sre;
					//}
					string insertBarcodeSql =
						"INSERT INTO TP_PM_UsedBarCode " +
						"  (BarCode, AccountID, CreateTime, CreateUserID,GroutingDailyDetailID,BarCodeStatus)" +
						"VALUES " +
						"  (:BarCode, :AccountID, sysdate, :CreateUserID,:GroutingDailyDetailID,:BarCodeStatus)";
					OracleParameter[] insertBarcodeParas = new OracleParameter[]
					{
						new OracleParameter(":BarCode", OracleDbType.NVarchar2, barcode, ParameterDirection.Input),
						new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input),
						new OracleParameter(":CreateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
						new OracleParameter(":GroutingDailyDetailID", OracleDbType.Int32, detailDataRow["GroutingDailyDetailID"], ParameterDirection.Input),
						new OracleParameter(":BarCodeStatus", OracleDbType.Char, detailDataRow["ScrapFlag"].ToString()=="0"?"1":"2", ParameterDirection.Input),

					};
					executeResult = tran.ExecuteNonQuery(insertBarcodeSql, insertBarcodeParas);
					if (executeResult <= 0)
					{
						sre.Status = Constant.ServiceResultStatus.NoModifyData;
						return sre;
					}

					// 绑定条码
					OracleParameter[] updateGroutingDailyDetailParas = new OracleParameter[]
					{
						new OracleParameter(":LogoID", OracleDbType.Int32, detailDataRow["LogoID"], ParameterDirection.Input),
						new OracleParameter(":GroutingDailyDetailID", OracleDbType.Int32, detailDataRow["GroutingDailyDetailID"], ParameterDirection.Input),
						new OracleParameter(":BarCode", OracleDbType.NVarchar2, detailDataRow["BarCode"], ParameterDirection.Input),
						new OracleParameter(":Remarks", OracleDbType.NVarchar2, detailDataRow["Remarks"], ParameterDirection.Input),
						new OracleParameter(":UpdateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
					};
					executeResult = tran.ExecuteNonQuery(updateGroutingDailyDetailSql, updateGroutingDailyDetailParas);
					if (executeResult <= 0)
					{
						sre.Status = Constant.ServiceResultStatus.NoModifyData;
						return sre;
					}

				}
				#endregion 更新注浆日报明细表

				tran.Commit();
				return sre;
			}
			catch (Exception ex)
			{
				if (tran != null &&
					tran.ConnState == ConnectionState.Open)
				{
					tran.Rollback();
				}
				throw ex;
			}
			finally
			{
				if (tran != null &&
					tran.ConnState == ConnectionState.Open)
				{
					tran.Disconnect();
				}
			}
		}

		#endregion 条码绑定

		#region 取消最后注浆
		/// <summary>
		/// 验证成型线编码是否能取消最后注浆
		/// </summary>
		/// <param name="user"></param>
		/// <param name="glcode"></param>
		/// <returns></returns>
		public static ServiceResultEntity CheckFPM0106GLCode(SUserInfo user, string glcode)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			if (string.IsNullOrWhiteSpace(glcode))
			{
				sre.Status = Constant.ServiceResultStatus.Other;
				sre.OtherStatus = 1;
				sre.Message = $"成型线【{glcode}】不存在";
				return sre;
			}
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				//输入成型线号，1.验证是否存在、2.最后注浆日期、批次是否存在，3.是否有报损、是否绑定条码。 返回【最后注浆日期、批次】。

				string sqlString = "select GL.GroutingLineID\n" +
				"      ,gl.GroutingLineCode\n" +
				"      ,gl.GroutingLineName\n" +
				"      ,GL.LastGroutingDate\n" +
				"      ,GL.LastGroutingBatchNo\n" +
				"      ,gd.usercode\n" +
				"      ,gd.GroutingDailyID\n" +
				"  from TP_PC_GroutingLine gl\n" +
				"  left join TP_PM_GroutingDaily gd\n" +
				"    on gd.GroutingLineID = gl.GroutingLineID\n" +
				"   and gd.GroutingDate = GL.LastGroutingDate\n" +
				"   and gd.GroutingBatchNo = gl.LastGroutingBatchNo\n" +
				"   and gd.valueflag = '1'\n" +
				" where gl.valueflag = '1'\n" +
				"   and gl.GroutingLineCode = :glcode";
				OracleParameter[] ps = new OracleParameter[]
				{
					new OracleParameter(":glcode", glcode),
				};
				DataTable data = conn.GetSqlResultToDt(sqlString, ps);
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 1;
					sre.Message = $"成型线【{glcode}】不存在";
					return sre;
				}
				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);

				object objgdid = data.Rows[0]["GroutingDailyID"];
				if (objgdid == null || objgdid == DBNull.Value)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 2;
					sre.Message = $"成型线【{glcode}】未注浆";
					return sre;
				}
				int gdid = Convert.ToInt32(objgdid);

				sqlString = "select count(gdd.GroutingDailyDetailID) dc\n" +
				"  from TP_PM_GroutingDailyDetail gdd\n" +
				" where gdd.valueflag = '1'\n" +
				"   and gdd.GroutingDailyID = :gdid\n" +
				"   and (gdd.ScrapFlag <> '0' or gdd.barcode is not null)";
				ps = new OracleParameter[]
				{
					new OracleParameter(":gdid", gdid),
				};
				int dcount = Convert.ToInt32(conn.GetSqlResultToObj(sqlString, ps));
				if (dcount > 0)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 3;
					sre.Message = $"成型线【{glcode}】最后注浆登记中有已报损或绑定条码的注浆明细";
					return sre;
				}

				// 'S_PM_022', '注浆编辑限制天数' add by chenxy 2018-12-15 begin
				sre.Result = 1;
				string spm022 = conn.GetSqlResultToStr("select ss.SETTINGVALUE from tp_mst_systemsetting ss where ss.SETTINGCODE = 'S_PM_022' and ss.AccountID = " + user.AccountID);
				int spm022Value = 0;
				if (!string.IsNullOrWhiteSpace(spm022) && int.TryParse(spm022, out spm022Value) && spm022Value > 0)
				{
					DateTime tDate = DateTime.Now.Date;
					DateTime lastDate = tDate.AddDays(1 - spm022Value);
					DateTime gData = (DateTime)data.Rows[0]["LastGroutingDate"];
					if (gData < lastDate || gData > tDate)
					{
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = 9;
						sre.Message = string.Format("允许注浆编辑的日期范围【{0:yyyy-MM-dd}】-【{1:yyyy-MM-dd}】", lastDate, tDate);
						return sre;
					}
				}
				// 'S_PM_022', '注浆编辑限制天数' add by chenxy 2018-12-15 end
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 验证成型线编码是否能取消最后注浆
		/// </summary>
		/// <param name="user"></param>
		/// <param name="glcode"></param>
		/// <returns></returns>
		public static ServiceResultEntity SetFPM0106GLCode(SUserInfo user, ClientRequestEntity cre)
		{
			string glcode = cre.Data.Tables[0].Rows[0]["GroutingLineCode"] + "";
			int glID = Convert.ToInt32(cre.Data.Tables[0].Rows[0]["GroutingLineID"]);
			int gdID = Convert.ToInt32(cre.Data.Tables[0].Rows[0]["GroutingDailyID"]);
			ServiceResultEntity sre = new ServiceResultEntity();
			if (string.IsNullOrWhiteSpace(glcode))
			{
				sre.Status = Constant.ServiceResultStatus.Other;
				sre.OtherStatus = 1;
				sre.Message = $"成型线【{glcode}】不存在";
				return sre;
			}
			IDBTransaction conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				//输入成型线号，1.验证是否存在、2.最后注浆日期、批次是否存在，3.是否有报损、是否绑定条码。 返回【最后注浆日期、批次】。

				string sqlString = "select GL.GroutingLineID\n" +
				//"      ,gl.GroutingLineCode\n" +
				//"      ,gl.GroutingLineName\n" +
				//"      ,nvl(GL.LastGroutingDate, to_date('1900-01-01','yyyy-mm-dd')) LastGroutingDate\n" +
				//"      ,nvl(GL.LastGroutingBatchNo,0) LastGroutingBatchNo\n" +
				//"      ,gd.usercode\n" +
				"      ,gd.GroutingDailyID\n" +
				"  from TP_PC_GroutingLine gl\n" +
				" inner join TP_PM_GroutingDaily gd\n" +
				"    on gd.GroutingLineID = gl.GroutingLineID\n" +
				"   and gd.GroutingDate = GL.LastGroutingDate\n" +
				"   and gd.GroutingBatchNo = gl.LastGroutingBatchNo\n" +
				"   and gd.valueflag = '1'\n" +
				" where gl.valueflag = '1'\n" +
				"   and gl.GroutingLineID = :glID\n" +
				" for update";
				OracleParameter[] ps = new OracleParameter[]
				{
					new OracleParameter(":glID", glID),
				};
				DataTable data = conn.GetSqlResultToDt(sqlString, ps);
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 1;
					sre.Message = $"成型线【{glcode}】不存在";
					return sre;
				}
				//sre.Data = new DataSet();
				//sre.Data.Tables.Add(data);

				//DateTime lgd = Convert.ToDateTime(data.Rows[0]["LastGroutingDate"]);
				//int lgb = Convert.ToInt32(data.Rows[0]["LastGroutingBatchNo"]);

				//if (lgd != Convert.ToDateTime(cre.Data.Tables[0].Rows[0]["LastGroutingDate"]) ||
				//    lgb != Convert.ToInt32(cre.Data.Tables[0].Rows[0]["LastGroutingBatchNo"]))
				//{
				//    sre.Status = Constant.ServiceResultStatus.Other;
				//    sre.OtherStatus = 2;
				//    sre.Message = $"成型线【{glcode}】最后注浆日期和批次已变更";
				//    return sre;
				//}
				int lgdid = Convert.ToInt32(data.Rows[0]["GroutingDailyID"]);
				if (lgdid != gdID)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 2;
					sre.Message = $"成型线【{glcode}】最后注浆日期和批次已变更";
					return sre;
				}

				sqlString = "select count(gdd.GroutingDailyDetailID) dc\n" +
				"  from TP_PM_GroutingDailyDetail gdd\n" +
				" where gdd.valueflag = '1'\n" +
				"   and gdd.GroutingDailyID = :gdid\n" +
				"   and (gdd.ScrapFlag <> '0' or gdd.barcode is not null)";
				ps = new OracleParameter[]
				{
					new OracleParameter(":gdid", gdID),
				};
				int dcount = Convert.ToInt32(conn.GetSqlResultToObj(sqlString, ps));
				if (dcount > 0)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 3;
					sre.Message = $"成型线【{glcode}】最后注浆登记中有已报损或绑定条码的注浆明细";
					return sre;
				}

				// 'S_PM_022', '注浆编辑限制天数' add by chenxy 2018-12-15 begin
				//sre.Result = 1;
				//string spm022 = conn.GetSqlResultToStr("select ss.SETTINGVALUE from tp_mst_systemsetting ss where ss.SETTINGCODE = 'S_PM_022' and ss.AccountID = " + user.AccountID);
				//int spm022Value = 0;
				//if (!string.IsNullOrWhiteSpace(spm022) && int.TryParse(spm022, out spm022Value) && spm022Value > 0)
				//{
				//    DateTime tDate = DateTime.Now.Date;
				//    DateTime lastDate = tDate.AddDays(1 - spm022Value);
				//    DateTime gData = (DateTime)data.Rows[0]["LastGroutingDate"];
				//    if (gData < lastDate || gData > tDate)
				//    {
				//        sre.Status = Constant.ServiceResultStatus.Other;
				//        sre.OtherStatus = 9;
				//        sre.Message = string.Format("允许注浆编辑的日期范围【{0:yyyy-MM-dd}】-【{1:yyyy-MM-dd}】", lastDate, tDate);
				//        return sre;
				//    }
				//}
				// 'S_PM_022', '注浆编辑限制天数' add by chenxy 2018-12-15 end

				//2.然后取消注浆，3.并valueflag=0。4.修改成型线的最后注浆日期、批次。
				int r = 0;
				string sql = null;
				sql =
				"UPDATE TP_PM_GroutingDailyDetail" +
				"   SET GroutingCount = CASE" +
				"                       WHEN GroutingFlag = '1'" +
				"                       THEN GroutingCount - 1" +
				"                       ELSE GroutingCount END," +
				"       GroutingFlag = '0'," +
				"       UpdateUserID = :UpdateUserID" +
				" WHERE GroutingDailyID = :gdid";
				ps = new OracleParameter[]
				{
					new OracleParameter(":UpdateUserID", user.UserID),
					new OracleParameter(":gdid", gdID),
				};
				r = conn.ExecuteNonQuery(sql, ps);

				sql = "UPDATE tp_pc_groutinglinedetail gld\n" +
				"   SET gld.groutingcount =\n" +
				"       (SELECT gdds.groutingcount\n" +
				"          FROM tp_pm_groutingdailydetail gdds\n" +
				"         WHERE gdds.groutingdailyid = :gdid\n" +
				"           AND gdds.groutinglinedetailid = gld.groutinglinedetailid\n" +
				"           AND gdds.valueflag = '1')\n" +
				"      ,gld.updateuserid  = :UpdateUserID\n" +
				" WHERE gld.groutinglinedetailid IN\n" +
				"       (SELECT gdd.groutinglinedetailid\n" +
				"          FROM tp_pm_groutingdailydetail gdd\n" +
				"         WHERE gdd.groutingdailyid = :gdid\n" +
				"           AND gdd.valueflag = '1')";
				r = conn.ExecuteNonQuery(sql, ps);

				sql =
				"UPDATE TP_PM_GroutingDailyDetail" +
				"   SET valueflag = '0'," +
				"       UpdateUserID = :UpdateUserID" +
				" WHERE GroutingDailyID = :gdid";
				r = conn.ExecuteNonQuery(sql, ps);

				sql = "update TP_PM_GroutingDaily gd set gd.valueflag='0', updateuserid = :UpdateUserID where gd.GroutingDailyID = :gdid";
				r = conn.ExecuteNonQuery(sql, ps);

				sql = "update TP_PC_GroutingLine gl\n" +
				"   set (gl.LastGroutingDate, gl.LastGroutingBatchNo) =\n" +
				"       (select gd.GroutingDate, gd.GroutingBatchNo\n" +
				"          from TP_PM_GroutingDaily gd\n" +
				"         where gd.GroutingDailyID =\n" +
				"               (select max(gm.GroutingDailyID)\n" +
				"                  from TP_PM_GroutingDaily gm\n" +
				"                 where gm.GroutingLineID = :glid\n" +
				"                   and gm.valueflag = '1'))\n" +
				"      ,gl.UpdateUserID = :UpdateUserID\n" +
				" where gl.GroutingLineID = :glid";
				ps = new OracleParameter[]
				{
					new OracleParameter(":UpdateUserID", user.UserID),
					new OracleParameter(":glid", glID),
				};
				r = conn.ExecuteNonQuery(sql, ps);

				conn.Commit();
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Disconnect();
				}
			}
		}
		#endregion
		#endregion 注浆管理

		#region 条码管理

		#region 条码校验
		/*
		/// <summary>
		/// 条码（）无效
		/// </summary>
		private const string MSG_CHECK_BARCODE_1 = "条码（{0}）无效";
		/// <summary>
		/// 系统中不存在条码（）
		/// </summary>
		private const string MSG_CHECK_BARCODE_2 = "系统中不存在条码（{0}）";
		/// <summary>
		/// 条码（）属于其他账套
		/// </summary>
		private const string MSG_CHECK_BARCODE_3 = "条码（{0}）属于其他账套";
		/// <summary>
		/// 条码（）未被使用
		/// </summary>
		private const string MSG_CHECK_BARCODE_4 = "条码（{0}）未被使用";
		/// <summary>
		/// 条码（）已被使用
		/// </summary>
		private const string MSG_CHECK_BARCODE_5 = "条码（{0}）已被使用";
		/// <summary>
		/// 条码（）已被更换为（）
		/// </summary>
		private const string MSG_CHECK_BARCODE_6 = "条码（{0}）已被更换为（{1}）";

		/// <summary>
		/// 校验更换条码
		/// </summary>
		/// <param name="user"></param>
		/// <param name="barcodes"></param>
		/// <returns></returns>
		private static bool CheckBarcode2(IDBTransaction tran, SUserInfo user,
			string barcode, string newBarcode, out string messages)
		{
			messages = null;
			if (string.IsNullOrWhiteSpace(barcode))
			{
				// 无效条码
				messages = string.Format(MSG_CHECK_BARCODE_1, barcode);
				return false;
			}

			if (string.IsNullOrWhiteSpace(newBarcode))
			{
				// 无效条码
				messages = string.Format(MSG_CHECK_BARCODE_1, newBarcode);
				return false;
			}

			string checkBarCodeSql =
				"SELECT BC.BarCode, BC.BarCodeStatus, BC.AccountID" +
				"  FROM TP_PM_BarCode BC" +
				" WHERE BarCode = :BarCode OR BarCode = :NewBarCode";
			OracleParameter[] checkBarCodeParas = new OracleParameter[]
			{
				new OracleParameter(":BarCode", OracleDbType.Varchar2, barcode, ParameterDirection.Input),
				new OracleParameter(":NewBarCode", OracleDbType.Varchar2, newBarcode, ParameterDirection.Input),
			};
			DataTable barcodeData = tran.GetSqlResultToDt(checkBarCodeSql, checkBarCodeParas);
			if (barcodeData == null || barcodeData.Rows.Count == 0)
			{
				// 系统中不存在条码
				messages = string.Format(MSG_CHECK_BARCODE_2, barcode);
				return false;
			}

			DataRow[] drs = barcodeData.Select("BarCode = '" + barcode + "'");
			if (drs == null || drs.Length == 0)
			{
				// 系统中不存在条码
				messages = string.Format(MSG_CHECK_BARCODE_2, barcode);
				return false;
			}
			if (user.AccountID.ToString() != drs[0]["AccountID"].ToString())
			{
				// 条码属于其他账套
				messages = string.Format(MSG_CHECK_BARCODE_3, barcode);
				return false;
			}
			if (((int)Constant.BarcodeStatus.Unused).ToString() == drs[0]["BarCodeStatus"].ToString())
			{
				// 条码未被使用
				messages = string.Format(MSG_CHECK_BARCODE_4, barcode);
				return false;
			}
			if (((int)Constant.BarcodeStatus.Replaced).ToString() == drs[0]["BarCodeStatus"].ToString())
			{
				string sql = "SELECT FinalBarCode FROM TP_PM_BarCodeRecord WHERE BarCode = :BarCode";
				OracleParameter[] paras = new OracleParameter[]
				{
					new OracleParameter(":BarCode", OracleDbType.Varchar2, barcode, ParameterDirection.Input),
				};
				object finalBarCode = tran.GetSqlResultToObj(sql, paras);
				if (finalBarCode != null)
				{
					// 条码已被更换
					messages = string.Format(MSG_CHECK_BARCODE_6, barcode, finalBarCode);
					return false;
				}
			}

			drs = barcodeData.Select("BarCode = '" + newBarcode + "'");
			if (drs == null || drs.Length == 0)
			{
				return true;
			}
			if (user.AccountID.ToString() != drs[0]["AccountID"].ToString())
			{
				// 条码属于其他账套
				messages = string.Format(MSG_CHECK_BARCODE_3, newBarcode);
				return false;
			}
			if (((int)Constant.BarcodeStatus.Unused).ToString() != drs[0]["BarCodeStatus"].ToString())
			{
				// 条码已被使用
				messages = string.Format(MSG_CHECK_BARCODE_5, newBarcode);
				return false;
			}

			return true;
		}

		/// <summary>
		/// 校验注浆绑定条码
		/// </summary>
		/// <param name="user"></param>
		/// <param name="barcodes"></param>
		/// <returns></returns>
		private static bool CheckBarcode1(IDBTransaction tran, SUserInfo user, string barcodes,
			out DataTable invalid, out DataTable effective)
		{
			// 无效条码
			invalid = null;
			// 有效条码
			effective = null;

			if (string.IsNullOrWhiteSpace(barcodes))
			{
				// 无效条码
				return false;
			}

			string checkBarCodeSql =
				"SELECT BC.BarCodeStatus, BC.AccountID" +
				"  FROM TP_PM_BarCode BC" +
				//" WHERE BarCode = :BarCode;";
				" WHERE INSTR(:BarCodes, ',' || BC.BarCode || ',') > 0";

			OracleParameter[] checkBarCodeParas = new OracleParameter[]
			{
				new OracleParameter(":BarCodes", OracleDbType.Varchar2, checkBarCodeSql, ParameterDirection.Input),
			};
			DataTable barcodeData = tran.GetSqlResultToDt(checkBarCodeSql, checkBarCodeParas);
			if (barcodeData == null || barcodeData.Rows.Count == 0)
			{
				// 通过校验
				return true;
			}

			foreach (DataRow barcode in barcodeData.Rows)
			{
				if (user.AccountID.ToString() != barcode["AccountID"].ToString())
				{
					// 不在同一个账套
				}

				if (((int)Constant.BarcodeStatus.Unused).ToString() != barcode["BarCodeStatus"].ToString())
				{

				}
			}

			return true;
		}
		*/
		#endregion 条码校验

		#region 条码变更
		/// <summary>
		/// 取得FPM0202画面（条码变更用条码查询）的查询数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetFPM0202SData(SUserInfo user, FPM0202_SE se)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);

				// 'S_PM_024', '未交坯可否替换条码' add by chenxy 2019-05-07 begin
				string spm024 = conn.GetSqlResultToStr("select ss.SETTINGVALUE from tp_mst_systemsetting ss where ss.SETTINGCODE = 'S_PM_024' and ss.AccountID = " + user.AccountID);
				if (spm024 != "1")
				{
					spm024 = "0";
				}
				// 'S_PM_024', '未交坯可否替换条码' add by chenxy 2019-05-07 end

				List<OracleParameter> parameters = new List<OracleParameter>();
				StringBuilder sql = new StringBuilder(PMModuleLogic.GetFPM0202SSQL());
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));
				//parameters.Add(new OracleParameter(":UPUserId", OracleDbType.Int32, user.UserID, ParameterDirection.Input));

				if (se != null)
				{
					if (spm024 == "0")
					{
						sql.Append(" AND GDD.deliverflag = '1'");
					}

					// 成型线编码
					if (!string.IsNullOrEmpty(se.GroutingLineCode))
					{
						sql.Append(" AND INSTR(GD.GroutingLineCode, :GroutingLineCode) > 0");
						parameters.Add(new OracleParameter(":GroutingLineCode", OracleDbType.NVarchar2, se.GroutingLineCode, ParameterDirection.Input));
					}
					// 成型线名称
					if (!string.IsNullOrEmpty(se.GroutingLineName))
					{
						sql.Append(" AND INSTR(GD.GroutingLineName, :GroutingLineName) > 0");
						parameters.Add(new OracleParameter(":GroutingLineName", OracleDbType.NVarchar2, se.GroutingLineName, ParameterDirection.Input));
					}
					// 成型线类别
					if (se.GMouldTypeID.HasValue)
					{
						sql.Append(" AND GD.GMouldTypeID = :GMouldTypeID");
						parameters.Add(new OracleParameter(":GMouldTypeID", OracleDbType.Int32, se.GMouldTypeID.Value, ParameterDirection.Input));
					}
					// 注浆日期-开始
					if (se.GroutingDateBegin.HasValue)
					{
						sql.Append(" AND GD.GroutingDate >= :GroutingDateBegin");
						parameters.Add(new OracleParameter(":GroutingDateBegin", OracleDbType.Date, se.GroutingDateBegin.Value, ParameterDirection.Input));
					}
					// 注浆日期-结束
					if (se.GroutingDateEnd.HasValue)
					{
						sql.Append(" AND GD.GroutingDate <= :GroutingDateEnd");
						parameters.Add(new OracleParameter(":GroutingDateEnd", OracleDbType.Date, se.GroutingDateEnd.Value, ParameterDirection.Input));
					}
					// 注浆批次
					if (se.GroutingBatchNo.HasValue)
					{
						sql.Append(" AND GD.GroutingBatchNo = :GroutingBatchNo");
						parameters.Add(new OracleParameter(":GroutingBatchNo", OracleDbType.Int32, se.GroutingBatchNo, ParameterDirection.Input));
					}
					//PDA 注浆日期-开始与结束
					if (!string.IsNullOrEmpty(se.GroutingDateBeginPDA))
					{
						sql.Append(" AND GD.GroutingDate >= TO_DATE(:GroutingDateBeginPDA, 'yyyy-mm-dd hh24:mi:ss')");
						parameters.Add(new OracleParameter(":GroutingDateBeginPDA", OracleDbType.Varchar2, se.GroutingDateBeginPDA, ParameterDirection.Input));
					}
					if (!string.IsNullOrEmpty(se.GroutingDateEndPDA))
					{
						sql.Append(" AND GD.GroutingDate <= TO_DATE(:GroutingDateEndPDA, 'yyyy-mm-dd hh24:mi:ss')");
						parameters.Add(new OracleParameter(":GroutingDateEndPDA", OracleDbType.Varchar2, se.GroutingDateEndPDA, ParameterDirection.Input));
					}
					// 注浆模具编号
					if (!string.IsNullOrEmpty(se.GroutingMouldCode))
					{
						sql.Append(" AND INSTR(GDD.GroutingMouldCode, :GroutingMouldCode) > 0");
						parameters.Add(new OracleParameter(":GroutingMouldCode", OracleDbType.NVarchar2, se.GroutingMouldCode, ParameterDirection.Input));
					}
					// 产品编号
					if (!string.IsNullOrEmpty(se.GoodsCode))
					{
						sql.Append(" AND INSTR(GDD.GoodsCode, :GoodsCode) > 0");
						parameters.Add(new OracleParameter(":GoodsCode", OracleDbType.NVarchar2, se.GoodsCode, ParameterDirection.Input));
					}
					// 产品名称
					if (!string.IsNullOrEmpty(se.GoodsName))
					{
						sql.Append(" AND INSTR(GDD.GoodsName, :GoodsName) > 0");
						parameters.Add(new OracleParameter(":GoodsName", OracleDbType.NVarchar2, se.GoodsName, ParameterDirection.Input));
					}
					// 备注
					if (!string.IsNullOrEmpty(se.Remarks))
					{
						sql.Append(" AND INSTR(GDD.Remarks, :Remarks) > 0");
						parameters.Add(new OracleParameter(":Remarks", OracleDbType.NVarchar2, se.Remarks, ParameterDirection.Input));
					}
					// 成型工号
					if (!string.IsNullOrEmpty(se.GroutingUserCode))
					{
						// 成型工号不要模糊查询
						//sql.Append(" AND INSTR(GDD.UserCode, :GroutingUserCode) > 0");
						sql.Append(" AND GDD.UserCode = :GroutingUserCode");
						parameters.Add(new OracleParameter(":GroutingUserCode", OracleDbType.NVarchar2, se.GroutingUserCode, ParameterDirection.Input));
					}
					// 条码
					if (!string.IsNullOrEmpty(se.BarCode))
					{
						sql.Append(" AND INSTR(GDD.BarCode, :BarCode) > 0");
						parameters.Add(new OracleParameter(":BarCode", OracleDbType.NVarchar2, se.BarCode, ParameterDirection.Input));
					}
					// 交坯时间-开始
					if (se.DeliverMudDateBegin.HasValue)
					{
						sql.Append(" AND GDD.DeliverTime >= :DMCreateTimeBegin");
						parameters.Add(new OracleParameter(":DMCreateTimeBegin", OracleDbType.Date, se.DeliverMudDateBegin.Value, ParameterDirection.Input));
					}
					// 交坯时间-结束
					if (se.DeliverMudDateEnd.HasValue)
					{
						sql.Append(" AND GDD.DeliverTime < :DMCreateTimeEnd");
						parameters.Add(new OracleParameter(":DMCreateTimeEnd", OracleDbType.Date, se.DeliverMudDateEnd.Value.AddDays(1), ParameterDirection.Input));
					}
					//PDA 交坯时间-开始与结束
					if (!string.IsNullOrEmpty(se.DeliverMudDateBeginPDA))
					{
						sql.Append(" AND GDD.DeliverTime >= TO_DATE(:DeliverMudDateBeginPDA, 'yyyy-mm-dd hh24:mi:ss')");
						parameters.Add(new OracleParameter(":DeliverMudDateBeginPDA", OracleDbType.Varchar2, se.DeliverMudDateBeginPDA, ParameterDirection.Input));
					}
					if (!string.IsNullOrEmpty(se.DeliverMudDateEndPDA))
					{
						sql.Append(" AND GDD.DeliverTime < TO_DATE(:DeliverMudDateEndPDA, 'yyyy-mm-dd hh24:mi:ss')");
						parameters.Add(new OracleParameter(":DeliverMudDateEndPDA", OracleDbType.Varchar2, se.DeliverMudDateEndPDA, ParameterDirection.Input));
					}
				}

				sql.Append(" GROUP BY GDD.GroutingLineCode, GDD.GroutingLineName, GDD.GroutingDate, GDD.GroutingBatchNo,GDD.DeliverTime, GDD.UserCode, " +
							"       GDD.GoodsCode, GDD.GoodsName, GDD.GroutingMouldCode, GMS.GMouldStatusName, GDD.GroutingCount, mu.username," +
							"       GDD.Remarks, GMT.GMouldTypeName, GDD.BarCode, P.ProcedureName, IP.ProcedureTime, GDD.IsPublicBody");
				sql.Append(" ) ");

				// 生产工号
				if (se != null && !string.IsNullOrEmpty(se.WorkUserCode))
				{
					//sql.Append(" AND EXISTS (SELECT 1");
					//sql.Append("               FROM TP_PM_PRODUCTIONDATA PPD");
					//sql.Append("              WHERE PPD.AccountID = :AccountID");
					//sql.Append("                AND PPD.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'");
					//sql.Append("                AND PPD.BarCode = GDD.BarCode");
					//sql.Append("                AND INSTR(PPD.UserCode, :WorkUserCode) > 0");
					//sql.Append("            )");
					//sql.Append(" AND INSTR(PDW.UserCode, :WorkUserCode) > 0");
					sql.Append(" WHERE INSTR(WorkUserCodes, :WorkUserCode) > 0");
					parameters.Add(new OracleParameter(":WorkUserCode", OracleDbType.NVarchar2, se.WorkUserCode, ParameterDirection.Input));
				}

				//sql.Append(" ORDER BY GDD.GroutingDate, GDD.GroutingLineCode, GDD.GroutingMouldCode");
				sql.Append(" ORDER BY GroutingDate, GroutingLineCode, GroutingBatchNo, GroutingMouldCode");
				DataTable data = conn.GetSqlResultToDt(sql.ToString(), parameters.ToArray());

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
					return sre;
				}
				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 获取查询sql
		/// </summary>
		/// <returns>sql</returns>
		private static string GetFPM0202SSQL()
		{
			string selSql =
				"SELECT GroutingLineCode, GroutingLineName, GroutingDate,GroutingBatchNo, UserCode, " +
				"       GoodsCode, GoodsName, GroutingMouldCode, GMouldStatusName," +
				"       GroutingCount, Remarks, GMouldTypeName, BarCode, ProcedureName, ProcedureTime," +
				"       IsPublicBody," +
				"       DMCreateTime,MONITORName," +
				"       WorkUserCodes,BarCodeRecord" +
				"  FROM (" +
				  //"SELECT GDD.GroutingDailyDetailID," +
				  //"       GDD.GroutingDailyID," +
				  "SELECT " +
				// 成型线编码
				"       GDD.GroutingLineCode," +
				// 成型线名称
				"       GDD.GroutingLineName," +
				// 注浆日期
				"       GDD.GroutingDate," +
				// 注浆批次
				"       GDD.GroutingBatchNo," +
				// 成型工号
				"       GDD.UserCode," +
				// 产品编码
				"       GDD.GoodsCode," +
				// 产品名称
				"       GDD.GoodsName," +
				// 注浆线模具编码
				"       GDD.GroutingMouldCode," +
				// 模具状态
				"       GMS.GMouldStatusName," +
				// 注浆次数
				"       GDD.GroutingCount," +
				// 备注
				"       GDD.Remarks," +
				// 成型线类型
				"       GMT.GMouldTypeName," +
				// 成型班长
				"       mu.username as MONITORName," +
				// 绑定条码
				"       GDD.BarCode," +
				// 当前工序名称
				"       P.ProcedureName," +
				// 当前工序完成时间
				"       IP.ProcedureTime," +
				// 公坯标识
				"       GDD.IsPublicBody," +
				// 交坯时间
				"       GDD.DeliverTime AS DMCreateTime," +
			//"       GDD.deliverflag," + 
			// 生产工号
			//"       WMSYS.WM_CONCAT(DISTINCT TO_CHAR(PDW.UserCode)) AS WorkUserCodes," +
			//"       WMSYS.WM_CONCAT(DISTINCT TO_CHAR(BCR.BarCode)) AS BarCodeRecord" +
			"       listagg(to_char(PDW.UserCode), ',')  within GROUP(ORDER BY PDW.ProductionDataID)  AS WorkUserCodes," +
				"       listagg(to_char(BCR.BarCode), ',')  within GROUP(ORDER BY BCR.CREATETIME)  AS BarCodeRecord" +
				// 注浆日报
				"  FROM TP_PM_GroutingDaily GD" +
				// 注浆日报明细表
				" INNER JOIN TP_PM_GroutingDailyDetail GDD" +
				"    ON GD.GroutingDailyID = GDD.GroutingDailyID" +
				// 成型线类型
				" INNER JOIN TP_MST_GMouldType GMT" +
				"    ON GD.GMouldTypeID = GMT.GMouldTypeID" +
				// 模具状态
				" INNER JOIN TP_SYS_GMouldStatus GMS" +
				"    ON GMS.GMouldStatusID = GDD.GMouldStatus" +
				// 成型线
				" LEFT JOIN tp_pc_groutingline gl" +
				"    ON gl.groutinglineid = GDD.GroutingLineID" +
				// 成型班长
				" LEFT JOIN tp_mst_user mu" +
				"    ON mu.userid = gl.MONITORID" +
				// 历史条码
				"  LEFT JOIN TP_PM_BarCodeRecord BCR" +
				"    ON BCR.FinalBarCode = GDD.BarCode" +
				// 当前工序
				"  LEFT JOIN TP_PM_InProduction IP" +
				"    ON IP.BarCode = GDD.BarCode" +
				// 当前工序名
				"  LEFT JOIN TP_PC_Procedure P" +
				"    ON P.ProcedureID = IP.ProcedureID" +
				// 生产工号
				"  LEFT JOIN TP_PM_ProductionData PDW" +
				"    ON PDW.BarCode = GDD.BarCode" +
				"   AND PDW.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
				// 账套
				" WHERE GD.AccountID = :AccountID" +
				"   AND GD.ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'" +
				"   AND LENGTH(GDD.BarCode) > 0";
			//// 成型线操作权限
			//"   AND EXISTS (SELECT UP.PurviewID" +
			//"          FROM TP_MST_UserPurview UP" +
			//"         WHERE UP.PurviewType = '" + (int)Constant.PurviewType.OperateGroutingLine + "'" +
			//"           AND (UP.PurviewID = -1 OR UP.PurviewID = GD.GroutingLineID)" +
			//"           AND UP.UserId = :UPUserId)";
			return selSql;
		}

		/// <summary>
		/// 更换条码
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="barcode">原条码</param>
		/// <param name="newBarcode">新条码</param>
		/// <param name="remarks">备注</param>
		/// <returns>操作结果</returns>
		public static ServiceResultEntity SetFPM0201Data(SUserInfo user, string barcode, string newBarcode, string remarks, string groutingUserCode, string goodsCode)
		{
			IDBTransaction tran = null;
			try
			{
				ServiceResultEntity sre = new ServiceResultEntity();
				if (string.IsNullOrWhiteSpace(barcode) ||
					string.IsNullOrWhiteSpace(newBarcode) ||
					barcode == newBarcode)
				{
					sre.Status = Constant.ServiceResultStatus.NoModifyData;
					return sre;
				}

				tran = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);

				#region 校验条码
				/*
				//string message = null;
				//bool check = PMModuleLogic.CheckBarcode2(tran, user, barcode, newBarcode, out message);
				//if (!check)
				//{
				//	sre.Status = Constant.ServiceResultStatus.Other;
				//	sre.Message = message;
				//	return sre;
				//}

				// todo 条码状态表
				string checkBarcodeSql =
					"SELECT UBC.BarCode FROM TP_PM_UsedBarCode UBC " +
					" WHERE UBC.BarCode = :BarCode";
				OracleParameter[] checkBarcodeParas = new OracleParameter[]
				{
					new OracleParameter(":BarCode", OracleDbType.NVarchar2, barcode, ParameterDirection.Input),
				};
				object objBarCode = tran.GetSqlResultToObj(checkBarcodeSql, checkBarcodeParas);
				if (objBarCode == null || objBarCode.ToString().Length == 0)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 1;
					sre.Message = string.Format("原条码（{0}）不存在", barcode);
					return sre;
				}

				OracleParameter[] checkBarcodeParas1 = new OracleParameter[]
				{
					new OracleParameter(":BarCode", OracleDbType.NVarchar2, newBarcode, ParameterDirection.Input),
				};
				objBarCode = tran.GetSqlResultToObj(checkBarcodeSql, checkBarcodeParas1);
				if (objBarCode != null && objBarCode.ToString().Length > 0)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 2;
					sre.Message = string.Format("新条码（{0}）已被使用", newBarcode);
					return sre;
				}
				*/
				#endregion 校验条码

				OracleParameter[] paras = new OracleParameter[]
				{
					new OracleParameter("in_BarCode", OracleDbType.NVarchar2, barcode, ParameterDirection.Input),
					new OracleParameter("in_NewBarCode", OracleDbType.NVarchar2, newBarcode, ParameterDirection.Input),
					new OracleParameter("in_Remarks", OracleDbType.NVarchar2, remarks, ParameterDirection.Input),
					new OracleParameter("in_AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input),
					new OracleParameter("in_CreateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input),
					new OracleParameter("out_Result", OracleDbType.Varchar2, 10, null, ParameterDirection.Output),
					new OracleParameter("out_Barcode", OracleDbType.NVarchar2, 50, null, ParameterDirection.Output),
					new OracleParameter("in_GroutingUserCode", OracleDbType.Varchar2, groutingUserCode, ParameterDirection.Input),
					new OracleParameter("in_GoodsCode", OracleDbType.Varchar2, goodsCode, ParameterDirection.Input),
				};
				DataSet ds = tran.ExecStoredProcedure("PRO_PM_ReplacedBarCode", paras);

				//-- 1.1 原条码不存在
				//-- 1.2 原条码属于其他账套
				//-- 1.3 原条码已被替换
				//-- 1.4 产品已登窑
				//-- 1.5 产品已包装
				//-- 1.6 产品已成型报损
				//-- 1.7 未交坯不可替换
				//-- 2.1 新条码属于其他账套
				//-- 2.2 新条码已被使用
				//-- 2.3 新条码已被替换
				//-- 3.1 条码对应成型工号不正确
				//-- 3.2 替换工号没有操作成型线权限
				//-- 3.3 无注浆信息
				//-- 3.4 产品编码与条码不一致
				//-- 3.5 产品不是在产产品

				string out_Result = paras[5].Value.ToString();
				if (out_Result != "0")
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					switch (out_Result)
					{
						case "1.1":
							sre.OtherStatus = 1;
							sre.Message = "原产品条码不存在";
							break;
						case "1.2":
							sre.OtherStatus = 2;
							sre.Message = "原产品条码属于其他账套";
							break;
						case "1.3":
							sre.OtherStatus = 3;
							sre.Message = "原产品条码已被替换为（" + paras[6].Value.ToString() + ")";
							break;
						case "1.4":
							sre.OtherStatus = 7;
							sre.Message = "产品已经过工序（" + paras[6].Value.ToString() + ")";
							break;
						case "1.5":
							sre.OtherStatus = 13;
							sre.Message = "产品已完成生产流程，不能替换";
							break;
						case "1.6":
							sre.OtherStatus = 14;
							sre.Message = "产品已成型报损，不能替换";
							break;
						case "1.7":
							sre.OtherStatus = 15;
							sre.Message = "产品未交坯，不能替换";
							break;
						case "2.1":
							sre.OtherStatus = 4;
							sre.Message = "新产品条码属于其他账套";
							break;
						case "2.2":
							sre.OtherStatus = 5;
							sre.Message = "新产品条码已被使用";
							break;
						case "2.3":
							sre.OtherStatus = 6;
							sre.Message = "新产品条码已被替换为（" + paras[6].Value.ToString() + ")";
							break;
						case "3.1":
							sre.OtherStatus = 8;
							sre.Message = "条码对应成型工号不正确";
							break;
						case "3.2":
							sre.OtherStatus = 9;
							sre.Message = "替换工号没有操作成型线权限";
							break;
						case "3.3":
							sre.OtherStatus = 10;
							sre.Message = "无注浆信息";
							break;
						case "3.4":
							sre.OtherStatus = 11;
							sre.Message = "产品编码与条码不一致";
							break;
						case "3.5":
							sre.OtherStatus = 12;
							sre.Message = "产品不是在产产品";
							break;
						default:
							break;
					}
				}

				tran.Commit();
				return sre;
			}
			catch (Exception ex)
			{
				if (tran != null &&
					tran.ConnState == ConnectionState.Open)
				{
					tran.Rollback();
				}
				throw ex;
			}
			finally
			{
				if (tran != null &&
					tran.ConnState == ConnectionState.Open)
				{
					tran.Disconnect();
				}
			}
		}

		/// <summary>
		/// 取得FPM0203画面（条码变更）的查询数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetFPM0203SData(SUserInfo user, FPM0203_SE se)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				List<OracleParameter> parameters = new List<OracleParameter>();
				StringBuilder sql = new StringBuilder(PMModuleLogic.GetFPM0203SSQL());
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":CreateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input));

				if (se != null)
				{
					// 变更日期-开始
					if (se.DateBegin.HasValue)
					{
						sql.Append(" AND BCR.CreateTime >= :DateBegin");
						parameters.Add(new OracleParameter(":DateBegin", OracleDbType.Date, se.DateBegin.Value, ParameterDirection.Input));
					}
					// 变更日期-结束
					if (se.DateEnd.HasValue)
					{
						sql.Append(" AND BCR.CreateTime <= :DateEnd");
						parameters.Add(new OracleParameter(":DateEnd", OracleDbType.Date, se.DateEnd.Value.AddDays(1), ParameterDirection.Input));
					}
					// 成型线编码
					if (!string.IsNullOrEmpty(se.GroutingLineCode))
					{
						sql.Append(" AND INSTR(GD.GroutingLineCode, :GroutingLineCode) > 0");
						parameters.Add(new OracleParameter(":GroutingLineCode", OracleDbType.NVarchar2, se.GroutingLineCode, ParameterDirection.Input));
					}
					// 成型线名称
					if (!string.IsNullOrEmpty(se.GroutingLineName))
					{
						sql.Append(" AND INSTR(GD.GroutingLineName, :GroutingLineName) > 0");
						parameters.Add(new OracleParameter(":GroutingLineName", OracleDbType.NVarchar2, se.GroutingLineName, ParameterDirection.Input));
					}
					// 成型线类别
					if (se.GMouldTypeID.HasValue)
					{
						sql.Append(" AND GD.GMouldTypeID = :GMouldTypeID");
						parameters.Add(new OracleParameter(":GMouldTypeID", OracleDbType.Int32, se.GMouldTypeID.Value, ParameterDirection.Input));
					}
					// 注浆日期-开始
					if (se.GroutingDateBegin.HasValue)
					{
						sql.Append(" AND GD.GroutingDate >= :GroutingDateBegin");
						parameters.Add(new OracleParameter(":GroutingDateBegin", OracleDbType.Date, se.GroutingDateBegin.Value, ParameterDirection.Input));
					}
					// 注浆日期-结束
					if (se.GroutingDateEnd.HasValue)
					{
						sql.Append(" AND GD.GroutingDate <= :GroutingDateEnd");
						parameters.Add(new OracleParameter(":GroutingDateEnd", OracleDbType.Date, se.GroutingDateEnd.Value, ParameterDirection.Input));
					}
					// 注浆批次
					if (se.GroutingBatchNo.HasValue)
					{
						sql.Append(" AND GD.GroutingBatchNo = :GroutingBatchNo");
						parameters.Add(new OracleParameter(":GroutingBatchNo", OracleDbType.Int32, se.GroutingBatchNo, ParameterDirection.Input));
					}
					// 注浆模具编号
					if (!string.IsNullOrEmpty(se.GroutingMouldCode))
					{
						sql.Append(" AND INSTR(GDD.GroutingMouldCode, :GroutingMouldCode) > 0");
						parameters.Add(new OracleParameter(":GroutingMouldCode", OracleDbType.NVarchar2, se.GroutingMouldCode, ParameterDirection.Input));
					}
					// 产品编号
					if (!string.IsNullOrEmpty(se.GoodsCode))
					{
						sql.Append(" AND INSTR(GDD.GoodsCode, :GoodsCode) > 0");
						parameters.Add(new OracleParameter(":GoodsCode", OracleDbType.NVarchar2, se.GoodsCode, ParameterDirection.Input));
					}
					// 产品名称
					if (!string.IsNullOrEmpty(se.GoodsName))
					{
						sql.Append(" AND INSTR(GDD.GoodsName, :GoodsName) > 0");
						parameters.Add(new OracleParameter(":GoodsName", OracleDbType.NVarchar2, se.GoodsName, ParameterDirection.Input));
					}
					// 备注
					if (!string.IsNullOrEmpty(se.Remarks))
					{
						sql.Append(" AND INSTR(BCR.Remarks, :Remarks) > 0");
						parameters.Add(new OracleParameter(":Remarks", OracleDbType.NVarchar2, se.Remarks, ParameterDirection.Input));
					}
					// 成型工号
					if (!string.IsNullOrEmpty(se.GroutingUserCode))
					{
						// 成型工号不要模糊查询
						sql.Append(" AND INSTR(GDD.UserCode, :GroutingUserCode) > 0");
						parameters.Add(new OracleParameter(":GroutingUserCode", OracleDbType.NVarchar2, se.GroutingUserCode, ParameterDirection.Input));
					}
				}

				sql.Append(" ORDER BY BCR.CreateTime, BCR.BarCode");
				DataTable data = conn.GetSqlResultToDt(sql.ToString(), parameters.ToArray());

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
					return sre;
				}
				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 取得FPM0203画面（条码变更）的查询数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="barcode">条码</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetFPM0203SData(SUserInfo user, string barcode)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				List<OracleParameter> parameters = new List<OracleParameter>();
				StringBuilder sql = new StringBuilder(PMModuleLogic.GetFPM0203SSQL());
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));
				parameters.Add(new OracleParameter(":CreateUserID", OracleDbType.Int32, user.UserID, ParameterDirection.Input));

				//if (!string.IsNullOrWhiteSpace(barcode))
				{
					sql.Append(" AND BCR.BarCode = :BarCode");
					parameters.Add(new OracleParameter(":BarCode", OracleDbType.Varchar2, barcode, ParameterDirection.Input));
				}

				sql.Append(" ORDER BY BCR.CreateTime, BCR.BarCode");
				DataTable data = conn.GetSqlResultToDt(sql.ToString(), parameters.ToArray());

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
					return sre;
				}
				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 获取查询sql
		/// </summary>
		/// <returns>sql</returns>
		private static string GetFPM0203SSQL()
		{
			string selSql =
				"SELECT BCR.BarCode," +
				"       BCR.NewBarCode," +
				// 创建时间
				"       BCR.CreateTime," +
				// 创建工号
				"       U.UserName AS CreateUser," +
				// 备注
				"       BCR.Remarks," +
				// 工序
				"       P.ProcedureCode," +
				"       P.ProcedureName," +
				// 成型线编码
				"       GDD.GroutingLineCode," +
				// 成型线名称
				"       GDD.GroutingLineName," +
				// 注浆日期
				"       GDD.GroutingDate," +
				// 注浆批次
				"       GDD.GroutingBatchNo," +
				// 成型工号
				"       GDD.UserCode," +
				// 产品编码
				"       GDD.GoodsCode," +
				// 产品名称
				"       GDD.GoodsName," +
				// 注浆线模具编码
				"       GDD.GroutingMouldCode," +
				// 模具状态
				"       GMS.GMouldStatusName," +
				// 注浆次数
				"       GDD.GroutingCount," +
				// 成型班长
				"       mu.username as MONITORName," +
				// 成型线类型
				"       GMT.GMouldTypeName " +
				"  FROM TP_PM_BarCodeRecord BCR" +
				" INNER JOIN TP_PM_GroutingDailyDetail GDD" +
				"    ON GDD.BarCode = BCR.FinalBarCode" +
				" INNER JOIN TP_PM_GroutingDaily GD" +
				"    ON GD.GroutingDailyID = GDD.GroutingDailyID" +
				" INNER JOIN TP_MST_User U" +
				"    ON U.UserID = BCR.CreateUserID" +
				// 成型线类型
				" INNER JOIN TP_MST_GMouldType GMT" +
				"    ON GD.GMouldTypeID = GMT.GMouldTypeID" +
				// 模具状态
				" INNER JOIN TP_SYS_GMouldStatus GMS" +
				"    ON GMS.GMouldStatusID = GDD.GMouldStatus" +
				// 成型线
				" LEFT JOIN tp_pc_groutingline gl" +
				"    ON gl.groutinglineid = GDD.GroutingLineID" +
				// 成型班长
				" LEFT JOIN tp_mst_user mu" +
				"    ON mu.userid = gl.MONITORID" +
				// 工序
				"  LEFT JOIN TP_PC_Procedure P" +
				"    ON P.ProcedureID = BCR.ProcedureID" +
				// 账套
				" WHERE BCR.AccountID = :AccountID" +
				"   AND (BCR.CreateUserID = :CreateUserID OR " +
				"        EXISTS (SELECT UP.PurviewID" +
				"          FROM TP_MST_UserPurview UP" +
				"         WHERE UP.PurviewType = '" + (int)Constant.PurviewType.OperateUser + "'" +
				"           AND (UP.PurviewID = -1 OR UP.PurviewID = BCR.CreateUserID)" +
				"           AND UP.UserId = :CreateUserID))";

			return selSql;
		}
		#endregion 条码变更

		#region 开模报损
		/// <summary>
		/// 保存开模报损信息
		/// </summary>
		/// <param name="user"></param>
		/// <param name="groutingInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity SaveScrapKm(ClientRequestEntity cre, SUserInfo userInfo)
		{
			IDBTransaction tran = null;
			string sqlString = string.Empty;
			DataSet groutingInfo = cre.Data;
			try
			{
				ServiceResultEntity sre = new ServiceResultEntity();
				if (groutingInfo == null ||
					groutingInfo.Tables.Count < 2 ||
					groutingInfo.Tables[0].Rows.Count < 1 ||
					groutingInfo.Tables[1].Rows.Count < 1)
				{
					sre.Status = Constant.ServiceResultStatus.NoModifyData;
					return sre;
				}

				tran = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				int executeResult = 0;

				#region 校验时间戳
				// 校验时间戳
				DataRow gdDataRow = groutingInfo.Tables[0].Rows[0];
				sqlString =
					"SELECT GroutingDailyID" +
					"  FROM TP_PM_GroutingDaily" +
					" WHERE GroutingDailyID = :GroutingDailyID" +
					"   AND OPTimeStamp = :OPTimeStamp" +
					"   AND ValueFlag = '" + (int)Constant.ValueFlag.Effective + "'";
				OracleParameter[] checkParas = new OracleParameter[]
				{
					new OracleParameter(":GroutingDailyID", OracleDbType.Int32, gdDataRow["GroutingDailyID"], ParameterDirection.Input),
					new OracleParameter(":OPTimeStamp", OracleDbType.TimeStamp, gdDataRow["OPTimeStamp"], ParameterDirection.Input),
				};
				object checkResult = tran.GetSqlResultToObj(sqlString, checkParas);
				if (checkResult == null)
				{
					sre.Status = Constant.ServiceResultStatus.DataChanged;
					return sre;
				}
				#endregion 校验时间戳

				#region 更新注浆日报明细表
				string errorMsg = string.Empty;
				foreach (DataRow detailDataRow in groutingInfo.Tables[1].Rows)
				{
					if (detailDataRow.RowState != DataRowState.Modified)
					{
						continue;
					}
					#region 1、判断是否符合报损条件（未注浆，交坯之后不允许报损,是否进行过了报损）
					sqlString = "SELECT GroutingFlag,DeliverFlag,ScrapFlag,GroutingMouldCode\n" +
								 " FROM TP_PM_GroutingDailyDetail \n" +
								 " WHERE AccountID = :AccountID\n" +
								 " AND GroutingDailyDetailID = :GroutingDailyDetailID\n";
					OracleParameter[] paras = new OracleParameter[] {
							new OracleParameter(":AccountID",OracleDbType.Int32, userInfo.AccountID, ParameterDirection.Input),
							new OracleParameter(":GroutingDailyDetailID",OracleDbType.Int32, detailDataRow["GroutingDailyDetailID"], ParameterDirection.Input),
					};
					DataTable returnTable = tran.GetSqlResultToDt(sqlString, paras);

					// 编码不存在
					if (returnTable.Rows.Count == 0)
					{
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.Result = -99;
						return sre;
					}
					// 未注浆
					if ("0".Equals(returnTable.Rows[0]["GroutingFlag"]))
					{
						sre.Result = -100;
						errorMsg += "模具：" + returnTable.Rows[0]["GroutingMouldCode"] + "未注浆";
						continue;
					}
					if (detailDataRow["ScrapFlag"].ToString() == "1")
					{

						// 已经交坯
						if ("1".Equals(returnTable.Rows[0]["DeliverFlag"]))
						{
							sre.Result = -101;
							errorMsg += "模具：" + returnTable.Rows[0]["GroutingMouldCode"] + "已经交坯";
							continue;
						}
						string sqlStrings = @"SELECT 1 FROM TP_PM_INPRODUCTION
                                                    WHERE AccountID = :AccountID
                                                    AND BARCODE = :BARCODE ";
						OracleParameter[] parass = new OracleParameter[] {
							new OracleParameter(":AccountID",OracleDbType.Int32, userInfo.AccountID, ParameterDirection.Input),
							new OracleParameter(":BARCODE",OracleDbType.Varchar2, detailDataRow["BARCODE"].ToString(), ParameterDirection.Input),
					};
						string returnTables = tran.GetSqlResultToStr(sqlStrings, parass);
						// 已经交坯
						if (returnTables != null && returnTables != "" )
						{
							sre.Result = -101;
							errorMsg += "模具：" + returnTable.Rows[0]["GroutingMouldCode"] + "流进工序";
							continue;
						}
					}
					#endregion
					sqlString = "UPDATE TP_PM_GroutingDailyDetail" +
							   "   SET ScrapFlag = :ScrapFlag, " +
							   "       ScrapTime = case when :ScrapFlag= '1' and ScrapFlag = '0' then sysdate when :ScrapFlag= '0' then null else ScrapTime end, " +
							   "       ScrapUser = case when :ScrapFlag= '1' and ScrapFlag = '0' then :UpdateUserID when :ScrapFlag= '0' then null else ScrapUser end, " +
							   "       ScrapType = :ScrapType, " +
							   "       SReasonID = :SReasonID, " +
							   "       Remarks = :Remarks," +
							   "       UpdateUserID = :UpdateUserID" +
							   " WHERE GroutingDailyDetailID = :GroutingDailyDetailID";
					OracleParameter[] oracleParameters = new OracleParameter[]
					 {
						new OracleParameter(":ScrapFlag", OracleDbType.Char, detailDataRow["ScrapFlag"], ParameterDirection.Input),
						new OracleParameter(":ScrapType", OracleDbType.Char, "0", ParameterDirection.Input),    // 开模报损
                        new OracleParameter(":SReasonID", OracleDbType.Int32, detailDataRow["SReasonID"], ParameterDirection.Input),
						new OracleParameter(":GroutingDailyDetailID", OracleDbType.Int32, detailDataRow["GroutingDailyDetailID"], ParameterDirection.Input),
						new OracleParameter(":Remarks", OracleDbType.NVarchar2, detailDataRow["Remarks"], ParameterDirection.Input),
						new OracleParameter(":UpdateUserID", OracleDbType.Int32, userInfo.UserID, ParameterDirection.Input),
					};
					executeResult = tran.ExecuteNonQuery(sqlString, oracleParameters);
					if (executeResult <= 0)
					{
						sre.Status = Constant.ServiceResultStatus.NoModifyData;
						return sre;
					}
				}
				#endregion 更新注浆日报明细表
				if (!string.IsNullOrWhiteSpace(errorMsg))
				{
					sre.Message = errorMsg;
				}
				tran.Commit();
				return sre;
			}
			catch (Exception ex)
			{
				if (tran != null &&
					tran.ConnState == ConnectionState.Open)
				{
					tran.Rollback();
				}
				throw ex;
			}
			finally
			{
				if (tran != null &&
					tran.ConnState == ConnectionState.Open)
				{
					tran.Disconnect();
				}
			}
		}
		#endregion

		#endregion 条码管理

		#region 生产数据查询

		#region 生产数据查询（干补）

		/// <summary>
		/// 取得FPM0202画面（条码变更用条码查询）的查询数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetProductionData8(SUserInfo user, ClientRequestEntity cre)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				conn.Open();

				//SearchProductionDataEntity searchEntity = cre.Request as SearchProductionDataEntity;
				//if (searchEntity == null)
				//{
				//    return null;
				//}

				string sqlString = "SELECT pd.CreateTime\n" +
				"      ,pd.UpdateTime\n" +
				"      ,pd.ProductionDataID\n" +
				"      ,pd.ProductionLineCode\n" +
				"      ,pd.BarCode\n" +
				"      ,pd.GoodsCode\n" +
				"      ,pd.GoodsName\n" +
				"      ,pd.UserCode\n" +
				"      ,pd.IsPublicBody\n" +
				"      ,decode(pd.ProcedureModel, '1', '计数模型', '检验模型') AS ProcedureModel\n" +
				"      ,pmt.ProcedureModelTypeName\n" +
				//"      ,decode(pd.PieceType, '1', '不计件', '同工种策略') AS PieceType\n" +
				//"      ,pd.IsReworked\n" +
				//"      ,gl.GoodsLevelName AS GoodsGrade\n" +
				"      ,org.OrganizationName\n" +
				//"      ,pd.Remarks\n" +
				//"      ,pd.KilnID\n" +
				//"      ,pd.KilnCode\n" +
				//"      ,pd.KilnName\n" +
				//"      ,pd.KilnCarID\n" +
				//"      ,pd.KilnCarCode\n" +
				//"      ,pd.KilnCarName\n" +
				//"      ,pd.KilnCarPosition\n" +
				//"      ,dd.DictionaryValue KilnCarPositionName\n" +
				"      ,gt.GoodsTypeName\n" +
				"      ,u.usercode AS barusercode\n" +
				"      ,pd.GroutingUserCode\n" +
				"      ,pd.GroutingMouldCode\n" +
				"      ,pd.GroutingDate\n" +
				"      ,pd.GroutingNum\n" +
				"      ,u.username AS barusername\n" +
				//"      ,decode(pd.Goodsleveltypeid,\n" +
				//"              '4',\n" +
				//"              '正品',\n" +
				//"              '5',\n" +
				//"              '副品',\n" +
				//"              '6',\n" +
				//"              '重烧',\n" +
				//"              '7',\n" +
				//"              '次品',\n" +
				//"              '') AS Goodsleveltype\n" +
				"      ,REPLACE((l.Logoname || '[' || l.Logocode || ']'), '[]', '') AS LogoCodeName\n" +
				"      ,pd.SpecialRepairFlag\n" +
				"      ,pcp.procedurename inprocedurename\n" +
				"      ,(SELECT pp.procedurename\n" +
				"          FROM tp_pc_procedure pp\n" +
				"         WHERE pp.procedureid =\n" +
				"               fun_rpt_getprevprocedureidall(pd.productiondataid, pd.barcode)) procedurename\n" +
				"  FROM TP_PM_ProductionData pd\n" +
				"  LEFT JOIN tp_pm_inproduction inp\n" +
				"    ON inp.barcode = pd.barcode\n" +
				"  LEFT JOIN tp_pc_procedure pcp\n" +
				"    ON pcp.procedureid = inp.procedureid\n" +
				"  LEFT JOIN TP_SYS_ProcedureModelType pmt\n" +
				"    ON pd.ModelType = pmt.PROCEDUREMODELTYPEID\n" +
				"  LEFT JOIN TP_MST_ORGANIZATION org\n" +
				"    ON pd.OrganizationID = org.OrganizationID\n" +
				//"  LEFT JOIN TP_MST_DataDictionary dd\n" +
				//"    ON pd.KilnCarPosition = dd.DictionaryID\n" +
				//"  LEFT JOIN TP_MST_GoodsLevel gl\n" +
				//"    ON pd.Goodslevelid = gl.Goodslevelid\n" +
				"  LEFT JOIN TP_MST_Goods g\n" +
				"    ON pd.GoodsID = g.GoodsID\n" +
				"  LEFT JOIN TP_MST_GoodsType gt\n" +
				"    ON g.GoodsTypeID = gt.GoodsTypeID\n" +
				"  LEFT JOIN TP_MST_USER u\n" +
				"    ON pd.Createuserid = u.userid\n" +
				"  LEFT JOIN TP_MST_Logo l\n" +
				"    ON pd.logoid = l.logoid\n" +
				" WHERE pd.accountID = :accountID and pd.ValueFlag = '1'\n" +
				"   AND pd.ProcedureID = :procedureID\n" +
				"   AND (:barCode IS NULL OR :barCode IS NULL OR\n" +
				"       instr(pd.BarCode, :barCode) > 0)\n" +
				"   AND (:goodsCode IS NULL OR :goodsCode IS NULL OR\n" +
				"       instr(pd.goodsCode, :goodsCode) > 0)\n" +
				"   AND (:goodsName IS NULL OR :goodsName IS NULL OR\n" +
				"       instr(pd.goodsName, :goodsName) > 0)\n" +
				"   AND (:userCode IS NULL OR :userCode IS NULL OR\n" +
				"       instr(pd.userCode, :userCode) > 0)\n" +
				"   AND (:organizationID = 0 OR :organizationID IS NULL OR\n" +
				"       pd.organizationID = :organizationID)\n" +
				"   AND (pd.CreateTime >= :begindate AND pd.CreateTime < :enddate)\n" +
				//"   AND (:isReworked IS NULL OR :isReworked IS NULL OR\n" +
				//"       (instr(:isReworked, pd.isReworked) > 0))\n" +
				//"   AND (:pKilnCode IS NULL OR :pKilnCode IS NULL OR\n" +
				//"       pd.KilnCode = :pKilnCode)\n" +
				//"   AND (:pKilnCarCode IS NULL OR :pKilnCarCode IS NULL OR\n" +
				//"       instr(pd.KilnCarCode, :KilnCarCode) > 0)\n" +
				//"   AND (:pKilnCarPosition IS NULL OR :pKilnCarPosition IS NULL OR\n" +
				//"       pd.KilnCarPosition = :pKilnCarPosition)\n" +
				"   AND (pd.CreateUserID = :currentUserID OR EXISTS\n" +
				"        (SELECT 1\n" +
				"           FROM TP_MST_UserPurview up\n" +
				"          WHERE up.PurviewType = 4\n" +
				"            AND (up.PurviewID = -1 OR up.PurviewID = pd.CreateUserID)\n" +
				"            AND up.UserId = :currentUserID))\n" +
				//"   AND (:remarks IS NULL OR :remarks IS NULL OR\n" +
				//"       instr(pd.remarks, :remarks) > 0)\n" +
				"   AND (:goodstypecode IS NULL OR :goodstypecode IS NULL OR\n" +
				"       instr(gt.goodstypecode, :goodstypecode) > 0)";

				//IDataParameter[] paras = new OracleParameter[] 
				//{
				//    new OracleParameter(":procedureID",OracleDbType.Int32, searchEntity.ProcedureID, ParameterDirection.Input),
				//    new OracleParameter(":barCode", OracleDbType.Varchar2,searchEntity.BarCode, ParameterDirection.Input),
				//    new OracleParameter(":goodsCode", OracleDbType.Varchar2,searchEntity.GoodsCode, ParameterDirection.Input),
				//    new OracleParameter(":goodsName", OracleDbType.Varchar2,searchEntity.GoodsName, ParameterDirection.Input),
				//    new OracleParameter(":userCode", OracleDbType.Varchar2,searchEntity.UserCode, ParameterDirection.Input),
				//    new OracleParameter(":organizationID", OracleDbType.Int32,searchEntity.OrganizationID, ParameterDirection.Input),
				//    new OracleParameter(":remarks", OracleDbType.Varchar2,searchEntity.Remarks, ParameterDirection.Input),
				//    new OracleParameter(":isReworked", OracleDbType.Varchar2,searchEntity.IsRework, ParameterDirection.Input),
				//    new OracleParameter(":begindate", OracleDbType.Date,searchEntity.BeginDate, ParameterDirection.Input),
				//    new OracleParameter(":enddate", OracleDbType.Date,searchEntity.EndDate, ParameterDirection.Input),
				//    new OracleParameter(":accountID", OracleDbType.Int32,user.AccountID, ParameterDirection.Input),
				//    new OracleParameter(":userID", OracleDbType.Int32,user.UserID, ParameterDirection.Input),
				//    new OracleParameter(":kilnCode", OracleDbType.Varchar2,searchEntity.KilnCode, ParameterDirection.Input),
				//    new OracleParameter(":kilnCarCode", OracleDbType.Varchar2,searchEntity.KilnCarCode, ParameterDirection.Input),
				//    new OracleParameter(":kilnCarPosition", OracleDbType.Int32,searchEntity.KilnCarPosition, ParameterDirection.Input),
				//    new OracleParameter(":currentUserID", OracleDbType.Int32,user.UserID, ParameterDirection.Input),
				//    new OracleParameter(":goodsTypeCode", OracleDbType.Varchar2,searchEntity.GoodsTypeCode, ParameterDirection.Input),
				//};
				IDataParameter[] paras = new OracleParameter[]
				{
					new OracleParameter(":procedureID",OracleDbType.Int32, cre.Properties["ProcedureID"], ParameterDirection.Input),
					new OracleParameter(":barCode", OracleDbType.Varchar2,cre.Properties["BarCode"], ParameterDirection.Input),
					new OracleParameter(":goodsCode", OracleDbType.Varchar2,cre.Properties["GoodsCode"], ParameterDirection.Input),
					new OracleParameter(":goodsName", OracleDbType.Varchar2,cre.Properties["GoodsName"], ParameterDirection.Input),
					new OracleParameter(":userCode", OracleDbType.Varchar2,cre.Properties["UserCode"], ParameterDirection.Input),
					new OracleParameter(":organizationID", OracleDbType.Int32,cre.Properties["OrganizationID"], ParameterDirection.Input),
                    //new OracleParameter(":remarks", OracleDbType.Varchar2,searchEntity.Remarks, ParameterDirection.Input),
                    //new OracleParameter(":isReworked", OracleDbType.Varchar2,searchEntity.IsRework, ParameterDirection.Input),
                    new OracleParameter(":begindate", OracleDbType.Date,cre.Properties["BeginDate"], ParameterDirection.Input),
					new OracleParameter(":enddate", OracleDbType.Date,cre.Properties["EndDate"], ParameterDirection.Input),
					new OracleParameter(":accountID", OracleDbType.Int32,user.AccountID, ParameterDirection.Input),
                    //new OracleParameter(":userID", OracleDbType.Int32,user.UserID, ParameterDirection.Input),
                    //new OracleParameter(":kilnCode", OracleDbType.Varchar2,searchEntity.KilnCode, ParameterDirection.Input),
                    //new OracleParameter(":kilnCarCode", OracleDbType.Varchar2,searchEntity.KilnCarCode, ParameterDirection.Input),
                    //new OracleParameter(":kilnCarPosition", OracleDbType.Int32,searchEntity.KilnCarPosition, ParameterDirection.Input),
                    new OracleParameter(":currentUserID", OracleDbType.Int32,user.UserID, ParameterDirection.Input),
					new OracleParameter(":goodstypecode", OracleDbType.Varchar2,cre.Properties["GoodsTypeCode"], ParameterDirection.Input),
				};

				DataTable data = conn.GetSqlResultToDt(sqlString, paras);

				ServiceResultEntity sre = new ServiceResultEntity();
				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
					return sre;
				}
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}
		#endregion

		#endregion

		#region 注浆盘点

		/// <summary>
		/// 获取盘点单列表（searchbox用）
		/// </summary>
		/// <param name="sUserInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity GetGBCheckedList(SUserInfo sUserInfo, ClientRequestEntity cre)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			IDBConnection con = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select GBCheckedID inCheckedID,GBCheckedNo inCheckedNo,AccountDate,Remarks from TP_PM_GroutingChecked where accountid=:accountid and ValueFlag=1 order by GBCheckedID desc";
				List<OracleParameter> parameters = new List<OracleParameter>();
				parameters.Add(new OracleParameter(":accountid", OracleDbType.Int32, sUserInfo.AccountID, ParameterDirection.Input));
				sre.Data = con.GetSqlResultToDs(sqlString, parameters.ToArray());
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取盘点单列表（一览用）
		/// </summary>
		/// <param name="sUserInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity GetAllGBCheckList(SUserInfo sUserInfo, ClientRequestEntity cre)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			IDBConnection con = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = "SELECT gbc.gbcheckedid\n" +
				"      ,gbc.gbcheckedno\n" +
				"      ,gbc.gbcheckname\n" +
				"      ,gbc.remarks\n" +
				"      ,gbc.createtime\n" +
				"      ,u.usercode      CreateUserCode\n" +
				"      ,u.username      CreateUserName\n" +
				"  FROM TP_PM_GroutingChecked gbc\n" +
				"  LEFT JOIN tp_mst_user u\n" +
				"    ON u.userid = gbc.createuserid\n" +
				" WHERE gbc.valueflag = '1'\n" +
				"   AND gbc.accountid = :accountid\n" +
				"   AND (:datebegin IS NULL OR gbc.createtime >= :datebegin)\n" +
				"   AND (:dateend IS NULL OR gbc.createtime <= :dateend)\n" +
				"   AND (:gbcheckedno IS NULL OR  instr(gbc.gbcheckedno, :gbcheckedno) > 0)\n" +
				"   AND (:gbcheckname IS NULL OR   instr(gbc.gbcheckname, :gbcheckname) > 0)\n" +
				"   AND (:remarks IS NULL OR  instr(gbc.remarks, :remarks) > 0)" +
				" ORDER BY gbcheckedid desc";

				OracleParameter[] parameters = new OracleParameter[] {
					new OracleParameter(":accountid", OracleDbType.Int32, sUserInfo.AccountID, ParameterDirection.Input),
					new OracleParameter(":datebegin", OracleDbType.Date, cre.Properties["datebegin"], ParameterDirection.Input),
					new OracleParameter(":dateend", OracleDbType.Date, cre.Properties["dateend"], ParameterDirection.Input),
					new OracleParameter(":gbcheckedno", OracleDbType.NVarchar2, cre.Properties["gbcheckedno"], ParameterDirection.Input),
					new OracleParameter(":gbcheckname", OracleDbType.NVarchar2, cre.Properties["gbcheckname"], ParameterDirection.Input),
					new OracleParameter(":remarks", OracleDbType.NVarchar2, cre.Properties["remarks"], ParameterDirection.Input),
				};
				sre.Data = con.GetSqlResultToDs(sqlString, parameters);
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取盘点单明细（一览用）
		/// </summary>
		/// <param name="sUserInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity GetAllGBCheckDetail(SUserInfo sUserInfo, ClientRequestEntity cre)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int checkedID = Convert.ToInt32(cre.Properties["CheckedID"]);
			IDBConnection con = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				sre.Data = new DataSet();
				con.Open();
				string sqlString = "SELECT gbu.gbcheckedid, u.userid, u.usercode, u.username\n" +
				"  FROM Tp_Pm_Gbcheckeduser gbu\n" +
				"  LEFT JOIN tp_mst_user u\n" +
				"    ON u.userid = gbu.userid\n" +
				" WHERE gbu.gbcheckedid = :gbcheckedid";

				OracleParameter[] parameters = new OracleParameter[] {
					new OracleParameter(":gbcheckedid", OracleDbType.Int32, checkedID, ParameterDirection.Input),
				};
				DataTable userTable = con.GetSqlResultToDt(sqlString, parameters);
				userTable.TableName = "UserTable";
				sre.Data.Tables.Add(userTable);

				sqlString = "SELECT 0 sel\n" +
				"      ,gbcd.GBCheckedID -- 盘点单ID\n" +
				"      ,gbcd.BarCode -- 产品条码\n" +
				"      ,gbcd.GBCheckedNo -- 盘点单号\n" +
				"      ,gbcd.GroutingLineCode -- 成型生产线编码\n" +
				"      ,gbcd.GroutingLineName -- 成型生产线名称\n" +
				"      ,gbcd.GroutingDate -- 注浆日期\n" +
				"      ,gbcd.GroutingMouldCode -- 注浆模具编号\n" +
				"      ,gbcd.GroutingBatchNo -- 注浆批次\n" +
				"      ,gbcd.UserCode -- 注浆工号编码\n" +
				"      ,gbcd.GoodsCode -- 产品编码\n" +
				"      ,gbcd.GoodsName -- 产品名称\n" +
				"      ,gbcd.GroutingCount -- 注浆次数\n" +
				"      ,gbcd.ScrapFlag -- 损坯标识\n" +
				"      ,gbcd.ScrapTime -- 损坯时间\n" +
				"      ,SUser.usercode   ScrapUsercode -- 损坯工号\n" +
				"      ,gbcd.IsPublicBody -- 公坯标识\n" +
				"      ,gbcd.DeliverFlag -- 交坯标识\n" +
				"      ,gbcd.DeliverTime -- 交坯时间\n" +
				"      ,gbcd.DeliverUserCode -- 交坯工号\n" +
				"      ,gbcd.Remarks -- 备注\n" +
				"      ,gbcd.GBCheckedFlag -- 盘点标识\n" +
				"      ,gbcd.CheckedDate -- 盘点时间\n" +
				"      ,CUser.usercode CheckedUserCode -- 盘点工号\n" +
				"      ,case when gdd.scrapflag = '1' then '成型损坯'" +
				"            when inp.barcode is not null then to_char(p.procedurename) " +
				"            when sp.barcode is not null then to_char(glt.goodsleveltypename) " +
				"            when fp.barcode is not null then '生产完成' else '' end procedurename -- 当前工序\n" +
				"      ,case when gdd.scrapflag = '1' then gdd.scraptime " +
				"            when inp.barcode is not null then inp.PROCEDURETIME " +
				"            when sp.barcode is not null then sp.auditdate " +
				"            when fp.barcode is not null then fp.createtime else null end PROCEDURETIME -- 当前工序时间\n" +
				//"      ,p.procedurename procedurename -- 当前工序\n" +
				//"      ,inp.PROCEDURETIME PROCEDURETIME -- 当前工序时间\n" +
				"  FROM tp_pm_gbcheckeddetail gbcd\n" +
				// 当前注浆信息
				" INNER JOIN tp_pm_groutingdailydetail gdd\n" +
				"    ON gdd.groutingdailydetailid = gbcd.groutingdailydetailid\n" +

				"  LEFT JOIN tp_mst_user SUser\n" +
				"    ON SUser.userid = gbcd.ScrapUser\n" +
				"  LEFT JOIN tp_mst_user CUser\n" +
				"    ON CUser.userid = gbcd.CheckedUserID\n" +

				// 在产工序
				"  LEFT JOIN  tp_pm_inproduction inp \n" +
				"    ON inp.barcode = gdd.barcode\n" +
				// 完成
				"  LEFT JOIN tp_pm_finishedproduct fp \n" +
				"    ON inp.barcode is null and fp.barcode = gdd.barcode\n" +
				// 损坯
				"  LEFT JOIN  tp_pm_scrapproduct sp \n" +
				"    ON inp.barcode is null and fp.barcode is null and sp.barcode = gdd.barcode\n" +
				"   AND sp.valueflag = '1'\n" +
				"   AND sp.auditstatus = 1\n" +
				"   AND sp.goodsleveltypeid <> 9\n" +
				"   AND sp.RECYCLINGFLAG = '0'\n" +
				"  LEFT JOIN  tp_sys_goodsleveltype glt \n" +
				"    ON glt.goodsleveltypeid = sp.goodsleveltypeid\n" +

				"  LEFT JOIN  tp_pc_procedure p \n" +
				"    ON p.procedureid = inp.procedureid\n" +
				" WHERE gbcd.gbcheckedid = :gbcheckedid\n" +
				"   AND gbcd.gbcheckedflag = :gbcheckedflag";

				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":gbcheckedflag",OracleDbType.Int32,(int)Constant.InCheckedFlag.InCheckedNo,ParameterDirection.Input),
					new OracleParameter(":gbcheckedid",OracleDbType.Int32,checkedID,ParameterDirection.Input),
				};
				sre.Data.Tables.Add(con.GetSqlResultToDt(sqlString, paras));

				paras[0].Value = (int)Constant.InCheckedFlag.InCheckeded;
				sre.Data.Tables.Add(con.GetSqlResultToDt(sqlString, paras));

				paras[0].Value = (int)Constant.InCheckedFlag.InCheckedWin;
				sre.Data.Tables.Add(con.GetSqlResultToDt(sqlString, paras));

				paras[0].Value = (int)Constant.InCheckedFlag.Loss;
				sre.Data.Tables.Add(con.GetSqlResultToDt(sqlString, paras));

				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取盘点单信息（编辑用）
		/// </summary>
		/// <param name="sUserInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity GetGBCheckedInfoForUpdate(SUserInfo sUserInfo, ClientRequestEntity cre)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int checkedID = Convert.ToInt32(cre.Properties["CheckedID"]);
			IDBConnection con = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();

				string sqlString =
					"SELECT gbc.gbcheckedid, gbc.gbcheckedno, gbc.gbcheckname, gbc.remarks\n" +
					"  FROM TP_PM_GroutingChecked gbc\n" +
					" WHERE gbc.gbcheckedid = :gbcheckedid";
				OracleParameter[] parameters = new OracleParameter[] {
					new OracleParameter(":gbcheckedid", OracleDbType.Int32, checkedID, ParameterDirection.Input)
				};
				sre.Data = con.GetSqlResultToDs(sqlString, parameters);

				sqlString =
					"SELECT u.userid, u.usercode, u.username\n" +
					"  FROM Tp_Pm_Gbcheckeduser gbu\n" +
					" INNER JOIN tp_mst_user u\n" +
					"    ON u.userid = gbu.userid\n" +
					" WHERE gbu.gbcheckedid = :gbcheckedid" +
					" ORDER BY u.usercode";
				sre.Data.Tables.Add(con.GetSqlResultToDt(sqlString, parameters));
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 保存盘点单
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns></returns>
		public static ServiceResultEntity SaveGBChecked(SUserInfo sUserInfo, ClientRequestEntity cre)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int checkedID = Convert.ToInt32(cre.Properties["CheckedID"]);
			string checkedName = cre.Properties["CheckedName"].ToString();
			string remarks = cre.Properties["Remarks"].ToString();

			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				string sql = null;
				OracleParameter[] paras = null;

				if (checkedID > 0)
				{
					// 编辑
					sql = "UPDATE TP_PM_GroutingChecked gbc\n" +
					"   SET gbc.gbcheckname  = :gbcheckname\n" +
					"      ,gbc.remarks      = :remarks\n" +
					"      ,gbc.updateuserid = :updateuserid\n" +
					" WHERE gbc.gbcheckedid = :gbcheckedid";
					paras = new OracleParameter[] {
						new OracleParameter(":GBCheckedID",OracleDbType.Int32,
							checkedID,ParameterDirection.Input),
						new OracleParameter(":gbcheckname",OracleDbType.NVarchar2,
							checkedName,ParameterDirection.Input),
						new OracleParameter(":remarks",OracleDbType.NVarchar2,
							remarks,ParameterDirection.Input),
						new OracleParameter(":updateuserid",OracleDbType.Int32,
							sUserInfo.UserID,ParameterDirection.Input)
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sql, paras);

					sql = "DELETE FROM Tp_Pm_Gbcheckeduser gbu\n" +
					" WHERE gbu.gbcheckedid = :gbcheckedid";
					paras = new OracleParameter[] {
						new OracleParameter(":GBCheckedID",OracleDbType.Int32,
							checkedID,ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sql, paras);

					if (cre.Data != null && cre.Data.Tables.Count > 0)
					{
						sql = "INSERT INTO Tp_Pm_Gbcheckeduser gbu\n" +
						"  (gbcheckedid, userid, usercode)\n" +
						"VALUES\n" +
						"  (:gbcheckedid, :userid, :usercode)";
						foreach (DataRow item in cre.Data.Tables[0].Rows)
						{
							if (item["UserID"] == DBNull.Value)
							{
								continue;
							}
							paras = new OracleParameter[] {
								new OracleParameter(":GBCheckedID",OracleDbType.Int32,
									checkedID,ParameterDirection.Input),
								new OracleParameter(":userid",OracleDbType.Int32,
									item["UserID"],ParameterDirection.Input),
								new OracleParameter(":usercode",OracleDbType.NVarchar2,
									item["UserCode"],ParameterDirection.Input),
							};
							returnRows += oracleTrConn.ExecuteNonQuery(sql, paras);
						}
					}
				}
				else
				{
					// 新建
					//盘点单号
					string checkedNo = string.Format("GBC{0}", DateTime.Now.ToString("yyyyMMddHHmmss"));
					//获得账务日期
					DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, sUserInfo);
					//盘点单ID
					sql = "select SEQ_PM_GBChecked_ID.nextval from dual";
					checkedID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sql));

					#region 插入盘点单主表信息
					sql = @"insert into TP_PM_GroutingChecked
                                (
                                    GBCheckedID,
                                    GBCheckedNo,
                                    AccountDate,
                                    Remarks,
                                    AccountID,
                                    CreateUserID,
                                    UpdateUserID,
                                    GBCHECKNAME
                                ) values
                                (   :GBCheckedID,
                                    :GBCheckedNo,
                                    :AccountDate,
                                    :Remarks,
                                    :AccountID,
                                    :CreateUserID,
                                    :CreateUserID,
                                    :GBCHECKNAME
                                )";
					OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":GBCheckedID",OracleDbType.Int32,
							checkedID,ParameterDirection.Input),
						new OracleParameter(":GBCheckedNo",OracleDbType.NVarchar2,
							checkedNo,ParameterDirection.Input),
						new OracleParameter(":AccountDate",OracleDbType.Date,
							accountDate,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							remarks,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							sUserInfo.AccountID,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							sUserInfo.UserID,ParameterDirection.Input),
						new OracleParameter(":GBCHECKNAME",OracleDbType.NVarchar2,
							checkedName,ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sql, Paras);
					#endregion

					#region 盘点工号
					if (cre.Data != null && cre.Data.Tables.Count > 0)
					{
						sql = "INSERT INTO Tp_Pm_Gbcheckeduser gbu\n" +
						"  (gbcheckedid, userid, usercode)\n" +
						"VALUES\n" +
						"  (:gbcheckedid, :userid, :usercode)";
						foreach (DataRow item in cre.Data.Tables[0].Rows)
						{
							if (item["UserID"] == DBNull.Value)
							{
								continue;
							}
							paras = new OracleParameter[] {
								new OracleParameter(":GBCheckedID",OracleDbType.Int32,
									checkedID,ParameterDirection.Input),
								new OracleParameter(":userid",OracleDbType.Int32,
									item["UserID"],ParameterDirection.Input),
								new OracleParameter(":usercode",OracleDbType.NVarchar2,
									item["UserCode"],ParameterDirection.Input),
							};
							returnRows += oracleTrConn.ExecuteNonQuery(sql, paras);
						}
					}
					#endregion

					#region 盘点信息
					string lineWhere = null;
					if (cre.Properties["BUILDINGNO"] + "" != "")
					{
						lineWhere = " instr('," + cre.Properties["BUILDINGNO"] + ",', ',' || gl.buildingno || ',') > 0\n";
					}
					if (cre.Properties["FLOORNO"] + "" != "")
					{
						if (lineWhere != null)
						{
							lineWhere += " AND";
						}
						lineWhere += " to_number(gl.floorno) IN (" + cre.Properties["FLOORNO"] + ")\n";
					}
					if (lineWhere != null)
					{
						lineWhere = "INNER JOIN (SELECT gl.groutinglineid\n" +
						"              FROM tp_pc_groutingline gl\n" +
						"             WHERE " + lineWhere + ") gll\n" +
						"   ON gll.groutinglineid = gdd.groutinglineid\n";
					}

					sql =
					"INSERT INTO TP_PM_GBCHECKEDDETAIL\n" +
					"  (GBCHECKEDID\n" +
					"  ,BARCODE\n" +
					"  ,GBCHECKEDNO\n" +
					"  ,GROUTINGDAILYDETAILID\n" +
					"  ,GROUTINGDAILYID\n" +
					"  ,GROUTINGLINEID\n" +
					"  ,GROUTINGLINECODE\n" +
					"  ,GROUTINGLINENAME\n" +
					"  ,GROUTINGLINEDETAILID\n" +
					"  ,GROUTINGDATE\n" +
					"  ,GROUTINGMOULDCODE\n" +
					"  ,MOULDCODE\n" +
					"  ,GMOULDTYPEID\n" +
					"  ,CANMANYTIMES\n" +
					"  ,GROUTINGBATCHNO\n" +
					"  ,USERID\n" +
					"  ,USERCODE\n" +
					"  ,CLASSESSETTINGID\n" +
					"  ,GOODSID\n" +
					"  ,GOODSCODE\n" +
					"  ,GOODSNAME\n" +
					"  ,GMOULDSTATUS\n" +
					"  ,GROUTINGCOUNT\n" +
					"  ,GROUTINGFLAG\n" +
					"  ,ONLYCODE\n" +
					"  ,NOGROUTINGRREASON\n" +
					"  ,SPECIALREPAIRFLAG\n" +
					"  ,SCRAPFLAG\n" +
					"  ,SCRAPTIME\n" +
					"  ,SCRAPUSER\n" +
					"  ,ISPUBLICBODY\n" +
					"  ,DELIVERFLAG\n" +
					"  ,DELIVERTIME\n" +
					"  ,DELIVERUSERID\n" +
					"  ,DELIVERUSERCODE\n" +
					"  ,LOGOID\n" +
					"  ,REMARKS\n" +
					"  ,ACCOUNTID\n" +
					"  ,VALUEFLAG\n" +
					"  ,CREATEUSERID\n" +
					"  ,UPDATEUSERID)\n" +
					"  SELECT :GBCHECKEDID\n" +
					"        ,gdd.BARCODE\n" +
					"        ,:GBCHECKEDNO\n" +
					"        ,gdd.GROUTINGDAILYDETAILID\n" +
					"        ,gdd.GROUTINGDAILYID\n" +
					"        ,gdd.GROUTINGLINEID\n" +
					"        ,gdd.GROUTINGLINECODE\n" +
					"        ,gdd.GROUTINGLINENAME\n" +
					"        ,gdd.GROUTINGLINEDETAILID\n" +
					"        ,gdd.GROUTINGDATE\n" +
					"        ,gdd.GROUTINGMOULDCODE\n" +
					"        ,gdd.MOULDCODE\n" +
					"        ,gdd.GMOULDTYPEID\n" +
					"        ,gdd.CANMANYTIMES\n" +
					"        ,gdd.GROUTINGBATCHNO\n" +
					"        ,gdd.USERID\n" +
					"        ,gdd.USERCODE\n" +
					"        ,gdd.CLASSESSETTINGID\n" +
					"        ,gdd.GOODSID\n" +
					"        ,gdd.GOODSCODE\n" +
					"        ,gdd.GOODSNAME\n" +
					"        ,gdd.GMOULDSTATUS\n" +
					"        ,gdd.GROUTINGCOUNT\n" +
					"        ,gdd.GROUTINGFLAG\n" +
					"        ,gdd.ONLYCODE\n" +
					"        ,gdd.NOGROUTINGRREASON\n" +
					"        ,gdd.SPECIALREPAIRFLAG\n" +
					"        ,gdd.SCRAPFLAG\n" +
					"        ,gdd.SCRAPTIME\n" +
					"        ,gdd.SCRAPUSER\n" +
					"        ,gdd.ISPUBLICBODY\n" +
					"        ,gdd.DELIVERFLAG\n" +
					"        ,gdd.DELIVERTIME\n" +
					"        ,gdd.DELIVERUSERID\n" +
					"        ,gdd.DELIVERUSERCODE\n" +
					"        ,gdd.LOGOID\n" +
					"        ,gdd.REMARKS\n" +
					"        ,gdd.ACCOUNTID\n" +
					"        ,'1'\n" +
					"        ,:CHECKEDUSERID\n" +
					"        ,:CHECKEDUSERID\n" +
					" FROM tp_pm_groutingdailydetail gdd\n" +
					" LEFT JOIN tp_mst_goods g\n" +
					"   ON g.goodsid = gdd.goodsid\n" +
					" LEFT JOIN tp_mst_goodsType gt\n" +
					"   ON gt.goodstypeid = g.goodstypeid\n" + lineWhere +
					"WHERE gdd.valueflag = '1'\n" +
					"  AND gdd.accountid = :accountid\n" +
					"  AND gdd.barcode IS NOT NULL\n" +
					"  AND gdd.deliverflag = '0'\n" +
					"  AND gdd.scrapflag = '0'\n" +
					"  AND (:DateBegin IS NULL OR gdd.groutingdate >= :DateBegin)\n" +
					"  AND (:DateEnd IS NULL OR gdd.groutingdate <= :DateEnd)\n" +
					"  AND (:GoodsIDS IS NULL OR\n" +
					"      instr(',' || :GoodsIDS || ',', ',' || gdd.GoodsID || ',') > 0)\n" +
					"  AND (:GoodsTypeCode IS NULL OR\n" +
					"      instr(gt.goodstypecode, :GoodsTypeCode) = 1)";

					paras = new OracleParameter[] {
						new OracleParameter(":accountid",OracleDbType.Int32,
							sUserInfo.AccountID,ParameterDirection.Input),
						new OracleParameter(":GBCHECKEDID",OracleDbType.Int32,
							checkedID,ParameterDirection.Input),
						new OracleParameter(":GBCHECKEDNO",OracleDbType.NVarchar2,
							checkedNo,ParameterDirection.Input),
						new OracleParameter(":CHECKEDUSERID",OracleDbType.Int32,
							sUserInfo.UserID,ParameterDirection.Input),
						new OracleParameter(":DateBegin",OracleDbType.Date,
							cre.Properties["DateBegin"],ParameterDirection.Input),
						new OracleParameter(":DateEnd",OracleDbType.Date,
							cre.Properties["DateEnd"],ParameterDirection.Input),
						new OracleParameter(":GoodsIDS",OracleDbType.NVarchar2,
							cre.Properties["GoodsCodeList"],ParameterDirection.Input),
						new OracleParameter(":GoodsTypeCode",OracleDbType.NVarchar2,
							cre.Properties["GoodsTypeCode"],ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sql, paras);
					#endregion
				}
				oracleTrConn.Commit();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return sre;
		}

		/// <summary>
		/// 停用盘点单
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns></returns>
		public static ServiceResultEntity DisableGBChecked(SUserInfo sUserInfo, ClientRequestEntity cre)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int checkedID = Convert.ToInt32(cre.Properties["CheckedID"]);
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				string sql = "update TP_PM_GroutingChecked set valueflag='0', updateuserid=:updateuserid where GBCheckedID=:GBCheckedID and valueflag='1'";
				OracleParameter[] Paras = new OracleParameter[] {
					new OracleParameter(":GBCheckedID",OracleDbType.Int32,
						checkedID,ParameterDirection.Input),
					new OracleParameter(":updateuserid",OracleDbType.Int32,
						sUserInfo.UserID,ParameterDirection.Input)
				};
				returnRows = oracleTrConn.ExecuteNonQuery(sql, Paras);
				if (returnRows > 0)
				{
					sre.Status = Constant.ServiceResultStatus.Success;
				}
				else
				{
					sre.Status = Constant.ServiceResultStatus.Other;
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return sre;
		}

		/// <summary>
		/// 更新盘点单(条码盘点)
		/// </summary>
		/// <param name="InCheckedID">盘点单号</param>
		/// <param name="BarCode">产品条码</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns></returns>
		public static ServiceResultEntity UpdateGBChecked(SUserInfo sUserInfo, ClientRequestEntity cre)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int checkedID = Convert.ToInt32(cre.Properties["CheckedID"]);
			string barcode = cre.Properties["Barcode"].ToString();
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				string sql = null;
				OracleParameter[] paras = null;
				DataSet ds = null;

				sql = @"select GBCheckedFlag,CHECKEDUSERID from TP_PM_GBCheckedDetail where GBCheckedID=:GBCheckedID and BarCode=:BarCode and Valueflag=1";
				paras = new OracleParameter[] {
					new OracleParameter(":GBCheckedID",OracleDbType.Int32,
						checkedID,ParameterDirection.Input),
					new OracleParameter(":BarCode",OracleDbType.NVarchar2,
						barcode,ParameterDirection.Input)
				};

				ds = oracleTrConn.GetSqlResultToDs(sql, paras);
				// 不在盘点单中
				if (ds != null && ds.Tables[0].Rows.Count == 0)
				{
					sql = @"select GBCheckedNo from tp_pm_groutingchecked where GBCheckedID=:GBCheckedID";
					paras = new OracleParameter[] {
					new OracleParameter(":GBCheckedID",OracleDbType.Int32,
						checkedID,ParameterDirection.Input),
					};
					ds = oracleTrConn.GetSqlResultToDs(sql, paras);
					if (ds == null || ds.Tables.Count == 0 || ds.Tables[0].Rows.Count == 0)
					{
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = -1;
						sre.Message = "盘点单不存在";
						return sre;
					}
					string checkedNo = ds.Tables[0].Rows[0]["GBCheckedNo"].ToString();

					// 条码是否在注浆日报中
					sql = "SELECT gdd.groutingdailydetailid\n" +
						"  FROM tp_pm_groutingdailydetail gdd\n" +
						" WHERE gdd.barcode = :BarCode";
					paras = new OracleParameter[] {
						new OracleParameter(":BarCode",OracleDbType.NVarchar2,
							barcode,ParameterDirection.Input)
					};
					DataTable dt = oracleTrConn.GetSqlResultToDt(sql, paras);
					if (dt == null || dt.Rows.Count == 0)
					{
						// 无效条码
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = -1;
						sre.Message = "条码【" + barcode + "】为无效条码";
						return sre;
					}

					sql =
					"INSERT INTO TP_PM_GBCHECKEDDETAIL\n" +
					"  (GBCHECKEDID\n" +
					"  ,BARCODE\n" +
					"  ,GBCHECKEDNO\n" +
					"  ,GROUTINGDAILYDETAILID\n" +
					"  ,GROUTINGDAILYID\n" +
					"  ,GROUTINGLINEID\n" +
					"  ,GROUTINGLINECODE\n" +
					"  ,GROUTINGLINENAME\n" +
					"  ,GROUTINGLINEDETAILID\n" +
					"  ,GROUTINGDATE\n" +
					"  ,GROUTINGMOULDCODE\n" +
					"  ,MOULDCODE\n" +
					"  ,GMOULDTYPEID\n" +
					"  ,CANMANYTIMES\n" +
					"  ,GROUTINGBATCHNO\n" +
					"  ,USERID\n" +
					"  ,USERCODE\n" +
					"  ,CLASSESSETTINGID\n" +
					"  ,GOODSID\n" +
					"  ,GOODSCODE\n" +
					"  ,GOODSNAME\n" +
					"  ,GMOULDSTATUS\n" +
					"  ,GROUTINGCOUNT\n" +
					"  ,GROUTINGFLAG\n" +
					"  ,ONLYCODE\n" +
					"  ,NOGROUTINGRREASON\n" +
					"  ,SPECIALREPAIRFLAG\n" +
					"  ,SCRAPFLAG\n" +
					"  ,SCRAPTIME\n" +
					"  ,SCRAPUSER\n" +
					"  ,ISPUBLICBODY\n" +
					"  ,DELIVERFLAG\n" +
					"  ,DELIVERTIME\n" +
					"  ,DELIVERUSERID\n" +
					"  ,DELIVERUSERCODE\n" +
					"  ,LOGOID\n" +
					"  ,REMARKS\n" +
					"  ,GBCHECKEDFLAG\n" +
					"  ,CHECKEDDATE\n" +
					"  ,CHECKEDUSERID\n" +
					"  ,ACCOUNTID\n" +
					"  ,VALUEFLAG\n" +
					"  ,CREATEUSERID\n" +
					"  ,UPDATEUSERID)\n" +
					"  SELECT :GBCHECKEDID\n" +
					"        ,BARCODE\n" +
					"        ,:GBCHECKEDNO\n" +
					"        ,GROUTINGDAILYDETAILID\n" +
					"        ,GROUTINGDAILYID\n" +
					"        ,GROUTINGLINEID\n" +
					"        ,GROUTINGLINECODE\n" +
					"        ,GROUTINGLINENAME\n" +
					"        ,GROUTINGLINEDETAILID\n" +
					"        ,GROUTINGDATE\n" +
					"        ,GROUTINGMOULDCODE\n" +
					"        ,MOULDCODE\n" +
					"        ,GMOULDTYPEID\n" +
					"        ,CANMANYTIMES\n" +
					"        ,GROUTINGBATCHNO\n" +
					"        ,USERID\n" +
					"        ,USERCODE\n" +
					"        ,CLASSESSETTINGID\n" +
					"        ,GOODSID\n" +
					"        ,GOODSCODE\n" +
					"        ,GOODSNAME\n" +
					"        ,GMOULDSTATUS\n" +
					"        ,GROUTINGCOUNT\n" +
					"        ,GROUTINGFLAG\n" +
					"        ,ONLYCODE\n" +
					"        ,NOGROUTINGRREASON\n" +
					"        ,SPECIALREPAIRFLAG\n" +
					"        ,SCRAPFLAG\n" +
					"        ,SCRAPTIME\n" +
					"        ,SCRAPUSER\n" +
					"        ,ISPUBLICBODY\n" +
					"        ,DELIVERFLAG\n" +
					"        ,DELIVERTIME\n" +
					"        ,DELIVERUSERID\n" +
					"        ,DELIVERUSERCODE\n" +
					"        ,LOGOID\n" +
					"        ,REMARKS\n" +
					"        ,'2'\n" +
					"        ,SYSDATE\n" +
					"        ,:CHECKEDUSERID\n" +
					"        ,ACCOUNTID\n" +
					"        ,'1'\n" +
					"        ,:CHECKEDUSERID\n" +
					"        ,:CHECKEDUSERID\n" +
					"    FROM tp_pm_groutingdailydetail\n" +
					"   WHERE GROUTINGDAILYDETAILID = :GROUTINGDAILYDETAILID";

					paras = new OracleParameter[] {
						new OracleParameter(":GBCHECKEDID",OracleDbType.Int32,
							checkedID,ParameterDirection.Input),
						new OracleParameter(":GBCHECKEDNO",OracleDbType.NVarchar2,
							checkedNo,ParameterDirection.Input),
						new OracleParameter(":CHECKEDUSERID",OracleDbType.Int32,
							sUserInfo.UserID,ParameterDirection.Input),
						new OracleParameter(":GROUTINGDAILYDETAILID",OracleDbType.Int32,
							dt.Rows[0]["GROUTINGDAILYDETAILID"],ParameterDirection.Input),
					};
					returnRows = oracleTrConn.ExecuteNonQuery(sql, paras);
					//returnRows = 10;
				}
				else
				{
					string checkedFlag = ds.Tables[0].Rows[0]["GBCheckedFlag"].ToString();
					if (checkedFlag == "1")
					{
						//if (Convert.ToInt32(ds.Tables[0].Rows[0]["CHECKEDUSERID"]) != sUserInfo.UserID)
						//{
						//    returnRows = -22;//己被其他工号盘点
						//}
						//else
						//{
						//    returnRows = -24;//己被自己工号盘点
						//}
						//return returnRows;
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = -1;
						sre.Message = "条码【" + barcode + "】已被盘点";
						return sre;
					}
					else if (checkedFlag == "2")
					{
						//if (Convert.ToInt32(ds.Tables[0].Rows[0]["CHECKEDUSERID"]) != sUserInfo.UserID)
						//{
						//    returnRows = -23;//己被其他工号盘盈
						//}
						//else
						//{
						//    returnRows = -25;//己被自己工号盘盈
						//}
						//return returnRows;
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = -1;
						sre.Message = "条码【" + barcode + "】已被盘盈";
						return sre;
					}
					sql = "update TP_PM_GBCheckedDetail set GBCheckedFlag=:GBCheckedFlag,CheckedDate=sysdate,CheckedUserID=:CheckedUserID,UpdateUserID=:UpdateUserID where GBCheckedID=:CheckedID and  BarCode=:BarCode and GBCheckedFlag=:whereGBCheckedFlag";
					paras = new OracleParameter[] {
						new OracleParameter(":CheckedUserID",OracleDbType.Int32,
							sUserInfo.UserID,ParameterDirection.Input),
						new OracleParameter(":GBCheckedFlag",OracleDbType.Int32,
							(int)Constant.InCheckedFlag.InCheckeded,ParameterDirection.Input),
						new OracleParameter(":CheckedID",OracleDbType.Int32,
							checkedID,ParameterDirection.Input),
						new OracleParameter(":BarCode",OracleDbType.NVarchar2,
							barcode,ParameterDirection.Input),
						new OracleParameter(":whereGBCheckedFlag",OracleDbType.Int32,
							(int)Constant.InCheckedFlag.InCheckedNo,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							sUserInfo.UserID,ParameterDirection.Input),
					};
					returnRows = oracleTrConn.ExecuteNonQuery(sql, paras);
					//returnRows = 1;
				}

				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				else
				{
					oracleTrConn.Commit();
					oracleTrConn.Disconnect();
				}
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return sre;
		}

		/// <summary>
		/// 报损未盘点
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns></returns>
		public static ServiceResultEntity SaveClearGBChecked(SUserInfo sUserInfo, ClientRequestEntity cre)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int checkedID = Convert.ToInt32(cre.Properties["CheckedID"]);
			string barcodes = null;
			if (cre.Properties["Barcodes"] != null)
			{
				barcodes = cre.Properties["Barcodes"].ToString();
			}
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);

			string sql = null;
			OracleParameter[] paras = null;
			try
			{
				if (barcodes == null)
				{
					sql =
						"UPDATE tp_pm_groutingdailydetail gdd\n" +
						"   SET gdd.scrapflag     = '1'\n" +
						"      ,gdd.scraptime     = SYSDATE\n" +
						"      ,gdd.scrapuser     = :UserID\n" +
						"      ,gdd.scrapreasonid = -2\n" +
						"      ,gdd.scrapreason   = '盘亏报损'\n" +
						"      ,gdd.ScrapType     = 2\n" +
						" WHERE gdd.scrapflag = '0'\n" +
						"   AND gdd.deliverflag = '0'\n" +
						//"   AND instr(:barcodes, gdd.barcode) > 0";
						"   AND exists (select 1 from tp_pm_gbcheckeddetail gbcd where gbcd.GBCheckedID = :CheckedID and gbcd.gbcheckedflag = '0' and gbcd.barcode = gdd.barcode)";
					paras = new OracleParameter[] {
						new OracleParameter(":CheckedID",OracleDbType.Int32,
							checkedID,ParameterDirection.Input),
						new OracleParameter(":UserID",OracleDbType.Int32,
							sUserInfo.UserID,ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sql, paras);

					sql = "UPDATE tp_pm_gbcheckeddetail gdd\n" +
						"   SET gdd.gbcheckedflag   = '3'\n" +
						"      ,gdd.CheckedDate   = SYSDATE\n" +
						"      ,gdd.CheckedUserID = :UserID\n" +
						"      ,gdd.UpdateUserID = :UserID\n" +
						" WHERE gdd.gbcheckedflag = '0'\n" +
						"   AND gdd.GBCheckedID = :CheckedID";
					paras = new OracleParameter[] {
						new OracleParameter(":UserID",OracleDbType.Int32,
							sUserInfo.UserID,ParameterDirection.Input),
						new OracleParameter(":CheckedID",OracleDbType.Int32,
							checkedID,ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sql, paras);
				}
				else
				{
					string[] barcodelist = barcodes.Split(',');
					foreach (string barcode in barcodelist)
					{
						sql =
							"UPDATE tp_pm_groutingdailydetail gdd\n" +
							"   SET gdd.scrapflag     = '1'\n" +
							"      ,gdd.scraptime     = SYSDATE\n" +
							"      ,gdd.scrapuser     = :UserID\n" +
							"      ,gdd.scrapreasonid = -2\n" +
							"      ,gdd.scrapreason   = '盘亏报损'\n" +
							"      ,gdd.ScrapType     = 2\n" +
							" WHERE gdd.scrapflag = '0'\n" +
							"   AND gdd.deliverflag = '0'\n" +
							//"   AND instr(:barcodes, gdd.barcode) > 0";
							"   AND gdd.barcode = :barcode";
						paras = new OracleParameter[] {
                            //new OracleParameter(":barcodes",OracleDbType.NVarchar2,
                            //    barcodes,ParameterDirection.Input),
                            new OracleParameter(":barcode",OracleDbType.NVarchar2,
								barcode,ParameterDirection.Input),
							new OracleParameter(":UserID",OracleDbType.Int32,
								sUserInfo.UserID,ParameterDirection.Input),
						};
						returnRows += oracleTrConn.ExecuteNonQuery(sql, paras);

						sql = "UPDATE tp_pm_gbcheckeddetail gdd\n" +
							"   SET gdd.gbcheckedflag   = '3'\n" +
							"      ,gdd.CheckedDate   = SYSDATE\n" +
							"      ,gdd.CheckedUserID = :UserID\n" +
							"      ,gdd.UpdateUserID = :UserID\n" +
							" WHERE gdd.gbcheckedflag = '0'\n" +
							"   AND gdd.GBCheckedID = :CheckedID" +
							//"   AND instr(:barcodes, gdd.barcode) > 0";
							"   AND gdd.barcode = :barcode";
						paras = new OracleParameter[] {
                            //new OracleParameter(":barcodes",OracleDbType.NVarchar2,
                            //    barcodes,ParameterDirection.Input),
                            new OracleParameter(":barcode",OracleDbType.NVarchar2,
								barcode,ParameterDirection.Input),
							new OracleParameter(":UserID",OracleDbType.Int32,
								sUserInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":CheckedID",OracleDbType.Int32,
								checkedID,ParameterDirection.Input),
						};
						returnRows += oracleTrConn.ExecuteNonQuery(sql, paras);
					}
				}
				oracleTrConn.Commit();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return sre;
		}

		/// <summary>
		/// 获取盘点单明细
		/// </summary>
		/// <param name="procedureID">工序ID</param>
		/// <returns>DataSet</returns>
		public static DataSet GetUpdateGBCheckedInfo(int checkedID, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"SELECT to_char(checked.UserCheckedCount) || '/' ||
                                   to_char(checked.CheckedCount) CheckedCount
                                  ,to_char(checked.UserOverageCount) || '/' ||
                                   to_char(checked.OverageCount) OverageCount
                                  ,to_char(checked.UserCheckedCount + checked.UserOverageCount) || '/' ||
                                   to_char(checked.CheckedCount + checked.OverageCount) || '/' ||
                                   to_char(TCount) TCount
                              FROM (SELECT icd.GBcheckedid
                                          , SUM(CASE
                                                  WHEN icd.checkeduserid = :userid AND icd.GBCheckedFlag = '1' THEN
                                                   1
                                                  ELSE
                                                   0
                                                END) UserCheckedCount
                                          , SUM(CASE
                                                  WHEN icd.checkeduserid = :userid AND icd.GBCheckedFlag = '2' THEN
                                                   1
                                                  ELSE
                                                   0
                                                END) UserOverageCount
                                          , SUM(CASE
                                                  WHEN icd.GBCheckedFlag = '1' THEN
                                                   1
                                                  ELSE
                                                   0
                                                END) CheckedCount
                                          , SUM(CASE
                                                  WHEN icd.GBCheckedFlag = '2' THEN
                                                   1
                                                  ELSE
                                                   0
                                                END) OverageCount
                                          ,COUNT(icd.GBcheckedid) TCount
                                      FROM tp_pm_GBcheckeddetail icd
                                     WHERE icd.GBcheckedid = :GBcheckedid
                                       AND icd.valueflag = '1') checked";
				OracleParameter[] paras = new OracleParameter[]{
						new OracleParameter(":GBcheckedid",OracleDbType.Int32, checkedID, ParameterDirection.Input),
						new OracleParameter(":userid",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
					};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				ds.Tables[0].TableName = "Table1";

				sqlString = @"SELECT icd.goodscode, COUNT(icd.goodscode) goodscount
                                FROM tp_pm_GBcheckeddetail icd
                                WHERE icd.GBcheckedid = :GBcheckedid
                                AND icd.checkeduserid = :userid
                                AND icd.GBCheckedFlag = '1'
                                AND icd.valueflag = '1'
                                GROUP BY icd.goodscode";

				DataTable dt = con.GetSqlResultToDt(sqlString, paras);
				dt.TableName = "Table2";
				ds.Tables.Add(dt);

				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 成型盘点-盘点选择条码
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns></returns>
		public static ServiceResultEntity GBCheckBarcodes(SUserInfo sUserInfo, ClientRequestEntity cre)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int checkedID = Convert.ToInt32(cre.Properties["CheckedID"]);
			string barcodes = null;
			if (cre.Properties["Barcodes"] != null)
			{
				barcodes = cre.Properties["Barcodes"].ToString();
			}
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				string sql = null;
				OracleParameter[] paras = null;
				if (barcodes == null)
				{
					sql = "update TP_PM_GBCheckedDetail set GBCheckedFlag=:GBCheckedFlag,CheckedDate=sysdate,CheckedUserID=:CheckedUserID,UpdateUserID=:UpdateUserID where GBCheckedID=:GBCheckedID and GBCheckedFlag=:whereGBCheckedFlag";
					paras = new OracleParameter[] {
						new OracleParameter(":CheckedUserID",OracleDbType.Int32,
							sUserInfo.UserID,ParameterDirection.Input),
						new OracleParameter(":GBCheckedFlag",OracleDbType.Int32,
							Constant.InCheckedFlag.InCheckeded,ParameterDirection.Input),
						new OracleParameter(":GBCheckedID",OracleDbType.Int32,
							checkedID,ParameterDirection.Input),
						new OracleParameter(":whereGBCheckedFlag",OracleDbType.Int32,
							Constant.InCheckedFlag.InCheckedNo,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							sUserInfo.UserID,ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sql, paras);
				}
				else
				{
					string[] barcode = barcodes.Split(',');
					foreach (string item in barcode)
					{
						sql = "update TP_PM_GBCheckedDetail set GBCheckedFlag=:GBCheckedFlag,CheckedDate=sysdate,CheckedUserID=:CheckedUserID,UpdateUserID=:UpdateUserID where GBCheckedID=:GBCheckedID and  BarCode=:BarCode and GBCheckedFlag=:whereGBCheckedFlag";
						paras = new OracleParameter[] {
							new OracleParameter(":CheckedUserID",OracleDbType.Int32,
								sUserInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":GBCheckedFlag",OracleDbType.Int32,
								Constant.InCheckedFlag.InCheckeded,ParameterDirection.Input),
							new OracleParameter(":GBCheckedID",OracleDbType.Int32,
								checkedID,ParameterDirection.Input),
							new OracleParameter(":BarCode",OracleDbType.NVarchar2,
								item,ParameterDirection.Input),
							new OracleParameter(":whereGBCheckedFlag",OracleDbType.Int32,
								Constant.InCheckedFlag.InCheckedNo,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
								sUserInfo.UserID,ParameterDirection.Input),
						};
						returnRows += oracleTrConn.ExecuteNonQuery(sql, paras);
					}
				}

				oracleTrConn.Commit();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return sre;
		}

		/// <summary>
		/// 在产盘点-盘点选择条码
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns></returns>
		public static ServiceResultEntity CheckBarcodes(SUserInfo sUserInfo, ClientRequestEntity cre)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int checkedID = Convert.ToInt32(cre.Properties["CheckedID"]);
			string barcodes = null;
			if (cre.Properties["Barcodes"] != null)
			{
				barcodes = cre.Properties["Barcodes"].ToString();
			}
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				string sql = null;
				OracleParameter[] paras = null;
				if (barcodes == null)
				{
					sql = "update TP_PM_InCheckedDetail set InCheckedFlag=:InCheckedFlag,CheckedDate=sysdate,CheckedUserID=:CheckedUserID,UpdateUserID=:UpdateUserID where InCheckedID=:InCheckedID and InCheckedFlag=:whereInCheckedFlag";
					paras = new OracleParameter[] {
						new OracleParameter(":CheckedUserID",OracleDbType.Int32,
							sUserInfo.UserID,ParameterDirection.Input),
						new OracleParameter(":InCheckedFlag",OracleDbType.Int32,
							Constant.InCheckedFlag.InCheckeded,ParameterDirection.Input),
						new OracleParameter(":InCheckedID",OracleDbType.Int32,
							checkedID,ParameterDirection.Input),
						new OracleParameter(":whereInCheckedFlag",OracleDbType.Int32,
							Constant.InCheckedFlag.InCheckedNo,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							sUserInfo.UserID,ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sql, paras);
				}
				else
				{
					string[] barcode = barcodes.Split(',');
					foreach (string item in barcode)
					{
						sql = "update TP_PM_InCheckedDetail set InCheckedFlag=:InCheckedFlag,CheckedDate=sysdate,CheckedUserID=:CheckedUserID,UpdateUserID=:UpdateUserID where InCheckedID=:InCheckedID and  BarCode=:BarCode and InCheckedFlag=:whereInCheckedFlag";
						paras = new OracleParameter[] {
							new OracleParameter(":CheckedUserID",OracleDbType.Int32,
								sUserInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":InCheckedFlag",OracleDbType.Int32,
								Constant.InCheckedFlag.InCheckeded,ParameterDirection.Input),
							new OracleParameter(":InCheckedID",OracleDbType.Int32,
								checkedID,ParameterDirection.Input),
							new OracleParameter(":BarCode",OracleDbType.NVarchar2,
								item,ParameterDirection.Input),
							new OracleParameter(":whereInCheckedFlag",OracleDbType.Int32,
								Constant.InCheckedFlag.InCheckedNo,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
								sUserInfo.UserID,ParameterDirection.Input),
						};
						returnRows += oracleTrConn.ExecuteNonQuery(sql, paras);
					}
				}

				oracleTrConn.Commit();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return sre;
		}
		#endregion

		#region 集中采集的结束工序（包装装板）验证参数（商标、型号、数量）

		/// <summary>
		/// 集中采集的结束工序（包装装板）验证参数（商标、型号、数量）
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetFinishedLoadingCarSetting(SUserInfo user, ClientRequestEntity cre)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				conn.Open();

				//// 列表中产品数量
				//int listCount = (int)cre.Properties["ListCount"];
				//// 第一产品时，获取系统参数
				//if (listCount == 0)
				//{
				string sqlString = "SELECT sss.settingcode, sss.settingvalue\n" +
				"  FROM tp_mst_systemsetting sss\n" +
				" WHERE sss.accountid = " + user.AccountID + "\n" +
				"   AND sss.settingcode IN ('S_PM_011', 'S_PM_012', 'S_PM_013')";
				IDataParameter[] paras = new OracleParameter[]
				{
						new OracleParameter(":accountID", OracleDbType.Int32,user.AccountID, ParameterDirection.Input),
				};
				DataTable data = conn.GetSqlResultToDt(sqlString, paras);
				//foreach (DataRow item in data.Rows)
				//{
				//    if (item["settingcode"].ToString() == "S_PM_011")
				//    {
				//        cre.Properties["S_PM_011"] = item["settingvalue"];
				//    }
				//    else if (item["settingcode"].ToString() == "S_PM_012")
				//    {
				//        cre.Properties["S_PM_012"] = item["settingvalue"];
				//    }
				//    else if (item["settingcode"].ToString() == "S_PM_013")
				//    {
				//        cre.Properties["S_PM_013"] = item["settingvalue"];
				//    }
				//}

				sqlString = "SELECT g.PLATELIMITNUM\n" +
				"  FROM tp_mst_goods g\n" +
				" WHERE g.goodsid = " + cre.Properties["GoodsID"];

				cre.Properties["PLATELIMITNUM"] = conn.GetSqlResultToObj(sqlString);
				//}

				ServiceResultEntity sre = new ServiceResultEntity();
				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);
				sre.Result = cre.Properties["PLATELIMITNUM"];
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}
		#endregion

		#region 成型报损
		/// <summary>
		/// 根据页面条件获取成型报损一览
		/// </summary>
		/// <param name="selectProEntity">成型报损</param>
		/// <param name="userInfo">用户基本信息</param>
		/// <returns>DataSet</returns>
		public static ServiceResultEntity GetGroutingScrapProduct(ClientRequestEntity cre, SUserInfo userInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				ServiceResultEntity result = new ServiceResultEntity();
				con.Open();

				string sqlString = "SELECT sp.BarCode\n" +
									"      ,sp.ScrapProductID\n" +
									"      ,sp.GoodsID\n" +
									"      ,sp.Goodscode\n" +
									"      ,sp.Goodsname\n" +
									"      ,sp.GroutingDailyID\n" +
									"      ,sp.Groutingdailydetailid\n" +
									"      ,sp.GroutingDate\n" +
									"      ,sp.GroutingLineID\n" +
									"      ,sp.Groutinglinecode\n" +
									"      ,sp.Groutinglinename\n" +
									"      ,sp.GMouldTypeID\n" +
									"      ,sp.Groutingmouldcode\n" +
									"      ,sp.Mouldcode\n" +
									"      ,sp.Groutinguserid\n" +
									"      ,sp.Groutingusercode\n" +
									"      ,sp.Groutingnum\n" +
									"      ,sp.Scraptype\n" +
									"      , CASE\n" +
									"          WHEN sp.ScrapType = '0' THEN\n" +
									"           '开模报损'\n" +
									"          WHEN sp.ScrapType = '1' THEN\n" +
									"           '普通报损'\n" +
									"          WHEN sp.ScrapType = '2' THEN\n" +
									"           '盘点报损'\n" +
									"          ELSE\n" +
									"           '自动报损'\n" +
									"        END ScrapTypeName\n" +
									"      ,sp.ResponType\n" +
									"      ,sp.ScrapDate\n" +
									"      ,sp.ScrapRreasonID\n" +
									"      ,msr.ScrapReason\n" +
									"      ,userInfo.UserName AS UName\n" +
									"      ,userInfo.UserCode AS UCode\n" +
									"      ,status.AuditStatusName\n" +
									"      ,createuser.usercode AS createuser\n" +
									"      ,responUser.UserName AS ResponUserName\n" +
									"      ,sp.ResponUserCode\n" +
									"      ,sp.ResponUserID\n" +
									"      ,sp.BackOutFlag\n" +
									"      ,sp.BackOutTime\n" +
									"      ,sp.BackOutUserID\n" +
									"      ,sp.BackOutUserCode\n" +
									"      ,backOutUser.UserName AS BackOutUserName\n" +
									"      ,sp.Remarks\n" +
									"      ,sp.AuditStatus\n" +
									"      ,sp.AuditDate\n" +
									"      ,sp.Auditopinion\n" +
									"      ,sp.Accountdate\n" +
									"      ,sp.OPTimeStamp\n" +
									"  FROM TP_PM_GroutingScrapProduct sp\n" +
									" INNER JOIN TP_SYS_AuditStatus status\n" +
									"    ON sp.AuditStatus = status.AuditStatusID\n" +
									"  LEFT JOIN TP_MST_USER userInfo\n" +
									"    ON sp.Auditor = userInfo.UserId\n" +
									"  LEFT JOIN TP_MST_USER createuser\n" +
									"    ON sp.createuserid = createuser.UserId\n" +
									"  LEFT JOIN TP_MST_USER responUser\n" +
									"    ON sp.ResponUserID = responUser.UserId\n" +
									"  LEFT JOIN TP_MST_ScrapReason msr\n" +
									"    ON sp.ScrapRreasonID = msr.ScrapReasonID\n" +
									"  LEFT JOIN TP_MST_USER backOutUser\n" +
									"    ON sp.BackOutUserID = backOutUser.UserId\n" +
									" WHERE sp.ValueFlag = 1\n" +
									"   AND sp.AccountID = :in_AccountID";

				List<OracleParameter> paraList = new List<OracleParameter>();
				paraList.Add(new OracleParameter(":in_AccountID", OracleDbType.Int32, userInfo.AccountID, ParameterDirection.Input));
				// 成型报损ID
				if (!string.IsNullOrWhiteSpace(cre.Properties["ScrapProductID"] + ""))
				{
					sqlString += " AND sp.ScrapProductID = :in_ScrapProductID";
					paraList.Add(new OracleParameter(":in_ScrapProductID", OracleDbType.Int32, cre.Properties["ScrapProductID"], ParameterDirection.Input));
				}
				// 产品编码
				if (!string.IsNullOrWhiteSpace(cre.Properties["GoodsCode"] + ""))
				{
					sqlString += " AND INSTR(sp.GoodsCode, :in_GoodsCode) > 0";
					paraList.Add(new OracleParameter(":in_GoodsCode", OracleDbType.NVarchar2, cre.Properties["GoodsCode"] + "", ParameterDirection.Input));
				}
				// 产品名称
				if (!string.IsNullOrWhiteSpace(cre.Properties["GoodsName"] + ""))
				{
					sqlString += " AND INSTR(sp.GoodsName, :in_GoodsName) > 0";
					paraList.Add(new OracleParameter(":in_GoodsName", OracleDbType.NVarchar2, cre.Properties["GoodsName"] + "", ParameterDirection.Input));
				}
				// 产品条码
				if (!string.IsNullOrWhiteSpace(cre.Properties["BarCode"] + ""))
				{
					sqlString += " AND INSTR(sp.BarCode, :in_BarCode) > 0";
					paraList.Add(new OracleParameter(":in_BarCode", OracleDbType.NVarchar2, cre.Properties["BarCode"] + "", ParameterDirection.Input));
				}
				// 成型工号
				if (!string.IsNullOrWhiteSpace(cre.Properties["GroutingUserCode"] + ""))
				{
					sqlString += " AND INSTR(sp.GroutingUserCode, :in_GroutingUserCode) > 0";
					paraList.Add(new OracleParameter(":in_GroutingUserCode", OracleDbType.NVarchar2, cre.Properties["GroutingUserCode"] + "", ParameterDirection.Input));
				}
				// 责任工号
				if (!string.IsNullOrWhiteSpace(cre.Properties["ResponUserCode"] + ""))
				{
					sqlString += " AND INSTR(sp.ResponUserCode, :in_ResponUserCode) > 0";
					paraList.Add(new OracleParameter(":in_ResponUserCode", OracleDbType.NVarchar2, cre.Properties["ResponUserCode"] + "", ParameterDirection.Input));
				}
				// 损坯原因
				if (!string.IsNullOrWhiteSpace(cre.Properties["Rreason"] + ""))
				{
					sqlString += " AND INSTR(msr.ScrapReason, :in_ScrapRreason) > 0";
					paraList.Add(new OracleParameter(":in_ScrapRreason", OracleDbType.NVarchar2, cre.Properties["Rreason"] + "", ParameterDirection.Input));
				}
				// 备注
				if (!string.IsNullOrWhiteSpace(cre.Properties["Remarks"] + ""))
				{
					sqlString += " AND INSTR(sp.Remarks, :in_Remarks) > 0";
					paraList.Add(new OracleParameter(":in_Remarks", OracleDbType.NVarchar2, cre.Properties["Remarks"] + "", ParameterDirection.Input));
				}
				// 审核状态
				if (!string.IsNullOrWhiteSpace(cre.Properties["AuditStatus"] + ""))
				{
					sqlString += " AND sp.AuditStatus = :in_AuditStatus";
					paraList.Add(new OracleParameter(":in_AuditStatus", OracleDbType.Int32, cre.Properties["AuditStatus"], ParameterDirection.Input));
				}
				// 报损开始日期
				if (!string.IsNullOrWhiteSpace(cre.Properties["ScrapDateStart"] + ""))
				{
					sqlString += " AND sp.ScrapDate >= :in_ScrapDateStart";
					paraList.Add(new OracleParameter(":in_ScrapDateStart", OracleDbType.Date, Convert.ToDateTime(cre.Properties["ScrapDateStart"]), ParameterDirection.Input));
				}
				// 报损结束日期
				if (!string.IsNullOrWhiteSpace(cre.Properties["ScrapDateEnd"] + ""))
				{
					sqlString += " AND sp.ScrapDate <= :in_ScrapDateEnd";
					paraList.Add(new OracleParameter(":in_ScrapDateEnd", OracleDbType.Date, Convert.ToDateTime(cre.Properties["ScrapDateEnd"]), ParameterDirection.Input));
				}
				sqlString += " ORDER BY sp.BarCode ";
				DataSet dsReturn = con.GetSqlResultToDs(sqlString, paraList.ToArray());

				// 是否查责任员工 
				if (!string.IsNullOrWhiteSpace(cre.Properties["IsSearchStaff"] + ""))
				{
					string detailString = "SELECT Mu.userid\n" +
											"      ,Staff.Staffid\n" +
											"      ,Staff.Staffname\n" +
											"      ,Staff.Organizationid\n" +
											"      ,Staff.Jobs\n" +
											"      ,Staff.Staffstatus\n" +
											"      ,Staff.Staffcode\n" +
											"      ,Jobs.Jobsname\n" +
											"      ,Mu.UserCode\n" +
											"      ,TUserJobs.Jobsname AS UJobsName\n" +
											"      ,TUserJobs.JobsId AS UJobsId\n" +
											"      , CASE\n" +
											"          WHEN PPG.ResponsibleID IS NULL THEN\n" +
											"           0\n" +
											"          ELSE\n" +
											"           1\n" +
											"        END UserSelected\n" +
											"  FROM TP_PM_GroutingScrapProduct PGS\n" +
											" INNER JOIN TP_MST_User Mu\n" +
											"    ON PGS.ResponUserID = Mu.Userid\n" +
											" INNER JOIN TP_MST_UserStaff Mus\n" +
											"    ON Mu.Userid = Mus.Userid\n" +
											" INNER JOIN TP_HR_Staff Staff\n" +
											"    ON Mus.StaffID = Staff.Staffid\n" +
											"  LEFT JOIN TP_MST_Jobs Jobs\n" +
											"    ON Staff.Jobs = Jobs.Jobsid\n" +
											"  LEFT JOIN TP_MST_Jobs TUserJobs\n" +
											"    ON TUserJobs.Jobsid = Mus.Ujobsid\n" +
											"  LEFT JOIN TP_PM_GroutingScrapResponsible PPG\n" +
											"    ON Staff.Staffid = PPG.Staffid\n" +
											"   AND PPG.ScrapProductID = :in_ScrapProductID\n" +
											" WHERE PGS.ScrapProductID = :in_ScrapProductID";
					OracleParameter[] dparas = new OracleParameter[] {
								new OracleParameter(":in_ScrapProductID",OracleDbType.Int32,
									cre.Properties["ScrapProductID"],ParameterDirection.Input),
					};
					DataTable returnTable = con.GetSqlResultToDt(detailString, dparas);

					if (dsReturn != null)
					{
						dsReturn.Tables.Add(returnTable);
					}
				}
				result.Data = dsReturn;
				return result;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取成型报损信息 用于撤销使用 支持 浆日报直接报损
		/// </summary>
		/// <param name="cre"></param>
		/// <param name="userInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity GetGroutingScrap(ClientRequestEntity cre, SUserInfo userInfo)
		{
			IDBConnection conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				ServiceResultEntity result = new ServiceResultEntity();
				conn.Open();

				//先从成型报损查询
				string sqlString = @"
                    SELECT
                        S.BARCODE,
	                    U.USERCODE,
	                    S.GOODSCODE,
	                    S.GROUTINGMOULDCODE,
	                    S.GROUTINGDATE
                    FROM
                        TP_PM_GROUTINGSCRAPPRODUCT S
                        LEFT JOIN TP_MST_USER U ON S.AUDITOR = U.USERID
                    WHERE
                        S.VALUEFLAG = '1'
                        AND S.BARCODE = :in_BarCode
                ";
				List<OracleParameter> paraList = new List<OracleParameter>();
				paraList.Add(new OracleParameter(":in_BarCode", OracleDbType.Varchar2, cre.Properties["BarCode"], ParameterDirection.Input));
				DataSet dtScrap = conn.GetSqlResultToDs(sqlString, paraList.ToArray());

				//如果没有再从注浆日报损坯标记查询
				if (dtScrap.Tables[0].Rows.Count == 0)
				{
					sqlString = @"
                        SELECT
	                        S.BARCODE,
	                        S.USERCODE,
	                        S.GOODSCODE,
	                        S.GROUTINGMOULDCODE,
	                        S.GROUTINGDATE 
                        FROM
	                        TP_PM_GROUTINGDAILYDETAIL S
                        WHERE
	                        S.VALUEFLAG = '1'
	                        AND S.SCRAPFLAG = '1'
                            AND S.BARCODE = :in_BarCode
                    ";
					dtScrap = conn.GetSqlResultToDs(sqlString, paraList.ToArray());
					if (dtScrap.Tables[0].Rows.Count == 0)
					{
						result.Message = "没查询到报损数据！";
						result.Status = Constant.ServiceResultStatus.NoSearchResults;
					}
					else
					{
						result.Message = "这是注浆日报报损数据！";
						result.Status = Constant.ServiceResultStatus.Success;
					}
				}
				else
				{
					result.Message = "这是成型报损数据！";
					result.Status = Constant.ServiceResultStatus.Success;
				}

				result.Data = dtScrap;
				return result;

			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}


		/// <summary>
		/// 保存成型报损数据
		/// </summary>
		/// <param name="cre"></param>
		/// <param name="userInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity SaveGroutingScrapProduct(ClientRequestEntity cre, SUserInfo userInfo)
		{
			ServiceResultEntity result = new ServiceResultEntity();
			result.Status = Constant.ServiceResultStatus.Success;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			string sqlString = string.Empty;
			int returnRow = Constant.INT_IS_ZERO;

			try
			{
				oracleTrConn.Connect();
				int scrapProductID = Convert.ToInt32(cre.Properties["ScrapProductID"]);

				#region 1、判断是否符合报损条件（未注浆，交坯之后不允许报损,是否进行过了报损）
				sqlString = "SELECT GroutingFlag,DeliverFlag,ScrapFlag,beginningflag\n" +
							 " FROM TP_PM_GroutingDailyDetail \n" +
							 " WHERE AccountID = :AccountID\n" +
							 " AND BarCode = :BarCode\n";
				OracleParameter[] paras = new OracleParameter[] {
							new OracleParameter(":AccountID",OracleDbType.Int32, userInfo.AccountID, ParameterDirection.Input),
							new OracleParameter(":Barcode",OracleDbType.NVarchar2, cre.Properties["BarCode"], ParameterDirection.Input),
				};
				DataTable returnTable = oracleTrConn.GetSqlResultToDt(sqlString, paras);

				// 编码不存在
				if (returnTable.Rows.Count == 0)
				{
					result.Result = -99;
					result.Status = Constant.ServiceResultStatus.SystemError;
					result.Message = "未查询到该产品信息，请确认该产品是否已经进行注浆";
					return result;
				}
				// 未注浆
				if ("0".Equals(returnTable.Rows[0]["GroutingFlag"]))
				{
					result.Result = -100;
					result.Status = Constant.ServiceResultStatus.SystemError;
					result.Message = "该产品还未进行注浆";
					return result;
				}
				// 已经交坯
				if ("1".Equals(returnTable.Rows[0]["DeliverFlag"]))
				{
					result.Result = -101;
					result.Status = Constant.ServiceResultStatus.SystemError;
					result.Message = "该产品已经交坯";
					return result;
				}
				// 已经报损(新建才行进行判断)
				if ("1".Equals(returnTable.Rows[0]["ScrapFlag"]) && scrapProductID == 0)
				{
					result.Result = -102;
					result.Status = Constant.ServiceResultStatus.SystemError;
					result.Message = "该产品已经报损";
					return result;
				}
				// 该产品已进入生产工序
				if ("1".Equals(returnTable.Rows[0]["beginningflag"]))
				{
					result.Result = -103;
					result.Status = Constant.ServiceResultStatus.SystemError;
					result.Message = "该产品已进入生产工序";
					return result;
				}
				#endregion

				#region 2、保存报损信息
				int? auditor = null;
				DateTime? auditDate = null;
				if (!Constant.AuditStatus.Pending.GetHashCode().Equals(cre.Properties["AuditStatus"]))
				{
					auditor = userInfo.UserID;
					auditDate = DateTime.Now;
				}

				#region 新建
				if (scrapProductID == 0)
				{
					#region 报损总表
					sqlString = "SELECT SEQ_PM_GroutingScrapProduct_ID.nextval FROM DUAL";
					scrapProductID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sqlString));

					sqlString = "INSERT INTO TP_PM_GroutingScrapProduct\n" +
									"  (ScrapProductID\n" +
									"  ,BarCode\n" +
									"  ,GoodsID\n" +
									"  ,GoodsCode\n" +
									"  ,GoodsName\n" +
									"  ,GroutingDailyID\n" +
									"  ,GroutingDailyDetailID\n" +
									"  ,GroutingDate\n" +
									"  ,GroutingLineID\n" +
									"  ,GroutingLineCode\n" +
									"  ,GroutingLineName\n" +
									"  ,GMouldTypeID\n" +
									"  ,GroutingLineDetailID\n" +
									"  ,GroutingMouldCode\n" +
									"  ,MouldCode\n" +
									"  ,GroutingUserID\n" +
									"  ,GroutingUserCode\n" +
									"  ,GroutingNum\n" +
									"  ,ScrapType\n" +
									"  ,ResponType\n" +
									"  ,ScrapDate\n" +
									"  ,ScrapRreasonID\n" +
									"  ,ResponUserID\n" +
									"  ,ResponUserCode\n" +
									"  ,Remarks\n" +
									"  ,AuditStatus\n" +
									"  ,Auditor\n" +
									"  ,AuditDate\n" +
									"  ,AccountDate\n" +
									"  ,AccountID\n" +
									"  ,CreateUserID\n" +
									"  ,UpdateUserID)\n" +
									"VALUES\n" +
									"  (:ScrapProductID\n" +
									"  ,:BarCode\n" +
									"  ,:GoodsID\n" +
									"  ,:GoodsCode\n" +
									"  ,:GoodsName\n" +
									"  ,:GroutingDailyID\n" +
									"  ,:GroutingDailyDetailID\n" +
									"  ,:GroutingDate\n" +
									"  ,:GroutingLineID\n" +
									"  ,:GroutingLineCode\n" +
									"  ,:GroutingLineName\n" +
									"  ,:GMouldTypeID\n" +
									"  ,:GroutingLineDetailID\n" +
									"  ,:GroutingMouldCode\n" +
									"  ,:MouldCode\n" +
									"  ,:GroutingUserID\n" +
									"  ,:GroutingUserCode\n" +
									"  ,:GroutingNum\n" +
									"  ,:ScrapType\n" +
									"  ,:ResponType\n" +
									"  ,:ScrapDate\n" +
									"  ,:ScrapRreasonID\n" +
									"  ,:ResponUserID\n" +
									"  ,:ResponUserCode\n" +
									"  ,:Remarks\n" +
									"  ,:AuditStatus\n" +
									"  ,:Auditor\n" +
									"  ,:AuditDate\n" +
									"  ,sysdate\n" +
									"  ,:AccountID\n" +
									"  ,:CreateUserID\n" +
									"  ,:UpdateUserID)";
					paras = new OracleParameter[] {
							new OracleParameter(":ScrapProductID",OracleDbType.Int32, scrapProductID, ParameterDirection.Input),
							new OracleParameter(":Barcode",OracleDbType.NVarchar2, cre.Properties["BarCode"], ParameterDirection.Input),
							new OracleParameter(":GoodsID",OracleDbType.Int32, cre.Properties["GoodsID"], ParameterDirection.Input),
							new OracleParameter(":GoodsCode",OracleDbType.NVarchar2, cre.Properties["GoodsCode"], ParameterDirection.Input),
							new OracleParameter(":GoodsName",OracleDbType.NVarchar2, cre.Properties["GoodsName"], ParameterDirection.Input),
							new OracleParameter(":GroutingDailyID",OracleDbType.Int32, cre.Properties["GroutingDailyID"], ParameterDirection.Input),
							new OracleParameter(":GroutingDailyDetailID",OracleDbType.Int32,
										cre.Properties["GroutingDailyDetailID"], ParameterDirection.Input),
							new OracleParameter(":GroutingDate",OracleDbType.Date,
										Convert.ToDateTime(cre.Properties["GroutingDate"]), ParameterDirection.Input),
							new OracleParameter(":GroutingLineID",OracleDbType.Int32, cre.Properties["GroutingLineID"], ParameterDirection.Input),
							new OracleParameter(":GroutingLineCode",OracleDbType.NVarchar2, cre.Properties["GroutingLineCode"], ParameterDirection.Input),
							new OracleParameter(":GroutingLineName",OracleDbType.NVarchar2, cre.Properties["GroutingLineName"], ParameterDirection.Input),
							new OracleParameter(":GMouldTypeID",OracleDbType.Int32, cre.Properties["GMouldTypeID"], ParameterDirection.Input),
							new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32, cre.Properties["GroutingLineDetailID"], ParameterDirection.Input),
							new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2, cre.Properties["GroutingMouldCode"], ParameterDirection.Input),
							new OracleParameter(":MouldCode",OracleDbType.NVarchar2, cre.Properties["MouldCode"], ParameterDirection.Input),
							new OracleParameter(":GroutingUserID",OracleDbType.Int32, cre.Properties["GroutingUserID"], ParameterDirection.Input),
							new OracleParameter(":GroutingUserCode",OracleDbType.NVarchar2, cre.Properties["GroutingUserCode"], ParameterDirection.Input),
							new OracleParameter(":GroutingNum",OracleDbType.Decimal, cre.Properties["GroutingNum"], ParameterDirection.Input),
							new OracleParameter(":ScrapType",OracleDbType.Char, cre.Properties["ScrapType"], ParameterDirection.Input),
							new OracleParameter(":ResponType",OracleDbType.Char, Constant.ScrapResponType.Person.GetHashCode(),
										ParameterDirection.Input),
							new OracleParameter(":ScrapDate",OracleDbType.Date,
										Convert.ToDateTime(cre.Properties["ScrapDate"]), ParameterDirection.Input),
							new OracleParameter(":ScrapRreasonID",OracleDbType.Int32, cre.Properties["ScrapRreasonID"], ParameterDirection.Input),
							new OracleParameter(":ResponUserID",OracleDbType.Int32, cre.Properties["ResponUserID"], ParameterDirection.Input),
							new OracleParameter(":ResponUserCode",OracleDbType.NVarchar2, cre.Properties["ResponUserCode"], ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.NVarchar2, cre.Properties["Remarks"], ParameterDirection.Input),
							new OracleParameter(":AuditStatus",OracleDbType.Int32, cre.Properties["AuditStatus"], ParameterDirection.Input),
							new OracleParameter(":Auditor",OracleDbType.Int32, auditor, ParameterDirection.Input),
							new OracleParameter(":AuditDate",OracleDbType.Date, auditDate, ParameterDirection.Input),
							new OracleParameter(":AccountID",OracleDbType.Int32, userInfo.AccountID, ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32, userInfo.UserID, ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32, userInfo.UserID, ParameterDirection.Input),
					};
					returnRow += oracleTrConn.ExecuteNonQuery(sqlString, paras);
					#endregion

					#region 报损责任者
					if (cre.Data != null && cre.Data.Tables.Count > 0
						&& cre.Data.Tables[0].Rows.Count > 0)
					{
						foreach (DataRow row in cre.Data.Tables[0].Rows)
						{
							sqlString = "INSERT INTO TP_PM_GroutingScrapResponsible\n" +
											"  (\n" +
											"  ScrapProductID\n" +
											"  ,BarCode\n" +
											"  ,StaffID\n" +
											"  ,StaffStatus\n" +
											"  ,UserID\n" +
											"  ,UserCode\n" +
											"  ,UJobsID\n" +
											"  ,SJobsID\n" +
											"  ,AccountID\n" +
											"  ,CreateUserID\n" +
											"  ,UpdateUserID)\n" +
											"VALUES\n" +
											"  (\n" +
											"  :ScrapProductID\n" +
											"  ,:BarCode\n" +
											"  ,:StaffID\n" +
											"  ,:StaffStatus\n" +
											"  ,:UserID\n" +
											"  ,:UserCode\n" +
											"  ,:UJobsID\n" +
											"  ,:SJobsID\n" +
											"  ,:AccountID\n" +
											"  ,:CreateUserID\n" +
											"  ,:UpdateUserID)";
							paras = new OracleParameter[] {
								new OracleParameter(":ScrapProductID",OracleDbType.Int32, scrapProductID, ParameterDirection.Input),
								new OracleParameter(":Barcode",OracleDbType.NVarchar2, cre.Properties["BarCode"], ParameterDirection.Input),
								new OracleParameter(":StaffID",OracleDbType.Int32, row["StaffID"], ParameterDirection.Input),
								new OracleParameter(":StaffStatus",OracleDbType.Int32, row["StaffStatus"], ParameterDirection.Input),
								new OracleParameter(":UserID",OracleDbType.Int32, row["UserID"], ParameterDirection.Input),
								new OracleParameter(":UserCode",OracleDbType.NVarchar2, row["UserCode"], ParameterDirection.Input),
								new OracleParameter(":UJobsID",OracleDbType.Int32, row["UJobsId"], ParameterDirection.Input),
								new OracleParameter(":SJobsID",OracleDbType.Int32, row["Jobs"], ParameterDirection.Input),
								new OracleParameter(":AccountID",OracleDbType.Int32, userInfo.AccountID, ParameterDirection.Input),
								new OracleParameter(":CreateUserID",OracleDbType.Int32, userInfo.UserID, ParameterDirection.Input),
								new OracleParameter(":UpdateUserID",OracleDbType.Int32, userInfo.UserID, ParameterDirection.Input),
							};
							returnRow += oracleTrConn.ExecuteNonQuery(sqlString, paras);
						}
					}
					#endregion

					#region 更新注浆日报明细表
					sqlString = "UPDATE TP_PM_GroutingDailyDetail\n" +
								"   SET ScrapFlag    = :ScrapFlag\n" +
								"      ,SReasonID    = :SReasonID\n" +
								"      ,ScrapType    = :ScrapType\n" +
								"      ,ScrapTime    = sysdate\n" +
								"      ,ScrapUser    = :ScrapUser\n" +
								"      ,UpdateUserID = :UpdateUserID\n" +
								" WHERE GroutingDailyDetailID = :GroutingDailyDetailID";
					paras = new OracleParameter[] {
							new OracleParameter(":ScrapFlag",OracleDbType.Char, 1, ParameterDirection.Input),
							new OracleParameter(":SReasonID",OracleDbType.NVarchar2, cre.Properties["ScrapRreasonID"], ParameterDirection.Input),
							new OracleParameter(":ScrapType",OracleDbType.Char, cre.Properties["ScrapType"], ParameterDirection.Input),
                            //new OracleParameter(":ScrapTime",OracleDbType.Date,
                            //        Convert.ToDateTime(cre.Properties["ScrapDate"]), ParameterDirection.Input),
                            new OracleParameter(":ScrapUser",OracleDbType.Int32, cre.Properties["ResponUserID"], ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32, userInfo.UserID, ParameterDirection.Input),
							new OracleParameter(":GroutingDailyDetailID",OracleDbType.Int32,
									cre.Properties["GroutingDailyDetailID"], ParameterDirection.Input),
					};
					returnRow += oracleTrConn.ExecuteNonQuery(sqlString, paras);
					#endregion
				}
				#endregion

				#region 编辑
				else
				{
					#region 报损总表
					sqlString = "UPDATE TP_PM_GroutingScrapProduct\n" +
								"   SET ScrapType      = :in_ScrapType\n" +
								"      ,ResponType     = :in_ResponType\n" +
								"      ,ScrapDate      = :in_ScrapDate\n" +
								"      ,ScrapRreasonID = :in_ScrapRreasonID\n" +
								"      ,ResponUserID   = :in_ResponUserID\n" +
								"      ,ResponUserCode = :in_ResponUserCode\n" +
								"      ,Remarks        = :in_Remarks\n" +
								"      ,AuditStatus    = :in_AuditStatus\n" +
								"      ,Auditor        = :in_Auditor\n" +
								"      ,AuditDate      = :in_AuditDate\n" +
								"      ,UpdateUserID   = :in_UpdateUserID\n" +
								" WHERE ScrapProductID = :in_ScrapProductID";

					paras = new OracleParameter[] {
							new OracleParameter(":in_ScrapProductID",OracleDbType.Int32, scrapProductID, ParameterDirection.Input),
							new OracleParameter(":in_ScrapType",OracleDbType.Char, cre.Properties["ScrapType"], ParameterDirection.Input),
							new OracleParameter(":in_ResponType",OracleDbType.Char, Constant.ScrapResponType.Person.GetHashCode(),
										ParameterDirection.Input),
							new OracleParameter(":in_ScrapDate",OracleDbType.Date,
										Convert.ToDateTime(cre.Properties["ScrapDate"]), ParameterDirection.Input),
							new OracleParameter(":in_ScrapRreasonID",OracleDbType.Int32, cre.Properties["ScrapRreasonID"], ParameterDirection.Input),
							new OracleParameter(":in_ResponUserID",OracleDbType.Int32, cre.Properties["ResponUserID"], ParameterDirection.Input),
							new OracleParameter(":in_ResponUserCode",OracleDbType.NVarchar2, cre.Properties["ResponUserCode"], ParameterDirection.Input),
							new OracleParameter(":in_Remarks",OracleDbType.NVarchar2, cre.Properties["Remarks"], ParameterDirection.Input),
							new OracleParameter(":in_AuditStatus",OracleDbType.Int32, cre.Properties["AuditStatus"], ParameterDirection.Input),
							new OracleParameter(":in_Auditor",OracleDbType.Int32, auditor, ParameterDirection.Input),
							new OracleParameter(":in_AuditDate",OracleDbType.Date, auditDate, ParameterDirection.Input),
							new OracleParameter(":in_UpdateUserID",OracleDbType.Int32, userInfo.UserID, ParameterDirection.Input),
					};
					returnRow += oracleTrConn.ExecuteNonQuery(sqlString, paras);
					#endregion

					#region 报损责任者
					if (cre.Data != null && cre.Data.Tables.Count > 0
						&& cre.Data.Tables[0].Rows.Count > 0)
					{
						// 先删除 后插入
						sqlString = "DELETE TP_PM_GroutingScrapResponsible\n" +
									" WHERE ScrapProductID = :in_ScrapProductID";
						paras = new OracleParameter[] {
							new OracleParameter(":in_ScrapProductID",OracleDbType.Int32, scrapProductID, ParameterDirection.Input),
						};
						returnRow += oracleTrConn.ExecuteNonQuery(sqlString, paras);

						foreach (DataRow row in cre.Data.Tables[0].Rows)
						{
							sqlString = "INSERT INTO TP_PM_GroutingScrapResponsible\n" +
											"  (\n" +
											"  ScrapProductID\n" +
											"  ,BarCode\n" +
											"  ,StaffID\n" +
											"  ,StaffStatus\n" +
											"  ,UserID\n" +
											"  ,UserCode\n" +
											"  ,UJobsID\n" +
											"  ,SJobsID\n" +
											"  ,AccountID\n" +
											"  ,CreateUserID\n" +
											"  ,UpdateUserID)\n" +
											"VALUES\n" +
											"  (\n" +
											"  :ScrapProductID\n" +
											"  ,:BarCode\n" +
											"  ,:StaffID\n" +
											"  ,:StaffStatus\n" +
											"  ,:UserID\n" +
											"  ,:UserCode\n" +
											"  ,:UJobsID\n" +
											"  ,:SJobsID\n" +
											"  ,:AccountID\n" +
											"  ,:CreateUserID\n" +
											"  ,:UpdateUserID)";
							paras = new OracleParameter[] {
								new OracleParameter(":ScrapProductID",OracleDbType.Int32, scrapProductID, ParameterDirection.Input),
								new OracleParameter(":Barcode",OracleDbType.NVarchar2, cre.Properties["BarCode"], ParameterDirection.Input),
								new OracleParameter(":StaffID",OracleDbType.Int32, row["StaffID"], ParameterDirection.Input),
								new OracleParameter(":StaffStatus",OracleDbType.Int32, row["StaffStatus"], ParameterDirection.Input),
								new OracleParameter(":UserID",OracleDbType.Int32, row["UserID"], ParameterDirection.Input),
								new OracleParameter(":UserCode",OracleDbType.NVarchar2, row["UserCode"], ParameterDirection.Input),
								new OracleParameter(":UJobsID",OracleDbType.Int32, row["UJobsId"], ParameterDirection.Input),
								new OracleParameter(":SJobsID",OracleDbType.Int32, row["Jobs"], ParameterDirection.Input),
								new OracleParameter(":AccountID",OracleDbType.Int32, userInfo.AccountID, ParameterDirection.Input),
								new OracleParameter(":CreateUserID",OracleDbType.Int32, userInfo.UserID, ParameterDirection.Input),
								new OracleParameter(":UpdateUserID",OracleDbType.Int32, userInfo.UserID, ParameterDirection.Input),
							};
							returnRow += oracleTrConn.ExecuteNonQuery(sqlString, paras);
						}
					}
					#endregion

					#region 更新注浆日报明细表
					sqlString = "UPDATE TP_PM_GroutingDailyDetail\n" +
								"   SET SReasonID    = :SReasonID\n" +
								"      ,ScrapType    = :ScrapType\n" +
								"      ,ScrapTime    = sysdate\n" +
								"      ,ScrapUser    = :ScrapUser\n" +
								"      ,UpdateUserID = :UpdateUserID\n" +
								" WHERE GroutingDailyDetailID = :GroutingDailyDetailID";
					paras = new OracleParameter[] {
							new OracleParameter(":SReasonID",OracleDbType.Int32, cre.Properties["ScrapRreasonID"], ParameterDirection.Input),
							new OracleParameter(":ScrapType",OracleDbType.Char, cre.Properties["ScrapType"], ParameterDirection.Input),
                            //new OracleParameter(":ScrapTime",OracleDbType.Date,
                            //        Convert.ToDateTime(cre.Properties["ScrapDate"]), ParameterDirection.Input),
                            new OracleParameter(":ScrapUser",OracleDbType.Int32, cre.Properties["ResponUserID"], ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32, userInfo.UserID, ParameterDirection.Input),
							new OracleParameter(":GroutingDailyDetailID",OracleDbType.Int32,
									cre.Properties["GroutingDailyDetailID"], ParameterDirection.Input),
					};
					returnRow += oracleTrConn.ExecuteNonQuery(sqlString, paras);
					#endregion
				}
				#endregion

				#endregion

				oracleTrConn.Commit();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				result.Result = -999;
				result.Status = Constant.ServiceResultStatus.SystemError;
				result.Message = "成型报损保存失败";
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			result.Result = returnRow;
			return result;
		}

		/// <summary>
		/// 审核成型报损
		/// </summary>
		/// <param name="cre"></param>
		/// <param name="userInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity AuditGroutingScrapProduct(ClientRequestEntity cre, SUserInfo userInfo)
		{
			ServiceResultEntity result = new ServiceResultEntity();
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			string sqlString = string.Empty;
			int returnRow = Constant.INT_IS_ZERO;

			try
			{
				oracleTrConn.Connect();

				#region 1、校验该成型报损是否是待审状态
				sqlString = "SELECT 1\n" +
						   " FROM TP_PM_GroutingScrapProduct \n" +
						   " WHERE ScrapProductID = :in_ScrapProductID\n" +
						   "   AND AuditStatus = 0";
				OracleParameter[] paras = new OracleParameter[] {
							new OracleParameter(":in_ScrapProductID",OracleDbType.Int32, cre.Properties["ScrapProductID"], ParameterDirection.Input),
				};
				DataTable returnTable = oracleTrConn.GetSqlResultToDt(sqlString, paras);

				// 审核状态不是待审
				if (returnTable.Rows.Count == 0)
				{
					result.Result = -99;
					return result;
				}
				#endregion

				#region 2、审核
				sqlString = "UPDATE TP_PM_GroutingScrapProduct\n" +
							"   SET AuditStatus  = :in_AuditStatus\n" +
							"      ,Auditor      = :in_Auditor\n" +
							"      ,AuditDate    = :in_AuditDate\n" +
							"      ,AuditOpinion = :in_AuditOpinion\n" +
							" WHERE ScrapProductID = :in_ScrapProductID";
				paras = new OracleParameter[] {
							new OracleParameter(":in_ScrapProductID",OracleDbType.Int32, cre.Properties["ScrapProductID"], ParameterDirection.Input),
							new OracleParameter(":in_AuditStatus",OracleDbType.Int32, cre.Properties["AuditStatus"], ParameterDirection.Input),
							new OracleParameter(":in_Auditor",OracleDbType.Int32, cre.Properties["Auditor"], ParameterDirection.Input),
							new OracleParameter(":in_AuditDate",OracleDbType.Date, DateTime.Now, ParameterDirection.Input),
							new OracleParameter(":in_AuditOpinion",OracleDbType.NVarchar2, cre.Properties["AuditOpinion"], ParameterDirection.Input),
				};
				returnRow += oracleTrConn.ExecuteNonQuery(sqlString, paras);
				#endregion

				oracleTrConn.Commit();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			result.Result = returnRow;
			return result;
		}

		/// <summary>
		/// 撤销成型报损
		/// </summary>
		/// <param name="cre"></param>
		/// <param name="userInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity ReverseGroutingScrapProduct(ClientRequestEntity cre, SUserInfo userInfo)
		{
			ServiceResultEntity result = new ServiceResultEntity();
			result.Status = Constant.ServiceResultStatus.Success;

			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			string sqlString = string.Empty;
			int returnRow = Constant.INT_IS_ZERO;

			try
			{
				oracleTrConn.Connect();

				#region 1、校验该成型报损是否是待审状态
				sqlString = "SELECT SCRAPPRODUCTID\n" +
						   " FROM TP_PM_GroutingScrapProduct \n" +
						   " WHERE BackOutFlag = '0'\n" +
						   " AND BarCode = :in_BarCode\n";
				OracleParameter[] paras = new OracleParameter[] {
							new OracleParameter(":in_BarCode",OracleDbType.NVarchar2, cre.Properties["BarCode"], ParameterDirection.Input),
				};
				DataTable returnTable = oracleTrConn.GetSqlResultToDt(sqlString, paras);
				DataTable groutingTable = null;

				// 该产品没有做成型报损
				if (returnTable.Rows.Count == 0)
				{
					//xuwei add 2020-03-23 再次从注浆表查询报损状态
					sqlString = @"
                        SELECT
	                        GROUTINGDAILYDETAILID 
                        FROM
	                        TP_PM_GROUTINGDAILYDETAIL 
                        WHERE
	                        SCRAPFLAG = '1'
	                        AND VALUEFLAG = '1'
	                        AND BARCODE = :in_BarCode
                    ";
					groutingTable = oracleTrConn.GetSqlResultToDt(sqlString, paras);
					if (groutingTable.Rows.Count == 0)
					{
						result.Result = -99;
						result.Status = Constant.ServiceResultStatus.SystemError;
						result.Message = "此产品没有损坯或已被撤销，不能撤销";
						return result;
					}
				}
				//// 该产品已经做了撤销了
				//if ("1".Equals(returnTable.Rows[0]["BackOutFlag"]))
				//{
				//    result.Result = -100;
				//    result.Status = Constant.ServiceResultStatus.SystemError;
				//    result.Message = "此产品已经撤销";
				//    return result;
				//}
				#endregion

				#region 2、撤销
				//xuwei fix 2020-03-23 如果成型报损才更新
				if (returnTable.Rows.Count > 0)
				{
					sqlString = "UPDATE TP_PM_GroutingScrapProduct\n" +
								"   SET BackOutFlag     = :in_BackOutFlag\n" +
								"      ,BackOutTime     = :in_BackOutTime\n" +
								"      ,BackOutUserID   = :in_BackOutUserID\n" +
								"      ,BackOutUserCode = :in_BackOutUserCode\n" +
								" WHERE SCRAPPRODUCTID = :in_ScrapProductID";
					paras = new OracleParameter[] {
								new OracleParameter(":in_ScrapProductID",OracleDbType.NVarchar2, returnTable.Rows[0]["SCRAPPRODUCTID"].ToString(), ParameterDirection.Input),
								new OracleParameter(":in_BackOutFlag",OracleDbType.Int32, Constant.INT_IS_ONE, ParameterDirection.Input),
								new OracleParameter(":in_BackOutTime",OracleDbType.Date, DateTime.Now, ParameterDirection.Input),
								new OracleParameter(":in_BackOutUserID",OracleDbType.Int32, userInfo.UserID, ParameterDirection.Input),
								new OracleParameter(":in_BackOutUserCode",OracleDbType.NVarchar2, userInfo.UserCode , ParameterDirection.Input),
					};
					returnRow += oracleTrConn.ExecuteNonQuery(sqlString, paras);
				}

				sqlString = "UPDATE TP_PM_GroutingDailyDetail\n" +
							"   SET ScrapFlag = :in_ScrapFlag\n" +
							"      ,SReasonID = NULL\n" +
							"      ,ScrapType = NULL\n" +
							"      ,ScrapTime = NULL\n" +
							"      ,ScrapUser = NULL\n" +
							" WHERE BarCode = :in_BarCode";
				paras = new OracleParameter[] {
							new OracleParameter(":in_BarCode",OracleDbType.NVarchar2, cre.Properties["BarCode"], ParameterDirection.Input),
							new OracleParameter(":in_ScrapFlag",OracleDbType.Char, "0" , ParameterDirection.Input),
				};
				returnRow += oracleTrConn.ExecuteNonQuery(sqlString, paras);
				#endregion

				oracleTrConn.Commit();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				result.Status = Constant.ServiceResultStatus.SystemError;
				result.Message = "撤销成型报损失败";
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			result.Result = returnRow;
			return result;
		}

		/// <summary>
		/// 获取注浆日报明细表
		/// </summary>
		/// <param name="cre"></param>
		/// <param name="userInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity GetGroutingDailyDetail(ClientRequestEntity cre, SUserInfo userInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				ServiceResultEntity result = new ServiceResultEntity();
				con.Open();

				string sqlString = "SELECT PGD.GroutingDailyDetailID\n" +
								"      ,PGD.GroutingDailyID\n" +
								"      ,PGD.GroutingLineID\n" +
								"      ,PGD.GroutingLineCode\n" +
								"      ,PGD.GroutingLineName\n" +
								"      ,PGD.GroutingLineDetailID\n" +
								"      ,PGD.GroutingDate\n" +
								"      ,PGD.GroutingMouldCode\n" +
								"      ,PGD.MouldCode\n" +
								"      ,PGD.GMouldTypeID\n" +
								"      ,PGD.CanManyTimes\n" +
								"      ,PGD.GroutingBatchNo\n" +
								"      ,PGD.UserID GroutingUserID\n" +
								"      ,PGD.UserCode GroutingUserCode\n" +
								"      ,PGD.ClassesSettingID\n" +
								"      ,PGD.GoodsID\n" +
								"      ,PGD.GoodsCode\n" +
								"      ,PGD.GoodsName\n" +
								"      ,PGD.GMouldStatus\n" +
								"      ,PGD.GroutingCount GroutingNum\n" +
								"      ,PGD.GroutingFlag\n" +
								"      ,PGD.BarCode\n" +
								"      ,PGD.OnlyCode\n" +
								//"      ,PGD.PrintTime\n" +
								"      ,PGD.NoGroutingRreason\n" +
								"      ,PGD.SpecialRepairFlag\n" +
								"      ,PGD.ScrapFlag\n" +
								"      ,PGD.SReasonID\n" +
								"      ,PGD.ScrapType\n" +
								"      ,PGD.ScrapTime\n" +
								"      ,PGD.ScrapUser\n" +
								"      ,PGD.IsPublicBody\n" +
								"      ,PGD.DeliverFlag\n" +
								"      ,PGD.beginningflag\n" +
								"  FROM TP_PM_GroutingDailyDetail PGD\n" +
								" WHERE PGD.AccountID = :in_AccountID";
				List<OracleParameter> paraList = new List<OracleParameter>();
				paraList.Add(new OracleParameter(":in_AccountID", OracleDbType.Int32, userInfo.AccountID, ParameterDirection.Input));

				// 产品条码
				if (!string.IsNullOrWhiteSpace(cre.Properties["BarCode"] + ""))
				{
					sqlString += " AND PGD.BarCode = :in_BarCode ";
					paraList.Add(new OracleParameter(":in_BarCode", OracleDbType.NVarchar2, cre.Properties["BarCode"] + "", ParameterDirection.Input));
				}
				DataSet dsReturn = con.GetSqlResultToDs(sqlString, paraList.ToArray());
				result.Data = dsReturn;
				return result;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}
		#endregion

		#region 产品挂起

		/// <summary>
		/// 获取可以挂起的工序（干补、装车、入窑、出窑）工序不能挂起
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetSuspendProcedure(SUserInfo user)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				conn.Open();

				string sqlString = "SELECT p.procedureid, p.procedurename\n" +
				"  FROM tp_pc_procedure p\n" +
				" INNER JOIN tp_pc_productionline line\n" +
				"    ON line.productionlineid = p.productionlineid\n" +
				" WHERE line.valueflag = '1'\n" +
				"   AND p.valueflag = '1'\n" +
				"   AND p.NODETYPE <> '3'\n" +
				//"   AND p.modeltype IN (-1, 0, 4, 5, 9)\n" +
				"   AND p.modeltype IN (0, 4, 5, 9)\n" +
				"   AND p.PROCEDUREMODEL = '1'\n" +
				"   AND p.accountid = :accountid\n" +
				"   AND line.accountid = :accountid\n" +
				" ORDER BY line.productionlineid, p.displayno";

				IDataParameter[] paras = new OracleParameter[]
				{
					new OracleParameter(":accountID", OracleDbType.Int32,user.AccountID, ParameterDirection.Input),
				};
				DataSet data = conn.GetSqlResultToDs(sqlString, paras);

				ServiceResultEntity sre = new ServiceResultEntity();
				sre.Data = data;
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 验证挂起条码
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity CheckSuspendBarcode(SUserInfo user, string barcode)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				conn.Open();

				string sqlString = "SELECT 1 AS SEL, gdd.groutingdailydetailid\n" +
				"      ,gdd.barcode\n" +
				"      ,gdd.groutingmouldcode\n" +
				"      ,gdd.groutingdate\n" +
				"      ,gdd.goodscode\n" +
				"      ,gdd.usercode\n" +
				"      ,gdd.scrapflag\n" +
				"      ,gdd.deliverflag\n" +
				"      ,inp.procedureid\n" +
				"      ,p.procedurename\n" +
				"  FROM tp_pm_groutingdailydetail gdd\n" +
				"  LEFT JOIN tp_pm_inproduction inp\n" +
				"    ON inp.barcode = gdd.barcode\n" +
				"  LEFT JOIN tp_pc_procedure p\n" +
				"    ON p.procedureid = inp.procedureid\n" +
				" WHERE gdd.accountid = :accountid\n" +
				"   AND gdd.barcode = :barcode";

				IDataParameter[] paras = new OracleParameter[]
				{
					new OracleParameter(":accountID", OracleDbType.Int32,user.AccountID, ParameterDirection.Input),
					new OracleParameter(":barcode", OracleDbType.NVarchar2,barcode, ParameterDirection.Input),
				};
				DataSet data = conn.GetSqlResultToDs(sqlString, paras);

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Tables.Count == 0 || data.Tables[0].Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.Message = "无效条码";
					return sre;
				}

				DataRow row = data.Tables[0].Rows[0];
				if (row["scrapflag"] + "" == "1" || (row["deliverflag"] + "" == "1" && row["procedureid"] + "" == ""))
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.Message = "此条码不是在产产品";
					return sre;
				}

				sre.Data = data;
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 保存条码挂起
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity SaveSuspendProduct(SUserInfo user, int[] procedureids, int[] groutingdailydetailids, string remarks)
		{
			IDBTransaction conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);

				string suspendBatchNo = Guid.NewGuid().ToString().ToUpper();

				string sqlDelete = "DELETE FROM TP_PM_ProductSuspend ps\n" +
				" WHERE ps.groutingdailydetailid = :groutingdailydetailid\n" +
				"   AND ps.suspendprocedureid = :suspendprocedureid";

				string sqlUpdateRecord = "update TP_PM_ProductSuspendRecord r set RevokeTime=sysdate, RevokeUserID=" + user.UserID +
				" WHERE RevokeUserID is null and r.groutingdailydetailid = :groutingdailydetailid\n" +
				"   AND r.suspendprocedureid = :suspendprocedureid";

				string sqlInsert = "INSERT INTO TP_PM_PRODUCTSUSPEND\n" +
				"  (GROUTINGDAILYDETAILID\n" +
				"  ,SUSPENDPROCEDUREID\n" +
				"  ,REMARKS\n" +
				"  ,SUSPENDBATCHNO\n" +
				"  ,ACCOUNTID\n" +
				"  ,CREATEUSERID)\n" +
				"VALUES\n" +
				"  (:GROUTINGDAILYDETAILID\n" +
				"  ,:SUSPENDPROCEDUREID\n" +
				"  ,:REMARKS\n" +
				"  ,:SUSPENDBATCHNO\n" +
				"  ,:ACCOUNTID\n" +
				"  ,:CREATEUSERID)";

				string sqlInsertRecord = "INSERT INTO TP_PM_PRODUCTSUSPENDRecord\n" +
				"  (GROUTINGDAILYDETAILID\n" +
				"  ,SUSPENDPROCEDUREID\n" +
				"  ,REMARKS\n" +
				"  ,SUSPENDBATCHNO\n" +
				"  ,ACCOUNTID\n" +
				"  ,CREATEUSERID)\n" +
				"VALUES\n" +
				"  (:GROUTINGDAILYDETAILID\n" +
				"  ,:SUSPENDPROCEDUREID\n" +
				"  ,:REMARKS\n" +
				"  ,:SUSPENDBATCHNO\n" +
				"  ,:ACCOUNTID\n" +
				"  ,:CREATEUSERID)";

				foreach (int procedureid in procedureids)
				{
					foreach (int groutingdailydetailid in groutingdailydetailids)
					{
						IDataParameter[] deleteParas = new OracleParameter[]
						{
							new OracleParameter(":groutingdailydetailid", OracleDbType.Int32,groutingdailydetailid, ParameterDirection.Input),
							new OracleParameter(":suspendprocedureid", OracleDbType.Int32,procedureid, ParameterDirection.Input),
						};

						conn.ExecuteNonQuery(sqlDelete, deleteParas);
						conn.ExecuteNonQuery(sqlUpdateRecord, deleteParas);

						IDataParameter[] insertParas = new OracleParameter[]
						{
							new OracleParameter(":GROUTINGDAILYDETAILID", OracleDbType.Int32,groutingdailydetailid, ParameterDirection.Input),
							new OracleParameter(":SUSPENDPROCEDUREID", OracleDbType.Int32,procedureid, ParameterDirection.Input),
							new OracleParameter(":REMARKS", OracleDbType.NVarchar2,remarks, ParameterDirection.Input),
							new OracleParameter(":SUSPENDBATCHNO", OracleDbType.Varchar2,suspendBatchNo, ParameterDirection.Input),
							new OracleParameter(":ACCOUNTID", OracleDbType.Int32,user.AccountID, ParameterDirection.Input),
							new OracleParameter(":CREATEUSERID", OracleDbType.Int32,user.UserID, ParameterDirection.Input),
						};

						conn.ExecuteNonQuery(sqlInsert, insertParas);
						conn.ExecuteNonQuery(sqlInsertRecord, insertParas);
					}
				}

				conn.Commit();
				conn.Disconnect();

				return new ServiceResultEntity();
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 查询挂起条码
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetSuspendProduct(SUserInfo user, string barcode)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				conn.Open();

				string sqlString = "SELECT 0 AS SEL, gdd.barcode\n" +
				"      ,gdd.groutingmouldcode\n" +
				"      ,gdd.groutingdate\n" +
				"      ,gdd.goodscode\n" +
				"      ,gdd.usercode\n" +
				"      ,ps.groutingdailydetailid\n" +
				"      ,ps.suspendprocedureid\n" +
				"      ,sp.procedurename suspendprocedurename\n" +
				"      ,ps.remarks\n" +
				"      ,ps.Createtime\n" +
				"      ,u.usercode CREATEUSERCode\n" +

				"      ,case when gdd.scrapflag = '1' then '成型损坯'" +
				"            when gdd.deliverflag = '0' then '注浆' " +
				"            when inp.barcode is not null then to_char(p.procedurename) " +
				"            when spp.barcode is not null then to_char(glt.goodsleveltypename) " +
				"            when fp.barcode is not null then '生产完成' else '' end procedurename -- 当前工序\n" +
				"  FROM TP_PM_ProductSuspend ps\n" +
				" INNER JOIN tp_pm_groutingdailydetail gdd\n" +
				"    ON gdd.groutingdailydetailid = ps.groutingdailydetailid\n" +
				" INNER JOIN tp_pc_procedure sp\n" +
				"    ON ps.suspendprocedureid = sp.procedureid\n" +
				" INNER JOIN tp_mst_user u\n" +
				"    ON u.userid = ps.CREATEUSERID\n" +

				// 在产工序
				"  LEFT JOIN  tp_pm_inproduction inp \n" +
				"    ON gdd.deliverflag = '1' and inp.barcode = gdd.barcode\n" +
				"  LEFT JOIN  tp_pc_procedure p \n" +
				"    ON p.procedureid = inp.procedureid\n" +
				// 完成
				"  LEFT JOIN tp_pm_finishedproduct fp \n" +
				"    ON gdd.deliverflag = '1' and inp.barcode is null and fp.barcode = gdd.barcode\n" +
				// 损坯
				"  LEFT JOIN  tp_pm_scrapproduct spp \n" +
				"    ON gdd.deliverflag = '1' and inp.barcode is null and fp.barcode is null and spp.barcode = gdd.barcode\n" +
				"   AND spp.valueflag = '1'\n" +
				"   AND spp.auditstatus = 1\n" +
				"   AND spp.goodsleveltypeid <> 9\n" +
				"   AND spp.RECYCLINGFLAG = '0'\n" +
				"  LEFT JOIN  tp_sys_goodsleveltype glt \n" +
				"    ON glt.goodsleveltypeid = spp.goodsleveltypeid\n" +

				" WHERE gdd.barcode = :barcode\n" +
				// 有工序撤销权限的用户才能撤销对应工序的挂起 add by chenxy 2020-09-27 恒洁潮州要求
				"   and exists (select 1 from tp_mst_userpurview t where t.purviewtype = 13 and t.userid = :userid and (t.purviewid=-1 or t.purviewid = sp.procedureid))\n" +
				" ORDER BY sp.displayno";

				IDataParameter[] paras = new OracleParameter[]
				{
					new OracleParameter(":barcode", OracleDbType.NVarchar2,barcode, ParameterDirection.Input),
					new OracleParameter(":userid", OracleDbType.NVarchar2,user.UserID, ParameterDirection.Input),
				};
				DataSet data = conn.GetSqlResultToDs(sqlString, paras);

				ServiceResultEntity sre = new ServiceResultEntity();
				sre.Data = data;

				if (data == null || data.Tables.Count == 0 || data.Tables[0].Rows.Count == 0)
				{
					sre.Message = "此条码没有可撤销的挂起信息";
					return sre;
				}
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 撤销条码挂起
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity DeleteSuspendProduct(SUserInfo user, int[] procedureids, int[] groutingdailydetailids)
		{
			IDBTransaction conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);

				string suspendBatchNo = Guid.NewGuid().ToString().ToUpper();

				string sqlDelete = "DELETE FROM TP_PM_ProductSuspend ps\n" +
				" WHERE ps.groutingdailydetailid = :groutingdailydetailid\n" +
				"   AND ps.suspendprocedureid = :suspendprocedureid";

				string sqlUpdateRecord = "update TP_PM_ProductSuspendRecord r set RevokeTime=sysdate, RevokeUserID=" + user.UserID +
				" WHERE RevokeUserID is null and r.groutingdailydetailid = :groutingdailydetailid\n" +
				"   AND r.suspendprocedureid = :suspendprocedureid";

				for (int i = 0; i < procedureids.Length; i++)
				{
					IDataParameter[] deleteParas = new OracleParameter[]
					{
						new OracleParameter(":groutingdailydetailid", OracleDbType.Int32,groutingdailydetailids[i], ParameterDirection.Input),
						new OracleParameter(":suspendprocedureid", OracleDbType.Int32,procedureids[i], ParameterDirection.Input),
					};

					conn.ExecuteNonQuery(sqlDelete, deleteParas);
					conn.ExecuteNonQuery(sqlUpdateRecord, deleteParas);
				}

				conn.Commit();
				conn.Disconnect();
				return new ServiceResultEntity();
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 查询挂起条码
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetAllSuspendProduct(SUserInfo user, ClientRequestEntity cre)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				conn.Open();

				//string sqlString = "SELECT gdd.barcode\n" +
				//"      ,gdd.groutingmouldcode\n" +
				//"      ,gdd.groutingdate\n" +
				//"      ,gdd.goodscode\n" +
				//"      ,gdd.usercode GroutingUserCode\n" +
				//"      ,ps.groutingdailydetailid\n" +
				//"      ,ps.suspendprocedureid\n" +
				//"      ,sp.procedurename suspendprocedurename\n" +
				//"      ,ps.remarks\n" +
				//"      ,ps.Createtime\n" +
				//"      ,u.usercode CREATEUSERCode\n" +
				//"      ,case when gdd.scrapflag = '1' then '成型损坯'" +
				//"            when gdd.deliverflag = '0' then '注浆' " +
				//"            when inp.barcode is not null then to_char(p.procedurename) " +
				//"            when spp.barcode is not null then to_char(glt.goodsleveltypename) " +
				//"            when fp.barcode is not null then '生产完成' else '' end procedurename\n" + // 当前工序
				//"  FROM TP_PM_ProductSuspend ps\n" +
				//" INNER JOIN tp_pc_procedure sp\n" +
				//"    ON ps.suspendprocedureid = sp.procedureid\n" +
				//" INNER JOIN tp_mst_user u\n" +
				//"    ON u.userid = ps.CREATEUSERID\n" +

				//" INNER JOIN tp_pm_groutingdailydetail gdd\n" +
				//"    ON gdd.groutingdailydetailid = ps.groutingdailydetailid\n" +
				//// 在产工序
				//"  LEFT JOIN  tp_pm_inproduction inp \n" +
				//"    ON gdd.deliverflag = '1' and inp.barcode = gdd.barcode\n" +
				//"  LEFT JOIN  tp_pc_procedure p \n" +
				//"    ON p.procedureid = inp.procedureid\n" +
				//    // 完成
				//"  LEFT JOIN tp_pm_finishedproduct fp \n" +
				//"    ON gdd.deliverflag = '1' and inp.barcode is null and fp.barcode = gdd.barcode\n" +
				//    // 损坯
				//"  LEFT JOIN  tp_pm_scrapproduct spp \n" +
				//"    ON gdd.deliverflag = '1' and inp.barcode is null and fp.barcode is null and spp.barcode = gdd.barcode\n" +
				//"   AND spp.valueflag = '1'\n" +
				//"   AND spp.auditstatus = 1\n" +
				//"   AND spp.goodsleveltypeid <> 9\n" +
				//"   AND spp.RECYCLINGFLAG = '0'\n" +
				//"  LEFT JOIN  tp_sys_goodsleveltype glt \n" +
				//"    ON glt.goodsleveltypeid = spp.goodsleveltypeid\n" +

				//" WHERE (:barcode is null or instr(gdd.barcode, :barcode) > 0)\n" +
				//"   AND (:remarks is null or instr(ps.remarks, :remarks) > 0)\n" +
				//"   AND (:datefrom is null or ps.createtime >= :datefrom)\n" +
				//"   AND (:dateend is null or ps.createtime <= :dateend)\n" +

				//" ORDER BY gdd.barcode, sp.displayno ";


				string sqlString = "SELECT GDD.BARCODE,\n" +
				"       GDD.GROUTINGMOULDCODE,\n" +
				"       GDD.GROUTINGDATE,\n" +
				"       GDD.GOODSCODE,\n" +
				"       GDD.USERCODE GROUTINGUSERCODE,\n" +
				"       PSR.GROUTINGDAILYDETAILID,\n" +
				"       PSR.SUSPENDPROCEDUREID,\n" +
				"       SP.PROCEDURENAME SUSPENDPROCEDURENAME,\n" +
				"       PSR.REMARKS,\n" +
				"       PSR.CREATETIME,\n" +
				"       U.USERCODE CREATEUSERCODE,\n" +
				"       CASE\n" +
				"         WHEN GDD.SCRAPFLAG = '1' THEN\n" +
				"          '成型损坯'\n" +
				"         WHEN GDD.DELIVERFLAG = '0' THEN\n" +
				"          '注浆'\n" +
				"         WHEN INP.BARCODE IS NOT NULL THEN\n" +
				"          TO_CHAR(P.PROCEDURENAME)\n" +
				"         WHEN SPP.BARCODE IS NOT NULL THEN\n" +
				"          TO_CHAR(GLT.GOODSLEVELTYPENAME)\n" +
				"         WHEN FP.BARCODE IS NOT NULL THEN\n" +
				"          '生产完成'\n" +
				"         ELSE\n" +
				"          ''\n" +
				"       END PROCEDURENAME,\n" +
				"       TO_CHAR(PSR.REVOKETIME, 'yyyy-mm-dd hh24:mi:ss') AS REVOKETIME,\n" +
				"       REVOKEUSER.USERCODE REVOKEUSERCODE\n" +
				"  FROM TP_PM_PRODUCTSUSPENDRECORD PSR\n" +
				" INNER JOIN TP_PC_PROCEDURE SP\n" +
				"    ON PSR.SUSPENDPROCEDUREID = SP.PROCEDUREID\n" +
				" INNER JOIN TP_MST_USER U\n" +
				"    ON U.USERID = PSR.CREATEUSERID\n" +
				" INNER JOIN TP_PM_GROUTINGDAILYDETAIL GDD\n" +
				"    ON GDD.GROUTINGDAILYDETAILID = PSR.GROUTINGDAILYDETAILID\n" +
				"  LEFT JOIN TP_PM_INPRODUCTION INP\n" +
				"    ON GDD.DELIVERFLAG = '1'\n" +
				"   AND INP.BARCODE = GDD.BARCODE\n" +
				"  LEFT JOIN TP_PC_PROCEDURE P\n" +
				"    ON P.PROCEDUREID = INP.PROCEDUREID\n" +
				"  LEFT JOIN TP_PM_FINISHEDPRODUCT FP\n" +
				"    ON GDD.DELIVERFLAG = '1'\n" +
				"   AND INP.BARCODE IS NULL\n" +
				"   AND FP.BARCODE = GDD.BARCODE\n" +
				"  LEFT JOIN TP_PM_SCRAPPRODUCT SPP\n" +
				"    ON GDD.DELIVERFLAG = '1'\n" +
				"   AND INP.BARCODE IS NULL\n" +
				"   AND FP.BARCODE IS NULL\n" +
				"   AND SPP.BARCODE = GDD.BARCODE\n" +
				"   AND SPP.VALUEFLAG = '1'\n" +
				"   AND SPP.AUDITSTATUS = 1\n" +
				"   AND SPP.GOODSLEVELTYPEID <> 9\n" +
				"   AND SPP.RECYCLINGFLAG = '0'\n" +
				"  LEFT JOIN TP_SYS_GOODSLEVELTYPE GLT\n" +
				"    ON GLT.GOODSLEVELTYPEID = SPP.GOODSLEVELTYPEID\n" +
				"  LEFT JOIN TP_MST_USER REVOKEUSER\n" +
				"    ON PSR.REVOKEUSERID = REVOKEUSER.USERID\n" +
				" WHERE (:barcode IS NULL OR INSTR(GDD.BARCODE, :barcode) > 0)\n" +
				"   AND (:remarks IS NULL OR INSTR(PSR.REMARKS, :remarks) > 0)\n" +
				"   AND (:datefrom IS NULL OR PSR.CREATETIME >= :datefrom)\n" +
				"   AND (:dateend is null or psr.createtime <= :dateend)\n" +
				" ORDER BY GDD.BARCODE, SP.DISPLAYNO";

				IDataParameter[] paras = new OracleParameter[]
				{
					new OracleParameter(":barcode", OracleDbType.NVarchar2, cre.Properties["barcode"], ParameterDirection.Input),
					new OracleParameter(":remarks", OracleDbType.NVarchar2, cre.Properties["remarks"], ParameterDirection.Input),
					new OracleParameter(":datefrom", OracleDbType.Date, cre.Properties["datefrom"], ParameterDirection.Input),
					new OracleParameter(":dateend", OracleDbType.Date, cre.Properties["dateend"], ParameterDirection.Input),
				};
				DataSet data = conn.GetSqlResultToDs(sqlString, paras);

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Tables.Count == 0 || data.Tables[0].Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
				}

				sre.Data = data;
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}
		#endregion

		#region 品保抽查
		/// <summary>
		/// 验证品保抽查条码
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity CheckQASpotCheck(SUserInfo user, string barcode)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				conn.Open();

				string sqlString = "SELECT gdd.groutingdailydetailid\n" +
				"      ,gdd.barcode\n" +
				"      ,gdd.groutingmouldcode\n" +
				"      ,gdd.groutingdate\n" +
				"      ,gdd.goodscode\n" +
				"      ,gdd.usercode\n" +
				//"      ,gdd.scrapflag\n" +
				//"      ,gdd.deliverflag\n" +
				// -1：未交坯 -2：生产完成 -3：成品交接 >0：在产工序ID
				"      ,case when gdd.deliverflag='0' then -1 \n" +
				"            when fp.FHUserID is not null then -3 \n" +
				"            when fp.barcode is not null then -2 \n" +
				"            when inp.barcode is null then -4 \n" +
				"            else inp.procedureid end procedureid \n" +
				"      ,case when gdd.deliverflag='0' then '未交坯' \n" +
				"            when fp.FHUserID is not null then '成品交接' \n" +
				"            when fp.barcode is not null then '生产完成' \n" +
				"            when inp.barcode is null then '损坯' \n" +
				"            else to_char(p.procedurename) end procedurename \n" +
				"      ,sysdate CheckTime \n" +
				"  FROM tp_pm_groutingdailydetail gdd\n" +
				"  LEFT JOIN tp_pm_inproduction inp\n" +
				"    ON inp.barcode = gdd.barcode\n" +
				"  LEFT JOIN tp_pc_procedure p\n" +
				"    ON p.procedureid = inp.procedureid\n" +
				"  LEFT JOIN TP_PM_FinishedProduct fp\n" +
				"    ON fp.barcode = gdd.barcode\n" +
				" WHERE gdd.accountid = :accountid\n" +
				"   AND gdd.barcode = :barcode";

				IDataParameter[] paras = new OracleParameter[]
				{
					new OracleParameter(":accountid", OracleDbType.Int32,user.AccountID, ParameterDirection.Input),
					new OracleParameter(":barcode", OracleDbType.NVarchar2,barcode, ParameterDirection.Input),
				};
				DataSet data = conn.GetSqlResultToDs(sqlString, paras);

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Tables.Count == 0 || data.Tables[0].Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.Message = "此条码为无效条码";
					return sre;
				}

				sre.Data = data;
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 保存品保抽查
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity SaveQASpotCheck(SUserInfo user, Dictionary<string, object> data)
		{
			if (data == null || data.Count == 0)
			{
				return new ServiceResultEntity();
			}

			IDBTransaction conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);

				string sqlInsert = "INSERT INTO TP_PM_QASpotCheck\n" +
				"  (GroutingDailyDetailID\n" +
				"  ,Remarks\n" +
				"  ,ProcedureID\n" +
				"  ,ProcedureName\n" +
				"  ,CheckTime\n" +
				"  ,AccountID\n" +
				"  ,CreateUserID)\n" +
				"VALUES\n" +
				"  (:GroutingDailyDetailID\n" +
				"  ,:Remarks\n" +
				"  ,:ProcedureID\n" +
				"  ,:ProcedureName\n" +
				"  ,:CheckTime\n" +
				"  ,:AccountID\n" +
				"  ,:CreateUserID)";

				IDataParameter[] insertParas = new OracleParameter[]
				{
					new OracleParameter(":GroutingDailyDetailID", OracleDbType.Int32,data["GroutingDailyDetailID"], ParameterDirection.Input),
					new OracleParameter(":Remarks", OracleDbType.NVarchar2,data["Remarks"], ParameterDirection.Input),
					new OracleParameter(":ProcedureID", OracleDbType.Int32,data["ProcedureID"], ParameterDirection.Input),
					new OracleParameter(":ProcedureName", OracleDbType.NVarchar2,data["ProcedureName"], ParameterDirection.Input),
					new OracleParameter(":CheckTime", OracleDbType.Date,data["CheckTime"], ParameterDirection.Input),
					new OracleParameter(":AccountID", OracleDbType.Int32,user.AccountID, ParameterDirection.Input),
					new OracleParameter(":CreateUserID", OracleDbType.Int32,user.UserID, ParameterDirection.Input),
				};

				conn.ExecuteNonQuery(sqlInsert, insertParas);

				conn.Commit();

				return new ServiceResultEntity();
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 自动保存品保抽查
		/// </summary>
		/// <param name="user"></param>
		/// <param name="barcode"></param>
		/// <param name="remarks"></param>
		/// <returns></returns>
		public static ServiceResultEntity AutoSaveQASpotCheck(SUserInfo user, string barcode, string remarks)
		{
			IDBTransaction conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);

				string sqlString = "SELECT gdd.groutingdailydetailid\n" +
				"      ,gdd.barcode\n" +
				"      ,gdd.groutingmouldcode\n" +
				"      ,gdd.groutingdate\n" +
				"      ,gdd.goodscode\n" +
				"      ,gdd.usercode\n" +
				//"      ,gdd.scrapflag\n" +
				//"      ,gdd.deliverflag\n" +
				// -1：未交坯 -2：生产完成 -3：成品交接 >0：在产工序ID
				"      ,case when gdd.deliverflag='0' then -1 \n" +
				"            when fp.FHUserID is not null then -3 \n" +
				"            when fp.barcode is not null then -2 \n" +
				"            when inp.barcode is null then -4 \n" +
				"            else inp.procedureid end procedureid \n" +
				"      ,case when gdd.deliverflag='0' then '未交坯' \n" +
				"            when fp.FHUserID is not null then '成品交接' \n" +
				"            when fp.barcode is not null then '生产完成' \n" +
				"            when inp.barcode is null then '损坯' \n" +
				"            else to_char(p.procedurename) end procedurename \n" +
				"      ,sysdate CheckTime \n" +
				"  FROM tp_pm_groutingdailydetail gdd\n" +
				"  LEFT JOIN tp_pm_inproduction inp\n" +
				"    ON inp.barcode = gdd.barcode\n" +
				"  LEFT JOIN tp_pc_procedure p\n" +
				"    ON p.procedureid = inp.procedureid\n" +
				"  LEFT JOIN TP_PM_FinishedProduct fp\n" +
				"    ON fp.barcode = gdd.barcode\n" +
				" WHERE gdd.accountid = :accountid\n" +
				"   AND gdd.barcode = :barcode";

				IDataParameter[] paras = new OracleParameter[]
				{
					new OracleParameter(":accountid", OracleDbType.Int32,user.AccountID, ParameterDirection.Input),
					new OracleParameter(":barcode", OracleDbType.NVarchar2,barcode, ParameterDirection.Input),
				};
				DataSet data = conn.GetSqlResultToDs(sqlString, paras);

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Tables.Count == 0 || data.Tables[0].Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.Message = "此条码为无效条码";
					return sre;
				}

				string sqlInsert = "INSERT INTO TP_PM_QASpotCheck\n" +
				"  (GroutingDailyDetailID\n" +
				"  ,Remarks\n" +
				"  ,ProcedureID\n" +
				"  ,ProcedureName\n" +
				"  ,CheckTime\n" +
				"  ,AccountID\n" +
				"  ,CreateUserID)\n" +
				"VALUES\n" +
				"  (:GroutingDailyDetailID\n" +
				"  ,:Remarks\n" +
				"  ,:ProcedureID\n" +
				"  ,:ProcedureName\n" +
				"  ,:CheckTime\n" +
				"  ,:AccountID\n" +
				"  ,:CreateUserID)";

				IDataParameter[] insertParas = new OracleParameter[]
				{
					new OracleParameter(":GroutingDailyDetailID", OracleDbType.Int32,data.Tables[0].Rows[0]["GroutingDailyDetailID"], ParameterDirection.Input),
					new OracleParameter(":Remarks", OracleDbType.NVarchar2,remarks, ParameterDirection.Input),
					new OracleParameter(":ProcedureID", OracleDbType.Int32,data.Tables[0].Rows[0]["ProcedureID"], ParameterDirection.Input),
					new OracleParameter(":ProcedureName", OracleDbType.NVarchar2,data.Tables[0].Rows[0]["ProcedureName"], ParameterDirection.Input),
					new OracleParameter(":CheckTime", OracleDbType.Date,data.Tables[0].Rows[0]["CheckTime"], ParameterDirection.Input),
					new OracleParameter(":AccountID", OracleDbType.Int32,user.AccountID, ParameterDirection.Input),
					new OracleParameter(":CreateUserID", OracleDbType.Int32,user.UserID, ParameterDirection.Input),
				};

				conn.ExecuteNonQuery(sqlInsert, insertParas);

				conn.Commit();

				sre.Data = data;
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 查询品保抽查
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetAllQASpotCheck(SUserInfo user, ClientRequestEntity cre)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				conn.Open();

				string sqlString = "select gdd.barcode\n" +
				"      ,gdd.goodscode\n" +
				"      ,gdd.GroutingDate\n" +
				"      ,gdd.usercode GroutingUserCode\n" +
				"      ,gdd.GroutingMouldCode\n" +
				"      ,u.usercode checkusercode\n" +
				"      ,qa.ProcedureName\n" +
				"      ,qa.checktime\n" +
				"      ,qa.remarks\n" +
				"  from TP_PM_QASPOTCHECK qa\n" +
				" inner join tp_pm_groutingdailydetail gdd\n" +
				"    on qa.groutingdailydetailid = gdd.groutingdailydetailid\n" +
				" inner join tp_mst_user u\n" +
				"    on u.userid = qa.createuserid\n" +
				" where qa.valueflag = '1'\n";

				List<OracleParameter> paras = new List<OracleParameter>();
				if (!string.IsNullOrEmpty(cre.Properties["barcode"] + ""))
				{
					sqlString += "   and instr(gdd.barcode, :barcode) > 0\n";
					paras.Add(new OracleParameter(":barcode", OracleDbType.NVarchar2, cre.Properties["barcode"], ParameterDirection.Input));
				}

				if (!string.IsNullOrEmpty(cre.Properties["goodscode"] + ""))
				{
					sqlString += "   and instr(gdd.goodscode, :goodscode) > 0\n";
					paras.Add(new OracleParameter(":goodscode", OracleDbType.NVarchar2, cre.Properties["goodscode"], ParameterDirection.Input));
				}
				if (!string.IsNullOrEmpty(cre.Properties["usercode"] + ""))
				{
					sqlString += "   and instr(u.usercode, :usercode) > 0\n";
					paras.Add(new OracleParameter(":usercode", OracleDbType.NVarchar2, cre.Properties["usercode"], ParameterDirection.Input));
				}
				if (!string.IsNullOrEmpty(cre.Properties["remarks"] + ""))
				{
					sqlString += "   and instr(qa.remarks, :remarks) > 0\n";
					paras.Add(new OracleParameter(":remarks", OracleDbType.NVarchar2, cre.Properties["remarks"], ParameterDirection.Input));
				}
				if (cre.Properties["checktimebegin"] != null)
				{
					sqlString += "   and qa.checktime >= :checktimebegin\n";
					paras.Add(new OracleParameter(":checktimebegin", OracleDbType.Date, cre.Properties["checktimebegin"], ParameterDirection.Input));
				}
				if (cre.Properties["checktimeend"] != null)
				{
					sqlString += "   and qa.checktime < :checktimeend\n";
					paras.Add(new OracleParameter(":checktimeend", OracleDbType.Date, cre.Properties["checktimeend"], ParameterDirection.Input));
				}
				sqlString += " ORDER BY gdd.barcode, qa.checktime ";

				DataSet data = conn.GetSqlResultToDs(sqlString, paras.ToArray());

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Tables.Count == 0 || data.Tables[0].Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
				}

				sre.Data = data;
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 查询品保抽查
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetAllQASpotCheckForPC(SUserInfo user, ClientRequestEntity cre)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				conn.Open();

				//string sqlString = "select gdd.barcode,\n" +
				//"       gdd.goodscode,\n" +
				//"       gdd.GroutingDate,\n" +
				//"       gdd.usercode GroutingUserCode,\n" +
				//"       gdd.GroutingMouldCode,\n" +
				//"       u.usercode checkusercode,\n" +
				//"       qa.ProcedureName,\n" +
				//"       qa.checktime,\n" +
				//"       qa.remarks,\n" +
				//"       inpp.procedurename currprocedurename,\n" +
				//"       listagg(decode(d.productiondefectid,\n" +
				//"                      null,\n" +
				//"                      null,\n" +
				//"                      '[' || to_char(d.defectcode) || ']' ||\n" +
				//"                      to_char(d.defectname)),\n" +
				//"               ',') WITHIN GROUP(ORDER BY d.productiondefectid) defectcodes,\n" +
				//"       (select listagg('[' || to_char(dd.defectcode) || ']' ||\n" +
				//"                       to_char(dd.defectname),\n" +
				//"                       ',') WITHIN GROUP(ORDER BY dd.productiondefectid)\n" +
				//"          from tp_pm_defect dd\n" +
				//"         where dd.valueflag = '1'\n" +
				//"           and dd.barcode = gdd.barcode) ddefectcode\n" +
				//"  from TP_PM_QASPOTCHECK qa\n" +
				//" inner join tp_mst_user u\n" +
				//"    on u.userid = qa.createuserid\n" +
				//" inner join tp_pm_groutingdailydetail gdd\n" +
				//"    on qa.groutingdailydetailid = gdd.groutingdailydetailid\n" +
				//"  left join tp_pm_inproduction inp\n" +
				//"    on inp.barcode = gdd.barcode\n" +
				//"  left join tp_pc_procedure inpp\n" +
				//"    on inp.procedureid = inpp.procedureid\n" +
				//"  left join tp_pm_defect d\n" +
				//"    on d.barcode = gdd.barcode\n" +
				//"   and d.valueflag = '1'\n" +
				//" where qa.valueflag = '1'\n" +
				//" group by gdd.barcode,\n" +
				//"          gdd.goodscode,\n" +
				//"          gdd.GroutingDate,\n" +
				//"          gdd.usercode,\n" +
				//"          gdd.GroutingMouldCode,\n" +
				//"          u.usercode,\n" +
				//"          qa.ProcedureName,\n" +
				//"          qa.checktime,\n" +
				//"          qa.remarks,\n" +
				//"          inpp.procedurename";


				string sqlString = "select gdd.barcode\n" +
				"      ,gdd.goodscode\n" +
				"      ,gdd.GroutingDate\n" +
				"      ,gdd.usercode GroutingUserCode\n" +
				"      ,gdd.GroutingMouldCode\n" +
				"      ,u.usercode checkusercode\n" +
				"      ,qa.ProcedureName\n" +
				"      ,qa.checktime\n" +
				"      ,qa.remarks\n" +
				"      ,inpp.procedurename currprocedurename\n" +
				"      ,(select listagg('[' || to_char(dd.defectcode) || ']' ||\n" +
				"                       to_char(dd.defectname),\n" +
				"                       ',') WITHIN GROUP(ORDER BY dd.productiondefectid)\n" +
				"          from tp_pm_defect dd\n" +
				"         where dd.valueflag = '1'\n" +
				"           and dd.barcode = gdd.barcode) ddefectcode\n" +
				"  from TP_PM_QASPOTCHECK qa\n" +
				" inner join tp_pm_groutingdailydetail gdd\n" +
				"    on qa.groutingdailydetailid = gdd.groutingdailydetailid\n" +
				" inner join tp_mst_user u\n" +
				"    on u.userid = qa.createuserid\n" +
				"  left join tp_pm_inproduction inp\n" +
				"    on inp.barcode = gdd.barcode\n" +
				"  left join tp_pc_procedure inpp\n" +
				"    on inp.procedureid = inpp.procedureid\n" +
				" where qa.valueflag = '1'\n";

				List<OracleParameter> paras = new List<OracleParameter>();
				if (!string.IsNullOrEmpty(cre.Properties["barcode"] + ""))
				{
					sqlString += "   and instr(gdd.barcode, :barcode) > 0\n";
					paras.Add(new OracleParameter(":barcode", OracleDbType.NVarchar2, cre.Properties["barcode"], ParameterDirection.Input));
				}

				if (!string.IsNullOrEmpty(cre.Properties["goodscode"] + ""))
				{
					sqlString += "   and instr(gdd.goodscode, :goodscode) > 0\n";
					paras.Add(new OracleParameter(":goodscode", OracleDbType.NVarchar2, cre.Properties["goodscode"], ParameterDirection.Input));
				}
				if (!string.IsNullOrEmpty(cre.Properties["usercode"] + ""))
				{
					sqlString += "   and instr(u.usercode, :usercode) > 0\n";
					paras.Add(new OracleParameter(":usercode", OracleDbType.NVarchar2, cre.Properties["usercode"], ParameterDirection.Input));
				}
				if (!string.IsNullOrEmpty(cre.Properties["remarks"] + ""))
				{
					sqlString += "   and instr(qa.remarks, :remarks) > 0\n";
					paras.Add(new OracleParameter(":remarks", OracleDbType.NVarchar2, cre.Properties["remarks"], ParameterDirection.Input));
				}
				if (cre.Properties["checktimebegin"] != null)
				{
					sqlString += "   and qa.checktime >= :checktimebegin\n";
					paras.Add(new OracleParameter(":checktimebegin", OracleDbType.Date, cre.Properties["checktimebegin"], ParameterDirection.Input));
				}
				if (cre.Properties["checktimeend"] != null)
				{
					sqlString += "   and qa.checktime < :checktimeend\n";
					paras.Add(new OracleParameter(":checktimeend", OracleDbType.Date, cre.Properties["checktimeend"], ParameterDirection.Input));
				}
				sqlString += " ORDER BY gdd.barcode, qa.checktime ";

				DataSet data = conn.GetSqlResultToDs(sqlString, paras.ToArray());

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Tables.Count == 0 || data.Tables[0].Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
				}

				sre.Data = data;
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}
		#endregion

		#region 成品装车（潮州需求【废弃】）
		/*
        /// <summary>
        /// 获取当天装车号
        /// </summary>
        /// <param name="user"></param>
        /// <returns></returns>
        public static int GetMaxLoadingNo(SUserInfo user)
        {
            IDBConnection conn = null;
            try
            {
                conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
                conn.Open();

                string sqlString = "select nvl(max(fl.loadingno), 0) + 1\n" +
                "  from TP_PM_FINISHEDLOADING fl\n" +
                " where fl.loadingdate = :loadingdate\n" +
                "   and fl.valueflag = '1'\n" +
                "   and fl.accountid = :accountid";

                IDataParameter[] paras = new OracleParameter[]
                {
                    new OracleParameter(":accountid", OracleDbType.Int32,user.AccountID, ParameterDirection.Input),
                    new OracleParameter(":loadingdate", OracleDbType.Date, DateTime.Now.Date, ParameterDirection.Input),
                };
                object maxno = conn.GetSqlResultToObj(sqlString, paras);
                if (maxno == null || maxno == DBNull.Value)
                {
                    return 1;
                }
                else
                {
                    return Convert.ToInt32(maxno);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conn != null &&
                    conn.ConnState == ConnectionState.Open)
                {
                    conn.Close();
                }
            }
        }

        /// <summary>
        /// 产成品装车条码验证
        /// </summary>
        /// <param name="barcode"></param>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public static ServiceResultEntity CheckFinishedLaodingBarcode(SUserInfo sUserInfo, string barcode)
        {
            IDBConnection oracleConn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
            try
            {
                oracleConn.Open();
                ServiceResultEntity resultEntity = new ServiceResultEntity();

                string sqlString = @"select FUN_CMN_GetBarCode(:barcode,null,:accountid) From DUAL";
                OracleParameter[] paras1 = new OracleParameter[]{
                    new OracleParameter(":barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
                    new OracleParameter(":accountid",OracleDbType.Int32, sUserInfo.AccountID,ParameterDirection.Input),
                };
                string gbarcode = oracleConn.GetSqlResultToObj(sqlString, paras1) + "";

                if (string.IsNullOrWhiteSpace(gbarcode))
                {
                    resultEntity.Status = Constant.ServiceResultStatus.Other;
                    resultEntity.OtherStatus = -1;
                    resultEntity.Message = "此条码不存在";
                    return resultEntity;
                }

                // 1.判断产品是否在产成品表中
                sqlString = @"select f.FINISHEDLOADBATCHNO from TP_PM_FinishedProduct f  where f.BarCode=:BarCode";
                OracleParameter[] paras = new OracleParameter[]{
                    new OracleParameter(":BarCode",OracleDbType.NVarchar2,gbarcode,ParameterDirection.Input),
                };

                DataTable dtResult = oracleConn.GetSqlResultToDt(sqlString, paras);
                string FINISHEDLOADBATCHNO = null;
                if (dtResult != null && dtResult.Rows.Count > 0)
                {
                    FINISHEDLOADBATCHNO = dtResult.Rows[0]["FINISHEDLOADBATCHNO"].ToString();
                }
                else
                {
                    resultEntity.Status = Constant.ServiceResultStatus.Other;
                    resultEntity.OtherStatus = -1;
                    resultEntity.Message = "此产品没有交接";
                    return resultEntity;
                }

                sqlString = "select 1\n" +
                "  from TP_PM_FPLoadingDetail fpld\n" +
                " where fpld.finishedloadbatchno = :fbatchno\n" +
                "   and rownum = 1";
                paras = new OracleParameter[]{
                    new OracleParameter(":fbatchno",OracleDbType.NVarchar2,FINISHEDLOADBATCHNO,ParameterDirection.Input),
                };
                string exists = oracleConn.GetSqlResultToObj(sqlString, paras)+"";
                if (!string.IsNullOrEmpty(exists))
                {
                    resultEntity.Status = Constant.ServiceResultStatus.Other;
                    resultEntity.OtherStatus = -1;
                    resultEntity.Message = "此产品已装车";
                    return resultEntity;
                }

                #region 查询产品相关信息
                sqlString = "select ss.settingvalue\n" +
                "  from tp_mst_systemsetting ss\n" +
                " where ss.settingcode = 'S_PM_025'\n" +
                "   and ss.accountid = :accountid";
                paras = new OracleParameter[]{
                    new OracleParameter(":accountid",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
                };
                exists = oracleConn.GetSqlResultToObj(sqlString, paras) + "";
                if (string.IsNullOrWhiteSpace(exists))
                {
                    exists = "0";
                }

                sqlString = "select "+ exists + " limitnum, :barcode barcode, :fbatchno fbatchno, to_char(sum(cc)) sumcount\n" +
                "      ,listagg(to_char(t.goodscode) || '[' || to_char(cc) || ']', ', ') within group(order by t.goodscode) dd\n" +
                "  from (select count(*) cc, fp.goodscode\n" +
                "          from tp_pm_finishedproduct fp\n" +
                "         where fp.finishedloadbatchno =:fbatchno\n" +
                "         group by fp.finishedloadbatchno, fp.goodscode) t";
                paras = new OracleParameter[]{
                    new OracleParameter(":barcode",OracleDbType.NVarchar2,barcode,ParameterDirection.Input),
                    new OracleParameter(":fbatchno",OracleDbType.NVarchar2,FINISHEDLOADBATCHNO,ParameterDirection.Input),
                };

                dtResult = oracleConn.GetSqlResultToDt(sqlString, paras);
                if (dtResult != null && dtResult.Rows.Count > 0)
                {
                    resultEntity.Data = new DataSet("ds");
                    resultEntity.Data.Tables.Add(dtResult);

                    sqlString = "select fp.barcode, fp.groutingdailydetailid, :fbatchno fbatchno\n" +
                    "  from tp_pm_finishedproduct fp\n" +
                    " where fp.finishedloadbatchno = :fbatchno";
                    paras = new OracleParameter[]{
                        new OracleParameter(":fbatchno",OracleDbType.NVarchar2,FINISHEDLOADBATCHNO,ParameterDirection.Input),
                    };
                    dtResult = oracleConn.GetSqlResultToDt(sqlString, paras);
                    resultEntity.Data.Tables.Add(dtResult);

                }
                else
                {
                    resultEntity.Status = Constant.ServiceResultStatus.Other;
                    resultEntity.OtherStatus = -1;
                    resultEntity.Message = "此条码不存在";
                    return resultEntity;
                }
                #endregion
                return resultEntity;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (oracleConn.ConnState == ConnectionState.Open)
                {
                    oracleConn.Close();
                }
            }
        }

        /// <summary>
        /// 产成品装车-保存
        /// </summary>
        /// <param name="barcode"></param>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public static ServiceResultEntity SaveFinishedLoading(SUserInfo sUserInfo, int loadingNo,
            string carLicense, int palletNum, int goodsNum, string remarks, Dictionary<string, object>[] details)
        {
            IDBTransaction oracleConn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
            try
            {
                oracleConn.Connect();
                ServiceResultEntity resultEntity = new ServiceResultEntity();

                DateTime date = DateTime.Now.Date;
                // 1 验证 LoadingNo
                string sqlString = "select 1\n" +
                "  from TP_PM_FinishedLoading fl\n" +
                " where fl.loadingdate = :loadingdate\n" +
                "   and fl.loadingno = :loadingno\n" +
                "   and fl.AccountID = :AccountID\n" +
                "   and rownum = 1";
                OracleParameter[] paras = new OracleParameter[]{
                    new OracleParameter(":loadingdate",OracleDbType.Date, date,ParameterDirection.Input),
                    new OracleParameter(":loadingno",OracleDbType.Int32, loadingNo,ParameterDirection.Input),
                    new OracleParameter(":AccountID",OracleDbType.Int32, sUserInfo.AccountID,ParameterDirection.Input),
                };
                string exists = oracleConn.GetSqlResultToObj(sqlString, paras) + "";
                if (!string.IsNullOrEmpty(exists))
                {
                    resultEntity.Status = Constant.ServiceResultStatus.Other;
                    resultEntity.OtherStatus = -1;
                    resultEntity.Message = "今天此装车序号已存在";
                    return resultEntity;
                }

                // 2 保存
                sqlString = @"select SEQ_PM_FinishedLoading_ID.Nextval From DUAL";
                int loadingID = Convert.ToInt32(oracleConn.GetSqlResultToObj(sqlString));

                sqlString = "insert into TP_PM_FinishedLoading\n" +
                "  (LOADINGID\n" +
                "  ,LOADINGDATE\n" +
                "  ,LOADINGNO\n" +
                "  ,CARLICENSE\n" +
                "  ,PALLETNUM\n" +
                "  ,GOODSNUM\n" +
                "  ,REMARKS\n" +
                "  ,ACCOUNTID\n" +
                "  ,CREATEUSERID)\n" +
                "values\n" +
                "  (:LOADINGID\n" +
                "  ,:LOADINGDATE\n" +
                "  ,:LOADINGNO\n" +
                "  ,:CARLICENSE\n" +
                "  ,:PALLETNUM\n" +
                "  ,:GOODSNUM\n" +
                "  ,:REMARKS\n" +
                "  ,:ACCOUNTID\n" +
                "  ,:CREATEUSERID)";

                paras = new OracleParameter[]{
                    new OracleParameter(":LOADINGID",OracleDbType.Int32, loadingID,ParameterDirection.Input),
                    new OracleParameter(":LOADINGDATE",OracleDbType.Date, date,ParameterDirection.Input),
                    new OracleParameter(":LOADINGNO",OracleDbType.Int32, loadingNo,ParameterDirection.Input),
                    new OracleParameter(":CARLICENSE",OracleDbType.Varchar2, carLicense,ParameterDirection.Input),
                    new OracleParameter(":PALLETNUM",OracleDbType.Int32, palletNum,ParameterDirection.Input),
                    new OracleParameter(":GOODSNUM",OracleDbType.Int32, goodsNum,ParameterDirection.Input),
                    new OracleParameter(":REMARKS",OracleDbType.NVarchar2, remarks,ParameterDirection.Input),
                    new OracleParameter(":ACCOUNTID",OracleDbType.Int32, sUserInfo.AccountID,ParameterDirection.Input),
                    new OracleParameter(":CREATEUSERID",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
                };
                int r = oracleConn.ExecuteNonQuery(sqlString, paras);

                sqlString = "insert into TP_PM_FPLoadingDetail\n" +
                "  (LOADINGID, GROUTINGDAILYDETAILID, FINISHEDLOADBATCHNO)\n" +
                "values\n" +
                "  (:LOADINGID, :GROUTINGDAILYDETAILID, :FINISHEDLOADBATCHNO)";

                foreach (Dictionary<string, object> item in details)
                {
                    paras = new OracleParameter[]{
                        new OracleParameter(":LOADINGID",OracleDbType.Int32, loadingID,ParameterDirection.Input),
                        new OracleParameter(":GROUTINGDAILYDETAILID",OracleDbType.Int32, item["groutingdailydetailid"],ParameterDirection.Input),
                        new OracleParameter(":FINISHEDLOADBATCHNO",OracleDbType.Varchar2, item["fbatchno"],ParameterDirection.Input),
                    };
                    r = oracleConn.ExecuteNonQuery(sqlString, paras);
                }

                oracleConn.Commit();
                return resultEntity;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (oracleConn.ConnState == ConnectionState.Open)
                {
                    oracleConn.Disconnect();
                }
            }
        }
        */
		#endregion

		#region 半检返修登记

		/// <summary>
		/// 获取半检返修登记列表
		/// </summary>
		/// <returns></returns>
		public static ServiceResultEntity GetSemiRework(ClientRequestEntity cre, SUserInfo userInfo)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				conn.Open();

				string sqlString = "select sr.SemiReworkID\n" +
				"      ,sr.BarCode\n" +
				"      ,sr.ProductionLineID\n" +
				"      ,sr.ProcedureID\n" +
				"      ,p.procedurename\n" +
				"      ,sr.ProcedureTime\n" +
				"      ,sr.GoodsID\n" +
				"      ,sr.GoodsCode\n" +
				"      ,sr.UserID --完成工号ID\n" +
				"      ,sr.UserCode\n" +
				"      ,sr.ProductionDataID\n" +
				"      ,sr.GroutingDailyID\n" +
				"      ,sr.GroutingDailyDetailID\n" +
				"      ,sr.GroutingLineID\n" +
				"      ,sr.GroutingLineCode\n" +
				"      ,sr.GroutingLineDetailID\n" +
				"      ,sr.GroutingDate\n" +
				"      ,sr.GroutingMouldCode\n" +
				"      ,sr.GroutingUserID\n" +
				"      ,sr.GroutingUserCode\n" +
				"      ,sr.SemiReworkUserID\n" +
				"      ,sr.SemiReworkUserCode\n" +
				"      ,sr.SemiReworkTime\n" +
				"      ,sr.ReworkProcedureID\n" +
				"      ,rp.procedurename ReworkProcedurename\n" +
				"      ,sr.BackOutFlag\n" +
				"      ,sr.BackOutTime\n" +
				"      ,sr.BackOutUserID\n" +
				"      ,sr.BackOutUserCode\n" +
				"      ,sr.Remarks\n" +
				"  from TP_PM_SemiRework sr\n" +
				" inner join tp_pc_procedure p\n" +
				"    on p.procedureid = sr.procedureid\n" +
				" inner join tp_pc_procedure rp\n" +
				"    on rp.procedureid = sr.reworkprocedureid" +
				" where sr.accountID = :accountID" +
				"   and sr.valueflag = '1'" +
				// todo 其他查询条件
				" order by sr.SemiReworkID desc";

				IDataParameter[] paras = new OracleParameter[]
				{
					new OracleParameter(":accountID", OracleDbType.Int32,userInfo.AccountID, ParameterDirection.Input),
				};

				ServiceResultEntity sre = new ServiceResultEntity();
				DataSet data = conn.GetSqlResultToDs(sqlString, paras);
				if (data == null || data.Tables.Count == 0 || data.Tables[0].Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
					return sre;
				}
				data.Tables[0].TableName = "SemiRework";
				sre.Data = data;

				int semiReworkID = Convert.ToInt32(data.Tables[0].Rows[0]["SemiReworkID"]);

				ServiceResultEntity sre1 = GetSemiReworkDefect(semiReworkID, userInfo, conn);
				if (sre1.Data == null || sre1.Data.Tables.Count == 0 || sre1.Data.Tables[0].Rows.Count == 0)
				{
					return sre;
				}
				sre1.Data.Tables[0].TableName = "SemiReworkDefect";
				sre.Data.Merge(sre1.Data.Tables[0]);
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 获取半检返修登记列表
		/// </summary>
		/// <returns></returns>
		public static ServiceResultEntity GetSemiReworkDefect(int semiReworkID, SUserInfo userInfo, IDBConnection conn = null)
		{
			try
			{
				if (conn == null)
				{
					conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
					conn.Open();
				}

				string sqlString = "select srd.SemiReworkDefectID\n" +
				"      ,srd.SemiReworkID\n" +
				"      ,srd.DefectID\n" +
				"      ,srd.DefectCode\n" +
				"      ,srd.DefectName\n" +
				"      ,srd.DefectPositionID\n" +
				"      ,srd.DefectPositionCode\n" +
				"      ,srd.DefectPositionName\n" +
				"      ,srd.ScrapResponFlag\n" +
				"      ,srd.DefectProductionDataID\n" +
				"      ,srd.DefectProcedureID\n" +
				"      ,p.procedurename DefectProcedureName\n" +
				"      ,srd.DefectUserID\n" +
				"      ,srd.DefectUserCode\n" +
				"      ,srd.Remarks\n" +
				"  from TP_PM_SemiReworkDefect srd\n" +
				" inner join tp_pc_procedure p\n" +
				"    on p.procedureid = srd.DefectProcedureID\n" +
				" where srd.accountID = :accountID" +
				"   and srd.valueflag = '1'" +
				"   and srd.SemiReworkID = :SemiReworkID" +
				" order by srd.DefectID";

				IDataParameter[] paras = new OracleParameter[]
				{
					new OracleParameter(":accountID", OracleDbType.Int32,userInfo.AccountID, ParameterDirection.Input),
					new OracleParameter(":SemiReworkID", OracleDbType.Int32,semiReworkID, ParameterDirection.Input),
				};

				DataSet data = conn.GetSqlResultToDs(sqlString, paras);

				ServiceResultEntity sre = new ServiceResultEntity();
				sre.Data = data;
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 获取登陆帐户有无修改半检返修权限
		/// </summary>
		/// <returns></returns>
		public static int GetSemiReworkEditFuntion(SUserInfo userInfo)
		{

			IDBConnection con = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string strSql = "";
				strSql = @"SELECT r.FunctionCode FROM TP_MST_UserRight R WHERE r.FunctionCode='06200104' AND R.UserID = " + userInfo.UserID;
				DataSet ds = con.GetSqlResultToDs(strSql);
				if (ds != null && ds.Tables[0].Rows.Count > 0)
				{
					return 1;
				}
				return 0;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 验证半检返修条码
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <returns></returns>
		public static ServiceResultEntity CheckSemiReworkBarcode(string barcode)
		{
			IDBConnection oracleConn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleConn.Open();
				ServiceResultEntity resultEntity = new ServiceResultEntity();
				// 1.判断产品是否在产
				string sql = @"select
                                InScrapFlag,
                                KilnCarID,
                                KilnCarName,
                                IsReworkFlag,
                                SemiCheckID
                                from TP_PM_InProduction
                                where BarCode=:BarCode";

				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":BarCode",OracleDbType.NVarchar2,barcode,ParameterDirection.Input),
				};
				DataSet dsResult = oracleConn.GetSqlResultToDs(sql, paras);
				if (dsResult != null && dsResult.Tables[0].Rows.Count > 0)
				{
					if (dsResult.Tables[0].Rows[0]["InScrapFlag"].ToString() == "1")
					{
						resultEntity.Result = -2; //报损待审批
						resultEntity.Message = "条码[" + barcode + "]已经报损待审批";
						return resultEntity;
					}
					if (!string.IsNullOrEmpty(dsResult.Tables[0].Rows[0]["KilnCarID"].ToString()))
					{
						resultEntity.Result = -3; //登窑车后不允许半成品检测
						resultEntity.Message = "条码[" + barcode + "]已经在窑车[" + dsResult.Tables[0].Rows[0]["KilnCarName"].ToString() + "]";
						return resultEntity;
					}
					if (dsResult.Tables[0].Rows[0]["IsReworkFlag"].ToString() == "1")
					{
						resultEntity.Result = -4; //半检返工
						resultEntity.Message = "条码[" + barcode + "]已半检返工";
						return resultEntity;
					}
					if (dsResult.Tables[0].Rows[0]["IsReworkFlag"].ToString() == "2")
					{
						resultEntity.Result = Convert.ToInt32(dsResult.Tables[0].Rows[0]["SemiCheckID"]);//编辑状态
						resultEntity.Message = "返修";
					}
					else
					{
						resultEntity.Result = "0";//新建状态
					}
				}
				else
				{
					resultEntity.Result = -1;// 不在在产表中
					resultEntity.Message = "条码[" + barcode + "]不在在产流程";
				}

				return resultEntity;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (oracleConn.ConnState == ConnectionState.Open)
				{
					oracleConn.Close();
				}
			}
		}

		/// <summary>
		/// 根据半成品检验数据ID,显示半成品数据信息
		/// </summary>
		/// <param name="semiCheckID">半成品数据ID</param>
		/// <returns>DataSet</returns>
		public static ServiceResultEntity GetSemiReworkByID(int semiReworkID, string userCode = "")
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				conn.Open();

				string sqlString = "select sr.SemiReworkID\n" +
				"      ,sr.BarCode\n" +
				"      ,sr.ProductionLineID\n" +
				"      ,sr.ProcedureID\n" +
				"      ,p.procedurename\n" +
				"      ,sr.ProcedureTime\n" +
				"      ,sr.GoodsID\n" +
				"      ,sr.GoodsCode\n" +
				"      ,sr.UserID --完成工号ID\n" +
				"      ,sr.UserCode\n" +
				"      ,sr.ProductionDataID\n" +
				"      ,sr.GroutingDailyID\n" +
				"      ,sr.GroutingDailyDetailID\n" +
				"      ,sr.GroutingLineID\n" +
				"      ,sr.GroutingLineCode\n" +
				"      ,sr.GroutingLineDetailID\n" +
				"      ,sr.GroutingDate\n" +
				"      ,sr.GroutingMouldCode\n" +
				"      ,sr.GroutingUserID\n" +
				"      ,sr.GroutingUserCode\n" +
				"      ,sr.SemiReworkUserID\n" +
				"      ,sr.SemiReworkUserCode\n" +
				"      ,sr.SemiReworkTime\n" +
				"      ,sr.ReworkProcedureID\n" +
				"      ,rp.procedurename ReworkProcedurename\n" +
				"      ,sr.BackOutFlag\n" +
				"      ,sr.BackOutTime\n" +
				"      ,sr.BackOutUserID\n" +
				"      ,sr.BackOutUserCode\n" +
				"      ,sr.Remarks\n" +
				"  from TP_PM_SemiRework sr\n" +
				" inner join tp_pc_procedure p\n" +
				"    on p.procedureid = sr.procedureid\n" +
				"  left join tp_pc_procedure rp\n" +
				"    on rp.procedureid = sr.reworkprocedureid" +
				" where sr.SemiReworkID = :SemiReworkID";

				string sqlString1 = "select srd.SemiReworkDefectID\n" +
				"      ,srd.SemiReworkID\n" +
				"      ,srd.DefectID\n" +
				"      ,srd.DefectCode\n" +
				"      ,srd.DefectName\n" +
				"      ,srd.DefectPositionID\n" +
				"      ,srd.DefectPositionCode\n" +
				"      ,srd.DefectPositionName\n" +
				"      ,srd.ScrapResponFlag\n" +
				"      ,srd.DefectProductionDataID\n" +
				"      ,srd.DefectProcedureID\n" +
				"      ,p.procedurecode DefectProcedureCode\n" +
				"      ,p.procedurename DefectProcedureName\n" +
				"      ,srd.DefectUserID\n" +
				"      ,du.username DefectUserName\n" +
				"      ,srd.DefectUserCode\n" +
				"      ,srd.Remarks\n" +
				"      ,srd.ValueFlag\n" + //xuwei add 2019-11-14 为 1 时可编辑 为 0 时不可编辑
				"  from TP_PM_SemiReworkDefect srd\n" +
				"  left join tp_pc_procedure p\n" +
				"    on p.procedureid = srd.DefectProcedureID\n" +
				" inner join tp_mst_user du\n" +
				"    on du.userid = srd.DefectUserID\n" +
				" where srd.SemiReworkID = :SemiReworkID" +
				" order by srd.SemiReworkDefectID";

				string sqlString2 = "select t.SemiReworkDefectID\n" +
				"      ,t.StaffID\n" +
				"      ,t.SemiReworkID\n" +
				"      ,t.UserID\n" +
				"      ,t.UserCode\n" +
				"      ,t.UJobsID\n" +
				"      ,t.SJobsID\n" +
				"      ,s.staffcode\n" +
				"      ,s.staffname\n" +
				"  from TP_PM_SemiReworkRPS t\n" +
				" inner join tp_hr_staff s\n" +
				"    on s.staffid = t.staffid\n" +
				" where t.valueflag = '1'" +
				"   and t.SemiReworkID = :SemiReworkID" +
				" order by t.semireworkdefectid, s.staffcode";

				IDataParameter[] paras = new OracleParameter[]
				{
					new OracleParameter(":SemiReworkID", OracleDbType.Int32,semiReworkID, ParameterDirection.Input),
				};

				ServiceResultEntity sre = new ServiceResultEntity();
				DataTable data = conn.GetSqlResultToDt(sqlString, paras);
				data.TableName = "SemiRework";
				DataTable data1 = conn.GetSqlResultToDt(sqlString1, paras);
				data1.TableName = "SemiReworkDefect";
				DataTable data2 = conn.GetSqlResultToDt(sqlString2, paras);
				data2.TableName = "SemiReworkRPS";

				//xuwei add 2019-11-14 验证并重置valueflag，确定是否可编辑
				if (userCode != "")
				{
					for (int i = 0; i < data1.Rows.Count; i++)
					{
						//半检工号等于当前工号 并且 有效标识为1的 将 valueflag 置 1 是可编辑记录
						if (data.Rows[0]["SemiReworkUserCode"].ToString() == userCode
							&& data1.Rows[i]["ValueFlag"].ToString() == "1")
							data1.Rows[i]["ValueFlag"] = '1';
						else
							data1.Rows[i]["ValueFlag"] = '0';
					}
				}
				else
				{
					for (int i = 0; i < data1.Rows.Count; i++)
					{
						//缺省半检工号 全部将 valueflag 置 0 不可编辑
						data1.Rows[i]["ValueFlag"] = '0';
					}
				}
				//xuwei end


				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);
				sre.Data.Tables.Add(data1);
				sre.Data.Tables.Add(data2);
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 可以返修的工序
		/// </summary>
		/// <param name="barcode"></param>
		/// <param name="userInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity GetSemiReworkProcedure(string barcode, SUserInfo userInfo)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
				conn.Open();

				string sqlString = "select p.procedureid, p.procedurecode, p.procedurename\n" +
				"  from tp_pm_inproduction t\n" +
				" inner join tp_pc_procedure p\n" +
				"    on p.productionlineid = t.productionlineid\n" +
				"   and p.ISSEMIREWORK = '1'\n" +
				" where t.barcode = :barcode";

				IDataParameter[] paras = new OracleParameter[]
				{
					new OracleParameter(":barcode", OracleDbType.NVarchar2,barcode, ParameterDirection.Input),
				};

				ServiceResultEntity sre = new ServiceResultEntity();
				sre.Data = conn.GetSqlResultToDs(sqlString, paras);

				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 根据条码获取经过的工序,用于责任工序
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <returns>DataSet</returns>
		public static ServiceResultEntity GetSemiReworkPassProcedure(string barcode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();

				string sqlString = "select pin.Barcode\n" +
				"      ,pin.UserID\n" +
				"      ,pin.UserCode\n" +
				"      ,pin.UserName\n" +
				"      ,pin.ProcedureID\n" +
				"      ,pin.ProcedureCode\n" +
				"      ,pin.ProcedureName\n" +
				"      ,pin.ProductionDataID\n" +
				"  from TP_PM_ProductionDataIn pin\n" +
				" where pin.valueflag = '1'\n" +
				"   and pin.barcode = :BarCode\n" +
				" order by pin.ProductionDataID";

				// 干补后 半检 不能选成型责任
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":BarCode",OracleDbType.NVarchar2, barcode,ParameterDirection.Input),
				};
				ServiceResultEntity sre = new ServiceResultEntity();
				sre.Data = con.GetSqlResultToDs(sqlString, paras);

				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 根据所选生产工序（生产数据ID）查询责任员工
		/// </summary>
		/// <param name="productionDataID"></param>
		/// <returns></returns>
		public static ServiceResultEntity GetSemiReworkDefectStaffByProductionDataID(int productionDataID)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();

				string sqlString = "select cd.StaffID\n" +
				"      ,s.StaffCode\n" +
				"      ,s.staffname\n" +
				"      ,cd.staffstatus\n" +
				"      ,cd.UJobsID\n" +
				"      ,cd.SJobsID\n" +
				"  from tp_pm_productiondatain pd\n" +
				//"--inner join tp_pc_classessetting c on c.classessettingid = pd.classessettingid\n" +
				" inner join tp_pc_classesdetail cd\n" +
				"    on cd.classessettingid = pd.classessettingid\n" +
				" inner join TP_HR_Staff s\n" +
				"    on s.staffid = cd.staffid\n" +
				" where pd.productiondataid = :productionDataID\n" +
				" order by s.StaffCode";

				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":productionDataID",OracleDbType.Int32, productionDataID,ParameterDirection.Input),
				};
				ServiceResultEntity se = new ServiceResultEntity();
				se.Data = con.GetSqlResultToDs(sqlString, paras);
				return se;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 根据所选工号，查出缺陷责任员工
		/// </summary>
		/// <param name="userid">用户ID</param>
		/// <returns>DataSet</returns>
		public static ServiceResultEntity GetSemiReworkDefectStaffByUserID(int userid)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = "select s.StaffID\n" +
				"      ,s.StaffCode\n" +
				"      ,s.StaffName\n" +
				"      ,s.StaffStatus\n" +
				"      ,us.UJobsID\n" +
				"      ,s.jobs SJobsID\n" +
				"  from TP_MST_UserStaff us\n" +
				" inner join TP_HR_Staff s\n" +
				"    on us.Staffid = s.Staffid\n" +
				" where us.Userid = :userid";

				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":userid",OracleDbType.Int32, userid,ParameterDirection.Input),
				};

				ServiceResultEntity se = new ServiceResultEntity();
				se.Data = con.GetSqlResultToDs(sqlString, paras);
				return se;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 保存半检返修
		/// </summary>
		/// <param name="entity">半检实体类</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>ServiceResultEntity</returns>
		/// <remarks>
		/// 王鑫              2016.06.27              新建
		/// </remarks>
		public static ServiceResultEntity AddSemiRework(SemiReworkEntity entityobj, SUserInfo sUserInfo)
		{
			IDBTransaction con = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				ServiceResultEntity resultEntity = new ServiceResultEntity();
				resultEntity.Result = 1;
				if (entityobj == null || string.IsNullOrWhiteSpace(entityobj.BarCode) ||
					entityobj.SemiReworkDefects == null || entityobj.SemiReworkDefects.Count == 0)
				{
					resultEntity.Result = -1;
					resultEntity.Message = "数据错误";
					return resultEntity;
				}
				con.Connect();

				string barcode = entityobj.BarCode;
				#region 验证条码
				// 1.判断产品是否在产
				string sql = @"select p.*,u.usercode from TP_PM_InProduction p inner join tp_mst_user u on u.userid=p.userid where p.BarCode=:BarCode for update";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":BarCode",OracleDbType.NVarchar2,barcode,ParameterDirection.Input),
				};
				DataTable dsResult = con.GetSqlResultToDt(sql, paras);
				if (dsResult == null || dsResult.Rows.Count == 0)
				{
					resultEntity.Result = -1;// 不在在产表中
					resultEntity.Message = "条码[" + barcode + "]不在在产流程";
					return resultEntity;
				}
				DataRow dataRow = dsResult.Rows[0];
				if (dataRow["InScrapFlag"].ToString() == "1")
				{
					resultEntity.Result = -2; //报损待审批
					resultEntity.Message = "条码[" + barcode + "]已经报损待审批";
					return resultEntity;
				}
				if (!string.IsNullOrEmpty(dataRow["KilnCarID"].ToString()))
				{
					resultEntity.Result = -3; //登窑车后不允许半成品检测
					resultEntity.Message = "条码[" + barcode + "]已经在窑车[" + dataRow["KilnCarName"].ToString() + "]";
					return resultEntity;
				}
				if (dataRow["IsReworkFlag"].ToString() == "1")
				{
					resultEntity.Result = -4; //半检返工
					resultEntity.Message = "条码[" + barcode + "]已半检返工";
					return resultEntity;
				}

				//xuwei modify 2019-11-14 允许多次半检
				//if (dataRow["IsReworkFlag"].ToString() == "2")
				//{
				//    resultEntity.Result = -5; //半检返修
				//    resultEntity.Message = "条码[" + barcode + "]已半检返修";
				//    return resultEntity;
				//}
				//xuwei end

				#endregion

				#region 保存数据
				sql = "select SEQ_PM_SemiRework_ID.nextval from dual";
				object srID = con.GetSqlResultToObj(sql);
				// 返修
				string sqlString = "insert into tp_pm_semirework\n" +
				"  (SEMIREWORKID\n" +
				"  ,BARCODE\n" +
				"  ,PRODUCTIONLINEID\n" +
				"  ,PROCEDUREID\n" +
				"  ,PROCEDURETIME\n" +
				"  ,GOODSID\n" +
				"  ,GOODSCODE\n" +
				"  ,USERID\n" +
				"  ,USERCODE\n" +
				"  ,PRODUCTIONDATAID\n" +
				"  ,GROUTINGDAILYID\n" +
				"  ,GROUTINGDAILYDETAILID\n" +
				"  ,GROUTINGLINEID\n" +
				"  ,GROUTINGLINECODE\n" +
				"  ,GROUTINGLINEDETAILID\n" +
				"  ,GROUTINGDATE\n" +
				"  ,GROUTINGMOULDCODE\n" +
				"  ,GROUTINGUSERID\n" +
				"  ,GROUTINGUSERCODE\n" +
				"  ,SEMIREWORKUSERID\n" +
				"  ,SEMIREWORKUSERCODE\n" +
				"  ,SEMIREWORKTIME\n" +
				"  ,REWORKPROCEDUREID\n" +
				"  ,REMARKS\n" +
				"  ,ACCOUNTID\n" +
				"  ,VALUEFLAG\n" +
				"  ,CREATEUSERID\n" +
				"  ,UPDATEUSERID)\n" +
				"values\n" +
				"  (:SEMIREWORKID\n" +
				"  ,:BARCODE\n" +
				"  ,:PRODUCTIONLINEID\n" +
				"  ,:PROCEDUREID\n" +
				"  ,:PROCEDURETIME\n" +
				"  ,:GOODSID\n" +
				"  ,:GOODSCODE\n" +
				"  ,:USERID\n" +
				"  ,:USERCODE\n" +
				"  ,:PRODUCTIONDATAID\n" +
				"  ,:GROUTINGDAILYID\n" +
				"  ,:GROUTINGDAILYDETAILID\n" +
				"  ,:GROUTINGLINEID\n" +
				"  ,:GROUTINGLINECODE\n" +
				"  ,:GROUTINGLINEDETAILID\n" +
				"  ,:GROUTINGDATE\n" +
				"  ,:GROUTINGMOULDCODE\n" +
				"  ,:GROUTINGUSERID\n" +
				"  ,:GROUTINGUSERCODE\n" +
				"  ,:SEMIREWORKUSERID\n" +
				"  ,:SEMIREWORKUSERCODE\n" +
				"  ,sysdate\n" +
				"  ,:REWORKPROCEDUREID\n" +
				"  ,:REMARKS\n" +
				"  ,:ACCOUNTID\n" +
				"  ,'1'\n" +
				"  ,:CREATEUSERID\n" +
				"  ,:UPDATEUSERID)\n";
				paras = new OracleParameter[]{
					new OracleParameter(":SEMIREWORKID",OracleDbType.Int32,srID,ParameterDirection.Input),
					new OracleParameter(":BarCode",OracleDbType.NVarchar2,barcode,ParameterDirection.Input),
					new OracleParameter(":PRODUCTIONLINEID",OracleDbType.Int32,dataRow["PRODUCTIONLINEID"],ParameterDirection.Input),
					new OracleParameter(":PROCEDUREID",OracleDbType.Int32,dataRow["PROCEDUREID"],ParameterDirection.Input),
					new OracleParameter(":PROCEDURETIME",OracleDbType.Date,dataRow["PROCEDURETIME"],ParameterDirection.Input),
					new OracleParameter(":GOODSID",OracleDbType.Int32,dataRow["GOODSID"],ParameterDirection.Input),
					new OracleParameter(":GOODSCODE",OracleDbType.NVarchar2,dataRow["GOODSCODE"],ParameterDirection.Input),
					new OracleParameter(":USERID",OracleDbType.Int32,dataRow["USERID"],ParameterDirection.Input),
					new OracleParameter(":USERCODE",OracleDbType.NVarchar2,dataRow["USERCODE"],ParameterDirection.Input),
					new OracleParameter(":PRODUCTIONDATAID",OracleDbType.Int32,dataRow["PRODUCTIONDATAID"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGDAILYID",OracleDbType.Int32,dataRow["GROUTINGDAILYID"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGDAILYDETAILID",OracleDbType.Int32,dataRow["GROUTINGDAILYDETAILID"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGLINEID",OracleDbType.Int32,dataRow["GROUTINGLINEID"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGLINECODE",OracleDbType.NVarchar2,dataRow["GROUTINGLINECODE"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGLINEDETAILID",OracleDbType.Int32,dataRow["GROUTINGLINEDETAILID"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGDATE",OracleDbType.Date,dataRow["GROUTINGDATE"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGMOULDCODE",OracleDbType.NVarchar2,dataRow["GROUTINGMOULDCODE"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGUSERID",OracleDbType.Int32,dataRow["GROUTINGUSERID"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGUSERCODE",OracleDbType.NVarchar2,dataRow["GROUTINGUSERCODE"],ParameterDirection.Input),
					new OracleParameter(":SEMIREWORKUSERID",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
					new OracleParameter(":SEMIREWORKUSERCODE",OracleDbType.NVarchar2,sUserInfo.UserCode,ParameterDirection.Input),
					new OracleParameter(":REWORKPROCEDUREID",OracleDbType.Int32,entityobj.ReworkProcedureID,ParameterDirection.Input),
					new OracleParameter(":REMARKS",OracleDbType.NVarchar2,entityobj.Remarks,ParameterDirection.Input),
					new OracleParameter(":ACCOUNTID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
					new OracleParameter(":CREATEUSERID",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
					new OracleParameter(":UPDATEUSERID",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
				};
				con.ExecuteNonQuery(sqlString, paras);

				// 缺陷
				string sqlStringDefect =
				"insert into TP_PM_SemiReworkDefect\n" +
				"  (SEMIREWORKDEFECTID\n" +
				"  ,SEMIREWORKID\n" +
				"  ,DEFECTID\n" +
				"  ,DEFECTCODE\n" +
				"  ,DEFECTNAME\n" +
				"  ,DEFECTPOSITIONID\n" +
				"  ,DEFECTPOSITIONCODE\n" +
				"  ,DEFECTPOSITIONNAME\n" +
				"  ,SCRAPRESPONFLAG\n" +
				"  ,DEFECTPRODUCTIONDATAID\n" +
				"  ,DEFECTPROCEDUREID\n" +
				"  ,DEFECTUSERID\n" +
				"  ,DEFECTUSERCODE\n" +
				"  ,REMARKS\n" +
				"  ,ACCOUNTID\n" +
				"  ,VALUEFLAG\n" +
				"  ,CREATEUSERID\n" +
				"  ,UPDATEUSERID)\n" +
				"values\n" +
				"  (:SEMIREWORKDEFECTID\n" +
				"  ,:SEMIREWORKID\n" +
				"  ,:DEFECTID\n" +
				"  ,:DEFECTCODE\n" +
				"  ,:DEFECTNAME\n" +
				"  ,:DEFECTPOSITIONID\n" +
				"  ,:DEFECTPOSITIONCODE\n" +
				"  ,:DEFECTPOSITIONNAME\n" +
				"  ,:SCRAPRESPONFLAG\n" +
				"  ,:DEFECTPRODUCTIONDATAID\n" +
				"  ,:DEFECTPROCEDUREID\n" +
				"  ,:DEFECTUSERID\n" +
				"  ,:DEFECTUSERCODE\n" +
				"  ,:REMARKS\n" +
				"  ,:ACCOUNTID\n" +
				"  ,:VALUEFLAG\n" +
				"  ,:CREATEUSERID\n" +
				"  ,:UPDATEUSERID)";

				string sqlStringRPS =
				"insert into TP_PM_SemiReworkRPS\n" +
				"  (semireworkdefectid\n" +
				"  ,staffid\n" +
				"  ,semireworkid\n" +
				"  ,userid\n" +
				"  ,usercode\n" +
				"  ,ujobsid\n" +
				"  ,sjobsid\n" +
				"  ,accountid\n" +
				"  ,valueflag\n" +
				"  ,createuserid\n" +
				"  ,updateuserid)\n" +
				"values\n" +
				"  (:semireworkdefectid\n" +
				"  ,:staffid\n" +
				"  ,:semireworkid\n" +
				"  ,:userid\n" +
				"  ,:usercode\n" +
				"  ,:ujobsid\n" +
				"  ,:sjobsid\n" +
				"  ,:accountid\n" +
				"  ,'1'\n" +
				"  ,:createuserid\n" +
				"  ,:updateuserid)";

				foreach (SemiReworkDefectEntity defect in entityobj.SemiReworkDefects)
				{
					sql = "select SEQ_PM_SEMIREWORKDEFECT_ID.nextval from dual";
					object srdefectID = con.GetSqlResultToObj(sql);
					paras = new OracleParameter[]{
						new OracleParameter(":SEMIREWORKDEFECTID",OracleDbType.Int32,srdefectID,ParameterDirection.Input),
						new OracleParameter(":SEMIREWORKID",OracleDbType.Int32,srID,ParameterDirection.Input),
						new OracleParameter(":DEFECTID",OracleDbType.Int32,defect.DefectID,ParameterDirection.Input),
						new OracleParameter(":DEFECTCODE",OracleDbType.NVarchar2,defect.DefectCode,ParameterDirection.Input),
						new OracleParameter(":DEFECTNAME",OracleDbType.NVarchar2,defect.DefectName,ParameterDirection.Input),
						new OracleParameter(":DEFECTPOSITIONID",OracleDbType.Int32,defect.DefectPositionID,ParameterDirection.Input),
						new OracleParameter(":DEFECTPOSITIONCODE",OracleDbType.NVarchar2,defect.DefectPositionCode,ParameterDirection.Input),
						new OracleParameter(":DEFECTPOSITIONNAME",OracleDbType.NVarchar2,defect.DefectPositionName,ParameterDirection.Input),
						new OracleParameter(":SCRAPRESPONFLAG",OracleDbType.NVarchar2,defect.ScrapResponFlag,ParameterDirection.Input),
						new OracleParameter(":DEFECTPRODUCTIONDATAID",OracleDbType.Int32,defect.DefectProductionDataID,ParameterDirection.Input),
						new OracleParameter(":DEFECTPROCEDUREID",OracleDbType.Int32,defect.DefectProcedureID,ParameterDirection.Input),
						new OracleParameter(":DEFECTUSERID",OracleDbType.Int32,defect.DefectUserID,ParameterDirection.Input),
						new OracleParameter(":DEFECTUSERCODE",OracleDbType.NVarchar2,defect.DefectUserCode,ParameterDirection.Input),
						new OracleParameter(":REMARKS",OracleDbType.NVarchar2,defect.Remarks,ParameterDirection.Input),
						new OracleParameter(":ACCOUNTID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
                        //xuwei add 2019-11-14
                        new OracleParameter(":VALUEFLAG",OracleDbType.Char,defect.ValueFlag,ParameterDirection.Input),
                        //xuwei end 
                        new OracleParameter(":CREATEUSERID",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
						new OracleParameter(":UPDATEUSERID",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
					};
					con.ExecuteNonQuery(sqlStringDefect, paras);
					foreach (SemiReworkRPSEntity item in defect.DefectResponsibles)
					{
						paras = new OracleParameter[]{
							new OracleParameter(":semireworkdefectid",OracleDbType.Int32,srdefectID,ParameterDirection.Input),
							new OracleParameter(":staffid",OracleDbType.Int32,item.StaffID,ParameterDirection.Input),
							new OracleParameter(":semireworkid",OracleDbType.Int32,srID,ParameterDirection.Input),
							new OracleParameter(":userid",OracleDbType.Int32,item.UserID,ParameterDirection.Input),
							new OracleParameter(":usercode",OracleDbType.NVarchar2,item.UserCode,ParameterDirection.Input),
							new OracleParameter(":ujobsid",OracleDbType.Int32,item.UJobsID,ParameterDirection.Input),
							new OracleParameter(":sjobsid",OracleDbType.Int32,item.SJobsID,ParameterDirection.Input),
							new OracleParameter(":accountid",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
							new OracleParameter(":createuserid",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":updateuserid",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
						};
						con.ExecuteNonQuery(sqlStringRPS, paras);
					}
				}
				#endregion

				#region 更新在产数据
				string sqlStringInp = "update tp_pm_inproduction inp\n" +
				"   set inp.reworkprocedureid = :pid\n" +
				"      ,inp.isreworkflag      = '2'\n" +
				"      ,inp.semicheckid       = :srid\n" +
				" where inp.barcode = :barcode";
				paras = new OracleParameter[]{
					new OracleParameter(":pid",OracleDbType.Int32,entityobj.ReworkProcedureID,ParameterDirection.Input),
					new OracleParameter(":srid",OracleDbType.Int32,srID,ParameterDirection.Input),
					new OracleParameter(":barcode",OracleDbType.NVarchar2,barcode,ParameterDirection.Input),
				};
				con.ExecuteNonQuery(sqlStringInp, paras);
				#endregion

				con.Commit();
				return resultEntity;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Disconnect();
				}
			}
		}

		/// <summary>
		/// 编辑半检返修
		/// </summary>
		/// <param name="entityobj"></param>
		/// <param name="sUserInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity EditSemiRework(SemiReworkEntity entityobj, SUserInfo sUserInfo)
		{
			IDBTransaction con = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				ServiceResultEntity resultEntity = new ServiceResultEntity();
				resultEntity.Result = 1;
				if (entityobj == null || string.IsNullOrWhiteSpace(entityobj.BarCode) ||
					entityobj.SemiReworkDefects == null || entityobj.SemiReworkDefects.Count == 0)
				{
					resultEntity.Result = -1;
					resultEntity.Message = "数据错误";
					return resultEntity;
				}
				con.Connect();

				string barcode = entityobj.BarCode;
				#region 验证条码
				// 1.判断产品是否在产
				string sql = @"select p.*,u.usercode from TP_PM_InProduction p inner join tp_mst_user u on u.userid=p.userid where p.BarCode=:BarCode for update";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":BarCode",OracleDbType.NVarchar2,barcode,ParameterDirection.Input),
				};
				DataTable dsResult = con.GetSqlResultToDt(sql, paras);
				if (dsResult == null || dsResult.Rows.Count == 0)
				{
					resultEntity.Result = -1;// 不在在产表中
					resultEntity.Message = "条码[" + barcode + "]不在在产流程";
					return resultEntity;
				}
				DataRow dataRow = dsResult.Rows[0];
				if (dataRow["InScrapFlag"].ToString() == "1")
				{
					resultEntity.Result = -2; //报损待审批
					resultEntity.Message = "条码[" + barcode + "]已经报损待审批";
					return resultEntity;
				}
				if (!string.IsNullOrEmpty(dataRow["KilnCarID"].ToString()))
				{
					resultEntity.Result = -3; //登窑车后不允许半成品检测
					resultEntity.Message = "条码[" + barcode + "]已经在窑车[" + dataRow["KilnCarName"].ToString() + "]";
					return resultEntity;
				}
				if (dataRow["IsReworkFlag"].ToString() == "1")
				{
					resultEntity.Result = -4; //半检返工
					resultEntity.Message = "条码[" + barcode + "]已半检返工";
					return resultEntity;
				}
				if (dataRow["IsReworkFlag"].ToString() != "2")
				{
					resultEntity.Result = -5; //半检返修
					resultEntity.Message = "条码[" + barcode + "]未半检返修";
					return resultEntity;
				}
				if (Convert.ToInt32(dataRow["SemiCheckID"]) != entityobj.SemiReworkID)
				{
					resultEntity.Result = -6; //半检返修
					resultEntity.Message = "条码[" + barcode + "]已重新登记半检返修";
					return resultEntity;
				}
				#endregion

				#region 停用数据
				//xuwei modify 2019-11-18 如果半检工号不同 跳过停用数据 
				//通过 SEMIREWORKUSERCODE 半检工号 与 当前操作工号 判定识别
				string isSameUser = con.GetSqlResultToStr($@"
                    SELECT
	                    count( SEMIREWORKID ) 
                    FROM
	                    TP_PM_SEMIREWORK 
                    WHERE
	                    SEMIREWORKID = {entityobj.SemiReworkID} 
	                    AND SEMIREWORKUSERCODE = '{sUserInfo.UserCode}'
                ");
				//xuwei modify 2019-11-18 如果半检工号不同 跳过停用数据
				if (isSameUser == "1")
				{
					paras = new OracleParameter[]{
						new OracleParameter(":userid",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
						new OracleParameter(":SemiReworkID",OracleDbType.Int32,entityobj.SemiReworkID,ParameterDirection.Input),
					};
					string sqldelete = "update TP_PM_SemiReworkRPS\n" +
					"   set valueflag = '0', UpdateTime = sysdate, UpdateUserID = :userid\n" +
					" where SemiReworkID = :SemiReworkID";
					con.ExecuteNonQuery(sqldelete, paras);
					sqldelete = "update TP_PM_SemiReworkDefect\n" +
					"   set valueflag = '0', UpdateTime = sysdate, UpdateUserID = :userid\n" +
					" where SemiReworkID = :SemiReworkID";
					con.ExecuteNonQuery(sqldelete, paras);
					sqldelete = " update TP_PM_SemiRework\n" +
					"   set valueflag = '0', UpdateTime = sysdate, UpdateUserID = :userid\n" +
					" where SemiReworkID = :SemiReworkID";
					con.ExecuteNonQuery(sqldelete, paras);
				}
				#endregion



				#region 保存数据
				sql = "select SEQ_PM_SemiRework_ID.nextval from dual";
				object srID = con.GetSqlResultToObj(sql);
				// 返修
				string sqlString = "insert into tp_pm_semirework\n" +
				"  (SEMIREWORKID\n" +
				"  ,BARCODE\n" +
				"  ,PRODUCTIONLINEID\n" +
				"  ,PROCEDUREID\n" +
				"  ,PROCEDURETIME\n" +
				"  ,GOODSID\n" +
				"  ,GOODSCODE\n" +
				"  ,USERID\n" +
				"  ,USERCODE\n" +
				"  ,PRODUCTIONDATAID\n" +
				"  ,GROUTINGDAILYID\n" +
				"  ,GROUTINGDAILYDETAILID\n" +
				"  ,GROUTINGLINEID\n" +
				"  ,GROUTINGLINECODE\n" +
				"  ,GROUTINGLINEDETAILID\n" +
				"  ,GROUTINGDATE\n" +
				"  ,GROUTINGMOULDCODE\n" +
				"  ,GROUTINGUSERID\n" +
				"  ,GROUTINGUSERCODE\n" +
				"  ,SEMIREWORKUSERID\n" +
				"  ,SEMIREWORKUSERCODE\n" +
				"  ,SEMIREWORKTIME\n" +
				"  ,REWORKPROCEDUREID\n" +
				"  ,REMARKS\n" +
				"  ,ACCOUNTID\n" +
				"  ,VALUEFLAG\n" +
				"  ,CREATEUSERID\n" +
				"  ,UPDATEUSERID)\n" +
				"values\n" +
				"  (:SEMIREWORKID\n" +
				"  ,:BARCODE\n" +
				"  ,:PRODUCTIONLINEID\n" +
				"  ,:PROCEDUREID\n" +
				"  ,:PROCEDURETIME\n" +
				"  ,:GOODSID\n" +
				"  ,:GOODSCODE\n" +
				"  ,:USERID\n" +
				"  ,:USERCODE\n" +
				"  ,:PRODUCTIONDATAID\n" +
				"  ,:GROUTINGDAILYID\n" +
				"  ,:GROUTINGDAILYDETAILID\n" +
				"  ,:GROUTINGLINEID\n" +
				"  ,:GROUTINGLINECODE\n" +
				"  ,:GROUTINGLINEDETAILID\n" +
				"  ,:GROUTINGDATE\n" +
				"  ,:GROUTINGMOULDCODE\n" +
				"  ,:GROUTINGUSERID\n" +
				"  ,:GROUTINGUSERCODE\n" +
				"  ,:SEMIREWORKUSERID\n" +
				"  ,:SEMIREWORKUSERCODE\n" +
				//"  ,:SEMIREWORKTIME\n" +
				"  ,sysdate\n" +
				"  ,:REWORKPROCEDUREID\n" +
				"  ,:REMARKS\n" +
				"  ,:ACCOUNTID\n" +
				"  ,'1'\n" +
				"  ,:CREATEUSERID\n" +
				"  ,:UPDATEUSERID)\n";
				paras = new OracleParameter[]{
					new OracleParameter(":SEMIREWORKID",OracleDbType.Int32,srID,ParameterDirection.Input),
					new OracleParameter(":BarCode",OracleDbType.NVarchar2,barcode,ParameterDirection.Input),
					new OracleParameter(":PRODUCTIONLINEID",OracleDbType.Int32,dataRow["PRODUCTIONLINEID"],ParameterDirection.Input),
					new OracleParameter(":PROCEDUREID",OracleDbType.Int32,dataRow["PROCEDUREID"],ParameterDirection.Input),
					new OracleParameter(":PROCEDURETIME",OracleDbType.Date,dataRow["PROCEDURETIME"],ParameterDirection.Input),
					new OracleParameter(":GOODSID",OracleDbType.Int32,dataRow["GOODSID"],ParameterDirection.Input),
					new OracleParameter(":GOODSCODE",OracleDbType.NVarchar2,dataRow["GOODSCODE"],ParameterDirection.Input),
					new OracleParameter(":USERID",OracleDbType.Int32,dataRow["USERID"],ParameterDirection.Input),
					new OracleParameter(":USERCODE",OracleDbType.NVarchar2,dataRow["USERCODE"],ParameterDirection.Input),
					new OracleParameter(":PRODUCTIONDATAID",OracleDbType.Int32,dataRow["PRODUCTIONDATAID"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGDAILYID",OracleDbType.Int32,dataRow["GROUTINGDAILYID"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGDAILYDETAILID",OracleDbType.Int32,dataRow["GROUTINGDAILYDETAILID"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGLINEID",OracleDbType.Int32,dataRow["GROUTINGLINEID"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGLINECODE",OracleDbType.NVarchar2,dataRow["GROUTINGLINECODE"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGLINEDETAILID",OracleDbType.Int32,dataRow["GROUTINGLINEDETAILID"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGDATE",OracleDbType.Date,dataRow["GROUTINGDATE"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGMOULDCODE",OracleDbType.NVarchar2,dataRow["GROUTINGMOULDCODE"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGUSERID",OracleDbType.Int32,dataRow["GROUTINGUSERID"],ParameterDirection.Input),
					new OracleParameter(":GROUTINGUSERCODE",OracleDbType.NVarchar2,dataRow["GROUTINGUSERCODE"],ParameterDirection.Input),

                    //new OracleParameter(":SEMIREWORKUSERID",OracleDbType.Int32,entityobj.SEMIREWORKUSERID,ParameterDirection.Input),
                    //new OracleParameter(":SEMIREWORKUSERCODE",OracleDbType.NVarchar2,entityobj.UserCode,ParameterDirection.Input),
                    //new OracleParameter(":SEMIREWORKTIME",OracleDbType.Date,sUserInfo.entityobj,ParameterDirection.Input),
                    new OracleParameter(":SEMIREWORKUSERID",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
					new OracleParameter(":SEMIREWORKUSERCODE",OracleDbType.NVarchar2,sUserInfo.UserCode,ParameterDirection.Input),

					new OracleParameter(":REWORKPROCEDUREID",OracleDbType.Int32,entityobj.ReworkProcedureID,ParameterDirection.Input),
					new OracleParameter(":REMARKS",OracleDbType.NVarchar2,entityobj.Remarks,ParameterDirection.Input),
					new OracleParameter(":ACCOUNTID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
					new OracleParameter(":CREATEUSERID",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
					new OracleParameter(":UPDATEUSERID",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
				};
				con.ExecuteNonQuery(sqlString, paras);

				// 缺陷
				string sqlStringDefect =
				"insert into TP_PM_SemiReworkDefect\n" +
				"  (SEMIREWORKDEFECTID\n" +
				"  ,SEMIREWORKID\n" +
				"  ,DEFECTID\n" +
				"  ,DEFECTCODE\n" +
				"  ,DEFECTNAME\n" +
				"  ,DEFECTPOSITIONID\n" +
				"  ,DEFECTPOSITIONCODE\n" +
				"  ,DEFECTPOSITIONNAME\n" +
				"  ,SCRAPRESPONFLAG\n" +
				"  ,DEFECTPRODUCTIONDATAID\n" +
				"  ,DEFECTPROCEDUREID\n" +
				"  ,DEFECTUSERID\n" +
				"  ,DEFECTUSERCODE\n" +
				"  ,REMARKS\n" +
				"  ,ACCOUNTID\n" +
				"  ,VALUEFLAG\n" +
				"  ,CREATEUSERID\n" +
				"  ,UPDATEUSERID)\n" +
				"values\n" +
				"  (:SEMIREWORKDEFECTID\n" +
				"  ,:SEMIREWORKID\n" +
				"  ,:DEFECTID\n" +
				"  ,:DEFECTCODE\n" +
				"  ,:DEFECTNAME\n" +
				"  ,:DEFECTPOSITIONID\n" +
				"  ,:DEFECTPOSITIONCODE\n" +
				"  ,:DEFECTPOSITIONNAME\n" +
				"  ,:SCRAPRESPONFLAG\n" +
				"  ,:DEFECTPRODUCTIONDATAID\n" +
				"  ,:DEFECTPROCEDUREID\n" +
				"  ,:DEFECTUSERID\n" +
				"  ,:DEFECTUSERCODE\n" +
				"  ,:REMARKS\n" +
				"  ,:ACCOUNTID\n" +
				"  ,:VALUEFLAG\n" + //xuwei add 2019-11-14
				"  ,:CREATEUSERID\n" +
				"  ,:UPDATEUSERID)";

				string sqlStringRPS =
				"insert into TP_PM_SemiReworkRPS\n" +
				"  (semireworkdefectid\n" +
				"  ,staffid\n" +
				"  ,semireworkid\n" +
				"  ,userid\n" +
				"  ,usercode\n" +
				"  ,ujobsid\n" +
				"  ,sjobsid\n" +
				"  ,accountid\n" +
				"  ,valueflag\n" +
				"  ,createuserid\n" +
				"  ,updateuserid)\n" +
				"values\n" +
				"  (:semireworkdefectid\n" +
				"  ,:staffid\n" +
				"  ,:semireworkid\n" +
				"  ,:userid\n" +
				"  ,:usercode\n" +
				"  ,:ujobsid\n" +
				"  ,:sjobsid\n" +
				"  ,:accountid\n" +
				"  ,'1'\n" +
				"  ,:createuserid\n" +
				"  ,:updateuserid)";

				foreach (SemiReworkDefectEntity defect in entityobj.SemiReworkDefects)
				{
					sql = "select SEQ_PM_SEMIREWORKDEFECT_ID.nextval from dual";
					object srdefectID = con.GetSqlResultToObj(sql);
					paras = new OracleParameter[]{
						new OracleParameter(":SEMIREWORKDEFECTID",OracleDbType.Int32,srdefectID,ParameterDirection.Input),
						new OracleParameter(":SEMIREWORKID",OracleDbType.Int32,srID,ParameterDirection.Input),
						new OracleParameter(":DEFECTID",OracleDbType.Int32,defect.DefectID,ParameterDirection.Input),
						new OracleParameter(":DEFECTCODE",OracleDbType.NVarchar2,defect.DefectCode,ParameterDirection.Input),
						new OracleParameter(":DEFECTNAME",OracleDbType.NVarchar2,defect.DefectName,ParameterDirection.Input),
						new OracleParameter(":DEFECTPOSITIONID",OracleDbType.Int32,defect.DefectPositionID,ParameterDirection.Input),
						new OracleParameter(":DEFECTPOSITIONCODE",OracleDbType.NVarchar2,defect.DefectPositionCode,ParameterDirection.Input),
						new OracleParameter(":DEFECTPOSITIONNAME",OracleDbType.NVarchar2,defect.DefectPositionName,ParameterDirection.Input),
						new OracleParameter(":SCRAPRESPONFLAG",OracleDbType.NVarchar2,defect.ScrapResponFlag,ParameterDirection.Input),
						new OracleParameter(":DEFECTPRODUCTIONDATAID",OracleDbType.Int32,defect.DefectProductionDataID,ParameterDirection.Input),
						new OracleParameter(":DEFECTPROCEDUREID",OracleDbType.Int32,defect.DefectProcedureID,ParameterDirection.Input),
						new OracleParameter(":DEFECTUSERID",OracleDbType.Int32,defect.DefectUserID,ParameterDirection.Input),
						new OracleParameter(":DEFECTUSERCODE",OracleDbType.NVarchar2,defect.DefectUserCode,ParameterDirection.Input),
						new OracleParameter(":REMARKS",OracleDbType.NVarchar2,defect.Remarks,ParameterDirection.Input),
						new OracleParameter(":ACCOUNTID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
                        //xuwei add 2019-11-14
                        new OracleParameter(":VALUEFLAG",OracleDbType.Char,defect.ValueFlag,ParameterDirection.Input),
                        //xuwei end
                        new OracleParameter(":CREATEUSERID",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
						new OracleParameter(":UPDATEUSERID",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
					};
					con.ExecuteNonQuery(sqlStringDefect, paras);
					foreach (SemiReworkRPSEntity item in defect.DefectResponsibles)
					{
						paras = new OracleParameter[]{
							new OracleParameter(":semireworkdefectid",OracleDbType.Int32,srdefectID,ParameterDirection.Input),
							new OracleParameter(":staffid",OracleDbType.Int32,item.StaffID,ParameterDirection.Input),
							new OracleParameter(":semireworkid",OracleDbType.Int32,srID,ParameterDirection.Input),
							new OracleParameter(":userid",OracleDbType.Int32,item.UserID,ParameterDirection.Input),
							new OracleParameter(":usercode",OracleDbType.NVarchar2,item.UserCode,ParameterDirection.Input),
							new OracleParameter(":ujobsid",OracleDbType.Int32,item.UJobsID,ParameterDirection.Input),
							new OracleParameter(":sjobsid",OracleDbType.Int32,item.SJobsID,ParameterDirection.Input),
							new OracleParameter(":accountid",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
							new OracleParameter(":createuserid",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":updateuserid",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
						};
						con.ExecuteNonQuery(sqlStringRPS, paras);
					}
				}
				#endregion

				#region 更新在产数据
				string sqlStringInp = "update tp_pm_inproduction inp\n" +
				"   set inp.reworkprocedureid = :pid\n" +
				"      ,inp.isreworkflag      = '2'\n" +
				"      ,inp.semicheckid       = :srid\n" +
				" where inp.barcode = :barcode";
				paras = new OracleParameter[]{
					new OracleParameter(":pid",OracleDbType.Int32,entityobj.ReworkProcedureID,ParameterDirection.Input),
					new OracleParameter(":srid",OracleDbType.Int32,srID,ParameterDirection.Input),
					new OracleParameter(":barcode",OracleDbType.NVarchar2,barcode,ParameterDirection.Input),
				};
				con.ExecuteNonQuery(sqlStringInp, paras);
				#endregion

				con.Commit();
				return resultEntity;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Disconnect();
				}
			}
		}

		/// <summary>
		/// 撤销半检返修
		/// </summary>
		/// <param name="entityobj"></param>
		/// <param name="sUserInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity CancelSemiRework(SemiReworkEntity entityobj, SUserInfo sUserInfo)
		{
			IDBTransaction con = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				ServiceResultEntity resultEntity = new ServiceResultEntity();
				resultEntity.Result = 1;
				if (entityobj == null || string.IsNullOrWhiteSpace(entityobj.BarCode) || entityobj.SemiReworkID < 1)
				{
					resultEntity.Result = -1;
					resultEntity.Message = "数据错误";
					return resultEntity;
				}
				con.Connect();

				string barcode = entityobj.BarCode;
				#region 验证条码
				// 1.判断产品是否在产
				string sql = @"select * from TP_PM_InProduction where BarCode=:BarCode for update";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":BarCode",OracleDbType.NVarchar2,barcode,ParameterDirection.Input),
				};
				DataTable dsResult = con.GetSqlResultToDt(sql, paras);
				if (dsResult == null || dsResult.Rows.Count == 0)
				{
					resultEntity.Result = -1;// 不在在产表中
					resultEntity.Message = "条码[" + barcode + "]不在在产流程";
					return resultEntity;
				}
				DataRow dataRow = dsResult.Rows[0];
				if (dataRow["InScrapFlag"].ToString() == "1")
				{
					resultEntity.Result = -2; //报损待审批
					resultEntity.Message = "条码[" + barcode + "]已经报损待审批";
					return resultEntity;
				}
				if (!string.IsNullOrEmpty(dataRow["KilnCarID"].ToString()))
				{
					resultEntity.Result = -3; //登窑车后不允许半成品检测
					resultEntity.Message = "条码[" + barcode + "]已经在窑车[" + dataRow["KilnCarName"].ToString() + "]";
					return resultEntity;
				}
				if (dataRow["IsReworkFlag"].ToString() == "1")
				{
					resultEntity.Result = -4; //半检返工
					resultEntity.Message = "条码[" + barcode + "]已半检返工";
					return resultEntity;
				}
				if (dataRow["IsReworkFlag"].ToString() != "2")
				{
					resultEntity.Result = -5; //半检返修
					resultEntity.Message = "条码[" + barcode + "]未半检返修";
					return resultEntity;
				}
				if (Convert.ToInt32(dataRow["SemiCheckID"]) != entityobj.SemiReworkID)
				{
					resultEntity.Result = -6; //半检返修
					resultEntity.Message = "条码[" + barcode + "]已重新登记半检返修";
					return resultEntity;
				}
				#endregion

				#region 停用数据
				paras = new OracleParameter[]{
					new OracleParameter(":userid",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
					new OracleParameter(":usercode",OracleDbType.NVarchar2,sUserInfo.UserCode,ParameterDirection.Input),
					new OracleParameter(":SemiReworkID",OracleDbType.Int32,entityobj.SemiReworkID,ParameterDirection.Input),
				};
				//string sqldelete = "update TP_PM_SemiReworkRPS\n" +
				//"   set valueflag = '0', UpdateTime = sysdate UpdateUserID = :userid\n" +
				//" where SemiReworkID = :SemiReworkID";
				//con.ExecuteNonQuery(sqldelete, paras);
				//sqldelete = "update TP_PM_SemiReworkDefect\n" +
				//"   set valueflag = '0', UpdateTime = sysdate UpdateUserID = :userid\n" +
				//" where SemiReworkID = :SemiReworkID";
				//con.ExecuteNonQuery(sqldelete, paras);
				//sqldelete = " update TP_PM_SemiRework\n" +
				//"   set valueflag = '0', UpdateTime = sysdate UpdateUserID = :userid\n" +
				//" where SemiReworkID = :SemiReworkID";
				//con.ExecuteNonQuery(sqldelete, paras);

				string sqlString = "update TP_PM_SemiRework\n" +
				"   set BackOutFlag     = '1'\n" +
				"      ,BackOutTime     = sysdate\n" +
				"      ,BackOutUserID   = :userid\n" +
				"      ,BackOutUserCode = :usercode\n" +
				"      ,UpdateTime      = sysdate\n" +
				"      ,UpdateUserID    = :userid\n" +
				" where SemiReworkID = :SemiReworkID";
				con.ExecuteNonQuery(sqlString, paras);

				#endregion

				#region 更新在产数据
				string sqlStringInp = "update tp_pm_inproduction inp\n" +
				"   set inp.reworkprocedureid = null\n" +
				"      ,inp.isreworkflag      = '0'\n" +
				"      ,inp.semicheckid       = null\n" +
				" where inp.barcode = :barcode";
				paras = new OracleParameter[]{
					new OracleParameter(":barcode",OracleDbType.NVarchar2,barcode,ParameterDirection.Input),
				};
				con.ExecuteNonQuery(sqlStringInp, paras);
				#endregion

				con.Commit();
				return resultEntity;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Disconnect();
				}
			}
		}

		public static ServiceResultEntity GetSemiReworkForPDAEdit(int semiReworkID, SUserInfo sUserInfo)
		{
			return null;
		}
		#endregion

		#region 窑车漏扫补件
		/// <summary>
		/// 验证窑车是否存在
		/// </summary>
		/// <param name="cre"></param>
		/// <param name="userInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity CheckKilnCar(ClientRequestEntity cre, SUserInfo userInfo)
		{
			IDataAccess dataAccess = DataAccess.Create(DataBaseType.Oracle, DataManager.ConnectionString);
			try
			{
				string sqlString = "select kc.kilncarid,kc.kilnid\n" +
				"  from tp_mst_kilncar kc\n" +
				" where kc.valueflag = '1'\n" +
				"   and kc.accountid = @accountID@\n" +
				"   and kc.kilncarcode = @kilncarcode@";

				CDAParameter[] paras = new CDAParameter[]
				{
					new CDAParameter("accountID", userInfo.AccountID),
					new CDAParameter("kilncarcode", cre.Properties["kilncarcode"]),
				};

				ServiceResultEntity sre = new ServiceResultEntity();
				DataTable data = dataAccess.ExecuteDatatable(sqlString, paras);
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 1;
					sre.Message = "此窑车不存在";
					return sre;
				}
				sre.Result = data.Rows[0]["kilncarid"];

				sqlString = "Select procedureID From tp_pc_procedureKiln t where t.KilnID = @KilnID@ and t.procedureID = @procedureID@";
				paras = new CDAParameter[]
				{
					new CDAParameter("KilnID", data.Rows[0]["kilnid"]),
					new CDAParameter("procedureID", cre.Properties["procedureID"]),
				};

				data = dataAccess.ExecuteDatatable(sqlString, paras);
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 2;
					sre.Message = "此窑车不不允许经过此工序";
					return sre;
				}

				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				dataAccess?.Dispose();
			}
		}

		/// <summary>
		/// 验证窑车烧成批次号是否存在 和 是否能补漏扫
		/// </summary>
		/// <param name="cre"></param>
		/// <param name="userInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity CheckKilnCarBatchNo(ClientRequestEntity cre, SUserInfo userInfo)
		{
			IDataAccess dataAccess = DataAccess.Create(DataBaseType.Oracle, DataManager.ConnectionString);
			try
			{
				string sqlString = "select t.kilncardataid, t.modelType, t.procedureid\n" +
				"  from tp_pm_kilncardata t\n" +
				" where t.kilnid = @kilnid@\n" +
				"   and t.kilncarid = @kilncarid@\n" +
				"   and t.valueflag = '1'\n" +
				"   and t.kilncarbatchno = @kilncarbatchno@";

				CDAParameter[] paras = new CDAParameter[]
				{
					new CDAParameter("kilnid", cre.Properties["KilnID"]),
					new CDAParameter("kilncarid", cre.Properties["KilnCarID"]),
					new CDAParameter("kilncarbatchno", cre.Properties["KilnCarBatchNo"]),
				};

				ServiceResultEntity sre = new ServiceResultEntity();
				DataTable data = dataAccess.ExecuteDatatable(sqlString, paras);
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 1;
					sre.Message = "此烧成批次号不存在";
					return sre;
				}

				int carProcedureid = Convert.ToInt32(data.Rows[0]["procedureid"]);
				string modelType = data.Rows[data.Rows.Count - 1]["modelType"] + "";

				if (modelType != "4")
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 2;
					sre.Message = "此窑车还未卸窑不能补件";
					return sre;
				}
				if (carProcedureid != Convert.ToInt32(cre.Properties["ProcedureID"]))
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = 3;
					sre.Message = "此窑车烧成批次不是在当前工序登窑";
					return sre;
				}

				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				dataAccess?.Dispose();
			}
		}

		/// <summary>
		/// 窑车漏扫补件
		/// </summary>
		/// <param name="cre"></param>
		/// <param name="userInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity SetKilnCarMissing(ClientRequestEntity cre, SUserInfo userInfo)
		{
			IDataAccess dataAccess = DataAccess.Create(DataBaseType.Oracle, DataManager.ConnectionString);
			try
			{
				ServiceResultEntity sre = new ServiceResultEntity();
				dataAccess.Open(true);

				DataTable data = cre.Data.Tables[0];
				string CENTRALIZEDBATCHNO = System.Guid.NewGuid().ToString().ToUpper();

				string sqlString = "\n" +
				"insert into tp_pm_productiondatain\n" +
				"  (BARCODE\n" +
				"  ,CENTRALIZEDBATCHNO\n" +
				"  ,PRODUCTIONLINEID\n" +
				"  ,PRODUCTIONLINECODE\n" +
				"  ,PRODUCTIONLINENAME\n" +
				"  ,PROCEDUREID\n" +
				"  ,PROCEDURECODE\n" +
				"  ,PROCEDURENAME\n" +
				"  ,PROCEDUREMODEL\n" +
				"  ,MODELTYPE\n" +
				"  ,PIECETYPE\n" +
				"  ,ISREWORKED\n" +
				"  ,NODETYPE\n" +
				"  ,ISPUBLICBODY\n" +
				"  ,ISREFIRE\n" +
				"  ,ORGANIZATIONID\n" +
				"  ,GOODSID\n" +
				"  ,GOODSCODE\n" +
				"  ,GOODSNAME\n" +
				"  ,USERID\n" +
				"  ,USERCODE\n" +
				"  ,USERNAME\n" +
				"  ,KILNID\n" +
				"  ,KILNCODE\n" +
				"  ,KILNNAME\n" +
				"  ,KILNCARID\n" +
				"  ,KILNCARCODE\n" +
				"  ,KILNCARNAME\n" +
				"  ,KILNCARBATCHNO\n" +
				"  ,KILNCARPOSITION\n" +
				"  ,REMARKS\n" +
				"  ,ACCOUNTDATE\n" +
				"  ,ACCOUNTID\n" +
				"  ,VALUEFLAG\n" +
				"  ,CREATEUSERID\n" +
				"  ,UPDATEUSERID\n" +
				"  ,GROUTINGDATE\n" +
				"  ,GROUTINGMOULDCODE\n" +
				"  ,MOULDCODE\n" +
				"  ,GROUTINGUSERID\n" +
				"  ,GROUTINGUSERCODE\n" +
				"  ,GROUTINGNUM\n" +
				"  ,GROUTINGDAILYID\n" +
				"  ,GROUTINGDAILYDETAILID\n" +
				"  ,GROUTINGLINEID\n" +
				"  ,GROUTINGLINECODE\n" +
				"  ,GROUTINGLINENAME\n" +
				"  ,GMOULDTYPEID\n" +
				"  ,CANMANYTIMES\n" +
				"  ,GROUTINGLINEDETAILID\n" +
				"  ,SPECIALREPAIRFLAG\n" +
				"  ,CLASSESSETTINGID\n" +
				"  ,LOGOID\n" +
				"  ,CHECKTIME)\n" +
				"  select inp.barcode\n" +
				"        ,@CENTRALIZEDBATCHNO@\n" +
				"        ,kd.productionlineid\n" +
				"        ,pline.PRODUCTIONLINECODE\n" +
				"        ,pline.PRODUCTIONLINENAME\n" +
				"        ,kd.procedureid\n" +
				"        ,pcp.PROCEDURECODE\n" +
				"        ,pcp.PROCEDURENAME\n" +
				"        ,pcp.proceduremodel\n" +
				"        ,pcp.modeltype\n" +
				"        ,pcp.piecetype\n" +
				"        ,'0'\n" +
				"        ,pcp.nodetype\n" +
				"        ,inp.ispublicbody\n" +
				"        ,inp.isrefire\n" +
				"        ,pcp.organizationid\n" +
				"        ,inp.goodsid\n" +
				"        ,inp.goodscode\n" +
				"        ,inp.goodsname\n" +
				//"        ,kd.USERID\n" +
				//"        ,kd.USERCODE\n" +
				//"        ,kd.USERNAME\n" +
				"        ,@USERID@\n" +
				"        ,@USERCODE@\n" +
				"        ,@USERNAME@\n" +
				"        ,kd.KILNID\n" +
				"        ,k.KILNCODE\n" +
				"        ,k.KILNNAME\n" +
				"        ,kc.KILNCARID\n" +
				"        ,kc.KILNCARCODE\n" +
				"        ,kc.KILNCARNAME\n" +
				"        ,kd.KILNCARBATCHNO\n" +
				"        ,@KILNCARPOSITION@\n" +
				"        ,'窑车漏扫补件'\n" +
				"        ,trunc(sysdate)\n" +
				"        ,@ACCOUNTID@\n" +
				"        ,'1'\n" +
				"        ,@CREATEUSERID@\n" +
				"        ,@CREATEUSERID@\n" +
				"        ,inp.GROUTINGDATE\n" +
				"        ,inp.GROUTINGMOULDCODE\n" +
				"        ,inp.MOULDCODE\n" +
				"        ,inp.GROUTINGUSERID\n" +
				"        ,inp.GROUTINGUSERCODE\n" +
				"        ,inp.GROUTINGNUM\n" +
				"        ,inp.GROUTINGDAILYID\n" +
				"        ,inp.GROUTINGDAILYDETAILID\n" +
				"        ,inp.GROUTINGLINEID\n" +
				"        ,inp.GROUTINGLINECODE\n" +
				"        ,inp.GROUTINGLINENAME\n" +
				"        ,inp.GMOULDTYPEID\n" +
				"        ,inp.CANMANYTIMES\n" +
				"        ,inp.GROUTINGLINEDETAILID\n" +
				"        ,inp.SPECIALREPAIRFLAG\n" +
				"        ,kd.CLASSESSETTINGID\n" +
				"        ,inp.LOGOID\n" +
				"        ,kd.CREATETIME\n" +
				"    from tp_pm_inproduction inp\n" +
				"   inner join tp_pm_kilncardata kd\n" +
				"      on kd.kilncarbatchno = @kilncarbatchno@\n" +
				"     and kd.valueflag = '1'\n" +
				"   inner join tp_pc_productionline pline\n" +
				"      on pline.productionlineid = kd.productionlineid\n" +
				"   inner join tp_pc_procedure pcp\n" +
				"      on pcp.procedureid = kd.procedureid\n" +
				"   inner join tp_mst_kiln k\n" +
				"      on kd.kilnid = k.kilnid\n" +
				"   inner join tp_mst_kilncar kc\n" +
				"      on kc.kilncarid = kd.kilncarid\n" +
				"   where inp.barcode = @barcode@\n" +
				"   order by kd.kilncardataid";

				string sqlUpdate = "update tp_pm_inproduction t\n" +
				"   set (t.KILNID\n" +
				"      ,t.KILNCODE\n" +
				"      ,t.KILNNAME\n" +
				"      ,t.KILNCARID\n" +
				"      ,t.KILNCARCODE\n" +
				"      ,t.KILNCARNAME\n" +
				"      ,t.KILNCARBATCHNO\n" +
				"      ,t.KILNCARPOSITION\n" +
				"      ,t.PROCEDUREMODEL\n" +
				"      ,t.MODELTYPE\n" +
				"      ,t.FLOWPROCEDUREID\n" +
				"      ,t.FLOWPROCEDURETIME\n" +
				"      ,t.PROCEDUREID\n" +
				"      ,t.PROCEDURETIME\n" +
				"      ,t.USERID\n" +
				"      ,t.PRODUCTIONDATAID) =\n" +
				"       (select pin.KILNID\n" +
				"              ,pin.KILNCODE\n" +
				"              ,pin.KILNNAME\n" +
				"              ,pin.KILNCARID\n" +
				"              ,pin.KILNCARCODE\n" +
				"              ,pin.KILNCARNAME\n" +
				"              ,pin.KILNCARBATCHNO\n" +
				"              ,pin.KILNCARPOSITION\n" +
				"              ,pin.PROCEDUREMODEL\n" +
				"              ,pin.MODELTYPE\n" +
				"              ,pin.PROCEDUREID\n" +
				"              ,sysdate\n" +
				"              ,pin.PROCEDUREID\n" +
				"              ,sysdate\n" +
				"              ,@USERID@\n" +
				"              ,pin.PRODUCTIONDATAID\n" +
				"          from tp_pm_productiondatain pin\n" +
				"         where pin.productiondataid =\n" +
				"               (select max(productiondataid)\n" +
				"                  from tp_pm_productiondatain ppin\n" +
				"                 where ppin.barcode = t.barcode))\n" +
				" where t.barcode = @barcode@";
				foreach (DataRow item in data.Rows)
				{
					CDAParameter[] paras = new CDAParameter[]
					{
						new CDAParameter("CENTRALIZEDBATCHNO", CENTRALIZEDBATCHNO),
						new CDAParameter("ACCOUNTID", userInfo.AccountID),
						new CDAParameter("CREATEUSERID", userInfo.UserID),
						new CDAParameter("kilncarbatchno", cre.Properties["KilnCarBatchNo"]),
						new CDAParameter("barcode", item["barcode"]),
						new CDAParameter("KILNCARPOSITION", item["KILNCARPOSITION"]),
						new CDAParameter("USERID", userInfo.UserID),
						new CDAParameter("USERCODE", userInfo.UserCode),
						new CDAParameter("USERNAME", userInfo.UserName),
					};

					// 插入生产数据
					dataAccess.ExecuteNonQuery(sqlString, paras);
					// 更新在产数据
					dataAccess.ExecuteNonQuery(sqlUpdate,
						new CDAParameter("barcode", item["barcode"]),
						new CDAParameter("USERID", userInfo.UserID));
				}

				dataAccess.Commit();
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				dataAccess?.Dispose();
			}
		}
		#endregion 

		#region  自动保存注浆确定+防止重复注浆
		/// <summary>
		/// 自动保存注浆确定
		/// </summary>
		/// <param name="user"></param>
		/// <param name="barcode"></param>
		/// <param name="remarks"></param>
		/// <returns></returns>
		public static ServiceResultEntity AutoSaveGROUTINGCHECK(SUserInfo user, string barcode/*, string remarks*/)
		{
			IDBTransaction conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBTransaction(Basics.DataAccess.DataBaseType.ORACLE, DataManager.ConnectionString);

				string sqlString = "SELECT gdd.groutingdailydetailid\n" +
				"      ,gdd.barcode\n" +
				"      ,gdd.groutingmouldcode\n" +
				"      ,gdd.groutingdate\n" +
				"      ,gdd.goodscode\n" +
				"      ,gdd.usercode\n" +
				//"      ,gdd.scrapflag\n" +
				//"      ,gdd.deliverflag\n" +
				// -1：未交坯 -2：生产完成 -3：成品交接 >0：在产工序ID
				"      ,case when gdd.deliverflag='0' then -1 \n" +
				"            when fp.FHUserID is not null then -3 \n" +
				"            when fp.barcode is not null then -2 \n" +
				"            when inp.barcode is null then -4 \n" +
				"            else inp.procedureid end procedureid \n" +
				"      ,case when gdd.deliverflag='0' then '未交坯' \n" +
				"            when fp.FHUserID is not null then '成品交接' \n" +
				"            when fp.barcode is not null then '生产完成' \n" +
				"            when inp.barcode is null then '损坯' \n" +
				"            else to_char(p.procedurename) end procedurename \n" +
				"      ,sysdate CheckTime \n" +
				"  FROM tp_pm_groutingdailydetail gdd\n" +
				"  LEFT JOIN tp_pm_inproduction inp\n" +
				"    ON inp.barcode = gdd.barcode\n" +
				"  LEFT JOIN tp_pc_procedure p\n" +
				"    ON p.procedureid = inp.procedureid\n" +
				"  LEFT JOIN TP_PM_FinishedProduct fp\n" +
				"    ON fp.barcode = gdd.barcode\n" +
				" WHERE gdd.accountid = :accountid\n" +
				"   AND gdd.barcode = :barcode";

				IDataParameter[] paras = new OracleParameter[]
				{
					new OracleParameter(":accountid", OracleDbType.Int32,user.AccountID, ParameterDirection.Input),
					new OracleParameter(":barcode", OracleDbType.NVarchar2,barcode, ParameterDirection.Input),
				};
				ServiceResultEntity sre = new ServiceResultEntity();
				DataSet data = conn.GetSqlResultToDs(sqlString, paras); 
				//防止重复注浆
				if (!(data == null || data.Tables.Count == 0 || data.Tables[0].Rows.Count == 0)) {
					decimal CODE= data.Tables[0].AsEnumerable().Select(ex=> ex.Field<decimal>("groutingdailydetailid")).FirstOrDefault();

					DataSet dt = conn.GetSqlResultToDs("SELECT * FROM TP_PM_GROUTINGCHECK WHERE VALUEFLAG=1 AND GROUTINGDAILYDETAILID=" + CODE);

					if (!(dt == null || dt.Tables.Count == 0 || dt.Tables[0].Rows.Count == 0))
					{
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.Message = "此条码已经注浆,不可重复注浆";
						return sre;
					}
				}
				

				
				if (data == null || data.Tables.Count == 0 || data.Tables[0].Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.Message = "此条码为无效条码";
					return sre;
				}

				string sqlInsert = "INSERT INTO TP_PM_GROUTINGCHECK\n" +
				"  (GroutingDailyDetailID\n" +
				"  ,Remarks\n" +
				"  ,ProcedureID\n" +
				"  ,ProcedureName\n" +
				"  ,CheckTime\n" +
				"  ,AccountID\n" +
				"  ,CreateUserID)\n" +
				"VALUES\n" +
				"  (:GroutingDailyDetailID\n" +
				"  ,:Remarks\n" +
				"  ,:ProcedureID\n" +
				"  ,:ProcedureName\n" +
				"  ,:CheckTime\n" +
				"  ,:AccountID\n" +
				"  ,:CreateUserID)";

				IDataParameter[] insertParas = new OracleParameter[]
				{
					new OracleParameter(":GroutingDailyDetailID", OracleDbType.Int32,data.Tables[0].Rows[0]["GroutingDailyDetailID"], ParameterDirection.Input),
					new OracleParameter(":Remarks", OracleDbType.NVarchar2,"", ParameterDirection.Input),
					new OracleParameter(":ProcedureID", OracleDbType.Int32,data.Tables[0].Rows[0]["ProcedureID"], ParameterDirection.Input),
					new OracleParameter(":ProcedureName", OracleDbType.NVarchar2,data.Tables[0].Rows[0]["ProcedureName"], ParameterDirection.Input),
					new OracleParameter(":CheckTime", OracleDbType.Date,data.Tables[0].Rows[0]["CheckTime"], ParameterDirection.Input),
					new OracleParameter(":AccountID", OracleDbType.Int32,user.AccountID, ParameterDirection.Input),
					new OracleParameter(":CreateUserID", OracleDbType.Int32,user.UserID, ParameterDirection.Input),
				};

				conn.ExecuteNonQuery(sqlInsert, insertParas);

				conn.Commit();

				sre.Data = data;
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Disconnect();
				}
			}
		}
		#endregion 
	}
}