HEGII.ss.mes.wcf/DK.Service/PCModuleLogic/PCModuleLogicDALPartial.cs

/*******************************************************************************
 * Copyright(c) 2014 DongkeSoft All rights reserved. / Confidential
 * 类的信息：
 *      1.程序名称：PCModuleLogicDAL.cs
 *      2.功能描述：生产配置数据库访问类（插入、修改、删除）
 * 编辑履历：
 *      作者            日期                版本            修改内容
 *      庄天威          2014/09/16          1.00            新建
 *******************************************************************************/

using System;
using System.Collections.Generic;
using System.Data;
using System.Text;

using Dongke.IBOSS.PRD.Basics.BaseResources;
using Dongke.IBOSS.PRD.Basics.DataAccess;
using Dongke.IBOSS.PRD.Service.DataModels;
using Dongke.IBOSS.PRD.WCF.DataModels;
using Oracle.ManagedDataAccess.Client;
using SAP.Middleware.Connector;
using System.Configuration;
using Dongke.IBOSS.PRD.Basics.Library;

namespace Dongke.IBOSS.PRD.Service.PCModuleLogic
{
	/// <summary>
	/// 生产配置数据库访问类（插入、修改、删除）
	/// </summary>
	public partial class PCModuleLogicDAL
	{
		#region 成型线配置

