IMEX.mes.wcf/DK.Service/PMModuleLogic/PMModuleLogicDALPartial.cs

/*******************************************************************************
 * Copyright(c) 2014 DongkeSoft All rights reserved. / Confidential
 * 类的信息：
 *      1.程序名称：PMModuleLogicDAL.cs
 *      2.功能描述：生产管理数据库访问类（插入、修改、删除）
 * 编辑履历：
 *      作者            日期                版本            修改内容
 *      庄天威          2014/09/20          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;

namespace Dongke.IBOSS.PRD.Service.PMModuleLogic
{
	/// <summary>
	/// 生产管理数据库访问类（插入、修改、删除）
	/// </summary>
	public partial class PMModuleLogicDAL
	{
		#region 注浆日报

		/// <summary> 
		/// 新建注浆日报信息
		/// </summary>
		/// <param name="dailyEntity">注浆日报实体</param>
		/// <param name="dailyDetailList">明细实体集合</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int返回受影响行数</returns>
		/// <remarks>
		/// 庄天威              2014.09.20              新建
		/// </remarks>
		public static int AddGroutingDaily(List<GroutingDailyEntity> dailyEntityList, List<GroutingDailyDetailEntity> dailyDetailList, SUserInfo user)
		{
			int returnRows = 0;
			int detailReturnRows = 0;
			int productReturnRows = 0;
			int addCountReturn = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			DataTable dtOldClassSet;
			try
			{
				oracleTrConn.Connect();
				StringBuilder sbSql = new StringBuilder();
				// 获得账务日期
				DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				int UCount = 0;
				int MCount = 0;
				//首先添加注浆日报主体信息
				foreach (GroutingDailyEntity dailyEntity in dailyEntityList)
				{
					//首先查询注浆日期的班次配置
					sbSql.Clear();
					sbSql.Append(@"select * from TP_PC_ClassesSetting 
                                       where AccountID =:accountID 
                                       and AccountDate>=:AccountDateStart 
                                       and AccountDate<=:AccountDateEnd 
                                       and UserId=:UserId
                                       Order by ClassesSettingID");
					OracleParameter[] CSParas = new OracleParameter[] {
							new OracleParameter(":accountID",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input),
							new OracleParameter(":AccountDateStart",OracleDbType.Date,
								Convert.ToDateTime(dailyEntity.GroutingDate),ParameterDirection.Input),
							new OracleParameter(":AccountDateEnd",OracleDbType.Date,
								Convert.ToDateTime(dailyEntity.GroutingDate).AddHours(23).AddMinutes(59).AddSeconds(59),ParameterDirection.Input),
							new OracleParameter(":UserId",OracleDbType.NVarchar2,
								dailyEntity.UserID,ParameterDirection.Input)
						};
					dtOldClassSet = oracleTrConn.GetSqlResultToDt(sbSql.ToString(), CSParas);
					//今天以前的注浆信息（补录）
					if (Convert.ToDateTime(dailyEntity.GroutingDate) < accountDate)
					{
						//如果没有信息就不可以补录
						if (dtOldClassSet.Rows.Count == 0)
						{
							oracleTrConn.Rollback();
							oracleTrConn.Disconnect();
							return -50001;
						}
					}
					else  //如果是当天的（当天以后的在前台已经做过处理）
					{
						//如果没有信息，查看工号下是否有员工
						if (dtOldClassSet.Rows.Count == 0)
						{
							sbSql.Clear();
							sbSql.Append(string.Format("select * from tp_hr_staff where staffid in(select staffid from tp_mst_userstaff where userid={0}) and valueflag=1 and (staffstatus=1 or staffstatus=2)", dailyEntity.UserID));
							DataTable dtUser = oracleTrConn.GetSqlResultToDt(sbSql.ToString(), null);
							//如果没有员工，提示先绑定员工
							if (dtUser.Rows.Count == 0)
							{
								oracleTrConn.Rollback();
								oracleTrConn.Disconnect();
								return -Convert.ToInt32(dailyEntity.UserID);
							}
						}
					}
					//添加注浆主体信息
					sbSql.Clear();
					sbSql.Append("select SEQ_PM_GroutingDaily_ID.nextval from dual");
					int id = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
					sbSql.Clear();
					sbSql.Append("Insert into TP_PM_GroutingDaily");
					sbSql.Append(" (GroutingDailyID,GroutingLineID,GroutingLineCode,GroutingLineName,GroutingDate,UserID,UserCode,");
					sbSql.Append(" MouldQuantity,GMouldTypeID,CanManyTimes,Remarks,AccountID,ValueFlag,CreateTime,");
					sbSql.Append(" CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
					sbSql.Append(" values(:GroutingDailyID,:GroutingLineID,:GroutingLineCode,:GroutingLineName,:GroutingDate,:UserID,:UserCode,");
					sbSql.Append(" :MouldQuantity,:GMouldTypeID,:CanManyTimes,:Remarks,:AccountID,:ValueFlag,sysdate,");
					sbSql.Append(" :CreateUserID,sysdate,:UpdateUserID,sysdate)");
					OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":GroutingDailyID",OracleDbType.Int32,
							id,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							dailyEntity.GroutingLineID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineCode",OracleDbType.NVarchar2,
							dailyEntity.GroutingLineCode,ParameterDirection.Input),
						new OracleParameter(":GroutingLineName",OracleDbType.NVarchar2,
							dailyEntity.GroutingLineName,ParameterDirection.Input),
						new OracleParameter(":GroutingDate",OracleDbType.Date,
							dailyEntity.GroutingDate,ParameterDirection.Input),
						new OracleParameter(":UserID",OracleDbType.Int32,
							dailyEntity.UserID,ParameterDirection.Input),
						new OracleParameter(":UserCode",OracleDbType.NVarchar2,
							dailyEntity.UserCode,ParameterDirection.Input),
						new OracleParameter(":MouldQuantity",OracleDbType.Int32,
							dailyEntity.MouldQuantity,ParameterDirection.Input),
						new OracleParameter(":GMouldTypeID",OracleDbType.Int32,
							dailyEntity.GMouldTypeID,ParameterDirection.Input),
						new OracleParameter(":CanManyTimes",OracleDbType.Int32,
							dailyEntity.CanManyTimes,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							dailyEntity.Remarks,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":ValueFlag",OracleDbType.Int32,
							dailyEntity.ValueFlag,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input)
					};
					returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
					//注浆者
					productReturnRows = AddGroutingProducer(oracleTrConn, accountDate, id, Convert.ToInt32(dailyEntity.UserID), user);
					//首先获取模具个数
					// 排序导致 模具个数错位。 by chenxy 2015-03-26 begin
					//MCount += Convert.ToInt32(dailyEntity.MouldQuantity);
					//for (int i = UCount; i < MCount; i++)
					// 排序导致 模具个数错位。 by chenxy 2015-03-26 end
					for (int i = 0; i < dailyDetailList.Count; i++)
					{
						// 排序导致 模具个数错位。 by chenxy 2015-03-26 begin
						if (dailyDetailList[i].GroutingLineID != dailyEntity.GroutingLineID)
						{
							continue;
						}
						// 排序导致 模具个数错位。 by chenxy 2015-03-26 end

						sbSql.Clear();
						sbSql.Append("select SEQ_PM_GroutingDailyD_ID.nextval from dual");
						int detailId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
						sbSql.Clear();
						GroutingDailyDetailEntity dailyDetail = dailyDetailList[i];
						sbSql.Append("Insert into TP_PM_GroutingDailyDetail");
						sbSql.Append(" (GroutingDailyDetailID,GroutingDailyID,GroutingLineID,GroutingLineCode,GroutingLineName,GroutingLineDetailID,UserID,UserCode,");
						sbSql.Append(" GroutingDate,GroutingMouldCode,MouldCode,GoodsID,GoodsCode,GoodsName,GMouldStatus,GroutingCount,GroutingFlag,");
						sbSql.Append(" NoGroutingRreason,Remarks,AccountID,ValueFlag,CreateTime,CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
						sbSql.Append(" values(:GroutingDailyDetailID,:GroutingDailyID,:GroutingLineID,:GroutingLineCode,:GroutingLineName,:GroutingLineDetailID,:UserID,:UserCode,");
						sbSql.Append(" :GroutingDate,:GroutingMouldCode,:MouldCode,:GoodsID,:GoodsCode,:GoodsName,:GMouldStatus,:GroutingCount,:GroutingFlag,");
						sbSql.Append(" :NoGroutingRreason,:Remarks,:AccountID,:ValueFlag,sysdate,:CreateUserID,sysdate,:UpdateUserID,sysdate)");
						OracleParameter[] DDParas = new OracleParameter[] {
						new OracleParameter(":GroutingDailyDetailID",OracleDbType.Int32,
							detailId,ParameterDirection.Input),
						new OracleParameter(":GroutingDailyID",OracleDbType.Int32,
							id,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							dailyDetail.GroutingLineID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineCode",OracleDbType.NVarchar2,
							dailyDetail.GroutingLineCode,ParameterDirection.Input),
						new OracleParameter(":GroutingLineName",OracleDbType.NVarchar2,
							dailyDetail.GroutingLineName,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dailyDetail.GroutingLineDetailID,ParameterDirection.Input),
						new OracleParameter(":UserID",OracleDbType.Int32,
							dailyEntity.UserID,ParameterDirection.Input),
						new OracleParameter(":UserCode",OracleDbType.NVarchar2,
							dailyEntity.UserCode,ParameterDirection.Input),
						new OracleParameter(":GroutingDate",OracleDbType.Date,
							dailyDetail.GroutingDate,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							dailyDetail.GroutingMouldCode,ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							dailyDetail.MouldCode,ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							dailyDetail.GoodsID,ParameterDirection.Input),
						new OracleParameter(":GoodsCode",OracleDbType.NVarchar2,
							dailyDetail.GoodsCode,ParameterDirection.Input),
						new OracleParameter(":GoodsName",OracleDbType.NVarchar2,
							dailyDetail.GoodsName,ParameterDirection.Input),
						new OracleParameter(":GMouldStatus",OracleDbType.Int32,
							dailyDetail.GMouldStatus,ParameterDirection.Input),
						new OracleParameter(":GroutingCount",OracleDbType.Int32,
							dailyDetail.GroutingCount,ParameterDirection.Input),
						new OracleParameter(":GroutingFlag",OracleDbType.Int32,
							dailyDetail.GroutingFlag,ParameterDirection.Input),
						new OracleParameter(":NoGroutingRreason",OracleDbType.Int32,
							dailyDetail.NoGroutingRreason,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							dailyDetail.Remarks,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":ValueFlag",OracleDbType.Int32,
							1,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input)
						};
						detailReturnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DDParas);
						//更新成型线明细的注浆次数(如果注浆了次数才+1)
						if (dailyDetail.GroutingFlag == 1)
						{
							if (dailyDetail.isBetweenGroutingLineDetail == false) //如果补录数据为当前使用模具的注浆记录
							{
								sbSql.Clear();
								sbSql.Append(" update TP_PC_GroutingLineDetail");
								sbSql.Append(" set GroutingCount=GroutingCount + 1");
								sbSql.Append(" where GroutingLineDetailID = " + dailyDetail.GroutingLineDetailID);
								sbSql.Append(" and MouldCode = '" + dailyDetail.MouldCode + "'");
							}
							else  //否则去履历中加次数
							{
								sbSql.Clear();
								sbSql.Append(" update TP_PC_GMouldHistory");
								sbSql.Append(" set GroutingCount=GroutingCount + 1");
								sbSql.Append(" where GroutingLineDetailID = " + dailyDetail.GroutingLineDetailID);
								sbSql.Append(" and MouldCode = '" + dailyDetail.MouldCode + "'");
							}
							addCountReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString());
							if (dailyDetail.isBetweenData == true)   //如果是补填数据,那么补填注浆时间后的同模具注浆记录都要加一
							{
								sbSql.Clear();
								sbSql.Append(" update TP_PM_GroutingDailyDetail");
								sbSql.Append(" set GroutingCount = GroutingCount+1");
								sbSql.Append(" where GroutingDate > to_date('" + dailyDetail.GroutingDate + "','yyyy-MM-dd hh24:mi:ss')");
								sbSql.Append(" and MouldCode = '" + dailyDetail.MouldCode + "'");
								oracleTrConn.ExecuteNonQuery(sbSql.ToString());
							}
						}
					}
					UCount = MCount;
				}
				if (returnRows == 0 || detailReturnRows == 0 || addCountReturn == 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 == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return returnRows;
		}

		/// <summary>
		/// 添加注浆者
		/// </summary>
		/// <param name="oracleTrConn">连接对象</param>
		/// <param name="accountDate">账务日期</param>
		/// <param name="groutingDailyID">注浆数据ID</param>
		/// <param name="dailyUserID">注浆工号ID</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		private static int AddGroutingProducer(IDBTransaction oracleTrConn, DateTime accountDate, int groutingDailyID, int dailyUserID, SUserInfo sUserInfo)
		{
			// 参数
			OracleParameter[] paras;
			#region 查询班次配置表是否有数据
			string sql = "select count(ClassesSettingID)"
						  + " from TP_PC_ClassesDetail"
						 + " where Valueflag =1 and AccountID = :accountID"
						   + " and UserID = :userID"
						   + " and AccountDate = :accountDate";

			paras = new OracleParameter[] {
				new OracleParameter(":accountID",sUserInfo.AccountID),
				new OracleParameter(":userID",dailyUserID),
				new OracleParameter(":accountDate",accountDate),
			};

			string countStr = oracleTrConn.GetSqlResultToStr(sql, paras);
			int classesSettingID = 0;

			// 查询新插入的班次配置表ID
			sql = "select SEQ_PC_ClassesSetting_ID.nextval from dual";
			string idStr = oracleTrConn.GetSqlResultToStr(sql);

			// 新插入的班次配置表ID

			if (!string.IsNullOrEmpty(idStr))
			{
				classesSettingID = int.Parse(idStr);
			}
			else
			{
				return 0;
			}

			#endregion
			#region 没有班次配置数据,将工号所属员工插入班次配置表中
			if (string.IsNullOrEmpty(countStr) || Constant.INT_IS_ZERO == int.Parse(countStr))
			{
				#region 班次配置总表
				sql = "insert into tp_pc_classessetting"
					  + " (ClassesSettingID,accountdate, "
					  + " userid, "
					  + " usercode, "
					  + " accountid, "
					  + " createuserid, "
					  + " updateuserid)"
					+ " select :ClassesSettingID,"
					  + " :accountdate, "
					  + " USERID, "
					  + " UserCode, "
					  + " accountid,"
					  + " :createuserid,"
					  + " :updateuserid"
					+ " from TP_MST_User"
					+ " where UserID = :userID";
				paras = new OracleParameter[] {
					new OracleParameter(":ClassesSettingID",classesSettingID),
					new OracleParameter(":accountdate",accountDate),
					new OracleParameter(":createuserid",sUserInfo.UserID),
					new OracleParameter(":updateuserid",sUserInfo.UserID),
					new OracleParameter(":userID",dailyUserID),
				};

				int result = oracleTrConn.ExecuteNonQuery(sql, paras);

				// 失败
				if (result != Constant.INT_IS_ONE)
				{
					return 0;
				}

				//// 查询新插入的班次配置表ID
				//sql = "select SEQ_PC_ClassesSetting_ID.Currval from dual";
				//string idStr = oracleTrConn.GetSqlResultToStr(sql);

				//// 新插入的班次配置表ID

				//if (!string.IsNullOrEmpty(idStr))
				//{
				//    classesSettingID = int.Parse(idStr);
				//}
				//else
				//{
				//    return 0;
				//}
				#endregion

				#region 班次配置明细SQL
				sql = " insert into tp_pc_classesdetail"
							  + " (classessettingid,"
							   + " accountdate,"
							   + " userid,"
							   + " usercode,"
							   + " UJobsID,"
							   + " staffid,"
							   + " SJobsID,"
							   + " staffstatus,"
							   + " accountid,"
							   + " createuserid,"
							   + " updateuserid)"
							  + " select "
								   + " :classessettingid,"
								   + " :accountdate,"
								   + " tuser.Userid,"
								   + " tuser.usercode,"
								   + " userStaff.Ujobsid,"
								   + " userStaff.Staffid,"
								   + " staff.Jobs,"
								   + " staff.staffstatus,"
								   + " :accountID,"
								   + " :createuserid,"
								   + " :updateuserid"
							  + " from TP_MST_UserStaff userStaff"
							 + " inner join tp_hr_staff staff on staff.staffid = userStaff.Staffid"
							 + " inner join TP_MST_User tuser on tuser.userid = userStaff.userid"
							 + " where (staff.StaffStatus = 1 or staff.StaffStatus = 2)"
							   + " and staff.ValueFlag = 1"
							   + " and staff.AccountID = :accountID"
							   + " and userStaff.UserID = :userID";

				paras = new OracleParameter[] {
					new OracleParameter(":classessettingid",OracleDbType.Int32,classesSettingID,ParameterDirection.Input),
					new OracleParameter(":accountdate",OracleDbType.Date,accountDate,ParameterDirection.Input),
					new OracleParameter(":accountID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
					new OracleParameter(":createuserid",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
					new OracleParameter(":updateuserid",OracleDbType.Int32,sUserInfo.UserID,ParameterDirection.Input),
					new OracleParameter(":accountID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
					new OracleParameter(":userID",OracleDbType.Int32,dailyUserID,ParameterDirection.Input),
				};

				result = oracleTrConn.ExecuteNonQuery(sql, paras);

				// 失败
				if (result <= 0)
				{
					return 0;
				}

				#endregion
			}


			#endregion
			#region 将班次配置表中的数据插入注浆者表中
			sql = "insert into TP_PM_GroutingProducer"
				  + " (GroutingDailyID,"
				   + " StaffID,"
				   + " StaffCode,"
				   + " StaffStatus,"
				   + " UserID,"
				   + " UserCode,"
				   + " UJobsID,"
				   + " SJobsID,"
				   + " classessettingid"
				   + " )"
				  + " select :GroutingDailyID,"
						 + " classes.staffid,"
						 + " staff.staffcode,"
						 + " staff.staffstatus,"
						 + " classes.userid,"
						 + " muser.usercode,"
						 + " classes.Ujobsid,"
						 + " classes.Sjobsid,"
						 + " :classessettingid"
						 + " from tp_pc_classesdetail classes"
						 + " inner join TP_HR_Staff staff"
						 + " on classes.staffid = staff.staffid"
						 + " inner join TP_MST_User muser "
						 + " on classes.userid = muser.userid"
						 + " where ValueFlag = 1"
						 + " and classes.classessettingid = (select max(ClassesSettingID)"
											   + " from TP_PC_ClassesSetting"
											  + " where ValueFlag = 1 and AccountDate=:accountDate"
												+ " and UserID = :userID)";

			paras = new OracleParameter[] {
					new OracleParameter(":classessettingid",OracleDbType.Int32,classesSettingID,ParameterDirection.Input),
					new OracleParameter(":GroutingDailyID",groutingDailyID),
					new OracleParameter(":accountDate",accountDate),
					new OracleParameter(":userID",dailyUserID),
				};

			int resultCount = oracleTrConn.ExecuteNonQuery(sql, paras);

			// 失败
			if (resultCount == Constant.INT_IS_ZERO)
			{
				return 0;
			}
			#endregion
			return 1;
		}

		/// <summary> 
		/// 修改注浆日报信息（明细）
		/// </summary>
		/// <param name="dailyDetailList">明细实体集合</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 庄天威              2014.09.20              新建
		/// </remarks>
		public static int UpdateGroutingDaily(List<GroutingDailyDetailEntity> dailyDetailList, SUserInfo user)
		{
			int detailReturnRows = 0;
			int addCountReturn = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				StringBuilder sbSql = new StringBuilder();
				//循环明细信息（能修改的：注浆次数，是否注浆，未注浆原因,备注）
				foreach (GroutingDailyDetailEntity dailyDetailEntity in dailyDetailList)
				{
					sbSql.Clear();
					sbSql.Append("update TP_PM_GroutingDailyDetail");
					sbSql.Append(" set GroutingCount=:GroutingCount,");
					sbSql.Append(" GroutingFlag=:GroutingFlag,");
					sbSql.Append(" Remarks=:Remarks");
					if (dailyDetailEntity.NoGroutingRreason != null)
					{
						sbSql.Append(",NoGroutingRreason=" + dailyDetailEntity.NoGroutingRreason);
					}
					else
					{
						sbSql.Append(",NoGroutingRreason=null");
					}
					sbSql.Append(" where GroutingDailyDetailID=:GroutingDailyDetailID and OPTimeStamp=:OPTimeStamp ");
					OracleParameter[] DDParas = new OracleParameter[] {
						new OracleParameter(":GroutingCount",OracleDbType.Decimal,
							dailyDetailEntity.GroutingCount,ParameterDirection.Input),
						new OracleParameter(":GroutingFlag",OracleDbType.Int32,
							dailyDetailEntity.GroutingFlag,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							dailyDetailEntity.Remarks,ParameterDirection.Input),
						new OracleParameter(":GroutingDailyDetailID",OracleDbType.Int32,
							dailyDetailEntity.GroutingDailyDetailID,ParameterDirection.Input),
						new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							dailyDetailEntity.OPTimeStamp,ParameterDirection.Input)
					};
					detailReturnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DDParas);
					//如果注浆状态被修改，那么注浆次数要有相应变化
					if (dailyDetailEntity.GroutingFlagIsChange == true)
					{
						if (dailyDetailEntity.GroutingFlag == 1)
						{
							int NowReturn = 0;
							//如果改为已注浆，次数要加到模具或履历上（由于模具ID唯一，必定有一个成功，这样就不用查询了）
							sbSql.Clear();
							sbSql.Append(" update TP_PC_GroutingLineDetail");
							sbSql.Append(" set GroutingCount=GroutingCount + 1");
							sbSql.Append(" where GroutingLineDetailID = " + dailyDetailEntity.GroutingLineDetailID);
							sbSql.Append(" and MouldCode = '" + dailyDetailEntity.MouldCode + "'");
							NowReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString());
							if (NowReturn == 0) //如果未成功才去履历表中进行操作，否则节省一次操作资源
							{
								sbSql.Clear();
								sbSql.Append(" update TP_PC_GMouldHistory");
								sbSql.Append(" set GroutingCount=GroutingCount +1");
								sbSql.Append(" where GroutingLineDetailID = " + dailyDetailEntity.GroutingLineDetailID);
								sbSql.Append(" and MouldCode = '" + dailyDetailEntity.MouldCode + "'");
								NowReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString());
							}
							if (NowReturn > 0)
							{
								//然后，修改全部同模具编号，并且注浆日报明细时间大于本注浆日报明细时间的全部注浆明细
								sbSql.Clear();
								sbSql.Append(" update TP_PM_GroutingDailyDetail");
								sbSql.Append(" set GroutingCount=GroutingCount+1");
								sbSql.Append(" where MouldCode= '" + dailyDetailEntity.MouldCode + "'");
								sbSql.Append(" and (GroutingDate > to_date('" + dailyDetailEntity.GroutingDate + "','yyyy-MM-dd hh24:mi:ss')");
								sbSql.Append(" or (GroutingDate = to_date('" + dailyDetailEntity.GroutingDate + "','yyyy-MM-dd hh24:mi:ss') ");
								sbSql.Append(" and CreateTime > to_date('" + dailyDetailEntity.CreateTime + "','yyyy-MM-dd hh24:mi:ss')))");

								addCountReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString());
							}
						}
						else if (dailyDetailEntity.GroutingFlag == 0)  //反之，要减去模具或履历的注浆次数
						{
							int NowReturn = 0;
							sbSql.Clear();
							sbSql.Append(" update TP_PC_GroutingLineDetail");
							sbSql.Append(" set GroutingCount=GroutingCount - 1 ");
							sbSql.Append(" where GroutingLineDetailID = " + dailyDetailEntity.GroutingLineDetailID);
							sbSql.Append(" and MouldCode = '" + dailyDetailEntity.MouldCode + "'");
							NowReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString());
							if (NowReturn == 0)
							{
								sbSql.Clear();
								sbSql.Append(" update TP_PC_GMouldHistory");
								sbSql.Append(" set GroutingCount=GroutingCount -1");
								sbSql.Append(" where GroutingLineDetailID = " + dailyDetailEntity.GroutingLineDetailID);
								sbSql.Append(" and MouldCode = '" + dailyDetailEntity.MouldCode + "'");
								NowReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString());
							}
							if (NowReturn > 0)
							{
								//然后，修改全部同模具编号，并且注浆日报明细时间大于本注浆日报明细时间的全部注浆明细
								sbSql.Clear();
								sbSql.Append(" update TP_PM_GroutingDailyDetail");
								sbSql.Append(" set GroutingCount=GroutingCount-1");
								sbSql.Append(" where MouldCode= '" + dailyDetailEntity.MouldCode + "'");
								sbSql.Append(" and (GroutingDate > to_date('" + dailyDetailEntity.GroutingDate + "','yyyy-MM-dd hh24:mi:ss')");
								sbSql.Append(" or (GroutingDate = to_date('" + dailyDetailEntity.GroutingDate + "','yyyy-MM-dd hh24:mi:ss') ");
								sbSql.Append(" and CreateTime > to_date('" + dailyDetailEntity.CreateTime + "','yyyy-MM-dd hh24:mi:ss')))");
								addCountReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString());
							}
						}
					}
				}
				if (detailReturnRows == 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 == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return detailReturnRows;
		}

		/// <summary>
		/// 修改条码
		/// </summary>
		/// <param name="barCode">原条码</param>
		/// <param name="barCodeUpdate">新条码</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int返回值结果</returns>
		public static int UpdateBarCode(string barCode, string barCodeUpdate, SUserInfo user)
		{
			if (BarCodesIsRepeat(barCodeUpdate.ToString()) != "")
			{
				return -1;
			}
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			StringBuilder sbSql = new StringBuilder();
			try
			{
				con.Open();
				OracleParameter[] Paras = new OracleParameter[] {
							new OracleParameter("in_barCode",OracleDbType.NVarchar2,
								barCode,ParameterDirection.Input),
							new OracleParameter("in_barCodeUpdate",OracleDbType.NVarchar2,
								barCodeUpdate,ParameterDirection.Input),
							new OracleParameter("in_AccountID",OracleDbType.Int32,
								user.AccountID,ParameterDirection.Input),
							new OracleParameter("in_CreateUserID",OracleDbType.Int32,
								user.UserID,ParameterDirection.Input),
							new OracleParameter("out_isRepeat",OracleDbType.Int32,
								ParameterDirection.Output)
						};
				con.ExecStoredProcedure("PRO_PM_UpdateBarCode", Paras);
				con.Close();
				if (Convert.ToInt32(Paras[4].Value.ToString()) > 0)
				{
					return 1;
				}
				else
				{
					return Convert.ToInt32(Paras[4].Value.ToString());
				}
			}
			catch (Exception ex)
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary> 
		/// 验证条码唯一性
		/// </summary>
		/// <param name="Barcode">需要验证的条码</param>
		/// <returns>int结果</returns>
		/// <remarks>
		/// 庄天威              2014.09.23              新建
		/// </remarks>
		public static int BarCodeIsRepeat(String BarCode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			StringBuilder sbSql = new StringBuilder();
			try
			{
				con.Open();
				OracleParameter[] Paras = new OracleParameter[] {
							new OracleParameter("in_barCode",OracleDbType.NVarchar2,
								BarCode,ParameterDirection.Input),
							new OracleParameter("out_isRepeat",OracleDbType.Int32,
								ParameterDirection.Output)
						};
				con.ExecStoredProcedure("PRO_PM_BarCodeIsRepeat", Paras);
				con.Close();
				if (Paras[1].Value.ToString() == "0")  //可以插入
				{
					return 0;
				}
				else
				{
					return 1;
				}
			}
			catch (Exception ex)
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 根据注浆明细添加条码
		/// </summary>
		/// <param name="dailyDetailList">明细列表</param>
		///  <param name="ScrapIds">报废标记集</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 庄天威              2014.09.30              新建
		/// </remarks>
		public static int AddBarCode(List<GroutingDailyDetailEntity> dailyDetailList, string ScrapIds, SUserInfo user)
		{
			int detailReturnRows = 0;
			int RepeatReturnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				StringBuilder sbSql = new StringBuilder();
				int isScrapUpdate = 0;
				//循环插入条码
				foreach (GroutingDailyDetailEntity dailyDetailEntity in dailyDetailList)
				{
					//首先处理损坯明细
					//当然如果没有就不处理了
					if (isScrapUpdate == 0 && ScrapIds != null && ScrapIds != string.Empty)
					{
						//第一步要先把操作主ID下的所有明细改为非损坯
						sbSql.Clear();
						sbSql.Append("Update TP_PM_GroutingDailyDetail set ScrapFlag = 0 Where GroutingDailyID=" + dailyDetailEntity.GroutingDailyID);
						oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
						//第二步把传入的损坯ID的明细更改为已损坯
						sbSql.Clear();
						sbSql.Append("Update TP_PM_GroutingDailyDetail set ScrapFlag = 1 Where GroutingDailyDetailID in(" + ScrapIds + ")");
						oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
						isScrapUpdate++;
					}
					if (dailyDetailEntity.BarCodeStrList == null || dailyDetailEntity.BarCodeStrList == string.Empty)
					{
						continue;
					}
					sbSql.Clear();
					sbSql.Append("Insert into TP_PM_GroutingProduct");
					sbSql.Append(" (Barcode,GroutingDailyID,GroutingDailyDetailID,GroutingLineID,GroutingLineCode,GroutingLineName,");
					sbSql.Append(" GroutingLineDetailID,GroutingDate,GroutingMouldCode,MouldCode,GroutingUserID,GroutingUserCode,GroutingNum,GoodsID,GoodsCode,GoodsName,");
					sbSql.Append(" Remarks,AccountID,CreateTime,CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
					sbSql.Append(" values(:Barcode,:GroutingDailyID,:GroutingDailyDetailID,:GroutingLineID,:GroutingLineCode,:GroutingLineName,");
					sbSql.Append(" :GroutingLineDetailID,:GroutingDate,:GroutingMouldCode,:MouldCode,:GroutingUserID,:GroutingUserCode,:GroutingNum,:GoodsID,:GoodsCode,:GoodsName,");
					sbSql.Append(" :Remarks,:AccountID,sysdate,:CreateUserID,sysdate,:UpdateUserID,sysdate)");
					OracleParameter[] ProParas = new OracleParameter[] {
						new OracleParameter(":Barcode",OracleDbType.NVarchar2,
							dailyDetailEntity.BarCodeStrList,ParameterDirection.Input),
						new OracleParameter(":GroutingDailyID",OracleDbType.Int32,
							dailyDetailEntity.GroutingDailyID,ParameterDirection.Input),
						new OracleParameter(":GroutingDailyDetailID",OracleDbType.Int32,
							dailyDetailEntity.GroutingDailyDetailID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							dailyDetailEntity.GroutingLineID,ParameterDirection.Input),
						new OracleParameter(":GroutingLineCode",OracleDbType.NVarchar2,
							dailyDetailEntity.GroutingLineCode,ParameterDirection.Input),
						new OracleParameter(":GroutingLineName",OracleDbType.NVarchar2,
							dailyDetailEntity.GroutingLineName,ParameterDirection.Input),
						new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							dailyDetailEntity.GroutingLineDetailID,ParameterDirection.Input),
						new OracleParameter(":GroutingDate",OracleDbType.Date,
							dailyDetailEntity.GroutingDate,ParameterDirection.Input),
						new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							dailyDetailEntity.GroutingMouldCode,ParameterDirection.Input),
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							dailyDetailEntity.MouldCode,ParameterDirection.Input),
						new OracleParameter(":GroutingUserID",OracleDbType.Int32,
							dailyDetailEntity.UserID,ParameterDirection.Input),
						new OracleParameter(":GroutingUserCode",OracleDbType.NVarchar2,
							dailyDetailEntity.UserCode,ParameterDirection.Input),
						new OracleParameter(":GroutingNum",OracleDbType.Decimal,
							dailyDetailEntity.GroutingCount,ParameterDirection.Input),
						new OracleParameter(":GoodsID",OracleDbType.Int32,
							dailyDetailEntity.GoodsID,ParameterDirection.Input),
						new OracleParameter(":GoodsCode",OracleDbType.NVarchar2,
							dailyDetailEntity.GoodsCode,ParameterDirection.Input),
						new OracleParameter(":GoodsName",OracleDbType.NVarchar2,
							dailyDetailEntity.GoodsName,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							dailyDetailEntity.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)
						};
					detailReturnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), ProParas);
					RepeatReturnRows += AddBarCodeRepeat(dailyDetailEntity.BarCodeStrList, user, oracleTrConn);
				}
				if (detailReturnRows == 0 || RepeatReturnRows == 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 detailReturnRows;
		}

		/// <summary> 
		/// 验证条码唯一性
		/// </summary>
		/// <param name="Barcode">需要验证的条码(多个，逗号分割)</param>
		/// <returns>string结果</returns>
		/// <remarks>
		/// 庄天威              2014.09.23              新建
		/// </remarks>
		public static string BarCodesIsRepeat(String BarCodes)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("select Barcode from TP_PM_UsedBarCode");
				sbSql.Append(" where Barcode in (" + BarCodes + ")");
				DataTable dtReturn = con.GetSqlResultToDt(sbSql.ToString(), null);
				if (dtReturn != null)
				{
					StringBuilder sbCodes = new StringBuilder();
					foreach (DataRow drFor in dtReturn.Rows)
					{
						sbCodes.Append(drFor["Barcode"] + ",");
					}
					if (sbCodes.Length != 0)
					{
						return sbCodes.ToString().Substring(0, sbCodes.Length - 1);
					}
					else
					{
						return "";
					}
				}
				else
				{
					return "";
				}
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 添加产品条码
		/// </summary>
		/// <param name="BarCodes">产品条码</param>
		/// <param name="user">用户基本信息</param>
		/// <param name="oracleTrConn">数据连接</param>
		/// <returns>int</returns>
		public static int AddBarCodeRepeat(String BarCodes, SUserInfo user, IDBTransaction oracleTrConn)
		{
			int ReturnRows = 0;
			try
			{
				StringBuilder sbSql = new StringBuilder();
				//循环插入条码
				sbSql.Append("Insert into TP_PM_UsedBarCode");
				sbSql.Append(" (Barcode,AccountID,CreateUserID)");
				sbSql.Append(" Values(:Barcode,:AccountID,:CreateUserID)");
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":Barcode",OracleDbType.NVarchar2,
							BarCodes,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input)
						};
				ReturnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);
			}
			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="MouldCode">模具编号</param>
		/// <param name="inTime">注浆时间</param>
		/// <returns>int最大注浆次数(如录入数据需+1)</returns>
		public static int GetMaxGroutingCountByMouldCode(string MouldCode, DateTime inTime)
		{
			int MaxCount = 0;
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("select Max(GroutingCount) from TP_PM_GroutingDailyDetail");
				sbSql.Append(" where MouldCode = :MouldCode");
				sbSql.Append(" and GroutingDate <= to_date(:GroutingDate,'yyyy-MM-dd hh24:mi:ss')");
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							MouldCode,ParameterDirection.Input),
						new OracleParameter(":GroutingDate",OracleDbType.NVarchar2,
							inTime.ToString(),ParameterDirection.Input)
						};
				DataTable dtReturn = con.GetSqlResultToDt(sbSql.ToString(), Paras);
				if (dtReturn != null)
				{
					if (dtReturn.Rows.Count != 0)
					{
						if (dtReturn.Rows[0][0] != DBNull.Value)
						{
							MaxCount = Convert.ToInt32(dtReturn.Rows[0][0]);
						}
					}
				}
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
			return MaxCount;
		}

		/// <summary>
		/// 获取某一时间段的某成型线明细的模具编号
		/// </summary>
		/// <param name="GroutingLineDetailID">成型线明细ID</param>
		/// <param name="inTime">注浆时间</param>
		/// <returns>string</returns>
		public static string GetMouldCodeFromHistoryByTime(int GroutingLineDetailID, DateTime inTime)
		{
			string MouldCode = null;
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("select MouldCode from TP_PC_GMouldHistory");
				sbSql.Append(" where GroutingLineDetailID = :GroutingLineDetailID");
				sbSql.Append(" and BeginUsedDate <= to_date(:GroutingDate,'yyyy-MM-dd hh24:mi:ss')");
				sbSql.Append(" and EndUsedDate >= to_date(:GroutingDate,'yyyy-MM-dd hh24:mi:ss')");
				OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":GroutingLineDetailID",OracleDbType.NVarchar2,
							GroutingLineDetailID,ParameterDirection.Input),
						new OracleParameter(":GroutingDate",OracleDbType.NVarchar2,
							inTime.ToString(),ParameterDirection.Input)
						};
				DataTable dtReturn = con.GetSqlResultToDt(sbSql.ToString(), Paras);
				if (dtReturn != null)
				{
					if (dtReturn.Rows.Count != 0)
					{
						if (dtReturn.Rows[0][0] != DBNull.Value)
						{
							MouldCode = dtReturn.Rows[0][0].ToString();
						}
					}
				}
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
			return MouldCode;
		}

		#endregion

		#region 生产产品

		/// <summary>
		/// 保存生产数据
		/// </summary>
		/// <param name="productionData">生产数据对象</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>string</returns>
		public static string SaveProductionData(ProductionDataEntity productionData, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				#region SQL
				string sql = "insert into tp_pm_productiondata"
							  + " ("
							   + " barcode,"
							   + " centralizedbatchno,"
							   + " productionlineid,"
							   + " productionlinecode,"
							   + " productionlinename,"
							   + " procedureid,"
							   + " procedurecode,"
							   + " procedurename,"
							   + " proceduremodel,"
							   + " modeltype,"
							   + " piecetype,"
							   + " isreworked,"
							   + " nodetype,"
							   + " ispublicbody,"
							   + " isrefire,"
							   + " goodsgrade,"
							   + " organizationid,"
							   + " goodsid,"
							   + " goodscode,"
							   + " goodsname,"
							   + " userid,"
							   + " usercode,"
							   + " username,"
							   + " kilnid,"
							   + " kilncode,"
							   + " kilnname,"
							   + " kilncarid,"
							   + " kilncarcode,"
							   + " kilncarname,"
							   + " kilncarbatchno,"
							   + " kilncarposition,"
							   + " defectflag,"
							   + " isscrap,"
							   + " reworkprocedureid,"
							   + " reworkprocedurecode,"
							   + " reworkprocedurename,"
							   + " remarks,"
							   + " accountdate,"
							   + " accountid,"
							   + " createuserid,"
							   + " updateuserid)"
							+ " values"
							  + " ("
							   + " :barcode,"
							   + " :centralizedbatchno,"
							   + " :productionlineid,"
							   + " :productionlinecode,"
							   + " :productionlinename,"
							   + " :procedureid,"
							   + " :procedurecode,"
							   + " :procedurename,"
							   + " :proceduremodel,"
							   + " :modeltype,"
							   + " :piecetype,"
							   + " :isreworked,"
							   + " :nodetype,"
							   + " :ispublicbody,"
							   + " :isrefire,"
							   + " :goodsgrade,"
							   + " :organizationid,"
							   + " :goodsid,"
							   + " :goodscode,"
							   + " :goodsname,"
							   + " :userid,"
							   + " :usercode,"
							   + " :username,"
							   + " :kilnid,"
							   + " :kilncode,"
							   + " :kilnname,"
							   + " :kilncarid,"
							   + " :kilncarcode,"
							   + " :kilncarname,"
							   + " :kilncarbatchno,"
							   + " :kilncarposition,"
							   + " :defectflag,"
							   + " :isscrap,"
							   + " :reworkprocedureid,"
							   + " :reworkprocedurecode,"
							   + " :reworkprocedurename,"
							   + " :remarks,"
							   + " fun_cmn_getaccountdate(:dataaccountid),"
							   + " :accountid,"
							   + " :createuserid,"
							   + " :updateuserid)";
				#endregion
				#region OracleParameter
				OracleParameter[] paras = new OracleParameter[] {
				new OracleParameter(":barcode",productionData.Barcode),
				new OracleParameter(":centralizedbatchno",productionData.CentralizedBatchNo),
				new OracleParameter(":productionlineid",productionData.ProductionLineID),
				new OracleParameter(":productionlinecode",productionData.ProductionLineCode),
				new OracleParameter(":productionlinename",productionData.ProductionLineName),
				new OracleParameter(":procedureid",productionData.CompleteProcedureID),
				new OracleParameter(":procedurecode",productionData.ProcedureCode),
				new OracleParameter(":procedurename",productionData.ProcedureName),
				new OracleParameter(":proceduremodel",productionData.ProcedureModel),
				new OracleParameter(":modeltype",productionData.ModelType),
				new OracleParameter(":piecetype",productionData.PieceType),
				new OracleParameter(":isreworked",productionData.IsReworked),
				new OracleParameter(":nodetype",productionData.NodeType),
				new OracleParameter(":ispublicbody",productionData.IsPublicBody),
				new OracleParameter(":isrefire",productionData.IsReFire),
				new OracleParameter(":goodsgrade",productionData.GoodsGrade),
				new OracleParameter(":organizationid",productionData.OrganizationID),
				new OracleParameter(":goodsid",productionData.GoodsID),
				new OracleParameter(":goodscode",productionData.GoodsCode),
				new OracleParameter(":goodsname",productionData.GoodsName),
				new OracleParameter(":userid",productionData.UserID),
				new OracleParameter(":usercode",productionData.UserCode),
				new OracleParameter(":username",productionData.UserName),
				new OracleParameter(":kilnid",productionData.KilnID),
				new OracleParameter(":kilncode",productionData.KilnCode),
				new OracleParameter(":kilnname",productionData.KilnName),
				new OracleParameter(":kilncarid",productionData.KilnCarID),
				new OracleParameter(":kilncarcode",productionData.KilnCarCode),
				new OracleParameter(":kilncarname",productionData.KilnCarName),
				new OracleParameter(":kilncarbatchno",productionData.KilnCarBatchNo),
				new OracleParameter(":kilncarposition",productionData.KilnCarPosition),
				new OracleParameter(":defectflag",productionData.DefectFlag),
				new OracleParameter(":isscrap",productionData.IsScrap),
				new OracleParameter(":reworkprocedureid",productionData.ReworkProcedureID),
				new OracleParameter(":reworkprocedurecode",productionData.ReworkProcedureCode),
				new OracleParameter(":reworkprocedurename",productionData.ReworkProcedureName),
				new OracleParameter(":remarks",productionData.Remarks),
				new OracleParameter(":dataaccountid",sUserInfo.AccountID),
				new OracleParameter(":accountid",sUserInfo.AccountID),
				new OracleParameter(":createuserid",sUserInfo.UserID),
				new OracleParameter(":updateuserid",sUserInfo.UserID),
			};
				#endregion
				foreach (OracleParameter para in paras)
				{
					if (para.Value + "" == "")
					{
						para.Value = DBNull.Value;
					}
				}
				int result = oracleTrConn.ExecuteNonQuery(sql, paras);
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				// 失败
				if (result != Constant.INT_IS_ONE)
				{
					return string.Format(Messages.MSG_CMN_W001, "条码", "保存");
				}
				return null;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		#endregion

		#region 废弃产品

		/// <summary>
		/// 添加废弃产品记录
		/// </summary>
		/// <param name="SProductEntity">废弃产品实体</param>
		/// <param name="RProcedureEntity">废弃责任工序实体</param>
		/// <param name="SResponsibleList">责任者集合</param>
		/// <param name="userInfo">用户基本信息</param>
		/// <returns>int结果返回值</returns>
		/// <remarks>
		/// 庄天威              2014.09.24              新建
		/// </remarks>
		public static int AddScrapProduct(ScrapProductEntity SProductEntity,
			ResponProcedureEntity RProcedureEntity,
			List<ScrapResponsibleEntity> SResponsibleList, SUserInfo userInfo)
		{
			int returnRows = 0;
			int sresponsibleReturnRows = 0;
			int rprocedureReturn = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				//#region 判断产品是否被挂起
				//string sqlString = "SELECT 1 AS RES\n" +
				//					"  FROM TP_PM_PRODUCTSUSPEND PS\n" +
				//					" INNER JOIN TP_PM_GROUTINGDAILYDETAIL GDD\n" +
				//					"    ON GDD.GROUTINGDAILYDETAILID = PS.GROUTINGDAILYDETAILID\n" +
				//					" WHERE GDD.BARCODE = :Barcode";

				//OracleParameter[] pars = new OracleParameter[]
				//{
				//	new OracleParameter(":Barcode",OracleDbType.NVarchar2, SProductEntity.BarCode,ParameterDirection.Input),
				//};

				//object objResult = oracleTrConn.GetSqlResultToObj(sqlString, pars);
				//if (objResult != null)
				//{
				//	return Constant.INT_IS_NEGATIE_ONE;
				//}
				//#endregion

				object result = DBNull.Value;
				if (SProductEntity.AuditStatus != 0)
				{
					//string strSql1 = "select FUN_CMN_GetAccountDate(:accountId) From DUAL";
					string strSql1 = "select sysdate from dual";
					//    Oracle.ManagedDataAccess.Client.OracleParameter[] paras1 = new Oracle.ManagedDataAccess.Client.OracleParameter[] 
					//{
					//    new Oracle.ManagedDataAccess.Client.OracleParameter(":accountId",userInfo.AccountID)
					//};
					object strResult = oracleTrConn.GetSqlResultToObj(strSql1);
					if (strResult == null || strResult == DBNull.Value)
					{
						// 服务器时间错误
						throw new Exception("SystemDateTimeError");
					}
					result = Convert.ToDateTime(strResult);
				}

				// wangx 2016/01/13
				int? ProductionDataID = null;
				int? completeProcdureID = null;
				string completeProcdureName = string.Empty;
				string completeProcdureCode = string.Empty;
                // 重复登记的问题 for update
                //string sqlProductionDataID = @"select tp_pm_inproduction.productiondataid,
                //                               tp_pc_procedure.procedureid,
                //                               tp_pc_procedure.procedurename,
                //                               tp_pc_procedure.procedurecode, tp_pm_inproduction.InScrapFlag
                //                          from tp_pm_inproduction
                //                          left join tp_pc_procedure
                //                          on tp_pm_inproduction.procedureid=tp_pc_procedure.procedureid
                //                         where tp_pm_inproduction.barcode = :barcode
                //                        union
                //                        select tp_pm_inproductiontrash.productiondataid,
                //                               tp_pc_procedure.procedureid,
                //                               tp_pc_procedure.procedurename,
                //                               tp_pc_procedure.procedurecode
                //                          from tp_pm_inproductiontrash
                //                          left join tp_pc_procedure
                //                          on tp_pm_inproductiontrash.procedureid=tp_pc_procedure.procedureid
                //                         where tp_pm_inproductiontrash.barcode = :barcode 
                //                    for update";

                string sqlProductionDataID = @"select tp_pm_inproduction.productiondataid,
                                               tp_pc_procedure.procedureid,
                                               tp_pc_procedure.procedurename,
                                               tp_pc_procedure.procedurecode, tp_pm_inproduction.InScrapFlag
                                          from tp_pm_inproduction
                                          left join tp_pc_procedure
                                          on tp_pm_inproduction.procedureid=tp_pc_procedure.procedureid
                                         where tp_pm_inproduction.barcode = :barcode
                                    for update";

                OracleParameter[] ParasProductionDataID = new OracleParameter[] {
							new OracleParameter(":Barcode",OracleDbType.NVarchar2,
							SProductEntity.BarCode,ParameterDirection.Input),
				};

				DataSet dsProductionDataID = oracleTrConn.GetSqlResultToDs(sqlProductionDataID, ParasProductionDataID);
                if (dsProductionDataID != null && dsProductionDataID.Tables[0].Rows.Count > 0)
                {
                    ProductionDataID = Convert.ToInt32(dsProductionDataID.Tables[0].Rows[0]["productiondataid"]);
                    completeProcdureID = Convert.ToInt32(dsProductionDataID.Tables[0].Rows[0]["procedureid"]);
                    completeProcdureName = dsProductionDataID.Tables[0].Rows[0]["procedurename"].ToString();
                    completeProcdureCode = dsProductionDataID.Tables[0].Rows[0]["procedurecode"].ToString();
                    string InScrapFlag = dsProductionDataID.Tables[0].Rows[0]["InScrapFlag"].ToString();
                    if (InScrapFlag == "1")
                    {
                        return Constant.RETURN_IS_DATACHANGED;
                    }
                }
                else
                {
                    return Constant.RETURN_IS_DATACHANGED;
                }

				// end

				// 如果完成工序ID发生变化,则返回提示；
				if (completeProcdureID != SProductEntity.ProcedureID)
				{
					return Constant.RETURN_IS_DATACHANGED;
				}

				//首先添加废弃产品主体信息
				StringBuilder sbSql = new StringBuilder();
				//获取序列ID
				sbSql.Clear();
				sbSql.Append("select SEQ_PM_ScrapProduct_ID.nextval from dual");
				int id = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
				sbSql.Clear();
				sbSql.Append("Insert into TP_PM_ScrapProduct");
				sbSql.Append("(ScrapProductID,Barcode,ProductionLineID,ProductionLineCode,ProductionLineName,");
				sbSql.Append("GoodsID,GoodsCode,GoodsName,GroutingDailyID,GroutingDailyDetailID,");
				sbSql.Append("GroutingDate,GroutingLineID,GroutingLineCode,GroutingLineName,");
				sbSql.Append("GMouldTypeID,GroutingLineDetailID,GroutingMouldCode,MouldCode,");
				sbSql.Append("GoodsLevelID,GoodsLevelTypeID,ResponType,ScrapDate,Rreason,");
				sbSql.Append("Remarks,AuditStatus,");
				sbSql.Append("SettlementFlag,AccountID,ValueFlag,CreateTime,CreateUserID,");
				sbSql.Append("UpdateTime,UpdateUserID,OPTimeStamp,GroutingUserID,GroutingUserCode,GroutingNum,IsPublicBody,IsReFire,ScrapFine,Auditor,AuditDate,SpecialRepairflag,Procedureid,ProcedureName,ProcedureCode,logoid,ProductionDataID)");
				sbSql.Append("values(:ScrapProductID,:Barcode,:ProductionLineID,:ProductionLineCode,:ProductionLineName,");
				sbSql.Append(":GoodsID,:GoodsCode,:GoodsName,:GroutingDailyID,:GroutingDailyDetailID,");
				sbSql.Append(":GroutingDate,:GroutingLineID,:GroutingLineCode,:GroutingLineName,");
				sbSql.Append(":GMouldTypeID,:GroutingLineDetailID,:GroutingMouldCode,:MouldCode,");
				sbSql.Append(":GoodsLevelID,:GoodsLevelTypeID,:ResponType,:ScrapDate,:Rreason,");
				sbSql.Append(":Remarks,:AuditStatus,");
				sbSql.Append("0,:AccountID,1,sysdate,:CreateUserID,");
				sbSql.Append("sysdate,:UpdateUserID,systimestamp,:GroutingUserID,:GroutingUserCode,:GroutingNum,:IsPublicBody,:IsReFire,:ScrapFine,:Auditor,:AuditlDate,:SpecialRepairflag,:Procedureid,:ProcedureName,:ProcedureCode,:logoid,:ProductionDataID)");
				OracleParameter[] Paras = new OracleParameter[] {
							new OracleParameter(":ScrapProductID",OracleDbType.Int32,
							id,ParameterDirection.Input),
							new OracleParameter(":Barcode",OracleDbType.NVarchar2,
							SProductEntity.BarCode,ParameterDirection.Input),
							new OracleParameter(":ProductionLineID",OracleDbType.Int32,
							SProductEntity.ProductionLineID,ParameterDirection.Input),
							new OracleParameter(":ProductionLineCode",OracleDbType.NVarchar2,
							SProductEntity.ProductionLineCode,ParameterDirection.Input),
							new OracleParameter(":ProductionLineName",OracleDbType.NVarchar2,
							SProductEntity.ProductionLineName,ParameterDirection.Input),
							new OracleParameter(":GoodsID",OracleDbType.Int32,
							SProductEntity.GoodsID,ParameterDirection.Input),
							new OracleParameter(":GoodsCode",OracleDbType.NVarchar2,
							SProductEntity.GoodsCode,ParameterDirection.Input),
							new OracleParameter(":GoodsName",OracleDbType.NVarchar2,
							SProductEntity.GoodsName,ParameterDirection.Input),
							new OracleParameter(":GroutingDailyID",OracleDbType.Int32,
							SProductEntity.GroutingDailyID,ParameterDirection.Input),
							new OracleParameter(":GroutingDailyDetailID",OracleDbType.Int32,
							SProductEntity.GroutingDailyDetailID,ParameterDirection.Input),
							new OracleParameter(":GroutingDate",OracleDbType.Date,
							SProductEntity.GroutingDate,ParameterDirection.Input),
							new OracleParameter(":GroutingLineID",OracleDbType.Int32,
							SProductEntity.GroutingLineID,ParameterDirection.Input),
							new OracleParameter(":GroutingLineCode",OracleDbType.NVarchar2,
							SProductEntity.GroutingLineCode,ParameterDirection.Input),
							new OracleParameter(":GroutingLineName",OracleDbType.NVarchar2,
							SProductEntity.GroutingLineName,ParameterDirection.Input),
							new OracleParameter(":GMouldTypeID",OracleDbType.Int32,
							SProductEntity.GMouldTypeID,ParameterDirection.Input),
							new OracleParameter(":GroutingLineDetailID",OracleDbType.Int32,
							SProductEntity.GroutingLineDetailID,ParameterDirection.Input),
							new OracleParameter(":GroutingMouldCode",OracleDbType.NVarchar2,
							SProductEntity.GroutingMouldCode,ParameterDirection.Input),
							new OracleParameter(":MouldCode",OracleDbType.NVarchar2,
							SProductEntity.MouldCode,ParameterDirection.Input),
							new OracleParameter(":GoodsLevelID",OracleDbType.Int32,
							SProductEntity.GoodsLevelID,ParameterDirection.Input),
							new OracleParameter(":GoodsLevelTypeID",OracleDbType.Int32,
							SProductEntity.GoodsLevelTypeID,ParameterDirection.Input),
							new OracleParameter(":ResponType",OracleDbType.Int32,
							Convert.ToInt32(SProductEntity.ResponType),ParameterDirection.Input),
							new OracleParameter(":ScrapDate",OracleDbType.Date,
							SProductEntity.ScrapDate,ParameterDirection.Input),
							new OracleParameter(":Rreason",OracleDbType.NVarchar2,
							SProductEntity.Rreason,ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							SProductEntity.Remarks,ParameterDirection.Input),
							new OracleParameter(":AuditStatus",OracleDbType.Int32,
							SProductEntity.AuditStatus,ParameterDirection.Input),
							new OracleParameter(":AccountID",OracleDbType.Int32,
							userInfo.AccountID,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":GroutingUserID",OracleDbType.Int32,
							SProductEntity.GroutingUserID,ParameterDirection.Input),
							new OracleParameter(":GroutingUserCode",OracleDbType.NVarchar2,
							SProductEntity.GroutingUserCode,ParameterDirection.Input),
							new OracleParameter(":GroutingNum",OracleDbType.Decimal,
							SProductEntity.GroutingNum,ParameterDirection.Input),
							new OracleParameter(":IsPublicBody",OracleDbType.Int32,
							SProductEntity.IsPublicBody,ParameterDirection.Input),
							new OracleParameter(":IsReFire",OracleDbType.Int32,
							SProductEntity.IsReFire,ParameterDirection.Input),
							  new OracleParameter(":ScrapFine",OracleDbType.Decimal,
							SProductEntity.ScrapFine,ParameterDirection.Input),
							new OracleParameter(":Auditor",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":AuditlDate",OracleDbType.Date,
							result,ParameterDirection.Input),
							   new OracleParameter(":SpecialRepairflag",OracleDbType.Int32,
							SProductEntity.SpecialRepairflag==null?0:SProductEntity.SpecialRepairflag,ParameterDirection.Input),//SpecialRepairflag
                             new OracleParameter(":Procedureid",OracleDbType.Int32,
							completeProcdureID,ParameterDirection.Input),//SProductEntity.ProcedureID
                            new OracleParameter(":ProcedureName",OracleDbType.Varchar2,
							completeProcdureName,ParameterDirection.Input),//SProductEntity.ProcedureName
                            new OracleParameter(":ProcedureCode",OracleDbType.Varchar2,
							completeProcdureCode,ParameterDirection.Input),//SProductEntity.ProcedureCode
                             new OracleParameter(":logoid",OracleDbType.Int32,
							SProductEntity.LogoID,ParameterDirection.Input),
							new OracleParameter(":ProductionDataID",OracleDbType.Int32,
							ProductionDataID,ParameterDirection.Input),
				};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

				//如果是直接审批通过 wangxin 2015-03-24
				if (SProductEntity.AuditStatus == 1)
				{
					int DeleteRows = 0;
					string sqlInsert = @"insert into TP_PM_InProductionTrash
                                    (
                                        BarCode,
                                        ProductionLineID,
                                        ProductionLineCode,
                                        ProductionLineName,
                                        ProcedureModel,
                                        ModelType,
                                        DefectFlag,
                                        ReworkProcedureID,
                                        IsPublicBody,
                                        IsReFire,
                                        GoodsLevelID,
                                        GoodsLevelTypeID,
                                        GoodsID,
                                        GoodsCode,
                                        GoodsName,
                                        UserID,
                                        GroutingDailyID,
                                        GroutingDailyDetailID,
                                        GroutingDate,
                                        GroutingLineID,
                                        GroutingLineCode,
                                        GroutingLineName,
                                        GMouldTypeID,
                                        CanManyTimes,
                                        GroutingLineDetailID,
                                        GroutingMouldCode,
                                        MouldCode,
                                        GroutingUserID,
                                        GroutingUserCode,
                                        GroutingNum,
                                        Remarks,
                                        KilnID,
                                        KilnCode,
                                        KilnName,
                                        KilnCarID,
                                        KilnCarCode,
                                        KilnCarName,
                                        KilnCarBatchNo,
                                        KilnCarPosition,
                                        AccountID,
                                        ValueFlag,
                                        CreateUserID,
                                        UpdateUserID,
                                        SpecialRepairflag,
                                        FlowProcedureID,
                                        FlowProcedureTime,
                                        ProcedureID,
                                        ProcedureTime,
                                        ProductionDataID,
                                        logoid, ISREWORKFLAG, SEMICHECKID
                                    )
                                    select
                                        BarCode,
                                        ProductionLineID,
                                        ProductionLineCode,
                                        ProductionLineName,
                                        ProcedureModel,
                                        ModelType,
                                        DefectFlag,
                                        ReworkProcedureID,
                                        IsPublicBody,
                                        IsReFire,
                                        :GoodsLevelID,
                                        :GoodsLevelTypeID,
                                        GoodsID,
                                        GoodsCode,
                                        GoodsName,
                                        UserID,
                                        GroutingDailyID,
                                        GroutingDailyDetailID,
                                        GroutingDate,
                                        GroutingLineID,
                                        GroutingLineCode,
                                        GroutingLineName,
                                        GMouldTypeID,
                                        CanManyTimes,
                                        GroutingLineDetailID,
                                        GroutingMouldCode,
                                        MouldCode,
                                        GroutingUserID,
                                        GroutingUserCode,
                                        GroutingNum,
                                        Remarks,
                                        KilnID,
                                        KilnCode,
                                        KilnName,
                                        KilnCarID,
                                        KilnCarCode,
                                        KilnCarName,
                                        KilnCarBatchNo,
                                        KilnCarPosition,
                                        AccountID,
                                        ValueFlag,
                                        :CreateUserID,
                                        :UpdateUserID,
                                        SpecialRepairflag,
                                        FlowProcedureID,
                                        FlowProcedureTime,
                                        ProcedureID,
                                        ProcedureTime,
                                        ProductionDataID,
                                        logoid, ISREWORKFLAG, SEMICHECKID
                                        from TP_PM_InProduction
                                        where barcode='" + SProductEntity.BarCode + "'";
					OracleParameter[] Paras2 = new OracleParameter[] {
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
						   userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							 new OracleParameter(":GoodsLevelID",OracleDbType.Int32,
							SProductEntity.GoodsLevelID,ParameterDirection.Input),
							 new OracleParameter(":GoodsLevelTypeID",OracleDbType.Int32,
							SProductEntity.GoodsLevelTypeID,ParameterDirection.Input)
						};
					DeleteRows = oracleTrConn.ExecuteNonQuery(sqlInsert, Paras2);


					//20150714 modify wangx

					if (SProductEntity.ProcedureID != null)//在生产线上报废的,
					{
						sbSql.Clear();
						sbSql.Append("update  TP_PM_InProduction set inscrapflag='0' where BarCode='" + SProductEntity.BarCode + "'");
						DeleteRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
					}

					//20150714 modify wangx end


					sbSql.Clear();
					sbSql.Append("Delete from TP_PM_InProduction where BarCode='" + SProductEntity.BarCode + "'");
					DeleteRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
					//如果没有删除在产产品，那么要去删除成品表
					if (DeleteRows == 0)
					{
						sbSql.Clear();
						sbSql.Append("Update TP_PM_FinishedProduct set ValueFlag = 0 where BarCode='" + SProductEntity.BarCode + "'");
						DeleteRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
					}
					//并且要把该产品的生产数据的最终状态添加上
					//sbSql.Clear();
					//sbSql.Append("Update TP_PM_ProductionData set GoodsEnding=8 where BarCode='" + SProductEntity.BarCode + "'");
					//UpdateRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
				}
				else
				{
					if (SProductEntity.ProcedureID != null)//在生产线上报废的,
					{
						sbSql.Clear();
						if (SProductEntity.AuditStatus == 0) //待审核
						{
							sbSql.Append("update  TP_PM_InProduction set inscrapflag='1' where BarCode='" + SProductEntity.BarCode + "'");
						}
						else
						{
							sbSql.Append("update  TP_PM_InProduction set inscrapflag='0' where BarCode='" + SProductEntity.BarCode + "'");
						}
						oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
					}
				}

				//-----------------------------------------------

				//判断一下责任类型，如果是责任工序的话，则添加责任工序信息
				if (Convert.ToInt32(SProductEntity.ResponType) == 3)
				{
					//插入产品废弃责任工序
					sbSql.Clear();
					sbSql.Append("select SEQ_PM_ResponProcedure_ID.nextval from dual");
					RProcedureEntity.ResponProcedureID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
					sbSql.Clear();
					sbSql.Append("Insert into TP_PM_ResponProcedure");
					sbSql.Append("(ResponProcedureID,ScrapProductID,Barcode,ProductionDataID,ProductionLineID,");
					sbSql.Append("ProductionLineCode,ProductionLineName,");
					sbSql.Append("ProcedureID,ProcedureCode,ProcedureName,UserID,UserCode,UserName,Remarks,AccountID,");
					sbSql.Append("ValueFlag,CreateTime,CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
					sbSql.Append("Values(:ResponProcedureID,:ScrapProductID,:Barcode,:ProductionDataID,:ProductionLineID,");
					sbSql.Append(":ProductionLineCode,:ProductionLineName,");
					sbSql.Append(":ProcedureID,:ProcedureCode,:ProcedureName,:UserID,:UserCode,:UserName,:Remarks,");
					sbSql.Append(":AccountID,1,sysdate,:CreateUserID,sysdate,:UpdateUserID,systimestamp)");
					OracleParameter[] RPParas = new OracleParameter[] {
							new OracleParameter(":ResponProcedureID",OracleDbType.NVarchar2,
							RProcedureEntity.ResponProcedureID,ParameterDirection.Input),
							new OracleParameter(":ScrapProductID",OracleDbType.Int32,
							id,ParameterDirection.Input),
							new OracleParameter(":Barcode",OracleDbType.NVarchar2,
							RProcedureEntity.BarCode,ParameterDirection.Input),
							new OracleParameter(":ProductionDataID",OracleDbType.NVarchar2,
							RProcedureEntity.ProductionDataID,ParameterDirection.Input),
							new OracleParameter(":ProductionLineID",OracleDbType.NVarchar2,
							RProcedureEntity.ProductionLineID,ParameterDirection.Input),
							new OracleParameter(":ProductionLineCode",OracleDbType.NVarchar2,
							RProcedureEntity.ProductionLineCode,ParameterDirection.Input),
							new OracleParameter(":ProductionLineName",OracleDbType.NVarchar2,
							RProcedureEntity.ProductionLineName,ParameterDirection.Input),
							new OracleParameter(":ProcedureID",OracleDbType.NVarchar2,
							RProcedureEntity.ProcedureID,ParameterDirection.Input),
							new OracleParameter(":ProcedureCode",OracleDbType.NVarchar2,
							RProcedureEntity.ProcedureCode,ParameterDirection.Input),
							new OracleParameter(":ProcedureName",OracleDbType.NVarchar2,
							RProcedureEntity.ProcedureName,ParameterDirection.Input),
							new OracleParameter(":UserID",OracleDbType.NVarchar2,
							RProcedureEntity.UserID,ParameterDirection.Input),
							new OracleParameter(":UserCode",OracleDbType.NVarchar2,
							RProcedureEntity.UserCode,ParameterDirection.Input),
							new OracleParameter(":UserName",OracleDbType.NVarchar2,
							RProcedureEntity.UserName,ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							RProcedureEntity.Remarks,ParameterDirection.Input),
							new OracleParameter(":AccountID",OracleDbType.NVarchar2,
							userInfo.AccountID,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.NVarchar2,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.NVarchar2,
							userInfo.UserID,ParameterDirection.Input),
						};
					rprocedureReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), RPParas);

					#region 更新废弃责任工序的生产工序ID
					string sql = "UPDATE TP_PM_SCRAPPRODUCT SP\n" +
								"   SET (SP.RESPONPROCEDUREPROCEDUREID) =\n" +
								"       (SELECT RP.PROCEDUREID\n" +
								"          FROM TP_PM_RESPONPROCEDURE RP\n" +
								"         WHERE RP.SCRAPPRODUCTID = SP.SCRAPPRODUCTID)\n" +
								" WHERE SP.SCRAPTYPE IN (0, 2, 3)\n" +
								"   AND SP.SCRAPPRODUCTID = :SCRAPPRODUCTID";

					RPParas = new OracleParameter[]
					{
						new OracleParameter(":SCRAPPRODUCTID",OracleDbType.Int32,id,ParameterDirection.Input),
					};
					rprocedureReturn = oracleTrConn.ExecuteNonQuery(sql, RPParas);
					#endregion
				}
				if (Convert.ToInt32(SProductEntity.ResponType) != 1)
				{
					//计算每个责任人的报废扣罚
					decimal scrapfine = 0;
					if (SResponsibleList.Count > 0)
					{
						scrapfine = SProductEntity.ScrapFine / SResponsibleList.Count;
					}
					//循环插入产品废弃责任者
					OracleParameter[] SPParas;
					foreach (ScrapResponsibleEntity spFor in SResponsibleList)
					{
						sbSql.Clear();
						sbSql.Append("select SEQ_PM_ScrapResponsible_ID.nextval from dual");
						spFor.ResponsibleID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
						int? ResponProcedureID = null;
						if (RProcedureEntity != null)
						{
							ResponProcedureID = RProcedureEntity.ResponProcedureID;
						}
						sbSql.Clear();
						sbSql.Append("Insert into TP_PM_ScrapResponsible");
						sbSql.Append("(ResponsibleID,ScrapProductID,ResponType,ResponProcedureID,Barcode,StaffID,UserID,UserCode,UJobsID,SJobsID,");
						sbSql.Append("StaffStatus,AccountID,CreateTime,CreateUserID,");
						sbSql.Append("UpdateTime,UpdateUserID,OPTimeStamp,Scrapfine)");
						sbSql.Append("values(:ResponsibleID,:ScrapProductID,:ResponType,:ResponProcedureID,:Barcode,:StaffID,:UserID,:UserCode,:UJobsID,:SJobsID,");
						sbSql.Append(":StaffStatus,:AccountID,sysdate,:CreateUserID,");
						sbSql.Append("sysdate,:UpdateUserID,systimestamp,:Scrapfine)");
						SPParas = new OracleParameter[]
						{
							new OracleParameter(":ResponsibleID",OracleDbType.Int32,
							spFor.ResponsibleID,ParameterDirection.Input),
							new OracleParameter(":ScrapProductID",OracleDbType.Int32,
							id,ParameterDirection.Input),
							new OracleParameter(":ResponType",OracleDbType.Int32,
							Convert.ToInt32(SProductEntity.ResponType),ParameterDirection.Input),
							new OracleParameter(":ResponProcedureID",OracleDbType.NVarchar2,
							ResponProcedureID,ParameterDirection.Input),
							new OracleParameter(":Barcode",OracleDbType.NVarchar2,
							spFor.BarCode,ParameterDirection.Input),
							new OracleParameter(":StaffID",OracleDbType.Int32,
							spFor.StaffID,ParameterDirection.Input),
							new OracleParameter(":UserID",OracleDbType.Int32,
							spFor.UserID,ParameterDirection.Input),
							new OracleParameter(":UserCode",OracleDbType.NVarchar2,
							spFor.UserCode,ParameterDirection.Input),
							new OracleParameter(":UJobsID",OracleDbType.Int32,
							spFor.UJobsID,ParameterDirection.Input),
							new OracleParameter(":SJobsID",OracleDbType.Int32,
							spFor.SJobsID,ParameterDirection.Input),
							new OracleParameter(":StaffStatus",OracleDbType.Int32,
							spFor.StaffStatus,ParameterDirection.Input),
							new OracleParameter(":AccountID",OracleDbType.Int32,
							userInfo.AccountID,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":Scrapfine",OracleDbType.Decimal,
							scrapfine,ParameterDirection.Input)
						};
						sresponsibleReturnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), SPParas);
					}

					#region 更新废弃责任工序的责任者ID和编码
					string sql = "UPDATE TP_PM_SCRAPPRODUCT SP\n" +
								"   SET (SP.RESPONSIBLEUSERID, SP.RESPONSIBLEUSERCODE) =\n" +
								"       (SELECT SR.USERID, SR.USERCODE\n" +
								"          FROM TP_PM_SCRAPRESPONSIBLE SR\n" +
								"         WHERE SR.SCRAPPRODUCTID = SP.SCRAPPRODUCTID\n" +
								"         GROUP BY SR.USERID, SR.USERCODE)\n" +
								" WHERE SP.SCRAPTYPE IN (0, 2, 3)\n" +
								"   AND SP.SCRAPPRODUCTID = :SCRAPPRODUCTID";

					SPParas = new OracleParameter[]
					{
						new OracleParameter(":SCRAPPRODUCTID",OracleDbType.Int32,id,ParameterDirection.Input),
					};
					rprocedureReturn = oracleTrConn.ExecuteNonQuery(sql, SPParas);
					#endregion
				}
				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 == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return returnRows;
		}

		/// <summary>
		/// 修改废弃产品记录
		/// </summary>
		/// <param name="UpdateSProductEntity">修改的废弃产品实体</param>
		/// <param name="UpdateRProcedureEntity">修改的废弃责任工序实体</param>
		/// <param name="UpdateSResponsibleList">修改的废弃责任人实体</param>
		/// <param name="YSResponsibleList">修改前的废弃责任人实体</param>
		/// <param name="userInfo">用户基本信息</param>
		/// <returns>int结果返回值</returns>
		/// <remarks>
		/// 庄天威              2014.09.24              新建
		/// </remarks>
		public static int UpdateScrapProduct(ScrapProductEntity UpdateSProductEntity,
			ResponProcedureEntity UpdateRProcedureEntity,
			List<ScrapResponsibleEntity> UpdateSResponsibleList, List<ScrapResponsibleEntity> YSResponsibleList,
			SUserInfo userInfo)
		{
			int returnRows = 0;
			int sresponsibleReturnRows = 0;
			int rprocedureReturn = 0;
			int deleteRprocedureReturn = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				//首先修改废弃产品主体信息
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("update TP_PM_ScrapProduct");
				sbSql.Append(" set ScrapDate=to_date(:ScrapDate,'yyyy-mm-dd hh24:mi:ss'),");
				sbSql.Append(" Rreason=:Rreason,");
				sbSql.Append(" Remarks=:Remarks,");
				sbSql.Append(" ResponType=:ResponType,");
				sbSql.Append(" UpdateUserID=:UpdateUserID,");
				sbSql.Append(" ScrapFine=:ScrapFine");
				if (UpdateSProductEntity.AuditStatus != null)
				{
					sbSql.Append(" ,AuditStatus=" + UpdateSProductEntity.AuditStatus);
				}
				if (UpdateSProductEntity.AuditStatus == 0) //待审批
				{
					sbSql.Append(" ,AuditDate=null,Auditor=null");
				}
				else
				{
					//2021年12月6日10:58:08 by fy modify 取系统时间
					//object result = DBNull.Value;
					//string strSql1 = "select FUN_CMN_GetAccountDate(:accountId) From DUAL";
					//Oracle.ManagedDataAccess.Client.OracleParameter[] paras1 = new Oracle.ManagedDataAccess.Client.OracleParameter[]
					//{
					//	new Oracle.ManagedDataAccess.Client.OracleParameter(":accountId",userInfo.AccountID)
					//};
					//object strResult = oracleTrConn.GetSqlResultToObj(strSql1, paras1);
					//if (strResult == null || strResult == DBNull.Value)
					//{
					//	// 服务器时间错误
					//	throw new Exception("SystemDateTimeError");
					//}
					//result = Convert.ToDateTime(strResult);
					//sbSql.Append(string.Format(" ,AuditDate=to_date('{0}','yyyy-mm-dd hh24:mi:ss'),Auditor={1}", result.ToString().Replace("/", "-"), userInfo.UserID));
					sbSql.Append(string.Format(" ,AuditDate=sysdate,Auditor={0},AccountDate=trunc(sysdate)", userInfo.UserID));
				}

				sbSql.Append(" where ScrapProductID=:ScrapProductID");
				OracleParameter[] Paras = new OracleParameter[] 
				{
					new OracleParameter(":ScrapDate",OracleDbType.NVarchar2,
						UpdateSProductEntity.ScrapDate.ToString(),ParameterDirection.Input),
					new OracleParameter(":Rreason",OracleDbType.NVarchar2,
						UpdateSProductEntity.Rreason,ParameterDirection.Input),
					new OracleParameter(":Remarks",OracleDbType.NVarchar2,
						UpdateSProductEntity.Remarks,ParameterDirection.Input),
					new OracleParameter(":ResponType",OracleDbType.Int32,
						UpdateSProductEntity.ResponType,ParameterDirection.Input),
					new OracleParameter(":UpdateUserID",OracleDbType.Int32,
						userInfo.UserID,ParameterDirection.Input),
					new OracleParameter(":ScrapProductID",OracleDbType.NVarchar2,
						UpdateSProductEntity.ScrapProductID,ParameterDirection.Input),
					new OracleParameter(":ScrapFine",OracleDbType.Decimal,
						UpdateSProductEntity.ScrapFine,ParameterDirection.Input)
				};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);



				//如果是直接审批通过 wangxin 2015-03-24
				if (UpdateSProductEntity.AuditStatus == 1)
				{
					int DeleteRows = 0;
					string sqlInsert = @"insert into TP_PM_InProductionTrash
                                    (
                                        BarCode,
                                        ProductionLineID,
                                        ProductionLineCode,
                                        ProductionLineName,
                                        ProcedureModel,
                                        ModelType,
                                        DefectFlag,
                                        ReworkProcedureID,
                                        IsPublicBody,
                                        IsReFire,
                                        GoodsLevelID,
                                        GoodsLevelTypeID,
                                        GoodsID,
                                        GoodsCode,
                                        GoodsName,
                                        UserID,
                                        GroutingDailyID,
                                        GroutingDailyDetailID,
                                        GroutingDate,
                                        GroutingLineID,
                                        GroutingLineCode,
                                        GroutingLineName,
                                        GMouldTypeID,
                                        CanManyTimes,
                                        GroutingLineDetailID,
                                        GroutingMouldCode,
                                        MouldCode,
                                        GroutingUserID,
                                        GroutingUserCode,
                                        GroutingNum,
                                        Remarks,
                                        KilnID,
                                        KilnCode,
                                        KilnName,
                                        KilnCarID,
                                        KilnCarCode,
                                        KilnCarName,
                                        KilnCarBatchNo,
                                        KilnCarPosition,
                                        AccountID,
                                        ValueFlag,
                                        CreateUserID,
                                        UpdateUserID,
                                        SpecialRepairflag,
                                        FlowProcedureID,
                                        FlowProcedureTime,
                                        ProcedureID,
                                        ProcedureTime,
                                        ProductionDataID,
                                        logoid, ISREWORKFLAG, SEMICHECKID
                                    )
                                    select
                                        BarCode,
                                        ProductionLineID,
                                        ProductionLineCode,
                                        ProductionLineName,
                                        ProcedureModel,
                                        ModelType,
                                        DefectFlag,
                                        ReworkProcedureID,
                                        IsPublicBody,
                                        IsReFire,
                                        :GoodsLevelID,
                                        :GoodsLevelTypeID,
                                        GoodsID,
                                        GoodsCode,
                                        GoodsName,
                                        UserID,
                                        GroutingDailyID,
                                        GroutingDailyDetailID,
                                        GroutingDate,
                                        GroutingLineID,
                                        GroutingLineCode,
                                        GroutingLineName,
                                        GMouldTypeID,
                                        CanManyTimes,
                                        GroutingLineDetailID,
                                        GroutingMouldCode,
                                        MouldCode,
                                        GroutingUserID,
                                        GroutingUserCode,
                                        GroutingNum,
                                        Remarks,
                                        KilnID,
                                        KilnCode,
                                        KilnName,
                                        KilnCarID,
                                        KilnCarCode,
                                        KilnCarName,
                                        KilnCarBatchNo,
                                        KilnCarPosition,
                                        AccountID,
                                        ValueFlag,
                                        :CreateUserID,
                                        :UpdateUserID,
                                        SpecialRepairflag,
                                        FlowProcedureID,
                                        FlowProcedureTime,
                                        ProcedureID,
                                        ProcedureTime,
                                        ProductionDataID,
                                        logoid, ISREWORKFLAG, SEMICHECKID
                                        from TP_PM_InProduction
                                        where barcode='" + UpdateSProductEntity.BarCode + "'";
					OracleParameter[] Paras2 = new OracleParameter[] {
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
						   userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
                             new OracleParameter(":GoodsLevelID",OracleDbType.Int32,
                            UpdateSProductEntity.GoodsLevelID,ParameterDirection.Input),
                             new OracleParameter(":GoodsLevelTypeID",OracleDbType.Int32,
                            UpdateSProductEntity.GoodsLevelTypeID,ParameterDirection.Input)
                        };
					DeleteRows = oracleTrConn.ExecuteNonQuery(sqlInsert, Paras2);

					//20150714 modify wangx

					if (UpdateSProductEntity.ProcedureID != null)//在生产线上报废的,
					{
						sbSql.Clear();
						sbSql.Append("update  TP_PM_InProduction set inscrapflag='0' where BarCode='" + UpdateSProductEntity.BarCode + "'");
						DeleteRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
					}

					//20150714 modify wangx end

					sbSql.Clear();
					sbSql.Append("Delete from TP_PM_InProduction where BarCode='" + UpdateSProductEntity.BarCode + "'");
					DeleteRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
					//如果没有删除在产产品，那么要去删除成品表
					if (DeleteRows == 0)
					{
						sbSql.Clear();
						sbSql.Append("Update TP_PM_FinishedProduct set ValueFlag = 0 where BarCode='" + UpdateSProductEntity.BarCode + "'");
						DeleteRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
					}
					//并且要把该产品的生产数据的最终状态添加上
					//sbSql.Clear();
					//sbSql.Append("Update TP_PM_ProductionData set GoodsEnding=8 where BarCode='" + UpdateSProductEntity.BarCode + "'");
					//UpdateRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
				}
				else
				{
					//if (UpdateSProductEntity.ProcedureID != null)//在生产线上报废的,
					//{
					sbSql.Clear();
					if (UpdateSProductEntity.AuditStatus == 0) //待审核
					{
						sbSql.Append("update  TP_PM_InProduction set inscrapflag='1' where BarCode='" + UpdateSProductEntity.BarCode + "'");
					}
					else
					{
						sbSql.Append("update  TP_PM_InProduction set inscrapflag='0' where BarCode='" + UpdateSProductEntity.BarCode + "'");
					}
					oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
					//}
				}
				//-----------------------------------------------



				//无论如何，要把原始的责任者数据删除
				foreach (ScrapResponsibleEntity spFor in YSResponsibleList)
				{
					sbSql.Clear();
					sbSql.Append("delete from TP_PM_ScrapResponsible");
					sbSql.Append(" where ResponsibleID=:ResponsibleID ");
					OracleParameter[] SPParas = new OracleParameter[] {
							new OracleParameter(":ResponsibleID",OracleDbType.Int32,
							spFor.ResponsibleID,ParameterDirection.Input)
					};
					deleteRprocedureReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), SPParas);
				}
				//判断一下责任类型，如果有责任工序的话，则修改责任工序信息
				if (Convert.ToInt32(UpdateSProductEntity.ResponType) == 3)
				{
					if (UpdateRProcedureEntity != null)
					{
						if (UpdateRProcedureEntity.ResponProcedureID != null)
						{
							sbSql.Clear();
							sbSql.Append("update TP_PM_ResponProcedure");
							sbSql.Append(" set ProcedureID=:ProcedureID,");
							sbSql.Append(" ProcedureCode=:ProcedureCode,");
							sbSql.Append(" ProcedureName=:ProcedureName,");
							sbSql.Append(" UserID=:UserID,");
							sbSql.Append(" UserCode=:UserCode,");
							sbSql.Append(" UserName=:UserName,");
							sbSql.Append(" UpdateUserID=:UpdateUserID");
							sbSql.Append(" where ResponProcedureID=:ResponProcedureID");
							OracleParameter[] RPParas = new OracleParameter[]
							{
								new OracleParameter(":ProcedureID",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.ProcedureID,ParameterDirection.Input),
								new OracleParameter(":ProcedureCode",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.ProcedureCode,ParameterDirection.Input),
								new OracleParameter(":ProcedureName",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.ProcedureName,ParameterDirection.Input),
								new OracleParameter(":UserID",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.UserID,ParameterDirection.Input),
								new OracleParameter(":UserCode",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.UserCode,ParameterDirection.Input),
								new OracleParameter(":UserName",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.UserName,ParameterDirection.Input),
								new OracleParameter(":UpdateUserID",OracleDbType.NVarchar2,
								userInfo.UserID,ParameterDirection.Input),
								new OracleParameter(":ResponProcedureID",OracleDbType.Int32,
								UpdateRProcedureEntity.ResponProcedureID,ParameterDirection.Input)
							};
							rprocedureReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), RPParas);
						}
						else
						{
							//插入产品废弃责任工序
							sbSql.Clear();
							sbSql.Append("select SEQ_PM_ResponProcedure_ID.nextval from dual");
							UpdateRProcedureEntity.ResponProcedureID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
							sbSql.Clear();
							sbSql.Append("Insert into TP_PM_ResponProcedure");
							sbSql.Append("(ResponProcedureID,ScrapProductID,Barcode,ProductionDataID,ProductionLineID,");
							sbSql.Append("ProductionLineCode,ProductionLineName,");
							sbSql.Append("ProcedureID,ProcedureCode,ProcedureName,UserID,UserCode,UserName,Remarks,AccountID,");
							sbSql.Append("ValueFlag,CreateTime,CreateUserID,UpdateTime,UpdateUserID,OPTimeStamp)");
							sbSql.Append("Values(:ResponProcedureID,:ScrapProductID,:Barcode,:ProductionDataID,:ProductionLineID,");
							sbSql.Append(":ProductionLineCode,:ProductionLineName,");
							sbSql.Append(":ProcedureID,:ProcedureCode,:ProcedureName,:UserID,:UserCode,:UserName,:Remarks,");
							sbSql.Append(":AccountID,1,sysdate,:CreateUserID,sysdate,:UpdateUserID,systimestamp)");
							OracleParameter[] RPParas = new OracleParameter[] 
							{
								new OracleParameter(":ResponProcedureID",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.ResponProcedureID,ParameterDirection.Input),
								new OracleParameter(":ScrapProductID",OracleDbType.Int32,
								UpdateSProductEntity.ScrapProductID,ParameterDirection.Input),
								new OracleParameter(":Barcode",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.BarCode,ParameterDirection.Input),
								new OracleParameter(":ProductionDataID",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.ProductionDataID,ParameterDirection.Input),
								new OracleParameter(":ProductionLineID",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.ProductionLineID,ParameterDirection.Input),
								new OracleParameter(":ProductionLineCode",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.ProductionLineCode,ParameterDirection.Input),
								new OracleParameter(":ProductionLineName",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.ProductionLineName,ParameterDirection.Input),
								new OracleParameter(":ProcedureID",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.ProcedureID,ParameterDirection.Input),
								new OracleParameter(":ProcedureCode",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.ProcedureCode,ParameterDirection.Input),
								new OracleParameter(":ProcedureName",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.ProcedureName,ParameterDirection.Input),
								new OracleParameter(":UserID",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.UserID,ParameterDirection.Input),
								new OracleParameter(":UserCode",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.UserCode,ParameterDirection.Input),
								new OracleParameter(":UserName",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.UserName,ParameterDirection.Input),
								new OracleParameter(":Remarks",OracleDbType.NVarchar2,
								UpdateRProcedureEntity.Remarks,ParameterDirection.Input),
								new OracleParameter(":AccountID",OracleDbType.NVarchar2,
								userInfo.AccountID,ParameterDirection.Input),
								new OracleParameter(":CreateUserID",OracleDbType.NVarchar2,
								userInfo.UserID,ParameterDirection.Input),
								new OracleParameter(":UpdateUserID",OracleDbType.NVarchar2,
								userInfo.UserID,ParameterDirection.Input)
							};
							rprocedureReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), RPParas);
						}
					}
				}
				else //责任类型改为不存在责任工序了，要把原来的删除
				{
					if (UpdateRProcedureEntity != null)  //本来就没有的话就不用删了
					{
						if (UpdateRProcedureEntity.ValueFlag == 0)  //直接删除即可
						{
							sbSql.Clear();
							sbSql.Append("Delete from TP_PM_ResponProcedure");
							sbSql.Append(" where ResponProcedureID=:ResponProcedureID");
							OracleParameter[] RPParas = new OracleParameter[] {
							new OracleParameter(":ResponProcedureID",OracleDbType.Int32,
							UpdateRProcedureEntity.ResponProcedureID,ParameterDirection.Input)
						};
							rprocedureReturn = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), RPParas);
						}
					}
				}
				//如果存在修改的产品废弃责任者
				if (Convert.ToInt32(UpdateSProductEntity.ResponType) != 1)
				{

					//计算每个责任人的报废扣罚
					decimal scrapfine = 0;
					if (UpdateSResponsibleList.Count > 0)
					{
						scrapfine = UpdateSProductEntity.ScrapFine / UpdateSResponsibleList.Count;
					}
					//循环插入产品废弃责任者
					foreach (ScrapResponsibleEntity spFor in UpdateSResponsibleList)
					{
						sbSql.Clear();
						sbSql.Append("select SEQ_PM_ScrapResponsible_ID.nextval from dual");
						spFor.ResponsibleID = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
						int? ResponProcedureID = null;
						if (UpdateRProcedureEntity != null)
						{
							if (UpdateRProcedureEntity.ValueFlag != 0)
							{
								ResponProcedureID = UpdateRProcedureEntity.ResponProcedureID;
							}
						}
						sbSql.Clear();
						sbSql.Append("Insert into TP_PM_ScrapResponsible");
						sbSql.Append("(ResponsibleID,ResponType,ResponProcedureID,Barcode,ScrapProductID,StaffID,UserID,UserCode,UJobsID,SJobsID,");
						sbSql.Append("StaffStatus,AccountID,CreateTime,CreateUserID,");
						sbSql.Append("UpdateTime,UpdateUserID,OPTimeStamp,Scrapfine)");
						sbSql.Append("values(:ResponsibleID,:ResponType,:ResponProcedureID,:Barcode,:ScrapProductID,:StaffID,:UserID,:UserCode,:UJobsID,:SJobsID,");
						sbSql.Append(":StaffStatus,:AccountID,sysdate,:CreateUserID,");
						sbSql.Append("sysdate,:UpdateUserID,systimestamp,:Scrapfine)");
						OracleParameter[] SPParas = new OracleParameter[]
						{
							new OracleParameter(":ResponsibleID",OracleDbType.Int32,
							spFor.ResponsibleID,ParameterDirection.Input),
							new OracleParameter(":ResponType",OracleDbType.Int32,
							Convert.ToInt32(UpdateSProductEntity.ResponType),ParameterDirection.Input),
							new OracleParameter(":ResponProcedureID",OracleDbType.NVarchar2,
							ResponProcedureID,ParameterDirection.Input),
							new OracleParameter(":Barcode",OracleDbType.NVarchar2,
							spFor.BarCode,ParameterDirection.Input),
							new OracleParameter(":ScrapProductID",OracleDbType.Int32,
							UpdateSProductEntity.ScrapProductID,ParameterDirection.Input),
							new OracleParameter(":StaffID",OracleDbType.Int32,
							spFor.StaffID,ParameterDirection.Input),
							new OracleParameter(":UserID",OracleDbType.Int32,
							spFor.UserID,ParameterDirection.Input),
							new OracleParameter(":UserCode",OracleDbType.NVarchar2,
							spFor.UserCode,ParameterDirection.Input),
							new OracleParameter(":UJobsID",OracleDbType.Int32,
							spFor.UJobsID,ParameterDirection.Input),
							new OracleParameter(":SJobsID",OracleDbType.Int32,
							spFor.SJobsID,ParameterDirection.Input),
							new OracleParameter(":StaffStatus",OracleDbType.Int32,
							spFor.StaffStatus,ParameterDirection.Input),
							new OracleParameter(":AccountID",OracleDbType.Int32,
							userInfo.AccountID,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":Scrapfine",OracleDbType.Decimal,
							scrapfine,ParameterDirection.Input)
						};
						sresponsibleReturnRows += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), SPParas);
					}
				}
				#region 更新废弃责任工序的生产工序ID
				string sql = "UPDATE TP_PM_SCRAPPRODUCT SP\n" +
							"   SET (SP.RESPONPROCEDUREPROCEDUREID) =\n" +
							"       (SELECT RP.PROCEDUREID\n" +
							"          FROM TP_PM_RESPONPROCEDURE RP\n" +
							"         WHERE RP.SCRAPPRODUCTID = SP.SCRAPPRODUCTID)\n" +
							" WHERE SP.SCRAPTYPE IN (0, 2, 3)\n" +
							"   AND SP.SCRAPPRODUCTID = :SCRAPPRODUCTID";
				Paras = new OracleParameter[]
				{
						new OracleParameter(":SCRAPPRODUCTID",OracleDbType.Int32,UpdateSProductEntity.ScrapProductID,ParameterDirection.Input),
				};
				rprocedureReturn = oracleTrConn.ExecuteNonQuery(sql, Paras);
				#endregion

				#region 更新废弃责任工序的责任者ID和编码
				sql = "UPDATE TP_PM_SCRAPPRODUCT SP\n" +
						"   SET (SP.RESPONSIBLEUSERID, SP.RESPONSIBLEUSERCODE) =\n" +
						"       (SELECT SR.USERID, SR.USERCODE\n" +
						"          FROM TP_PM_SCRAPRESPONSIBLE SR\n" +
						"         WHERE SR.SCRAPPRODUCTID = SP.SCRAPPRODUCTID\n" +
						"         GROUP BY SR.USERID, SR.USERCODE)\n" +
						" WHERE SP.SCRAPTYPE IN (0, 2, 3)\n" +
						"   AND SP.SCRAPPRODUCTID = :SCRAPPRODUCTID";
				Paras = new OracleParameter[]
				{
						new OracleParameter(":SCRAPPRODUCTID",OracleDbType.Int32,UpdateSProductEntity.ScrapProductID,ParameterDirection.Input),
				};
				rprocedureReturn = oracleTrConn.ExecuteNonQuery(sql, Paras);
				#endregion

				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 == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return returnRows;
		}

		/// <summary>
		/// 审核报损产品信息
		/// </summary>
		/// <param name="spEntity">被审核的产品实体</param>
		/// <param name="userInfo">用户基本信息</param>
		/// <returns>int</returns>
		public static int AuditScrapProduct(ScrapProductEntity spEntity, SUserInfo userInfo)
		{
			int returnRows = 0;
			int DeleteRows = 0;
			//int UpdateRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append("update TP_PM_ScrapProduct");
				sbSql.Append(" set AuditStatus=:AuditStatus,");
				sbSql.Append(" Auditor=:Auditor,");
				//sbSql.Append(" AuditDate=to_date(:AuditDate,'yyyy-MM-dd'),");
                //sbSql.Append(" AuditDate=:AuditDate,");
				sbSql.Append(" AuditDate=sysdate,");
				sbSql.Append(" AuditOpinion=:AuditOpinion,");
				sbSql.Append(" UpdateUserID=:UpdateUserID");
				sbSql.Append(" where ScrapProductID=:ScrapProductID and OPTimeStamp=:OPTimeStamp");
				OracleParameter[] RPParas = new OracleParameter[] {
							new OracleParameter(":AuditStatus",OracleDbType.Int32,
							spEntity.AuditStatus,ParameterDirection.Input),
							new OracleParameter(":Auditor",OracleDbType.Int32,
							spEntity.Auditor,ParameterDirection.Input),
							//new OracleParameter(":AuditDate",OracleDbType.NVarchar2,
							//Convert.ToDateTime(spEntity.AuditlDate).ToString("yyyy-MM-dd"),ParameterDirection.Input),

							//2021年12月6日10:45:35 by fy modify将审核时间修改为系统当前时间
                            //new OracleParameter(":AuditDate",OracleDbType.Date,
                            //spEntity.AuditlDate,ParameterDirection.Input),

                            new OracleParameter(":AuditOpinion",OracleDbType.NVarchar2,
							spEntity.AuditOpinion,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.NVarchar2,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":ScrapProductID",OracleDbType.NVarchar2,
							spEntity.ScrapProductID,ParameterDirection.Input),
							new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							spEntity.OPTimeStamp,ParameterDirection.Input)
						};
				returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), RPParas);
				if (returnRows == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return -500;
				}
				//如果审核通过，要删除在产产品表中对应的信息
				if (spEntity.AuditStatus == 1)
				{

					string sqlInsert = @"insert into TP_PM_InProductionTrash
                                    (
                                        BarCode,
                                        ProductionLineID,
                                        ProductionLineCode,
                                        ProductionLineName,
                                        ProcedureModel,
                                        ModelType,
                                        DefectFlag,
                                        ReworkProcedureID,
                                        IsPublicBody,
                                        IsReFire,
                                        GoodsLevelID,
                                        GoodsLevelTypeID,
                                        GoodsID,
                                        GoodsCode,
                                        GoodsName,
                                        UserID,
                                        GroutingDailyID,
                                        GroutingDailyDetailID,
                                        GroutingDate,
                                        GroutingLineID,
                                        GroutingLineCode,
                                        GroutingLineName,
                                        GMouldTypeID,
                                        CanManyTimes,
                                        GroutingLineDetailID,
                                        GroutingMouldCode,
                                        MouldCode,
                                        GroutingUserID,
                                        GroutingUserCode,
                                        GroutingNum,
                                        Remarks,
                                        KilnID,
                                        KilnCode,
                                        KilnName,
                                        KilnCarID,
                                        KilnCarCode,
                                        KilnCarName,
                                        KilnCarBatchNo,
                                        KilnCarPosition,
                                        AccountID,
                                        ValueFlag,
                                        CreateUserID,
                                        UpdateUserID,
                                        SpecialRepairflag,
                                        FlowProcedureID,
                                        FlowProcedureTime,
                                        ProcedureID,
                                        ProcedureTime,
                                        ProductionDataID,logoid, ISREWORKFLAG, SEMICHECKID
                                    )
                                    select
                                        BarCode,
                                        ProductionLineID,
                                        ProductionLineCode,
                                        ProductionLineName,
                                        ProcedureModel,
                                        ModelType,
                                        DefectFlag,
                                        ReworkProcedureID,
                                        IsPublicBody,
                                        IsReFire,
                                        :GoodsLevelID,
                                        :GoodsLevelTypeID,
                                        GoodsID,
                                        GoodsCode,
                                        GoodsName,
                                        UserID,
                                        GroutingDailyID,
                                        GroutingDailyDetailID,
                                        GroutingDate,
                                        GroutingLineID,
                                        GroutingLineCode,
                                        GroutingLineName,
                                        GMouldTypeID,
                                        CanManyTimes,
                                        GroutingLineDetailID,
                                        GroutingMouldCode,
                                        MouldCode,
                                        GroutingUserID,
                                        GroutingUserCode,
                                        GroutingNum,
                                        Remarks,
                                        KilnID,
                                        KilnCode,
                                        KilnName,
                                        KilnCarID,
                                        KilnCarCode,
                                        KilnCarName,
                                        KilnCarBatchNo,
                                        KilnCarPosition,
                                        AccountID,
                                        ValueFlag,
                                        :CreateUserID,
                                        :UpdateUserID,
                                        SpecialRepairflag,
                                        FlowProcedureID,
                                        FlowProcedureTime,
                                        ProcedureID,
                                        ProcedureTime,
                                        ProductionDataID,logoid, ISREWORKFLAG, SEMICHECKID
                                        from TP_PM_InProduction
                                        where barcode='" + spEntity.BarCode + "'";
					OracleParameter[] Paras = new OracleParameter[] {
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
						   userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
                             new OracleParameter(":GoodsLevelID",OracleDbType.Int32,
                            spEntity.GoodsLevelID,ParameterDirection.Input),
                             new OracleParameter(":GoodsLevelTypeID",OracleDbType.Int32,
                            spEntity.GoodsLevelTypeID,ParameterDirection.Input)
                        };
					DeleteRows = oracleTrConn.ExecuteNonQuery(sqlInsert, Paras);


					sbSql.Clear();
					sbSql.Append("Delete from TP_PM_InProduction where BarCode='" + spEntity.BarCode + "'");
					DeleteRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
					//如果没有删除在产产品，那么要去删除成品表
					if (DeleteRows == 0)
					{
						sbSql.Clear();
						sbSql.Append("Update TP_PM_FinishedProduct set ValueFlag = 0 where BarCode='" + spEntity.BarCode + "'");
						DeleteRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
					}
					//并且要把该产品的生产数据的最终状态添加上
					//sbSql.Clear();
					//sbSql.Append("Update TP_PM_ProductionData set GoodsEnding=8 where BarCode='" + spEntity.BarCode + "'");
					//UpdateRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
				}
				if (spEntity.AuditStatus != 1) //审批未通过
				{
					sbSql.Clear();
					sbSql.Append("update  TP_PM_InProduction set inscrapflag='0' where BarCode='" + spEntity.BarCode + "'");
					oracleTrConn.ExecuteNonQuery(sbSql.ToString(), null);
				}


				if (spEntity.AuditStatus == 1 && DeleteRows == 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();
				}
			}
		}

		#endregion

		#region 温湿计信息

		/// <summary>
		/// 添加温湿计信息
		/// </summary>
		/// <param name="crEntity">温湿计信息实体</param>
		/// <param name="userInfo">当前用户</param>
		/// <returns>影响行/结果</returns>
		public static int AddCelsiusRecord(CelsiusRecordEntity crEntity, SUserInfo userInfo)
		{
			int RowsCount = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				StringBuilder sbSql = new StringBuilder();
				//获取序列ID
				sbSql.Clear();
				sbSql.Append("select SEQ_MST_Thermometer_ID.nextval from dual");
				int entityId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
				sbSql.Clear();

				//添加温湿计信息
				sbSql.Append(@"Insert into TP_PM_CelsiusRecord
                               (RecordID,ThermometerID,RecorderID,RecordDate,Celsius,Humidity,
                                Remarks,AccountID,CreateUserID,UpdateUserID)
                               Values
                               (:RecordID,:ThermometerID,:RecorderID,:RecordDate,:Celsius,:Humidity,
                                :Remarks,:AccountID,:CreateUserID,:UpdateUserID)");
				OracleParameter[] CRParas = new OracleParameter[] {
							new OracleParameter(":RecordID",OracleDbType.Int32,
							entityId,ParameterDirection.Input),
							new OracleParameter(":ThermometerID",OracleDbType.Int32,
							crEntity.ThermometerID,ParameterDirection.Input),
							new OracleParameter(":RecorderID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":RecordDate",OracleDbType.Date,
							crEntity.RecordDate,ParameterDirection.Input),
							new OracleParameter(":Celsius",OracleDbType.Decimal,
							crEntity.Celsius,ParameterDirection.Input),
							new OracleParameter(":Humidity",OracleDbType.Decimal,
							crEntity.Humidity,ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.Varchar2,
							crEntity.Remarks,ParameterDirection.Input),
							new OracleParameter(":AccountID",OracleDbType.Int32,
							userInfo.AccountID,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
				};
				//连接数据库并返回结果
				RowsCount = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), CRParas);
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return RowsCount;
			}
			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="crEntity">温湿计信息实体</param>
		/// <param name="userInfo">当前用户</param>
		/// <returns>影响行/结果</returns>
		public static int UpdateCelsiusRecord(CelsiusRecordEntity crEntity, SUserInfo userInfo)
		{
			int RowsCount = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				StringBuilder sbSql = new StringBuilder();

				//修改温湿度信息
				sbSql.Append(@"Update TP_PM_CelsiusRecord
                                Set RecordDate = :RecordDate,
                                Celsius = :Celsius,
                                Humidity = :Humidity,
                                Remarks = :Remarks,
                                UpdateUserID = :UpdateUserID
                                Where RecordId = :RecordID");
				OracleParameter[] CRParas = new OracleParameter[] {
							new OracleParameter(":RecordDate",OracleDbType.Date,
							crEntity.RecordDate,ParameterDirection.Input),
							new OracleParameter(":Celsius",OracleDbType.Decimal,
							crEntity.Celsius,ParameterDirection.Input),
							new OracleParameter(":Humidity",OracleDbType.Decimal,
							crEntity.Humidity,ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.Varchar2,
							crEntity.Remarks,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":RecordID",OracleDbType.Int32,
							crEntity.RecordID,ParameterDirection.Input),
				};
				//连接数据库并返回结果
				RowsCount = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), CRParas);
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return RowsCount;
			}
			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="RecordTime">记录时间</param>
		/// <param name="dtCelsius">信息数据集</param>
		/// <param name="userInfo">用户信息</param>
		/// <returns>影响行数</returns>
		public static int EditCelsiusRecord(DateTime RecordTime, DataTable dtCelsius, SUserInfo userInfo)
		{
			int RowsCount = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				StringBuilder sbSql = new StringBuilder();
				foreach (DataRow drFor in dtCelsius.Rows)
				{
					sbSql.Clear();
					if (drFor.RowState == DataRowState.Added)
					{
						//获取序列ID
						sbSql.Append("select SEQ_MST_Thermometer_ID.nextval from dual");
						int entityId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
						sbSql.Clear();

						//添加温湿计信息
						sbSql.Append(@"Insert into TP_PM_CelsiusRecord
                               (RecordID,ThermometerID,RecorderID,RecordDate,Celsius,Humidity,
                                Remarks,AccountID,CreateUserID,UpdateUserID)
                               Values
                               (:RecordID,:ThermometerID,:RecorderID,:RecordDate,:Celsius,:Humidity,
                                :Remarks,:AccountID,:CreateUserID,:UpdateUserID)");
						OracleParameter[] CRParas = new OracleParameter[] {
							new OracleParameter(":RecordID",OracleDbType.Int32,
							entityId,ParameterDirection.Input),
							new OracleParameter(":ThermometerID",OracleDbType.Int32,
							drFor["ThermometerID"],ParameterDirection.Input),
							new OracleParameter(":RecorderID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":RecordDate",OracleDbType.Date,
							RecordTime,ParameterDirection.Input),
							new OracleParameter(":Celsius",OracleDbType.Decimal,
							drFor["Celsius"]==DBNull.Value?0: drFor["Celsius"],ParameterDirection.Input),
							new OracleParameter(":Humidity",OracleDbType.Decimal,
							drFor["Humidity"]==DBNull.Value?0: drFor["Humidity"],ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.Varchar2,
							drFor["Remarks"],ParameterDirection.Input),
							new OracleParameter(":AccountID",OracleDbType.Int32,
							userInfo.AccountID,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
						};
						//连接数据库并返回结果
						RowsCount += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), CRParas);
					}
					else if (drFor.RowState == DataRowState.Modified)
					{
						//修改
						sbSql.Append(@"Update TP_PM_CelsiusRecord
                                Set RecordDate = :RecordDate,
                                Celsius = :Celsius,
                                Humidity = :Humidity,
                                Remarks = :Remarks,
                                UpdateUserID = :UpdateUserID
                                Where RecordId = :RecordID");
						OracleParameter[] CRParas = new OracleParameter[] {
							new OracleParameter(":RecordDate",OracleDbType.Date,
							RecordTime,ParameterDirection.Input),
							new OracleParameter(":Celsius",OracleDbType.Decimal,
							drFor["Celsius"]==DBNull.Value?0: drFor["Celsius"],ParameterDirection.Input),
							new OracleParameter(":Humidity",OracleDbType.Decimal,
							drFor["Humidity"]==DBNull.Value?0: drFor["Humidity"],ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.Varchar2,
							drFor["Remarks"],ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":RecordID",OracleDbType.Int32,
							drFor["RecordID"],ParameterDirection.Input),
						};
						//连接数据库并返回结果
						RowsCount += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), CRParas);
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return RowsCount;
			}
			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="recordID">记录id</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>影响行数</returns>
		/// <remarks>
		/// 陈晓野              2016.09.13              新建
		/// </remarks>
		public static int DeleteCelsiusRecord(int recordID, SUserInfo user)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				string sql = "Update TP_PM_CelsiusRecord t "
					+ " Set t.ValueFlag = '0' Where t.RecordId = :RecordID";

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

				//连接数据库并返回结果
				int rowsCount = oracleTrConn.ExecuteNonQuery(sql, paras);

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

		/// <summary>
		/// 添加撤销装车
		/// </summary>
		/// <param name="procedureID"><工序ID/param>
		/// <param name="barcode">产品条码</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>string</returns>
		public static string AddCancelLoadCar(int procedureID, string barcode, SUserInfo sUserInfo)
		{
			string errMsg = "";
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter("in_barcode",OracleDbType.Varchar2,
						barcode,ParameterDirection.Input),
					new OracleParameter("in_procedureid",OracleDbType.Int32,procedureID,ParameterDirection.Input),
					new OracleParameter("in_accountID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
					new OracleParameter("out_errMsg",OracleDbType.NVarchar2,200,null,ParameterDirection.Output),
					new OracleParameter("out_goodscode",OracleDbType.NVarchar2,50,null,ParameterDirection.Output),
					new OracleParameter("out_goodsname",OracleDbType.NVarchar2,50,null,ParameterDirection.Output),
					new OracleParameter("out_kilncarcode",OracleDbType.NVarchar2,50,null,ParameterDirection.Output),
				};
				oracleTrConn.ExecStoredProcedure("PRO_PM_CheckCancelLoadCar", paras);
				errMsg = paras[3].Value.ToString() == "null" ? "" : paras[3].Value.ToString().Replace("\\n\\r", "\n\r");
				if (string.IsNullOrEmpty(errMsg))
				{
					#region 先查询生产数据最后2条
					//                    string sqlString = @"select ProductionDataID,
					//                                           ProcedureID,
					//                                           ProcedureModel,
					//                                           ModelType,
					//                                           ReworkProcedureID,
					//                                           UserID
					//                                      from (select ProductionDataID,
					//                                                   ProcedureID,
					//                                                   ProcedureModel,
					//                                                   ModelType,
					//                                                   ReworkProcedureID,
					//                                                   UserID
					//                                              from Tp_Pm_ProductiondataIn
					//                                             where barcode = :barcode
					//                                               and valueflag = 1
					//                                             order by ProductionDataID desc)
					//                                     where rownum <= 2";
					string sqlString = @"select ProductionDataID,
                                           ProcedureID,
                                             ProcedureName,
                                           ProcedureModel,
                                           ModelType,
                                           ReworkProcedureID,
                                           UserID,
                                           logoid,
                                        KILNID ,
                                        KILNCODE,
                                        KILNNAME,
                                        KilnCarID,
                                        KILNCARCODE,
                                        KILNCARNAME,
                                        KILNCARBATCHNO,
                                        KILNCARPOSITION,
(select max(ProcedureID) from Tp_Pm_ProductiondataIn inpp where inpp.barcode = :barcode and inpp.ProductionDataID > t.ProductionDataID and ModelType=8 and valueflag='1') p8id --干补
                                      from (select ProductionDataID,
                                                   ProcedureID,
                                                    ProcedureName,
                                                   ProcedureModel,
                                                   ModelType,
                                                   ReworkProcedureID,
                                                   UserID,
                                                   logoid,
                                                   KILNID ,
                                                   KILNCODE,
                                                   KILNNAME,
                                                   KilnCarID,
                                                   KILNCARCODE,
                                                   KILNCARNAME,
                                                   KILNCARBATCHNO,
                                                   KILNCARPOSITION
                                              from Tp_Pm_ProductiondataIn
                                             where barcode = :barcode
                                               and valueflag = 1 and ModelType<>1 and ModelType<>8
                                             order by ProductionDataID desc) t
                                     where rownum <= 1";
					paras = new OracleParameter[]{
					new OracleParameter(":barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
					};
					DataSet productionData = oracleTrConn.GetSqlResultToDs(sqlString, paras);
					if (productionData == null
						|| productionData.Tables.Count == Constant.INT_IS_ZERO
						|| productionData.Tables[0].Rows.Count != Constant.INT_IS_ONE)//INT_IS_TWO
					{
						// 条码至少要有2次数据采集
						errMsg = "条码没有登窑前数据";// Messages.MSG_PM_W016;
						return errMsg;
					}
					#endregion
					#region 回滚在产数据
					// 重烧撤销装车要恢复到本烧窑车信息 modify by chenxy 2017-07-11 begin
					//                    sqlString = @"update TP_PM_InProduction
					//                                   set FlowProcedureID = :flowProcedureID,
					//                                       ProcedureModel      = :procedureModel,
					//                                       ProcedureID         = :flowProcedureID,
					//                                       ModelType           = :modelType,
					//                                       ReworkProcedureID   = :reworkProcedureID,
					//                                       UserID              = :userID,
					//                                       updateuserid = :updateuserid,
					//                                       --logoid = :logoid,
					//                                       KILNID = null,
					//                                       KILNCODE = null,
					//                                       KILNNAME = null,
					//                                       KilnCarID = null,
					//                                       KILNCARCODE = null,
					//                                       KILNCARNAME = null,
					//                                       KILNCARBATCHNO = null,
					//                                       KILNCARPOSITION = null
					//                                 where barcode = :barcode";
					sqlString = "UPDATE TP_PM_INPRODUCTION\n" +
								"   SET FLOWPROCEDUREID   = :FLOWPROCEDUREID,\n" +
								"       PROCEDUREMODEL    = :PROCEDUREMODEL,\n" +
								"       PROCEDUREID       = :PROCEDUREID,\n" +
								"       MODELTYPE         = :MODELTYPE,\n" +
								"       REWORKPROCEDUREID = :REWORKPROCEDUREID,\n" +
								"       USERID            = :USERID,\n" +
								"       UPDATEUSERID      = :UPDATEUSERID,\n" +
								"       KILNID           = :KILNID,\n" +
								"       KILNCODE         = :KILNCODE,\n" +
								"       KILNNAME         = :KILNNAME,\n" +
								"       KILNCARID        = :KILNCARID,\n" +
								"       KILNCARCODE      = :KILNCARCODE,\n" +
								"       KILNCARNAME      = :KILNCARNAME,\n" +
								"       KILNCARBATCHNO   = :KILNCARBATCHNO,\n" +
								"       KILNCARPOSITION  = :KILNCARPOSITION,\n" +
								"       PRODUCTIONDATAID = :PRODUCTIONDATAID,\n" +
								"       PROCEDURETIME   =\n" +
								"       (SELECT CREATETIME\n" +
								"          FROM TP_PM_PRODUCTIONDATAIN\n" +
								"         WHERE PRODUCTIONDATAID = :PRODUCTIONDATAID)\n" +
								" WHERE BARCODE = :BARCODE";

					object pid = productionData.Tables[0].Rows[0]["p8id"];
					if (pid == null || pid == DBNull.Value)
					{
						pid = productionData.Tables[0].Rows[0]["ProcedureID"];
					}
					paras = new OracleParameter[]{
						new OracleParameter(":flowProcedureID",OracleDbType.Int32,
							productionData.Tables[0].Rows[0]["ProcedureID"],ParameterDirection.Input),//1--->0
                        new OracleParameter(":ProcedureID",OracleDbType.Int32,
							pid,ParameterDirection.Input),
						new OracleParameter(":procedureModel",OracleDbType.Int32,
							productionData.Tables[0].Rows[0]["procedureModel"],ParameterDirection.Input),
						new OracleParameter(":modelType",OracleDbType.Int32,
							productionData.Tables[0].Rows[0]["modelType"],ParameterDirection.Input),
						new OracleParameter(":reworkProcedureID",OracleDbType.Int32,
							productionData.Tables[0].Rows[0]["reworkProcedureID"],ParameterDirection.Input),
						new OracleParameter(":userID",OracleDbType.Int32,
							productionData.Tables[0].Rows[0]["userID"],ParameterDirection.Input),
						new OracleParameter(":KILNID",OracleDbType.Int32,
							productionData.Tables[0].Rows[0]["KILNID"],ParameterDirection.Input),
						new OracleParameter(":KILNCODE",OracleDbType.NVarchar2,
							productionData.Tables[0].Rows[0]["KILNCODE"],ParameterDirection.Input),
						new OracleParameter(":KILNNAME",OracleDbType.NVarchar2,
							productionData.Tables[0].Rows[0]["KILNNAME"],ParameterDirection.Input),
						new OracleParameter(":KilnCarID",OracleDbType.Int32,
							productionData.Tables[0].Rows[0]["KilnCarID"],ParameterDirection.Input),
						new OracleParameter(":KILNCARCODE",OracleDbType.NVarchar2,
							productionData.Tables[0].Rows[0]["KILNCARCODE"],ParameterDirection.Input),
						new OracleParameter(":KILNCARNAME",OracleDbType.NVarchar2,
							productionData.Tables[0].Rows[0]["KILNCARNAME"],ParameterDirection.Input),
						new OracleParameter(":KILNCARBATCHNO",OracleDbType.NVarchar2,
							productionData.Tables[0].Rows[0]["KILNCARBATCHNO"],ParameterDirection.Input),
						new OracleParameter(":KILNCARPOSITION",OracleDbType.Int32,
							productionData.Tables[0].Rows[0]["KILNCARPOSITION"],ParameterDirection.Input),

						new OracleParameter(":updateuserid",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
						new OracleParameter(":barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
						 new OracleParameter(":ProductionDataID",OracleDbType.Int32,
							productionData.Tables[0].Rows[0]["ProductionDataID"],ParameterDirection.Input)
                         //new OracleParameter(":logoid",OracleDbType.Int32, 
                         //   productionData.Tables[0].Rows[0]["logoid"].ToString()==""?null:productionData.Tables[0].Rows[0]["logoid"],ParameterDirection.Input),
                    };
					// 重烧撤销装车要恢复到本烧窑车信息 modify by chenxy 2017-07-11 end
					int rutenRows = oracleTrConn.ExecuteNonQuery(sqlString, paras);
					if (rutenRows == Constant.INT_IS_ZERO)
					{
						// 保存失败
						errMsg = string.Format(Messages.MSG_CMN_W001, "条码", "保存");
						return errMsg;
					}
					#endregion
					#region 删除生产者和最后一条生产数据
					//sqlString = "delete TP_PM_Producer where ProductionDataID=:productionDataID";
					//paras = new OracleParameter[]{
					//    new OracleParameter(":productionDataID",OracleDbType.Int32, 
					//        productionData.Tables[0].Rows[0]["productionDataID"],ParameterDirection.Input),
					//};
					//rutenRows = oracleTrConn.ExecuteNonQuery(sqlString, paras);
					//if (rutenRows == Constant.INT_IS_ZERO)
					//{
					//    // 保存失败
					//    errMsg = string.Format(Messages.MSG_CMN_W001, "条码", "保存");
					//    return errMsg;
					//}
					//modify 2015/05/13 wangx GoodsLevelTypeID=11 撤销装车
					sqlString = "select GoodsLevelID,GoodsLevelName,GoodsLevelTypeID from TP_MST_GoodsLevel where GoodsLevelTypeID=11 and AccountID=" + sUserInfo.AccountID + " and ValueFlag=1";
					DataSet dsGoodsLevel = oracleTrConn.GetSqlResultToDs(sqlString, null);
					int? GoodsLevelID = null;
					if (dsGoodsLevel != null && dsGoodsLevel.Tables[0].Rows.Count > 0)
					{
						GoodsLevelID = Convert.ToInt32(dsGoodsLevel.Tables[0].Rows[0]["GoodsLevelID"]);
					}

					//modify end
					sqlString = "update Tp_Pm_ProductiondataIn set valueflag=0 ,updateuserid=" + sUserInfo.UserID; //wangxin 20150406
					if (GoodsLevelID != null)
					{
						sqlString += ",GoodsLevelID=" + GoodsLevelID;
						sqlString += ",GoodsLevelTypeID=11";
					}
					//sqlString += " where ProductionDataID=:productionDataID";
					//新添加的 begin
					paras = new OracleParameter[]{
						new OracleParameter(":productionDataID",OracleDbType.Int32,
							Convert.ToInt32(productionData.Tables[0].Rows[0]["productionDataID"]),ParameterDirection.Input),
						new OracleParameter(":barcode",OracleDbType.Varchar2,
							barcode,ParameterDirection.Input),
					};
					//新添加的 end
					// 干补 数据不能撤销
					//sqlString += " where ProductionDataID>:productionDataID and barcode=:barcode";
					sqlString += " where ProductionDataID>:productionDataID and barcode=:barcode and ModelType=1 and valueflag='1'";
					rutenRows = oracleTrConn.ExecuteNonQuery(sqlString, paras);
					if (rutenRows == Constant.INT_IS_ZERO)
					{
						// 保存失败
						errMsg = string.Format(Messages.MSG_CMN_W001, "条码", "保存");
						return errMsg;
					}
					#endregion
					#region 删除窑车产品
					sqlString = "SELECT KILNCARID, kilncarbatchno from TP_PM_KilnCarGoods where BarCode=:barCode";
					paras = new OracleParameter[]{
						new OracleParameter(":barCode",OracleDbType.Varchar2,
							barcode,ParameterDirection.Input),
					};
					DataTable kilnCar = oracleTrConn.GetSqlResultToDt(sqlString, paras);
					if (kilnCar == null || kilnCar.Rows.Count == 0)
					{
						errMsg = string.Format(Messages.MSG_CMN_W001, "条码", "保存");
						return errMsg;
					}

					sqlString = "delete TP_PM_KilnCarGoods where BarCode=:barCode";
					paras = new OracleParameter[]{
						new OracleParameter(":barCode",OracleDbType.Varchar2,
							barcode,ParameterDirection.Input),
					};
					rutenRows = oracleTrConn.ExecuteNonQuery(sqlString, paras);
					if (rutenRows == Constant.INT_IS_ZERO)
					{
						// 保存失败
						errMsg = string.Format(Messages.MSG_CMN_W001, "条码", "保存");
						return errMsg;
					}
					#endregion
					#region 撤销窑车上最后一个产品
					// 撤销窑车上最后一个产品后，删除窑车装车记录 add by chenxy 2017-06-06 begin
					sqlString = "select count(*) from TP_PM_KilnCarGoods where KILNCARID = :KILNCARID";
					paras = new OracleParameter[]{
						new OracleParameter(":KILNCARID",OracleDbType.Int32,
							kilnCar.Rows[0]["KILNCARID"],ParameterDirection.Input),
					};
					string goodsCount = oracleTrConn.GetSqlResultToStr(sqlString, paras);
					if (string.IsNullOrWhiteSpace(goodsCount) || "0" == goodsCount)
					{
						// 撤销窑车上最后一个产品后，删除窑车装车记录（窑车生产数据）
						sqlString = "UPDATE tp_pm_kilncardata kcd SET kcd.valueflag = '0' WHERE kcd.modeltype = 1 and kcd.kilncarbatchno = '" + kilnCar.Rows[0]["kilncarbatchno"] + "'";
						rutenRows = oracleTrConn.ExecuteNonQuery(sqlString, paras);

						// 最后一条窑车生产数据
						sqlString = "select max(kilncardataid) kilncardataid from tp_pm_kilncardata where modeltype = 4 and valueflag = '1' and KILNCARID = :KILNCARID";
						paras = new OracleParameter[]{
							new OracleParameter(":KILNCARID",OracleDbType.Int32,
								kilnCar.Rows[0]["KILNCARID"],ParameterDirection.Input),
						};
						string kilncardataid = oracleTrConn.GetSqlResultToStr(sqlString, paras);
						// 回退窑车状态
						if (string.IsNullOrWhiteSpace(kilncardataid))
						{
							// 第一次装车被撤销
							sqlString = "delete from TP_PM_Kilncarstatus where KILNCARID = :KILNCARID";
							paras = new OracleParameter[]{
								new OracleParameter(":KILNCARID",OracleDbType.Int32,
									kilnCar.Rows[0]["KILNCARID"],ParameterDirection.Input),
							};
							rutenRows = oracleTrConn.ExecuteNonQuery(sqlString, paras);
						}
						else
						{
							sqlString = "UPDATE TP_PM_Kilncarstatus kcs\n" +
							"   SET (kcs.productionlineid,\n" +
							"        kcs.procedureid,\n" +
							"        kcs.procedurecode,\n" +
							"        kcs.procedurename,\n" +
							"        kcs.proceduremodel,\n" +
							"        kcs.modeltype,\n" +
							"        kcs.piecetype,\n" +
							"        kcs.kilncarstatus,\n" +
							"        kcs.loadingtime,\n" +
							"        kcs.intokilntime,\n" +
							"        kcs.outkilntime,\n" +
							"        kcs.unloadingtime,\n" +
							"        kcs.kilncarbatchno) =\n" +
							"       (SELECT kcd.productionlineid\n" +
							"              ,kcd.procedureid\n" +
							"              ,kcd.procedurecode\n" +
							"              ,kcd.procedurename\n" +
							"              ,kcd.proceduremodel\n" +
							"              ,kcd.modeltype\n" +
							"              ,kcd.piecetype\n" +
							"              ,kcd.kilncarstatus\n" +
							"              ,kcd.loadingtime\n" +
							"              ,kcd.intokilntime\n" +
							"              ,kcd.outkilntime\n" +
							"              ,kcd.unloadingtime\n" +
							"              ,kcd.kilncarbatchno\n" +
							"          FROM TP_PM_KILNCARDATA kcd\n" +
							"         WHERE kcd.kilncardataid = :kilncardataid)\n" +
							" WHERE kcs.kilncarid = :kilncarid";
							paras = new OracleParameter[]{
								new OracleParameter(":kilncarid",OracleDbType.Int32,
									kilnCar.Rows[0]["kilncarid"],ParameterDirection.Input),
								new OracleParameter(":kilncardataid",OracleDbType.Int32,
									kilncardataid,ParameterDirection.Input),
							};
							rutenRows = oracleTrConn.ExecuteNonQuery(sqlString, paras);
						}
					}
					// 撤销窑车上最后一个产品后，删除窑车装车记录 add by chenxy 2017-06-06 end
					#endregion
				}
				// 没有错误 提交事务
				if (string.IsNullOrEmpty(errMsg))
				{
					oracleTrConn.Commit();
				}
			}
			catch (Exception ex)
			{
				oracleTrConn.Rollback();
				throw ex;
			}
			finally
			{
				// 释放资源
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return errMsg;
		}

		/// <summary>
		/// 保存半检测信息
		/// </summary>
		/// <param name="semiTestEntitys">半检实体类</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>string</returns>
		public static string AddSemiTest(SemiTestEntity[] semiTestEntitys, SUserInfo sUserInfo)
		{
			string errMsg = "";
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				foreach (SemiTestEntity semiTest in semiTestEntitys)
				{
					#region 添加半检数据
					// 查询新插入的半检数据ID
					string sql = "select SEQ_PM_SemiTest_SemiTestID.nextval from dual";
					string idStr = oracleTrConn.GetSqlResultToStr(sql);
					semiTest.SemiTestID = Convert.ToInt32(idStr);
					errMsg = AddSemiTestInfo(oracleTrConn, semiTest, sUserInfo);

					if (!string.IsNullOrEmpty(errMsg))
					{
						return errMsg;
					}

					//// 查询新插入的半检数据ID
					//string sql = "select SEQ_PM_SemiTest_SemiTestID.Currval from dual";
					//string idStr = oracleTrConn.GetSqlResultToStr(sql);

					errMsg = AddSemiTestStaff(oracleTrConn, Convert.ToInt32(idStr), semiTest.TestUserID);

					if (!string.IsNullOrEmpty(errMsg))
					{
						return errMsg;
					}

					// 存在半检明细
					if (semiTest.SemiTestDetails != null)
					{
						foreach (SemiTestDetailEntity semiTestDetail in semiTest.SemiTestDetails)
						{
							errMsg = AddSemiTestDetails(oracleTrConn, semiTestDetail, sUserInfo, Convert.ToInt32(idStr), semiTest.TestDate);

							if (!string.IsNullOrEmpty(errMsg))
							{
								return errMsg;
							}
						}
					}

					#endregion
				}
				// 没有错误 提交事务
				if (string.IsNullOrEmpty(errMsg))
				{
					oracleTrConn.Commit();
				}
			}
			catch (Exception ex)
			{
				oracleTrConn.Rollback();
				throw ex;
			}
			finally
			{
				// 释放资源
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return errMsg;
		}

		/// <summary>
		/// 添加半检数据
		/// </summary>
		/// <param name="oracleTrConn">数据连接事务</param>
		/// <param name="semiTestEntity">半检实体类</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>string</returns>
		private static string AddSemiTestInfo(IDBTransaction oracleTrConn, SemiTestEntity semiTestEntity, SUserInfo sUserInfo)
		{
			string errMsg = "";
			#region SQL

			string sql = "insert into TP_PM_SemiTest"
						 + " (SemiTestID,"
						 + " TestUserID,"
						 + " TestDate,"
						 + " Remarks,"
						 + " AuditStatus,"
						 + " Auditor,"
						 + " AuditlDate,"
						 + " AccountID,"
						 + " ValueFlag,"
						 + " CreateUserID,"
						 + " UpdateUserID,"
						 + " SemiTestType"
						 + ")"
						 + " values"
						 + " (:SemiTestID,"
						 + " :TestUserID,"
						 + " :TestDate,"
						 + " :Remarks,"
						 + " :AuditStatus,"
						 + " :Auditor,"
						 + " :AuditlDate,"
						 + " :AccountID,"
						 + " :ValueFlag,"
						 + " :CreateUserID,"
						 + " :UpdateUserID,"
						 + " :SemiTestType"
						 + ")";
			#endregion
			#region OracleParameter

			OracleParameter[] oracleParameters = new OracleParameter[] {
				 new OracleParameter(":SemiTestID",OracleDbType.Int32, semiTestEntity.SemiTestID,ParameterDirection.Input),
				  new OracleParameter(":TestUserID",OracleDbType.Int32, semiTestEntity.TestUserID,ParameterDirection.Input),
				  new OracleParameter(":TestDate",OracleDbType.Date, semiTestEntity.TestDate,ParameterDirection.Input),
				  new OracleParameter(":Remarks",OracleDbType.Varchar2, semiTestEntity.Remarks,ParameterDirection.Input),
				  new OracleParameter(":AuditStatus",OracleDbType.Int32, semiTestEntity.AuditStatus,ParameterDirection.Input),
				  new OracleParameter(":Auditor",OracleDbType.Int32, semiTestEntity.Auditor,ParameterDirection.Input),
				  new OracleParameter(":AuditlDate",OracleDbType.Date, semiTestEntity.AuditlDate,ParameterDirection.Input),
				  new OracleParameter(":AccountID",OracleDbType.Int32, sUserInfo.AccountID,ParameterDirection.Input),
				  new OracleParameter(":ValueFlag",OracleDbType.Int32, semiTestEntity.ValueFlag,ParameterDirection.Input),
				  new OracleParameter(":CreateUserID",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
				  new OracleParameter(":UpdateUserID",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
				  new OracleParameter(":SemiTestType",OracleDbType.Int32, semiTestEntity.SemiTestType,ParameterDirection.Input),
				  };

			#endregion
			int result = oracleTrConn.ExecuteNonQuery(sql, oracleParameters);
			// 保存失败
			if (result != Constant.INT_IS_ONE)
			{
				return string.Format(Messages.MSG_CMN_W001, "半检", "保存");
			}
			return errMsg;
		}

		/// <summary>
		/// 保存半检员工
		/// </summary>
		/// <param name="oracleTrConn">数据连接事务</param>
		/// <param name="SemiTestID">半检数据ID</param>
		/// <param name="UserID">工号ID</param>
		/// <returns>string</returns>
		private static string AddSemiTestStaff(IDBTransaction oracleTrConn, int SemiTestID, int UserID)
		{
			string errMsg = "";
			#region SQL

			string sql = @"insert into TP_PM_SemiTestStaff(SemiTestID,StaffID)
                         select :SemiTestID ,StaffID from TP_MST_UserStaff where UserID=:UserID";

			#endregion
			#region OracleParameter

			OracleParameter[] oracleParameters = new OracleParameter[] {
				  new OracleParameter(":SemiTestID",OracleDbType.Int32, SemiTestID,ParameterDirection.Input),
				  new OracleParameter(":UserID",OracleDbType.Int32, UserID,ParameterDirection.Input),
				  };

			#endregion
			int resultCount = oracleTrConn.ExecuteNonQuery(sql, oracleParameters);
			// 失败
			if (resultCount == Constant.INT_IS_ZERO)
			{
				return string.Format(Messages.MSG_CMN_W001, "半检员工", "保存");
			}
			return errMsg;
		}

		/// <summary>
		/// 添加半检数据明细
		/// </summary>
		/// <param name="oracleTrConn">数据连接事务</param>
		/// <param name="semiTestDetail">半检明细实体类</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="SemiTestID">半检ID</param>
		/// <param name="SemiTestDate">检验日期</param>
		/// <returns>string</returns>
		private static string AddSemiTestDetails(IDBTransaction oracleTrConn, SemiTestDetailEntity semiTestDetail, SUserInfo sUserInfo, int SemiTestID, DateTime SemiTestDate)
		{
			string errMsg = "";
			#region SQL
			// 查询新插入的半检数据ID
			string sqlView = "select SEQ_PM_SemiTestDetail_ID.nextval from dual";
			string idStr = oracleTrConn.GetSqlResultToStr(sqlView);

			string sql = "insert into TP_PM_SemiTestDetail"
					   + " (SemiTestDetailID,"
					   + " SemiTestID,"
					   + " SemiTestDate,"
					   + " GroutingUserID,"
					   + " GoodsID,"
					   + " GoodsCode,"
					   + " GoodsName,"
					   + " TestNum,"
					   + " ScrapNum,"
					   + " ScrapReason,"
					   + " Feedback,"
					   + " AccountID,"
					   + " ValueFlag,"
					   + " CreateUserID,"
					   + " UpdateUserID"
					   + ")"
					   + " values"
					   + " (:SemiTestDetailID,"
					   + " :SemiTestID,"
					   + " :SemiTestDate,"
					   + " :GroutingUserID,"
					   + " :GoodsID,"
					   + " :GoodsCode,"
					   + " :GoodsName,"
					   + " :TestNum,"
					   + " :ScrapNum,"
					   + " :ScrapReason,"
					   + " :Feedback,"
					   + " :AccountID,"
					   + " 1,"
					   + " :CreateUserID,"
					   + " :UpdateUserID"
					   + ")";

			#endregion
			#region OracleParameter

			OracleParameter[] oracleParameters = new OracleParameter[] {
				  new OracleParameter(":SemiTestDetailID",OracleDbType.Int32, Convert.ToInt32(idStr),ParameterDirection.Input),
				  new OracleParameter(":SemiTestID",OracleDbType.Int32, SemiTestID,ParameterDirection.Input),
				  new OracleParameter(":SemiTestDate",OracleDbType.Date, SemiTestDate,ParameterDirection.Input),
				  new OracleParameter(":GroutingUserID",OracleDbType.Int32, semiTestDetail.GroutingUserID,ParameterDirection.Input),
				  new OracleParameter(":GoodsID",OracleDbType.Int32, semiTestDetail.GoodsID,ParameterDirection.Input),
				  new OracleParameter(":GoodsCode",OracleDbType.Varchar2, semiTestDetail.GoodsCode,ParameterDirection.Input),
				  new OracleParameter(":GoodsName",OracleDbType.Varchar2, semiTestDetail.GoodsName,ParameterDirection.Input),
				  new OracleParameter(":TestNum",OracleDbType.Decimal, semiTestDetail.TestNum,ParameterDirection.Input),
				  new OracleParameter(":ScrapNum",OracleDbType.Decimal, semiTestDetail.ScrapNum,ParameterDirection.Input),
				  new OracleParameter(":AccountID",OracleDbType.Int32, sUserInfo.AccountID,ParameterDirection.Input),
				  new OracleParameter(":ScrapReason",OracleDbType.Varchar2, semiTestDetail.ScrapReason,ParameterDirection.Input),
				  new OracleParameter(":Feedback",OracleDbType.Varchar2, semiTestDetail.Feedback,ParameterDirection.Input),
				  new OracleParameter(":CreateUserID",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
				  new OracleParameter(":UpdateUserID",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
				  };

			#endregion
			int result = oracleTrConn.ExecuteNonQuery(sql, oracleParameters);
			// 保存失败
			if (result != Constant.INT_IS_ONE)
			{
				return string.Format(Messages.MSG_CMN_W001, "半检明细", "保存");
			}

			errMsg = AddSemiTestGStaff(oracleTrConn, Convert.ToInt32(idStr), Convert.ToInt32(semiTestDetail.GroutingUserID));
			if (!string.IsNullOrEmpty(errMsg))
			{
				return errMsg;
			}
			// 存在半检明细
			if (semiTestDetail.SemiTestDefects != null)
			{
				foreach (SemiTestDefectEntity semiTestDefect in semiTestDetail.SemiTestDefects)
				{
					errMsg = AddSemiTestDefect(oracleTrConn, semiTestDefect, sUserInfo, SemiTestID, Convert.ToInt32(idStr), SemiTestDate);

					if (!string.IsNullOrEmpty(errMsg))
					{
						return errMsg;
					}
				}
			}
			return null;
		}

		/// <summary>
		/// 保存半检成型员工
		/// </summary>
		/// <param name="oracleTrConn">数据连接事务</param>
		/// <param name="SemiTestID">半检ID</param>
		/// <param name="UserID">成型工号</param>
		/// <returns>string</returns>
		private static string AddSemiTestGStaff(IDBTransaction oracleTrConn, int SemiTestDetailID, int UserID)
		{
			string errMsg = "";
			#region SQL

			string sql = @"insert into TP_PM_SemiTestGStaff(SemiTestDetailID,StaffID)
                         select :SemiTestDetailID ,StaffID from TP_MST_UserStaff where UserID=:UserID";

			#endregion
			#region OracleParameter

			OracleParameter[] oracleParameters = new OracleParameter[] {
				  new OracleParameter(":SemiTestDetailID",OracleDbType.Int32, SemiTestDetailID,ParameterDirection.Input),
				  new OracleParameter(":UserID",OracleDbType.Int32, UserID,ParameterDirection.Input),
				  };

			#endregion
			int resultCount = oracleTrConn.ExecuteNonQuery(sql, oracleParameters);
			// 失败
			if (resultCount == Constant.INT_IS_ZERO)
			{
				return string.Format(Messages.MSG_CMN_W001, "半检成型员工", "保存");
			}
			return errMsg;
		}

		/// <summary>
		/// 添加半检缺陷
		/// </summary>
		/// <param name="oracleTrConn">数据连接事务</param>
		/// <param name="semiTestDefect">半检缺陷</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="SemiTestID"><半检ID/param>
		/// <param name="SemiTestDetailID">半检明细ID</param>
		/// <param name="SemiTestDate">检验日期</param>
		/// <returns>string</returns>
		private static string AddSemiTestDefect(IDBTransaction oracleTrConn, SemiTestDefectEntity semiTestDefect, SUserInfo sUserInfo, int SemiTestID, int SemiTestDetailID, DateTime SemiTestDate)
		{
			string errMsg = "";
			#region SQL

			string sql = "insert into TP_PM_SemiTestDefect"
					   + " ("
					   + " SemiTestDetailID,"
					   + " SemiTestID,"
					   + " SemiTestDate,"
					   + " DefectID,"
					   + " DefectPositionID,"
					   + " DefectNum,"
					   + " AccountID,"
					   + " ValueFlag,"
					   + " CreateUserID,"
					   + " UpdateUserID"
					   + ")"
					   + " values"
					   + " ("
					   + " :SemiTestDetailID,"
					   + " :SemiTestID,"
					   + " :SemiTestDate,"
					   + " :DefectID,"
					   + " :DefectPositionID,"
					   + " :DefectNum,"
					   + " :AccountID,"
					   + " 1,"
					   + " :CreateUserID,"
					   + " :UpdateUserID"
					   + ")";

			#endregion
			#region OracleParameter

			OracleParameter[] oracleParameters = new OracleParameter[] {
				  new OracleParameter(":SemiTestDetailID",OracleDbType.Int32, SemiTestDetailID,ParameterDirection.Input),
				  new OracleParameter(":SemiTestID",OracleDbType.Int32, SemiTestID,ParameterDirection.Input),
				  new OracleParameter(":SemiTestDate",OracleDbType.Date, SemiTestDate,ParameterDirection.Input),
				  new OracleParameter(":DefectID",OracleDbType.Int32, semiTestDefect.DefectID,ParameterDirection.Input),
				  new OracleParameter(":DefectPositionID",OracleDbType.Int32, semiTestDefect.DefectPositionID,ParameterDirection.Input),
				  new OracleParameter(":DefectNum",OracleDbType.Int32, semiTestDefect.DefectNum,ParameterDirection.Input),
				  new OracleParameter(":AccountID",OracleDbType.Int32, sUserInfo.AccountID,ParameterDirection.Input),
				  new OracleParameter(":CreateUserID",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
				  new OracleParameter(":UpdateUserID",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
				  };

			#endregion
			int result = oracleTrConn.ExecuteNonQuery(sql, oracleParameters);
			// 保存失败
			if (result != Constant.INT_IS_ONE)
			{
				return string.Format(Messages.MSG_CMN_W001, "半检缺陷", "保存");
			}
			return errMsg;
		}

		/// <summary>
		/// 编辑后禁用半检数据
		/// </summary>
		/// <param name="semiTestID">半检数据ID</param>
		/// <returns>int</returns>
		public static int DeleteSemiTestDataByID(int semiTestID)
		{
			int deleteRow = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				string sqlString1 = @" update TP_PM_SemiTestDefect set ValueFlag=0 where SemiTestID=:SemiTestID";
				string sqlString2 = @" update TP_PM_SemiTestDetail set ValueFlag=0 where SemiTestID=:SemiTestID";
				string sqlString3 = @" update TP_PM_SemiTest set ValueFlag=0 where SemiTestID=:SemiTestID";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":SemiTestID",OracleDbType.Int32, semiTestID,ParameterDirection.Input),
				};
				deleteRow += oracleTrConn.ExecuteNonQuery(sqlString1, paras);
				deleteRow += oracleTrConn.ExecuteNonQuery(sqlString2, paras);
				deleteRow += oracleTrConn.ExecuteNonQuery(sqlString3, paras);
				// 没有错误 提交事务
				if (deleteRow > 0)
				{
					oracleTrConn.Commit();
				}
				else
				{
					oracleTrConn.Rollback();
				}
			}
			catch (Exception ex)
			{
				oracleTrConn.Rollback();
				throw ex;
			}
			finally
			{
				// 释放资源
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return deleteRow;
		}

		/// <summary>
		/// 验证时间戳
		/// </summary>
		/// <param name="semiTestID">半检ID</param>
		/// <param name="opTimeStamp">时间戳</param>
		/// <returns>int</returns>
		public static int ValidateOPTimeStamp(int semiTestID, DateTime opTimeStamp)
		{
			int Row = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				string sql = "SELECT OPTimeStamp FROM TP_PM_SemiTest"
							+ " WHERE SemiTestID =:SemiTestID and OPTimeStamp = :OPTimeStamp";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":SemiTestID",OracleDbType.Int32, semiTestID,ParameterDirection.Input),
					new OracleParameter(":OPTimeStamp", OracleDbType.TimeStamp,  opTimeStamp, ParameterDirection.Input),
				};
				DataSet returnDataset = oracleTrConn.GetSqlResultToDs(sql, paras);
				if (returnDataset != null
					&& returnDataset.Tables[0].Rows.Count == 0)
				{
					oracleTrConn.Commit();
					oracleTrConn.Disconnect();
					return -1;
				}
				oracleTrConn.Commit();
			}
			catch (Exception ex)
			{
				oracleTrConn.Rollback();
				throw ex;
			}
			finally
			{
				// 释放资源
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return Row;
		}

		/// <summary>
		/// 更新审核状态
		/// </summary>
		/// <param name="semiTestID">半检ID</param>
		/// <param name="auditStatus">审核状态</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		public static int UpdateSemiTestByID(int semiTestID, int auditStatus, SUserInfo sUserInfo)
		{
			int UpdateRow = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				string sql = "update TP_PM_SemiTest set AuditStatus=:AuditStatus,Auditor=:Auditor,AuditlDate=sysdate "
						   + " WHERE SemiTestID =:SemiTestID";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":AuditStatus",OracleDbType.Int32, auditStatus,ParameterDirection.Input),
					new OracleParameter(":semiTestID", OracleDbType.Int32,  semiTestID, ParameterDirection.Input),
					new OracleParameter(":Auditor", OracleDbType.Int32,  sUserInfo.UserID, ParameterDirection.Input),
				};
				UpdateRow = oracleTrConn.ExecuteNonQuery(sql, paras);
				if (UpdateRow > 0)
				{
					oracleTrConn.Commit();
				}
				else
				{
					oracleTrConn.Rollback();
				}
			}
			catch (Exception ex)
			{
				oracleTrConn.Rollback();
				throw ex;
			}
			finally
			{
				// 释放资源
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return UpdateRow;
		}

		#region  撤销产品报损

		/// <summary>
		/// 撤销产品报损 
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <param name="sUserInfo"></param>
		/// <returns></returns>
		public static ServiceResultEntity AddCancelScrapProduction(string barcode, SUserInfo sUserInfo)
		{
			ServiceResultEntity entity = new ServiceResultEntity();
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				DateTime? auditDate = null;
				int ScrapProductID = 0;
				//string sql = "select ScrapProductID,AuditDate from TP_PM_ScrapProduct where barcode=:barcode and valueflag=1 and AuditStatus=1 and goodsleveltypeid=8";
				string sql = @"select ScrapProductID,AuditDate,recyclingflag from TP_PM_ScrapProduct 
                                where barcode=:barcode and valueflag=1 and AuditStatus=1 
                                      and goodsleveltypeid=8 and 
                                createtime=(select max(createtime) from TP_PM_ScrapProduct  where barcode=:barcode and valueflag=1 and AuditStatus=1   and goodsleveltypeid=8)";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
				};
				DataSet ds = oracleTrConn.GetSqlResultToDs(sql, paras);
				if (ds != null && ds.Tables[0].Rows.Count == 0)
				{
					//此产品没有损坯，不能撤销
					returnRows = -1;
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					entity.Result = returnRows;
					return entity;
				}
				else
				{
					if (Convert.ToInt32(ds.Tables[0].Rows[0]["recyclingflag"]) > 0)
					{
						//已经回收不允许撤销
						returnRows = -200;
						oracleTrConn.Rollback();
						oracleTrConn.Disconnect();
						entity.Result = returnRows;
						entity.Message = "此产品已经回收，不能撤销";
						return entity;
					}

					ScrapProductID = Convert.ToInt32(ds.Tables[0].Rows[0]["ScrapProductID"]);
					auditDate = Convert.ToDateTime(ds.Tables[0].Rows[0]["auditDate"]);
				}

				#region  是否启用损坯撤销限制天数
				if (auditDate != null)
				{
					sql = "select settingvalue from TP_MST_SystemSetting where settingcode=:settingcode and accountid=:accountid";
					paras = new OracleParameter[] {
					new OracleParameter(":settingcode",OracleDbType.Varchar2,
						Constant.SettingType.S_PM_006.ToString(),ParameterDirection.Input),
						 new OracleParameter(":accountid",OracleDbType.Int32,
						sUserInfo.AccountID,ParameterDirection.Input)
				};
					ds = oracleTrConn.GetSqlResultToDs(sql, paras);
					if (ds != null && ds.Tables[0].Rows.Count > 0)
					{
						if (Convert.ToInt32(ds.Tables[0].Rows[0]["settingvalue"]) > 0)
						{
							// 开启了限制
							ServiceResultEntity resultEntity = PMModuleLogic.BarcodeAllowCancel(Convert.ToDateTime(auditDate),
								Convert.ToInt32(ds.Tables[0].Rows[0]["settingvalue"]), Constant.SettingType.S_PM_006.ToString(), sUserInfo);
							if (Convert.ToInt32(resultEntity.Result) < 0)
							{
								//超过损坯撤销限制天数
								returnRows = -200;
								oracleTrConn.Rollback();
								oracleTrConn.Disconnect();
								entity.Result = returnRows;
								entity.Message = resultEntity.Message;
								return entity;
							}
						}
					}
				}
				#endregion

				//第二步,回收站中数据回到在产中。 
				string sqlInsInProdString = @"insert into TP_PM_InProduction(BARCODE, PRODUCTIONLINEID, PRODUCTIONLINECODE, PRODUCTIONLINENAME, 
                                                    PROCEDUREMODEL, MODELTYPE, REWORKPROCEDUREID, 
                                                    ISPUBLICBODY, GOODSID, GOODSCODE, GOODSNAME, 
                                                    USERID, GROUTINGDAILYID, GROUTINGDAILYDETAILID, GROUTINGDATE, 
                                                    GROUTINGLINEID, GROUTINGLINECODE, GROUTINGLINENAME, GMOULDTYPEID, 
                                                    CANMANYTIMES, GROUTINGLINEDETAILID, GROUTINGMOULDCODE, MOULDCODE, 
                                                    REMARKS, ACCOUNTID, VALUEFLAG, CREATETIME, 
                                                    CREATEUSERID, UPDATETIME, UPDATEUSERID,
                                                    ISREFIRE, GOODSLEVELID, GOODSLEVELTYPEID, DEFECTFLAG, 
                                                     GROUTINGUSERID, GROUTINGUSERCODE, GROUTINGNUM, 
                                                    KILNID, KILNCODE, KILNNAME, KILNCARID, 
                                                    KILNCARCODE, KILNCARNAME, KILNCARBATCHNO, KILNCARPOSITION,SpecialRepairFlag,FlowProcedureID
                                                    ,FlowProcedureTime,ProcedureID,ProcedureTime,ProductionDataID,logoid,IsReworkFlag,SemiCheckID
                                            ) 
                                           select BARCODE, PRODUCTIONLINEID, PRODUCTIONLINECODE, PRODUCTIONLINENAME, 
                                                PROCEDUREMODEL, MODELTYPE, REWORKPROCEDUREID, 
                                                ISPUBLICBODY, GOODSID, GOODSCODE, GOODSNAME, 
                                                USERID, GROUTINGDAILYID, GROUTINGDAILYDETAILID, GROUTINGDATE, 
                                                GROUTINGLINEID, GROUTINGLINECODE, GROUTINGLINENAME, GMOULDTYPEID, 
                                                CANMANYTIMES, GROUTINGLINEDETAILID, GROUTINGMOULDCODE, MOULDCODE, 
                                                REMARKS, ACCOUNTID, VALUEFLAG, CREATETIME, 
                                                CREATEUSERID, UPDATETIME,  :UpdateUserID,
                                                ISREFIRE, null, null, DEFECTFLAG, 
                                                 GROUTINGUSERID, GROUTINGUSERCODE, GROUTINGNUM, 
                                                KILNID, KILNCODE, KILNNAME, KILNCARID, 
                                                KILNCARCODE, KILNCARNAME, KILNCARBATCHNO, KILNCARPOSITION,SpecialRepairFlag,FlowProcedureID ,
                                                FlowProcedureTime,ProcedureID,sysdate,ProductionDataID,logoid,IsReworkFlag,SemiCheckID
                                                from TP_PM_InProductionTrash where barcode=:barcode ";
				OracleParameter[] InProductparas = new OracleParameter[]{
					  new OracleParameter(":UpdateUserID",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
						new OracleParameter(":barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
					};

				returnRows += oracleTrConn.ExecuteNonQuery(sqlInsInProdString, InProductparas);

				//第三步,删除回收站中的条码
				string sqlDelInProductTrashString = "delete from TP_PM_InProductionTrash where barcode=:barcode ";
				OracleParameter[] TrashProductparas = new OracleParameter[]{
						new OracleParameter(":barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input)
					};
				returnRows += oracleTrConn.ExecuteNonQuery(sqlDelInProductTrashString, TrashProductparas);

				//第四步,停用对应报损产品
				string sqlString = "update  TP_PM_ScrapProduct set valueflag=0 where ScrapProductid=:ScrapProductid ";
				OracleParameter[] parasScrapProduct = new OracleParameter[]{
						new OracleParameter(":ScrapProductid",OracleDbType.Int32,ScrapProductID,ParameterDirection.Input)
					};
				returnRows += oracleTrConn.ExecuteNonQuery(sqlString, parasScrapProduct);

				//第五步，回添加生产数据 modify wangx 2015/07/20  新添加的代码

				sql = "select 1 from tp_pm_productiondatain where barcode=:barcode and valueflag=1";
				OracleParameter[] Paras = new OracleParameter[] {
					new OracleParameter(":barcode",OracleDbType.Varchar2,
						barcode,ParameterDirection.Input)
				};
				ds = oracleTrConn.GetSqlResultToDs(sql, Paras);
				if (ds.Tables[0].Rows.Count == 0)
				{
					// 2 生产数据恢复到在产生产数据
					sql = @"insert into tp_pm_productiondatain
                       (
                            ProductionDataID,
                            BarCode,
                            CentralizedBatchNo,
                            ProductionLineID,
                            ProductionLineCode,
                            ProductionLineName,
                            ProcedureID,
                            ProcedureCode,
                            ProcedureName,
                            ProcedureModel,
                            ModelType,
                            PieceType,
                            IsReworked,
                            NodeType,
                            IsPublicBody,
                            IsReFire,
                            GoodsLevelID,
                            GoodsLevelTypeID,
                            SpecialRepairFlag,
                            OrganizationID,
                            GoodsID,
                            GoodsCode,
                            GoodsName,
                            UserID,
                            UserCode,
                            UserName,
                            ClassesSettingID,
                            KilnID,
                            KilnCode,
                            KilnName,
                            KilnCarID,
                            KilnCarCode,
                            KilnCarName,
                            KilnCarBatchNo,
                            KilnCarPosition,
                            ReworkProcedureID,
                            ReworkProcedureCode,
                            ReworkProcedureName,
                            GroutingDailyID,
                            GroutingDailyDetailID,
                            GroutingLineID,
                            GroutingLineCode,
                            GroutingLineName,
                            GMouldTypeID,
                            CanManyTimes,
                            GroutingLineDetailID,
                            GroutingDate,
                            GroutingMouldCode,
                            MouldCode,
                            GroutingUserID,
                            GroutingUserCode,
                            GroutingNum,
                            Remarks,
                            AccountDate,
                            SettlementFlag,
                            AccountID,
                            ValueFlag,
                            CreateTime,
                            CreateUserID,
                            UpdateTime,
                            UpdateUserID,
                            OPTimeStamp,
                            TriggerFlag,
                            logoid,
                            BackOutTime,BackOutUserID,BackOutUserCode,CheckTime
                        )
                        select 
                        ProductionDataID,
                            BarCode,
                            CentralizedBatchNo,
                            ProductionLineID,
                            ProductionLineCode,
                            ProductionLineName,
                            ProcedureID,
                            ProcedureCode,
                            ProcedureName,
                            ProcedureModel,
                            ModelType,
                            PieceType,
                            IsReworked,
                            NodeType,
                            IsPublicBody,
                            IsReFire,
                            GoodsLevelID,
                            GoodsLevelTypeID,
                            SpecialRepairFlag,
                            OrganizationID,
                            GoodsID,
                            GoodsCode,
                            GoodsName,
                            UserID,
                            UserCode,
                            UserName,
                            ClassesSettingID,
                            KilnID,
                            KilnCode,
                            KilnName,
                            KilnCarID,
                            KilnCarCode,
                            KilnCarName,
                            KilnCarBatchNo,
                            KilnCarPosition,
                            ReworkProcedureID,
                            ReworkProcedureCode,
                            ReworkProcedureName,
                            GroutingDailyID,
                            GroutingDailyDetailID,
                            GroutingLineID,
                            GroutingLineCode,
                            GroutingLineName,
                            GMouldTypeID,
                            CanManyTimes,
                            GroutingLineDetailID,
                            GroutingDate,
                            GroutingMouldCode,
                            MouldCode,
                            GroutingUserID,
                            GroutingUserCode,
                            GroutingNum,
                            Remarks,
                            AccountDate,
                            SettlementFlag,
                            AccountID,
                            ValueFlag,
                            CreateTime,
                            CreateUserID,
                            UpdateTime,
                            UpdateUserID,
                            OPTimeStamp,
                            1,
                            logoid,
                            BackOutTime,BackOutUserID,BackOutUserCode,CheckTime
                         from TP_PM_ProductionData where valueflag=1 and barcode=:barcode
                        ";
					returnRows += oracleTrConn.ExecuteNonQuery(sql, Paras);
				}
				//第五步，回添加生产数据 modify wangx 2015/07/20  新添加的代码 end

				if (returnRows <= 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				else
				{
					oracleTrConn.Commit();
					oracleTrConn.Disconnect();
				}
			}
			catch (Exception ex)
			{
				oracleTrConn.Rollback();
				throw ex;
			}
			finally
			{
				// 释放资源
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			entity.Result = returnRows;
			return entity;
		}

		#endregion
	}
}