		/// <summary>
		/// 新建成型线信息
		/// </summary>
		/// <param name="groutingLineEntity">成型线实体</param>
		/// <param name="detailList">明细实体集合</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>返回受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.10              新建
		/// </remarks>
		public static int AddGroutingLine(GroutingLineEntity groutingLineEntity,
			List<GroutingLineDetailEntity> detailList, SUserInfo user)
		{
			int returnRows = 0;
			int detailReturn = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				if (GroutingLineCodeIsRepeat(groutingLineEntity.GROUTINGLINECODE, user.AccountID) == false)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return -50;
				}
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				//获取成型线ID索引
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("select SEQ_PC_GroutingLine_ID.nextval from dual");
				int id = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
				sbSql.Clear();
				//添加成型线信息
				sbSql.Append("Insert into TP_PC_GroutingLine");
				sbSql.Append("(GroutingLineID,BuildingNo,FloorNo,GroutingLineNo,GroutingLineCode,");
				sbSql.Append("GroutingLineName,MouldQuantity,GMouldTypeID,UserID,");
				sbSql.Append("BeginUsedDate,GMouldStatus,Remarks,AccountID,ValueFlag,CreateTime,");
				sbSql.Append("CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
				sbSql.Append("values(:GroutingLineID,:BuildingNo,:FloorNo,:GroutingLineNo,:GroutingLineCode,");
				sbSql.Append(":GroutingLineName,:MouldQuantity,:GMouldTypeID,:UserID,");
				sbSql.Append(":BeginUsedDate,:GMouldStatus,:Remarks,:AccountID,:ValueFlag,:CreateTime,");
				sbSql.Append(":CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp)");
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							id,ParameterDirection.Input),
						new OracleParameter(":BuildingNo",OracleDbType.NVarchar2,
							groutingLineEntity.BUILDINGNO,ParameterDirection.Input),
						new OracleParameter(":FloorNo",OracleDbType.NVarchar2,
							groutingLineEntity.FLOORNO,ParameterDirection.Input),
						new OracleParameter(":GroutingLineNo",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINENO,ParameterDirection.Input),
						new OracleParameter(":GroutingLineCode",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINECODE,ParameterDirection.Input),
						new OracleParameter(":GroutingLineName",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINENAME,ParameterDirection.Input),
						new OracleParameter(":MouldQuantity",OracleDbType.Decimal,
							groutingLineEntity.MOULDQUANTITY,ParameterDirection.Input),
						new OracleParameter(":GMouldTypeID",OracleDbType.Int32,
							groutingLineEntity.MOULDTYPEID,ParameterDirection.Input),
						new OracleParameter(":UserID",OracleDbType.Int32,
							groutingLineEntity.USERID,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							accountDate,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							groutingLineEntity.MouldStatus,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							groutingLineEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":ValueFlag",OracleDbType.Int32,
							groutingLineEntity.VALUEFLAG,ParameterDirection.Input),
						new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							DateTime.Now,ParameterDirection.Input)
					};
				//执行插入成型线SQL语句
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				//此处添加明细信息（循环）
				foreach (GroutingLineDetailEntity detailInfo in detailList)
				{
					//查看该成型线明细编号是否存在
					if (GroutingLineDetailCodeIsRepeat(detailInfo.GROUTINGMOULDCODE, user.AccountID) == false)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						return -2;
					}
					//获取成型线明细索引
					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GroutingLineDetail_ID.nextval from dual");
					int detailId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
					sbSql.Clear();
					//插入成型线明细信息
					sbSql.Append("Insert into TP_PC_GroutingLineDetail");
					sbSql.Append("(GroutingLineDetailID,GroutingLineID,GroutingMouldCode,MouldCode,GoodsID,GroutingCount,");
					sbSql.Append("GMouldStatus,BeginUsedDate,Remarks,AccountID,ValueFlag,CreateTime,");
					sbSql.Append("CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
					sbSql.Append("Values(:GroutingLineDetailID,:GroutingLineID,:GroutingMouldCode,:MouldCode,:GoodsID,:GroutingCount,");
					sbSql.Append(":GMouldStatus,:BeginUsedDate,:Remarks,:AccountID,:ValueFlag,:CreateTime,");
					sbSql.Append(":CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp)");
					OracleParameter[] DetailParas = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailId,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							id,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							detailInfo.GROUTINGMOULDCODE,ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							detailInfo.MOULDCODE,ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							detailInfo.GOODSID,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							detailInfo.GROUTINGCOUNT,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							detailInfo.MOULDSTATUS,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							accountDate,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							detailInfo.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":ValueFlag",OracleDbType.Int32,
							detailInfo.VALUEFLAG,ParameterDirection.Input),
						new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							DateTime.Now,ParameterDirection.Input)
					};
					//执行插入语句并累加成功插入次数
					detailReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);
				}
				//如果有插入不成功的情况，回滚事务，否则提交
				if (returnRows == 0 || detailReturn == 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 returnRows;
		}

		/// <summary>
		/// 修改成型线信息
		/// </summary>
		/// <param name="groutingLineEntity">成型线实体</param>
		/// <param name="detailList">明细实体集合</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int返回受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.10              新建
		/// </remarks>
		public static int UpdateGroutingLine(GroutingLineEntity groutingLineEntity,
			List<GroutingLineDetailEntity> detailList, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				//修改成型线信息
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("update TP_PC_GroutingLine");
				sbSql.Append(" set BuildingNo=:BuildingNo,");
				sbSql.Append("FloorNo=:FloorNo,");
				sbSql.Append("GroutingLineNo=:GroutingLineNo,");
				sbSql.Append("GroutingLineCode=:GroutingLineCode,");
				sbSql.Append("GroutingLineName=:GroutingLineName,");
				sbSql.Append("MouldQuantity=:MouldQuantity,");
				sbSql.Append("GMouldTypeID=:GMouldTypeID,");
				sbSql.Append("UserID=:UserID,");
				sbSql.Append("BeginUsedDate=:BeginUsedDate,");
				sbSql.Append("EndUsedDate=:EndUsedDate,");
				sbSql.Append("GMouldStatus=:GMouldStatus,");
				sbSql.Append("Remarks=:Remarks,");
				sbSql.Append("AccountID=:AccountID,");
				sbSql.Append("ValueFlag=:ValueFlag,");
				sbSql.Append("UpdateTime=:UpdateTime,");
				sbSql.Append("UpdateUserID=:UpdateUserID");
				sbSql.Append(" where GroutingLineID=:GroutingLineID and OPTimeStamp=:OPTimeStamp");
				if (groutingLineEntity.VALUEFLAG == 0)
				{
					groutingLineEntity.ENDUSEDDATE = DateTime.Now;
				}
				else
				{
					groutingLineEntity.ENDUSEDDATE = null;
				}
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":BuildingNo",OracleDbType.NVarchar2,
							groutingLineEntity.BUILDINGNO,ParameterDirection.Input),
						new OracleParameter(":FloorNo",OracleDbType.NVarchar2,
							groutingLineEntity.FLOORNO,ParameterDirection.Input),
						new OracleParameter(":GroutingLineNo",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINENO,ParameterDirection.Input),
						new OracleParameter(":GroutingLineCode",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINECODE,ParameterDirection.Input),
						new OracleParameter(":GroutingLineName",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINENAME,ParameterDirection.Input),
						new OracleParameter(":MouldQuantity",OracleDbType.Decimal,
							groutingLineEntity.MOULDQUANTITY,ParameterDirection.Input),
						new OracleParameter(":GMouldTypeID",OracleDbType.Int32,
							groutingLineEntity.MOULDTYPEID,ParameterDirection.Input),
						new OracleParameter(":UserID",OracleDbType.Int32,
							groutingLineEntity.USERID,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							groutingLineEntity.BEGINUSEDDATE,ParameterDirection.Input),
						new OracleParameter(":EndUsedDate",OracleDbType.Date,
							groutingLineEntity.ENDUSEDDATE,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							groutingLineEntity.MouldStatus,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							groutingLineEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							groutingLineEntity.ACCOUNTID,ParameterDirection.Input),
						new OracleParameter(":ValueFlag",OracleDbType.Int32,
							groutingLineEntity.VALUEFLAG,ParameterDirection.Input),
						new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							groutingLineEntity.OPTIMESTAMP,ParameterDirection.Input)
					};
				//执行修改语句
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				//时间戳无法匹配
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return -500;
				}
				//添加修改时新建的模具信息
				foreach (GroutingLineDetailEntity detailInfo in detailList)
				{
					//模具明细编号唯一
					if (GroutingLineDetailCodeIsRepeat(detailInfo.GROUTINGMOULDCODE, user.AccountID) == false)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						return -2;
					}
					//获取模具明细索引
					int detailReturn = 0;
					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GroutingLineDetail_ID.nextval from dual");
					int detailId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
					sbSql.Clear();
					//插入新增的模具信息
					sbSql.Append("Insert into TP_PC_GroutingLineDetail");
					sbSql.Append("(GroutingLineDetailID,GroutingLineID,GroutingMouldCode,MouldCode,GoodsID,GroutingCount,");
					sbSql.Append("GMouldStatus,BeginUsedDate,Remarks,AccountID,ValueFlag,CreateTime,");
					sbSql.Append("CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
					sbSql.Append("Values(:GroutingLineDetailID,:GroutingLineID,:GroutingMouldCode,:MouldCode,:GoodsID,:GroutingCount,");
					sbSql.Append(":GMouldStatus,:BeginUsedDate,:Remarks,:AccountID,:ValueFlag,:CreateTime,");
					sbSql.Append(":CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp)");
					OracleParameter[] DetailParas = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailId,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							detailInfo.GROUTINGMOULDCODE,ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							detailInfo.MOULDCODE,ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							detailInfo.GOODSID,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							detailInfo.GROUTINGCOUNT,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							detailInfo.MOULDSTATUS,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							accountDate,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							detailInfo.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":ValueFlag",OracleDbType.Int32,
							detailInfo.VALUEFLAG,ParameterDirection.Input),
						new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							DateTime.Now,ParameterDirection.Input)
					};
					//执行
					detailReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);
				}
				//提交事务
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return returnRows;
		}

		/// <summary>
		/// 修改成型线明细
		/// </summary>
		/// <param name="detailInfo">成型线明细实体</param>
		/// <param name="oracleTrConn">数据库事务</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.11              新建
		/// </remarks>
		public static int UpdateGroutingLineDetail(GroutingLineDetailEntity detailInfo, IDBTransaction oracleTrConn, SUserInfo user)
		{
			int detailReturn = 0;
			StringBuilder sbSql = new StringBuilder();
			sbSql.Append("update TP_PC_GroutingLineDetail");
			sbSql.Append(" set GroutingLineID =:GroutingLineID,");
			sbSql.Append("GroutingMouldCode =:GroutingMouldCode,");
			sbSql.Append("MouldCode=:MouldCode,");
			sbSql.Append("GoodsID =:GoodsID,");
			sbSql.Append("GroutingCount =:GroutingCount,");
			sbSql.Append("GMouldStatus =:GMouldStatus,");
			sbSql.Append("BeginUsedDate =:BeginUsedDate,");
			sbSql.Append("Remarks =:Remarks,");
			sbSql.Append("AccountID =:AccountID,");
			sbSql.Append("ValueFlag=:ValueFlag,");
			sbSql.Append("CreateTime =:CreateTime,");
			sbSql.Append("CreateUserID =:CreateUserID,");
			sbSql.Append("UpdateTime =:UpdateTime,");
			sbSql.Append("UpdateUserID =:UpdateUserID");
			sbSql.Append(" where GroutingLineDetailID =:GroutingLineDetailID");
			OracleParameter[] DetailParas = new OracleParameter[] {
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							detailInfo.GROUTINGLINEID,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							detailInfo.GROUTINGMOULDCODE,ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							detailInfo.MOULDCODE,ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							detailInfo.GOODSID,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							detailInfo.GROUTINGCOUNT,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							detailInfo.MOULDSTATUS,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							detailInfo.BEGINUSEDDATE,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							detailInfo.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							detailInfo.ACCOUNTID,ParameterDirection.Input),
						new OracleParameter(":ValueFlag",OracleDbType.Int32,
							detailInfo.VALUEFLAG,ParameterDirection.Input),
						new OracleParameter(":CreateTime",OracleDbType.Date,
							detailInfo.CREATETIME,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							detailInfo.CREATEUSERID,ParameterDirection.Input),
						new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailInfo.GROUTINGLINEDETAILID,ParameterDirection.Input)
					};
			detailReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);
			return detailReturn;
		}

		/// <summary>
		/// 新建注浆模具换修履历
		/// </summary>
		/// <param name="recordEntity">换修履历实体</param>
		/// <param name="oracleTrConn">数据库事务</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.11              新建
		/// </remarks>
		public static int AddMouldRecord(GMouldRecordEntity recordEntity, IDBTransaction oracleTrConn, SUserInfo user)
		{
			StringBuilder sbSql = new StringBuilder();
			int MyReturn = 0;
			sbSql.Clear();
			sbSql.Append("select SEQ_PC_GMouldRecord_ID.nextval from dual");
			int Id = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
			sbSql.Clear();
			sbSql.Append("Insert into TP_PC_GMouldRecord");
			sbSql.Append("(GMouldRecordID,GroutingLineID,GroutingLineDetailID,GoodsID,GroutingMouldCode,MouldCode,GroutingCount,");
			sbSql.Append("GMouldRecordType,BeginDate,EndDate,Rreason,Remarks,AccountID,CreateTime,CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
			sbSql.Append("VALUES(:GMouldRecordID,:GroutingLineID,:GroutingLineDetailID,:GoodsID,GroutingMouldCode,:MouldCode,:GroutingCount,");
			sbSql.Append(":GMouldRecordType,:BeginDate,:EndDate,:Rreason,:Remarks,:AccountID,:CreateTime,:CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp)");
			OracleParameter[] Paras = new OracleParameter[] {
					new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							Id,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEID,ParameterDirection.Input),
					new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
					new OracleParameter(":GoodsID",OracleDbType.Int32,
							recordEntity.GOODSID,ParameterDirection.Input),
					new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							recordEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
					new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							recordEntity.MouldCode,ParameterDirection.Input),
					new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							recordEntity.GROUTINGCOUNT,ParameterDirection.Input),
					new OracleParameter(":GMouldRecordType",OracleDbType.Int32,
							recordEntity.RESUMETYPE,ParameterDirection.Input),
					new OracleParameter(":BeginDate",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":EndDate",OracleDbType.Date,
							DBNull.Value,ParameterDirection.Input),
					new OracleParameter(":Rreason",OracleDbType.NVarchar2,
							recordEntity.RREASON,ParameterDirection.Input),
					new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							recordEntity.REMARKS,ParameterDirection.Input),
					new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
					new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
					new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
					new OracleParameter(":OPTimeStamp",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input)
			};
			MyReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
			return MyReturn;
		}

		/// <summary>
		/// 补完注浆模具换修履历的结束时间
		/// </summary>
		/// <param name="recordEntity">换修履历实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.11              新建
		/// </remarks>
		public static int UpdateMouldRecordEndTime(GMouldRecordEntity recordEntity, SUserInfo user)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			StringBuilder sbSql = new StringBuilder();
			int MyReturn = 0;
			int MouldResumeId = 0;
			//ID为倒序的第一个数据就是符合条件的
			//IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				//con.Open();
				oracleTrConn.Connect();
				sbSql.Append("Select GMouldRecordID from TP_PC_GMouldRecord where ");
				sbSql.Append(" GroutingLineDetailID=:GroutingLineDetailID and GroutingLineID=:GroutingLineID");
				sbSql.Append(" and AccountId=:AccountId Order by GMouldRecordID Desc");
				OracleParameter[] Paras = new OracleParameter[] {
					new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEID,ParameterDirection.Input),
					new OracleParameter(":AccountId",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input)
				};
				DataSet ds = oracleTrConn.GetSqlResultToDs(sbSql.ToString(), Paras);
				MouldResumeId = Convert.ToInt32(ds.Tables[0].Rows[0][0]);
				//con.Close();
				//}
				//catch (Exception ex)
				//{
				//    if (con.ConnState == ConnectionState.Open)
				//    {
				//        con.Close();
				//    }
				//    throw ex;
				//}

				//try
				//{
				//oracleTrConn.Connect();
				//根据获取到的ID，修改结束时间
				sbSql.Clear();
				sbSql.Append("update TP_PC_GMouldRecord");
				sbSql.Append(" set ENDDATE = :ENDDATE");
				sbSql.Append(" where GMouldRecordID= :GMouldRecordID");
				sbSql.Append(" and ACCOUNTID= :ACCOUNTID");
				OracleParameter[] UpParas = new OracleParameter[] {
					new OracleParameter(":ENDDATE",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							MouldResumeId,ParameterDirection.Input),
					new OracleParameter(":ACCOUNTID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input)
				};
				MyReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), UpParas);
				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 MyReturn;
		}

		/// <summary>
		/// 新建注浆模具履历
		/// </summary>
		/// <param name="historyEntity">履历实体</param>
		/// <param name="oracleTrConn">数据库事务</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.11              新建
		/// </remarks>
		public static int AddMouldHistory(GMouldHistoryEntity historyEntity,
			IDBTransaction oracleTrConn, SUserInfo user)
		{
			StringBuilder sbSql = new StringBuilder();
			int MyReturn = 0;
			sbSql.Clear();
			sbSql.Append("select SEQ_PC_GMouldHistory_ID.nextval from dual");
			int Id = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
			sbSql.Clear();
			sbSql.Append("Insert into TP_PC_GMouldHistory");
			sbSql.Append("(GMouldHistoryID,GroutingLineID,GroutingLineDetailID,GoodsID,GroutingMouldCode,MouldCode,GroutingCount,");
			sbSql.Append("BeginUsedDate,EndUsedDate,Remarks,AccountID,CreateTime,CreateUserID)");
			sbSql.Append(" Values(:GMouldHistoryID,:GroutingLineID,:GroutingLineDetailID,:GoodsID,:GroutingMouldCode,:MouldCode,:GroutingCount,");
			sbSql.Append(":BeginUsedDate,:EndUsedDate,:Remarks,:AccountID,:CreateTime,:CreateUserID)");
			OracleParameter[] Paras = new OracleParameter[] {
					new OracleParameter(":GMouldHistoryID",OracleDbType.Int32,
							Id,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							historyEntity.GROUTINGLINEID,ParameterDirection.Input),
					new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							historyEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
					new OracleParameter(":GoodsID",OracleDbType.Int32,
							historyEntity.GOODSID,ParameterDirection.Input),
					new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							historyEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
					new OracleParameter(":MOULDCODE",OracleDbType.NVarchar2,
							historyEntity.MouldCode,ParameterDirection.Input),
					new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							historyEntity.GROUTINGCOUNT,ParameterDirection.Input),
					new OracleParameter(":BeginUsedDate",OracleDbType.Date,
						   historyEntity.BEGINUSEDDATE,ParameterDirection.Input),
					new OracleParameter(":EndUsedDate",OracleDbType.Date,
						   historyEntity.ENDUSEDDATE,ParameterDirection.Input),
					new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							historyEntity.REMARKS,ParameterDirection.Input),
					new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
					new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input)
			};
			MyReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
			return MyReturn;
		}

		/// <summary>
		/// 修理模具
		/// </summary>
		/// <param name="detailEntity">明细实体</param>
		/// <param name="recordEntity">换修履历实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.11              新建
		/// </remarks>
		public static int RepAirDetail(GroutingLineDetailEntity detailEntity,
			GMouldRecordEntity recordEntity, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				//更新明细信息
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("update TP_PC_GroutingLineDetail");
				sbSql.Append(" set GroutingLineID =:GroutingLineID,");
				sbSql.Append("GroutingMouldCode =:GroutingMouldCode,");
				sbSql.Append("GoodsID =:GoodsID,");
				sbSql.Append("GroutingCount =:GroutingCount,");
				sbSql.Append("GMouldStatus =:GMouldStatus,");
				sbSql.Append("BeginUsedDate =to_date(:BeginUsedDate,'yyyy-mm-dd hh24:mi:ss'),");
				sbSql.Append("Remarks =:Remarks,");
				sbSql.Append("AccountID =:AccountID,");
				sbSql.Append("CreateTime =to_date(:CreateTime,'yyyy-mm-dd hh24:mi:ss'),");
				sbSql.Append("CreateUserID =:CreateUserID,");
				sbSql.Append("UpdateTime =to_date(:UpdateTime,'yyyy-mm-dd hh24:mi:ss'),");
				sbSql.Append("UpdateUserID =:UpdateUserID");
				sbSql.Append(" where GroutingLineDetailID =:GroutingLineDetailID And OPTimeStamp=:OPTimeStamp");
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEID,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							detailEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							detailEntity.GOODSID,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							detailEntity.GROUTINGCOUNT,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							detailEntity.MOULDSTATUS,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.NVarchar2,
							detailEntity.BEGINUSEDDATE.ToString(),ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							detailEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							detailEntity.ACCOUNTID,ParameterDirection.Input),
						new OracleParameter(":CreateTime",OracleDbType.NVarchar2,
							detailEntity.CREATETIME.ToString(),ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							detailEntity.CREATEUSERID,ParameterDirection.Input),
						new OracleParameter(":UpdateTime",OracleDbType.NVarchar2,
							DateTime.Now.ToString(),ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							detailEntity.OPTIMESTAMP,ParameterDirection.Input)
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return -500;
				}
				//添加换修履历
				int MyReturn = 0;
				sbSql.Clear();
				sbSql.Append("select SEQ_PC_GMouldRecord_ID.nextval from dual");
				int Id = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
				sbSql.Clear();
				//插入换修履历信息
				sbSql.Append("Insert into TP_PC_GMouldRecord");
				sbSql.Append("(GMouldRecordID,GroutingLineID,GroutingLineDetailID,GoodsID,GroutingMouldCode,MouldCode,GroutingCount,");
				sbSql.Append("GMouldRecordType,BeginDate,EndDate,Rreason,Remarks,AccountID,CreateTime,CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
				sbSql.Append("VALUES(:GMouldRecordID,:GroutingLineID,:GroutingLineDetailID,:GoodsID,:GroutingMouldCode,:MouldCode,:GroutingCount,");
				sbSql.Append(":GMouldRecordType,:BeginDate,:EndDate,:Rreason,:Remarks,:AccountID,:CreateTime,:CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp)");
				OracleParameter[] RParas = new OracleParameter[] {
					new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							Id,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEID,ParameterDirection.Input),
					new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
					new OracleParameter(":GoodsID",OracleDbType.Int32,
							recordEntity.GOODSID,ParameterDirection.Input),
					new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							recordEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
					new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							recordEntity.MouldCode,ParameterDirection.Input),
					new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							recordEntity.GROUTINGCOUNT,ParameterDirection.Input),
					new OracleParameter(":GMouldRecordType",OracleDbType.Int32,
							recordEntity.RESUMETYPE,ParameterDirection.Input),
					new OracleParameter(":BeginDate",OracleDbType.Date,
							recordEntity.BEGINDATE,ParameterDirection.Input),
					new OracleParameter(":EndDate",OracleDbType.Date,
							DBNull.Value,ParameterDirection.Input),
					new OracleParameter(":Rreason",OracleDbType.NVarchar2,
							recordEntity.RREASON,ParameterDirection.Input),
					new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							recordEntity.REMARKS,ParameterDirection.Input),
					new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
					new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
					new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
					new OracleParameter(":OPTimeStamp",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input)
				};
				MyReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), RParas);
				//插入不成功回滚事务
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnRows;
				}
				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 returnRows;
		}

		/// <summary>
		/// 修理完成
		/// </summary>
		/// <param name="detailEntity">明细实体</param>
		/// <param name="EndTime">结束日期</param>
		/// <param name="Remarks">备注</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.11              新建
		/// </remarks>
		public static int RepAirDetailEnd(GroutingLineDetailEntity detailEntity, DateTime? EndTime, String Remarks, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			StringBuilder sbSql = new StringBuilder();
			int MouldResumeId = 0;
			try
			{
				//获取之前修理的履历的ID
				oracleTrConn.Connect();
				sbSql.Append("Select GMouldRecordID from TP_PC_GMouldRecord");
				sbSql.Append(" where GroutingLineDetailID=:GroutingLineDetailID and GroutingLineID=:GroutingLineID");
				sbSql.Append(" and AccountId=:AccountId Order by GMouldRecordID Desc");
				OracleParameter[] Paras = new OracleParameter[] {
					new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEID,ParameterDirection.Input),
					new OracleParameter(":AccountId",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input)
				};
				DataSet ds = oracleTrConn.GetSqlResultToDs(sbSql.ToString(), Paras);
				MouldResumeId = Convert.ToInt32(ds.Tables[0].Rows[0][0]);
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				//更新明细信息
				sbSql.Clear();
				sbSql.Append("update TP_PC_GroutingLineDetail");
				sbSql.Append(" set GroutingLineID =:GroutingLineID,");
				sbSql.Append("GroutingMouldCode =:GroutingMouldCode,");
				sbSql.Append("GoodsID =:GoodsID,");
				sbSql.Append("GroutingCount =:GroutingCount,");
				sbSql.Append("GMouldStatus =:GMouldStatus,");
				sbSql.Append("BeginUsedDate =to_date(:BeginUsedDate,'yyyy-mm-dd hh24:mi:ss'),");
				sbSql.Append("Remarks =:Remarks,");
				sbSql.Append("AccountID =:AccountID,");
				sbSql.Append("CreateTime =to_date(:CreateTime,'yyyy-mm-dd hh24:mi:ss'),");
				sbSql.Append("CreateUserID =:CreateUserID,");
				sbSql.Append("UpdateTime =to_date(:UpdateTime,'yyyy-mm-dd hh24:mi:ss'),");
				sbSql.Append("UpdateUserID =:UpdateUserID");
				sbSql.Append(" where GroutingLineDetailID =:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp");
				OracleParameter[] Paras1 = new OracleParameter[] {
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEID,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							detailEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							detailEntity.GOODSID,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							detailEntity.GROUTINGCOUNT,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							detailEntity.MOULDSTATUS,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.NVarchar2,
							detailEntity.BEGINUSEDDATE.ToString(),ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							detailEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							detailEntity.ACCOUNTID,ParameterDirection.Input),
						new OracleParameter(":CreateTime",OracleDbType.NVarchar2,
							detailEntity.CREATETIME.ToString(),ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							detailEntity.CREATEUSERID,ParameterDirection.Input),
						new OracleParameter(":UpdateTime",OracleDbType.NVarchar2,
							DateTime.Now.ToString(),ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							detailEntity.OPTIMESTAMP,ParameterDirection.Input)
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras1);
				//时间戳不同
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return -500;
				}
				//根据前面取得的ID更新换修履历
				sbSql.Clear();
				sbSql.Append("update TP_PC_GMouldRecord");
				sbSql.Append(" set ENDDATE = :ENDDATE");
				sbSql.Append(",Remarks = :Remarks");
				sbSql.Append(" where GMouldRecordID= :GMouldRecordID");
				sbSql.Append(" and ACCOUNTID= :ACCOUNTID");
				DateTime? RecordEndTime = accountDate;
				if (EndTime != null)
				{
					RecordEndTime = EndTime;
				}
				OracleParameter[] UpParas = new OracleParameter[] {
					new OracleParameter(":ENDDATE",OracleDbType.Date,
							RecordEndTime,ParameterDirection.Input),
					new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							Remarks,ParameterDirection.Input),
					new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							MouldResumeId,ParameterDirection.Input),
					new OracleParameter(":ACCOUNTID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input)
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), UpParas);
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnRows;
				}
				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 returnRows;
		}

		/// <summary>
		/// 更换模具(先插入模具履历以及重置次数及开始时间)
		/// </summary>
		/// <param name="detailEntity">明细实体</param>
		/// <param name="recordEntity">换修履历实体</param>
		/// <param name="historyEntity">履历实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.11              新建
		/// </remarks>
		public static int ChangeDetail(GroutingLineDetailEntity detailEntity, GMouldRecordEntity recordEntity, GMouldHistoryEntity historyEntity, SUserInfo user)
		{
			int returnRows = 0;
			int UpReturn = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				//更新明细信息
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("update TP_PC_GroutingLineDetail set ");
				sbSql.Append("remarks =:remarks,");
				sbSql.Append("MouldCode =:MouldCode,");
				sbSql.Append("GroutingCount =:GroutingCount,");
				sbSql.Append("GMouldStatus =:GMouldStatus,");
				sbSql.Append("BeginUsedDate =to_date(:BeginUsedDate,'yyyy-mm-dd hh24:mi:ss'),");
				sbSql.Append("UpdateUserID =:UpdateUserID");
				sbSql.Append(" where GroutingLineDetailID =:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp");
				OracleParameter[] Paras = new OracleParameter[] {
					 new OracleParameter(":remarks",OracleDbType.NVarchar2,
							detailEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							detailEntity.MOULDCODE,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							detailEntity.GROUTINGCOUNT,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							detailEntity.MOULDSTATUS,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.NVarchar2,
							detailEntity.BEGINUSEDDATE,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							detailEntity.OPTIMESTAMP,ParameterDirection.Input)
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				//时间戳不匹配
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return -500;
				}
				//如果是维修转换模
				if (recordEntity.RESUMETYPE == Convert.ToInt32(Constant.GMouldRecordType.RepairToReplac))
				{
					int MouldResumeId = 0;
					//把上一条维修信息的结束时间添加上
					//ID为倒序的第一个数据就是符合条件的
					//IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
					//try
					//{
					//    con.Open();
					sbSql.Clear();
					sbSql.Append("Select GMouldRecordID from TP_PC_GMouldRecord where ");
					sbSql.Append(" GroutingLineDetailID=:GroutingLineDetailID and GroutingLineID=:GroutingLineID");
					sbSql.Append(" and AccountId=:AccountId Order by GMouldRecordID Desc");
					OracleParameter[] QParas = new OracleParameter[] {
							new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
							new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEID,ParameterDirection.Input),
							new OracleParameter(":AccountId",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input)
						};
					//DataSet ds = con.GetSqlResultToDs(sbSql.ToString(), QParas);
					DataSet ds = oracleTrConn.GetSqlResultToDs(sbSql.ToString(), QParas);
					MouldResumeId = Convert.ToInt32(ds.Tables[0].Rows[0][0]);
					//con.Close();
					//根据获取的ID补录结束时间
					sbSql.Clear();
					sbSql.Append("update TP_PC_GMouldRecord");
					sbSql.Append(" set ENDDATE = :ENDDATE");
					sbSql.Append(" where GMouldRecordID= :GMouldRecordID");
					sbSql.Append(" and ACCOUNTID= :ACCOUNTID");
					OracleParameter[] UpParas = new OracleParameter[] {
							new OracleParameter(":ENDDATE",OracleDbType.Date,
								detailEntity.BEGINUSEDDATE,ParameterDirection.Input),
							new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
								MouldResumeId,ParameterDirection.Input),
							new OracleParameter(":ACCOUNTID",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input)
						};
					UpReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), UpParas);
					//}
					//catch (Exception ex)
					//{
					//    if (con.ConnState == ConnectionState.Open)
					//    {
					//        con.Close();
					//    }
					//    throw ex;
					//}
				}
				//添加换修履历
				int RecordReturn = 0;
				sbSql.Clear();
				sbSql.Append("select SEQ_PC_GMouldRecord_ID.nextval from dual");
				int Id = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
				sbSql.Clear();
				sbSql.Append("Insert into TP_PC_GMouldRecord");
				sbSql.Append("(GMouldRecordID,GroutingLineID,GroutingLineDetailID,GoodsID,GroutingMouldCode,MouldCode,GroutingCount,");
				sbSql.Append("GMouldRecordType,BeginDate,EndDate,Rreason,Remarks,AccountID,CreateTime,CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
				sbSql.Append("VALUES(:GMouldRecordID,:GroutingLineID,:GroutingLineDetailID,:GoodsID,:GroutingMouldCode,:MouldCode,:GroutingCount,");
				sbSql.Append(":GMouldRecordType,:BeginDate,:EndDate,:Rreason,:Remarks,:AccountID,:CreateTime,:CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp)");
				OracleParameter[] RParas = new OracleParameter[] {
					new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							Id,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEID,ParameterDirection.Input),
					new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
					new OracleParameter(":GoodsID",OracleDbType.Int32,
							recordEntity.GOODSID,ParameterDirection.Input),
					new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							recordEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
					new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							recordEntity.MouldCode,ParameterDirection.Input),
					new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							recordEntity.GROUTINGCOUNT,ParameterDirection.Input),
					new OracleParameter(":GMouldRecordType",OracleDbType.Int32,
							recordEntity.RESUMETYPE,ParameterDirection.Input),
					new OracleParameter(":BeginDate",OracleDbType.Date,
							recordEntity.BEGINDATE,ParameterDirection.Input),
					new OracleParameter(":EndDate",OracleDbType.Date,
							DBNull.Value,ParameterDirection.Input),
					new OracleParameter(":Rreason",OracleDbType.NVarchar2,
							recordEntity.RREASON,ParameterDirection.Input),
					new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							recordEntity.REMARKS,ParameterDirection.Input),
					new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
					new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
					new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
					new OracleParameter(":OPTimeStamp",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input)
				};
				RecordReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), RParas);
				//添加履历
				int HistoryReturn = 0;
				sbSql.Clear();
				sbSql.Append("select SEQ_PC_GMouldHistory_ID.nextval from dual");
				int HistoryId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
				sbSql.Clear();
				sbSql.Append("Insert into TP_PC_GMouldHistory");
				sbSql.Append("(GMouldHistoryID,GroutingLineID,GroutingLineDetailID,GoodsID,GroutingMouldCode,MouldCode,GroutingCount,");
				sbSql.Append("BeginUsedDate,EndUsedDate,Remarks,AccountID,CreateTime,CreateUserID)");
				sbSql.Append(" Values(:GMouldHistoryID,:GroutingLineID,:GroutingLineDetailID,:GoodsID,:GroutingMouldCode,:MouldCode,:GroutingCount,");
				sbSql.Append(":BeginUsedDate,:EndUsedDate,:Remarks,:AccountID,:CreateTime,:CreateUserID)");
				OracleParameter[] HParas = new OracleParameter[] {
					new OracleParameter(":GMouldHistoryID",OracleDbType.Int32,
							HistoryId,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							historyEntity.GROUTINGLINEID,ParameterDirection.Input),
					new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							historyEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
					new OracleParameter(":GoodsID",OracleDbType.Int32,
							historyEntity.GOODSID,ParameterDirection.Input),
					new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							historyEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
					new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							historyEntity.MouldCode,ParameterDirection.Input),
					new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							historyEntity.GROUTINGCOUNT,ParameterDirection.Input),
					new OracleParameter(":BeginUsedDate",OracleDbType.Date,
						   historyEntity.BEGINUSEDDATE,ParameterDirection.Input),
					new OracleParameter(":EndUsedDate",OracleDbType.Date,
						   historyEntity.ENDUSEDDATE,ParameterDirection.Input),
					new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							historyEntity.REMARKS,ParameterDirection.Input),
					new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
					new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input)
					};
				HistoryReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), HParas);
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnRows;
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			return returnRows;
		}

		/// <summary>
		/// 更换模具(只插入换修履历，并只更新成型线明细的状态)
		/// </summary>
		/// <param name="detailEntity">明细实体</param>
		/// <param name="recordEntity">换修履历实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.11              新建
		/// </remarks>
		public static int ChangeDetail(GroutingLineDetailEntity detailEntity, GMouldRecordEntity recordEntity, SUserInfo user)
		{
			int returnRows = 0;
			int UpReturn = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				//更新明细信息
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("update TP_PC_GroutingLineDetail");
				sbSql.Append(" set GMouldStatus =:GMouldStatus");
				sbSql.Append(" UpdateUserID =:UpdateUserID");
				sbSql.Append(" where GroutingLineDetailID =:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp");
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							detailEntity.MOULDSTATUS,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							detailEntity.OPTIMESTAMP,ParameterDirection.Input)
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return -500;
				}
				//如果是维修转换模
				if (recordEntity.RESUMETYPE == Convert.ToInt32(Constant.GMouldRecordType.RepairToReplac))
				{
					int MouldResumeId = 0;
					//把上一条维修信息的结束时间添加上
					//ID为倒序的第一个数据就是符合条件的
					IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
					try
					{
						con.Open();
						sbSql.Clear();
						sbSql.Append("Select GMouldRecordID from TP_PC_GMouldRecord where ");
						sbSql.Append(" GroutingLineDetailID=:GroutingLineDetailID and GroutingLineID=:GroutingLineID");
						sbSql.Append(" and AccountId=:AccountId Order by GMouldRecordID Desc");
						OracleParameter[] QParas = new OracleParameter[] {
							new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
							new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEID,ParameterDirection.Input),
							new OracleParameter(":AccountId",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input)
						};
						DataSet ds = con.GetSqlResultToDs(sbSql.ToString(), QParas);
						MouldResumeId = Convert.ToInt32(ds.Tables[0].Rows[0][0]);
						con.Close();
						//根据ID补录结束时间
						sbSql.Clear();
						sbSql.Append("update TP_PC_GMouldRecord");
						sbSql.Append(" set ENDDATE = :ENDDATE");
						sbSql.Append(" where GMouldRecordID= :GMouldRecordID");
						sbSql.Append(" and ACCOUNTID= :ACCOUNTID");
						OracleParameter[] UpParas = new OracleParameter[] {
							new OracleParameter(":ENDDATE",OracleDbType.Date,
								recordEntity.BEGINDATE,ParameterDirection.Input),
							new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
								MouldResumeId,ParameterDirection.Input),
							new OracleParameter(":ACCOUNTID",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input)
						};
						UpReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), UpParas);
					}
					catch (Exception ex)
					{
						if (con.ConnState == ConnectionState.Open)
						{
							con.Close();
						}
						throw ex;
					}
				}
				//添加换修履历
				int RecordReturn = 0;
				sbSql.Clear();
				sbSql.Append("select SEQ_PC_GMouldRecord_ID.nextval from dual");
				int Id = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
				sbSql.Clear();
				sbSql.Append("Insert into TP_PC_GMouldRecord");
				sbSql.Append("(GMouldRecordID,GroutingLineID,GroutingLineDetailID,GoodsID,GroutingMouldCode,MouldCode,GroutingCount,");
				sbSql.Append("GMouldRecordType,BeginDate,EndDate,Rreason,Remarks,AccountID,CreateTime,CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
				sbSql.Append("VALUES(:GMouldRecordID,:GroutingLineID,:GroutingLineDetailID,:GoodsID,:GroutingMouldCode,:MouldCode,:GroutingCount,");
				sbSql.Append(":GMouldRecordType,:BeginDate,:EndDate,:Rreason,:Remarks,:AccountID,:CreateTime,:CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp)");
				OracleParameter[] RParas = new OracleParameter[] {
					new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							Id,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEID,ParameterDirection.Input),
					new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
					new OracleParameter(":GoodsID",OracleDbType.Int32,
							recordEntity.GOODSID,ParameterDirection.Input),
					new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							recordEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
					new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							recordEntity.MouldCode,ParameterDirection.Input),
					new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							recordEntity.GROUTINGCOUNT,ParameterDirection.Input),
					new OracleParameter(":GMouldRecordType",OracleDbType.Int32,
							recordEntity.RESUMETYPE,ParameterDirection.Input),
					new OracleParameter(":BeginDate",OracleDbType.Date,
							recordEntity.BEGINDATE,ParameterDirection.Input),
					new OracleParameter(":EndDate",OracleDbType.Date,
							DBNull.Value,ParameterDirection.Input),
					new OracleParameter(":Rreason",OracleDbType.NVarchar2,
							recordEntity.RREASON,ParameterDirection.Input),
					new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							recordEntity.REMARKS,ParameterDirection.Input),
					new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
					new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
					new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
					new OracleParameter(":OPTimeStamp",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input)
				};
				RecordReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), RParas);
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnRows;
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return returnRows;
		}

		/// <summary>
		/// 更换完成(只修改明细状态)
		/// </summary>
		/// <param name="detailEntity">明细实体</param>
		/// <param name="EndTime">结束日期</param>
		/// <param name="Remarks">备注</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.11              新建
		/// </remarks>
		public static int ChangeDetailEnd(GroutingLineDetailEntity detailEntity, DateTime? EndTime, String Remarks, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			StringBuilder sbSql = new StringBuilder();
			int MouldResumeId = 0;
			string remarks = "";
			try
			{
				//首先获取换修履历的ID
				oracleTrConn.Connect();
				//sbSql.Append("Select GMouldRecordID from TP_PC_GMouldRecord");
				sbSql.Append("Select GMouldRecordID,RREASON from TP_PC_GMouldRecord");
				sbSql.Append(" where GroutingLineDetailID=:GroutingLineDetailID and GroutingLineID=:GroutingLineID");
				sbSql.Append(" and AccountId=:AccountId Order by GMouldRecordID Desc");
				OracleParameter[] Paras = new OracleParameter[] {
					new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEID,ParameterDirection.Input),
					new OracleParameter(":AccountId",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input)
				};
				DataSet ds = oracleTrConn.GetSqlResultToDs(sbSql.ToString(), Paras);
				MouldResumeId = Convert.ToInt32(ds.Tables[0].Rows[0][0]);
				remarks = ds.Tables[0].Rows[0]["RREASON"].ToString();
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				//更新明细信息
				sbSql.Clear();
				sbSql.Append("update TP_PC_GroutingLineDetail set ");
				sbSql.Append("Remarks =:Remarks,");//新添加的
				sbSql.Append("GMouldStatus =:GMouldStatus,");
				sbSql.Append("UpdateUserID =:UpdateUserID");
				sbSql.Append(" where GroutingLineDetailID =:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp");
				OracleParameter[] Paras1 = new OracleParameter[] {
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							detailEntity.MOULDSTATUS,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							detailEntity.OPTIMESTAMP,ParameterDirection.Input),
							  new OracleParameter(":Remarks",OracleDbType.Varchar2,
						   remarks+"->"+ detailEntity.REMARKS,ParameterDirection.Input),
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras1);
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return -500;
				}
				//更新换修履历的结束时间
				sbSql.Clear();
				sbSql.Append("update TP_PC_GMouldRecord");
				sbSql.Append(" set ENDDATE = :ENDDATE");
				sbSql.Append(",Remarks = :Remarks");
				sbSql.Append(" where GMouldRecordID= :GMouldRecordID");
				sbSql.Append(" and ACCOUNTID= :ACCOUNTID");
				DateTime? recordEndTime = accountDate;
				if (EndTime != null)
				{
					recordEndTime = EndTime;
				}
				OracleParameter[] UpParas = new OracleParameter[] {
					new OracleParameter(":ENDDATE",OracleDbType.Date,
							recordEndTime,ParameterDirection.Input),
					new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							Remarks,ParameterDirection.Input),
					new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							MouldResumeId,ParameterDirection.Input),
					new OracleParameter(":ACCOUNTID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input)
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), UpParas);
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnRows;
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return returnRows;
		}

		/// <summary>
		/// 更换完成(修改明细状态，重置模具编号，注浆次数，开始使用时间，并插入模具履历)
		/// </summary>
		/// <param name="detailEntity">明细实体</param>
		/// <param name="historyEntity">模具履历实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.11              新建
		/// </remarks>
		public static int ChangeDetailEnd(GroutingLineDetailEntity detailEntity, GMouldHistoryEntity historyEntity, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			StringBuilder sbSql = new StringBuilder();
			int MouldResumeId = 0;
			try
			{
				//首先获取换修履历的ID
				oracleTrConn.Connect();
				sbSql.Append("Select GMouldRecordID from TP_PC_GMouldRecord");
				sbSql.Append(" where GroutingLineDetailID=:GroutingLineDetailID and GroutingLineID=:GroutingLineID");
				sbSql.Append(" and AccountId=:AccountId Order by GMouldRecordID Desc");
				OracleParameter[] Paras = new OracleParameter[] {
					new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEID,ParameterDirection.Input),
					new OracleParameter(":AccountId",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input)
				};
				DataSet ds = oracleTrConn.GetSqlResultToDs(sbSql.ToString(), Paras);
				MouldResumeId = Convert.ToInt32(ds.Tables[0].Rows[0][0]);
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				//更新明细信息
				sbSql.Clear();
				sbSql.Append("update TP_PC_GroutingLineDetail set ");
				sbSql.Append("MouldCode =:MouldCode,");
				sbSql.Append("GroutingCount =:GroutingCount,");
				sbSql.Append("BeginUsedDate =to_date(:BeginUsedDate,'yyyy-mm-dd hh24:mi:ss'),");
				sbSql.Append("UpdateUserID =:UpdateUserID");
				sbSql.Append(" where GroutingLineDetailID =:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp");
				OracleParameter[] Paras1 = new OracleParameter[] {
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							detailEntity.MOULDCODE,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							detailEntity.GROUTINGCOUNT,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							detailEntity.MOULDSTATUS,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.NVarchar2,
							detailEntity.BEGINUSEDDATE.ToString("yyyy-MM-dd"),ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							detailEntity.OPTIMESTAMP,ParameterDirection.Input)
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras1);
				//时间戳不匹配
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return -500;
				}
				//添加履历
				int HistoryReturn = 0;
				sbSql.Clear();
				sbSql.Append("select SEQ_PC_GMouldHistory_ID.nextval from dual");
				int HistoryId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
				sbSql.Clear();
				sbSql.Append("Insert into TP_PC_GMouldHistory");
				sbSql.Append("(GMouldHistoryID,GroutingLineID,GroutingLineDetailID,GoodsID,GroutingMouldCode,MouldCode,GroutingCount,");
				sbSql.Append("BeginUsedDate,EndUsedDate,Remarks,AccountID,CreateTime,CreateUserID)");
				sbSql.Append(" Values(:GMouldHistoryID,:GroutingLineID,:GroutingLineDetailID,:GoodsID,:GroutingMouldCode,:MouldCode,:GroutingCount,");
				sbSql.Append(":BeginUsedDate,:EndUsedDate,:Remarks,:AccountID,:CreateTime,:CreateUserID)");
				OracleParameter[] HParas = new OracleParameter[] {
					new OracleParameter(":GMouldHistoryID",OracleDbType.Int32,
							HistoryId,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							historyEntity.GROUTINGLINEID,ParameterDirection.Input),
					new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							historyEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
					new OracleParameter(":GoodsID",OracleDbType.Int32,
							historyEntity.GOODSID,ParameterDirection.Input),
					new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							historyEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
					new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							historyEntity.MouldCode,ParameterDirection.Input),
					new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							historyEntity.GROUTINGCOUNT,ParameterDirection.Input),
					new OracleParameter(":BeginUsedDate",OracleDbType.Date,
						   historyEntity.BEGINUSEDDATE,ParameterDirection.Input),
					new OracleParameter(":EndUsedDate",OracleDbType.Date,
						   historyEntity.ENDUSEDDATE,ParameterDirection.Input),
					new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							historyEntity.REMARKS,ParameterDirection.Input),
					new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
					new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input)
					};
				HistoryReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), HParas);
				//更新换修履历
				sbSql.Clear();
				sbSql.Append("update TP_PC_GMouldRecord");
				sbSql.Append(" set ENDDATE = :ENDDATE");
				sbSql.Append(" where GMouldRecordID= :GMouldRecordID");
				sbSql.Append(" and ACCOUNTID= :ACCOUNTID");
				OracleParameter[] UpParas = new OracleParameter[] {
					new OracleParameter(":ENDDATE",OracleDbType.Date,
							detailEntity.BEGINUSEDDATE,ParameterDirection.Input),
					new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							MouldResumeId,ParameterDirection.Input),
					new OracleParameter(":ACCOUNTID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input)
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), UpParas);
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnRows;
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return returnRows;
		}

		/// <summary>
		/// 停用成型线明细
		/// </summary>
		/// <param name="detailEntity">明细实体</param>
		/// <param name="recordEntity">换修履历实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.12              新建
		/// </remarks>
		public static int StopDetail(GroutingLineDetailEntity detailEntity, GMouldRecordEntity recordEntity, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				//更新明细信息
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("update TP_PC_GroutingLineDetail");
				sbSql.Append(" set GroutingLineID =:GroutingLineID,");
				sbSql.Append("GroutingMouldCode =:GroutingMouldCode,");
				sbSql.Append("GoodsID =:GoodsID,");
				sbSql.Append("GroutingCount =:GroutingCount,");
				sbSql.Append("GMouldStatus =:GMouldStatus,");
				sbSql.Append("BeginUsedDate =to_date(:BeginUsedDate,'yyyy-mm-dd hh24:mi:ss'),");
				sbSql.Append("Remarks =:Remarks,");
				sbSql.Append("AccountID =:AccountID,");
				sbSql.Append("CreateTime =to_date(:CreateTime,'yyyy-mm-dd hh24:mi:ss'),");
				sbSql.Append("CreateUserID =:CreateUserID,");
				sbSql.Append("UpdateTime =to_date(:UpdateTime,'yyyy-mm-dd hh24:mi:ss'),");
				sbSql.Append("UpdateUserID =:UpdateUserID");
				sbSql.Append(" where GroutingLineDetailID =:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp");
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEID,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							detailEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							detailEntity.GOODSID,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							detailEntity.GROUTINGCOUNT,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							detailEntity.MOULDSTATUS,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.NVarchar2,
							detailEntity.BEGINUSEDDATE.ToString(),ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							detailEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							detailEntity.ACCOUNTID,ParameterDirection.Input),
						new OracleParameter(":CreateTime",OracleDbType.NVarchar2,
							detailEntity.CREATETIME.ToString(),ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							detailEntity.CREATEUSERID,ParameterDirection.Input),
						new OracleParameter(":UpdateTime",OracleDbType.NVarchar2,
							DateTime.Now.ToString(),ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							detailEntity.OPTIMESTAMP,ParameterDirection.Input)
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return -500;
				}
				//添加换修履历
				int RecordReturn = 0;
				sbSql.Clear();
				sbSql.Append("select SEQ_PC_GMouldRecord_ID.nextval from dual");
				int Id = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
				sbSql.Clear();
				sbSql.Append("Insert into TP_PC_GMouldRecord");
				sbSql.Append("(GMouldRecordID,GroutingLineID,GroutingLineDetailID,GoodsID,GroutingMouldCode,MouldCode,GroutingCount,");
				sbSql.Append("GMouldRecordType,BeginDate,EndDate,Rreason,Remarks,AccountID,CreateTime,CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
				sbSql.Append("VALUES(:GMouldRecordID,:GroutingLineID,:GroutingLineDetailID,:GoodsID,:GroutingMouldCode,:MouldCode,:GroutingCount,");
				sbSql.Append(":GMouldRecordType,:BeginDate,:EndDate,:Rreason,:Remarks,:AccountID,:CreateTime,:CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp)");
				OracleParameter[] RParas = new OracleParameter[] {
					new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							Id,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEID,ParameterDirection.Input),
					new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							recordEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
					new OracleParameter(":GoodsID",OracleDbType.Int32,
							recordEntity.GOODSID,ParameterDirection.Input),
					new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							recordEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
					new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							recordEntity.MouldCode,ParameterDirection.Input),
					new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							recordEntity.GROUTINGCOUNT,ParameterDirection.Input),
					new OracleParameter(":GMouldRecordType",OracleDbType.Int32,
							recordEntity.RESUMETYPE,ParameterDirection.Input),
					new OracleParameter(":BeginDate",OracleDbType.Date,
							recordEntity.BEGINDATE,ParameterDirection.Input),
					new OracleParameter(":EndDate",OracleDbType.Date,
							DBNull.Value,ParameterDirection.Input),
					new OracleParameter(":Rreason",OracleDbType.NVarchar2,
							recordEntity.RREASON,ParameterDirection.Input),
					new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							recordEntity.REMARKS,ParameterDirection.Input),
					new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
					new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
					new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
					new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
					new OracleParameter(":OPTimeStamp",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input)
				};
				RecordReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), RParas);
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return returnRows;
		}

		/// <summary>
		/// 启用成型线明细
		/// </summary>
		/// <param name="GroutingLineDetailID"></param>
		/// <param name="user"></param>
		/// <returns></returns>
		public static int StartDetail(int GroutingLineDetailID, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				//更新明细信息
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("update TP_PC_GroutingLineDetail");
				sbSql.Append(" set GMouldStatus =1");
				sbSql.Append(" where GroutingLineDetailID =:GroutingLineDetailID");
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							GroutingLineDetailID,ParameterDirection.Input),
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				else
				{
					oracleTrConn.Commit();
					oracleTrConn.Disconnect();
				}
				return returnRows;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 整线换模(插入模具履历，并更新明细的各字段（模具编号，注浆次数，开始使用日期，模具状态）)
		/// </summary>
		/// <param name="groutingLineEntity">成型线实体</param>
		/// <param name="detailList">明细集合</param>
		/// <param name="StartTime">起始日期</param>
		/// <param name="Rreason">原因</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.12              新建
		/// </remarks>
		public static int ChangeAllLine(GroutingLineEntity groutingLineEntity, List<GroutingLineDetailEntity> detailList, DateTime? StartTime, String Rreason, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				if (StartTime != null)
				{
					accountDate = Convert.ToDateTime(StartTime);
				}
				//修改成型线整体状态
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("update TP_PC_GroutingLine");
				sbSql.Append(" set GMouldStatus=3,");
				sbSql.Append("UpdateTime=:UpdateTime,");
				sbSql.Append("UpdateUserID=:UpdateUserID");
				sbSql.Append(" where GroutingLineID=:GroutingLineID");
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input),
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				//遍历该成型线的每一个模具信息（明细）
				foreach (GroutingLineDetailEntity detailEntity in detailList)
				{
					//判断该模具的状态
					//正常或维修状态可以转为换模状态，并更新模具编号，注浆次数，开始使用日期，模具状态
					if (detailEntity.MOULDSTATUS != 0)  //只要不是停用的，就要进行修改
					{
						string newMouldCode = Guid.NewGuid().ToString().ToUpper();
						//更新明细信息
						sbSql.Clear();
						sbSql.Append("update TP_PC_GroutingLineDetail");
						sbSql.Append(" set GMouldStatus =3,");
						sbSql.Append("remarks=:remarks,");//后添加的
						sbSql.Append(" GroutingCount=0,");
						sbSql.Append(" BeginUsedDate = to_date(:BeginUsedDate,'yyyy-mm-dd hh24:mi:ss'),");
						sbSql.Append(" MouldCode =:MouldCode,");
						sbSql.Append(" UpdateUserID =:UpdateUserID");
						sbSql.Append(" where GroutingLineDetailID =:GroutingLineDetailID");
						OracleParameter[] DParas = new OracleParameter[] {
							  new OracleParameter(":remarks",OracleDbType.Varchar2,
							Rreason,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.NVarchar2,
							accountDate,ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							Guid.NewGuid().ToString().ToUpper(),ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
						};
						returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DParas);
						//添加换修履历
						int RecordReturn = 0;
						sbSql.Clear();
						sbSql.Append("select SEQ_PC_GMouldRecord_ID.nextval from dual");
						int RecordId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
						sbSql.Clear();
						sbSql.Append("Insert into TP_PC_GMouldRecord");
						sbSql.Append("(GMouldRecordID,GroutingLineID,GroutingLineDetailID,GoodsID,GroutingMouldCode,MouldCode,GroutingCount,");
						sbSql.Append("GMouldRecordType,BeginDate,Rreason,Remarks,AccountID,CreateTime,CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
						sbSql.Append("VALUES(:GMouldRecordID,:GroutingLineID,:GroutingLineDetailID,:GoodsID,:GroutingMouldCode,:MouldCode,:GroutingCount,");
						sbSql.Append(":GMouldRecordType,:BeginDate,:Rreason,:Remarks,:AccountID,:CreateTime,:CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp)");
						string rreasonStr = "整线换模";
						if (Rreason != "")
						{
							rreasonStr = Rreason;
						}
						OracleParameter[] RParas = new OracleParameter[] {
							new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
								RecordId,ParameterDirection.Input),
							new OracleParameter(":GroutingLineID",OracleDbType.Int32,
								detailEntity.GROUTINGLINEID,ParameterDirection.Input),
							new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
								detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
							new OracleParameter(":GoodsID",OracleDbType.Int32,
								detailEntity.GOODSID,ParameterDirection.Input),
							new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
								detailEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
							new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
								detailEntity.MOULDCODE,ParameterDirection.Input),
							new OracleParameter(":GroutingCount",OracleDbType.Decimal,
								detailEntity.GROUTINGCOUNT,ParameterDirection.Input),
							new OracleParameter(":GMouldRecordType",OracleDbType.Int32,
								4,ParameterDirection.Input),
							new OracleParameter(":BeginDate",OracleDbType.Date,
								accountDate,ParameterDirection.Input),
							new OracleParameter(":Rreason",OracleDbType.NVarchar2,
								rreasonStr,ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.NVarchar2,
								String.Empty,ParameterDirection.Input),
							new OracleParameter(":AccountID",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input),
							new OracleParameter(":CreateTime",OracleDbType.Date,
								DateTime.Now,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
								user.UserID,ParameterDirection.Input),
							new OracleParameter(":UpdateTime",OracleDbType.Date,
								DateTime.Now,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
								user.UserID,ParameterDirection.Input),
							new OracleParameter(":OPTimeStamp",OracleDbType.Date,
								DateTime.Now,ParameterDirection.Input),
						};
						RecordReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), RParas);
						//如果是正常换模或维修转换模，要进行模具履历的添加，如果最开始先换了，那么就不添加这条履历。
						if (detailEntity.MOULDSTATUS != 2)
						{
							int HistoryReturn = 0;
							sbSql.Clear();
							sbSql.Append("select SEQ_PC_GMouldHistory_ID.nextval from dual");
							int HistoryId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
							sbSql.Clear();
							sbSql.Append("Insert into TP_PC_GMouldHistory");
							sbSql.Append("(GMouldHistoryID,GroutingLineID,GroutingLineDetailID,GoodsID,GroutingMouldCode,MouldCode,GroutingCount,");
							sbSql.Append("BeginUsedDate,EndUsedDate,Remarks,AccountID,CreateTime,CreateUserID)");
							sbSql.Append(" Values(:GMouldHistoryID,:GroutingLineID,:GroutingLineDetailID,:GoodsID,:GroutingMouldCode,:MouldCode,:GroutingCount,");
							sbSql.Append(":BeginUsedDate,:EndUsedDate,:Remarks,:AccountID,:CreateTime,:CreateUserID)");
							OracleParameter[] HParas = new OracleParameter[] {
							new OracleParameter(":GMouldHistoryID",OracleDbType.Int32,
								HistoryId,ParameterDirection.Input),
							new OracleParameter(":GroutingLineID",OracleDbType.Int32,
								detailEntity.GROUTINGLINEID,ParameterDirection.Input),
							new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
								detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
							new OracleParameter(":GoodsID",OracleDbType.Int32,
								detailEntity.GOODSID,ParameterDirection.Input),
							new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
								detailEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
							new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
								detailEntity.MOULDCODE,ParameterDirection.Input),
							new OracleParameter(":GroutingCount",OracleDbType.Decimal,
								detailEntity.GROUTINGCOUNT,ParameterDirection.Input),
							new OracleParameter(":BeginUsedDate",OracleDbType.Date,
								detailEntity.BEGINUSEDDATE,ParameterDirection.Input),
							new OracleParameter(":EndUsedDate",OracleDbType.Date,
								accountDate,ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.NVarchar2,
								detailEntity.REMARKS,ParameterDirection.Input),
							new OracleParameter(":AccountID",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input),
							new OracleParameter(":CreateTime",OracleDbType.Date,
								DateTime.Now,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
								user.UserID,ParameterDirection.Input)
							 };
							HistoryReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), HParas);
						}
						//把之前的换修履历的结束时间添加上。
						int MouldResumdId = 0;
						if (detailEntity.MOULDSTATUS != 1) //如果是维修或者换模状态，那么之前会有一条履历，正常状态则没有
						{
							//ID为倒序的第一个数据就是符合条件的
							sbSql.Clear();
							sbSql.Append("Select GMouldRecordID from TP_PC_GMouldRecord where ");
							sbSql.Append(" GroutingLineDetailID=:GroutingLineDetailID and GroutingLineID=:GroutingLineID");
							sbSql.Append(" and AccountId=:AccountId Order by GMouldRecordID Desc");
							OracleParameter[] TParas = new OracleParameter[] {
									new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
										detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
									new OracleParameter(":GroutingLineID",OracleDbType.Int32,
										detailEntity.GROUTINGLINEID,ParameterDirection.Input),
									new OracleParameter(":AccountId",OracleDbType.Int32,
										user.AccountID,ParameterDirection.Input)
								};
							DataSet ds = oracleTrConn.GetSqlResultToDs(sbSql.ToString(), TParas);
							MouldResumdId = Convert.ToInt32(ds.Tables[0].Rows[0][0]);
							sbSql.Clear();
							sbSql.Append("update TP_PC_GMouldRecord");
							sbSql.Append(" set ENDDATE = :ENDDATE");
							sbSql.Append(" where GMouldRecordID= :GMouldRecordID");
							sbSql.Append(" and ACCOUNTID= :ACCOUNTID");
							OracleParameter[] UpParas = new OracleParameter[] {
									new OracleParameter(":ENDDATE",OracleDbType.Date,
										accountDate,ParameterDirection.Input),
									new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
										MouldResumdId,ParameterDirection.Input),
									new OracleParameter(":ACCOUNTID",OracleDbType.Int32,
										user.AccountID,ParameterDirection.Input)
								};
							int UpdateTimeReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), UpParas);
						}
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return returnRows;
		}

		/// <summary>
		/// 整线换模完毕(更新明细状态即可)
		/// </summary>
		/// <param name="groutingLineEntity">成型线实体</param>
		/// <param name="detailList">明细集合</param>
		/// <param name="endTime">结束日期</param>
		/// <param name="remarks">备注</param>
		/// <param name="user">用户信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.12              新建
		/// </remarks>
		public static int ChangeAllLineEnd(GroutingLineEntity groutingLineEntity, List<GroutingLineDetailEntity> detailList, DateTime? endTime, string remarks, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			int MouldResumeId = 0;
			try
			{
				oracleTrConn.Connect();
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				if (endTime != null)
				{
					accountDate = Convert.ToDateTime(endTime);
				}
				//修改成型线整体状态
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("update TP_PC_GroutingLine");
				sbSql.Append(" set GMouldStatus=1,");
				sbSql.Append("UpdateTime=:UpdateTime,");
				sbSql.Append("UpdateUserID=:UpdateUserID");
				sbSql.Append(" where GroutingLineID=:GroutingLineID");
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input),
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

				string remark2 = "";
				if (detailList.Count > 0)
				{
					string sql = "select remarks from TP_PC_GroutingLineDetail where GroutingLineDetailID=" + detailList[0].GROUTINGLINEDETAILID;
					DataSet ds = oracleTrConn.GetSqlResultToDs(sql);
					if (ds != null && ds.Tables[0].Rows.Count > 0)
					{
						remark2 = ds.Tables[0].Rows[0]["remarks"].ToString();
					}
				}


				//将该成型线所属模具的状态改为正常
				foreach (GroutingLineDetailEntity detailEntity in detailList)
				{
					if (detailEntity.MOULDSTATUS != 0)  //停用的略过
					{
						//更新明细信息
						sbSql.Clear();
						sbSql.Append("update TP_PC_GroutingLineDetail");
						sbSql.Append(" set GMouldStatus =:GMouldStatus,");
						sbSql.Append("remarks =:remarks,");//后添加的
						sbSql.Append("UpdateUserID =:UpdateUserID");
						sbSql.Append(" where GroutingLineDetailID =:GroutingLineDetailID");
						OracleParameter[] DParas = new OracleParameter[] {
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							1,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
							 new OracleParameter(":remarks",OracleDbType.Varchar2,
							remark2+"->"+remarks,ParameterDirection.Input),
						};
						returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DParas);
						//更新换修履历
						//首先查询到该模具的最新换修履历
						sbSql.Clear();
						sbSql.Append("Select GMouldRecordID from TP_PC_GMouldRecord");
						sbSql.Append(" where GroutingLineDetailID=:GroutingLineDetailID and GroutingLineID=:GroutingLineID");
						sbSql.Append(" and AccountId=:AccountId Order by GMouldRecordID Desc");
						OracleParameter[] SParas = new OracleParameter[] {
							new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
								detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
							new OracleParameter(":GroutingLineID",OracleDbType.Int32,
								detailEntity.GROUTINGLINEID,ParameterDirection.Input),
							new OracleParameter(":AccountId",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input)
						};
						DataSet ds = oracleTrConn.GetSqlResultToDs(sbSql.ToString(), SParas);
						if (ds.Tables[0].Rows.Count > 0)
						{
							MouldResumeId = Convert.ToInt32(ds.Tables[0].Rows[0][0]);
						}
						if (MouldResumeId != 0)
						{
							//把结束时间添加上
							sbSql.Clear();
							sbSql.Append("update TP_PC_GMouldRecord");
							sbSql.Append(" set ENDDATE = :ENDDATE");
							sbSql.Append(",Remarks = :Remarks");
							sbSql.Append(" where GMouldRecordID= :GMouldRecordID");
							sbSql.Append(" and ACCOUNTID= :ACCOUNTID");
							OracleParameter[] UpParas = new OracleParameter[] {
								new OracleParameter(":ENDDATE",OracleDbType.Date,
								accountDate,ParameterDirection.Input),
								new OracleParameter(":Remarks",OracleDbType.NVarchar2,
								remarks,ParameterDirection.Input),
								new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
								MouldResumeId,ParameterDirection.Input),
								new OracleParameter(":ACCOUNTID",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input)
								};
							returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), UpParas);
						}
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return returnRows;
		}

		/// <summary>
		/// 判断成型线编号是否存在
		/// </summary>
		/// <param name="GroutingLineCode">成型线编码</param>
		/// <param name="AccountID">帐套ID</param>
		/// <returns>bool是否可插入数据</returns>
		/// <remarks>
		/// 庄天威              2014.09.12              新建
		/// </remarks>
		private static bool GroutingLineCodeIsRepeat(string GroutingLineCode, int AccountID)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			StringBuilder sbSql = new StringBuilder();
			try
			{
				con.Open();
				sbSql.Append("Select GroutingLineID from TP_PC_GroutingLine");
				sbSql.Append(" where AccountId=:AccountId and GroutingLineCode=:GroutingLineCode");
				OracleParameter[] Paras = new OracleParameter[] {
							new OracleParameter(":GroutingLineCode",OracleDbType.NVarchar2,
								GroutingLineCode,ParameterDirection.Input),
							new OracleParameter(":AccountId",OracleDbType.Int32,
								AccountID,ParameterDirection.Input)
						};
				DataSet ds = con.GetSqlResultToDs(sbSql.ToString(), Paras);
				con.Close();

				if (ds.Tables[0].Rows.Count > 0)
				{
					return false;
				}
				else
				{
					return true;
				}
			}
			catch (Exception ex)
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 判断成型线编号是否存在(外用)
		/// </summary>
		/// <param name="GroutingLineCode">成型线编码</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>bool是否可插入数据</returns>
		/// <remarks>
		/// 庄天威              2014.09.12              新建
		/// </remarks>
		public static bool GroutingLineCodeIsRepeat(string GroutingLineCode, SUserInfo user)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			StringBuilder sbSql = new StringBuilder();
			try
			{
				con.Open();
				sbSql.Append("Select GroutingLineID from TP_PC_GroutingLine");
				sbSql.Append(" where AccountId=:AccountId and GroutingLineCode=:GroutingLineCode");
				OracleParameter[] Paras = new OracleParameter[] {
							new OracleParameter(":GroutingLineCode",OracleDbType.NVarchar2,
								GroutingLineCode,ParameterDirection.Input),
							new OracleParameter(":AccountId",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input)
						};
				DataSet ds = con.GetSqlResultToDs(sbSql.ToString(), Paras);
				con.Close();

				if (ds.Tables[0].Rows.Count > 0)
				{
					return false;
				}
				else
				{
					return true;
				}
			}
			catch (Exception ex)
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 判断成型线明细编号是否存在
		/// </summary>
		/// <param name="GroutingLineDetailCode">成型线明细编码</param>
		/// <param name="AccountID">帐套ID</param>
		/// <returns>bool是否可插入数据</returns>
		/// <remarks>
		/// 庄天威              2014.09.12              新建
		/// </remarks>
		private static bool GroutingLineDetailCodeIsRepeat(string GroutingLineDetailCode, int AccountID)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			StringBuilder sbSql = new StringBuilder();
			try
			{
				con.Open();
				sbSql.Append("Select GroutingLineDetailID from TP_PC_GroutingLineDetail gld");
				sbSql.Append(" inner join TP_PC_GroutingLine gl on gld.GroutingLineID = gl.GroutingLineID");
				sbSql.Append(" where gld.AccountId=:AccountId and gld.GroutingMouldCode=:GroutingMouldCode and gld.valueflag = '1' and gl.valueflag='1'");
				OracleParameter[] Paras = new OracleParameter[] {
							new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
								GroutingLineDetailCode,ParameterDirection.Input),
							new OracleParameter(":AccountId",OracleDbType.Int32,
								AccountID,ParameterDirection.Input)
						};
				DataSet ds = con.GetSqlResultToDs(sbSql.ToString(), Paras);
				con.Close();
				if (ds.Tables[0].Rows.Count > 0)
				{
					return false;
				}
				else
				{
					return true;
				}
			}
			catch (Exception ex)
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 成性线变产
		/// </summary>
		/// <param name="groutingLineEntity">成型线实体</param>
		/// <param name="detailList">明细集合</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.12              新建
		/// </remarks>
		public static int UpdateLine(GroutingLineEntity groutingLineEntity, List<GroutingLineDetailEntity> detailList, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();

				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);

				//修改成型线整体状态（4为变产）
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("update TP_PC_GroutingLine");
				sbSql.Append(" set GMouldStatus=4,");
				sbSql.Append("UpdateTime=:UpdateTime,");
				sbSql.Append("UpdateUserID=:UpdateUserID");
				sbSql.Append(" where GroutingLineID=:GroutingLineID");
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input),
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				//遍历该成型线的每一个模具信息（明细）
				foreach (GroutingLineDetailEntity detailEntity in detailList)
				{
					//更新成性线明细的各模具状态
					if (detailEntity.MOULDSTATUS != 0)  //只要不是停用的，就要进行修改
					{
						//更新明细信息
						sbSql.Clear();
						sbSql.Append("update TP_PC_GroutingLineDetail");
						sbSql.Append(" set GMouldStatus =4,");
						// modify wangx 2015/06/23 新添加
						sbSql.Append("  Remarks =:Remarks,");
						// modify wangx  2015/06/23 新添加 end
						sbSql.Append(" UpdateUserID =:UpdateUserID");
						sbSql.Append(" where GroutingLineDetailID =:GroutingLineDetailID");
						OracleParameter[] DParas = new OracleParameter[] {
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.Varchar2,
							groutingLineEntity.REMARKS,ParameterDirection.Input)
						};
						returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DParas);

						//插入变产履历
						sbSql.Clear();
						sbSql.Append("select SEQ_PC_GMouldRecord_ID.nextval from dual");
						int Id = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
						sbSql.Clear();
						sbSql.Append("Insert into TP_PC_GMouldRecord");
						sbSql.Append("(GMouldRecordID,GroutingLineID,GroutingLineDetailID,GoodsID,GroutingMouldCode,MouldCode,GroutingCount,");
						sbSql.Append("GMouldRecordType,BeginDate,Rreason,Remarks,AccountID,CreateTime,CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
						sbSql.Append("VALUES(:GMouldRecordID,:GroutingLineID,:GroutingLineDetailID,:GoodsID,:GroutingMouldCode,:MouldCode,:GroutingCount,");
						sbSql.Append(":GMouldRecordType,:BeginDate,:Rreason,:Remarks,:AccountID,:CreateTime,:CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp)");
						OracleParameter[] GRParas = new OracleParameter[] {
						new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							Id,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							detailEntity.GOODSID,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							detailEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							detailEntity.MOULDCODE,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							detailEntity.GROUTINGCOUNT,ParameterDirection.Input),
						new OracleParameter(":GMouldRecordType",OracleDbType.Int32,
							Constant.GMouldRecordType.Update,ParameterDirection.Input),
						new OracleParameter(":BeginDate",OracleDbType.Date,
							accountDate,ParameterDirection.Input),
						new OracleParameter(":Rreason",OracleDbType.NVarchar2,
							groutingLineEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							groutingLineEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input)
						};
						oracleTrConn.ExecuteNonQuery(sbSql.ToString(), GRParas);
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();

				return returnRows;
			}
			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();
				}
			}
		}

		/// <summary>
		/// 成型线变产完毕
		/// </summary>
		/// <param name="groutingLineEntity">成型线实体</param>
		/// <param name="detailList">成型线明细集合</param>
		/// <param name="detailNewGoodsId">新模具生产产品ID</param>
		/// <param name="user">当前用户</param>
		/// <returns>影响行数</returns>
		public static int UpdateLineEnd(GroutingLineEntity groutingLineEntity, List<GroutingLineDetailEntity> detailList, int detailNewGoodsId, SUserInfo user)
		{
			int returnRows = 0;
			int detailReturn = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);

				//变产成功后，首先停用原成性线及其明细
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("update TP_PC_GroutingLine");
				sbSql.Append(" set ValueFlag=0,");
				//sbSql.Append("UpdateTime=:UpdateTime,");
				sbSql.Append("UpdateUserID=:UpdateUserID");
				sbSql.Append(" where GroutingLineID=:GroutingLineID");
				OracleParameter[] Paras = new OracleParameter[] {
                        //new OracleParameter(":UpdateTime",OracleDbType.Date,
                        //    DateTime.Now,ParameterDirection.Input),
                        new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input),
					};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

				// 查明细变产备注 modify wangx 20150623
				string remarks = "";
				if (detailList.Count > 0)
				{
					string sql = "select remarks from TP_PC_GroutingLineDetail where GroutingLineDetailID=" + detailList[0].GROUTINGLINEDETAILID;
					DataSet ds = oracleTrConn.GetSqlResultToDs(sql);
					if (ds != null && ds.Tables[0].Rows.Count > 0)
					{
						remarks = ds.Tables[0].Rows[0]["remarks"].ToString();
					}
				}

				// 查明细变产备注 modify wangx 20150623 end
				// 遍历该成型线的每一个模具信息（明细），修改为停用状态
				foreach (GroutingLineDetailEntity detailEntity in detailList)
				{
					// 更新成性线明细的各模具状态
					//if (detailEntity.MOULDSTATUS != 0)  //只要不是停用的，就要进行修改
					{
						// 更新明细信息
						sbSql.Clear();
						sbSql.Append("update TP_PC_GroutingLineDetail");
						sbSql.Append(" set ValueFlag=0,");
						sbSql.Append(" UpdateUserID =:UpdateUserID");
						sbSql.Append(" where GroutingLineDetailID =:GroutingLineDetailID");
						OracleParameter[] DParas = new OracleParameter[] {
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input)
						};
						returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DParas);
					}
				}

				//新建一条成性线，继承停用的成性线的一切属性，状态与是否停用均为正常属性。
				//获取成型线ID索引
				sbSql.Clear();
				sbSql.Append("select SEQ_PC_GroutingLine_ID.nextval from dual");
				int newLineId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
				sbSql.Clear();
				sbSql.Append(@"Insert into TP_PC_GroutingLine 
                               (GroutingLineID,BuildingNo,FloorNo,GroutingLineNo,GroutingLineCode,GroutingLineName,MouldQuantity,GMouldTypeID,
                                UserID,BeginUsedDate,GMouldStatus,Remarks,AccountID,CreateUserID,UpdateUserID)
                               Select :NewGroutingLineID,BuildingNo,FloorNo,GroutingLineNo,GroutingLineCode,GroutingLineName,MouldQuantity,GMouldTypeID,
                                UserID,:BeginUsedDate,1,Remarks,AccountID,:CreateUserID,:UpdateUserID from TP_PC_GroutingLine
                                Where GroutingLineID = :GroutingLineID");
				OracleParameter[] AParas = new OracleParameter[] {
						new OracleParameter(":NewGroutingLineID",OracleDbType.Int32,
							newLineId,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							accountDate,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input)
				};
				detailReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), AParas);
				//根据新成性线ID插入该成型线明细，
				foreach (GroutingLineDetailEntity detailEntity in detailList)
				{
					//获取成型线明细索引
					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GroutingLineDetail_ID.nextval from dual");
					int detailId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
					sbSql.Clear();
					//插入成型线明细信息
					string NewMouldCode = Guid.NewGuid().ToString().ToUpper();
					sbSql.Append("Insert into TP_PC_GroutingLineDetail");
					sbSql.Append("(GroutingLineDetailID,GroutingLineID,GroutingMouldCode,MouldCode,GoodsID,GroutingCount,");
					sbSql.Append("GMouldStatus,BeginUsedDate,Remarks,AccountID,ValueFlag,CreateTime,");
					sbSql.Append("CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
					sbSql.Append("Values(:GroutingLineDetailID,:GroutingLineID,:GroutingMouldCode,:MouldCode,:GoodsID,:GroutingCount,");
					sbSql.Append(":GMouldStatus,:BeginUsedDate,:Remarks,:AccountID,:ValueFlag,:CreateTime,");
					sbSql.Append(":CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp)");
					OracleParameter[] DetailParas = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailId,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							newLineId,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							detailEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							NewMouldCode,ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							detailNewGoodsId,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							0,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							1,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							accountDate,ParameterDirection.Input),
                        //new OracleParameter(":Remarks",OracleDbType.NVarchar2,
                        //    detailEntity.REMARKS,ParameterDirection.Input),
                       new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							remarks+"->"+ groutingLineEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":ValueFlag",OracleDbType.Int32,
							1,ParameterDirection.Input),
						new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							DateTime.Now,ParameterDirection.Input)
					};
					//执行插入语句并累加成功插入次数
					detailReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);

					//补全变产履历
					//首先查询到该模具的最新换修履历
					sbSql.Clear();
					sbSql.Append("Select GMouldRecordID from TP_PC_GMouldRecord");
					sbSql.Append(" where GroutingLineDetailID=:GroutingLineDetailID and GroutingLineID=:GroutingLineID");
					sbSql.Append(" and AccountId=:AccountId Order by GMouldRecordID Desc");
					OracleParameter[] SParas = new OracleParameter[] {
							new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
								detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
							new OracleParameter(":GroutingLineID",OracleDbType.Int32,
								detailEntity.GROUTINGLINEID,ParameterDirection.Input),
							new OracleParameter(":AccountId",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input)
						};
					int MouldResumeId = 0;
					DataSet ds = oracleTrConn.GetSqlResultToDs(sbSql.ToString(), SParas);
					if (ds.Tables[0].Rows.Count > 0)
					{
						MouldResumeId = Convert.ToInt32(ds.Tables[0].Rows[0][0]);
					}
					if (MouldResumeId != 0)
					{
						//把结束时间以及变产后信息添加上
						sbSql.Clear();
						sbSql.Append("update TP_PC_GMouldRecord");
						sbSql.Append(" set ENDDATE = :ENDDATE");
						sbSql.Append(",ChangedGoodsID = :ChangedGoodsID");
						sbSql.Append(",ChangedMouldCode = :ChangedMouldCode");
						sbSql.Append(",Remarks = :Remarks");
						sbSql.Append(" where GMouldRecordID= :GMouldRecordID");
						sbSql.Append(" and ACCOUNTID= :ACCOUNTID");
						OracleParameter[] UpParas = new OracleParameter[] {
								new OracleParameter(":ENDDATE",OracleDbType.Date,
								accountDate,ParameterDirection.Input),
								new OracleParameter(":ChangedGoodsID",OracleDbType.Int32,
								detailNewGoodsId,ParameterDirection.Input),
								new OracleParameter(":ChangedMouldCode",OracleDbType.NVarchar2,
								NewMouldCode,ParameterDirection.Input),
								new OracleParameter(":Remarks",OracleDbType.NVarchar2,
								groutingLineEntity.REMARKS,ParameterDirection.Input),
								new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
								MouldResumeId,ParameterDirection.Input),
								new OracleParameter(":ACCOUNTID",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input)
								};
						returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), UpParas);
					}

					//插入换模履历
					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GMouldHistory_ID.nextval from dual");
					int HistoryId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
					sbSql.Clear();
					sbSql.Append("Insert into TP_PC_GMouldHistory");
					sbSql.Append("(GMouldHistoryID,GroutingLineID,GroutingLineDetailID,GoodsID,GroutingMouldCode,MouldCode,GroutingCount,");
					sbSql.Append("BeginUsedDate,EndUsedDate,Remarks,AccountID,CreateTime,CreateUserID)");
					sbSql.Append(" Values(:GMouldHistoryID,:GroutingLineID,:GroutingLineDetailID,:GoodsID,:GroutingMouldCode,:MouldCode,:GroutingCount,");
					sbSql.Append(":BeginUsedDate,:EndUsedDate,:Remarks,:AccountID,:CreateTime,:CreateUserID)");
					OracleParameter[] HParas = new OracleParameter[] {
						new OracleParameter(":GMouldHistoryID",OracleDbType.Int32,
							HistoryId,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailEntity.GROUTINGLINEDETAILID,ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							detailEntity.GOODSID,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							detailEntity.GROUTINGMOULDCODE,ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							detailEntity.MOULDCODE,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							detailEntity.GROUTINGCOUNT,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							detailEntity.BEGINUSEDDATE,ParameterDirection.Input),
						new OracleParameter(":EndUsedDate",OracleDbType.Date,
							accountDate,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							groutingLineEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input)
					 };
					oracleTrConn.ExecuteNonQuery(sbSql.ToString(), HParas);
				}

				//复制该线的所有范围权限，并移交到新线上，老线的权限全部删除
				sbSql.Clear();
				sbSql.Append(@" Insert into TP_MST_UserPurview (UserID,PurviewID,PurviewType,CreateUserID)
                                Select UserID,:PurviewID,PurviewType,:CreateUserID from TP_MST_UserPurview
                                Where PurviewID = :OldPurviewID and PurviewType in (5,6)");
				OracleParameter[] UPParas = new OracleParameter[] {
						new OracleParameter(":PurviewID",OracleDbType.Int32,
							newLineId,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":OldPurviewID",OracleDbType.Int32,
							groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input)
				};
				detailReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), UPParas);
				sbSql.Clear();
				// 只删除操作权限
				//sbSql.Append(@" Delete from TP_MST_UserPurview Where PurviewID = :OldPurviewID and PurviewType in (5,6)");
				sbSql.Append(@" Delete from TP_MST_UserPurview Where PurviewID = :OldPurviewID and PurviewType = 6");
				OracleParameter[] DPParas = new OracleParameter[] {
						new OracleParameter(":OldPurviewID",OracleDbType.Int32,
							groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input)
				};
				detailReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DPParas);

				oracleTrConn.Commit();
				oracleTrConn.Disconnect();

				return newLineId;
			}
			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();
				}
			}
		}

		#endregion

		#region 更新生产线信息

		/// <summary>
		/// 更新生产线
		/// </summary>
		/// <param name="productionLine">生产线实体</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns></returns>
		public static int UpdateProductionLine(ProductionLineEntity productionLine, SUserInfo sUserInfo)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{

				string sqlText = " SELECT ProductionLineID "
															+ " FROM TP_PC_ProductionLine "
															+ " WHERE "
															+ " AccountID=:accountID "
															+ " AND ProductionLineCode=:productionLineCode"
															+ " AND ProductionLineID <> :productionLineID";
				OracleParameter[] paras = new OracleParameter[]
					{
						new OracleParameter(":accountID",sUserInfo.AccountID),
						new OracleParameter(":productionLineCode",productionLine.ProductionLineCode),
						new OracleParameter(":productionLineID",productionLine.ProductionLineID),
					};
				string returnCode = oracleTrConn.GetSqlResultToStr(sqlText, paras);
				if (!string.IsNullOrEmpty(returnCode))
				{
					return Constant.RETURN_IS_EXIST;//-3
				}
				#region 编辑生产线
				sqlText = "UPDATE TP_PC_ProductionLine SET "
																+ "ProductionLineName=:productionLineName,"
																+ "ProductionLineCode=:productionLineCode,"
																+ "Remarks=:remarks,"
																+ "ValueFlag=:valueflag,"
																+ "UpdateTime=sysdate, "
																+ "UpdateUserID=:updateUserID "
																+ " WHERE ProductionLineID=:productionLineID";
				paras = new OracleParameter[]
						{
							new OracleParameter(":productionLineName",productionLine.ProductionLineName),
							new OracleParameter(":productionLineCode",productionLine.ProductionLineCode),
							new OracleParameter(":remarks",productionLine.Remarks),
							new OracleParameter(":valueflag",productionLine.ValueFlags[0]),
							new OracleParameter(":updateUserID",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":productionLineID", OracleDbType.Int32, productionLine.ProductionLineID,ParameterDirection.Input)
						};
				returnRows += oracleTrConn.ExecuteNonQuery(sqlText, paras);
				#endregion
				oracleTrConn.Commit();
			}
			catch (Exception ex)
			{
				oracleTrConn.Rollback();
				throw ex;
			}
			finally
			{
				// 释放资源
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return returnRows;
		}

		#endregion

		#region 成型线配置 20150916

		/// <summary>
		/// 更改成型线状态
		/// </summary>
		/// <param name="GroutingLineID"></param>
		/// <param name="ValueFlag"></param>
		/// <param name="sUserInfo"></param>
		/// <returns></returns>
		public static int SaveGroutingLineValueFlag(int GroutingLineID, int ValueFlag, SUserInfo sUserInfo)
		{
			int returnRows = 0;

			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				// 查询新插入的生产数据ID
				string sqlText = "";
				if (ValueFlag == 0)
				{
					sqlText = "update TP_PC_GroutingLine set GMouldStatus=:ValueFlag,updateUserID=:updateUserID,EndUsedDate=trunc(sysdate) where GroutingLineID=:GroutingLineID and GMouldStatus = 1";
				}
				else
				{
					sqlText = "update TP_PC_GroutingLine set GMouldStatus=:ValueFlag,updateUserID=:updateUserID,EndUsedDate=null where GroutingLineID=:GroutingLineID and GMouldStatus = 0";
				}

				OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":GroutingLineID",OracleDbType.Int32,GroutingLineID,ParameterDirection.Input),
							new OracleParameter(":ValueFlag",OracleDbType.Int32,ValueFlag,ParameterDirection.Input),
							new OracleParameter(":updateUserID",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
						};
				returnRows = oracleTrConn.ExecuteNonQuery(sqlText, parmeters1);
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnRows;
			}
			catch (Exception ex)
			{
				oracleTrConn.Rollback();
				oracleTrConn.Disconnect();
				throw ex;
			}
			finally
			{
				// 释放资源
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}


		/// <summary>
		/// 新建成型线信息
		/// </summary>
		/// <param name="groutingLineEntity">成型线实体</param>
		/// <param name="detailList">明细实体集合</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>返回受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.10              新建
		/// </remarks>
		public static int AddGroutingLine_New(GroutingLineEntity groutingLineEntity,
			List<GroutingLineDetailEntity> detailList, List<GroutingLineUserEntity> detailUserList, SUserInfo user)
		{
			int returnRows = 0;
			int detailReturn = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				if (GroutingLineCodeIsRepeat(groutingLineEntity.GROUTINGLINECODE, user.AccountID) == false)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return -50;
				}
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				//获取成型线ID索引
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("select SEQ_PC_GroutingLine_ID.nextval from dual");
				int id = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
				sbSql.Clear();
				//添加成型线信息
				sbSql.Append("Insert into TP_PC_GroutingLine");
				sbSql.Append("(GroutingLineID,BuildingNo,FloorNo,GroutingLineNo,GroutingLineCode,");
				sbSql.Append("GroutingLineName,MouldQuantity,GMouldTypeID,UserID,");
				sbSql.Append("BeginUsedDate,GMouldStatus,Remarks,AccountID,ValueFlag,CreateTime,");
				sbSql.Append("CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp,UserCount)");
				sbSql.Append("values(:GroutingLineID,:BuildingNo,:FloorNo,:GroutingLineNo,:GroutingLineCode,");
				sbSql.Append(":GroutingLineName,:MouldQuantity,:GMouldTypeID,:UserID,");
				sbSql.Append(":BeginUsedDate,:GMouldStatus,:Remarks,:AccountID,:ValueFlag,:CreateTime,");
				sbSql.Append(":CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp,:UserCount)");
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							id,ParameterDirection.Input),
						new OracleParameter(":BuildingNo",OracleDbType.NVarchar2,
							groutingLineEntity.BUILDINGNO,ParameterDirection.Input),
						new OracleParameter(":FloorNo",OracleDbType.NVarchar2,
							groutingLineEntity.FLOORNO,ParameterDirection.Input),
						new OracleParameter(":GroutingLineNo",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINENO,ParameterDirection.Input),
						new OracleParameter(":GroutingLineCode",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINECODE,ParameterDirection.Input),
						new OracleParameter(":GroutingLineName",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINENAME,ParameterDirection.Input),
						new OracleParameter(":MouldQuantity",OracleDbType.Decimal,
							groutingLineEntity.MOULDQUANTITY,ParameterDirection.Input),
						new OracleParameter(":GMouldTypeID",OracleDbType.Int32,
							groutingLineEntity.MOULDTYPEID,ParameterDirection.Input),
						new OracleParameter(":UserID",OracleDbType.Int32,
							groutingLineEntity.USERID,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							accountDate,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							groutingLineEntity.MouldStatus,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							groutingLineEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":ValueFlag",OracleDbType.Int32,
							groutingLineEntity.VALUEFLAG,ParameterDirection.Input),
						new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UserCount",OracleDbType.Int32,
							detailUserList.Count,ParameterDirection.Input),
					};
				//执行插入成型线SQL语句
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				//此处添加明细信息（循环）
				foreach (GroutingLineDetailEntity detailInfo in detailList)
				{
					//查看该成型线明细编号是否存在
					if (GroutingLineDetailCodeIsRepeat(detailInfo.GROUTINGMOULDCODE, user.AccountID) == false)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						return -2;
					}
					//获取成型线明细索引
					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GroutingLineDetail_ID.nextval from dual");
					int detailId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
					sbSql.Clear();
					//插入成型线明细信息
					sbSql.Append("Insert into TP_PC_GroutingLineDetail");
					sbSql.Append("(GroutingLineDetailID,GroutingLineID,GroutingMouldCode,MouldCode,GoodsID,GroutingCount,");
					sbSql.Append("GMouldStatus,BeginUsedDate,Remarks,AccountID,ValueFlag,CreateTime,");
					sbSql.Append("CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
					sbSql.Append("Values(:GroutingLineDetailID,:GroutingLineID,:GroutingMouldCode,:MouldCode,:GoodsID,:GroutingCount,");
					sbSql.Append(":GMouldStatus,:BeginUsedDate,:Remarks,:AccountID,:ValueFlag,:CreateTime,");
					sbSql.Append(":CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp)");
					OracleParameter[] DetailParas = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailId,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							id,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							detailInfo.GROUTINGMOULDCODE,ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							detailInfo.MOULDCODE,ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							detailInfo.GOODSID,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							detailInfo.GROUTINGCOUNT,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							detailInfo.MOULDSTATUS,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							accountDate,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							detailInfo.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":ValueFlag",OracleDbType.Int32,
							detailInfo.VALUEFLAG,ParameterDirection.Input),
						new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							DateTime.Now,ParameterDirection.Input)
					};
					//执行插入语句并累加成功插入次数
					detailReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);
				}

				// 添加成型工号
				foreach (GroutingLineUserEntity detailInfo in detailUserList)
				{
					//插入成型线明细信息
					sbSql.Clear();
					sbSql.Append("Insert into TP_PC_GroutingUser");
					sbSql.Append("(GroutingLineID,UserID,Remarks)");
					sbSql.Append("Values(:GroutingLineID,:UserID,:Remarks)");
					OracleParameter[] DetailParas = new OracleParameter[] {

						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							id,ParameterDirection.Input),
						new OracleParameter(":UserID",OracleDbType.Int32,
							detailInfo.USERID,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							detailInfo.REMARK,ParameterDirection.Input),
					};
					//执行插入语句并累加成功插入次数
					detailReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);
				}

				//如果有插入不成功的情况，回滚事务，否则提交
				if (returnRows == 0 || detailReturn == 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 returnRows;
		}

		/// <summary>
		/// 修改成型线信息
		/// </summary>
		/// <param name="groutingLineEntity">成型线实体</param>
		/// <param name="detailList">明细实体集合</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int返回受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.10              新建
		/// </remarks>
		public static int UpdateGroutingLine_New(GroutingLineEntity groutingLineEntity,
			List<GroutingLineDetailEntity> detailList, List<GroutingLineUserEntity> detailUserList, List<GroutingLineDetailEntity> UpdatedetailList, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				//修改成型线信息
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("update TP_PC_GroutingLine");
				sbSql.Append(" set BuildingNo=:BuildingNo,");
				sbSql.Append("FloorNo=:FloorNo,");
				sbSql.Append("GroutingLineNo=:GroutingLineNo,");
				sbSql.Append("GroutingLineCode=:GroutingLineCode,");
				sbSql.Append("GroutingLineName=:GroutingLineName,");
				sbSql.Append("MouldQuantity=:MouldQuantity,");
				sbSql.Append("GMouldTypeID=:GMouldTypeID,");
				sbSql.Append("UserID=:UserID,");
				sbSql.Append("BeginUsedDate=:BeginUsedDate,");
				sbSql.Append("EndUsedDate=:EndUsedDate,");
				sbSql.Append("GMouldStatus=:GMouldStatus,");
				sbSql.Append("Remarks=:Remarks,");
				sbSql.Append("AccountID=:AccountID,");
				//sbSql.Append("ValueFlag=:ValueFlag,");
				sbSql.Append("UpdateTime=:UpdateTime,");
				sbSql.Append("UpdateUserID=:UpdateUserID,");
				sbSql.Append("UserCount=:UserCount");
				sbSql.Append(" where GroutingLineID=:GroutingLineID and OPTimeStamp=:OPTimeStamp");
				if (groutingLineEntity.VALUEFLAG == 0)
				{
					groutingLineEntity.ENDUSEDDATE = DateTime.Now;
				}
				else
				{
					groutingLineEntity.ENDUSEDDATE = null;
				}
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":BuildingNo",OracleDbType.NVarchar2,
							groutingLineEntity.BUILDINGNO,ParameterDirection.Input),
						new OracleParameter(":FloorNo",OracleDbType.NVarchar2,
							groutingLineEntity.FLOORNO,ParameterDirection.Input),
						new OracleParameter(":GroutingLineNo",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINENO,ParameterDirection.Input),
						new OracleParameter(":GroutingLineCode",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINECODE,ParameterDirection.Input),
						new OracleParameter(":GroutingLineName",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINENAME,ParameterDirection.Input),
						new OracleParameter(":MouldQuantity",OracleDbType.Decimal,
							groutingLineEntity.MOULDQUANTITY,ParameterDirection.Input),
						new OracleParameter(":GMouldTypeID",OracleDbType.Int32,
							groutingLineEntity.MOULDTYPEID,ParameterDirection.Input),
						new OracleParameter(":UserID",OracleDbType.Int32,
							groutingLineEntity.USERID,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							groutingLineEntity.BEGINUSEDDATE,ParameterDirection.Input),
						new OracleParameter(":EndUsedDate",OracleDbType.Date,
							groutingLineEntity.ENDUSEDDATE,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							groutingLineEntity.MouldStatus,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							groutingLineEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							groutingLineEntity.ACCOUNTID,ParameterDirection.Input),
                        //new OracleParameter(":ValueFlag",OracleDbType.Int32,
                        //    groutingLineEntity.VALUEFLAG,ParameterDirection.Input),
                        new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							groutingLineEntity.OPTIMESTAMP,ParameterDirection.Input),
						new OracleParameter(":UserCount",OracleDbType.Int32,
							detailUserList.Count,ParameterDirection.Input),
					};
				//执行修改语句
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				//时间戳无法匹配
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return -500;
				}
				int detailReturn = 0;

				//添加修改时新建的模具信息
				foreach (GroutingLineDetailEntity detailInfo in UpdatedetailList)
				{
					sbSql.Clear();
					sbSql.Append("Update TP_PC_GroutingLineDetail set Remarks=:Remarks,UpdateUserID=:UpdateUserID where GroutingLineDetailID=:GroutingLineDetailID");
					OracleParameter[] DetailParas = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailInfo.GROUTINGLINEDETAILID,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							detailInfo.REMARKS,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
					};
					//执行
					detailReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);
				}

				//添加修改时新建的模具信息
				foreach (GroutingLineDetailEntity detailInfo in detailList)
				{
					//模具明细编号唯一
					if (GroutingLineDetailCodeIsRepeat(detailInfo.GROUTINGMOULDCODE, user.AccountID) == false)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						return -2;
					}
					//获取模具明细索引

					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GroutingLineDetail_ID.nextval from dual");
					int detailId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
					sbSql.Clear();
					//插入新增的模具信息
					sbSql.Append("Insert into TP_PC_GroutingLineDetail");
					sbSql.Append("(GroutingLineDetailID,GroutingLineID,GroutingMouldCode,MouldCode,GoodsID,GroutingCount,");
					sbSql.Append("GMouldStatus,BeginUsedDate,Remarks,AccountID,ValueFlag,CreateTime,");
					sbSql.Append("CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
					sbSql.Append("Values(:GroutingLineDetailID,:GroutingLineID,:GroutingMouldCode,:MouldCode,:GoodsID,:GroutingCount,");
					sbSql.Append(":GMouldStatus,:BeginUsedDate,:Remarks,:AccountID,:ValueFlag,:CreateTime,");
					sbSql.Append(":CreateUserID,:UpdateTime,:UpdateUserID,:OPTimeStamp)");
					OracleParameter[] DetailParas = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailId,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							detailInfo.GROUTINGMOULDCODE,ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							detailInfo.MOULDCODE,ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							detailInfo.GOODSID,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							detailInfo.GROUTINGCOUNT,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							detailInfo.MOULDSTATUS,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							accountDate,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							detailInfo.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":ValueFlag",OracleDbType.Int32,
							detailInfo.VALUEFLAG,ParameterDirection.Input),
						new OracleParameter(":CreateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							DateTime.Now,ParameterDirection.Input)
					};
					//执行
					detailReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);
				}

				string sqlDelete = "delete from TP_PC_GroutingUser where GroutingLineID=" + groutingLineEntity.GROUTINGLINEID.ToString();
				detailReturn += oracleTrConn.ExecuteNonQuery(sqlDelete);
				// 添加成型工号
				foreach (GroutingLineUserEntity detailInfo in detailUserList)
				{
					sbSql.Clear();
					//插入成型线明细信息
					sbSql.Append("Insert into TP_PC_GroutingUser");
					sbSql.Append("(GroutingLineID,UserID,Remarks)");
					sbSql.Append("Values(:GroutingLineID,:UserID,:Remarks)");
					OracleParameter[] DetailParas = new OracleParameter[] {

						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input),
						new OracleParameter(":UserID",OracleDbType.Int32,
							detailInfo.USERID,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							detailInfo.REMARK,ParameterDirection.Input),
					};
					//执行插入语句并累加成功插入次数
					detailReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);
				}

				//提交事务
				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 returnRows;
		}


		#endregion

		/// <summary>
		/// 停用成型线明细
		/// </summary>
		/// <param name="dtGroutingLineDetail">明细实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 
		/// </remarks>
		public static int StopGroutingLineDetail(DataTable dtGroutingLineDetail, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				OracleParameter[] Paras = null;
				StringBuilder sbSql = new StringBuilder();
				int GMouldRecordID = 0;
				bool isError = false;
				if (dtGroutingLineDetail.Rows.Count > 0)
				{
					// 更新成型线UpdateUserID
					sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"] + " and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[0]["LineOPTimeStamp"],ParameterDirection.Input)
					};
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						return returnRows = -500;
					}

				}
				for (int i = 0; i < dtGroutingLineDetail.Rows.Count; i++)
				{
					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GMouldRecord_ID.nextval from dual");
					GMouldRecordID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));//变更履历
					sbSql.Clear();
					// 1.插入变更履历
					sbSql.Append("insert into TP_PC_GMouldRecord");
					sbSql.Append("(GMouldRecordID,");
					sbSql.Append("GroutingLineID,GroutingLineDetailID,GoodsID,");
					sbSql.Append("GroutingMouldCode,MouldCode,GroutingCount,");
					sbSql.Append("GMouldRecordType,BeginDate,");
					sbSql.Append("Remarks,AccountID,CreateTime,");
					sbSql.Append("CreateUserID,UpdateTime,UpdateUserID");
					sbSql.Append(")");
					sbSql.Append("select :GMouldRecordID,");
					sbSql.Append("GroutingLineID,GroutingLineDetailID,GoodsID,");
					sbSql.Append("GroutingMouldCode,MouldCode,GroutingCount,");
					sbSql.Append(":GMouldRecordType,trunc(sysdate),");
					sbSql.Append(":Remarks,:AccountID,sysdate,");
					sbSql.Append(":CreateUserID,sysdate,:UpdateUserID");
					sbSql.Append(" from TP_PC_GroutingLineDetail where GroutingLineDetailID=:GroutingLineDetailID ");
					Paras = new OracleParameter[] {
						new OracleParameter(":GMouldRecordType",OracleDbType.Int32,
						   0,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"],ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							GMouldRecordID,ParameterDirection.Input)
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					//2.更新成型线模具状态
					sbSql.Clear();
					sbSql.Append("update TP_PC_GroutingLineDetail set GMouldStatus=0,LastGMouldRecordID=:LastGMouldRecordID, ");
					sbSql.Append("UpdateUserID=:UpdateUserID,EndUsedDate=trunc(sysdate) where  GroutingLineDetailID=:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						new OracleParameter(":LastGMouldRecordID",OracleDbType.Int32,
						   GMouldRecordID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[i]["OPTimeStamp"],ParameterDirection.Input)
					};
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						isError = true;  //即更新了，也可以用这个判断时间戳
						break;
					}
					returnRows += row;
				}
				//更新明细信息
				if (isError)
				{
					returnRows = -500;
					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 returnRows;
		}

		/// <summary>
		/// 启用成型线明细
		/// </summary>
		/// <param name="dtGroutingLineDetail">明细实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 
		/// </remarks>
		public static int StartGroutingLineDetail(DataTable dtGroutingLineDetail, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				OracleParameter[] Paras = null;
				StringBuilder sbSql = new StringBuilder();
				bool isError = false;
				if (dtGroutingLineDetail.Rows.Count > 0)
				{
					//// 更新成型线UpdateUserID
					//sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"]);
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					// 更新成型线UpdateUserID
					sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"] + " and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[0]["LineOPTimeStamp"],ParameterDirection.Input)
					};
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						return returnRows = -500;
					}
				}
				for (int i = 0; i < dtGroutingLineDetail.Rows.Count; i++)
				{
					sbSql.Clear();
					//1查出注浆明细最后变更履历ID，进行更新
					sbSql.Append("select nvl(LastGMouldRecordID,0) as LastGMouldRecordID  from TP_PC_GroutingLineDetail where GroutingLineDetailID=:GroutingLineDetailID");
					Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input)
					};
					DataSet dsInfo = oracleTrConn.GetSqlResultToDs(sbSql.ToString(), Paras);
					int? LastGMouldRecordID = null;
					if (dsInfo != null && dsInfo.Tables[0].Rows.Count > 0)
					{
						LastGMouldRecordID = Convert.ToInt32(dsInfo.Tables[0].Rows[0]["LastGMouldRecordID"]);
					}

					sbSql.Clear();
					sbSql.Append("Update TP_PC_GMouldRecord set EndDate=trunc(sysdate),Remarks=:Remarks,UpdateUserID=:UpdateUserID where GMouldRecordID=:GMouldRecordID");
					Paras = new OracleParameter[] {
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"],ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							LastGMouldRecordID,ParameterDirection.Input)
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

					//2.更新成型线模具状态
					sbSql.Clear();
					sbSql.Append("update TP_PC_GroutingLineDetail set GMouldStatus=1,EndUsedDate=null,");
					sbSql.Append("UpdateUserID=:UpdateUserID where  GroutingLineDetailID=:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp and GMouldStatus=0");
					Paras = new OracleParameter[] {
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[i]["OPTimeStamp"],ParameterDirection.Input)
					};
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						isError = true;  //即更新了，也可以用这个判断时间戳
						break;
					}
					returnRows += row;
				}
				//更新明细信息
				if (isError)
				{
					returnRows = -500;
					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 returnRows;
		}

		/// <summary>
		/// 维修开始 
		/// </summary>
		/// <param name="dtGroutingLineDetail">明细实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 
		/// </remarks>
		public static int RepairStartGroutingLineDetail(DataTable dtGroutingLineDetail, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				OracleParameter[] Paras = null;
				StringBuilder sbSql = new StringBuilder();
				int GMouldRecordID = 0;
				bool isError = false;
				if (dtGroutingLineDetail.Rows.Count > 0)
				{
					// 更新成型线UpdateUserID
					//sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"]);
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					// 更新成型线UpdateUserID
					sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"] + " and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[0]["LineOPTimeStamp"],ParameterDirection.Input)
					};
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						return returnRows = -500;
					}
				}
				// 一模多产时，同一模具只操作一次。 add by chenxy 2018-10-29
				List<int> mouldIDs = new List<int>();
				for (int i = 0; i < dtGroutingLineDetail.Rows.Count; i++)
				{
					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GMouldRecord_ID.nextval from dual");
					GMouldRecordID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));//变更履历
					sbSql.Clear();
					// 1.插入变更履历
					sbSql.Append("insert into TP_PC_GMouldRecord");
					sbSql.Append("(GMouldRecordID,");
					sbSql.Append("GroutingLineID,GroutingLineDetailID,GoodsID,");
					sbSql.Append("GroutingMouldCode,MouldCode,GroutingCount,");
					sbSql.Append("GMouldRecordType,BeginDate,");
					sbSql.Append("Remarks,AccountID,CreateTime,");
					sbSql.Append("CreateUserID,UpdateTime,UpdateUserID");
					sbSql.Append(")");
					sbSql.Append("select :GMouldRecordID,");
					sbSql.Append("GroutingLineID,GroutingLineDetailID,GoodsID,");
					sbSql.Append("GroutingMouldCode,MouldCode,GroutingCount,");
					sbSql.Append(":GMouldRecordType,trunc(sysdate),");
					sbSql.Append(":Remarks,:AccountID,sysdate,");
					sbSql.Append(":CreateUserID,sysdate,:UpdateUserID");
					sbSql.Append(" from TP_PC_GroutingLineDetail where GroutingLineDetailID=:GroutingLineDetailID ");
					Paras = new OracleParameter[] {
						new OracleParameter(":GMouldRecordType",OracleDbType.Int32,
						   1,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"],ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							GMouldRecordID,ParameterDirection.Input)
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					//2.更新成型线模具状态
					sbSql.Clear();
					sbSql.Append("update TP_PC_GroutingLineDetail set GMouldStatus=2,LastGMouldRecordID=:LastGMouldRecordID, ");
					//sbSql.Append("UpdateUserID=:UpdateUserID,BeginUsedDate=trunc(sysdate),EndUsedDate=null where  GroutingLineDetailID=:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp");
					sbSql.Append("UpdateUserID=:UpdateUserID,EndUsedDate=null where  GroutingLineDetailID=:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						new OracleParameter(":LastGMouldRecordID",OracleDbType.Int32,
						   GMouldRecordID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[i]["OPTimeStamp"],ParameterDirection.Input)
					};
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						isError = true;  //即更新了，也可以用这个判断时间戳
						break;
					}
					returnRows += row;

					// 非条码模具
					if (dtGroutingLineDetail.Rows[i]["MouldID"] + "" == "")
					{
						continue;
					}
					// 一模多产时，同一模具只操作一次。（不能有多履历，会导致模具收发存等报表统计错误） add by chenxy 2018-10-29
					int mID = Convert.ToInt32(dtGroutingLineDetail.Rows[i]["MouldID"]);
					if (mouldIDs.Contains(mID))
					{
						continue;
					}
					mouldIDs.Add(mID);

					// 添加模具履历
					int mouldHistoryID = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select seq_pc_mouldhistory_id.nextval from dual "));

					string sqlString =
					"INSERT INTO tp_pc_mouldchangehistory\n" +
					"  (CHANGEID\n" +
					"  ,MOULDID\n" +
					"  ,MOULDCODE\n" +
					"  ,MOULDBARCODE\n" +
					"  ,GOODSID\n" +
					"  ,GOODSCODE\n" +
					"  ,OPERATIONTYPE\n" +
					"  ,GroutingLineDetailID\n" +
					"  ,MOULDSTATUS\n" +
					"  ,MOULDSTATUSAFTER\n" +
					"  ,GROUTINGNUM\n" +
					"  ,REMARKS\n" +
					"  ,CHANGEFLAG\n" +
					"  ,ACCOUNTID\n" +
					"  ,CREATEUSERID)\n" +
					"  SELECT :changeID\n" +
					"        ,:mouldid\n" +
					"        ,:MOULDCODE\n" +
					"        ,m.mouldbarcode\n" +
					"        ,m.goodsid\n" +
					"        ,m.goodscode\n" +
					"        ,-3 OPERATIONTYPE\n" +
					"        ,m.GroutingLineDetailID\n" +
					"        ,m.mouldstatus\n" +
					"        ,m.mouldstatus\n" +
					"        ,m.groutingnum\n" +
					"        ,:REMARKS\n" +
					"        ,'0' CHANGEFLAG\n" +
					"        ,:ACCOUNTID\n" +
					"        ,:USERID\n" +
					"    FROM tp_pc_mould m\n" +
					"   WHERE m.mouldid = :mouldid";
					OracleParameter[] paras = new OracleParameter[]
					{
						new OracleParameter(":changeID", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":MouldID", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
						new OracleParameter(":MOULDCODE", OracleDbType.Varchar2,
							dtGroutingLineDetail.Rows[i]["MOULDCODE"], ParameterDirection.Input),
						new OracleParameter(":REMARKS", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"], ParameterDirection.Input),
						new OracleParameter(":ACCOUNTID", OracleDbType.Int32,
							user.AccountID, ParameterDirection.Input),
						new OracleParameter(":USERID", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);

					// 修改模具状态
					sqlString = "UPDATE tp_pc_mould m\n" +
					"   SET m.RepairFlag      = '1'\n" +
					"      ,m.updateuserid        = :userid\n" +
					"      ,m.lastchangehistoryid = :changeid\n" +
					" WHERE m.mouldid = :mouldid";

					paras = new OracleParameter[]
					{
						new OracleParameter(":changeid", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":userid", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
						new OracleParameter(":mouldid", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);

				}
				//更新明细信息
				if (isError)
				{
					returnRows = -500;
					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 returnRows;
		}

		/// <summary>
		/// 维修结束
		/// </summary>
		/// <param name="dtGroutingLineDetail">明细实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 
		/// </remarks>
		public static int RepairEndGroutingLineDetail(DataTable dtGroutingLineDetail, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				OracleParameter[] Paras = null;
				StringBuilder sbSql = new StringBuilder();
				bool isError = false;
				if (dtGroutingLineDetail.Rows.Count > 0)
				{
					// 更新成型线UpdateUserID
					//sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"]);
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					// 更新成型线UpdateUserID
					sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"] + " and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[0]["LineOPTimeStamp"],ParameterDirection.Input)
					};
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						return returnRows = -500;
					}
				}

				// 一模多产时，同一模具只操作一次。 add by chenxy 2018-10-29
				List<int> mouldIDs = new List<int>();
				for (int i = 0; i < dtGroutingLineDetail.Rows.Count; i++)
				{
					sbSql.Clear();
					//1查出注浆明细最后变更履历ID，进行更新
					sbSql.Append("select nvl(LastGMouldRecordID,0) as LastGMouldRecordID  from TP_PC_GroutingLineDetail where GroutingLineDetailID=:GroutingLineDetailID");
					Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input)
					};
					DataSet dsInfo = oracleTrConn.GetSqlResultToDs(sbSql.ToString(), Paras);
					int? LastGMouldRecordID = null;
					if (dsInfo != null && dsInfo.Tables[0].Rows.Count > 0)
					{
						LastGMouldRecordID = Convert.ToInt32(dsInfo.Tables[0].Rows[0]["LastGMouldRecordID"]);
					}

					sbSql.Clear();
					sbSql.Append("Update TP_PC_GMouldRecord set EndDate=trunc(sysdate),Remarks=:Remarks,UpdateUserID=:UpdateUserID where GMouldRecordID=:GMouldRecordID");
					Paras = new OracleParameter[] {
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"],ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							LastGMouldRecordID,ParameterDirection.Input)
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

					//2.更新成型线模具状态
					sbSql.Clear();
					sbSql.Append("update TP_PC_GroutingLineDetail set GMouldStatus=1,");
					sbSql.Append("UpdateUserID=:UpdateUserID where  GroutingLineDetailID=:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp and GMouldStatus=2");
					Paras = new OracleParameter[] {
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[i]["OPTimeStamp"],ParameterDirection.Input)
					};
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						isError = true;  //即更新了，也可以用这个判断时间戳
						break;
					}
					returnRows += row;

					// 非条码模具
					if (dtGroutingLineDetail.Rows[i]["MouldID"] + "" == "")
					{
						continue;
					}
					// 一模多产时，同一模具只操作一次。（不能有多履历，会导致模具收发存等报表统计错误） add by chenxy 2018-10-29
					int mID = Convert.ToInt32(dtGroutingLineDetail.Rows[i]["MouldID"]);
					if (mouldIDs.Contains(mID))
					{
						continue;
					}
					mouldIDs.Add(mID);

					// 添加模具履历
					int mouldHistoryID = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select seq_pc_mouldhistory_id.nextval from dual "));

					string sqlString =
					"INSERT INTO tp_pc_mouldchangehistory\n" +
					"  (CHANGEID\n" +
					"  ,MOULDID\n" +
					"  ,MOULDCODE\n" +
					"  ,MOULDBARCODE\n" +
					"  ,GOODSID\n" +
					"  ,GOODSCODE\n" +
					"  ,OPERATIONTYPE\n" +
					"  ,GroutingLineDetailID\n" +
					"  ,MOULDSTATUS\n" +
					"  ,MOULDSTATUSAFTER\n" +
					"  ,GROUTINGNUM\n" +
					"  ,REMARKS\n" +
					"  ,CHANGEFLAG\n" +
					"  ,ACCOUNTID\n" +
					"  ,CREATEUSERID)\n" +
					"  SELECT :changeID\n" +
					"        ,:mouldid\n" +
					"        ,:MOULDCODE\n" +
					"        ,m.mouldbarcode\n" +
					"        ,m.goodsid\n" +
					"        ,m.goodscode\n" +
					"        ,-4 OPERATIONTYPE\n" +
					"        ,m.GroutingLineDetailID\n" +
					"        ,m.mouldstatus\n" +
					"        ,m.mouldstatus\n" +
					"        ,m.groutingnum\n" +
					"        ,:REMARKS\n" +
					"        ,'0' CHANGEFLAG\n" +
					"        ,:ACCOUNTID\n" +
					"        ,:USERID\n" +
					"    FROM tp_pc_mould m\n" +
					"   WHERE m.mouldid = :mouldid";
					OracleParameter[] paras = new OracleParameter[]
					{
						new OracleParameter(":changeID", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":MouldID", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
						new OracleParameter(":MOULDCODE", OracleDbType.Varchar2,
							dtGroutingLineDetail.Rows[i]["MOULDCODE"], ParameterDirection.Input),
						new OracleParameter(":REMARKS", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"], ParameterDirection.Input),
						new OracleParameter(":ACCOUNTID", OracleDbType.Int32,
							user.AccountID, ParameterDirection.Input),
						new OracleParameter(":USERID", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);

					// 修改模具状态
					sqlString = "UPDATE tp_pc_mould m\n" +
					"   SET m.RepairFlag      = '0'\n" +
					"      ,m.updateuserid        = :userid\n" +
					"      ,m.lastchangehistoryid = :changeid\n" +
					" WHERE m.mouldid = :mouldid";

					paras = new OracleParameter[]
					{
						new OracleParameter(":changeid", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":userid", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
						new OracleParameter(":mouldid", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);
				}
				//更新明细信息
				if (isError)
				{
					returnRows = -500;
					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 returnRows;
		}

		/// <summary>
		/// 换模开始 
		/// </summary>
		/// <param name="dtGroutingLineDetail">明细实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 
		/// </remarks>
		public static int ChangeGMouldStartGroutingLineDetail(DataTable dtGroutingLineDetail, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				OracleParameter[] Paras = null;
				StringBuilder sbSql = new StringBuilder();
				int GMouldRecordID = 0;
				bool isError = false;
				if (dtGroutingLineDetail.Rows.Count > 0)
				{
					// 更新成型线UpdateUserID
					//sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"]);
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					// 更新成型线UpdateUserID
					sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"] + " and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[0]["LineOPTimeStamp"],ParameterDirection.Input)
					};
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						return returnRows = -500;
					}
				}

				// 一模多产时，同一模具只操作一次。 add by chenxy 2018-10-29
				List<int> mouldIDs = new List<int>();
				for (int i = 0; i < dtGroutingLineDetail.Rows.Count; i++)
				{
					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GMouldRecord_ID.nextval from dual");
					GMouldRecordID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));//变更履历
					sbSql.Clear();
					// 1.插入变更履历
					sbSql.Append("insert into TP_PC_GMouldRecord");
					sbSql.Append("(GMouldRecordID,");
					sbSql.Append("GroutingLineID,GroutingLineDetailID,GoodsID,");
					sbSql.Append("GroutingMouldCode,MouldCode,GroutingCount,");
					sbSql.Append("GMouldRecordType,BeginDate,");
					sbSql.Append("Remarks,AccountID,CreateTime,");
					sbSql.Append("CreateUserID,UpdateTime,UpdateUserID");
					sbSql.Append(")");
					sbSql.Append("select :GMouldRecordID,");
					sbSql.Append("GroutingLineID,GroutingLineDetailID,GoodsID,");
					sbSql.Append("GroutingMouldCode,MouldCode,GroutingCount,");
					sbSql.Append(":GMouldRecordType,trunc(sysdate),");
					sbSql.Append(":Remarks,:AccountID,sysdate,");
					sbSql.Append(":CreateUserID,sysdate,:UpdateUserID");
					sbSql.Append(" from TP_PC_GroutingLineDetail where GroutingLineDetailID=:GroutingLineDetailID ");
					Paras = new OracleParameter[] {
						new OracleParameter(":GMouldRecordType",OracleDbType.Int32,
						   3,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"],ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							GMouldRecordID,ParameterDirection.Input)
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					//2.更新成型线模具状态
					sbSql.Clear();
					sbSql.Append("update TP_PC_GroutingLineDetail set GMouldStatus=3,LastGMouldRecordID=:LastGMouldRecordID, MouldID = null,MouldOutputNo=null, ");
					sbSql.Append("UpdateUserID=:UpdateUserID,EndUsedDate=trunc(sysdate) where  GroutingLineDetailID=:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						new OracleParameter(":LastGMouldRecordID",OracleDbType.Int32,
						   GMouldRecordID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[i]["OPTimeStamp"],ParameterDirection.Input)
					};
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						isError = true;  //即更新了，也可以用这个判断时间戳
						break;
					}
					returnRows += row;

					// 非条码模具
					if (dtGroutingLineDetail.Rows[i]["MouldID"] + "" == "")
					{
						continue;
					}
					// 一模多产时，同一模具只操作一次。（不能有多履历，会导致模具收发存等报表统计错误） add by chenxy 2018-10-29
					int mID = Convert.ToInt32(dtGroutingLineDetail.Rows[i]["MouldID"]);
					//object mOutputNo = dtGroutingLineDetail.Rows[i]["MouldOutputNo"];
					//if (mOutputNo != null && mOutputNo != DBNull.Value)
					//{
					//    string sql = "UPDATE tp_pc_mouldoutput m\n" +
					//    "   SET m.GroutingLineDetailID = null\n" +
					//    " WHERE m.mouldid = :mouldid and m.OutputNo=:OutputNo";

					//    OracleParameter[] oparas = new OracleParameter[]
					//    {
					//        new OracleParameter(":OutputNo", OracleDbType.Int32,
					//            mOutputNo, ParameterDirection.Input),
					//        new OracleParameter(":mouldid", OracleDbType.Int32,
					//            mID, ParameterDirection.Input),
					//    };
					//    row += oracleTrConn.ExecuteNonQuery(sql, oparas);
					//}
					if (mouldIDs.Contains(mID))
					{
						continue;
					}
					mouldIDs.Add(mID);
					object mOutputNo = dtGroutingLineDetail.Rows[i]["MouldOutputNo"];
					if (mOutputNo != null && mOutputNo != DBNull.Value && mOutputNo + "" != "0")
					{
						string sql = "UPDATE tp_pc_mouldoutput m\n" +
						"   SET m.GroutingLineDetailID = null\n" +
						" WHERE m.mouldid = :mouldid\n";
						//" and m.OutputNo=:OutputNo";

						OracleParameter[] oparas = new OracleParameter[]
						{
                            //new OracleParameter(":OutputNo", OracleDbType.Int32,
                            //    mOutputNo, ParameterDirection.Input),
                            new OracleParameter(":mouldid", OracleDbType.Int32,
								mID, ParameterDirection.Input),
						};
						row += oracleTrConn.ExecuteNonQuery(sql, oparas);
					}
					// 添加模具履历
					int mouldHistoryID = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select seq_pc_mouldhistory_id.nextval from dual "));

					string sqlString =
					"INSERT INTO tp_pc_mouldchangehistory\n" +
					"  (CHANGEID\n" +
					"  ,MOULDID\n" +
					"  ,MOULDCODE\n" +
					"  ,MOULDBARCODE\n" +
					"  ,GOODSID\n" +
					"  ,GOODSCODE\n" +
					"  ,OPERATIONTYPE\n" +
					"  ,GroutingLineDetailID\n" +
					"  ,MOULDSTATUS\n" +
					"  ,MOULDSTATUSAFTER\n" +
					"  ,GROUTINGNUM\n" +
					"  ,REMARKS\n" +
					"  ,CHANGEFLAG\n" +
					"  ,ScrapReason\n" +
					"  ,ScrapResponsibility\n" +
					"  ,ACCOUNTID\n" +
					"  ,CREATEUSERID)\n" +
					"  SELECT :changeID\n" +
					"        ,:MouldID\n" +
					"        ,:MOULDCODE\n" +
					"        ,m.mouldbarcode\n" +
					"        ,m.goodsid\n" +
					"        ,m.goodscode\n" +
					"        ,decode(:mouldstatus, 1, 7, 3, 8, 4, 9) OPERATIONTYPE\n" +
					"        ,m.GroutingLineDetailID\n" +
					"        ,m.mouldstatus\n" +
					"        ,:mouldstatus\n" +
					"        ,m.groutingnum\n" +
					"        ,:REMARKS\n" +
					"        ,decode(:mouldstatus, 1, '1', 3, '0', 4, '0') CHANGEFLAG\n" +
					"  ,:ScrapReason\n" +
					"  ,:ScrapResponsibility\n" +
					"        ,:ACCOUNTID\n" +
					"        ,:USERID\n" +
					"    FROM tp_pc_mould m\n" +
					"   WHERE m.mouldid = :MouldID";
					OracleParameter[] paras = new OracleParameter[]
					{
						new OracleParameter(":mouldstatus", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["mouldstatus"], ParameterDirection.Input),
						new OracleParameter(":ScrapReason", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["ScrapReason"], ParameterDirection.Input),
						new OracleParameter(":ScrapResponsibility", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["ScrapResponsibility"], ParameterDirection.Input),
						new OracleParameter(":changeID", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":MouldID", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
						new OracleParameter(":MOULDCODE", OracleDbType.Varchar2,
							dtGroutingLineDetail.Rows[i]["MOULDCODE"], ParameterDirection.Input),
						new OracleParameter(":REMARKS", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"], ParameterDirection.Input),
						new OracleParameter(":ACCOUNTID", OracleDbType.Int32,
							user.AccountID, ParameterDirection.Input),
						new OracleParameter(":USERID", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);

					// 修改模具状态
					sqlString = "UPDATE tp_pc_mould m\n" +
					"   SET m.premouldstatus      = m.mouldstatus\n" +
					"      ,m.mouldstatus         = :mouldstatus\n" +
					"      ,m.updateuserid        = :userid\n" +
					"      ,m.lastchangehistoryid = :changeid\n" +
					"      ,m.GroutingLineDetailID = null\n" +

					"      ,m.scrapdate           = decode(:mouldstatus,4,SYSDATE, null)\n" +
					"      ,m.scrapuserid         = decode(:mouldstatus,4,:userid, null)\n" +
					"      ,m.scrapusercode       = decode(:mouldstatus,4,:usercode, null)\n" +
					"      ,m.ScrapReason = :ScrapReason\n" +
					"      ,m.ScrapResponsibility = :ScrapResponsibility\n" +
					" WHERE m.mouldid = :mouldid";

					paras = new OracleParameter[]
					{
						new OracleParameter(":mouldstatus", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["mouldstatus"], ParameterDirection.Input),
						new OracleParameter(":ScrapReason", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["ScrapReason"], ParameterDirection.Input),
						new OracleParameter(":ScrapResponsibility", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["ScrapResponsibility"], ParameterDirection.Input),
						new OracleParameter(":changeid", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":userid", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
						new OracleParameter(":usercode", OracleDbType.NVarchar2,
							user.UserCode, ParameterDirection.Input),
						new OracleParameter(":mouldid", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);
				}
				//更新明细信息
				if (isError)
				{
					returnRows = -500;
					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 returnRows;
		}

		/// <summary>
		/// 换模结束
		/// </summary>
		/// <param name="dtGroutingLineDetail">明细实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 
		/// </remarks>
		public static ServiceResultEntity ChangeGMouldEndGroutingLineDetail(DataTable dtGroutingLineDetail, SUserInfo user)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();

				// 验证模具条码
				DataRow[] moulds = dtGroutingLineDetail.Select("MouldID is not null");
				if (moulds != null && moulds.Length > 0)
				{
					List<string> ids = new List<string>();
					foreach (DataRow item in moulds)
					{
						string id = item["MouldID"].ToString();
						if (!ids.Contains(id))
						{
							ids.Add(id);
						}
					}
					string idswhere = string.Join(",", ids);
					string sql = "select mouldid from tp_pc_mould m where m.mouldid in (" + idswhere + ") for update";
					oracleTrConn.GetSqlResultToDt(sql);

					sql = "select mouldbarcode from tp_pc_mould m where m.mouldstatus not in (1,3) and m.mouldid in (" + idswhere + ")";
					DataTable dt = oracleTrConn.GetSqlResultToDt(sql);
					if (dt != null && dt.Rows.Count > 0)
					{
						ids.Clear();
						foreach (DataRow item in dt.Rows)
						{
							ids.Add(item["mouldbarcode"].ToString());
						}

						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = -100;
						sre.Message = "以下模具的状态不是【在库】或【待产】，不能添加到成型线。" + System.Environment.NewLine
							+ string.Join(",", ids);
						return sre;
					}
				}

				OracleParameter[] Paras = null;
				StringBuilder sbSql = new StringBuilder();
				bool isError = false;
				if (dtGroutingLineDetail.Rows.Count > 0)
				{
					// 更新成型线UpdateUserID
					//sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"]);
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					// 更新成型线UpdateUserID
					sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"] + " and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[0]["LineOPTimeStamp"],ParameterDirection.Input)
					};
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = -500;
						return sre;
					}
				}
				// 一模多产时，同一模具只操作一次。 add by chenxy 2018-10-29
				List<int> mouldIDs = new List<int>();
				int? GroutingLineDetailID = null;
				for (int i = 0; i < dtGroutingLineDetail.Rows.Count; i++)
				{
					sbSql.Clear();

					sbSql.Append("update TP_PC_GroutingLineDetail set valueflag='0', UpdateUserID=:UpdateUserID where GroutingLineDetailID=:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp and valueflag = '1' and GMouldStatus=3");
					Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[i]["OPTimeStamp"],ParameterDirection.Input)
					};
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						isError = true;  //即更新了，也可以用这个判断时间戳
						break;
					}
					returnRows += row;

					//1查出注浆明细最后变更履历ID，进行更新
					sbSql.Clear();
					sbSql.Append("select nvl(LastGMouldRecordID,0) as LastGMouldRecordID from TP_PC_GroutingLineDetail where GroutingLineDetailID=:GroutingLineDetailID");
					Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input)
					};
					DataSet dsInfo = oracleTrConn.GetSqlResultToDs(sbSql.ToString(), Paras);
					int? LastGMouldRecordID = null;
					if (dsInfo != null && dsInfo.Tables[0].Rows.Count > 0)
					{
						LastGMouldRecordID = Convert.ToInt32(dsInfo.Tables[0].Rows[0]["LastGMouldRecordID"]);
					}

					// 插入新明细
					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GroutingLineDetail_ID.nextval from dual");
					GroutingLineDetailID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
					if (dtGroutingLineDetail.Rows[i]["MouldID"] + "" == "")
					{
						dtGroutingLineDetail.Rows[i]["MouldSource"] = "0";
						dtGroutingLineDetail.Rows[i]["MouldCode"] = System.Guid.NewGuid().ToString().ToUpper();
					}
					object groutingCount = dtGroutingLineDetail.Rows[i]["GroutingCount"];
					//string guid = System.Guid.NewGuid().ToString().ToUpper();
					sbSql.Clear();
					sbSql.Append("insert into TP_PC_GroutingLineDetail");
					sbSql.Append("(");
					sbSql.Append("GroutingLineDetailID");
					sbSql.Append(",GroutingLineID");
					sbSql.Append(",GroutingMouldCode");
					sbSql.Append(",MouldSource");
					sbSql.Append(",MouldID");
					sbSql.Append(",MouldCode");
					sbSql.Append(",MouldOutputNo");
					sbSql.Append(",GoodsID");
					sbSql.Append(",StandardGroutingCount");
					sbSql.Append(",GroutingCount");
					sbSql.Append(",GMouldStatus");
					sbSql.Append(",BeginUsedDate");
					sbSql.Append(",EndUsedDate");
					sbSql.Append(",LastGMouldRecordID");
					sbSql.Append(",Remarks");
					sbSql.Append(",AccountID");
					sbSql.Append(",ValueFlag");
					sbSql.Append(",CreateUserID");
					sbSql.Append(",UpdateUserID");
					sbSql.Append(") ");
					//sbSql.Append("select");
					sbSql.Append("Values (");
					sbSql.Append(" :GroutingLineDetailIDNew");
					sbSql.Append(",:GroutingLineID");
					sbSql.Append(",:GroutingMouldCode");
					sbSql.Append(",:MouldSource");
					sbSql.Append(",:MouldID");
					sbSql.Append(",:MouldCode");
					sbSql.Append(",:MouldOutputNo");
					sbSql.Append(",:GoodsID");
					sbSql.Append(",:StandardGroutingCount");
					sbSql.Append(",:GroutingCount");
					sbSql.Append(",1");
					sbSql.Append(",trunc(sysdate)");
					sbSql.Append(",null");
					sbSql.Append(",:LastGMouldRecordID");
					sbSql.Append(",:Remarks");
					sbSql.Append(",:AccountID");
					sbSql.Append(",1");
					sbSql.Append(",:CreateUserID");
					sbSql.Append(",:UpdateUserID");
					sbSql.Append(" )");
					//sbSql.Append(" from TP_PC_GroutingLineDetail where GroutingLineDetailID=:GroutingLineDetailID");
					Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailIDNew",OracleDbType.Int32,
							GroutingLineDetailID,ParameterDirection.Input),
                        //new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
                        //    dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
                        new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineID"],ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["GroutingMouldCode"],ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GoodsID"],ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":MouldSource",OracleDbType.Char,
							dtGroutingLineDetail.Rows[i]["MouldSource"],ParameterDirection.Input),
						new OracleParameter(":MouldID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"],ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["MouldCode"],ParameterDirection.Input),
						new OracleParameter(":MouldOutputNo",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldOutputNo"],ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.Varchar2,
							dtGroutingLineDetail.Rows[i]["RreasonRemarks"],ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":StandardGroutingCount",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["StandardGroutingCount"],ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Int32,
							((groutingCount == null || groutingCount == DBNull.Value) ? 0 : groutingCount),ParameterDirection.Input),
						new OracleParameter(":LastGMouldRecordID",OracleDbType.Int32,
                            //dtGroutingLineDetail.Rows[i]["LastGMouldRecordID"],ParameterDirection.Input),
                            LastGMouldRecordID,ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

					sbSql.Clear();
					sbSql.Append("Update TP_PC_GMouldRecord set EndDate=trunc(sysdate),Remarks=:Remarks,UpdateUserID=:UpdateUserID,ChangedMouldCode=:ChangedMouldCode, ChangedDetailID=:GroutingLineDetailID where GMouldRecordID=:GMouldRecordID");
					Paras = new OracleParameter[] {
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"],ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							LastGMouldRecordID,ParameterDirection.Input),
						new OracleParameter(":ChangedMouldCode",OracleDbType.Varchar2,
							dtGroutingLineDetail.Rows[i]["MouldCode"],ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							GroutingLineDetailID,ParameterDirection.Input)
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

					// 非条码模具
					if (dtGroutingLineDetail.Rows[i]["MouldID"] + "" == "")
					{
						continue;
					}
					// 一模多产时，同一模具只操作一次。（不能有多履历，会导致模具收发存等报表统计错误） add by chenxy 2018-10-29
					int mID = Convert.ToInt32(dtGroutingLineDetail.Rows[i]["MouldID"]);
					object mOutputNo = dtGroutingLineDetail.Rows[i]["MouldOutputNo"];
					if (mOutputNo != null && mOutputNo != DBNull.Value)
					{
						string sql = "UPDATE tp_pc_mouldoutput m\n" +
						"   SET m.GroutingLineDetailID = :GroutingLineDetailID\n" +
						" WHERE m.mouldid = :mouldid and m.OutputNo=:OutputNo";

						OracleParameter[] oparas = new OracleParameter[]
						{
							new OracleParameter(":OutputNo", OracleDbType.Int32,
								mOutputNo, ParameterDirection.Input),
							new OracleParameter(":mouldid", OracleDbType.Int32,
								mID, ParameterDirection.Input),
							new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
								GroutingLineDetailID, ParameterDirection.Input),
						};
						returnRows += oracleTrConn.ExecuteNonQuery(sql, oparas);
					}
					if (mouldIDs.Contains(mID))
					{
						continue;
					}
					mouldIDs.Add(mID);

					// 添加模具履历
					int mouldHistoryID = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select seq_pc_mouldhistory_id.nextval from dual "));

					string sqlString =
					"INSERT INTO tp_pc_mouldchangehistory\n" +
					"  (CHANGEID\n" +
					"  ,MOULDID\n" +
					"  ,MOULDCODE\n" +
					"  ,MOULDBARCODE\n" +
					"  ,GOODSID\n" +
					"  ,GOODSCODE\n" +
					"  ,OPERATIONTYPE\n" +
					"  ,GroutingLineDetailID\n" +
					"  ,MOULDSTATUS\n" +
					"  ,MOULDSTATUSAFTER\n" +
					"  ,GROUTINGNUM\n" +
					"  ,REMARKS\n" +
					"  ,CHANGEFLAG\n" +
					"  ,ACCOUNTID\n" +
					"  ,CREATEUSERID)\n" +
					"  SELECT :changeID\n" +
					"        ,:mouldid\n" +
					"        ,:MOULDCODE\n" +
					"        ,m.mouldbarcode\n" +
					"        ,m.goodsid\n" +
					"        ,m.goodscode\n" +
					"        ,decode(m.mouldstatus, 1, 6, 3, 10) OPERATIONTYPE\n" +
					"        ,:GroutingLineDetailID\n" +
					"        ,m.mouldstatus\n" +
					"        ,2\n" +
					"        ,m.groutingnum\n" +
					"        ,:REMARKS\n" +
					"        ,decode(m.mouldstatus, 1, '2', 3, '0') CHANGEFLAG\n" +
					"        ,:ACCOUNTID\n" +
					"        ,:USERID\n" +
					"    FROM tp_pc_mould m\n" +
					"   WHERE m.mouldid = :mouldid";
					OracleParameter[] paras = new OracleParameter[]
					{
						new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
							GroutingLineDetailID, ParameterDirection.Input),
						new OracleParameter(":changeID", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":MouldID", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
						new OracleParameter(":MOULDCODE", OracleDbType.Varchar2,
							dtGroutingLineDetail.Rows[i]["MOULDCODE"], ParameterDirection.Input),
						new OracleParameter(":REMARKS", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"], ParameterDirection.Input),
						new OracleParameter(":ACCOUNTID", OracleDbType.Int32,
							user.AccountID, ParameterDirection.Input),
						new OracleParameter(":USERID", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);

					// 修改模具状态
					sqlString = "UPDATE tp_pc_mould m\n" +
					"   SET m.premouldstatus      = m.mouldstatus\n" +
					"      ,m.mouldstatus         = :mouldstatus\n" +
					"      ,m.updateuserid        = :userid\n" +
					"      ,m.lastchangehistoryid = :changeid\n" +
					"      ,m.GroutingLineDetailID = :GroutingLineDetailID\n" +
					" WHERE m.mouldid = :mouldid";

					paras = new OracleParameter[]
					{
						new OracleParameter(":mouldstatus", OracleDbType.Int32,
							(int)Constant.MouldStatus.OnLine, ParameterDirection.Input),
						new OracleParameter(":changeid", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":userid", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
						new OracleParameter(":mouldid", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
							GroutingLineDetailID, ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);
				}

				// 庆祥要求，整线换模或变产后，成型线开始使用日期是成型线中模具最小开始使用日期。
				string sqlUpdate = "update TP_PC_GROUTINGLINE l " +
							"   set l.beginuseddate =" +
							"       (select min(ld.beginuseddate)" +
							"          from TP_PC_GROUTINGLINEDETAIL ld" +
							"         where ld.groutinglineid = l.groutinglineid" +
							"           and ld.valueflag = '1')" +
							" where l.groutinglineid = " + dtGroutingLineDetail.Rows[0]["GroutingLineID"];
				oracleTrConn.ExecuteNonQuery(sqlUpdate, null);

				//更新明细信息
				if (isError)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = -500;
					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="dtGroutingLineDetail">明细实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 
		/// </remarks>
		public static int UpdateLineStartGroutingLineDetail(DataTable dtGroutingLineDetail, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				OracleParameter[] Paras = null;
				StringBuilder sbSql = new StringBuilder();
				int GMouldRecordID = 0;
				bool isError = false;
				if (dtGroutingLineDetail.Rows.Count > 0)
				{
					// 更新成型线UpdateUserID
					//sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"]);
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					// 更新成型线UpdateUserID
					sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"] + " and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[0]["LineOPTimeStamp"],ParameterDirection.Input)
					};
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						return returnRows = -500;
					}
				}
				// 一模多产时，同一模具只操作一次。 add by chenxy 2018-10-29
				List<int> mouldIDs = new List<int>();
				for (int i = 0; i < dtGroutingLineDetail.Rows.Count; i++)
				{
					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GMouldRecord_ID.nextval from dual");
					GMouldRecordID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));//变更履历
					sbSql.Clear();
					// 1.插入变更履历
					sbSql.Append("insert into TP_PC_GMouldRecord");
					sbSql.Append("(GMouldRecordID,");
					sbSql.Append("GroutingLineID,GroutingLineDetailID,GoodsID,");
					sbSql.Append("GroutingMouldCode,MouldCode,GroutingCount,");
					sbSql.Append("GMouldRecordType,BeginDate,");
					sbSql.Append("Remarks,AccountID,CreateTime,");
					sbSql.Append("CreateUserID,UpdateTime,UpdateUserID");
					sbSql.Append(")");
					sbSql.Append("select :GMouldRecordID,");
					sbSql.Append("GroutingLineID,GroutingLineDetailID,GoodsID,");
					sbSql.Append("GroutingMouldCode,MouldCode,GroutingCount,");
					sbSql.Append(":GMouldRecordType,trunc(sysdate),");
					sbSql.Append(":Remarks,:AccountID,sysdate,");
					sbSql.Append(":CreateUserID,sysdate,:UpdateUserID");
					sbSql.Append(" from TP_PC_GroutingLineDetail where GroutingLineDetailID=:GroutingLineDetailID ");
					Paras = new OracleParameter[] {
						new OracleParameter(":GMouldRecordType",OracleDbType.Int32,
						   5,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"],ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							GMouldRecordID,ParameterDirection.Input)
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					//2.更新成型线模具状态
					sbSql.Clear();
					sbSql.Append("update TP_PC_GroutingLineDetail set GMouldStatus=4,LastGMouldRecordID=:LastGMouldRecordID, MouldID = null,MouldOutputNo=null, ");
					sbSql.Append("UpdateUserID=:UpdateUserID,EndUsedDate=trunc(sysdate) where  GroutingLineDetailID=:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						new OracleParameter(":LastGMouldRecordID",OracleDbType.Int32,
						   GMouldRecordID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[i]["OPTimeStamp"],ParameterDirection.Input)
					};
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						isError = true;  //即更新了，也可以用这个判断时间戳
						break;
					}
					returnRows += row;

					// 非条码模具
					if (dtGroutingLineDetail.Rows[i]["MouldID"] + "" == "")
					{
						continue;
					}
					// 一模多产时，同一模具只操作一次。（不能有多履历，会导致模具收发存等报表统计错误） add by chenxy 2018-10-29
					int mID = Convert.ToInt32(dtGroutingLineDetail.Rows[i]["MouldID"]);
					//object mOutputNo = dtGroutingLineDetail.Rows[i]["MouldOutputNo"];
					//if (mOutputNo != null && mOutputNo != DBNull.Value)
					//{
					//    string sql = "UPDATE tp_pc_mouldoutput m\n" +
					//    "   SET m.GroutingLineDetailID = null\n" +
					//    " WHERE m.mouldid = :mouldid and m.OutputNo=:OutputNo";

					//    OracleParameter[] oparas = new OracleParameter[]
					//    {
					//        new OracleParameter(":OutputNo", OracleDbType.Int32,
					//            mOutputNo, ParameterDirection.Input),
					//        new OracleParameter(":mouldid", OracleDbType.Int32,
					//            mID, ParameterDirection.Input),
					//    };
					//    row += oracleTrConn.ExecuteNonQuery(sql, oparas);
					//}
					if (mouldIDs.Contains(mID))
					{
						continue;
					}
					mouldIDs.Add(mID);
					object mOutputNo = dtGroutingLineDetail.Rows[i]["MouldOutputNo"];
					if (mOutputNo != null && mOutputNo != DBNull.Value && mOutputNo + "" != "0")
					{
						string sql = "UPDATE tp_pc_mouldoutput m\n" +
						"   SET m.GroutingLineDetailID = null\n" +
						" WHERE m.mouldid = :mouldid\n";
						//" and m.OutputNo=:OutputNo";

						OracleParameter[] oparas = new OracleParameter[]
						{
                            //new OracleParameter(":OutputNo", OracleDbType.Int32,
                            //    mOutputNo, ParameterDirection.Input),
                            new OracleParameter(":mouldid", OracleDbType.Int32,
								mID, ParameterDirection.Input),
						};
						row += oracleTrConn.ExecuteNonQuery(sql, oparas);
					}
					// 添加模具履历
					int mouldHistoryID = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select seq_pc_mouldhistory_id.nextval from dual "));

					string sqlString =
					"INSERT INTO tp_pc_mouldchangehistory\n" +
					"  (CHANGEID\n" +
					"  ,MOULDID\n" +
					"  ,MOULDCODE\n" +
					"  ,MOULDBARCODE\n" +
					"  ,GOODSID\n" +
					"  ,GOODSCODE\n" +
					"  ,OPERATIONTYPE\n" +
					"  ,GroutingLineDetailID\n" +
					"  ,MOULDSTATUS\n" +
					"  ,MOULDSTATUSAFTER\n" +
					"  ,GROUTINGNUM\n" +
					"  ,REMARKS\n" +
					"  ,CHANGEFLAG\n" +
					"  ,ScrapReason\n" +
					"  ,ScrapResponsibility\n" +
					"  ,ACCOUNTID\n" +
					"  ,CREATEUSERID)\n" +
					"  SELECT :changeID\n" +
					"        ,:MouldID\n" +
					"        ,:MOULDCODE\n" +
					"        ,m.mouldbarcode\n" +
					"        ,m.goodsid\n" +
					"        ,m.goodscode\n" +
					"        ,decode(:mouldstatus, 1, 7, 3, 8, 4, 9) OPERATIONTYPE\n" +
					"        ,m.GroutingLineDetailID\n" +
					"        ,m.mouldstatus\n" +
					"        ,:mouldstatus\n" +
					"        ,m.groutingnum\n" +
					"        ,:REMARKS\n" +
					"        ,decode(:mouldstatus, 1, '1', 3, '0', 4, '0') CHANGEFLAG\n" +
					"  ,:ScrapReason\n" +
					"  ,:ScrapResponsibility\n" +
					"        ,:ACCOUNTID\n" +
					"        ,:USERID\n" +
					"    FROM tp_pc_mould m\n" +
					"   WHERE m.mouldid = :MouldID";
					OracleParameter[] paras = new OracleParameter[]
					{
						new OracleParameter(":mouldstatus", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["mouldstatus"], ParameterDirection.Input),
						new OracleParameter(":ScrapReason", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["ScrapReason"], ParameterDirection.Input),
						new OracleParameter(":ScrapResponsibility", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["ScrapResponsibility"], ParameterDirection.Input),
						new OracleParameter(":changeID", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":MouldID", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
						new OracleParameter(":MOULDCODE", OracleDbType.Varchar2,
							dtGroutingLineDetail.Rows[i]["MOULDCODE"], ParameterDirection.Input),
						new OracleParameter(":REMARKS", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"], ParameterDirection.Input),
						new OracleParameter(":ACCOUNTID", OracleDbType.Int32,
							user.AccountID, ParameterDirection.Input),
						new OracleParameter(":USERID", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);

					// 修改模具状态
					sqlString = "UPDATE tp_pc_mould m\n" +
					"   SET m.premouldstatus      = m.mouldstatus\n" +
					"      ,m.mouldstatus         = :mouldstatus\n" +
					"      ,m.updateuserid        = :userid\n" +
					"      ,m.lastchangehistoryid = :changeid\n" +
					"      ,m.GroutingLineDetailID = null\n" +

					"      ,m.scrapdate           = decode(:mouldstatus,4,SYSDATE, null)\n" +
					"      ,m.scrapuserid         = decode(:mouldstatus,4,:userid, null)\n" +
					"      ,m.scrapusercode       = decode(:mouldstatus,4,:usercode, null)\n" +
					"      ,m.ScrapReason = :ScrapReason\n" +
					"      ,m.ScrapResponsibility = :ScrapResponsibility\n" +
					" WHERE m.mouldid = :mouldid";

					paras = new OracleParameter[]
					{
						new OracleParameter(":mouldstatus", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["mouldstatus"], ParameterDirection.Input),
						new OracleParameter(":ScrapReason", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["ScrapReason"], ParameterDirection.Input),
						new OracleParameter(":ScrapResponsibility", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["ScrapResponsibility"], ParameterDirection.Input),
						new OracleParameter(":changeid", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":userid", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
						new OracleParameter(":usercode", OracleDbType.NVarchar2,
							user.UserCode, ParameterDirection.Input),
						new OracleParameter(":mouldid", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);
				}
				//更新明细信息
				if (isError)
				{
					returnRows = -500;
					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 returnRows;
		}

		/// <summary>
		/// 变产结束
		/// </summary>
		/// <param name="dtGroutingLineDetail">明细实体</param>
		/// <param name="goodsID">变产产品ID</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 
		/// </remarks>
		public static ServiceResultEntity UpdateLineEndGroutingLineDetail(DataTable dtGroutingLineDetail, int goodsID, SUserInfo user)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();

				// 验证模具条码
				DataRow[] moulds = dtGroutingLineDetail.Select("MouldID is not null");
				if (moulds != null && moulds.Length > 0)
				{
					List<string> ids = new List<string>();
					foreach (DataRow item in moulds)
					{
						string id = item["MouldID"].ToString();
						if (!ids.Contains(id))
						{
							ids.Add(id);
						}
					}
					string idswhere = string.Join(",", ids);
					string sql = "select mouldid from tp_pc_mould m where m.mouldid in (" + idswhere + ") for update";
					oracleTrConn.GetSqlResultToDt(sql);

					sql = "select mouldbarcode from tp_pc_mould m where m.mouldstatus not in (1,3) and m.mouldid in (" + idswhere + ")";
					DataTable dt = oracleTrConn.GetSqlResultToDt(sql);
					if (dt != null && dt.Rows.Count > 0)
					{
						ids.Clear();
						foreach (DataRow item in dt.Rows)
						{
							ids.Add(item["mouldbarcode"].ToString());
						}

						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = -100;
						sre.Message = "以下模具的状态不是【在库】或【待产】，不能添加到成型线。" + System.Environment.NewLine
							+ string.Join(",", ids);
						return sre;
					}
				}

				OracleParameter[] Paras = null;
				StringBuilder sbSql = new StringBuilder();
				bool isError = false;
				if (dtGroutingLineDetail.Rows.Count > 0)
				{
					// 更新成型线UpdateUserID
					//sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"]);
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					// 更新成型线UpdateUserID
					sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"] + " and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[0]["LineOPTimeStamp"],ParameterDirection.Input)
					};
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = -500;
						return sre;
					}
				}
				// 一模多产时，同一模具只操作一次。 add by chenxy 2018-10-29
				List<int> mouldIDs = new List<int>();
				int? GroutingLineDetailID = null;
				for (int i = 0; i < dtGroutingLineDetail.Rows.Count; i++)
				{
					sbSql.Clear();

					sbSql.Append("update TP_PC_GroutingLineDetail set valueflag='0', UpdateUserID=:UpdateUserID where GroutingLineDetailID=:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp and valueflag='1' and GMouldStatus=4");
					Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[i]["OPTimeStamp"],ParameterDirection.Input)
					};
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						isError = true;  //即更新了，也可以用这个判断时间戳
						break;
					}
					returnRows += row;

					//1查出注浆明细最后变更履历ID，进行更新
					sbSql.Clear();
					sbSql.Append("select nvl(LastGMouldRecordID,0) as LastGMouldRecordID from TP_PC_GroutingLineDetail where GroutingLineDetailID=:GroutingLineDetailID");
					Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input)
					};
					DataSet dsInfo = oracleTrConn.GetSqlResultToDs(sbSql.ToString(), Paras);
					int? LastGMouldRecordID = null;
					if (dsInfo != null && dsInfo.Tables[0].Rows.Count > 0)
					{
						LastGMouldRecordID = Convert.ToInt32(dsInfo.Tables[0].Rows[0]["LastGMouldRecordID"]);
					}

					// 插入新明细
					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GroutingLineDetail_ID.nextval from dual");
					GroutingLineDetailID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
					if (dtGroutingLineDetail.Rows[i]["MouldCode"] + "" == "")
					{
						dtGroutingLineDetail.Rows[i]["MouldCode"] = System.Guid.NewGuid().ToString().ToUpper();
					}
					//string guid = System.Guid.NewGuid().ToString().ToUpper();
					sbSql.Clear();
					sbSql.Append("insert into TP_PC_GroutingLineDetail");
					sbSql.Append("(");
					sbSql.Append("GroutingLineDetailID");
					sbSql.Append(",GroutingLineID");
					sbSql.Append(",GroutingMouldCode");
					sbSql.Append(",MouldSource");
					sbSql.Append(",MouldID");
					sbSql.Append(",MouldCode");
					sbSql.Append(",MouldOutputNo");
					sbSql.Append(",GoodsID");
					sbSql.Append(",StandardGroutingCount");
					sbSql.Append(",GroutingCount");
					sbSql.Append(",GMouldStatus");
					sbSql.Append(",BeginUsedDate");
					sbSql.Append(",EndUsedDate");
					sbSql.Append(",LastGMouldRecordID");
					sbSql.Append(",Remarks");
					sbSql.Append(",AccountID");
					sbSql.Append(",ValueFlag");
					sbSql.Append(",CreateUserID");
					sbSql.Append(",UpdateUserID");
					sbSql.Append(") ");
					//sbSql.Append("select");
					sbSql.Append("Values (");
					sbSql.Append(" :GroutingLineDetailIDNew");
					sbSql.Append(",:GroutingLineID");
					sbSql.Append(",:GroutingMouldCode");
					sbSql.Append(",:MouldSource");
					sbSql.Append(",:MouldID");
					sbSql.Append(",:MouldCode");
					sbSql.Append(",:MouldOutputNo");
					sbSql.Append(",:GoodsID");
					sbSql.Append(",:StandardGroutingCount");
					sbSql.Append(",:GroutingCount");
					sbSql.Append(",1");
					sbSql.Append(",trunc(sysdate)");
					sbSql.Append(",null");
					sbSql.Append(",:LastGMouldRecordID");
					sbSql.Append(",:Remarks");
					sbSql.Append(",:AccountID");
					sbSql.Append(",1");
					sbSql.Append(",:CreateUserID");
					sbSql.Append(",:UpdateUserID");
					sbSql.Append(" )");
					//sbSql.Append(" from TP_PC_GroutingLineDetail where GroutingLineDetailID=:GroutingLineDetailID");
					Paras = new OracleParameter[] {
						 new OracleParameter(":GroutingLineDetailIDNew",OracleDbType.Int32,
							GroutingLineDetailID,ParameterDirection.Input),
                        //new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
                        //    dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
                        new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineID"],ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["GroutingMouldCode"],ParameterDirection.Input),
                         //new OracleParameter(":GoodsID",OracleDbType.Int32,
                         //  goodsID,ParameterDirection.Input),
                        new OracleParameter(":GoodsID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GoodsID"],ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":MouldSource",OracleDbType.Char,
							dtGroutingLineDetail.Rows[i]["MouldSource"],ParameterDirection.Input),
						new OracleParameter(":MouldID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"],ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["MouldCode"],ParameterDirection.Input),
						new OracleParameter(":MouldOutputNo",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldOutputNo"],ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.Varchar2,
						   dtGroutingLineDetail.Rows[i]["RREASONRemarks"],ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						 new OracleParameter(":StandardGroutingCount",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["StandardGroutingCount"],ParameterDirection.Input),
						 new OracleParameter(":GroutingCount",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingCount"],ParameterDirection.Input),
						new OracleParameter(":LastGMouldRecordID",OracleDbType.Int32,
                            //dtGroutingLineDetail.Rows[i]["LastGMouldRecordID"],ParameterDirection.Input),
                            LastGMouldRecordID,ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

					sbSql.Clear();
					sbSql.Append("Update TP_PC_GMouldRecord set EndDate=trunc(sysdate),Remarks=:Remarks,UpdateUserID=:UpdateUserID,ChangedMouldCode=:ChangedMouldCode,ChangedGoodsID=:GoodsID,ChangedDetailID=:GroutingLineDetailID where GMouldRecordID=:GMouldRecordID");
					Paras = new OracleParameter[] {
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"],ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							LastGMouldRecordID,ParameterDirection.Input),
						new OracleParameter(":ChangedMouldCode",OracleDbType.Varchar2,
							dtGroutingLineDetail.Rows[i]["MouldCode"],ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GoodsID"],ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							GroutingLineDetailID,ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

					// 非条码模具
					if (dtGroutingLineDetail.Rows[i]["MouldID"] + "" == "")
					{
						continue;
					}
					// 一模多产时，同一模具只操作一次。（不能有多履历，会导致模具收发存等报表统计错误） add by chenxy 2018-10-29
					int mID = Convert.ToInt32(dtGroutingLineDetail.Rows[i]["MouldID"]);
					object mOutputNo = dtGroutingLineDetail.Rows[i]["MouldOutputNo"];
					if (mOutputNo != null && mOutputNo != DBNull.Value)
					{
						string sql = "UPDATE tp_pc_mouldoutput m\n" +
						"   SET m.GroutingLineDetailID = :GroutingLineDetailID\n" +
						" WHERE m.mouldid = :mouldid and m.OutputNo=:OutputNo";

						OracleParameter[] oparas = new OracleParameter[]
						{
							new OracleParameter(":OutputNo", OracleDbType.Int32,
								mOutputNo, ParameterDirection.Input),
							new OracleParameter(":mouldid", OracleDbType.Int32,
								mID, ParameterDirection.Input),
							new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
								GroutingLineDetailID, ParameterDirection.Input),
						};
						returnRows += oracleTrConn.ExecuteNonQuery(sql, oparas);
					}
					if (mouldIDs.Contains(mID))
					{
						continue;
					}
					mouldIDs.Add(mID);

					// 添加模具履历
					int mouldHistoryID = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select seq_pc_mouldhistory_id.nextval from dual "));

					string sqlString =
					"INSERT INTO tp_pc_mouldchangehistory\n" +
					"  (CHANGEID\n" +
					"  ,MOULDID\n" +
					"  ,MOULDCODE\n" +
					"  ,MOULDBARCODE\n" +
					"  ,GOODSID\n" +
					"  ,GOODSCODE\n" +
					"  ,OPERATIONTYPE\n" +
					"  ,GroutingLineDetailID\n" +
					"  ,MOULDSTATUS\n" +
					"  ,MOULDSTATUSAFTER\n" +
					"  ,GROUTINGNUM\n" +
					"  ,REMARKS\n" +
					"  ,CHANGEFLAG\n" +
					"  ,ACCOUNTID\n" +
					"  ,CREATEUSERID)\n" +
					"  SELECT :changeID\n" +
					"        ,:mouldid\n" +
					"        ,:MOULDCODE\n" +
					"        ,m.mouldbarcode\n" +
					"        ,m.goodsid\n" +
					"        ,m.goodscode\n" +
					"        ,decode(m.mouldstatus, 1, 6, 3, 10) OPERATIONTYPE\n" +
					"        ,:GroutingLineDetailID\n" +
					"        ,m.mouldstatus\n" +
					"        ,2\n" +
					"        ,m.groutingnum\n" +
					"        ,:REMARKS\n" +
					"        ,decode(m.mouldstatus, 1, '2', 3, '0') CHANGEFLAG\n" +
					"        ,:ACCOUNTID\n" +
					"        ,:USERID\n" +
					"    FROM tp_pc_mould m\n" +
					"   WHERE m.mouldid = :mouldid";
					OracleParameter[] paras = new OracleParameter[]
					{
						new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
							GroutingLineDetailID, ParameterDirection.Input),
						new OracleParameter(":changeID", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":MouldID", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
						new OracleParameter(":MOULDCODE", OracleDbType.Varchar2,
							dtGroutingLineDetail.Rows[i]["MOULDCODE"], ParameterDirection.Input),
						new OracleParameter(":REMARKS", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"], ParameterDirection.Input),
						new OracleParameter(":ACCOUNTID", OracleDbType.Int32,
							user.AccountID, ParameterDirection.Input),
						new OracleParameter(":USERID", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);

					// 修改模具状态
					sqlString = "UPDATE tp_pc_mould m\n" +
					"   SET m.premouldstatus      = m.mouldstatus\n" +
					"      ,m.mouldstatus         = :mouldstatus\n" +
					"      ,m.updateuserid        = :userid\n" +
					"      ,m.lastchangehistoryid = :changeid\n" +
					"      ,m.GroutingLineDetailID = :GroutingLineDetailID\n" +
					" WHERE m.mouldid = :mouldid";

					paras = new OracleParameter[]
					{
						new OracleParameter(":mouldstatus", OracleDbType.Int32,
							(int)Constant.MouldStatus.OnLine, ParameterDirection.Input),
						new OracleParameter(":changeid", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":userid", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
						new OracleParameter(":mouldid", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
							GroutingLineDetailID, ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);
				}

				// 庆祥要求，整线换模或变产后，成型线开始使用日期是成型线中模具最小开始使用日期。
				string sqlUpdate = "update TP_PC_GROUTINGLINE l " +
							"   set l.beginuseddate =" +
							"       (select min(ld.beginuseddate)" +
							"          from TP_PC_GROUTINGLINEDETAIL ld" +
							"         where ld.groutinglineid = l.groutinglineid" +
							"           and ld.valueflag = '1')" +
							" where l.groutinglineid = " + dtGroutingLineDetail.Rows[0]["GroutingLineID"];
				oracleTrConn.ExecuteNonQuery(sqlUpdate, null);
				//更新明细信息
				if (isError)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = -500;
					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="dtGroutingLineDetail">明细实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 
		/// </remarks>
		public static int UpdateAllLineStartGroutingLineDetail(DataTable dtGroutingLineDetail,
			int groutingLineID, DateTime lineOPTimeStamp, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				OracleParameter[] Paras = null;
				StringBuilder sbSql = new StringBuilder();
				int GMouldRecordID = 0;
				bool isError = false;

				// 更新成型线UpdateUserID
				//sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + ",GMouldStatus=4 where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"]);
				//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
				// 更新成型线UpdateUserID
				sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + ",GMouldStatus=4,ENDUSEDDATE=trunc(sysdate) where GroutingLineID=" + groutingLineID + " and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
				Paras = new OracleParameter[] {
					new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
					lineOPTimeStamp,ParameterDirection.Input)
				};
				//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
				int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				if (row == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnRows = -500;
				}

				sbSql.Clear();
				sbSql.Append("select SEQ_PC_GMouldRecord_ID.nextval from dual");
				GMouldRecordID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));//变更履历
				sbSql.Clear();
				// 1.插入变更履历
				sbSql.Append("insert into TP_PC_GMouldRecord");
				sbSql.Append("(GMouldRecordID,");
				sbSql.Append("GroutingLineID,GroutingLineDetailID,GoodsID,");
				sbSql.Append("GroutingMouldCode,MouldCode,GroutingCount,");
				sbSql.Append("GMouldRecordType,BeginDate,");
				sbSql.Append("Remarks,AccountID,CreateTime,");
				sbSql.Append("CreateUserID,UpdateTime,UpdateUserID");
				sbSql.Append(")");
				sbSql.Append(" values (:GMouldRecordID,");
				sbSql.Append(":GroutingLineID,null,null,");
				sbSql.Append("null,null,null,");
				sbSql.Append(":GMouldRecordType,trunc(sysdate),");
				sbSql.Append(":Remarks,:AccountID,sysdate,");
				sbSql.Append(":CreateUserID,sysdate,:UpdateUserID)");
				// sbSql.Append(" from TP_PC_GroutingLineDetail where GroutingLineID=:GroutingLineID ");
				Paras = new OracleParameter[] {
					new OracleParameter(":GMouldRecordType",OracleDbType.Int32,
						6,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
						groutingLineID,ParameterDirection.Input),
					new OracleParameter(":Remarks",OracleDbType.NVarchar2,
						(dtGroutingLineDetail.Rows.Count > 0 ? dtGroutingLineDetail.Rows[0]["RecordRemarks"].ToString() : "[整线变产]")
						,ParameterDirection.Input),//0没有写i,是因为整体变产，只在第一行添加了操作备注
                    new OracleParameter(":AccountID",OracleDbType.Int32,
						user.AccountID,ParameterDirection.Input),
					new OracleParameter(":CreateUserID",OracleDbType.Int32,
						user.UserID,ParameterDirection.Input),
					new OracleParameter(":UpdateUserID",OracleDbType.Int32,
						user.UserID,ParameterDirection.Input),
					new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
						GMouldRecordID,ParameterDirection.Input)
				};
				returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

				// 一模多产时，同一模具只操作一次。 add by chenxy 2018-10-29
				List<int> mouldIDs = new List<int>();
				for (int i = 0; i < dtGroutingLineDetail.Rows.Count; i++)
				{
					//2.更新成型线模具状态
					sbSql.Clear();
					sbSql.Append("update TP_PC_GroutingLineDetail set GMouldStatus=4,LastGMouldRecordID=:LastGMouldRecordID, MouldID = null,MouldOutputNo=null, ");
					sbSql.Append("UpdateUserID=:UpdateUserID,EndUsedDate=trunc(sysdate) where  GroutingLineDetailID=:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp and GMouldStatus in (0,1)");
					Paras = new OracleParameter[] {
						new OracleParameter(":LastGMouldRecordID",OracleDbType.Int32,
						   GMouldRecordID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[i]["OPTimeStamp"],ParameterDirection.Input)
					};
					row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						isError = true;  //即更新了，也可以用这个判断时间戳
						break;
					}
					returnRows += row;

					// 非条码模具
					if (dtGroutingLineDetail.Rows[i]["MouldID"] + "" == "")
					{
						continue;
					}
					// 一模多产时，同一模具只操作一次。（不能有多履历，会导致模具收发存等报表统计错误） add by chenxy 2018-10-29
					int mID = Convert.ToInt32(dtGroutingLineDetail.Rows[i]["MouldID"]);
					//object mOutputNo = dtGroutingLineDetail.Rows[i]["MouldOutputNo"];
					//if (mOutputNo != null && mOutputNo != DBNull.Value)
					//{
					//    string sql = "UPDATE tp_pc_mouldoutput m\n" +
					//    "   SET m.GroutingLineDetailID = null\n" +
					//    " WHERE m.mouldid = :mouldid and m.OutputNo=:OutputNo";

					//    OracleParameter[] oparas = new OracleParameter[]
					//    {
					//        new OracleParameter(":OutputNo", OracleDbType.Int32,
					//            mOutputNo, ParameterDirection.Input),
					//        new OracleParameter(":mouldid", OracleDbType.Int32,
					//            mID, ParameterDirection.Input),
					//    };
					//    row += oracleTrConn.ExecuteNonQuery(sql, oparas);
					//}
					if (mouldIDs.Contains(mID))
					{
						continue;
					}
					mouldIDs.Add(mID);
					object mOutputNo = dtGroutingLineDetail.Rows[i]["MouldOutputNo"];
					if (mOutputNo != null && mOutputNo != DBNull.Value && mOutputNo + "" != "0")
					{
						string sql = "UPDATE tp_pc_mouldoutput m\n" +
						"   SET m.GroutingLineDetailID = null\n" +
						" WHERE m.mouldid = :mouldid\n";
						//" and m.OutputNo=:OutputNo";

						OracleParameter[] oparas = new OracleParameter[]
						{
                            //new OracleParameter(":OutputNo", OracleDbType.Int32,
                            //    mOutputNo, ParameterDirection.Input),
                            new OracleParameter(":mouldid", OracleDbType.Int32,
								mID, ParameterDirection.Input),
						};
						row += oracleTrConn.ExecuteNonQuery(sql, oparas);
					}
					// 添加模具履历
					int mouldHistoryID = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select seq_pc_mouldhistory_id.nextval from dual "));

					string sqlString =
					"INSERT INTO tp_pc_mouldchangehistory\n" +
					"  (CHANGEID\n" +
					"  ,MOULDID\n" +
					"  ,MOULDCODE\n" +
					"  ,MOULDBARCODE\n" +
					"  ,GOODSID\n" +
					"  ,GOODSCODE\n" +
					"  ,OPERATIONTYPE\n" +
					"  ,GroutingLineDetailID\n" +
					"  ,MOULDSTATUS\n" +
					"  ,MOULDSTATUSAFTER\n" +
					"  ,GROUTINGNUM\n" +
					"  ,REMARKS\n" +
					"  ,CHANGEFLAG\n" +
					"  ,ScrapReason\n" +
					"  ,ScrapResponsibility\n" +
					"  ,ACCOUNTID\n" +
					"  ,CREATEUSERID)\n" +
					"  SELECT :changeID\n" +
					"        ,:MouldID\n" +
					"        ,:MOULDCODE\n" +
					"        ,m.mouldbarcode\n" +
					"        ,m.goodsid\n" +
					"        ,m.goodscode\n" +
					"        ,decode(:mouldstatus, 1, 7, 3, 8, 4, 9) OPERATIONTYPE\n" +
					"        ,m.GroutingLineDetailID\n" +
					"        ,m.mouldstatus\n" +
					"        ,:mouldstatus\n" +
					"        ,m.groutingnum\n" +
					"        ,:REMARKS\n" +
					"        ,decode(:mouldstatus, 1, '1', 3, '0', 4, '0') CHANGEFLAG\n" +
					"  ,:ScrapReason\n" +
					"  ,:ScrapResponsibility\n" +
					"        ,:ACCOUNTID\n" +
					"        ,:USERID\n" +
					"    FROM tp_pc_mould m\n" +
					"   WHERE m.mouldid = :MouldID";
					OracleParameter[] paras = new OracleParameter[]
					{
						new OracleParameter(":mouldstatus", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["mouldstatus"], ParameterDirection.Input),
						new OracleParameter(":ScrapReason", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["ScrapReason"], ParameterDirection.Input),
						new OracleParameter(":ScrapResponsibility", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["ScrapResponsibility"], ParameterDirection.Input),
						new OracleParameter(":changeID", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":MouldID", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
						new OracleParameter(":MOULDCODE", OracleDbType.Varchar2,
							dtGroutingLineDetail.Rows[i]["MOULDCODE"], ParameterDirection.Input),
						new OracleParameter(":REMARKS", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"], ParameterDirection.Input),
						new OracleParameter(":ACCOUNTID", OracleDbType.Int32,
							user.AccountID, ParameterDirection.Input),
						new OracleParameter(":USERID", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);

					// 修改模具状态
					sqlString = "UPDATE tp_pc_mould m\n" +
					"   SET m.premouldstatus      = m.mouldstatus\n" +
					"      ,m.mouldstatus         = :mouldstatus\n" +
					"      ,m.updateuserid        = :userid\n" +
					"      ,m.lastchangehistoryid = :changeid\n" +
					"      ,m.GroutingLineDetailID = null\n" +

					"      ,m.scrapdate           = decode(:mouldstatus,4,SYSDATE, null)\n" +
					"      ,m.scrapuserid         = decode(:mouldstatus,4,:userid, null)\n" +
					"      ,m.scrapusercode       = decode(:mouldstatus,4,:usercode, null)\n" +
					"      ,m.ScrapReason = :ScrapReason\n" +
					"      ,m.ScrapResponsibility = :ScrapResponsibility\n" +
					" WHERE m.mouldid = :mouldid";

					paras = new OracleParameter[]
					{
						new OracleParameter(":mouldstatus", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["mouldstatus"], ParameterDirection.Input),
						new OracleParameter(":ScrapReason", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["ScrapReason"], ParameterDirection.Input),
						new OracleParameter(":ScrapResponsibility", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["ScrapResponsibility"], ParameterDirection.Input),
						new OracleParameter(":changeid", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":userid", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
						new OracleParameter(":usercode", OracleDbType.NVarchar2,
							user.UserCode, ParameterDirection.Input),
						new OracleParameter(":mouldid", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);
				}
				//更新明细信息
				if (isError)
				{
					returnRows = -500;
					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;
			}
			return returnRows;
		}

		/// <summary>
		/// 整线变产结束
		/// </summary>
		/// <param name="dtGroutingLineDetail">明细实体</param>
		/// <param name="goodsID">变产产品ID</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 
		/// </remarks>
		public static ServiceResultEntity UpdateAllLineEndGroutingLineDetail(DataTable dtGroutingLineDetail,
			DataTable oldDetail, int groutingLineID, DateTime lineOPTimeStamp, SUserInfo user)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();

				int MouldQuantity = 0;
				if (dtGroutingLineDetail != null)
				{
					MouldQuantity = dtGroutingLineDetail.Rows.Count;
					// 验证模具条码
					DataRow[] moulds = dtGroutingLineDetail.Select("MouldID is not null");
					if (moulds != null && moulds.Length > 0)
					{
						List<string> ids = new List<string>();
						foreach (DataRow item in moulds)
						{
							string id = item["MouldID"].ToString();
							if (!ids.Contains(id))
							{
								ids.Add(id);
							}
						}
						string idswhere = string.Join(",", ids);
						string sql = "select mouldid from tp_pc_mould m where m.mouldid in (" + idswhere + ") for update";
						oracleTrConn.GetSqlResultToDt(sql);

						sql = "select mouldbarcode from tp_pc_mould m where m.mouldstatus not in (1,3) and m.mouldid in (" + idswhere + ")";
						DataTable dt = oracleTrConn.GetSqlResultToDt(sql);
						if (dt != null && dt.Rows.Count > 0)
						{
							ids.Clear();
							foreach (DataRow item in dt.Rows)
							{
								ids.Add(item["mouldbarcode"].ToString());
							}

							sre.Status = Constant.ServiceResultStatus.Other;
							sre.OtherStatus = -100;
							sre.Message = "以下模具的状态不是【在库】或【待产】，不能添加到成型线。" + System.Environment.NewLine
								+ string.Join(",", ids);
							return sre;
						}
					}
				}

				OracleParameter[] Paras = null;
				StringBuilder sbSql = new StringBuilder();
				bool isError = false;

				//DataRow[] drMouldQuantity = dtGroutingLineDetail.Select("NewFlag=1");
				//if(drMouldQuantity.Length>0)
				//{
				//    MouldQuantity = drMouldQuantity.Length;
				//}
				// 更新成型线UpdateUserID
				sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + ",GMouldStatus=1,ENDUSEDDATE=null, MouldQuantity= " + MouldQuantity + " where GroutingLineID=" + groutingLineID + " and OPTimeStamp=:OPTimeStamp and GMouldStatus=4");
				Paras = new OracleParameter[] {
					new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
					lineOPTimeStamp,ParameterDirection.Input)
				};
				int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				if (row == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = -500;
					return sre;
				}

				//for (int i = 0; i < oldDetail.Rows.Count; i++)
				//{
				//    sbSql.Clear();

				//    sbSql.Append("update TP_PC_GroutingLineDetail set valueflag=0, UpdateUserID=:UpdateUserID where GroutingLineDetailID=:GroutingLineDetailID");
				//    Paras = new OracleParameter[] {
				//        new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
				//            oldDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
				//        new OracleParameter(":UpdateUserID",OracleDbType.Int32,
				//            user.UserID,ParameterDirection.Input)
				//    };
				//    returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				//}
				sbSql.Clear();

				sbSql.Append("update TP_PC_GroutingLineDetail set valueflag='0', UpdateUserID=:UpdateUserID where GroutingLineID=:GroutingLineID and valueflag='1' and GMouldStatus=4");
				Paras = new OracleParameter[] {
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
						groutingLineID,ParameterDirection.Input),
					new OracleParameter(":UpdateUserID",OracleDbType.Int32,
						user.UserID,ParameterDirection.Input)
				};
				row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				// 无模具明细，结束变产
				//if (row == 0)
				//{
				//    oracleTrConn.Rollback();
				//    oracleTrConn.Disconnect();
				//    sre.Status = Constant.ServiceResultStatus.Other;
				//    sre.OtherStatus = -500;
				//    return sre;
				//}

				//1查出注浆明细最后变更履历ID，进行更新
				sbSql.Clear();
				sbSql.Append("select nvl(max(GMouldRecordID),0) as LastGMouldRecordID from TP_PC_GMouldRecord where GroutingLineID=:GroutingLineID and GroutingLineDetailID is null");
				Paras = new OracleParameter[] {
				new OracleParameter(":GroutingLineID",OracleDbType.Int32,
					groutingLineID,ParameterDirection.Input)
				};
				DataSet dsInfo = oracleTrConn.GetSqlResultToDs(sbSql.ToString(), Paras);
				int? LastGMouldRecordID = null;
				if (dsInfo != null && dsInfo.Tables[0].Rows.Count > 0)
				{
					LastGMouldRecordID = Convert.ToInt32(dsInfo.Tables[0].Rows[0]["LastGMouldRecordID"]);
				}

				sbSql.Clear();
				sbSql.Append("Update TP_PC_GMouldRecord set EndDate=trunc(sysdate),Remarks=:Remarks,UpdateUserID=:UpdateUserID where GMouldRecordID=:GMouldRecordID");
				Paras = new OracleParameter[] {
				new OracleParameter(":Remarks",OracleDbType.NVarchar2,
                    //"[结束整线变产]"
                    ((dtGroutingLineDetail != null && dtGroutingLineDetail.Rows.Count > 0) ? dtGroutingLineDetail.Rows[0]["RecordRemarks"].ToString() : "[结束整线变产]")
					,ParameterDirection.Input),
				new OracleParameter(":UpdateUserID",OracleDbType.Int32,
					user.UserID,ParameterDirection.Input),
				new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
					LastGMouldRecordID,ParameterDirection.Input),
				};
				returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

				int? GroutingLineDetailID = null;
				if (dtGroutingLineDetail != null)
				{
					// 一模多产时，同一模具只操作一次。 add by chenxy 2018-10-29
					List<int> mouldIDs = new List<int>();
					for (int i = 0; i < dtGroutingLineDetail.Rows.Count; i++)
					{
						// 插入新明细
						sbSql.Clear();
						sbSql.Append("select SEQ_PC_GroutingLineDetail_ID.nextval from dual");
						GroutingLineDetailID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
						if (dtGroutingLineDetail.Rows[i]["MouldCode"] + "" == "")
						{
							dtGroutingLineDetail.Rows[i]["MouldCode"] = System.Guid.NewGuid().ToString().ToUpper();
						}
						//string guid = System.Guid.NewGuid().ToString().ToUpper();
						sbSql.Clear();
						sbSql.Append("insert into TP_PC_GroutingLineDetail");
						sbSql.Append("(");
						sbSql.Append("GroutingLineDetailID");
						sbSql.Append(",GroutingLineID");
						sbSql.Append(",GroutingMouldCode");
						sbSql.Append(",MouldSource");
						sbSql.Append(",MouldID");
						sbSql.Append(",MouldCode");
						sbSql.Append(",MouldOutputNo");
						sbSql.Append(",GoodsID");
						sbSql.Append(",StandardGroutingCount");
						sbSql.Append(",GroutingCount");
						sbSql.Append(",GMouldStatus");
						sbSql.Append(",BeginUsedDate");
						sbSql.Append(",EndUsedDate");
						sbSql.Append(",LastGMouldRecordID");
						sbSql.Append(",Remarks");
						sbSql.Append(",AccountID");
						sbSql.Append(",ValueFlag");
						sbSql.Append(",CreateUserID");
						sbSql.Append(",UpdateUserID");
						sbSql.Append(") ");
						sbSql.Append("values(");
						sbSql.Append(" :GroutingLineDetailID");
						sbSql.Append(",:GroutingLineID");
						sbSql.Append(",:GroutingMouldCode");
						sbSql.Append(",:MouldSource");
						sbSql.Append(",:MouldID");
						sbSql.Append(",:MouldCode");
						sbSql.Append(",:MouldOutputNo");
						sbSql.Append(",:GoodsID");
						sbSql.Append(",:StandardGroutingCount");
						sbSql.Append(",:GroutingCount");
						sbSql.Append(",1");
						sbSql.Append(",trunc(sysdate)");
						sbSql.Append(",null");
						sbSql.Append(",:LastGMouldRecordID");
						sbSql.Append(",:Remarks");
						sbSql.Append(",:AccountID");
						sbSql.Append(",1");
						sbSql.Append(",:CreateUserID");
						sbSql.Append(",:UpdateUserID");
						sbSql.Append(" )");
						Paras = new OracleParameter[] {
							new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
								GroutingLineDetailID,ParameterDirection.Input),
							new OracleParameter(":GroutingLineID",OracleDbType.Int32,
								groutingLineID,ParameterDirection.Input),
							new OracleParameter(":GroutingMouldCode",OracleDbType.Varchar2,
								dtGroutingLineDetail.Rows[i]["GroutingMouldCode"],ParameterDirection.Input),
							new OracleParameter(":MouldSource",OracleDbType.Char,
								dtGroutingLineDetail.Rows[i]["MouldSource"],ParameterDirection.Input),
							new OracleParameter(":MouldID",OracleDbType.Int32,
								dtGroutingLineDetail.Rows[i]["MouldID"],ParameterDirection.Input),
							new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
								dtGroutingLineDetail.Rows[i]["MouldCode"],ParameterDirection.Input),
							new OracleParameter(":MouldOutputNo",OracleDbType.Int32,
								dtGroutingLineDetail.Rows[i]["MouldOutputNo"],ParameterDirection.Input),
							new OracleParameter(":GoodsID",OracleDbType.Int32,
								dtGroutingLineDetail.Rows[i]["GoodsID"],ParameterDirection.Input),
							new OracleParameter(":StandardGroutingCount",OracleDbType.Int32,
								dtGroutingLineDetail.Rows[i]["StandardGroutingCount"],ParameterDirection.Input),
							new OracleParameter(":GroutingCount",OracleDbType.Int32,
								dtGroutingLineDetail.Rows[i]["GroutingCount"],ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.Varchar2,
								dtGroutingLineDetail.Rows[i]["Remarks"],ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
								user.UserID,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
								user.UserID,ParameterDirection.Input),
							new OracleParameter(":AccountID",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input),
							new OracleParameter(":LastGMouldRecordID",OracleDbType.Int32,
								LastGMouldRecordID,ParameterDirection.Input),
						};
						returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

						// 非条码模具
						if (dtGroutingLineDetail.Rows[i]["MouldID"] + "" == "")
						{
							continue;
						}
						// 一模多产时，同一模具只操作一次。（不能有多履历，会导致模具收发存等报表统计错误） add by chenxy 2018-10-29
						int mID = Convert.ToInt32(dtGroutingLineDetail.Rows[i]["MouldID"]);
						object mOutputNo = dtGroutingLineDetail.Rows[i]["MouldOutputNo"];
						if (mOutputNo != null && mOutputNo != DBNull.Value)
						{
							string sql = "UPDATE tp_pc_mouldoutput m\n" +
							"   SET m.GroutingLineDetailID = :GroutingLineDetailID\n" +
							" WHERE m.mouldid = :mouldid and m.OutputNo=:OutputNo";

							OracleParameter[] oparas = new OracleParameter[]
							{
							new OracleParameter(":OutputNo", OracleDbType.Int32,
								mOutputNo, ParameterDirection.Input),
							new OracleParameter(":mouldid", OracleDbType.Int32,
								mID, ParameterDirection.Input),
							new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
								GroutingLineDetailID, ParameterDirection.Input),
							};
							returnRows += oracleTrConn.ExecuteNonQuery(sql, oparas);
						}
						if (mouldIDs.Contains(mID))
						{
							continue;
						}
						mouldIDs.Add(mID);

						// 添加模具履历
						int mouldHistoryID = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select seq_pc_mouldhistory_id.nextval from dual "));

						string sqlString =
						"INSERT INTO tp_pc_mouldchangehistory\n" +
						"  (CHANGEID\n" +
						"  ,MOULDID\n" +
						"  ,MOULDCODE\n" +
						"  ,MOULDBARCODE\n" +
						"  ,GOODSID\n" +
						"  ,GOODSCODE\n" +
						"  ,OPERATIONTYPE\n" +
						"  ,GroutingLineDetailID\n" +
						"  ,MOULDSTATUS\n" +
						"  ,MOULDSTATUSAFTER\n" +
						"  ,GROUTINGNUM\n" +
						"  ,REMARKS\n" +
						"  ,CHANGEFLAG\n" +
						"  ,ACCOUNTID\n" +
						"  ,CREATEUSERID)\n" +
						"  SELECT :changeID\n" +
						"        ,:mouldid\n" +
						"        ,:MOULDCODE\n" +
						"        ,m.mouldbarcode\n" +
						"        ,m.goodsid\n" +
						"        ,m.goodscode\n" +
						"        ,decode(m.mouldstatus, 1, 6, 3, 10) OPERATIONTYPE\n" +
						"        ,:GroutingLineDetailID\n" +
						"        ,m.mouldstatus\n" +
						"        ,2\n" +
						"        ,m.groutingnum\n" +
						"        ,:REMARKS\n" +
						"        ,decode(m.mouldstatus, 1, '2', 3, '0') CHANGEFLAG\n" +
						"        ,:ACCOUNTID\n" +
						"        ,:USERID\n" +
						"    FROM tp_pc_mould m\n" +
						"   WHERE m.mouldid = :mouldid";
						OracleParameter[] paras = new OracleParameter[]
						{
							new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
								GroutingLineDetailID, ParameterDirection.Input),
							new OracleParameter(":changeID", OracleDbType.Int32,
								mouldHistoryID, ParameterDirection.Input),
							new OracleParameter(":MouldID", OracleDbType.Int32,
								dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
							new OracleParameter(":MOULDCODE", OracleDbType.Varchar2,
								dtGroutingLineDetail.Rows[i]["MOULDCODE"], ParameterDirection.Input),
							new OracleParameter(":REMARKS", OracleDbType.NVarchar2,
								dtGroutingLineDetail.Rows[i]["RecordRemarks"], ParameterDirection.Input),
							new OracleParameter(":ACCOUNTID", OracleDbType.Int32,
								user.AccountID, ParameterDirection.Input),
							new OracleParameter(":USERID", OracleDbType.Int32,
								user.UserID, ParameterDirection.Input),
						};
						returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);

						// 修改模具状态
						sqlString = "UPDATE tp_pc_mould m\n" +
						"   SET m.premouldstatus      = m.mouldstatus\n" +
						"      ,m.mouldstatus         = :mouldstatus\n" +
						"      ,m.updateuserid        = :userid\n" +
						"      ,m.lastchangehistoryid = :changeid\n" +
						"      ,m.GroutingLineDetailID = :GroutingLineDetailID\n" +
						" WHERE m.mouldid = :mouldid";

						paras = new OracleParameter[]
						{
							new OracleParameter(":mouldstatus", OracleDbType.Int32,
								(int)Constant.MouldStatus.OnLine, ParameterDirection.Input),
							new OracleParameter(":changeid", OracleDbType.Int32,
								mouldHistoryID, ParameterDirection.Input),
							new OracleParameter(":userid", OracleDbType.Int32,
								user.UserID, ParameterDirection.Input),
							new OracleParameter(":mouldid", OracleDbType.Int32,
								dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
							new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
								GroutingLineDetailID, ParameterDirection.Input),
						};
						returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);
					}
				}
				// 庆祥要求，整线换模或变产后，成型线开始使用日期是成型线中模具最小开始使用日期。
				string sqlupdate = "update TP_PC_GROUTINGLINE l " +
							"   set l.beginuseddate =" +
							"       nvl((select min(ld.beginuseddate)" +
							"          from TP_PC_GROUTINGLINEDETAIL ld" +
							"         where ld.groutinglineid = l.groutinglineid" +
							"           and ld.valueflag = '1'), l.beginuseddate)" +
							" where l.groutinglineid = " + groutingLineID;
				oracleTrConn.ExecuteNonQuery(sqlupdate, null);
				//更新明细信息
				if (isError)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = -500;
					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="dtGroutingLineDetail">明细实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int受影响行数</returns>
		/// <remarks>
		/// 
		/// </remarks>
		public static int UnloadGroutingLineDetail(DataTable dtGroutingLineDetail, SUserInfo user)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				OracleParameter[] Paras = null;
				StringBuilder sbSql = new StringBuilder();
				int GMouldRecordID = 0;
				bool isError = false;
				if (dtGroutingLineDetail.Rows.Count > 0)
				{
					// 更新成型线UpdateUserID
					//sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"]);
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					// 更新成型线UpdateUserID
					sbSql.Append("update TP_PC_GroutingLine set UpdateUserID=" + user.UserID + " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"] + " and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[0]["LineOPTimeStamp"],ParameterDirection.Input)
					};
					//oracleTrConn.ExecuteNonQuery(sbSql.ToString());
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						return returnRows = -500;
					}
				}
				// 一模多产时，同一模具只操作一次。 add by chenxy 2018-10-29
				List<int> mouldIDs = new List<int>();
				for (int i = 0; i < dtGroutingLineDetail.Rows.Count; i++)
				{
					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GMouldRecord_ID.nextval from dual");
					GMouldRecordID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
					sbSql.Clear();
					// 1.插入变更履历
					sbSql.Append("insert into TP_PC_GMouldRecord");
					sbSql.Append("(GMouldRecordID,");
					sbSql.Append("GroutingLineID,GroutingLineDetailID,GoodsID,");
					sbSql.Append("GroutingMouldCode,MouldCode,GroutingCount,");
					sbSql.Append("GMouldRecordType,BeginDate,EndDate,");
					sbSql.Append("Remarks,AccountID,CreateTime,");
					sbSql.Append("CreateUserID,UpdateTime,UpdateUserID");
					sbSql.Append(")");
					sbSql.Append("select :GMouldRecordID,");
					sbSql.Append("GroutingLineID,GroutingLineDetailID,GoodsID,");
					sbSql.Append("GroutingMouldCode,MouldCode,GroutingCount,");
					sbSql.Append(":GMouldRecordType,trunc(sysdate),trunc(sysdate),");
					sbSql.Append(":Remarks,:AccountID,sysdate,");
					sbSql.Append(":CreateUserID,sysdate,:UpdateUserID");
					sbSql.Append(" from TP_PC_GroutingLineDetail where GroutingLineDetailID=:GroutingLineDetailID ");
					Paras = new OracleParameter[] {
						new OracleParameter(":GMouldRecordType",OracleDbType.Int32,
						   7,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"],ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GMouldRecordID",OracleDbType.Int32,
							GMouldRecordID,ParameterDirection.Input)
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					//2.更新成型线模具状态
					sbSql.Clear();
					sbSql.Append("update TP_PC_GroutingLineDetail set GMouldStatus=6,LastGMouldRecordID=:LastGMouldRecordID, MouldID = null,MouldOutputNo=null, Valueflag = '0', ");
					sbSql.Append("UpdateUserID=:UpdateUserID,EndUsedDate=trunc(sysdate) where  GroutingLineDetailID=:GroutingLineDetailID and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
					Paras = new OracleParameter[] {
						new OracleParameter(":LastGMouldRecordID",OracleDbType.Int32,
						   GMouldRecordID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["GroutingLineDetailID"],ParameterDirection.Input),
						 new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dtGroutingLineDetail.Rows[i]["OPTimeStamp"],ParameterDirection.Input)
					};
					int row = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					if (row == 0)
					{
						isError = true;  //即更新了，也可以用这个判断时间戳
						break;
					}
					returnRows += row;

					// 非条码模具
					if (dtGroutingLineDetail.Rows[i]["MouldID"] + "" == "")
					{
						continue;
					}
					// 一模多产时，同一模具只操作一次。（不能有多履历，会导致模具收发存等报表统计错误） add by chenxy 2018-10-29
					int mID = Convert.ToInt32(dtGroutingLineDetail.Rows[i]["MouldID"]);
					//object mOutputNo = dtGroutingLineDetail.Rows[i]["MouldOutputNo"];
					//if (mOutputNo != null && mOutputNo != DBNull.Value)
					//{
					//    string sql = "UPDATE tp_pc_mouldoutput m\n" +
					//    "   SET m.GroutingLineDetailID = null\n" +
					//    " WHERE m.mouldid = :mouldid and m.OutputNo=:OutputNo";

					//    OracleParameter[] oparas = new OracleParameter[]
					//    {
					//        new OracleParameter(":OutputNo", OracleDbType.Int32,
					//            mOutputNo, ParameterDirection.Input),
					//        new OracleParameter(":mouldid", OracleDbType.Int32,
					//            mID, ParameterDirection.Input),
					//    };
					//    row += oracleTrConn.ExecuteNonQuery(sql, oparas);
					//}
					if (mouldIDs.Contains(mID))
					{
						continue;
					}
					mouldIDs.Add(mID);
					object mOutputNo = dtGroutingLineDetail.Rows[i]["MouldOutputNo"];
					if (mOutputNo != null && mOutputNo != DBNull.Value && mOutputNo + "" != "0")
					{
						string sql = "UPDATE tp_pc_mouldoutput m\n" +
						"   SET m.GroutingLineDetailID = null\n" +
						" WHERE m.mouldid = :mouldid\n";
						//" and m.OutputNo=:OutputNo";

						OracleParameter[] oparas = new OracleParameter[]
						{
                            //new OracleParameter(":OutputNo", OracleDbType.Int32,
                            //    mOutputNo, ParameterDirection.Input),
                            new OracleParameter(":mouldid", OracleDbType.Int32,
								mID, ParameterDirection.Input),
						};
						row += oracleTrConn.ExecuteNonQuery(sql, oparas);
					}
					// 添加模具履历
					int mouldHistoryID = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select seq_pc_mouldhistory_id.nextval from dual "));

					string sqlString =
					"INSERT INTO tp_pc_mouldchangehistory\n" +
					"  (CHANGEID\n" +
					"  ,MOULDID\n" +
					"  ,MOULDCODE\n" +
					"  ,MOULDBARCODE\n" +
					"  ,GOODSID\n" +
					"  ,GOODSCODE\n" +
					"  ,OPERATIONTYPE\n" +
					"  ,GroutingLineDetailID\n" +
					"  ,MOULDSTATUS\n" +
					"  ,MOULDSTATUSAFTER\n" +
					"  ,GROUTINGNUM\n" +
					"  ,REMARKS\n" +
					"  ,CHANGEFLAG\n" +
					"  ,ScrapReason\n" +
					"  ,ScrapResponsibility\n" +
					"  ,ACCOUNTID\n" +
					"  ,CREATEUSERID)\n" +
					"  SELECT :changeID\n" +
					"        ,:MouldID\n" +
					"        ,:MOULDCODE\n" +
					"        ,m.mouldbarcode\n" +
					"        ,m.goodsid\n" +
					"        ,m.goodscode\n" +
					"        ,decode(:mouldstatus, 1, 7, 3, 8, 4, 9) OPERATIONTYPE\n" +
					"        ,m.GroutingLineDetailID\n" +
					"        ,m.mouldstatus\n" +
					"        ,:mouldstatus\n" +
					"        ,m.groutingnum\n" +
					"        ,:REMARKS\n" +
					"        ,decode(:mouldstatus, 1, '1', 3, '0', 4, '0') CHANGEFLAG\n" +
					"  ,:ScrapReason\n" +
					"  ,:ScrapResponsibility\n" +
					"        ,:ACCOUNTID\n" +
					"        ,:USERID\n" +
					"    FROM tp_pc_mould m\n" +
					"   WHERE m.mouldid = :MouldID";
					OracleParameter[] paras = new OracleParameter[]
					{
						new OracleParameter(":mouldstatus", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["mouldstatus"], ParameterDirection.Input),
						new OracleParameter(":ScrapReason", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["ScrapReason"], ParameterDirection.Input),
						new OracleParameter(":ScrapResponsibility", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["ScrapResponsibility"], ParameterDirection.Input),
						new OracleParameter(":changeID", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":MouldID", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
						new OracleParameter(":MOULDCODE", OracleDbType.Varchar2,
							dtGroutingLineDetail.Rows[i]["MOULDCODE"], ParameterDirection.Input),
						new OracleParameter(":REMARKS", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["RecordRemarks"], ParameterDirection.Input),
						new OracleParameter(":ACCOUNTID", OracleDbType.Int32,
							user.AccountID, ParameterDirection.Input),
						new OracleParameter(":USERID", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);

					// 修改模具状态
					sqlString = "UPDATE tp_pc_mould m\n" +
					"   SET m.premouldstatus      = m.mouldstatus\n" +
					"      ,m.mouldstatus         = :mouldstatus\n" +
					"      ,m.updateuserid        = :userid\n" +
					"      ,m.lastchangehistoryid = :changeid\n" +
					"      ,m.GroutingLineDetailID = null\n" +

					"      ,m.scrapdate           = decode(:mouldstatus,4,SYSDATE, null)\n" +
					"      ,m.scrapuserid         = decode(:mouldstatus,4,:userid, null)\n" +
					"      ,m.scrapusercode       = decode(:mouldstatus,4,:usercode, null)\n" +
					"      ,m.ScrapReason = :ScrapReason\n" +
					"      ,m.ScrapResponsibility = :ScrapResponsibility\n" +
					" WHERE m.mouldid = :mouldid";

					paras = new OracleParameter[]
					{
						new OracleParameter(":mouldstatus", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["mouldstatus"], ParameterDirection.Input),
						new OracleParameter(":ScrapReason", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["ScrapReason"], ParameterDirection.Input),
						new OracleParameter(":ScrapResponsibility", OracleDbType.NVarchar2,
							dtGroutingLineDetail.Rows[i]["ScrapResponsibility"], ParameterDirection.Input),
						new OracleParameter(":changeid", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":userid", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
						new OracleParameter(":usercode", OracleDbType.NVarchar2,
							user.UserCode, ParameterDirection.Input),
						new OracleParameter(":mouldid", OracleDbType.Int32,
							dtGroutingLineDetail.Rows[i]["MouldID"], ParameterDirection.Input),
					};
					returnRows += oracleTrConn.ExecuteNonQuery(sqlString, paras);
				}

				//更新明细信息
				if (isError)
				{
					returnRows = -500;
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				else
				{
					// 更新成型线模具个数
					string sqlupdate = "update TP_PC_GroutingLine set MouldQuantity = MouldQuantity - "
						+ dtGroutingLineDetail.Rows.Count
						+ " where GroutingLineID=" + dtGroutingLineDetail.Rows[0]["GroutingLineID"];
					returnRows = oracleTrConn.ExecuteNonQuery(sqlupdate);

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

		/// <summary>
		/// 新建成型线信息
		/// </summary>
		/// <param name="groutingLineEntity">成型线实体</param>
		/// <param name="detailList">明细实体集合</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>返回受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.10              新建
		/// </remarks>
		public static ServiceResultEntity AddGroutingLine_NewLine(GroutingLineEntity groutingLineEntity,
			DataTable detailList, DataTable detailUserList, SUserInfo user)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int returnRows = 0;
			int detailReturn = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				if (GroutingLineCodeIsRepeat(groutingLineEntity.GROUTINGLINECODE, user.AccountID) == false)
				{
					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = -50;
					return sre;
				}

				oracleTrConn.Connect();
				// 验证模具条码
				DataRow[] moulds = detailList.Select("MouldID is not null");
				if (moulds != null && moulds.Length > 0)
				{
					List<string> ids = new List<string>();
					foreach (DataRow item in moulds)
					{
						ids.Add(item["MouldID"].ToString());
					}
					string idswhere = string.Join(",", ids);
					string sql = "select mouldid from tp_pc_mould m where m.mouldid in (" + idswhere + ") for update";
					oracleTrConn.GetSqlResultToDt(sql);

					sql = "select mouldbarcode from tp_pc_mould m where m.mouldstatus not in (1,3) and m.mouldid in (" + idswhere + ")";
					DataTable dt = oracleTrConn.GetSqlResultToDt(sql);
					if (dt != null && dt.Rows.Count > 0)
					{
						ids.Clear();
						foreach (DataRow item in dt.Rows)
						{
							ids.Add(item["mouldbarcode"].ToString());
						}

						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = -100;
						sre.Message = "以下模具的状态不是【在库】或【待产】，不能添加到成型线。" + System.Environment.NewLine
							+ string.Join(",", ids);
						return sre;
					}
				}

				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				//获取成型线ID索引
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("select SEQ_PC_GroutingLine_ID.nextval from dual");
				int id = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
				sbSql.Clear();
				//添加成型线信息
				sbSql.Append("Insert into TP_PC_GroutingLine");
				sbSql.Append("(GroutingLineID,BuildingNo,FloorNo,GroutingLineNo,GroutingLineCode,");
				//xuwei add 2019-11-13 高压注浆
				sbSql.Append("HighPressureFlag,");
				//xuwei end 
				//xuwei add 2021-09-12 部门
				sbSql.Append("WorkShop,");
				//xuwei end 
				//feiy add 2022-03-25 试验线
				sbSql.Append("TestFlag,");
				//feiy end 
				sbSql.Append("GroutingLineName,MouldQuantity,GMouldTypeID,UserID,MonitorID,");
				sbSql.Append("BeginUsedDate,GMouldStatus,Remarks,AccountID,");
				sbSql.Append("CreateUserID,UpdateUserID,UserCount)");
				sbSql.Append("values(:GroutingLineID,:BuildingNo,:FloorNo,:GroutingLineNo,:GroutingLineCode,");
				//xuwei add 2019-11-13 高压注浆
				sbSql.Append(":HighPressureFlag,");
				//xuwei end 
				//xuwei add 2021-09-12 部门
				sbSql.Append(":WorkShop,");
				//xuwei end 
				//feiy add 2022-03-25 试验线
				sbSql.Append(":TestFlag,");
				//feiy end 
				sbSql.Append(":GroutingLineName,:MouldQuantity,:GMouldTypeID,:UserID,:MonitorID,");
				sbSql.Append(":BeginUsedDate,:GMouldStatus,:Remarks,:AccountID,");
				sbSql.Append(":CreateUserID,:UpdateUserID,:UserCount)");
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							id,ParameterDirection.Input),
						new OracleParameter(":BuildingNo",OracleDbType.NVarchar2,
							groutingLineEntity.BUILDINGNO,ParameterDirection.Input),
						new OracleParameter(":FloorNo",OracleDbType.NVarchar2,
							groutingLineEntity.FLOORNO,ParameterDirection.Input),
						new OracleParameter(":GroutingLineNo",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINENO,ParameterDirection.Input),
						new OracleParameter(":GroutingLineCode",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINECODE,ParameterDirection.Input),
                        //xuwei add 2019-11-13 高压注浆
                        new OracleParameter(":HighPressureFlag",OracleDbType.Char,
							groutingLineEntity.HIGHPRESSUREFLAG,ParameterDirection.Input),
                        //xuwei end
                        //xuwei add 2021-09-12 部门
                        new OracleParameter(":WorkShop",OracleDbType.Int32,
							groutingLineEntity.WORKSHOP,ParameterDirection.Input),
                        //xuwei end
                        //feiy add 2022-03-25 试验线
                        new OracleParameter(":TestFlag",OracleDbType.Int32,
							groutingLineEntity.TestFlag,ParameterDirection.Input),
                        //feiy end 
                        new OracleParameter(":GroutingLineName",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINENAME,ParameterDirection.Input),
						new OracleParameter(":MouldQuantity",OracleDbType.Decimal,
							groutingLineEntity.MOULDQUANTITY,ParameterDirection.Input),
						new OracleParameter(":GMouldTypeID",OracleDbType.Int32,
							groutingLineEntity.MOULDTYPEID,ParameterDirection.Input),
						new OracleParameter(":UserID",OracleDbType.Int32,
							groutingLineEntity.USERID,ParameterDirection.Input),
						new OracleParameter(":MonitorID",OracleDbType.Int32,
							groutingLineEntity.MonitorID,ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							accountDate,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							groutingLineEntity.MouldStatus,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							groutingLineEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UserCount",OracleDbType.Int32,
							detailUserList.Rows.Count,ParameterDirection.Input),
					};
				//执行插入成型线SQL语句
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				// 一模多产时，同一模具只操作一次。 add by chenxy 2018-10-29
				List<int> mouldIDs = new List<int>();
				//此处添加明细信息（循环）
				foreach (DataRow detailInfo in detailList.Rows)
				{
					//查看该成型线明细编号是否存在
					if (GroutingLineDetailCodeIsRepeat(detailInfo["GROUTINGMOULDCODE"].ToString(), user.AccountID) == false)
					{
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = -2;
						return sre;
					}
					//获取成型线明细索引
					sbSql.Clear();
					sbSql.Append("select SEQ_PC_GroutingLineDetail_ID.nextval from dual");
					int detailId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
					sbSql.Clear();
					//插入成型线明细信息
					sbSql.Append("Insert into TP_PC_GroutingLineDetail");
					sbSql.Append("(GroutingLineDetailID,GroutingLineID,GroutingMouldCode,GoodsID,GroutingCount,StandardGroutingCount,");
					sbSql.Append("GMouldStatus,BeginUsedDate,Remarks,AccountID,");
					sbSql.Append("MouldSource,MouldID,MouldCode,MouldOutputNo,");
					sbSql.Append("CreateUserID,UpdateUserID)");
					sbSql.Append("Values(:GroutingLineDetailID,:GroutingLineID,:GroutingMouldCode,:GoodsID,:GroutingCount,:StandardGroutingCount,");
					sbSql.Append(":GMouldStatus,:BeginUsedDate,:Remarks,:AccountID,");
					sbSql.Append(":MouldSource,:MouldID,:MouldCode,:MouldOutputNo,");
					sbSql.Append(":CreateUserID,:UpdateUserID)");
					OracleParameter[] DetailParas = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							detailId,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							id,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							detailInfo["GROUTINGMOULDCODE"],ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							detailInfo["GOODSID"],ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Int32,
							detailInfo["GROUTINGCOUNT"],ParameterDirection.Input),
						new OracleParameter(":StandardGroutingCount",OracleDbType.Int32,
							detailInfo["StandardGroutingCount"],ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							detailInfo["MOULDSTATUS"],ParameterDirection.Input),
						new OracleParameter(":BeginUsedDate",OracleDbType.Date,
							accountDate,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							detailInfo["REMARKS"],ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":MouldSource",OracleDbType.Char,
							detailInfo["MouldSource"],ParameterDirection.Input),
						new OracleParameter(":MouldID",OracleDbType.Int32,
							detailInfo["MouldID"],ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							detailInfo["MouldCode"],ParameterDirection.Input),
						new OracleParameter(":MouldOutputNo",OracleDbType.Int32,
							detailInfo["MouldOutputNo"],ParameterDirection.Input),
					};
					//执行插入语句并累加成功插入次数
					detailReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);

					// 非条码模具
					if (detailInfo["MouldID"] + "" == "")
					{
						continue;
					}

					// 一模多产时，同一模具只操作一次。（不能有多履历，会导致模具收发存等报表统计错误） add by chenxy 2018-10-29
					int mID = Convert.ToInt32(detailInfo["MouldID"]);

					object mOutputNo = detailInfo["MouldOutputNo"];
					if (mOutputNo != null && mOutputNo != DBNull.Value)
					{
						string sql = "UPDATE tp_pc_mouldoutput m\n" +
						"   SET m.GroutingLineDetailID = :GroutingLineDetailID\n" +
						" WHERE m.mouldid = :mouldid and m.OutputNo=:OutputNo";

						OracleParameter[] oparas = new OracleParameter[]
						{
							new OracleParameter(":OutputNo", OracleDbType.Int32,
								mOutputNo, ParameterDirection.Input),
							new OracleParameter(":mouldid", OracleDbType.Int32,
								mID, ParameterDirection.Input),
							new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
								detailId, ParameterDirection.Input),
						};
						detailReturn += oracleTrConn.ExecuteNonQuery(sql, oparas);
					}
					if (mouldIDs.Contains(mID))
					{
						continue;
					}
					mouldIDs.Add(mID);

					// 添加模具履历
					int mouldHistoryID = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select seq_pc_mouldhistory_id.nextval from dual "));

					string sqlString =
					"INSERT INTO tp_pc_mouldchangehistory\n" +
					"  (CHANGEID\n" +
					"  ,MOULDID\n" +
					"  ,MOULDCODE\n" +
					"  ,MOULDBARCODE\n" +
					"  ,GOODSID\n" +
					"  ,GOODSCODE\n" +
					"  ,OPERATIONTYPE\n" +
					"  ,GroutingLineDetailID\n" +
					"  ,MOULDSTATUS\n" +
					"  ,MOULDSTATUSAFTER\n" +
					"  ,GROUTINGNUM\n" +
					"  ,REMARKS\n" +
					"  ,CHANGEFLAG\n" +
					"  ,ACCOUNTID\n" +
					"  ,CREATEUSERID)\n" +
					"  SELECT :changeID\n" +
					"        ,:mouldid\n" +
					"        ,:MOULDCODE\n" +
					"        ,m.mouldbarcode\n" +
					"        ,m.goodsid\n" +
					"        ,m.goodscode\n" +
					"        ,decode(m.mouldstatus, 1, 6, 3, 10) OPERATIONTYPE\n" +
					"        ,:GroutingLineDetailID\n" +
					"        ,m.mouldstatus\n" +
					"        ,2\n" +
					"        ,m.groutingnum\n" +
					"        ,:REMARKS\n" +
					"        ,decode(m.mouldstatus, 1, '2', 3, '0') CHANGEFLAG\n" +
					"        ,:ACCOUNTID\n" +
					"        ,:USERID\n" +
					"    FROM tp_pc_mould m\n" +
					"   WHERE m.mouldid = :mouldid";
					OracleParameter[] paras = new OracleParameter[]
					{
						new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
							detailId, ParameterDirection.Input),
						new OracleParameter(":changeID", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":MouldID", OracleDbType.Int32,
							detailInfo["MouldID"], ParameterDirection.Input),
						new OracleParameter(":MOULDCODE", OracleDbType.Varchar2,
							detailInfo["MOULDCODE"], ParameterDirection.Input),
						new OracleParameter(":REMARKS", OracleDbType.NVarchar2,
							detailInfo["Remarks"], ParameterDirection.Input),
						new OracleParameter(":ACCOUNTID", OracleDbType.Int32,
							user.AccountID, ParameterDirection.Input),
						new OracleParameter(":USERID", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
					};
					detailReturn += oracleTrConn.ExecuteNonQuery(sqlString, paras);

					// 修改模具状态
					sqlString = "UPDATE tp_pc_mould m\n" +
					"   SET m.premouldstatus      = m.mouldstatus\n" +
					"      ,m.mouldstatus         = :mouldstatus\n" +
					"      ,m.updateuserid        = :userid\n" +
					"      ,m.lastchangehistoryid = :changeid\n" +
					"      ,m.GroutingLineDetailID = :GroutingLineDetailID\n" +
					" WHERE m.mouldid = :mouldid";

					paras = new OracleParameter[]
					{
						new OracleParameter(":mouldstatus", OracleDbType.Int32,
							(int)Constant.MouldStatus.OnLine, ParameterDirection.Input),
						new OracleParameter(":changeid", OracleDbType.Int32,
							mouldHistoryID, ParameterDirection.Input),
						new OracleParameter(":userid", OracleDbType.Int32,
							user.UserID, ParameterDirection.Input),
						new OracleParameter(":mouldid", OracleDbType.Int32,
							detailInfo["MouldID"], ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
							detailId, ParameterDirection.Input),
					};
					detailReturn += oracleTrConn.ExecuteNonQuery(sqlString, paras);

				}

				// 添加成型工号
				foreach (DataRow detailInfo in detailUserList.Rows)
				{
					//插入成型线明细信息
					sbSql.Clear();
					sbSql.Append("Insert into TP_PC_GroutingUser");
					sbSql.Append("(GroutingLineID,UserID,Remarks)");
					sbSql.Append("Values(:GroutingLineID,:UserID,:Remarks)");
					OracleParameter[] DetailParas = new OracleParameter[] {
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							id,ParameterDirection.Input),
						new OracleParameter(":UserID",OracleDbType.Int32,
							detailInfo["USERID"],ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							detailInfo["REMARK"],ParameterDirection.Input),
					};
					//执行插入语句并累加成功插入次数
					detailReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);
				}
				//如果有插入不成功的情况，回滚事务，否则提交
				//if (returnRows == 0 || detailReturn == 0
				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="groutingLineEntity">成型线实体</param>
		/// <param name="detailList">明细实体集合</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int返回受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.10              新建
		/// </remarks>
		public static ServiceResultEntity UpdateGroutingLine_NewLine(GroutingLineEntity groutingLineEntity,
		   DataTable detailList, DataTable detailUserList, DataTable UpdatedetailList, SUserInfo user)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				DataTable newTable = new DataTable();

				// 原成型线试验状态
				object oriTestFlag = oracleTrConn.GetSqlResultToObj("select TestFlag from TP_PC_GroutingLine where GroutingLineID = " + groutingLineEntity.GROUTINGLINEID);

				// 如果修改了试验线标识，要判断是否有权限
				if (!(oriTestFlag + "").Equals(groutingLineEntity.TestFlag + ""))
				{
					object isExists = oracleTrConn.GetSqlResultToObj(@"
                        SELECT 1
                          FROM TP_MST_USERRIGHT
                         WHERE (FUNCTIONCODE = '[ALL]' OR FUNCTIONCODE = '040116')
                           AND USERID = " + user.UserID);

					if (isExists == null)
					{
						sre.Status = Constant.ServiceResultStatus.Other;
						sre.OtherStatus = -100;
						sre.Message = "当前工号没有修改试验线的权限";
						return sre;
					}
				}

				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				//修改成型线信息
				StringBuilder sbSql = new StringBuilder();

				sbSql.Append("update TP_PC_GroutingLine SET ");
				sbSql.Append("MouldQuantity=:MouldQuantity,");
				sbSql.Append("GMouldTypeID=:GMouldTypeID,");
				sbSql.Append("UserID=:UserID,");
				sbSql.Append("GROUTINGLINENAME=:GROUTINGLINENAME,");
				sbSql.Append("MonitorID=:MonitorID,");
				//xuwei add 2019-11-13 高压注浆
				sbSql.Append("HighPressureFlag=:HighPressureFlag,");
				//xuwei end
				//xuwei add 2021-09-12 部门
				sbSql.Append("WorkShop=:WorkShop,");
				//xuwei end
				//feiy add 2022-03-25 试验线
				sbSql.Append("TestFlag=:TestFlag,");
				//feiy end
				sbSql.Append("Remarks=:Remarks,");
				sbSql.Append("AccountID=:AccountID,");
				sbSql.Append("ValueFlag=:ValueFlag2,");
				sbSql.Append("UpdateTime=:UpdateTime,");
				sbSql.Append("UpdateUserID=:UpdateUserID,");
				sbSql.Append("UserCount=:UserCount,");
				//qq end 20260311 注浆线组
				sbSql.Append("H_LINECODE=:HLINECODE,");
				sbSql.Append("H_LINEINDEX=:HLINEINDEX");

				sbSql.Append(" where GroutingLineID=:GroutingLineID and OPTimeStamp=:OPTimeStamp and GMouldStatus=1");
				if (groutingLineEntity.VALUEFLAG == 0)
				{
					groutingLineEntity.ENDUSEDDATE = DateTime.Now;
				}
				else
				{
					groutingLineEntity.ENDUSEDDATE = null;
				}
				int MouldQuantity_temp = 0;
				if (detailList != null)
				{
					// 验证模具条码
					DataRow[] moulds = detailList.Select("MouldID is not null");
					if (moulds != null && moulds.Length > 0)
					{
						List<string> ids = new List<string>();
						foreach (DataRow item in moulds)
						{
							string id = item["MouldID"].ToString();
							if (!ids.Contains(id))
							{
								ids.Add(id);
							}
						}
						string idswhere = string.Join(",", ids);
						string sql = "select mouldid from tp_pc_mould m where m.mouldid in (" + idswhere + ") for update";
						oracleTrConn.GetSqlResultToDt(sql);

						sql = "select mouldbarcode from tp_pc_mould m where m.mouldstatus not in (1,3) and m.mouldid in (" + idswhere + ")";
						DataTable dt = oracleTrConn.GetSqlResultToDt(sql);
						if (dt != null && dt.Rows.Count > 0)
						{
							ids.Clear();
							foreach (DataRow item in dt.Rows)
							{
								ids.Add(item["mouldbarcode"].ToString());
							}

							sre.Status = Constant.ServiceResultStatus.Other;
							sre.OtherStatus = -100;
							sre.Message = "以下模具的状态不是【在库】或【待产】，不能添加到成型线。" + System.Environment.NewLine
								+ string.Join(",", ids);
							return sre;
						}

						string sqldt111 = @"
						 SELECT
						  G.MOULDMATERIALCODE AS MATNR,
						  COUNT(G.MOULDMATERIALCODE) AS mouldcount
						FROM TP_PC_MOULD M 
						INNER JOIN TP_MST_GOODS G ON M.GOODSID = G.GOODSID
						WHERE M.MOULDSTATUS = 1 AND M.MOULDTYPE <> 86 AND M.MouldID in(" + idswhere + ") group by G.MOULDMATERIALCODE";
						newTable = oracleTrConn.GetSqlResultToDt(sqldt111, null);
					}
					MouldQuantity_temp = detailList.Rows.Count;
				}
				if (UpdatedetailList != null)
				{
					MouldQuantity_temp += UpdatedetailList.Rows.Count;
				}
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":MouldQuantity",OracleDbType.Decimal,
							MouldQuantity_temp,ParameterDirection.Input),
						new OracleParameter(":GMouldTypeID",OracleDbType.Int32,
							groutingLineEntity.MOULDTYPEID,ParameterDirection.Input),
						new OracleParameter(":UserID",OracleDbType.Int32,
                            //Convert.ToInt32(detailUserList.Rows[0]["userid"]),ParameterDirection.Input),
                            groutingLineEntity.USERID,ParameterDirection.Input),
						new OracleParameter(":GROUTINGLINENAME",OracleDbType.NVarchar2,
							groutingLineEntity.GROUTINGLINENAME,ParameterDirection.Input),
						new OracleParameter(":MonitorID",OracleDbType.Int32,
							groutingLineEntity.MonitorID,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							groutingLineEntity.REMARKS,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							groutingLineEntity.ACCOUNTID,ParameterDirection.Input),
						new OracleParameter(":ValueFlag2",OracleDbType.Char,
							groutingLineEntity.ValueFlag2,ParameterDirection.Input),
                        //xuwei add 2019-11-13 高压注浆
                        new OracleParameter(":HighPressureFlag",OracleDbType.Char,
							groutingLineEntity.HIGHPRESSUREFLAG,ParameterDirection.Input),
                        //xuwei end 
                        //xuwei add 2021-09-12 部门
                        new OracleParameter(":WorkShop",OracleDbType.Int32,
							groutingLineEntity.WORKSHOP,ParameterDirection.Input),
                        //xuwei end 
                         //feiy add 2022-03-25 试验线
                        new OracleParameter(":TestFlag",OracleDbType.Int32,
							groutingLineEntity.TestFlag,ParameterDirection.Input),
                        //feiy end
                        new OracleParameter(":UpdateTime",OracleDbType.Date,
							DateTime.Now,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							groutingLineEntity.OPTIMESTAMP,ParameterDirection.Input),
						new OracleParameter(":UserCount",OracleDbType.Int32,
							detailUserList.Rows.Count,ParameterDirection.Input),
						//qq end 20260311 注浆线组
						new OracleParameter(":HLINECODE",OracleDbType.NVarchar2,
							groutingLineEntity.HLINECODE,ParameterDirection.Input),
						new OracleParameter(":HLINEINDEX",OracleDbType.NVarchar2,
							groutingLineEntity.HLINEINDEX,ParameterDirection.Input), 
			};
				//执行修改语句
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				//时间戳无法匹配
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();

					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = -500;
					return sre;
				}
				int detailReturn = 0;

				if (UpdatedetailList != null)
				{
					//添加修改时新建的模具信息
					foreach (DataRow detailInfo in UpdatedetailList.Rows)
					{
						sbSql.Clear();
						sbSql.Append("Update TP_PC_GroutingLineDetail set Remarks=:Remarks,UpdateUserID=:UpdateUserID,StandardGroutingCount=:StandardGroutingCount where GroutingLineDetailID=:GroutingLineDetailID");
						OracleParameter[] DetailParas = new OracleParameter[] {
							new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
								detailInfo["GROUTINGLINEDETAILID"],ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.NVarchar2,
								detailInfo["REMARKS"],ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
								user.UserID,ParameterDirection.Input),
							new OracleParameter(":StandardGroutingCount",OracleDbType.Decimal,
								detailInfo["StandardGroutingCount"],ParameterDirection.Input),
						};
						//执行
						detailReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);
					}
				}
				if (detailList != null)
				{
					// 一模多产时，同一模具只操作一次。 add by chenxy 2018-10-29
					List<int> mouldIDs = new List<int>();
					//添加修改时新建的模具信息
					foreach (DataRow detailInfo in detailList.Rows)
					{
						//模具明细编号唯一
						if (GroutingLineDetailCodeIsRepeat(detailInfo["GROUTINGMOULDCODE"].ToString(), user.AccountID) == false)
						{
							oracleTrConn.Rollback();
							oracleTrConn.Disconnect();
							sre.Status = Constant.ServiceResultStatus.Other;
							sre.OtherStatus = -2;
							return sre;
						}
						//获取模具明细索引
						sbSql.Clear();
						sbSql.Append("select SEQ_PC_GroutingLineDetail_ID.nextval from dual");
						int detailId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
						sbSql.Clear();
						//插入新增的模具信息
						sbSql.Append("Insert into TP_PC_GroutingLineDetail");
						sbSql.Append("(GroutingLineDetailID,GroutingLineID,GroutingMouldCode,GoodsID,StandardGroutingCount,GroutingCount,");
						sbSql.Append("GMouldStatus,BeginUsedDate,Remarks,AccountID,");
						sbSql.Append("MouldSource,MouldID,MouldCode,MouldOutputNo,");
						sbSql.Append("CreateUserID,UpdateUserID)");
						sbSql.Append("Values(:GroutingLineDetailID,:GroutingLineID,:GroutingMouldCode,:GoodsID,:StandardGroutingCount,:GroutingCount,");
						sbSql.Append(":GMouldStatus,:BeginUsedDate,:Remarks,:AccountID,");
						sbSql.Append(":MouldSource,:MouldID,:MouldCode,:MouldOutputNo,");
						sbSql.Append(":CreateUserID,:UpdateUserID)");
						OracleParameter[] DetailParas = new OracleParameter[] {
							new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
								detailId,ParameterDirection.Input),
							new OracleParameter(":GroutingLineID",OracleDbType.Int32,
								groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input),
							new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
								detailInfo["GROUTINGMOULDCODE"],ParameterDirection.Input),
							new OracleParameter(":GoodsID",OracleDbType.Int32,
								detailInfo["GOODSID"],ParameterDirection.Input),
							new OracleParameter(":StandardGroutingCount",OracleDbType.Decimal,
								detailInfo["StandardGroutingCount"],ParameterDirection.Input),
							new OracleParameter(":GroutingCount",OracleDbType.Decimal,
								detailInfo["GROUTINGCOUNT"],ParameterDirection.Input),
							new OracleParameter(":GMouldStatus",OracleDbType.Int32,
								1, ParameterDirection.Input),
							new OracleParameter(":BeginUsedDate",OracleDbType.Date,
								accountDate,ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.NVarchar2,
								detailInfo["REMARKS"],ParameterDirection.Input),
							new OracleParameter(":AccountID",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
								user.UserID,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
								user.UserID,ParameterDirection.Input),
							new OracleParameter(":MouldSource",OracleDbType.Char,
								detailInfo["MouldSource"],ParameterDirection.Input),
							new OracleParameter(":MouldID",OracleDbType.Int32,
								detailInfo["MouldID"],ParameterDirection.Input),
							new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
								detailInfo["MouldCode"],ParameterDirection.Input),
							new OracleParameter(":MouldOutputNo",OracleDbType.Int32,
								detailInfo["MouldOutputNo"],ParameterDirection.Input),
						};
						//执行
						detailReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);

						// 非条码模具
						if (detailInfo["MouldID"] + "" == "")
						{
							continue;
						}
						// 一模多产时，同一模具只操作一次。（不能有多履历，会导致模具收发存等报表统计错误） add by chenxy 2018-10-29
						int mID = Convert.ToInt32(detailInfo["MouldID"]);

						object mOutputNo = detailInfo["MouldOutputNo"];
						if (mOutputNo != null && mOutputNo != DBNull.Value)
						{
							string sql = "UPDATE tp_pc_mouldoutput m\n" +
							"   SET m.GroutingLineDetailID = :GroutingLineDetailID\n" +
							" WHERE m.mouldid = :mouldid and m.OutputNo=:OutputNo";

							OracleParameter[] oparas = new OracleParameter[]
							{
							new OracleParameter(":OutputNo", OracleDbType.Int32,
								mOutputNo, ParameterDirection.Input),
							new OracleParameter(":mouldid", OracleDbType.Int32,
								mID, ParameterDirection.Input),
							new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
								detailId, ParameterDirection.Input),
							};
							detailReturn += oracleTrConn.ExecuteNonQuery(sql, oparas);
						}
						if (mouldIDs.Contains(mID))
						{
							continue;
						}
						mouldIDs.Add(mID);

						// 添加模具履历
						int mouldHistoryID = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select seq_pc_mouldhistory_id.nextval from dual "));

						string sqlString =
						"INSERT INTO tp_pc_mouldchangehistory\n" +
						"  (CHANGEID\n" +
						"  ,MOULDID\n" +
						"  ,MOULDCODE\n" +
						"  ,MOULDBARCODE\n" +
						"  ,GOODSID\n" +
						"  ,GOODSCODE\n" +
						"  ,OPERATIONTYPE\n" +
						"  ,GroutingLineDetailID\n" +
						"  ,MOULDSTATUS\n" +
						"  ,MOULDSTATUSAFTER\n" +
						"  ,GROUTINGNUM\n" +
						"  ,REMARKS\n" +
						"  ,CHANGEFLAG\n" +
						"  ,ACCOUNTID\n" +
						"  ,CREATEUSERID)\n" +
						"  SELECT :changeID\n" +
						"        ,:mouldid\n" +
						"        ,:MOULDCODE\n" +
						"        ,m.mouldbarcode\n" +
						"        ,m.goodsid\n" +
						"        ,m.goodscode\n" +
						"        ,decode(m.mouldstatus, 1, 6, 3, 10) OPERATIONTYPE\n" +
						"        ,:GroutingLineDetailID\n" +
						"        ,m.mouldstatus\n" +
						"        ,2\n" +
						"        ,m.groutingnum\n" +
						"        ,:REMARKS\n" +
						"        ,decode(m.mouldstatus, 1, '2', 3, '0') CHANGEFLAG\n" +
						"        ,:ACCOUNTID\n" +
						"        ,:USERID\n" +
						"    FROM tp_pc_mould m\n" +
						"   WHERE m.mouldid = :mouldid";
						OracleParameter[] paras = new OracleParameter[]
						{
							new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
								detailId, ParameterDirection.Input),
							new OracleParameter(":changeID", OracleDbType.Int32,
								mouldHistoryID, ParameterDirection.Input),
							new OracleParameter(":MouldID", OracleDbType.Int32,
								detailInfo["MouldID"], ParameterDirection.Input),
							new OracleParameter(":MOULDCODE", OracleDbType.Varchar2,
								detailInfo["MOULDCODE"], ParameterDirection.Input),
							new OracleParameter(":REMARKS", OracleDbType.NVarchar2,
								detailInfo["Remarks"], ParameterDirection.Input),
							new OracleParameter(":ACCOUNTID", OracleDbType.Int32,
								user.AccountID, ParameterDirection.Input),
							new OracleParameter(":USERID", OracleDbType.Int32,
								user.UserID, ParameterDirection.Input),
						};
						detailReturn += oracleTrConn.ExecuteNonQuery(sqlString, paras);

						// 修改模具状态
						sqlString = "UPDATE tp_pc_mould m\n" +
						"   SET m.premouldstatus      = m.mouldstatus\n" +
						"      ,m.mouldstatus         = :mouldstatus\n" +
						"      ,m.updateuserid        = :userid\n" +
						"      ,m.lastchangehistoryid = :changeid\n" +
						"      ,m.GroutingLineDetailID = :GroutingLineDetailID\n" +
						" WHERE m.mouldid = :mouldid";

						paras = new OracleParameter[]
						{
							new OracleParameter(":mouldstatus", OracleDbType.Int32,
								(int)Constant.MouldStatus.OnLine, ParameterDirection.Input),
							new OracleParameter(":changeid", OracleDbType.Int32,
								mouldHistoryID, ParameterDirection.Input),
							new OracleParameter(":userid", OracleDbType.Int32,
								user.UserID, ParameterDirection.Input),
							new OracleParameter(":mouldid", OracleDbType.Int32,
								detailInfo["MouldID"], ParameterDirection.Input),
							new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
								detailId, ParameterDirection.Input),
						};
						detailReturn += oracleTrConn.ExecuteNonQuery(sqlString, paras);

					}
				}

				if (groutingLineEntity.GROUTINGLINEIDS == null)
				{
					string sqlDelete = "delete from TP_PC_GroutingUser where GroutingLineID=" + groutingLineEntity.GROUTINGLINEID.ToString();
					detailReturn += oracleTrConn.ExecuteNonQuery(sqlDelete);
					// 添加成型工号
					foreach (DataRow detailInfo in detailUserList.Rows)
					{
						sbSql.Clear();
						//插入成型线明细信息
						sbSql.Append("Insert into TP_PC_GroutingUser");
						sbSql.Append("(GroutingLineID,UserID,Remarks)");
						sbSql.Append("Values(:GroutingLineID,:UserID,:Remarks)");
						OracleParameter[] DetailParas = new OracleParameter[] {
							new OracleParameter(":GroutingLineID",OracleDbType.Int32,
								groutingLineEntity.GROUTINGLINEID,ParameterDirection.Input),
							new OracleParameter(":UserID",OracleDbType.Int32,
								detailInfo["USERID"],ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.NVarchar2,
								detailInfo["REMARK"],ParameterDirection.Input),
						};
						//执行插入语句并累加成功插入次数
						detailReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);
					}
				}
				// 庆祥要求，整线换模或变产后，成型线开始使用日期是成型线中模具最小开始使用日期。
				string sqlLine = "update TP_PC_GROUTINGLINE l " +
							"   set l.beginuseddate =" +
							"       nvl((select min(ld.beginuseddate)" +
							"          from TP_PC_GROUTINGLINEDETAIL ld" +
							"         where ld.groutinglineid = l.groutinglineid" +
							"           and ld.valueflag = '1'),l.beginuseddate)" +
							" where l.groutinglineid = " + groutingLineEntity.GROUTINGLINEID;
				oracleTrConn.ExecuteNonQuery(sqlLine, null);

				// 梓滨要求，修改成型线试验标识时，整条线上的模具都改
				if (!(oriTestFlag + "").Equals(groutingLineEntity.TestFlag + ""))
				{
					string sqlMouldString =
					@"UPDATE TP_PC_MOULD
                         SET TESTMOULDFLAG = '" + groutingLineEntity.TestFlag + @"'
                       WHERE MOULDID IN (SELECT MOULDID
                                           FROM TP_PC_GROUTINGLINEDETAIL T
                                          WHERE VALUEFLAG = '1'
                                            AND GROUTINGLINEID = " + groutingLineEntity.GROUTINGLINEID + ")";
					oracleTrConn.ExecuteNonQuery(sqlMouldString);
				}

				// 上模时，如果成型线是试验线，则模具自动勾选试验标识
				if (groutingLineEntity.GROUTINGLINEIDS == "0" && (oriTestFlag + "").Equals("1"))
				{
					string sqlMouldString =
					@"UPDATE TP_PC_MOULD
                         SET TESTMOULDFLAG = '1'
                       WHERE TESTMOULDFLAG = '0'
                         AND MOULDID IN (SELECT MOULDID
                                           FROM TP_PC_GROUTINGLINEDETAIL T
                                          WHERE VALUEFLAG = '1'
                                            AND GROUTINGLINEID = " + groutingLineEntity.GROUTINGLINEID + ")";
					oracleTrConn.ExecuteNonQuery(sqlMouldString);
				}

				#region SAP模具在产状态更新
				if (groutingLineEntity.GROUTINGLINEIDS == "0")
				{
					#region 模具在库→在产（上模PDA）
					//查询需要传输的Table~
					DataTable dtMateriaTransferDetail = new DataTable();
					//DataTable dtMateriaTransferDetail1 = new DataTable();
					DataTable detailListInfo = new DataTable();
					//DataView dv = new DataView(detailList);
					//detailListInfo = dv.ToTable(true, "MouldID");
					string sqldt = string.Empty;
					if (newTable != null && newTable.Rows.Count > 0)
					{
						int groutingLineID1 = Convert.ToInt32(groutingLineEntity.GROUTINGLINEID);
						if (UpdatedetailList == null)
						{
							groutingLineID1 = Convert.ToInt32(groutingLineEntity.GROUTINGLINEID);
						}
						else if (UpdatedetailList.Rows.Count > 0)
						{
							groutingLineID1 = Convert.ToInt32(UpdatedetailList.Rows[0]["GROUTINGLINEID"]);
						}
						sqldt = @"
						SELECT
							CASE WHEN INSTR(GL.GROUTINGLINECODE, 'A') = 1 THEN '2110'
							WHEN (INSTR(GL.GROUTINGLINECODE, 'B') = 1 OR INSTR(GL.GROUTINGLINECODE, 'D') = 1) THEN '2210'
							WHEN INSTR(GL.GROUTINGLINECODE, 'C') = 1 THEN '2310'
							ELSE ''
							END AS LGORT_TO,
							G.MOULDMATERIALCODE AS MATNR
						FROM
							TP_PC_GROUTINGLINEDETAIL GLD
						INNER JOIN TP_PC_GROUTINGLINE GL ON GL.GROUTINGLINEID = GLD.GROUTINGLINEID
						INNER JOIN TP_PC_MOULD M ON M.MOULDCODE = GLD.MOULDCODE
						INNER JOIN TP_MST_GOODS G ON M.GOODSID = G.GOODSID
						WHERE
							GL.GROUTINGLINEID = " + groutingLineID1 + " AND GLD.VALUEFLAG = 1";
						dtMateriaTransferDetail = oracleTrConn.GetSqlResultToDt(sqldt, null);

						//List<string> codes = new List<string>();
						//foreach (DataRow item in detailListInfo.Rows)
						//{
						//	string code = item["MOULDBARCODE"].ToString();
						//	if (!codes.Contains(code))
						//	{
						//		codes.Add("'"+code+"'");
						//	}
						//}
						//string codeswhere = string.Join(",", codes);

						//sqldt = @"
						// SELECT
						//  G.MOULDMATERIALCODE AS MATNR,
						//  COUNT(G.MOULDMATERIALCODE) AS mouldcount
						//FROM TP_PC_MOULD M 
						//INNER JOIN TP_MST_GOODS G ON M.GOODSID = G.GOODSID
						//WHERE  M.MOULDSTATUS = 1 AND M.MOULDBARCODE in(" + codeswhere + ")  group by G.MOULDMATERIALCODE";
						//dtMateriaTransferDetail1 = oracleTrConn.GetSqlResultToDt(sqldt, null);
						#endregion

						#region 获取东科单据号
						int ZDKNO = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select SEQ_MOULDCHANGELOGID.NEXTVAL from dual "));
						#endregion

						#region 普通参数
						DateTime createTime = DateTime.Now;
						//消息类型: S 成功,E 错误
						string ZTYPE;
						//消息文本
						string ZMSG;
						#endregion

						#region 调用SAP接口方法
						string upsql = string.Empty;
						DataTable dtResult = new DataTable();

						for (int j = 0; j < newTable.Rows.Count; j++)
						{
							int count = Convert.ToInt32(newTable.Rows[j]["mouldcount"]);

							dtResult = ZMMFM045(createTime.ToString("yyyyMMdd"), ZDKNO + "", dtMateriaTransferDetail, newTable.Rows[j]["MATNR"].ToString(), count, out ZTYPE, out ZMSG);

							if (dtResult != null && dtResult.Rows.Count > 0)
							{
								if ("S".Equals(ZTYPE))
								{
									#region 插入SAP模具变更传输日志
									string insql = @"
							INSERT INTO TP_SAP_MOULDCHANGELOG 
							( BLDAT
							, BUDAT
							, WERKS
							, LGORT_FM
							, LGORT_TO
							, MATNR
							, BWART
							, MEINS
							, MENGE
							, MBLNR
							, MJAHR
							, MSGTY
							, MSGTX)
							VALUES
							( SYSDATE
							, SYSDATE
							, '5000'
							, '3001'
							, :LGORT_TO
							, :MATNR
							, '311'
							, 'PCS'
							, :MENGE 
							, :MBLNR
							, :MJAHR
							, :MSGTY
							, :MSGTX)";
									OracleParameter[] inparas = new OracleParameter[]{
								new OracleParameter(":LGORT_TO", OracleDbType.NVarchar2,ZDKNO, ParameterDirection.Input),
								new OracleParameter(":LGORT_TO", OracleDbType.NVarchar2,dtMateriaTransferDetail.Rows[0]["LGORT_TO"], ParameterDirection.Input),
								new OracleParameter(":MATNR", OracleDbType.NVarchar2,newTable.Rows[j]["MATNR"], ParameterDirection.Input),
								new OracleParameter(":MENGE", OracleDbType.Int32,count, ParameterDirection.Input),
								new OracleParameter(":MBLNR", OracleDbType.NVarchar2, dtResult.Rows[0]["MBLNR"].ToString(), ParameterDirection.Input),
								new OracleParameter(":MJAHR", OracleDbType.NVarchar2,dtResult.Rows[0]["MJAHR"].ToString(), ParameterDirection.Input),
								new OracleParameter(":MSGTY", OracleDbType.NVarchar2,dtResult.Rows[0]["MSGTY"].ToString(), ParameterDirection.Input),
								new OracleParameter(":MSGTX", OracleDbType.NVarchar2,dtResult.Rows[0]["MSGTX"].ToString(), ParameterDirection.Input)
							};
									oracleTrConn.ExecuteNonQuery(insql, inparas);
									#endregion
								}
								else if ("E".Equals(ZTYPE))
								{
									#region 插入SAP模具变更传输日志
									string insql = @"
							INSERT INTO TP_SAP_MOULDCHANGELOG 
							( BLDAT
							, BUDAT
							, WERKS
							, LGORT_FM
							, LGORT_TO
							, MATNR
							, BWART
							, MEINS
							, MENGE
							, MBLNR
							, MJAHR
							, MSGTY
							, MSGTX)
							VALUES
							( SYSDATE
							, SYSDATE
							, '5000'
							, '3001'
							, :LGORT_TO
							, :MATNR
							, '311'
							, 'PCS'
							, :MENGE 
							, :MBLNR
							, :MJAHR
							, :MSGTY
							, :MSGTX)";
									OracleParameter[] inparas = new OracleParameter[]{
								new OracleParameter(":LGORT_TO", OracleDbType.NVarchar2,ZDKNO, ParameterDirection.Input),
								new OracleParameter(":LGORT_TO", OracleDbType.NVarchar2,dtMateriaTransferDetail.Rows[0]["LGORT_TO"], ParameterDirection.Input),
								new OracleParameter(":MATNR", OracleDbType.NVarchar2,newTable.Rows[j]["MATNR"], ParameterDirection.Input),
								new OracleParameter(":MENGE", OracleDbType.Int32,count, ParameterDirection.Input),
								new OracleParameter(":MBLNR", OracleDbType.NVarchar2, dtResult.Rows[0]["MBLNR"].ToString(), ParameterDirection.Input),
								new OracleParameter(":MJAHR", OracleDbType.NVarchar2,dtResult.Rows[0]["MJAHR"].ToString(), ParameterDirection.Input),
								new OracleParameter(":MSGTY", OracleDbType.NVarchar2,dtResult.Rows[0]["MSGTY"].ToString(), ParameterDirection.Input),
								new OracleParameter(":MSGTX", OracleDbType.NVarchar2,dtResult.Rows[0]["MSGTX"].ToString(), ParameterDirection.Input)
							};
									oracleTrConn.ExecuteNonQuery(insql, inparas);
									#endregion

									if (dtResult != null && dtResult.Rows.Count > 0)
									{
										sre.Status = Constant.ServiceResultStatus.Other;
										sre.OtherStatus = -10001;
										sre.Message = dtResult.Rows[0]["MSGTX"].ToString();
										oracleTrConn.Rollback();
										oracleTrConn.Disconnect();
										return sre;
									}
									else
									{
										sre.Status = Constant.ServiceResultStatus.Other;
										sre.OtherStatus = -10002;
										sre.Message = dtResult.Rows[0]["MSGTX"].ToString();
										oracleTrConn.Rollback();
										oracleTrConn.Disconnect();
										return sre;
									}
								}
							}
						}
						#endregion
					}
				}
				#endregion

				//提交事务
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			return sre;
		}

		/// <summary>
		/// 上模
		/// </summary>
		public static ServiceResultEntity UpdateGroutingLine_AddMould(int groutingLineID, string groutingLineCode, DateTime lineTimeStamp,
		   DataTable detailList, SUserInfo user)
		{
			ServiceResultEntity sre = new ServiceResultEntity();
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();

				DataTable newTable = new DataTable();
				if (detailList != null)
				{
					// 验证模具条码
					DataRow[] moulds = detailList.Select("MouldID is not null and GroutingLineDetailID = 0");
					if (moulds != null && moulds.Length > 0)
					{
						List<string> ids = new List<string>();
						foreach (DataRow item in moulds)
						{
							//ids.Add(item["MouldID"].ToString());
							string id = item["MouldID"].ToString();
							if (!ids.Contains(id))
							{
								ids.Add(id);
							}
						}
						string idswhere = string.Join(",", ids);
						string sql = "select mouldid from tp_pc_mould m where m.mouldid in (" + idswhere + ") for update";
						oracleTrConn.GetSqlResultToDt(sql);

						sql = "select mouldbarcode from tp_pc_mould m where m.mouldstatus not in (1,3) and m.mouldid in (" + idswhere + ")";
						DataTable dt = oracleTrConn.GetSqlResultToDt(sql);
						if (dt != null && dt.Rows.Count > 0)
						{
							ids.Clear();
							foreach (DataRow item in dt.Rows)
							{
								ids.Add(item["mouldbarcode"].ToString());
							}

							sre.Status = Constant.ServiceResultStatus.Other;
							sre.OtherStatus = -100;
							sre.Message = "以下模具的状态不是【在库】或【待产】，不能添加到成型线。" + System.Environment.NewLine
								+ string.Join(",", ids);
							return sre;
						}

						string sqldt111 = @"
						 SELECT
						  G.MOULDMATERIALCODE AS MATNR,
						  COUNT(G.MOULDMATERIALCODE) AS mouldcount
						FROM TP_PC_MOULD M 
						INNER JOIN TP_MST_GOODS G ON M.GOODSID = G.GOODSID
						WHERE M.MOULDSTATUS = 1 AND M.MOULDTYPE <> 86 AND M.MouldID in(" + idswhere + ") group by G.MOULDMATERIALCODE";
						newTable = oracleTrConn.GetSqlResultToDt(sqldt111, null); 
					}
				}

				//修改成型线信息
				StringBuilder sbSql = new StringBuilder();

				sbSql.Append("update TP_PC_GroutingLine SET ");
				sbSql.Append("MouldQuantity=MouldQuantity+:MouldQuantity,");
				sbSql.Append("UpdateUserID=:UpdateUserID");
				sbSql.Append(" where GroutingLineID=:GroutingLineID and OPTimeStamp=:OPTimeStamp");

				OracleParameter[] Paras = new OracleParameter[] {
					new OracleParameter(":MouldQuantity",OracleDbType.Decimal,
						(detailList == null ? 0 : detailList.Rows.Count), ParameterDirection.Input),
					new OracleParameter(":UpdateUserID",OracleDbType.Int32,
						user.UserID,ParameterDirection.Input),
					new OracleParameter(":GroutingLineID",OracleDbType.Int32,
						groutingLineID,ParameterDirection.Input),
					new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
						lineTimeStamp,ParameterDirection.Input),
				};
				//执行修改语句
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
				//时间戳无法匹配
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();

					sre.Status = Constant.ServiceResultStatus.Other;
					sre.OtherStatus = -500;
					return sre;
				}
				int detailReturn = 0;
				if (detailList != null && detailList.Rows.Count > 0)
				{
					// 一模多产时，同一模具只操作一次。 add by chenxy 2018-10-29
					List<int> mouldIDs = new List<int>();
					// 获得账务日期
					DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
					//添加修改时新建的模具信息
					foreach (DataRow detailInfo in detailList.Rows)
					{
						int detailID = Convert.ToInt32(detailInfo["GroutingLineDetailID"]);

						// 编辑
						if (detailID > 0)
						{
							sbSql.Clear();
							sbSql.Append("Update TP_PC_GroutingLineDetail set Remarks=:Remarks,UpdateUserID=:UpdateUserID,StandardGroutingCount=:StandardGroutingCount where GroutingLineDetailID=:GroutingLineDetailID");
							OracleParameter[] DetailUpdateParas = new OracleParameter[] {
								new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
									detailID,ParameterDirection.Input),
								new OracleParameter(":Remarks",OracleDbType.NVarchar2,
									detailInfo["REMARKS"],ParameterDirection.Input),
								new OracleParameter(":UpdateUserID",OracleDbType.Int32,
									user.UserID,ParameterDirection.Input),
								new OracleParameter(":StandardGroutingCount",OracleDbType.Decimal,
									detailInfo["StandardGroutingCount"],ParameterDirection.Input),
							};
							//执行
							detailReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailUpdateParas);

							continue;
						}

						//模具明细编号唯一
						if (GroutingLineDetailCodeIsRepeat(detailInfo["GROUTINGMOULDCODE"].ToString(), user.AccountID) == false)
						{
							oracleTrConn.Rollback();
							oracleTrConn.Disconnect();
							sre.Status = Constant.ServiceResultStatus.Other;
							sre.OtherStatus = -2;
							sre.Message = "成型模具号【" + detailInfo["GROUTINGMOULDCODE"] + "】已存在，请确认。";
							return sre;
						}

						//获取模具明细索引
						sbSql.Clear();
						sbSql.Append("select SEQ_PC_GroutingLineDetail_ID.nextval from dual");
						detailID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));

						if (detailInfo["MouldID"] + "" == "" && detailInfo["MouldCode"] + "" == "")
						{
							detailInfo["MouldCode"] = System.Guid.NewGuid().ToString().ToUpper();
						}

						sbSql.Clear();
						//插入新增的模具信息
						sbSql.Append("Insert into TP_PC_GroutingLineDetail");
						sbSql.Append("(GroutingLineDetailID,GroutingLineID,GroutingMouldCode,GoodsID,StandardGroutingCount,GroutingCount,");
						sbSql.Append("GMouldStatus,BeginUsedDate,Remarks,AccountID,");
						sbSql.Append("MouldSource,MouldID,MouldCode,MouldOutputNo,");
						sbSql.Append("CreateUserID,UpdateUserID)");
						sbSql.Append("Values(:GroutingLineDetailID,:GroutingLineID,:GroutingMouldCode,:GoodsID,:StandardGroutingCount,:GroutingCount,");
						sbSql.Append(":GMouldStatus,:BeginUsedDate,:Remarks,:AccountID,");
						sbSql.Append(":MouldSource,:MouldID,:MouldCode,:MouldOutputNo,");
						sbSql.Append(":CreateUserID,:UpdateUserID)");
						OracleParameter[] DetailParas = new OracleParameter[] {
							new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
								detailID,ParameterDirection.Input),
							new OracleParameter(":GroutingLineID",OracleDbType.Int32,
								groutingLineID,ParameterDirection.Input),
							new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
								detailInfo["GROUTINGMOULDCODE"],ParameterDirection.Input),
							new OracleParameter(":GoodsID",OracleDbType.Int32,
								detailInfo["GOODSID"],ParameterDirection.Input),
							new OracleParameter(":StandardGroutingCount",OracleDbType.Decimal,
								detailInfo["StandardGroutingCount"],ParameterDirection.Input),
							new OracleParameter(":GroutingCount",OracleDbType.Decimal,
								detailInfo["GROUTINGCOUNT"],ParameterDirection.Input),
							new OracleParameter(":GMouldStatus",OracleDbType.Int32,
								1, ParameterDirection.Input),
							new OracleParameter(":BeginUsedDate",OracleDbType.Date,
								accountDate,ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.NVarchar2,
								detailInfo["REMARKS"],ParameterDirection.Input),
							new OracleParameter(":AccountID",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
								user.UserID,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
								user.UserID,ParameterDirection.Input),
							new OracleParameter(":MouldSource",OracleDbType.Char,
								detailInfo["MouldSource"],ParameterDirection.Input),
							new OracleParameter(":MouldID",OracleDbType.Int32,
								detailInfo["MouldID"],ParameterDirection.Input),
							new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
								detailInfo["MouldCode"],ParameterDirection.Input),
							new OracleParameter(":MouldOutputNo",OracleDbType.Int32,
								detailInfo["MouldOutputNo"],ParameterDirection.Input),
						};
						//执行
						detailReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);

						// 非条码模具
						if (detailInfo["MouldID"] + "" == "")
						{
							continue;
						}
						// 一模多产时，同一模具只操作一次。（不能有多履历，会导致模具收发存等报表统计错误） add by chenxy 2018-10-29
						int mID = Convert.ToInt32(detailInfo["MouldID"]);
						object mOutputNo = detailInfo["MouldOutputNo"];
						if (mOutputNo != null && mOutputNo != DBNull.Value)
						{
							string sql = "UPDATE tp_pc_mouldoutput m\n" +
							"   SET m.GroutingLineDetailID = :GroutingLineDetailID\n" +
							" WHERE m.mouldid = :mouldid and m.OutputNo=:OutputNo";

							OracleParameter[] oparas = new OracleParameter[]
							{
							new OracleParameter(":OutputNo", OracleDbType.Int32,
								mOutputNo, ParameterDirection.Input),
							new OracleParameter(":mouldid", OracleDbType.Int32,
								mID, ParameterDirection.Input),
							new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
								detailID, ParameterDirection.Input),
							};
							returnRows += oracleTrConn.ExecuteNonQuery(sql, oparas);
						}
						if (mouldIDs.Contains(mID))
						{
							continue;
						}
						mouldIDs.Add(mID);

						// 添加模具履历
						int mouldHistoryID = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select seq_pc_mouldhistory_id.nextval from dual "));

						string sqlString =
						"INSERT INTO tp_pc_mouldchangehistory\n" +
						"  (CHANGEID\n" +
						"  ,MOULDID\n" +
						"  ,MOULDCODE\n" +
						"  ,MOULDBARCODE\n" +
						"  ,GOODSID\n" +
						"  ,GOODSCODE\n" +
						"  ,OPERATIONTYPE\n" +
						"  ,GroutingLineDetailID\n" +
						"  ,MOULDSTATUS\n" +
						"  ,MOULDSTATUSAFTER\n" +
						"  ,GROUTINGNUM\n" +
						"  ,REMARKS\n" +
						"  ,CHANGEFLAG\n" +
						"  ,ACCOUNTID\n" +
						"  ,CREATEUSERID)\n" +
						"  SELECT :changeID\n" +
						"        ,:mouldid\n" +
						"        ,:MOULDCODE\n" +
						"        ,m.mouldbarcode\n" +
						"        ,m.goodsid\n" +
						"        ,m.goodscode\n" +
						"        ,decode(m.mouldstatus, 1, 6, 3, 10) OPERATIONTYPE\n" +
						"        ,:GroutingLineDetailID\n" +
						"        ,m.mouldstatus\n" +
						"        ,2\n" +
						"        ,m.groutingnum\n" +
						"        ,:REMARKS\n" +
						"        ,decode(m.mouldstatus, 1, '2', 3, '0') CHANGEFLAG\n" +
						"        ,:ACCOUNTID\n" +
						"        ,:USERID\n" +
						"    FROM tp_pc_mould m\n" +
						"   WHERE m.mouldid = :mouldid";
						OracleParameter[] paras = new OracleParameter[]
						{
							new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
								detailID, ParameterDirection.Input),
							new OracleParameter(":changeID", OracleDbType.Int32,
								mouldHistoryID, ParameterDirection.Input),
							new OracleParameter(":MouldID", OracleDbType.Int32,
								detailInfo["MouldID"], ParameterDirection.Input),
							new OracleParameter(":MOULDCODE", OracleDbType.Varchar2,
								detailInfo["MOULDCODE"], ParameterDirection.Input),
							new OracleParameter(":REMARKS", OracleDbType.NVarchar2,
								detailInfo["Remarks"], ParameterDirection.Input),
							new OracleParameter(":ACCOUNTID", OracleDbType.Int32,
								user.AccountID, ParameterDirection.Input),
							new OracleParameter(":USERID", OracleDbType.Int32,
								user.UserID, ParameterDirection.Input),
						};
						detailReturn += oracleTrConn.ExecuteNonQuery(sqlString, paras);

						// 修改模具状态
						sqlString = "UPDATE tp_pc_mould m\n" +
						"   SET m.premouldstatus      = m.mouldstatus\n" +
						"      ,m.mouldstatus         = :mouldstatus\n" +
						"      ,m.updateuserid        = :userid\n" +
						"      ,m.lastchangehistoryid = :changeid\n" +
						"      ,m.GroutingLineDetailID = :GroutingLineDetailID\n" +
						" WHERE m.mouldid = :mouldid";

						paras = new OracleParameter[]
						{
							new OracleParameter(":mouldstatus", OracleDbType.Int32,
								(int)Constant.MouldStatus.OnLine, ParameterDirection.Input),
							new OracleParameter(":changeid", OracleDbType.Int32,
								mouldHistoryID, ParameterDirection.Input),
							new OracleParameter(":userid", OracleDbType.Int32,
								user.UserID, ParameterDirection.Input),
							new OracleParameter(":mouldid", OracleDbType.Int32,
								detailInfo["MouldID"], ParameterDirection.Input),
							new OracleParameter(":GroutingLineDetailID", OracleDbType.Int32,
								detailID, ParameterDirection.Input),
						};
						detailReturn += oracleTrConn.ExecuteNonQuery(sqlString, paras);
					}
				}

				// 庆祥要求，整线换模或变产后，成型线开始使用日期是成型线中模具最小开始使用日期。
				string sqlLine = "update TP_PC_GROUTINGLINE l " +
							"   set l.beginuseddate =" +
							"       nvl((select min(ld.beginuseddate)" +
							"          from TP_PC_GROUTINGLINEDETAIL ld" +
							"         where ld.groutinglineid = l.groutinglineid" +
							"           and ld.valueflag = '1'),l.beginuseddate)" +
							" where l.groutinglineid = " + groutingLineID;
				oracleTrConn.ExecuteNonQuery(sqlLine, null);

				#region SAP模具在产状态更新
				#region 模具在库→在产（上模PDA）
				//查询需要传输的Table~
				DataTable dtMateriaTransferDetail = new DataTable();
				//DataTable dtMateriaTransferDetail1 = new DataTable();
				DataTable detailListInfo = new DataTable();
				//DataView dv = new DataView(detailList);
				//detailListInfo = dv.ToTable(true, "MouldID");
				string sqldt = string.Empty;
				if (newTable != null && newTable.Rows.Count >0)
				{
					sqldt = @"
						SELECT
							CASE WHEN INSTR(GL.GROUTINGLINECODE, 'A') = 1 THEN '2110'
							WHEN (INSTR(GL.GROUTINGLINECODE, 'B') = 1 OR INSTR(GL.GROUTINGLINECODE, 'D') = 1) THEN '2210'
							WHEN INSTR(GL.GROUTINGLINECODE, 'C') = 1 THEN '2310'
							ELSE ''
							END AS LGORT_TO,
							G.MOULDMATERIALCODE AS MATNR
						FROM
							TP_PC_GROUTINGLINEDETAIL GLD
						INNER JOIN TP_PC_GROUTINGLINE GL ON GL.GROUTINGLINEID = GLD.GROUTINGLINEID
						INNER JOIN TP_PC_MOULD M ON M.MOULDCODE = GLD.MOULDCODE
						INNER JOIN TP_MST_GOODS G ON M.GOODSID = G.GOODSID
						WHERE
							GL.GROUTINGLINEID = " + groutingLineID + " AND GLD.VALUEFLAG = 1";
					dtMateriaTransferDetail = oracleTrConn.GetSqlResultToDt(sqldt, null);

					//List<string> codes = new List<string>();
					//foreach (DataRow item in detailListInfo.Rows)
					//{
					//	string code = item["MouldID"].ToString();
					//	if (!codes.Contains(code))
					//	{
					//		codes.Add(code );
					//	}
					//}
					//string codeswhere = string.Join(",", codes);

					//sqldt = @"
					//	 SELECT
					//	  G.MOULDMATERIALCODE AS MATNR,
					//	  COUNT(G.MOULDMATERIALCODE) AS mouldcount
					//	FROM TP_PC_MOULD M 
					//	INNER JOIN TP_MST_GOODS G ON M.GOODSID = G.GOODSID
					//	WHERE M.MOULDSTATUS = 1 AND M.MouldID in(" + codeswhere + ") group by G.MOULDMATERIALCODE";
					//dtMateriaTransferDetail1 = oracleTrConn.GetSqlResultToDt(sqldt, null);

					#region 获取东科单据号
					int ZDKNO = Convert.ToInt32(oracleTrConn.GetSqlResultToObj("select SEQ_MOULDCHANGELOGID.NEXTVAL from dual "));
					#endregion

					#region 普通参数
					DateTime createTime = DateTime.Now;
					//消息类型: S 成功,E 错误
					string ZTYPE;
					//消息文本
					string ZMSG;
					#endregion

					#region 调用SAP接口方法
					string upsql = string.Empty;
					DataTable dtResult = new DataTable();

					for (int j = 0; j < newTable.Rows.Count; j++)
					{
						int count = Convert.ToInt32(newTable.Rows[j]["mouldcount"]);

						dtResult = ZMMFM045(createTime.ToString("yyyyMMdd"), ZDKNO + "", dtMateriaTransferDetail, newTable.Rows[j]["MATNR"].ToString(), count, out ZTYPE, out ZMSG);

						if (dtResult != null && dtResult.Rows.Count > 0)
						{
							if ("S".Equals(ZTYPE))
							{
								#region 插入SAP模具变更传输日志
								string insql = @"
								INSERT INTO TP_SAP_MOULDCHANGELOG 
								( BLDAT
								, BUDAT
								, WERKS
								, LGORT_FM
								, LGORT_TO
								, MATNR
								, BWART
								, MEINS
								, MENGE
								, MBLNR
								, MJAHR
								, MSGTY
								, MSGTX)
								VALUES
								( SYSDATE
								, SYSDATE
								, '5000'
								, '3001'
								, :LGORT_TO
								, :MATNR
								, '311'
								, 'PCS'
								, :MENGE 
								, :MBLNR
								, :MJAHR
								, :MSGTY
								, :MSGTX)";
									OracleParameter[] inparas = new OracleParameter[]{
									new OracleParameter(":LGORT_TO", OracleDbType.NVarchar2,ZDKNO, ParameterDirection.Input),
									new OracleParameter(":LGORT_TO", OracleDbType.NVarchar2,dtMateriaTransferDetail.Rows[0]["LGORT_TO"], ParameterDirection.Input),
									new OracleParameter(":MATNR", OracleDbType.NVarchar2,newTable.Rows[j]["MATNR"], ParameterDirection.Input),
									new OracleParameter(":MENGE", OracleDbType.Int32,count, ParameterDirection.Input),
									new OracleParameter(":MBLNR", OracleDbType.NVarchar2, dtResult.Rows[0]["MBLNR"].ToString(), ParameterDirection.Input),
									new OracleParameter(":MJAHR", OracleDbType.NVarchar2,dtResult.Rows[0]["MJAHR"].ToString(), ParameterDirection.Input),
									new OracleParameter(":MSGTY", OracleDbType.NVarchar2,dtResult.Rows[0]["MSGTY"].ToString(), ParameterDirection.Input),
									new OracleParameter(":MSGTX", OracleDbType.NVarchar2,dtResult.Rows[0]["MSGTX"].ToString(), ParameterDirection.Input)
								};
								oracleTrConn.ExecuteNonQuery(insql, inparas);
								#endregion
							}
							else if ("E".Equals(ZTYPE))
							{
								#region 插入SAP模具变更传输日志
								string insql = @"
						INSERT INTO TP_SAP_MOULDCHANGELOG 
						( BLDAT
						, BUDAT
						, WERKS
						, LGORT_FM
						, LGORT_TO
						, MATNR
						, BWART
						, MEINS
						, MENGE
						, MBLNR
						, MJAHR
						, MSGTY
						, MSGTX)
						VALUES
						( SYSDATE
						, SYSDATE
						, '5000'
						, '3001'
						, :LGORT_TO
						, :MATNR
						, '311'
						, 'PCS'
						, :MENGE 
						, :MBLNR
						, :MJAHR
						, :MSGTY
						, :MSGTX)";
								OracleParameter[] inparas = new OracleParameter[]{
							new OracleParameter(":LGORT_TO", OracleDbType.NVarchar2,ZDKNO, ParameterDirection.Input),
							new OracleParameter(":LGORT_TO", OracleDbType.NVarchar2,dtMateriaTransferDetail.Rows[0]["LGORT_TO"], ParameterDirection.Input),
							new OracleParameter(":MATNR", OracleDbType.NVarchar2,newTable.Rows[j]["MATNR"], ParameterDirection.Input),
							new OracleParameter(":MENGE", OracleDbType.Int32,count, ParameterDirection.Input),
							new OracleParameter(":MBLNR", OracleDbType.NVarchar2, dtResult.Rows[0]["MBLNR"].ToString(), ParameterDirection.Input),
							new OracleParameter(":MJAHR", OracleDbType.NVarchar2,dtResult.Rows[0]["MJAHR"].ToString(), ParameterDirection.Input),
							new OracleParameter(":MSGTY", OracleDbType.NVarchar2,dtResult.Rows[0]["MSGTY"].ToString(), ParameterDirection.Input),
							new OracleParameter(":MSGTX", OracleDbType.NVarchar2,dtResult.Rows[0]["MSGTX"].ToString(), ParameterDirection.Input)
						};
								oracleTrConn.ExecuteNonQuery(insql, inparas);
								#endregion

								if (dtResult.Rows.Count > 0)
								{
									sre.OtherStatus = -10001;
									sre.Status = Constant.ServiceResultStatus.SystemError;
									sre.Message = dtResult.Rows[0]["MSGTX"].ToString();
									oracleTrConn.Rollback();
									oracleTrConn.Disconnect();
									return sre;
								}
								else
								{
									sre.OtherStatus = -10002;
									sre.Status = Constant.ServiceResultStatus.SystemError;
									sre.Message = dtResult.Rows[0]["MSGTX"].ToString();
									oracleTrConn.Rollback();
									oracleTrConn.Disconnect();
									return sre;
								}
							}
						}
					}
					#endregion
					#endregion
				}
				#endregion

				//提交事务
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			return sre;
		}

		#region SAP模具状态
		//SAP服务器配置参数
		//public static string appServerHost = ConfigurationManager.AppSettings["SapAppServerHost"].ToString();
		//public static string systemNumber = ConfigurationManager.AppSettings["SapSystemNumber"].ToString();
		//public static string user = ConfigurationManager.AppSettings["SapUser"].ToString();
		//public static string password = ConfigurationManager.AppSettings["SapPassword"].ToString();
		//public static string client = ConfigurationManager.AppSettings["SapClient"].ToString();
		public static INIUtility ini = INIUtility.Instance(INIUtility.IniFile.SAP_HEGII);
		public static string appServerHost = ini.ReadIniData("SAP_RFC_INFO", "SapAppServerHost");
		public static string systemNumber = ini.ReadIniData("SAP_RFC_INFO", "SapSystemNumber");
		public static string user = ini.ReadIniData("SAP_RFC_INFO", "SapUser");
		public static string password = ini.ReadIniData("SAP_RFC_INFO", "SapPassword");
		public static string client = ini.ReadIniData("SAP_RFC_INFO", "SapClient");

		/// <summary>
		///  东科与SAP系统之摸具状态变更（上模）
		/// </summary>
		/// <param name="BLDAT"></param>
		/// <param name="ZDKNO"></param>
		/// <param name="dtTable"></param>
		/// <param name="ZTYPE"></param>
		/// <param name="ZMSG"></param>
		/// <returns></returns>
		public static DataTable ZMMFM045(string BLDAT, string ZDKNO, DataTable dtTable, string MATNR, int dtcount, out string ZTYPE, out string ZMSG)
		{
			#region 接口定义
			RfcConfigParameters rfcPara = new RfcConfigParameters();
			rfcPara.Add(RfcConfigParameters.AppServerHost, appServerHost);
			rfcPara.Add(RfcConfigParameters.SystemNumber, systemNumber);
			rfcPara.Add(RfcConfigParameters.User, user);
			rfcPara.Add(RfcConfigParameters.Password, password);
			rfcPara.Add(RfcConfigParameters.Client, client);
			rfcPara.Add(RfcConfigParameters.Name, "CON");
			rfcPara.Add(RfcConfigParameters.Language, "ZH");
			rfcPara.Add(RfcConfigParameters.PoolSize, "5");
			rfcPara.Add(RfcConfigParameters.ConnectionIdleTimeout, "60");
			RfcDestination rfcDest = RfcDestinationManager.GetDestination(rfcPara);
			RfcRepository rfcRep = rfcDest.Repository;
			#endregion

			//接口API
			IRfcFunction rfcApi = rfcRep.CreateFunction("ZMMFM045");

			//输入参数
			IRfcTable imTable = rfcApi.GetTable("IT_ITEM");

			#region 传参
			imTable.Append();
			imTable.SetValue("BLDAT", BLDAT);                                         //凭证日期
			imTable.SetValue("BUDAT", BLDAT);                                        //过帐日期
			imTable.SetValue("WERKS", "5000");                                        //工厂（默认：5000）
			imTable.SetValue("LGORT_FM", "3001");                                 //发出库位：3001
			imTable.SetValue("LGORT_TO", dtTable.Rows[0]["LGORT_TO"]);                       //接收库位：一车间2110、二车间2210、三车间2310
			imTable.SetValue("MATNR", MATNR);                             //物料编号：模具对应产品的物料编号
			imTable.SetValue("BWART", "311");                                          //移动类型(库存管理)：311
			imTable.SetValue("MEINS", "PCS");                                              //基本计量单位：PCS
			imTable.SetValue("MENGE", dtcount);                                                //数量
			imTable.SetValue("ZDKNO", ZDKNO);                                       //东科单据号 （LOGOID）
			#endregion

			//调用接口
			rfcApi.Invoke(rfcDest);
			//获取输出
			ZTYPE = rfcApi.GetValue("ZTYPE").ToString();
			ZMSG = rfcApi.GetValue("ZMSG").ToString();
			IRfcTable table = rfcApi.GetTable("ET_RETURN");
			DataTable dt = GetDataTableFromRFCTable(table);
			rfcDest = null;
			rfcRep = null;
			return dt;
		}

		/// <summary>
		/// IRfcTable转DataTable
		/// </summary>
		/// <param name="myrfcTable"></param>
		/// <returns></returns>
		public static DataTable GetDataTableFromRFCTable(IRfcTable myrfcTable)
		{
			DataTable loTable = new DataTable();
			int liElement = 0;
			for (liElement = 0; liElement <= myrfcTable.ElementCount - 1; liElement++)
			{
				RfcElementMetadata metadata = myrfcTable.GetElementMetadata(liElement);
				loTable.Columns.Add(metadata.Name);
			}

			foreach (IRfcStructure Row in myrfcTable)
			{
				DataRow ldr = loTable.NewRow();
				for (liElement = 0; liElement <= myrfcTable.ElementCount - 1; liElement++)
				{
					RfcElementMetadata metadata = myrfcTable.GetElementMetadata(liElement);
					ldr[metadata.Name] = Row.GetString(metadata.Name);
				}
				loTable.Rows.Add(ldr);
			}
			return loTable;
		}
		
		#endregion
	}
}