SANHOPE.mes.wcf/DK.Service/SystemModuleLogic/SystemModuleDAL.cs

/*******************************************************************************
 * Copyright(c) 2014 DongkeSoft All rights reserved. / Confidential
 * 类的信息：
 *      1.程序名称：SystemModuleDAL.cs
 *      2.功能描述：系统管理更新db逻辑处理
 * 编辑履历：
 *      作者            日期                版本            修改内容
 *      张国印          2014/09/12          1.00            新建
 *******************************************************************************/

using System;
using System.Text;
using System.Data;

using Dongke.IBOSS.PRD.Basics.DataAccess;
using Dongke.IBOSS.PRD.Basics.BaseResources;
using Dongke.IBOSS.PRD.Basics.Library;
using Dongke.IBOSS.PRD.Service.DataModels;
using Dongke.IBOSS.PRD.WCF.DataModels;
using Oracle.ManagedDataAccess.Client;

namespace Dongke.IBOSS.PRD.Service.SystemModuleLogic
{
	/// <summary>
	/// 系统管理更新db逻辑处理
	/// </summary>
	public partial class SystemModuleDAL
	{
		#region 数据字典和基础数据相关

		/// <summary>
		/// 保存窑炉数据
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="datatKilnData">窑炉数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.09.01			任海			新建
		/// </remarks>
		public static int SaveKilnData(SUserInfo sUserInfo, DataTable datatKilnData)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (datatKilnData == null && datatKilnData.Rows.Count < Constant.INT_IS_ZERO)
				{
					return Constant.INT_IS_THREE;
				}
				int returnResult = Constant.INT_IS_TWO;
				oracleTrConn.Connect();
				#region 对要保存的窑炉数据进行必要的验证
				foreach (DataRow dataRow in datatKilnData.Rows)
				{
					// 新建窑炉
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的窑炉代码
						string sqlString = "SELECT Count(*) FROM TP_MST_Kiln WHERE AccountID = :AccountID and KilnCode =:KilnCode ";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":KilnCode",dataRow["KilnCode"].ToString())
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlString, oracleParameter);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的窑炉代码
						string sqlStrings = "SELECT Count(*) FROM TP_MST_Kiln WHERE AccountID = :AccountID and KilnCode = :KilnCode and KilnID <> :KilnID";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":KilnCode",dataRow["KilnCode"]),
							new OracleParameter(":KilnID",dataRow["KilnID"])
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlStrings, oracleParameters);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
				}
				if (returnResult == Constant.INT_IS_ONE)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnResult;
				}
				#endregion
				foreach (DataRow dataRow in datatKilnData.Rows)
				{
					// 新建窑炉
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增窑炉信息

						#region 向T_MST_Kiln插入数据
						string sqlInsertString = "INSERT INTO TP_MST_Kiln "
												+ "(KilnCode"
												+ ",KilnName"
												+ ",KilnType"
												+ ",InOutMinTimeIinterval"
												+ ",OutMinTimeIinterval"
												+ ",TurnoverInterval"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:KilnCode"
												+ ",:KilnName"
												+ ",:KilnType"
												+ ",decode(:InOutMinTimeIinterval, null, 0, :InOutMinTimeIinterval)"
												+ ",decode(:OutMinTimeIinterval, null, 0, :OutMinTimeIinterval)"
												+ ",decode(:TurnoverInterval, null, 0, :TurnoverInterval)"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":KilnCode",dataRow["KilnCode"].ToString()),
							new OracleParameter(":KilnName",dataRow["KilnName"].ToString()),
							new OracleParameter(":KilnType",dataRow["KilnType"].ToString()),
							new OracleParameter(":InOutMinTimeIinterval",dataRow["InOutMinTimeIinterval"]),
							new OracleParameter(":OutMinTimeIinterval",dataRow["OutMinTimeIinterval"]),
							new OracleParameter(":TurnoverInterval",dataRow["TurnoverInterval"]),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameter);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新窑炉信息
						string sqlUpdateString = "UPDATE TP_MST_Kiln SET "
											+ " KilnCode = :KilnCode,"
											+ " KilnName = :KilnName,"
											+ " KilnType = :KilnType,"
											+ " InOutMinTimeIinterval = decode(:InOutMinTimeIinterval, null, 0, :InOutMinTimeIinterval),"
											+ " OutMinTimeIinterval = decode(:OutMinTimeIinterval, null, 0, :OutMinTimeIinterval),"
											+ " TurnoverInterval = decode(:TurnoverInterval, null, 0, :TurnoverInterval),"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE KilnID = :KilnID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":KilnCode",dataRow["KilnCode"].ToString()),
							new OracleParameter(":KilnName",dataRow["KilnName"].ToString()),
							new OracleParameter(":KilnType",dataRow["KilnType"].ToString()),
							new OracleParameter(":InOutMinTimeIinterval",dataRow["InOutMinTimeIinterval"]),
							new OracleParameter(":OutMinTimeIinterval",dataRow["OutMinTimeIinterval"]),
							new OracleParameter(":TurnoverInterval",dataRow["TurnoverInterval"]),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":KilnID",dataRow["KilnID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParameter);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除窑炉信息
						string sqlDeleteString = "DELETE TP_MST_Kiln  WHERE KilnID = :KilnID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":KilnID",dataRow["KilnID",DataRowVersion.Original].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlDeleteString, oracleParameter);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
		}

		/// <summary>
		/// 保存窑车数据
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="datatKilnCarData">窑车数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.09.01          任海          新建
		/// </remarks>
		public static int SaveKilnCarData(SUserInfo sUserInfo, DataTable datatKilnCarData)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (datatKilnCarData == null && datatKilnCarData.Rows.Count < Constant.INT_IS_ZERO)
				{
					return Constant.INT_IS_THREE;
				}
				int returnResult = Constant.INT_IS_TWO;
				oracleTrConn.Connect();

				#region 对要保存的窑车数据进行必要的验证
				foreach (DataRow dataRow in datatKilnCarData.Rows)
				{
					// 新建窑车
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的窑车代码
						string sqlString = "SELECT Count(*) FROM TP_MST_KilnCar WHERE AccountID = :AccountID and KilnCarCode =:KilnCarCode ";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":KilnCarCode",dataRow["KilnCarCode"].ToString())
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlString, oracleParameter);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的窑车代码
						string sqlStrings = "SELECT Count(*) FROM TP_MST_KilnCar WHERE AccountID = :AccountID and KilnCarCode = :KilnCarCode and KilnCarID <> :KilnCarID";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":KilnCarCode",dataRow["KilnCarCode"]),
							new OracleParameter(":KilnCarID",dataRow["KilnCarID"])
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlStrings, oracleParameters);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
				}
				if (returnResult == Constant.INT_IS_ONE)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnResult;
				}
				#endregion

				foreach (DataRow dataRow in datatKilnCarData.Rows)
				{
					// 新建窑车
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增窑车信息

						#region 向TP_MST_KilnCar插入数据
						string sqlInsertString = "INSERT INTO TP_MST_KilnCar "
												+ "(KilnID"
												+ ",KilnCarCode"
												+ ",KilnCarName"
												+ ",MaxGoodsNum"
												+ ",KilnCarNum"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:KilnID"
												+ ",:KilnCarCode"
												+ ",:KilnCarName"
												+ ",:MaxGoodsNum"
												+ ",:KilnCarNum"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":KilnID",dataRow["KilnID"].ToString()),
							new OracleParameter(":KilnCarCode",dataRow["KilnCarCode"].ToString()),
							new OracleParameter(":KilnCarName",dataRow["KilnCarName"].ToString()),
							new OracleParameter(":MaxGoodsNum",(dataRow["MaxGoodsNum"] == null || dataRow["MaxGoodsNum"] == DBNull.Value)?0:dataRow["MaxGoodsNum"]),
							new OracleParameter(":KilnCarNum",dataRow["KilnCarNum"]),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameter);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新窑车信息
						string sqlUpdateString = "UPDATE TP_MST_KilnCar SET "
											+ " KilnID = :KilnID,"
											+ " KilnCarCode = :KilnCarCode,"
											+ " KilnCarName = :KilnCarName,"
											+ " MaxGoodsNum = :MaxGoodsNum,"
											+ " KilnCarNum = :KilnCarNum,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE KilnCarID = :KilnCarID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":KilnID",dataRow["KilnID"].ToString()),
							new OracleParameter(":KilnCarCode",dataRow["KilnCarCode"].ToString()),
							new OracleParameter(":KilnCarName",dataRow["KilnCarName"].ToString()),
							new OracleParameter(":MaxGoodsNum",(dataRow["MaxGoodsNum"] == null || dataRow["MaxGoodsNum"] == DBNull.Value)?0:dataRow["MaxGoodsNum"]),
							new OracleParameter(":KilnCarNum",dataRow["KilnCarNum"]),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":KilnCarID",dataRow["KilnCarID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParameter);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除窑车信息
						string sqlDeleteString = "DELETE TP_MST_KilnCar  WHERE KilnCarID = :KilnCarID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":KilnCarID",dataRow["KilnCarID",DataRowVersion.Original].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlDeleteString, oracleParameter);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
		}

		/// <summary>
		/// 保存数据字典数据
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="dataDictionaryData">数据字典数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.09.05          任海          新建
		/// </remarks>
		public static int SaveDictionaryData(SUserInfo sUserInfo, DataTable dataDictionaryData)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (dataDictionaryData == null && dataDictionaryData.Rows.Count < Constant.INT_IS_ZERO)
				{
					return Constant.INT_IS_THREE;
				}
				int returnResult = Constant.INT_IS_TWO;
				oracleTrConn.Connect();
				foreach (DataRow dataRow in dataDictionaryData.Rows)
				{
					// 新建数据字典
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增数据字典信息

						#region 向T_MST_DataDictionary插入数据
						string sqlInsertString = "INSERT INTO TP_MST_DataDictionary "
												+ "(DictionaryType"
												+ ",DictionaryValue"
												+ ",DisplayNo"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:DictionaryType"
												+ ",:DictionaryValue"
												+ ",:DisplayNo"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":DictionaryType",dataRow["DictionaryType"].ToString()),
							new OracleParameter(":DictionaryValue",dataRow["DictionaryValue"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameter);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新数据字典信息
						string sqlUpdateString = "UPDATE TP_MST_DataDictionary SET "
											+ " DictionaryType = :DictionaryType,"
											+ " DictionaryValue = :DictionaryValue,"
											+ " DisplayNo = :DisplayNo,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE DictionaryID = :DictionaryID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":DictionaryType",dataRow["DictionaryType"].ToString()),
							new OracleParameter(":DictionaryValue",dataRow["DictionaryValue"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":DictionaryID",dataRow["DictionaryID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParameter);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除数据字典信息
						string sqlDeleteString = "DELETE TP_MST_DataDictionary  WHERE DictionaryID = :DictionaryID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":DictionaryID",dataRow["DictionaryID",DataRowVersion.Original].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlDeleteString, oracleParameter);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
		}

		/// <summary>
		/// 保存系统参数数据
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="datatSystemData">系统参数数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.09.15 			任海			新建
		/// </remarks>
		public static int SaveSystemData(DataTable datatSystemData, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (datatSystemData == null && datatSystemData.Rows.Count < Constant.INT_IS_ZERO)
				{
					return Constant.INT_IS_THREE;
				}
				int returnResult = Constant.INT_IS_TWO;
				oracleTrConn.Connect();

				#region 对要保存的操作时间戳进行必要的验证
				foreach (DataRow dataRow in datatSystemData.Rows)
				{
					#region 判断是否存在相同的系统参数代码
					string sqlStrings = "SELECT OPTimeStamp FROM TP_MST_SystemSetting WHERE AccountID = :AccountID and SettingCode = :SettingCode ";
					OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":SettingCode",dataRow["SettingCode"])
						};
					string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlStrings, oracleParameter);
					if (sqlReturnStr != dataRow["OPTimeStamp"].ToString())
					{
						returnResult = Constant.INT_IS_ONE;
						break;
					}
					#endregion
				}
				if (returnResult == Constant.INT_IS_ONE)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnResult;
				}
				#endregion

				string sqlString = string.Empty;
				foreach (DataRow drowRow in datatSystemData.Rows)
				{
					// 行状态为编辑
					if (drowRow.RowState == DataRowState.Modified)
					{
						// 如果修改账务时间，需要进行判断
						if (Constant.SettingType.S_CMN_0004.ToString().Equals(drowRow["SettingCode"]))
						{
							continue;
							//bool isCanEdit = true;
							//DateTime serverDate = DateTime.MinValue;
							//DataTable dtServertime = oracleTrConn.GetSqlResultToDt("SELECT sysdate FROM dual");
							//if (dtServertime != null && dtServertime.Rows.Count > 0)
							//{
							//    serverDate = Convert.ToDateTime(dtServertime.Rows[0][0]);
							//}
							//DateTime nowAccountTime = Utility.ConvertTimeStr(serverDate, drowRow["SettingValue"] + "");
							//DateTime orginalAccountTime = Utility.ConvertTimeStr(serverDate,
							//    drowRow["SettingValue", DataRowVersion.Original] + "");

							//// 当前时间大于原来账务日期不可进行修改
							//if (serverDate >= orginalAccountTime)
							//{
							//    isCanEdit = false;
							//}
							//else
							//{
							//    // 当前时间小于原来账务日期，但修改后的账务日期在当前时间之前也是不能进行修改的
							//    if (nowAccountTime <= serverDate)
							//    {
							//        isCanEdit = false;
							//    }
							//}
							//if (!isCanEdit)
							//{
							//    oracleTrConn.Rollback();
							//    oracleTrConn.Disconnect();
							//    return Constant.RETURN_IS_ERRORACCOUNTTIME;
							//}
						}
						//更新系统参数信息
						sqlString = "UPDATE TP_MST_SystemSetting "
									+ "SET SettingValue = :SettingValue, "
									//+ "UpdateTime = sysdate, "
									//+ "OPTimeStamp = systimestamp, "
									+ "UpdateUserID = :UpdateUserID "
									+ "WHERE SettingCode = :SettingCode "
									+ "and AccountID = :AccountID ";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
								new OracleParameter(":SettingValue", drowRow["SettingValue"].ToString()),
								new OracleParameter(":UpdateUserID", sUserInfo.UserID),
								new OracleParameter(":AccountID", sUserInfo.AccountID),
								new OracleParameter(":SettingCode", drowRow["SettingCode"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlString, oracleParameter);
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
		}

		/// <summary>
		/// 保存工种数据
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="datatJobsData">工种数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.09.09          任海          新建
		/// </remarks>
		public static int SavetJobsData(DataTable datatJobsData, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (datatJobsData == null && datatJobsData.Rows.Count < Constant.INT_IS_ZERO)
				{
					return Constant.INT_IS_THREE;
				}

				int returnResult = Constant.INT_IS_TWO;
				oracleTrConn.Connect();

				#region 对要保存的工种数据进行必要的验证
				foreach (DataRow dataRow in datatJobsData.Rows)
				{
					// 新建工种
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的工种代码
						string sqlString = "SELECT Count(*) FROM TP_MST_Jobs WHERE AccountID = :AccountID and JobsCode =:JobsCode ";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":JobsCode",dataRow["JobsCode"].ToString())
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlString, oracleParameter);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的工种代码
						string sqlStrings = "SELECT Count(*) FROM TP_MST_Jobs WHERE AccountID = :AccountID and JobsCode = :JobsCode and JobsID <> :JobsID";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":JobsCode",dataRow["JobsCode"]),
							new OracleParameter(":JobsID",dataRow["JobsID"])
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlStrings, oracleParameters);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
				}
				if (returnResult == Constant.INT_IS_ONE)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnResult;
				}
				#endregion
				foreach (DataRow dataRow in datatJobsData.Rows)
				{
					// 新建工种
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增工种信息

						#region 向T_MST_Jobs插入数据
						string sqlInsertString = "INSERT INTO TP_MST_Jobs "
												+ "(JobsCode"
												+ ",JobsName"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:JobsCode"
												+ ",:JobsName"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":JobsCode",dataRow["JobsCode"].ToString()),
							new OracleParameter(":JobsName",dataRow["JobsName"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameters);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新工种信息
						string sqlUpdateString = "UPDATE TP_MST_Jobs SET "
											+ " JobsCode = :JobsCode,"
											+ " JobsName = :JobsName,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE JobsID = :JobsID";
						OracleParameter[] oracleParametere = new OracleParameter[]
						{
							new OracleParameter(":JobsCode",dataRow["JobsCode"].ToString()),
							new OracleParameter(":JobsName",dataRow["JobsName"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":JobsID",dataRow["JobsID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParametere);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除工种信息
						string sqlDeleteString = "DELETE TP_MST_Jobs  WHERE JobsID = :JobsID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":JobsID",dataRow["JobsID",DataRowVersion.Original].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlDeleteString, oracleParameter);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
		}

		/// <summary>
		/// 保存职务数据
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="datatPostData">职务数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.09.10          任海          新建
		/// </remarks>
		public static int SavePostData(DataTable datatPostData, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (datatPostData == null && datatPostData.Rows.Count < Constant.INT_IS_ZERO)
				{
					return Constant.INT_IS_THREE;
				}
				int returnResult = Constant.INT_IS_TWO;
				oracleTrConn.Connect();

				#region 对要保存的职务数据进行必要的验证
				foreach (DataRow dataRow in datatPostData.Rows)
				{
					// 新建职务
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的职务代码
						string sqlString = "SELECT Count(*) FROM TP_MST_Post WHERE AccountID = :AccountID and PostCode =:PostCode ";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":PostCode",dataRow["PostCode"].ToString())
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlString, oracleParameter);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的职务代码
						string sqlStrings = "SELECT Count(*) FROM TP_MST_Post WHERE AccountID = :AccountID and PostCode = :PostCode and PostID <> :PostID";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":PostCode",dataRow["PostCode"]),
							new OracleParameter(":PostID",dataRow["PostID"])
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlStrings, oracleParameters);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
				}
				if (returnResult == Constant.INT_IS_ONE)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnResult;
				}
				#endregion

				foreach (DataRow dataRow in datatPostData.Rows)
				{
					// 新建职务
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增职务信息

						#region 向TP_MST_Post插入数据
						string sqlInsertString = "INSERT INTO TP_MST_Post "
												+ "(PostCode"
												+ ",PostName"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:PostCode"
												+ ",:PostName"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":PostCode",dataRow["PostCode"].ToString()),
							new OracleParameter(":PostName",dataRow["PostName"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameter);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新职务信息
						string sqlUpdateString = "UPDATE TP_MST_Post SET "
											+ " PostCode = :PostCode,"
											+ " PostName = :PostName,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE PostID = :PostID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":PostCode",dataRow["PostCode"].ToString()),
							new OracleParameter(":PostName",dataRow["PostName"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":PostID",dataRow["PostID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParameter);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除职务信息
						string sqlDeleteString = "DELETE TP_MST_Post  WHERE PostID = :PostID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":PostID",dataRow["PostID",DataRowVersion.Original].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlDeleteString, oracleParameter);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
		}

		/// <summary>
		/// 保存产品缺陷数据
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="dataDefectData">产品缺陷数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.09.10          任海          新建
		/// </remarks>
		public static int SaveDefectData(DataTable dataDefectData, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (dataDefectData == null && dataDefectData.Rows.Count < Constant.INT_IS_ZERO)
				{
					return Constant.INT_IS_THREE;
				}
				int returnResult = Constant.INT_IS_TWO;
				oracleTrConn.Connect();

				#region 对要保存的产品缺陷数据进行必要的验证
				foreach (DataRow dataRow in dataDefectData.Rows)
				{
					// 新建产品缺陷
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的产品缺陷代码
						string sqlString = "SELECT Count(*) FROM TP_MST_Defect WHERE AccountID = :AccountID and DefectCode =:DefectCode ";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":DefectCode",dataRow["DefectCode"].ToString())
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlString, oracleParameter);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的产品缺陷代码
						string sqlStrings = "SELECT Count(*) FROM TP_MST_Defect WHERE AccountID = :AccountID and DefectCode = :DefectCode and DefectID <> :DefectID";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":DefectCode",dataRow["DefectCode"]),
							new OracleParameter(":DefectID",dataRow["DefectID"])
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlStrings, oracleParameters);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
				}
				if (returnResult == Constant.INT_IS_ONE)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnResult;
				}
				#endregion
				foreach (DataRow dataRow in dataDefectData.Rows)
				{
					// 新建产品缺陷
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增产品缺陷信息

						#region 向TP_MST_Defect插入数据
						string sqlInsertString = "INSERT INTO TP_MST_Defect"
												+ "(DefectCode"
												+ ",DefectName"
												+ ",DisplayNo"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID"
												+ ",DefectTypeID)"
										+ " VALUES "
												+ "(:DefectCode"
												+ ",:DefectName"
												+ ",:DisplayNo"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID"
												+ ",:DefectTypeID)";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":DefectCode",dataRow["DefectCode"].ToString()),
							new OracleParameter(":DefectName",dataRow["DefectName"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"]),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID),
							new OracleParameter(":DefectTypeID",dataRow["DefectTypeID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameter);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新产品缺陷信息
						string sqlUpdateString = "UPDATE TP_MST_Defect SET "
											+ " DefectCode = :DefectCode,"
											+ " DefectName = :DefectName,"
											+ " DisplayNo = :DisplayNo,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime,"
											+ " DefectTypeID = :DefectTypeID"
											+ " WHERE DefectID = :DefectID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":DefectCode",dataRow["DefectCode"].ToString()),
							new OracleParameter(":DefectName",dataRow["DefectName"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"]),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":DefectID",dataRow["DefectID"].ToString()),
							 new OracleParameter(":DefectTypeID",dataRow["DefectTypeID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParameter);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除产品缺陷信息
						string sqlDeleteString = "DELETE TP_MST_Defect  WHERE DefectID = :DefectID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":DefectID",dataRow["DefectID",DataRowVersion.Original].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlDeleteString, oracleParameter);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
		}

		/// <summary>
		/// 保存成型线类型数据
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="datatGMouldTypeData">成型线类型数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.09.11          任海          新建
		/// </remarks>
		public static int SavetGMouldTypeData(DataTable datatGMouldTypeData, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (datatGMouldTypeData == null && datatGMouldTypeData.Rows.Count < Constant.INT_IS_ZERO)
				{
					return Constant.INT_IS_THREE;
				}
				int returnResult = Constant.INT_IS_TWO;
				oracleTrConn.Connect();

				#region 对要保存的成型线类型数据进行必要的验证
				foreach (DataRow dataRow in datatGMouldTypeData.Rows)
				{
					// 新建成型线类型
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的成型线类型代码
						string sqlString = "SELECT Count(*) FROM TP_MST_GMouldType WHERE AccountID = :AccountID and GMouldTypeCode =:GMouldTypeCode ";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":GMouldTypeCode",dataRow["GMouldTypeCode"].ToString())
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlString, oracleParameter);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的成型线类型代码
						string sqlStrings = "SELECT Count(*) FROM TP_MST_GMouldType WHERE AccountID = :AccountID and GMouldTypeCode = :GMouldTypeCode and GMouldTypeID <> :GMouldTypeID";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":GMouldTypeCode",dataRow["GMouldTypeCode"]),
							new OracleParameter(":GMouldTypeID",dataRow["GMouldTypeID"])
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlStrings, oracleParameters);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
				}
				if (returnResult == Constant.INT_IS_ONE)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnResult;
				}
				#endregion

				foreach (DataRow dataRow in datatGMouldTypeData.Rows)
				{
					// 新建成型线类型
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增成型线类型信息

						#region 向TP_MST_GMouldType插入数据
						string sqlInsertString = "INSERT INTO TP_MST_GMouldType "
												+ "(GMouldTypeCode"
												+ ",GMouldTypeName"
												+ ",CanManyTimes"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:GMouldTypeCode"
												+ ",:GMouldTypeName"
												+ ",:CanManyTimes"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":GMouldTypeCode",dataRow["GMouldTypeCode"].ToString()),
							new OracleParameter(":GMouldTypeName",dataRow["GMouldTypeName"].ToString()),
							new OracleParameter(":CanManyTimes",dataRow["CanManyTimes"].ToString()=="True"?"1"
							:dataRow["CanManyTimes"].ToString()=="Flase"?"0":dataRow["CanManyTimes"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameter);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新成型线类型信息
						string sqlUpdateString = "UPDATE TP_MST_GMouldType SET "
											+ " GMouldTypeCode = :GMouldTypeCode,"
											+ " GMouldTypeName = :GMouldTypeName,"
											+ " CanManyTimes = :CanManyTimes,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE GMouldTypeID = :GMouldTypeID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":GMouldTypeCode",dataRow["GMouldTypeCode"].ToString()),
							new OracleParameter(":GMouldTypeName",dataRow["GMouldTypeName"].ToString()),
							new OracleParameter(":CanManyTimes",dataRow["CanManyTimes"].ToString()=="True"?"1"
						   :dataRow["CanManyTimes"].ToString()=="Flase"?"0":dataRow["CanManyTimes"].ToString()==""?"0":"1"),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":GMouldTypeID",dataRow["GMouldTypeID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParameter);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除成型线类型信息
						string sqlDeleteString = "DELETE TP_MST_GMouldType  WHERE GMouldTypeID = :GMouldTypeID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":GMouldTypeID",dataRow["GMouldTypeID",DataRowVersion.Original].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlDeleteString, oracleParameter);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存产品分级的数据
		/// </summary>
		/// <param name="datatGoodsLevelData">产品分级的数据</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.10.22          任海          新建
		/// </remarks>
		public static int SaveGoodsLevelData(DataTable datatGoodsLevelData, SUserInfo sUserInfo)
		{
			int returnRows = Constant.INT_IS_TWO;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				foreach (DataRow dataRow in datatGoodsLevelData.Rows)
				{
					string sqlUpdateString = "UPDATE tp_mst_goodslevel SET "
											+ " GoodsLevelName = :GoodsLevelName,"
											+ " GoodsLevelTypeID = :GoodsLevelTypeID,"
											+ " IsSemiFinishedEx = :IsSemiFinishedEx,"
											+ " SFEDisplayNo = :SFEDisplayNo,"
											+ " IsFinishedEx = :IsFinishedEx,"
											+ " FEDisplayNo = :FEDisplayNo,"
											+ " IsFinished = :IsFinished,"
											+ " IsScrapped = :IsScrapped,"
											+ " CanDisable = :CanDisable,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE GoodsLevelID = :GoodsLevelID";
					OracleParameter[] oracleParameter = new OracleParameter[]
					{
							new OracleParameter(":GoodsLevelName",dataRow["GoodsLevelName"].ToString()),
							new OracleParameter(":GoodsLevelTypeID",dataRow["GoodsLevelTypeID"].ToString()),
							new OracleParameter(":IsSemiFinishedEx",dataRow["IsSemiFinishedEx"].ToString()),
							new OracleParameter(":SFEDisplayNo",dataRow["SFEDisplayNo"].ToString()),
							new OracleParameter(":IsFinishedEx",dataRow["IsFinishedEx"].ToString()),
							new OracleParameter(":FEDisplayNo",dataRow["FEDisplayNo"].ToString()),
							new OracleParameter(":IsFinished",dataRow["IsFinished"].ToString()),
							new OracleParameter(":IsScrapped",dataRow["IsScrapped"].ToString()),
							new OracleParameter(":CanDisable",dataRow["CanDisable"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":GoodsLevelID",dataRow["GoodsLevelID"].ToString())
					};
					oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParameter);
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnRows;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存配置员工的数据
		/// </summary>
		/// <param name="userID">用户ID</param>
		/// <param name="dataDeploystaffData">员工数据表</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.10.13          任海          新建
		/// </remarks>
		public static int SaveDeploystaffData(int userID, DataTable dataDeploystaffData, SUserInfo sUserInfo)
		{
			int returnRows = Constant.INT_IS_ZERO;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				foreach (DataRow dataRow in dataDeploystaffData.Rows)
				{
					if (dataRow.RowState == DataRowState.Added)
					{
						int intStaffID = Convert.ToInt32(dataRow["StaffID"]);
						string sqlUpdateString = "UPDATE TP_HR_Staff SET UserID=:pUuserID"
							 + " Where StaffID = :pStaffID And AccountID = :pAccountID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":pUuserID",OracleDbType.Int32,userID,ParameterDirection.Input),
							new OracleParameter(":pStaffID",OracleDbType.Int32,intStaffID,ParameterDirection.Input),
							new OracleParameter(":pAccountID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
						};
						returnRows += oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParameter);
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						int intStaffID = Convert.ToInt32(dataRow["StaffID", DataRowVersion.Original].ToString());
						string sqlUpdateString2 = "UPDATE TP_HR_Staff SET UserID=null"
							 + " Where StaffID = :pStaffID And AccountID = :pAccountID";
						OracleParameter[] oracleParameter2 = new OracleParameter[]
						{
							new OracleParameter(":pStaffID",OracleDbType.Int32,intStaffID,ParameterDirection.Input),
							new OracleParameter(":pAccountID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
						};
						returnRows += oracleTrConn.ExecuteNonQuery(sqlUpdateString2, oracleParameter2);
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnRows;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存缺陷位置数据
		/// </summary>
		/// <param name="dataDefectPositionData">缺陷数据</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.09.11          冯雪          新建
		/// </remarks>
		public static int SaveDefectPositionsData(DataTable dataDefectPositionData, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (dataDefectPositionData == null && dataDefectPositionData.Rows.Count < 0)
				{
					return 3;
				}
				int intResult = 2;
				oracleTrConn.Connect();
				#region 对要保存的帐套数据进行必要的验证
				foreach (DataRow dataRow in dataDefectPositionData.Rows)
				{
					// 新建缺陷位置
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的位置代码
						string sqlString1 = "SELECT Count(*) FROM TP_MST_DefectPosition WHERE AccountID = :AccountID and DefectPositionCode =:DefectPositionCode ";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							 new OracleParameter(":DefectPositionCode",dataRow["DefectPositionCode"].ToString())
						};
						string strTemp1 = oracleTrConn.GetSqlResultToStr(sqlString1, parmeters1);
						if (strTemp1 != "0")
						{
							intResult = 1;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的位置代码
						string sqlString2 = "SELECT Count(*) FROM TP_MST_DefectPosition WHERE AccountID = :AccountID and DefectPositionCode = :DefectPositionCode and DefectPositionID <> :DefectPositionID";
						OracleParameter[] parmeters2 = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":DefectPositionCode",dataRow["DefectPositionCode"]),
							 new OracleParameter(":DefectPositionID",dataRow["DefectPositionID"])
						};
						string strTemp1 = oracleTrConn.GetSqlResultToStr(sqlString2, parmeters2);
						if (strTemp1 != "0")
						{
							intResult = 1;
							break;
						}
						#endregion
					}
				}
				if (intResult == 1)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return intResult;
				}
				#endregion
				//string accountID = "";  // 存储新插入账套ID
				//string userID = "";     //用户ID
				foreach (DataRow dataRow in dataDefectPositionData.Rows)
				{
					// 新建缺陷
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增缺陷位置信息

						#region 向TP_MST_DEFECTPOSITION插入数据
						string sqlString1 = "INSERT INTO TP_MST_DefectPosition "
												+ "(DefectPositionCode"
												+ ",DefectPositionName"
												+ ",DisplayNo"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:DefectPositionCode"
												+ ",:DefectPositionName"
												+ ",:DisplayNo"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":DefectPositionCode",dataRow["DefectPositionCode"].ToString()),
							new OracleParameter(":DefectPositionName",dataRow["DefectPositionName"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"]),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							 new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlString1, parmeters1);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新缺陷信息
						string sqlString = "UPDATE TP_MST_DefectPosition SET "
											+ " DefectPositionCode = :DefectPositionCode,"
											+ " DefectPositionName = :DefectPositionName,"
											+ " DisplayNo = :DisplayNo,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE DefectPositionID = :DefectPositionID";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":DefectPositionCode",dataRow["DefectPositionCode"].ToString()),
							new OracleParameter(":DefectPositionName",dataRow["DefectPositionName"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"].ToString()),
                            //new OracleParameter(":KilnType",dataRow["KilnType"].ToString()), 
                            new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":DefectPositionID",dataRow["DefectPositionID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlString, parmeters1);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除缺陷信息
						string sqlDeleteString = "DELETE TP_MST_DefectPosition  WHERE DefectPositionID = :DefectPositionID";
						OracleParameter[] parmeters2 = new OracleParameter[]
						{
							new OracleParameter(":DefectPositionID",dataRow["DefectPositionID",DataRowVersion.Original].ToString())
						};

						oracleTrConn.ExecuteNonQuery(sqlDeleteString, parmeters2);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return intResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存产品类型数据
		/// </summary>
		/// <param name="dataGoodsTypeData">产品类型数据</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.09.12          冯雪          新建
		/// </remarks>
		public static int SaveGoodsTypeData(DataTable dataGoodsTypeData, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (dataGoodsTypeData == null && dataGoodsTypeData.Rows.Count < 0)
				{
					return 3;
				}
				int intResult = 2;
				oracleTrConn.Connect();
				#region 对要保存的帐套数据进行必要的验证

				foreach (DataRow dataRow in dataGoodsTypeData.Rows)
				{
					// 新建缺陷位置
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的位置代码

						string sqlString1 = "SELECT Count(*) FROM TP_MST_GoodsType WHERE AccountID = :AccountID and goodstypecode =:goodstypecode ";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							 new OracleParameter(":goodstypecode",dataRow["goodstypecode"].ToString())
						};
						string strTemp1 = oracleTrConn.GetSqlResultToStr(sqlString1, parmeters1);
						if (strTemp1 != "0")
						{
							intResult = 1;
							break;
						}

						string datRowSub = dataRow["goodstypecode"].ToString().Substring(0, dataRow["goodstypecode"].ToString().Length - 3);

						string sqlString2 = @"select count(*) from Tp_Mst_Goods
                                         where goodstypeid = (select distinct goodsTypeId from tp_mst_goodstype where GoodstypeCode = :GoodstypeCode and accountid=:accountid)";
						OracleParameter[] parmeters2 = new OracleParameter[]
						{
							 new OracleParameter(":AccountID",sUserInfo.AccountID),
							  new OracleParameter(":GoodstypeCode",datRowSub),
						};
						string strTemp2 = oracleTrConn.GetSqlResultToStr(sqlString2, parmeters2);

						if (strTemp2 != "0")
						{
							intResult = 4;
							break;
						}

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的产品类型代码

						string sqlString2 = "SELECT Count(*) FROM TP_MST_GoodsType WHERE AccountID = :AccountID and Goodstypecode = :goodstypecode and GoodsTypeID <> :goodsTypeID";
						OracleParameter[] parmeters2 = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":goodstypecode",dataRow["goodstypecode"]),
							 new OracleParameter(":goodsTypeID",dataRow["goodsTypeID"])
						};
						string strTemp1 = oracleTrConn.GetSqlResultToStr(sqlString2, parmeters2);
						if (strTemp1 != "0")
						{
							intResult = 1;
							break;
						}

						#endregion
					}
				}
				if (intResult == 1 || intResult == 4)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return intResult;
				}

				#endregion
				//string accountID = "";  // 存储新插入账套ID
				//string userID = "";     //用户ID
				foreach (DataRow dataRow in dataGoodsTypeData.Rows)
				{
					// 新建产品类型
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增产品类型信息

						string sqlString1 = "INSERT INTO TP_MST_GoodsType "
												+ "(GoodsTypeCode"
												+ ",GoodsTypeName"
												+ ",GoodsTypeFullName"
												+ ",Remarks"
												+ ",AccountID"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID"
												+ ",IsLeafNode)"
										+ " VALUES "
												+ "(:goodsTypeCode"
												+ ",:goodsTypeName"
												+ ",:goodsTypeFullName"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID,1)";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":goodsTypeCode",dataRow["goodsTypeCode"].ToString()),
							new OracleParameter(":goodsTypeName",dataRow["goodsTypeName"].ToString()),
							new OracleParameter(":goodsTypeFullName",dataRow["goodsTypeFullName"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlString1, parmeters1);

						sqlString1 = " update TP_MST_GoodsType SET IsLeafNode =0 "
										 + " where GoodsTypeCode = :goodsTypeCode "
										 + " and AccountID = :accountID";
						parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":goodsTypeCode",dataRow["goodsTypeCode"].ToString().Substring(0, dataRow["goodsTypeCode"].ToString().Length - 3)),
							new OracleParameter(":accountID",sUserInfo.AccountID),
						};
						oracleTrConn.ExecuteNonQuery(sqlString1, parmeters1);


						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新产品类型信息

						string sqlString = "UPDATE TP_MST_GoodsType SET "
											+ " GoodsTypeName = :goodsTypeName,"
											+ " GoodsTypeFullName = :GoodsTypeFullName,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE GoodsTypeID = :goodsTypeID";

						string[] sub = dataRow["GoodsTypeFullName"].ToString().Split('→');
						string oldGoodsTypeFullName = dataRow["GoodsTypeFullName"].ToString();
						if (sub.Length > 0)
						{
							if (sub[sub.Length - 1] != dataRow["goodsTypeName"].ToString())
							{
								sub[sub.Length - 1] = dataRow["goodsTypeName"].ToString();
							}
							string newFullName = "";
							for (int i = 0; i < sub.Length; i++)
							{
								if (i != sub.Length - 1)
									newFullName += sub[i] + "→";
								else
									newFullName += sub[i];
							}
							dataRow["GoodsTypeFullName"] = newFullName;
						}

						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":goodsTypeName",dataRow["goodsTypeName"].ToString()),
							new OracleParameter(":GoodsTypeFullName",dataRow["GoodsTypeFullName"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":goodsTypeID",dataRow["goodsTypeID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlString, parmeters1);

						string sqlUpdateOtherFullName = @"select * from TP_MST_GoodsType
                                             where TP_MST_GoodsType.AccountID=" + sUserInfo.AccountID + " and TP_MST_GoodsType.GoodsTypeCode like '" + dataRow["GoodsTypeCode"].ToString() + "%' and  GoodsTypeID<>" + dataRow["goodsTypeID"].ToString();
						DataSet returnDataset5 = oracleTrConn.GetSqlResultToDs(sqlUpdateOtherFullName);
						if (returnDataset5 != null && returnDataset5.Tables[0].Rows.Count > 0) // 更新所有子级
						{
							for (int i = 0; i < returnDataset5.Tables[0].Rows.Count; i++)
							{
								string sqlReplace = @"update TP_MST_GoodsType set GoodsTypeFullName=replace(GoodsTypeFullName,:oldGoodsTypeFullName,:newGoodsTypeFullName)
                                                  where GoodsTypeID=:GoodsTypeID";

								OracleParameter[] Updateparmeters = new OracleParameter[]
										{
											new OracleParameter(":oldGoodsTypeFullName",oldGoodsTypeFullName),
											new OracleParameter(":newGoodsTypeFullName",dataRow["GoodsTypeFullName"].ToString()),
											new OracleParameter(":GoodsTypeID",returnDataset5.Tables[0].Rows[i]["GoodsTypeID"].ToString()),
										};
								oracleTrConn.ExecuteNonQuery(sqlReplace, Updateparmeters);
								;
							}
						}

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除产品类型信息

						string sqlDeleteString = "DELETE TP_MST_GoodsType  WHERE GoodsTypeID = :goodsTypeID";
						OracleParameter[] parmeters2 = new OracleParameter[]
						{
							new OracleParameter(":goodsTypeID",dataRow["goodsTypeID",DataRowVersion.Original].ToString())
						};

						oracleTrConn.ExecuteNonQuery(sqlDeleteString, parmeters2);

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

		/// <summary>
		/// 新建温湿计信息
		/// </summary>
		/// <param name="thermometerEntity">温湿计信息实体</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.12.25          任海          新建
		/// </remarks>
		public static int AddThermometerEntity(ThermometerEntity thermometerEntity, SUserInfo userInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				int returnResult = Constant.INT_IS_ONE;
				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_MST_Thermometer
                               (ThermometerID,BuildingNo,FloorNo,
                               LocationCode,ThermometerCode,ManagerName,Remarks,ValueFlag,AccountID,CreateUserID,UpdateUserID)
                               Values
                               (:ThermometerID,:BuildingNo,:FloorNo,
                               :LocationCode,:ThermometerCode,:ManagerName,:Remarks,:ValueFlag,:AccountID,:CreateUserID,:UpdateUserID)");
				OracleParameter[] DFParas = new OracleParameter[] {
							new OracleParameter(":ThermometerID",OracleDbType.Int32,
							entityId,ParameterDirection.Input),
							new OracleParameter(":BuildingNo",OracleDbType.NVarchar2,
							thermometerEntity.BuildingNo,ParameterDirection.Input),
							new OracleParameter(":FloorNo",OracleDbType.NVarchar2,
							thermometerEntity.FloorNo,ParameterDirection.Input),
							new OracleParameter(":LocationCode",OracleDbType.NVarchar2,
							thermometerEntity.LocationCode,ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							thermometerEntity.Remarks,ParameterDirection.Input),
							new OracleParameter(":ThermometerCode",OracleDbType.NVarchar2,
							thermometerEntity.ThermometerCode,ParameterDirection.Input),
							 new OracleParameter(":ManagerName",OracleDbType.NVarchar2,
							thermometerEntity.ManagerName,ParameterDirection.Input),
							new OracleParameter(":ValueFlag",OracleDbType.Int32,
							thermometerEntity.ValueFlag,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),
				};
				//连接数据库并返回结果
				oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DFParas);
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 编辑温湿计信息
		/// </summary>
		/// <param name="thermometerEntity">温湿计信息实体</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.12.25          任海          新建
		/// </remarks>
		public static int UpdateThermometerEntity(ThermometerEntity thermometerEntity, SUserInfo userInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				int returnResult = Constant.INT_IS_ONE;
				oracleTrConn.Connect();
				StringBuilder sbSql = new StringBuilder();
				sbSql.Append(@"Update TP_MST_Thermometer
                               Set BuildingNo=:BuildingNo,
                                   FloorNo=:FloorNo,
                                   LocationCode=:LocationCode,
                                   ThermometerCode=:ThermometerCode,
                                   ManagerName=:ManagerName,
                                   ValueFlag=:ValueFlag,
                                   Remarks=:Remarks,
                                   UpdateUserID=:UpdateUserID
                             Where ThermometerID=:ThermometerID
                               And OPTimeStamp=:OPTimeStamp");
				OracleParameter[] DFParas = new OracleParameter[] {
							new OracleParameter(":BuildingNo",OracleDbType.NVarchar2,
							thermometerEntity.BuildingNo,ParameterDirection.Input),
							new OracleParameter(":FloorNo",OracleDbType.NVarchar2,
							thermometerEntity.FloorNo,ParameterDirection.Input),
							new OracleParameter(":LocationCode",OracleDbType.NVarchar2,
							thermometerEntity.LocationCode,ParameterDirection.Input),
							new OracleParameter(":ThermometerCode",OracleDbType.NVarchar2,
							thermometerEntity.ThermometerCode,ParameterDirection.Input),
							new OracleParameter(":ManagerName",OracleDbType.NVarchar2,
							thermometerEntity.ManagerName,ParameterDirection.Input),
							new OracleParameter(":ValueFlag",OracleDbType.Int32,
							thermometerEntity.ValueFlag,ParameterDirection.Input),
							new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							thermometerEntity.Remarks,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":ThermometerID",OracleDbType.Int32,
							thermometerEntity.ThermometerID,ParameterDirection.Input),
							new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							thermometerEntity.OPTimeStamp,ParameterDirection.Input),
				};
				oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DFParas);
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存窑炉财年
		/// </summary>
		/// <param name="sUserInfo"></param>
		/// <param name="skDate"></param>
		/// <returns></returns>
		public static ServiceResultEntity SaveKilnData(SUserInfo sUserInfo, int skDate)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			ServiceResultEntity sre = new ServiceResultEntity();
			try
			{
				// 检验参数的有效性
				if (skDate <= 0)
				{
					sre.OtherStatus = Constant.INT_IS_NEGATIE_ONE;
					sre.Message = "财年数必须大于0";
					return sre;
				}
				string sqlString = string.Empty;
				oracleTrConn.Connect();

				sqlString = "SELECT k.sk_date\n" +
							"  FROM tp_mst_kiln k\n" +
							" WHERE k.valueflag = '1'\n" +
							"   AND k.accountid = :accountid\n" +
							"   AND rownum = 1";

				OracleParameter[] oracleParameter = new OracleParameter[]
				{
					new OracleParameter(":accountid", sUserInfo.AccountID)
				};

				string nowSKDate = oracleTrConn.GetSqlResultToStr(sqlString, oracleParameter);
				int skDateInt = 0;
				int.TryParse(nowSKDate, out skDateInt);

				if (skDate <= skDateInt)
				{
					sre.OtherStatus = Constant.INT_IS_NEGATIE_ONE;
					sre.Message = "输入值小于或等于当前系统的财年数";
					return sre;
				}

				sqlString = "UPDATE tp_mst_kiln k\n" +
							"   SET k.sk_batchno = 1\n" +
							"      ,k.sk_date    = :skdate\n" +
							"      ,k.updateuserid    = :userid\n" +
							" WHERE k.accountid = :accountid";

				oracleParameter = new OracleParameter[]
				{
					new OracleParameter(":skdate", skDate),
					new OracleParameter(":userid", sUserInfo.UserID),
					new OracleParameter(":accountid", sUserInfo.AccountID)
				};
				sre.OtherStatus += oracleTrConn.ExecuteNonQuery(sqlString, oracleParameter);

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

		#region 用户处理相关逻辑

		/// <summary>
		/// 新增组织机构OrganizationCode
		/// </summary>
		/// <param name="v_parentOrganizationCode">上级组织机构编码</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		public static string GetOrganizationCode(string v_parentOrganizationCode, SUserInfo sUserInfo)
		{
			IDBConnection oracleConn = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleConn.Open();
				string sqlString = "select  Max(OrganizationCode) from TP_MST_Organization "
										 + " where OrganizationCode like '" + v_parentOrganizationCode + "%'"
										 + "and length(OrganizationCode) = length('" + v_parentOrganizationCode + "')+3"
										 + "and AccountID = " + sUserInfo.AccountID;
				DataSet returnDatasetHuoQu2 = oracleConn.GetSqlResultToDs(sqlString);
				oracleConn.Close();
				string v_MaxOrganizationCode = "";
				if (returnDatasetHuoQu2 != null && returnDatasetHuoQu2.Tables[0].Rows.Count > 0)
				{
					v_MaxOrganizationCode = returnDatasetHuoQu2.Tables[0].Rows[0][0].ToString();
				}
				if (v_MaxOrganizationCode == "")
				{
					v_MaxOrganizationCode = v_MaxOrganizationCode + v_parentOrganizationCode + "001";
				}
				else
				{
					string v_tempCode = "";
					v_tempCode = Convert.ToString(Convert.ToInt32(v_MaxOrganizationCode.Substring(v_MaxOrganizationCode.Length - 3)) + 1);
					v_MaxOrganizationCode = "000" + v_tempCode;
					v_MaxOrganizationCode = v_parentOrganizationCode + v_MaxOrganizationCode.Substring(v_MaxOrganizationCode.Length - 3);
				}

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

		/// <summary>
		/// 新增组织机构
		/// </summary>
		/// <param name="organization">OrganizationEntity对象</param>
		/// <returns>int</returns>
		public static int SaveOrganization(OrganizationEntity organization)
		{
			int returnRows = 0;
			if (organization == null)
			{
				return returnRows;
			}
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				#region 生成全称
				//string fullName = string.Empty;			// 生成的全称
				//if (organization.ParentOrganizationID <= 0)
				//{
				//    fullName = organization.OrganizationName;
				//}
				//else
				//{
				//    string sqlString1 = "SELECT OrganizationFullName FROM TP_MST_Organization"
				//            + " WHERE OrganizationID = :in_ParentOrganizationID";
				//    OracleParameter[] parmeters1 = new OracleParameter[]
				//            {
				//                new OracleParameter(":in_ParentOrganizationID",organization.ParentOrganizationID)
				//            };
				//    DataSet returnDataset = oracleTrConn.GetSqlResultToDs(sqlString1, parmeters1);
				//    if (returnDataset.Tables[0].Rows.Count != 0)
				//    {
				//        if (!string.IsNullOrEmpty(returnDataset.Tables[0].Rows[0][0] + ""))
				//        {
				//            fullName = Convert.ToString(returnDataset.Tables[0].Rows[0][0]);
				//            fullName += "→" + organization.OrganizationName;
				//        }
				//        else
				//        {
				//            return returnRows;
				//        }
				//    }
				//    else
				//    {
				//        return returnRows;
				//    }
				//}
				#endregion
				// 编辑
				if (organization.OrganizationID > 0)
				{
					#region 组织机构下级存在有效子级，员工和用户的时候不允许被设置为无效
					if (organization.ValueFlag == 0)
					{
						string sqlString2 = "SELECT OrganizationCode  FROM TP_MST_Organization WHERE OrganizationCode LIKE '" + organization.OrganizationCode + "%'"
						+ "  AND LENGTH(OrganizationCode) >" + organization.OrganizationCode.Length + " AND ValueFlag = 1 AND AccountID =:AccountID";
						OracleParameter[] parmeters2 = new OracleParameter[]
								{
									new OracleParameter(":AccountID",organization.in_AccountID)
								};
						DataSet returnDataset = oracleTrConn.GetSqlResultToDs(sqlString2, parmeters2);
						if (returnDataset != null
								&& returnDataset.Tables.Count > 0
								&& returnDataset.Tables[0].Rows.Count > 0)
						{
							return -5;//// 子级中存在有效数据
						}
						string sqlString3 = "SELECT STAFFID"
													+ " FROM TP_HR_STAFF"
													+ " WHERE OrganizationID =:OrganizationID "
													+ " AND ValueFlag = 1";
						OracleParameter[] parmeters3 = new OracleParameter[]
								{
									new OracleParameter(":OrganizationID",organization.OrganizationID)
								};
						DataSet returnDataset3 = oracleTrConn.GetSqlResultToDs(sqlString3, parmeters3);
						if (returnDataset3 != null
								&& returnDataset3.Tables.Count > 0
								&& returnDataset3.Tables[0].Rows.Count > 0)
						{
							return -53;//// 当前数据状态不符合操作条件
						}
						string sqlString4 = "SELECT UserID"
											 + " FROM TP_MST_User"
											 + " WHERE OrganizationID =:OrganizationID "
											 + " AND ValueFlag = 1";
						OracleParameter[] parmeters4 = new OracleParameter[]
								{
									new OracleParameter(":OrganizationID",organization.OrganizationID)
								};
						DataSet returnDataset4 = oracleTrConn.GetSqlResultToDs(sqlString4, parmeters4);
						if (returnDataset3 != null
								&& returnDataset3.Tables.Count > 0
								&& returnDataset3.Tables[0].Rows.Count > 0)
						{
							return -8;//// // 操作数据不合法
						}
					}
					#endregion
					string sqlUpdateString = "UPDATE TP_MST_Organization SET "
										 + "OrganizationCode = :organizationCode"
										 + ",OrganizationName = :organizationName"
										 + ",OrganizationFullName = :organizationFullName"
										 + ",Leader = :leader"
										 + ",LetterMarket = :letterMarket"
										 + ",Telephone = :telephone"
										 + ",Address = :address"
										 + ",AccountID = :accountID"
										 + ",UpdateUserID =" + organization.in_UserID
										 + ",ValueFlag=" + organization.ValueFlag
										  + ",remarks=:remarks"
									 + " WHERE OrganizationID = :organizationID";
					//string[] sub = organization.OrganizationFullName.Split('→');
					//string oldOrganizationFullName = organization.OrganizationFullName;
					//if (sub.Length > 0)
					//{
					//    if (sub[sub.Length - 1] != organization.OrganizationName)
					//    {
					//        sub[sub.Length - 1] = organization.OrganizationName;
					//    }
					//    string newFullName = "";
					//    for (int i = 0; i < sub.Length; i++)
					//    {
					//        if (i != sub.Length - 1)
					//            newFullName += sub[i] + "→";
					//        else
					//            newFullName += sub[i];
					//    }
					//    organization.OrganizationFullName = newFullName;
					//}
					OracleParameter[] parmeters = new OracleParameter[]
										{
											new OracleParameter(":organizationCode",organization.OrganizationCode),
											new OracleParameter(":organizationName",organization.OrganizationName),
											new OracleParameter(":organizationFullName",organization.OrganizationFullName),
											new OracleParameter(":leader",organization.Leader),
											new OracleParameter(":letterMarket",organization.LetterMarket),
											new OracleParameter(":telephone",organization.Telephone),
											new OracleParameter(":address",organization.Address),
											new OracleParameter(":accountID",organization.in_AccountID),
											new OracleParameter(":remarks",organization.Remarks),
											new OracleParameter(":organizationID",organization.OrganizationID),
										};
					returnRows = oracleTrConn.ExecuteNonQuery(sqlUpdateString, parmeters);
					//                    string sqlUpdateOtherFullName = @"select tp_mst_organization.organizationid,tp_mst_organization.organizationfullname from tp_mst_organization
					//                                             where tp_mst_organization.accountID = " + organization.AccountID + " and tp_mst_organization.organizationcode like '" + organization.OrganizationCode + "%' and  organizationid<>" + organization.OrganizationID;
					//                    DataSet returnDataset5 = oracleTrConn.GetSqlResultToDs(sqlUpdateOtherFullName);
					//                    if (returnDataset5 != null && returnDataset5.Tables[0].Rows.Count > 0) // 更新所有子级
					//                    {
					//                        for (int i = 0; i < returnDataset5.Tables[0].Rows.Count; i++)
					//                        {
					//                            string sqlReplace = @"update tp_mst_organization set organizationfullname=replace(organizationfullname,:oldorganizationFullName,:neworganizationFullName)
					//                                                  where organizationid=:organizationid";
					//                            OracleParameter[] Updateparmeters = new OracleParameter[]
					//                                        {
					//                                            new OracleParameter(":oldorganizationFullName",oldOrganizationFullName),
					//                                            new OracleParameter(":neworganizationFullName",organization.OrganizationFullName),
					//                                            new OracleParameter(":organizationid",returnDataset5.Tables[0].Rows[i]["organizationid"].ToString()),
					//                                        };
					//                            oracleTrConn.ExecuteNonQuery(sqlReplace, Updateparmeters);
					//                        }
					//                    }
				}
				else
				{
					#region 判断上级组织机构是否已经被置为无效
					string sqlString11 = "SELECT ValueFlag FROM TP_MST_Organization"
												+ " WHERE OrganizationID = " + organization.ParentOrganizationID;
					DataSet returnDataset11 = oracleTrConn.GetSqlResultToDs(sqlString11);
					bool valueFlag = false;
					if (returnDataset11.Tables[0].Rows.Count != 0)
					{
						if (!string.IsNullOrEmpty(returnDataset11.Tables[0].Rows[0][0] + ""))
						{
							valueFlag = Convert.ToBoolean(Convert.ToInt32(returnDataset11.Tables[0].Rows[0][0]));
						}
					}
					if (!valueFlag)
					{
						return returnRows;
					}
					// 判断所选节点是已到最底层，不能新建
					if (7 <= organization.ParentOrganizationCode.Length / 3)
					{
						return returnRows;
					}
					// 上级部门包含的部门不能超过最大值999
					if (999 <= GetOrgLevelMax(oracleTrConn,
							 organization.ParentOrganizationCode, organization.in_AccountID.ToString()))
					{
						return returnRows;
					}
					// 判断选择的组织机构下是否有员工
					//if (IsExistStaff(oracleTrConn, organization.ParentOrganizationID, organization.in_AccountID.ToString()))
					//{
					//    return returnRows;
					//}
					#endregion
					string inString = "INSERT INTO TP_MST_Organization "
										  + "(OrganizationCode"
										  + ",OrganizationName"
										  + ",OrganizationFullName"
										  + ",Leader"
										  + ",LetterMarket"
										  + ",Telephone"
										  + ",Address"
										  + ",AccountID"
										  + ",ValueFlag"
										  + ",Remarks"
										  + ",CreateUserID"
										  + ",UpdateUserID,ISLEAFNODE)"
									  + " VALUES "
										 + "(:OrganizationCode"
										  + ",:organizationName"
										  + ",:organizationFullName"
										  + ",:leader"
										  + ",:letterMarket"
										  + ",:telephone"
										  + ",:address"
										  + ",:accountID"
										  + ",:valueFlag"
										  + ",:remarks"
										  + ",:createUserID"
										  + ",:updateUserID,1)";
					#region 获取组织机构编码
					string v_parentOrganizationCode = "";
					string sql1 = "SELECT  OrganizationCode FROM TP_MST_Organization"
											   + " WHERE OrganizationID = " + organization.ParentOrganizationID + " and AccountID = " + organization.in_AccountID;
					DataSet returnDatasetHuoQu = oracleTrConn.GetSqlResultToDs(sql1);
					if (returnDatasetHuoQu != null && returnDatasetHuoQu.Tables[0].Rows.Count > 0)
					{
						v_parentOrganizationCode = returnDatasetHuoQu.Tables[0].Rows[0]["OrganizationCode"].ToString();
					}

					string sql2 = "select  Max(OrganizationCode) from TP_MST_Organization "
									+ " where OrganizationCode like '" + v_parentOrganizationCode + "%'"
									+ "and length(OrganizationCode) = length('" + v_parentOrganizationCode + "')+3"
									+ "and AccountID = " + organization.in_AccountID;
					DataSet returnDatasetHuoQu2 = oracleTrConn.GetSqlResultToDs(sql2);
					string v_MaxOrganizationCode = "";
					if (returnDatasetHuoQu2 != null && returnDatasetHuoQu2.Tables[0].Rows.Count > 0)
					{
						v_MaxOrganizationCode = returnDatasetHuoQu2.Tables[0].Rows[0][0].ToString();
					}
					if (v_MaxOrganizationCode == "")
					{
						v_MaxOrganizationCode = v_MaxOrganizationCode + v_parentOrganizationCode + "001";
					}
					else
					{
						string v_tempCode = "";
						v_tempCode = Convert.ToString(Convert.ToInt32(v_MaxOrganizationCode.Substring(v_MaxOrganizationCode.Length - 3)) + 1);
						v_MaxOrganizationCode = "000" + v_tempCode;
						v_MaxOrganizationCode = v_parentOrganizationCode + v_MaxOrganizationCode.Substring(v_MaxOrganizationCode.Length - 3);
					}
					#endregion
					OracleParameter[] parmeters10 = new OracleParameter[]
										{
											new OracleParameter(":OrganizationCode",v_MaxOrganizationCode),
											new OracleParameter(":organizationName",organization.OrganizationName),
											new OracleParameter(":organizationFullName",organization.OrganizationName),
											new OracleParameter(":leader",organization.Leader),
											new OracleParameter(":letterMarket",organization.LetterMarket),
											new OracleParameter(":telephone",organization.Telephone),
											new OracleParameter(":address",organization.Address),
											new OracleParameter(":accountID",organization.in_AccountID),
											new OracleParameter(":valueFlag",organization.ValueFlag),
											new OracleParameter(":remarks",organization.Remarks),
											new OracleParameter(":createUserID",organization.in_UserID),
											new OracleParameter(":updateUserID",organization.in_UserID),
										};
					returnRows = oracleTrConn.ExecuteNonQuery(inString, parmeters10);
					//oracleTrConn.Commit();
					//oracleTrConn.Disconnect();
					//return returnRows;
				}

				string sqlString = "select t.organizationid from tp_mst_organization t where t.accountid = " + organization.in_AccountID
				+ " order by t.organizationcode";
				DataTable dt = oracleTrConn.GetSqlResultToDt(sqlString, null);

				if (dt != null && dt.Rows.Count > 0)
				{
					foreach (DataRow item in dt.Rows)
					{
						sqlString =
							"UPDATE tp_mst_organization t\n" +
							"   SET t.isleafnode          =\n" +
							"       (SELECT decode(COUNT(tlf.organizationid), 1, '1', '0')\n" +
							"          FROM tp_mst_organization tlf\n" +
							"         WHERE t.accountid = tlf.accountid\n" +
							"           AND tlf.valueflag = '1'\n" +
							"           AND INSTR(tlf.organizationcode, t.organizationcode) = 1)\n" +
							"      ,t.organizationfullname =\n" +
							"       (SELECT listagg(to_char(tfn.organizationname), '→') within GROUP(ORDER BY tfn.organizationcode)\n" +
							"          FROM tp_mst_organization tfn\n" +
							"         WHERE t.accountid = tfn.accountid\n" +
							"           AND INSTR(t.organizationcode, tfn.organizationcode) = 1)\n" +
							"   WHERE t.organizationid = :organizationid";
						OracleParameter[] parmeters = new OracleParameter[]
						{
							new OracleParameter(":organizationid",item["organizationid"]),
						};
						oracleTrConn.ExecuteNonQuery(sqlString, parmeters);
					}
				}

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

		/// <summary>
		/// 添加用户信息
		/// </summary>
		/// <param name="userInfo">用户实体</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		public static int AddUserInfo(SUserEntity userInfo, SUserInfo sUserInfo)
		{
			int returnUserID = 0;
			if (userInfo == null)
			{
				return returnUserID;
			}
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			oracleTrConn.Connect();
			try
			{
				string sqlString = "SELECT OrganizationCode FROM TP_MST_Organization WHERE OrganizationID = :organizationID";
				OracleParameter[] parmeters2 = new OracleParameter[]
							{
								new OracleParameter(":organizationID",userInfo.OrganizationID)
							};
				DataSet returnDataset = oracleTrConn.GetSqlResultToDs(sqlString, parmeters2);
				if (returnDataset.Tables[0].Rows.Count != 0)
				{
					if (returnDataset.Tables[0].Rows[0][0].ToString().Length == 3)
					{
						return -2;
					}
				}
				else
				{
					return -1;
				}
				string userTempID = oracleTrConn.GetSqlResultToStr("Select seq_mst_user_userid.nextval from dual");
				int affectRows = 0;
				string useridplus = Encryption.GetMD5String(userInfo.UserCode);

				string sqlString4 = "INSERT INTO TP_MST_User "
								   + "(UserID"
								   + ",UserCode"
								   + ",UserName"
								   + ",Password"
								   + ",OrganizationID"
								   + ",AccountID"
								   + ",AccountCode"
								   + ",ValueFlag"
								   + ",CreateUserID"
								   + ",UpdateUserID"
								   + ",CreateTime"
								   + ",UpdateTime"
								   + ",LimitMAC"
								   + ",LimitStartTime"
								   + ",LimitEndTime"
								   + ",CanSmartLogin"
								   + ",CanPCLogin"
								   + ",IsWorker"
								   + ",IsGroutingWorker"
								   + ",Remarks"
								   + ",ispublicbody"
								   + ",post"
								   + ",canloginprd"
								   + ",canloginmbc"
								   + ",BarcodePrinterID"
								   + ",PLCID"
								   + ",USERIDPLUS"
								   + ")"
						   + " VALUES( "
								   + ":userID"
								   + ",:userCode"
								   + ",:UserName"
								   + ",:Password"
								   + ",:organizationID"
								   + ",:accountID"
								   + ",:accountCode"
								   + ",:valueFlag"
								   + ",:createUserID"
								   + ",:updateUserID"
								   + ",sysdate"
								   + ",sysdate"
								   + ",:LimitMAC"
								   + ",:LimitStartTime"
								   + ",:LimitEndTime"
								   + ",:CanSmartLogin"
								   + ",:CanPCLogin"
								   + ",:IsWorker"
								   + ",:IsGroutingWorker"
								   + ",:Remarks"
								   + ",:ispublicbody"
								   + ",:post"
								   + ",:canloginprd"
								   + ",:canloginmbc"
								   + ",:BarcodePrinterID"
								   + ",:PLCID"
								   + ",:USERIDPLUS"
									+ ")";
				OracleParameter[] parmeters4 = new OracleParameter[]
						{
							new OracleParameter(":userID",userTempID),
							new OracleParameter(":userCode",userInfo.UserCode),
							new OracleParameter(":UserName",userInfo.UserName),
							new OracleParameter(":Password",userInfo.Password),
							new OracleParameter(":organizationID",userInfo.OrganizationID),
							new OracleParameter(":accountID",sUserInfo.AccountID),
							new OracleParameter(":accountCode",sUserInfo.AccountCode),
							new OracleParameter(":valueFlag",userInfo.ValueFlag),
							new OracleParameter(":createUserID", sUserInfo.UserID),
							new OracleParameter(":updateUserID", sUserInfo.UserID),
							new OracleParameter(":LimitMAC", userInfo.LimitMAC),
							new OracleParameter(":LimitStartTime",userInfo.LimitStartTime),
							new OracleParameter(":LimitEndTime",userInfo.LimitEndTime),
							new OracleParameter(":CanSmartLogin", userInfo.CanSmartLogin),
							new OracleParameter(":CanPCLogin", userInfo.CanPCLogin),
							new OracleParameter(":IsWorker", userInfo.IsWorker),
							new OracleParameter(":IsGroutingWorker", userInfo.IsGroutingWorker),
							new OracleParameter(":Remarks",userInfo.Remarks),
							new OracleParameter(":ispublicbody",userInfo.Ispublicbody),
							new OracleParameter(":post",userInfo.PostID),
							new OracleParameter(":canloginprd",userInfo.CanLoginPRD),
							new OracleParameter(":canloginmbc",userInfo.CanLoginMBC),
							new OracleParameter(":BarcodePrinterID",userInfo.BarcodePrinterID),
							new OracleParameter(":PLCID",userInfo.PLCID),
							new OracleParameter(":USERIDPLUS",useridplus)
						};
				affectRows = oracleTrConn.ExecuteNonQuery(sqlString4, parmeters4);
				//添加工号工种关联----庄天威 2014.10.23
				int jobsCount = 0;
				foreach (DataRow drFor in userInfo.UserJobs.Rows)
				{
					if (drFor.RowState != DataRowState.Deleted)
					{
						if (drFor["JobsID"] == DBNull.Value)
						{
							continue;
						}
						string sqlstring5 = @"Insert into TP_MST_UserJobs(UserID,JobsID,CreateUserID)
                            Values(:UserID,:JobsID,:CreateUserID)";
						OracleParameter[] parmeters5 = new OracleParameter[]
						{
							new OracleParameter(":UserID",userTempID),
							new OracleParameter(":JobsID",drFor["JobsID"].ToString()),
							new OracleParameter(":CreateUserID",sUserInfo.UserID),
						};
						jobsCount += oracleTrConn.ExecuteNonQuery(sqlstring5, parmeters5);
					}
				}

				int newuserid = Convert.ToInt32(userTempID);
				if (userInfo.UserID > 0)
				{
					OracleParameter[] parright = new OracleParameter[]
					{
						new OracleParameter(":newuserid",newuserid),
						new OracleParameter(":oruserid",userInfo.UserID),
						new OracleParameter(":createuserid",sUserInfo.UserID),
					};
					// 复制功能权限
					string sqlright = "insert into tp_mst_userright\n" +
					"  (userid, functioncode, createuserid)\n" +
					"select :newuserid, functioncode, :createuserid from tp_mst_userright ur\n" +
					" where ur.userid = :oruserid";
					oracleTrConn.ExecuteNonQuery(sqlright, parright);

					// 复制范围权限
					string sqlpurview = "insert into tp_mst_userpurview\n" +
					"  (userid, purviewid, purviewtype, createuserid)\n" +
					"select :newuserid, purviewid, purviewtype, :createuserid from tp_mst_userpurview up\n" +
					" where up.userid = :oruserid";
					oracleTrConn.ExecuteNonQuery(sqlpurview, parright);
				}

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

		/// <summary>
		/// 添加工号对应员工
		/// </summary>
		/// <param name="UserId">工号ID</param>
		/// <param name="StaffTable">员工数据表</param>
		/// <param name="userInfo">用户基本信息</param>
		/// <returns>int</returns>
		public static int AddUserStaff(int UserId, DataTable StaffTable, SUserInfo userInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				//操作工号工种关联----庄天威 2014.10.23
				int StaffCount = 0;
				foreach (DataRow drFor in StaffTable.Rows)
				{
					if (drFor.RowState == DataRowState.Added)
					{
						if (drFor["StaffID"] == DBNull.Value)
						{
							continue;
						}
						string sqlstring5 = @"Insert into TP_MST_UserStaff(UserID,UJobsID,StaffID,AccountID,CreateUserID,UpdateUserID)
                            Values(:UserID,:UJobsID,:StaffID,:AccountID,:CreateUserID,:UpdateUserID)";
						OracleParameter[] parmeters5 = new OracleParameter[]
						{
							new OracleParameter(":UserID",UserId),
							new OracleParameter(":UJobsID",drFor["UserJobsID"].ToString()),
							new OracleParameter(":StaffID",drFor["StaffID"].ToString()),
							new OracleParameter(":AccountID",userInfo.AccountID),
							new OracleParameter(":CreateUserID",userInfo.UserID),
							new OracleParameter(":UpdateUserID",userInfo.UserID),
						};
						StaffCount += oracleTrConn.ExecuteNonQuery(sqlstring5, parmeters5);

						//xuwei add 2020-10-14
						#region 同步插入tp_mst_workstationuserdetail,先删除再插入，省去更新操作
						oracleTrConn.ExecuteNonQuery(@"
                            DELETE 
                                TP_MST_WORKSTATIONUSERDETAIL 
                            WHERE 
                                USERID = :UserID
                                AND STAFFID = :StaffID
                            ",
							new OracleParameter[] {
								new OracleParameter(":UserID",UserId),
								new OracleParameter(":StaffID",drFor["StaffID"].ToString())
							});
						string UserCode = oracleTrConn.GetSqlResultToStr(@"
                            SELECT 
                                USERCODE
                            FROM 
                                TP_MST_USER
                            WHERE
                                USERID = :UserID
                            ", new OracleParameter[] {
								new OracleParameter(":UserID",UserId)
							});
						oracleTrConn.ExecuteNonQuery(@"
                            INSERT INTO TP_MST_WORKSTATIONUSERDETAIL (
                                USERID,USERCODE,STAFFID,
                                STAFFSTATUS,UJOBSID,
                                ACCOUNTID,CREATEUSERID,UPDATEUSERID
                            ) VALUES (
                                :UserID,:UserCode,:StaffID,
                                :StaffStatus,:UjobsID,
                                :AccountId,:CreateUserID,:UpdateUserID
                            )
                            ",
							new OracleParameter[] {
								new OracleParameter(":UserID",UserId),
								new OracleParameter(":UserCode",UserCode),
								new OracleParameter(":StaffID",drFor["StaffID"].ToString()),
								new OracleParameter(":StaffStatus","2"),
								new OracleParameter(":UjobsID",drFor["UserJobsId"].ToString()),
								new OracleParameter(":AccountId",userInfo.AccountID),
								new OracleParameter(":CreateUserID",userInfo.UserID),
								new OracleParameter(":UpdateUserID",userInfo.UserID),
							});
						#endregion
					}
					else if (drFor.RowState == DataRowState.Deleted)
					{
						string sqlstring5 = @"Delete from TP_MST_UserStaff Where UserStaffID=:UserStaffID";
						OracleParameter[] parmeters5 = new OracleParameter[]
						{
							new OracleParameter(":UserStaffID",drFor["InfoID",DataRowVersion.Original].ToString()),
						};
						StaffCount += oracleTrConn.ExecuteNonQuery(sqlstring5, parmeters5);

						//xuwei add 2020-10-14
						#region 同步删除tp_mst_workstationuserdetail
						oracleTrConn.ExecuteNonQuery(@"
                            DELETE 
                                TP_MST_WORKSTATIONUSERDETAIL 
                            WHERE 
                                USERID = :UserID
                                AND STAFFID = :StaffID
                            ",
							new OracleParameter[] {
								new OracleParameter(":UserID",UserId),
								new OracleParameter(":StaffID",drFor["StaffID",DataRowVersion.Original].ToString())
							});
						#endregion
					}
					else if (drFor.RowState == DataRowState.Modified)
					{
						string sqlstring5 = @"Update TP_MST_UserStaff
                                              Set UJobsID=:UJobsID,
                                              StaffID=:StaffID,
                                              UpdateUserID=:UpdateUserID,
                                              UpdateTime=sysdate
                                              Where UserStaffID=:UserStaffID";
						OracleParameter[] parmeters5 = new OracleParameter[]
						{
							new OracleParameter(":UJobsID",drFor["UserJobsId"].ToString()),
							new OracleParameter(":StaffID",drFor["StaffID"].ToString()),
							new OracleParameter(":UpdateUserID",userInfo.UserID),
							new OracleParameter(":UserStaffID",drFor["InfoID"].ToString())
						};
						StaffCount += oracleTrConn.ExecuteNonQuery(sqlstring5, parmeters5);

						//xuwei add 2020-10-14
						#region 同步更新 tp_mst_workstationuserdetail
						oracleTrConn.ExecuteNonQuery(@"
                            UPDATE TP_MST_WORKSTATIONUSERDETAIL 
                            SET
                                STAFFID = :StaffID,
                                UJOBSID = :UJobsID
                            WHERE 
                                USERID = :UserID
                                AND STAFFID = :OldStaffID
                            ",
							new OracleParameter[] {
								new OracleParameter(":UserID",UserId),
								new OracleParameter(":UJobsID",drFor["UserJobsId"].ToString()),
								new OracleParameter(":OldStaffID",drFor["StaffID",DataRowVersion.Original].ToString()),
								new OracleParameter(":StaffID",drFor["StaffID"].ToString())
							});
						#endregion

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

		/// <summary>
		/// 编辑用户信息
		/// </summary>
		/// <param name="userInfo">用户实体</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		public static int EditUserInfo(SUserEntity userInfo, SUserInfo sUserInfo)
		{
			int returnUserID = 0;
			if (userInfo == null)
			{
				return returnUserID;
			}
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			oracleTrConn.Connect();
			try
			{
				string sqlString = "SELECT OrganizationCode FROM TP_MST_Organization WHERE OrganizationID = :organizationID";
				OracleParameter[] parmeters2 = new OracleParameter[]
							{
								new OracleParameter(":organizationID",userInfo.OrganizationID)
							};
				DataSet returnDataset = oracleTrConn.GetSqlResultToDs(sqlString, parmeters2);
				if (returnDataset.Tables[0].Rows.Count != 0)
				{
					if (returnDataset.Tables[0].Rows[0][0].ToString().Length == 3)
					{
						oracleTrConn.Commit();
						oracleTrConn.Disconnect();
						return -2;
					}
				}
				else
				{
					oracleTrConn.Commit();
					oracleTrConn.Disconnect();
					return -1;
				}
				int affectRows = 0;
				string inString = "update TP_MST_User set "
										 + " UserCode=:UserCode"
										 + ",UserName=:UserName"
										 + ",OrganizationID=:OrganizationID"
										 + ",LimitMAC=:LimitMAC"
										 + ",LimitStartTime=:LimitStartTime"
										 + ",LimitEndTime=:LimitEndTime"
										 + ",CanSmartLogin=:CanSmartLogin"
										 + ",CanPCLogin=:CanPCLogin"
										 + ",Remarks=:Remarks"
										 + ",AccountID=:AccountID"
										 + ",AccountCode=:AccountCode"
										 + ",ValueFlag=:ValueFlag"
										 + ",UpdateTime=sysdate"
										 + ",IsWorker=:IsWorker"
										 + ",IsGroutingWorker=:IsGroutingWorker"
										 + ",ispublicbody=:ispublicbody"
										 + ",post=:post"
										 + ",canloginprd=:canloginprd"
										 + ",canloginmbc=:canloginmbc"
										 + ",BarcodePrinterID=:BarcodePrinterID"
										 + ",PLCID=:PLCID"
										 + ",UpdateUserID=:UpdateUserID where UserID=" + userInfo.UserID;
				OracleParameter[] parmeters10 = new OracleParameter[]
				{
					new OracleParameter(":UserCode",userInfo.UserCode),
					new OracleParameter(":UserName",userInfo.UserName),
					new OracleParameter(":OrganizationID",userInfo.OrganizationID),
					new OracleParameter(":LimitMAC",userInfo.LimitMAC),
					new OracleParameter(":LimitStartTime",userInfo.LimitStartTime),
					new OracleParameter(":LimitEndTime",userInfo.LimitEndTime),
					new OracleParameter(":CanSmartLogin",userInfo.CanSmartLogin),
					new OracleParameter(":CanPCLogin",userInfo.CanPCLogin),
					new OracleParameter(":Remarks",userInfo.Remarks),
					new OracleParameter(":AccountID",sUserInfo.AccountID),
					new OracleParameter(":AccountCode",sUserInfo.AccountCode),
					new OracleParameter(":ValueFlag",userInfo.ValueFlag),
					new OracleParameter(":UpdateUserID",sUserInfo.UserID),
					new OracleParameter(":IsWorker",userInfo.IsWorker),
					new OracleParameter(":IsGroutingWorker",userInfo.IsGroutingWorker),
					new OracleParameter(":ispublicbody",userInfo.Ispublicbody),
					new OracleParameter(":post",userInfo.PostID),
					new OracleParameter(":canloginprd",userInfo.CanLoginPRD),
					new OracleParameter(":canloginmbc",userInfo.CanLoginMBC),
					new OracleParameter(":BarcodePrinterID",userInfo.BarcodePrinterID),
					new OracleParameter(":PLCID",userInfo.PLCID),
				};
				affectRows = oracleTrConn.ExecuteNonQuery(inString, parmeters10);
				//编辑工号关联工种----庄天威 2014.10.24
				string deleteSql = "Delete from TP_MST_UserJobs where UserID=" + userInfo.UserID;
				int deleteRows = oracleTrConn.ExecuteNonQuery(deleteSql, null);
				int jobsCount = 0;
				foreach (DataRow drFor in userInfo.UserJobs.Rows)
				{
					if (drFor.RowState != DataRowState.Deleted)
					{
						if (drFor["JobsID"] == DBNull.Value)
						{
							continue;
						}
						string sqlstring5 = @"Insert into TP_MST_UserJobs(UserID,JobsID,CreateUserID)
                            Values(:UserID,:JobsID,:CreateUserID)";
						OracleParameter[] parmeters5 = new OracleParameter[]
						{
							new OracleParameter(":UserID",userInfo.UserID),
							new OracleParameter(":JobsID",drFor["JobsID"].ToString()),
							new OracleParameter(":CreateUserID",sUserInfo.UserID),
						};
						jobsCount += oracleTrConn.ExecuteNonQuery(sqlstring5, parmeters5);
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return affectRows;
			}
			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="UserID">用户ID</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		public static int UnlockUserStatus(int UserID, SUserInfo sUserInfo)
		{
			int returnRows = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			oracleTrConn.Connect();
			try
			{
				#region 对应要执行的SQL语句
				string sqlString = "update tp_mst_userlogin set locktime=null,islocked=0 where userid=:userid";
				Oracle.ManagedDataAccess.Client.OracleParameter[] paras = new Oracle.ManagedDataAccess.Client.OracleParameter[]
				{
					new Oracle.ManagedDataAccess.Client.OracleParameter(":userid", OracleDbType.Int32, UserID, ParameterDirection.Input)
				};
				#endregion
				returnRows = oracleTrConn.ExecuteNonQuery(sqlString, paras);
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnRows;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 用户范围权限保存
		/// </summary>
		/// <param name="userRightData">用户权限记录集</param>
		/// <param name="userID">用户ID</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		public static int SaveUserRight(DataSet userRightData, int userID, SUserInfo sUserInfo)
		{
			int returnRowCount = 0;//返回影响行数
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				string sql = "DELETE TP_MST_UserPurview WHERE UserID = :userID";
						   //+ " AND PurviewType = :PurviewType ";
				Oracle.ManagedDataAccess.Client.OracleParameter[] paras = new Oracle.ManagedDataAccess.Client.OracleParameter[]
				{
					new Oracle.ManagedDataAccess.Client.OracleParameter(":PurviewType",2),
					new Oracle.ManagedDataAccess.Client.OracleParameter(":userID",userID)
				};
				returnRowCount += oracleTrConn.ExecuteNonQuery(sql, paras);//删除以前所设置的权限
				// 顺序插入现有的权限数据
				DataSet dsExist = null;
				for (int i = 0; i < userRightData.Tables.Count - 2; i++)
				{
					// 对每一种权限进行遍历
					foreach (DataRow dataRow in userRightData.Tables[i].Rows)
					{
						if (Convert.ToBoolean(dataRow["RightFlag"]))
						{
							if (Convert.ToInt32(dataRow["PurviewID"]) == -1)
							{
								sql = "select 1 from TP_MST_UserPurview where UserID=:UserID and PurviewID=:PurviewID and PurviewType=:PurviewType";
								paras = new Oracle.ManagedDataAccess.Client.OracleParameter[]
							   {
								   new Oracle.ManagedDataAccess.Client.OracleParameter(":UserID",userID),
								   new Oracle.ManagedDataAccess.Client.OracleParameter(":PurviewID", Convert.ToInt32(dataRow["PurviewID"])),
								   new Oracle.ManagedDataAccess.Client.OracleParameter(":PurviewType",Convert.ToInt32(dataRow["PurviewType"])),
							   };
								dsExist = oracleTrConn.GetSqlResultToDs(sql, paras);
								if (dsExist != null && dsExist.Tables[0].Rows.Count == 0)
								{
									sql = "INSERT INTO TP_MST_UserPurview"
								   + "(UserID"
								   + " ,PurviewID"
								   + " ,PurviewType "
								   + " ,CreateUserID) "
								   + " VALUES "
									+ "(:UserID"
								   + " ,:PurviewID"
								   + " ,:PurviewType"
								   + " ,:CreateUserID) ";
									paras = new Oracle.ManagedDataAccess.Client.OracleParameter[]
						   {
							   new Oracle.ManagedDataAccess.Client.OracleParameter(":UserID",userID),
							   new Oracle.ManagedDataAccess.Client.OracleParameter(":PurviewID", Convert.ToInt32(dataRow["PurviewID"])),
							   new Oracle.ManagedDataAccess.Client.OracleParameter(":PurviewType",Convert.ToInt32(dataRow["PurviewType"])),
							   new Oracle.ManagedDataAccess.Client.OracleParameter(":CreateUserID",sUserInfo.UserID),
						   };
									returnRowCount += oracleTrConn.ExecuteNonQuery(sql, paras);
								}

							}
							else
							{

								sql = "INSERT INTO TP_MST_UserPurview"
								   + "(UserID"
								   + " ,PurviewID"
								   + " ,PurviewType "
								   + " ,CreateUserID) "
								   + " VALUES "
									+ "(:UserID"
								   + " ,:PurviewID"
								   + " ,:PurviewType"
								   + " ,:CreateUserID) ";
								paras = new Oracle.ManagedDataAccess.Client.OracleParameter[]
						   {
							   new Oracle.ManagedDataAccess.Client.OracleParameter(":UserID",userID),
							   new Oracle.ManagedDataAccess.Client.OracleParameter(":PurviewID", Convert.ToInt32(dataRow["PurviewID"])),
							   new Oracle.ManagedDataAccess.Client.OracleParameter(":PurviewType",Convert.ToInt32(dataRow["PurviewType"])),
							   new Oracle.ManagedDataAccess.Client.OracleParameter(":CreateUserID",sUserInfo.UserID),
						   };
								returnRowCount += oracleTrConn.ExecuteNonQuery(sql, paras);
							}
						}
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnRowCount;
			}
			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="userRightData">用户权限记录集</param>
		/// <param name="userID">用户ID</param>
		/// <param name="licenseType">License授权方式：1→按站点  2→按用户</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>
		/// 执行更新影响的数据行数
		/// 大于0：正常操作，返回
		/// 等于0：无任何影响行数
		/// -1：更新的功能权限有超过授权站点数
		/// </returns>
		public static FunRightResultEntity SaveUserFunctionRight(DataSet userRightData, int userID, int licenseType, SUserInfo sUserInfo)
		{
			FunRightResultEntity result = new FunRightResultEntity();
			result.OperationStatus = 0;
			result.LicenseFunctions = "";
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				if (userRightData == null || userRightData.Tables.Count < 1 || userID < 1)
				{
					return result;
				}
				oracleTrConn.Connect();
				#region 删除数据
				//string sqlString1 = "DELETE TP_MST_UserRight WHERE UserID = :pUserID";
				//Oracle.ManagedDataAccess.Client.OracleParameter[] paras1 = new Oracle.ManagedDataAccess.Client.OracleParameter[] 
				//    {
				//        new Oracle.ManagedDataAccess.Client.OracleParameter(":pUserID", OracleDbType.Int32, userID, ParameterDirection.Input)
				//    };
				//result.OperationStatus += oracleTrConn.ExecuteNonQuery(sqlString1, paras1);
				#endregion
				#region  增加新的数据
				// 对现有功能权限进行遍历
				foreach (DataRow dataRow in userRightData.Tables[0].Rows)
				{
					string sqlString1 = "DELETE TP_MST_UserRight WHERE UserID = :pUserID and FunctionCode=:FunctionCode";
					Oracle.ManagedDataAccess.Client.OracleParameter[] paras1 = new Oracle.ManagedDataAccess.Client.OracleParameter[]
					{
						new Oracle.ManagedDataAccess.Client.OracleParameter(":pUserID", OracleDbType.Int32, userID, ParameterDirection.Input),
						new Oracle.ManagedDataAccess.Client.OracleParameter(":FunctionCode", OracleDbType.Varchar2, dataRow["FunctionCode"], ParameterDirection.Input)
					};
					result.OperationStatus += oracleTrConn.ExecuteNonQuery(sqlString1, paras1);
					if (dataRow["Choose"].ToString() == "1")
					{
						string sqlString2 = "INSERT INTO TP_MST_UserRight "
											+ "(UserID"
											+ ",FunctionCode"
											+ ",CreateUserID)"
										+ " VALUES "
											+ "(:pUserID"
											+ ",:pFunctionCode"
											+ ",:pCreateUserID)";
						Oracle.ManagedDataAccess.Client.OracleParameter[] paras2 = new Oracle.ManagedDataAccess.Client.OracleParameter[]
							{
								new Oracle.ManagedDataAccess.Client.OracleParameter(":pUserID", OracleDbType.Int32, userID, ParameterDirection.Input),
								new Oracle.ManagedDataAccess.Client.OracleParameter(":pFunctionCode",OracleDbType.Varchar2, dataRow["FunctionCode"].ToString(), ParameterDirection.Input),
								new Oracle.ManagedDataAccess.Client.OracleParameter(":pCreateUserID", OracleDbType.Int32, sUserInfo.UserID, ParameterDirection.Input)
							};
						result.OperationStatus += oracleTrConn.ExecuteNonQuery(sqlString2, paras2);
					}
				}
				#endregion
				#region 按站点授权时，需要检查每一个站点是否超出授权数
				//if (licenseType == Constant.SYSTEM_LICENSETYPE_BASE_FUNCTION)
				//{
				//    // 需要对更改的权限进行限制检查，查询已经使用的功能数量
				//    string sqlString3 = "SELECT C.FunctionCode, COUNT(C.UserID) UseNum"
				//        + " FROM TP_MST_UserRight C INNER JOIN T_MST_User  D ON C.UserID = D.UserID"
				//        + " INNER JOIN T_SYS_FUNCTION  E ON C.FunctionCode = E.FunctionCode"
				//        + " WHERE D.ValueFlag > 0 AND (E.FunctionFlag = 1) GROUP BY C.FunctionCode";
				//    DataTable dtUserRightNum = oracleTrConn.GetSqlResultToDt(sqlString3);

				//    bool isExistOverLicenseNumber = false;
				//    foreach (DataRow newRowNum in dtUserRightNum.Rows)
				//    {
				//        #region 比对是否超出了授权数量
				//        DataRow[] dataRow = userRightData.Tables[0].Select("FunctionCode = " + newRowNum["FunctionCode"].ToString() + "");
				//        if (dataRow.Length > 0)
				//        {
				//            /*暂时撤销=，否则使用数等于授权数时保存提示超出授权数 BY 陈建 2014-03-15 Start here*/
				//            //if (Convert.ToInt32(dataRow[0]["LicensesNumber"]) <= Convert.ToInt32(sqlDataReader["UseNum"]))
				//            if (Convert.ToInt32(dataRow[0]["LicensesNumber"]) < Convert.ToInt32(newRowNum["UseNum"]))
				//            /*暂时撤销=，否则使用数等于授权数时保存提示超出授权数 BY 陈建 2014-03-15 End here*/
				//            {
				//                isExistOverLicenseNumber = true;
				//                if (string.IsNullOrEmpty(overLicenseNumberFunctions))
				//                {
				//                    result.LicenseFunctions = "[" + dataRow[0]["FunctionCode"].ToString() + "] "
				//                                                                        + dataRow[0]["FunctionName"].ToString();
				//                }
				//                else
				//                {
				//                    result.LicenseFunctions += "; [" + dataRow[0]["FunctionCode"].ToString() + "] "
				//                                                                        + dataRow[0]["FunctionName"].ToString();
				//                }
				//            }
				//        }
				//        #endregion
				//    }                        

				//    // 存在超过授权站点数的情况，直接返回
				//    if (isExistOverLicenseNumber)
				//    {
				//        oracleTrConn.Rollback();
				//        oracleTrConn.Disconnect();
				//        result.OperationStatus = -1;
				//        return result;
				//    }
				//}
				#endregion
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return result;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存用户的功能权限
		/// </summary>
		/// <param name="userRightData">用户权限记录集</param>
		/// <param name="userID">用户ID</param>
		/// <param name="licenseType">License授权方式：1→按站点  2→按用户</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>
		/// 执行更新影响的数据行数
		/// 大于0：正常操作，返回
		/// 等于0：无任何影响行数
		/// -1：更新的功能权限有超过授权站点数
		/// </returns>
		public static FunRightResultEntity SaveUserFunctionTwoRight(DataSet userRightData, int userID, int licenseType, SUserInfo sUserInfo, DataSet userRightTwoData)
		{
			FunRightResultEntity result = new FunRightResultEntity();
			result.OperationStatus = 0;
			result.LicenseFunctions = "";
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				if (userRightData == null || userRightData.Tables.Count < 1 || userID < 1)
				{
					return result;
				}
				oracleTrConn.Connect();
				#region 删除数据
				//string sqlString1 = "DELETE TP_MST_UserRight WHERE UserID = :pUserID";
				//Oracle.ManagedDataAccess.Client.OracleParameter[] paras1 = new Oracle.ManagedDataAccess.Client.OracleParameter[] 
				//    {
				//        new Oracle.ManagedDataAccess.Client.OracleParameter(":pUserID", OracleDbType.Int32, userID, ParameterDirection.Input)
				//    };
				//result.OperationStatus += oracleTrConn.ExecuteNonQuery(sqlString1, paras1);
				#endregion
				#region  增加新的数据
				// 对现有功能权限进行遍历
				int allFlag = 0;
				foreach (DataRow dataRow in userRightData.Tables[0].Rows)
				{
					string sqlString1 = "DELETE TP_MST_UserRight WHERE UserID = :pUserID and FunctionCode=:FunctionCode";
					Oracle.ManagedDataAccess.Client.OracleParameter[] paras1 = new Oracle.ManagedDataAccess.Client.OracleParameter[]
					{
						new Oracle.ManagedDataAccess.Client.OracleParameter(":pUserID", OracleDbType.Int32, userID, ParameterDirection.Input),
						new Oracle.ManagedDataAccess.Client.OracleParameter(":FunctionCode", OracleDbType.Varchar2, dataRow["FunctionCode"], ParameterDirection.Input)
					};
					result.OperationStatus += oracleTrConn.ExecuteNonQuery(sqlString1, paras1);
					if (dataRow["Choose"].ToString() == "1" || dataRow["FunctionCode"].ToString() == "[ALL]")
					{
						string sqlString2 = "INSERT INTO TP_MST_UserRight "
											+ "(UserID"
											+ ",FunctionCode"
											+ ",CreateUserID)"
										+ " VALUES "
											+ "(:pUserID"
											+ ",:pFunctionCode"
											+ ",:pCreateUserID)";
						Oracle.ManagedDataAccess.Client.OracleParameter[] paras2 = new Oracle.ManagedDataAccess.Client.OracleParameter[]
							{
								new Oracle.ManagedDataAccess.Client.OracleParameter(":pUserID", OracleDbType.Int32, userID, ParameterDirection.Input),
								new Oracle.ManagedDataAccess.Client.OracleParameter(":pFunctionCode",OracleDbType.Varchar2, dataRow["FunctionCode"].ToString(), ParameterDirection.Input),
								new Oracle.ManagedDataAccess.Client.OracleParameter(":pCreateUserID", OracleDbType.Int32, sUserInfo.UserID, ParameterDirection.Input)
							};
						result.OperationStatus += oracleTrConn.ExecuteNonQuery(sqlString2, paras2);
					}
					if (dataRow["FunctionCode"].ToString() == "[ALL]")
					{
						allFlag = 1;
					}
				}
				if (allFlag < 1)
				{
					string sqlString3 = "DELETE TP_MST_UserRight WHERE UserID = :pUserID and FunctionCode=:FunctionCode";
					Oracle.ManagedDataAccess.Client.OracleParameter[] paras3 = new Oracle.ManagedDataAccess.Client.OracleParameter[]
					{
						new Oracle.ManagedDataAccess.Client.OracleParameter(":pUserID", OracleDbType.Int32, userID, ParameterDirection.Input),
						new Oracle.ManagedDataAccess.Client.OracleParameter(":FunctionCode", OracleDbType.Varchar2, "[ALL]", ParameterDirection.Input)
					};
					result.OperationStatus += oracleTrConn.ExecuteNonQuery(sqlString3, paras3);
				}
				#endregion

				// 二期
				#region  增加新的数据
				// 对现有功能权限进行遍历
				//foreach (DataRow dataRow in userRightTwoData.Tables[0].Rows)
				//{
				//    if (dataRow["Choose"].ToString() == "1" || dataRow["FunctionCode"].ToString() == "[ALL2]")
				//    {
				//        string sqlString2 = "INSERT INTO TP_MST_UserRight "
				//                            + "(UserID"
				//                            + ",FunctionCode"
				//                            + ",CreateUserID)"
				//                        + " VALUES "
				//                            + "(:pUserID"
				//                            + ",:pFunctionCode"
				//                            + ",:pCreateUserID)";
				//        Oracle.ManagedDataAccess.Client.OracleParameter[] paras2 = new Oracle.ManagedDataAccess.Client.OracleParameter[] 
				//            {
				//                new Oracle.ManagedDataAccess.Client.OracleParameter(":pUserID", OracleDbType.Int32, userID, ParameterDirection.Input),
				//                new Oracle.ManagedDataAccess.Client.OracleParameter(":pFunctionCode",OracleDbType.Varchar2, dataRow["FunctionCode"].ToString(), ParameterDirection.Input),
				//                new Oracle.ManagedDataAccess.Client.OracleParameter(":pCreateUserID", OracleDbType.Int32, sUserInfo.UserID, ParameterDirection.Input)
				//            };
				//        result.OperationStatus += oracleTrConn.ExecuteNonQuery(sqlString2, paras2);
				//    }
				//}
				#endregion

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

		/// <summary>
		/// 编辑用户密码
		/// </summary>
		/// <param name="userPassWord">用户密码</param>
		/// <param name="userCode">用户编码</param>
		/// <param name="userName">用户名称</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>string</returns>
		public static string SaveUserPassWord(string userPassWord, string userCode, string userName, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				string strPassWord = Encryption.GetMD5String(userPassWord);
				oracleTrConn.Connect();
				#region 更新TP_MST_User表的密码
				string sqlString1 = " UPDATE TP_MST_User SET Password =:passWord WHERE UserCode =:UserCode and accountid=:accountid";
				OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":accountid",sUserInfo.AccountID),
							new OracleParameter(":passWord",strPassWord),
							new OracleParameter(":UserCode",userCode),
                            //new OracleParameter(":UserName",userName)
                        };
				#endregion
				oracleTrConn.ExecuteNonQuery(sqlString1, parmeters1);
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				//sUserInfo.SetUserInfoPassWord(strPassWord);
				return strPassWord;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存帐套相关信息
		/// </summary>
		/// <param name="accountData">帐套数据集合</param>
		/// <param name="defaultPassword">默认密码</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>1 存在相同的帐套代码 2表示有数据被修改 3表示没有数据被修改</returns>
		public static int SaveAccountData(DataTable accountData, string defaultPassword, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (accountData == null && accountData.Rows.Count < 0)
				{
					return 3;
				}
				int intResult = 2;
				oracleTrConn.Connect();
				#region 对要保存的帐套数据进行必要的验证
				foreach (DataRow dataRow in accountData.Rows)
				{
					// 新建帐套
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的帐套代码
						string sqlString1 = "SELECT Count(*) FROM TP_MST_Account WHERE AccountCode = :accountCode";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":accountCode",dataRow["AccountCode"].ToString())
						};
						string strTemp1 = oracleTrConn.GetSqlResultToStr(sqlString1, parmeters1);
						if (strTemp1 != "0")
						{
							intResult = 1;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的帐套代码
						string sqlString2 = "SELECT Count(*) FROM TP_MST_Account WHERE AccountCode = :accountCode and AccountID <> :accountID";
						OracleParameter[] parmeters2 = new OracleParameter[]
						{
							new OracleParameter(":accountCode",dataRow["AccountCode"].ToString()),
							new OracleParameter(":accountID",dataRow["AccountID"])
						};
						string strTemp1 = oracleTrConn.GetSqlResultToStr(sqlString2, parmeters2);
						if (strTemp1 != "0")
						{
							intResult = 1;
							break;
						}
						#endregion
					}
				}
				if (intResult == 1)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return intResult;
				}
				#endregion
				string accountID = "";  // 存储新插入帐套ID
				string orgID = "";  // 存储新插入部门ID
				string userID = "";     //用户ID
				foreach (DataRow dataRow in accountData.Rows)
				{
					// 新建帐套
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增帐套信息
						accountID = oracleTrConn.GetSqlResultToStr("SELECT SEQ_MST_ACCOUNT_ACCOUNTID.nextval FROM dual");

						#region 向T_MST_Account插入数据
						string sqlString1 = "INSERT INTO TP_MST_Account "
												+ "(AccountId"
												+ ",AccountCode"
												+ ",AccountName"
												+ ",Remarks"
												+ ",ValueFlag"
												+ ",CreateUserID"
												+ ",UpdateUserID)"
										+ " VALUES "
												+ "(:accountId"
												+ ",:accountCode"
												+ ",:accountName"
												+ ",:remarks"
												+ ",:valueFlag"
												+ ",:createUserID"
												+ ",:updateUserID)";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":accountId", OracleDbType.Int32, accountID, ParameterDirection.Input),
							new OracleParameter(":accountCode",OracleDbType.Varchar2, dataRow["AccountCode"].ToString(), ParameterDirection.Input),
							new OracleParameter(":accountName",OracleDbType.NVarchar2, dataRow["AccountName"].ToString(), ParameterDirection.Input),
							new OracleParameter(":remarks",OracleDbType.NVarchar2, dataRow["Remarks"].ToString(), ParameterDirection.Input),
							new OracleParameter(":valueFlag", OracleDbType.Char, "1", ParameterDirection.Input),
							new OracleParameter(":createUserID", OracleDbType.Int32,sUserInfo.UserID, ParameterDirection.Input),
							new OracleParameter(":updateUserID", OracleDbType.Int32,sUserInfo.UserID, ParameterDirection.Input)
						};
						oracleTrConn.ExecuteNonQuery(sqlString1, parmeters1);
						#endregion

						orgID = oracleTrConn.GetSqlResultToStr("SELECT SEQ_MST_ORGANIZATION_ID.nextval FROM dual");

						#region 根据新插入的帐套ID，生成该帐套下的组织机构001部门
						string sqlString2 = "INSERT INTO TP_MST_Organization "
									+ "(OrganizationID"
									+ ",OrganizationCode"
									+ ",OrganizationName"
									+ ",OrganizationFullName"
									+ ",Address"
									+ ",AccountID"
									+ ",ValueFlag"
									+ ",CreateUserID"
									+ ",UpdateUserID"
									+ ",IsLeafNode)"
								+ " VALUES "
									+ "(:organizationID"
									+ ",:organizationCode"
									+ ",:organizationName"
									+ ",:organizationfullName"
									+ ",:address"
									+ ",:accountID"
									+ ",:valueFlag"
									+ ",:createUserID"
									+ ",:updateUserID"
									+ ",:isLeafNode)";
						OracleParameter[] parmeters2 = new OracleParameter[]
						{
							new OracleParameter(":organizationID", Convert.ToInt32(orgID)),
							new OracleParameter(":organizationCode","001"),
							new OracleParameter(":organizationName",dataRow["AccountName"].ToString()),
							new OracleParameter(":organizationfullName",dataRow["AccountName"].ToString()),
							new OracleParameter(":address","-"),
							new OracleParameter(":accountID",Convert.ToInt32(accountID)),
							new OracleParameter(":valueFlag","1"),
							new OracleParameter(":createUserID",sUserInfo.UserID),
							new OracleParameter(":updateUserID",sUserInfo.UserID),
							new OracleParameter(":isLeafNode","0")
						};
						oracleTrConn.ExecuteNonQuery(sqlString2, parmeters2);
						#endregion

						string orgID2 = oracleTrConn.GetSqlResultToStr("SELECT SEQ_MST_ORGANIZATION_ID.nextval FROM dual");

						#region 根据新插入的帐套ID，生成该帐套下的组织机构001001部门
						string sqlString21 = "INSERT INTO TP_MST_Organization "
									+ "(OrganizationID"
									+ ",OrganizationCode"
									+ ",OrganizationName"
									+ ",OrganizationFullName"
									+ ",Address"
									+ ",AccountID"
									+ ",ValueFlag"
									+ ",CreateUserID"
									+ ",UpdateUserID"
									+ ",IsLeafNode)"
								+ " VALUES "
									+ "(:organizationID"
									+ ",:organizationCode"
									+ ",:organizationName"
									+ ",:organizationfullName"
									+ ",:address"
									+ ",:accountID"
									+ ",:valueFlag"
									+ ",:createUserID"
									+ ",:updateUserID"
									+ ",:isLeafNode)";
						OracleParameter[] parmeters21 = new OracleParameter[]
						{
							new OracleParameter(":organizationID", Convert.ToInt32(orgID2)),
							new OracleParameter(":organizationCode","001001"),
							new OracleParameter(":organizationName",dataRow["AccountName"].ToString()),
							new OracleParameter(":organizationfullName",dataRow["AccountName"].ToString()+"→"+dataRow["AccountName"].ToString()),
							new OracleParameter(":address","-"),
							new OracleParameter(":accountID",Convert.ToInt32(accountID)),
							new OracleParameter(":valueFlag","1"),
							new OracleParameter(":createUserID",sUserInfo.UserID),
							new OracleParameter(":updateUserID",sUserInfo.UserID),
							new OracleParameter(":isLeafNode","1")
						};
						oracleTrConn.ExecuteNonQuery(sqlString21, parmeters21);
						#endregion

						userID = oracleTrConn.GetSqlResultToStr("SELECT SEQ_MST_USER_USERID.nextval FROM dual");

						#region 根据新插入的帐套ID和部门ID 生成admin用户
						string sqlString4 = "INSERT INTO TP_MST_User "
									+ "(UserID"
									+ ",UserCode"
									+ ",UserName"
									+ ",Password"
									+ ",OrganizationID"
									+ ",AccountID"
									+ ",AccountCode"
									+ ",ValueFlag"
									+ ",CreateUserID"
									+ ",UpdateUserID"
									//+ ",Relatedobjecttype"
									+ ",CanSmartLogin"
									+ ",CanPCLogin"
									+ ",IsWorker)"
							+ " VALUES ("
									+ ":userID"
									+ ",:userCode"
									+ ",:UserName"
									+ ",:Password"
									+ ",:organizationID"
									+ ",:accountID"
									+ ",:accountCode"
									+ ",:valueFlag"
									+ ",:createUserID"
									+ ",:updateUserID"
									//+ ",:relatedobjecttype"
									+ ",'0'"
									+ ",'1'"
									+ ",'0'"
									//+ " FROM TP_MST_Account WHERE AccountID=:accountID";
									+ ")";
						OracleParameter[] parmeters4 = new OracleParameter[]
						{
							new OracleParameter(":userID",Convert.ToInt32(userID)),
							new OracleParameter(":userCode","admin"),
							new OracleParameter(":UserName","系统管理员"),
							new OracleParameter(":Password",defaultPassword),
							new OracleParameter(":organizationID",Convert.ToInt32(orgID)),
							new OracleParameter(":accountID",Convert.ToInt32(accountID)),
							new OracleParameter(":accountCode",dataRow["AccountCode"].ToString()),
							new OracleParameter(":valueFlag","1"),
							new OracleParameter(":createUserID", sUserInfo.UserID),
							new OracleParameter(":updateUserID", sUserInfo.UserID),
                            //new OracleParameter(":relatedobjecttype", 1)
                        };
						oracleTrConn.ExecuteNonQuery(sqlString4, parmeters4);
						#endregion

						#region 根据新插入的帐套ID 生成业务系统参数数据
						string sqlString6 = "INSERT INTO TP_MST_SYSTEMSETTING "
									+ "("
									+ "SETTINGCODE"
									+ ",SETTINGNAME"
									+ ",CATEGORYNAME"
									+ ",SETTINGVALUE"
									+ ",SETTINGDEFAULTVALUES"
									+ ",ACCOUNTID"
									+ ",REMARKS"
									+ ",TOOLTIP"
									+ ",EDITFLAG"
									+ ",UPDATEUSERID"
									+ ")"
							+ " SELECT "
									+ "SETTINGCODE"
									+ ",SETTINGNAME"
									+ ",CATEGORYNAME"
									//+ ",SETTINGVALUE"
									+ ",SETTINGDEFAULTVALUES"
									+ ",SETTINGDEFAULTVALUES"
									+ ",:accountID"
									+ ",REMARKS"
									+ ",TOOLTIP"
									+ ",EDITFLAG"
									+ ",:updateUserID"
							+ " FROM TP_MST_SystemSetting "
							//+ " WHERE AccountID IN (SELECT AccountID FROM TP_MST_User WHERE userCode=:userCode)";
							+ " WHERE AccountID = :systemaccountID";
						OracleParameter[] parmeters6 = new OracleParameter[]
						{
							new OracleParameter(":accountID",Convert.ToInt32(accountID)),
							new OracleParameter(":updateUserID",sUserInfo.UserID),
                            //new OracleParameter(":userCode","system")
                            new OracleParameter(":systemaccountID",sUserInfo.AccountID)
						};
						oracleTrConn.ExecuteNonQuery(sqlString6, parmeters6);
						#endregion

						#region  根据新插入的帐套ID 生成系统日期信息
						string sqlString7 = "INSERT INTO TP_MST_SYSTEMDATE "
								+ "("
								+ "SYSTEMDATETYPE"
								+ ",DATEVALUE"
								+ ",REMARKS"
								+ ",ACCOUNTID"
								+ ",UPDATEUSERID"
								+ ")"
							+ " SELECT "
								+ "SYSTEMDATETYPE"
								+ ",TRUNC(sysdate)"
								+ ",REMARKS"
								+ ",:accountid"
								+ ",:UPDATEUSERID"
							+ " FROM TP_MST_SYSTEMDATE WHERE AccountID = :sysaccountid";
						OracleParameter[] parmeters7 = new OracleParameter[]
						{
							new OracleParameter(":accountid",Convert.ToInt32(accountID)),
							new OracleParameter(":UPDATEUSERID",sUserInfo.UserID),
							new OracleParameter(":sysaccountid",sUserInfo.AccountID),
						};
						oracleTrConn.ExecuteNonQuery(sqlString7, parmeters7);
						#endregion

						#region  根据新插入的产品类别数据信息
						string sqlString8 = "INSERT INTO TP_MST_GoodsType "
									+ "("
									+ "GOODSTYPECODE"
									+ ",GOODSTYPENAME"
									+ ",GOODSTYPEFULLNAME"
									+ ",ISLEAFNODE"
									+ ",REMARKS"
									+ ",ACCOUNTID"
									+ ",VALUEFLAG"
									//+ ",CREATETIME"
									+ ",CREATEUSERID"
									+ ",UPDATEUSERID"
									+ ") "
							+ " VALUES( "
								+ "'001'"
								+ ",'产品类别'"
								+ ",'产品类别'"
								+ ",'0'"
								+ ",null"
								+ ",:accountid"
								+ ",'1'"
								//+ ",sysdate"
								+ ",:createUserid"
								+ ",:updateUserid"
						   // + " FROM TP_MST_GoodsType WHERE ACCOUNTID IN (SELECT AccountID FROM TP_MST_User WHERE userCode=:userCode)";
						   + ")";
						OracleParameter[] parmeters8 = new OracleParameter[]
						{
							new OracleParameter(":accountid",Convert.ToInt32(accountID)),
							new OracleParameter(":createUserid",sUserInfo.UserID),
							new OracleParameter(":updateUserid",sUserInfo.UserID),
                           // new OracleParameter(":userCode","system")
                        };
						oracleTrConn.ExecuteNonQuery(sqlString8, parmeters8);

						string sqlString81 = "INSERT INTO TP_MST_GoodsType "
									+ "("
									+ "GOODSTYPECODE"
									+ ",GOODSTYPENAME"
									+ ",GOODSTYPEFULLNAME"
									+ ",ISLEAFNODE"
									+ ",REMARKS"
									+ ",ACCOUNTID"
									+ ",VALUEFLAG"
									//+ ",CREATETIME"
									+ ",CREATEUSERID"
									+ ",UPDATEUSERID"
									+ ") "
							+ " VALUES( "
								+ "'001001'"
								+ ",'大件'"
								+ ",'产品类别→大件'"
								+ ",'1'"
								+ ",null"
								+ ",:accountid"
								+ ",'1'"
								//+ ",sysdate"
								+ ",:createUserid"
								+ ",:updateUserid"
						   // + " FROM TP_MST_GoodsType WHERE ACCOUNTID IN (SELECT AccountID FROM TP_MST_User WHERE userCode=:userCode)";
						   + ")";
						OracleParameter[] parmeters81 = new OracleParameter[]
						{
							new OracleParameter(":accountid",Convert.ToInt32(accountID)),
							new OracleParameter(":createUserid",sUserInfo.UserID),
							new OracleParameter(":updateUserid",sUserInfo.UserID),
                           // new OracleParameter(":userCode","system")
                        };
						oracleTrConn.ExecuteNonQuery(sqlString81, parmeters81);

						string sqlString82 = "INSERT INTO TP_MST_GoodsType "
									+ "("
									+ "GOODSTYPECODE"
									+ ",GOODSTYPENAME"
									+ ",GOODSTYPEFULLNAME"
									+ ",ISLEAFNODE"
									+ ",REMARKS"
									+ ",ACCOUNTID"
									+ ",VALUEFLAG"
									//+ ",CREATETIME"
									+ ",CREATEUSERID"
									+ ",UPDATEUSERID"
									+ ") "
							+ " VALUES( "
								+ "'001002'"
								+ ",'小件'"
								+ ",'产品类别→小件'"
								+ ",'1'"
								+ ",null"
								+ ",:accountid"
								+ ",'1'"
								//+ ",sysdate"
								+ ",:createUserid"
								+ ",:updateUserid"
						   // + " FROM TP_MST_GoodsType WHERE ACCOUNTID IN (SELECT AccountID FROM TP_MST_User WHERE userCode=:userCode)";
						   + ")";
						OracleParameter[] parmeters82 = new OracleParameter[]
						{
							new OracleParameter(":accountid",Convert.ToInt32(accountID)),
							new OracleParameter(":createUserid",sUserInfo.UserID),
							new OracleParameter(":updateUserid",sUserInfo.UserID),
                           // new OracleParameter(":userCode","system")
                        };
						oracleTrConn.ExecuteNonQuery(sqlString82, parmeters82);
						#endregion

						#region  根据新插入的产品分级数据信息
						string sqlString9 = "INSERT INTO TP_MST_GoodsLevel "
									+ "("
									+ "GoodsLevelName,"
									+ "GoodsLevelTypeID,"
									+ "IsSemiFinishedEx,"
									+ "SFEDisplayNo,"
									+ "IsFinishedEx,"
									+ "FEDisplayNo,"
									+ "IsFinished,"
									+ "IsScrapped,"
									+ "CanDisable,"
									+ "Remarks,"
									+ "AccountID,"
									+ "ValueFlag,"
									+ "CreateUserID,"
									+ "UpdateUserID"
									+ ") "
							+ " SELECT "
								+ "GoodsLevelTypeName,"
								+ "GoodsLevelTypeID,"
									+ "IsSemiFinishedEx,"
									+ "SFEDisplayNo,"
									+ "IsFinishedEx,"
									+ "FEDisplayNo,"
									+ "IsFinished,"
									+ "IsScrapped,"
									+ "CanDisable,"
									+ "Remarks,"
									+ ":accountID,"
									+ "'1',"
								+ ":createUserid,"
								+ ":updateUserid"
							+ " FROM TP_SYS_GoodsLevelType";
						OracleParameter[] parmeters9 = new OracleParameter[]
						{
							new OracleParameter(":accountID",Convert.ToInt32(accountID)),
							new OracleParameter(":createUserid",sUserInfo.UserID),
							new OracleParameter(":updateUserid",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlString9, parmeters9);
						#endregion

						#region  报销 结算方式
						string sqlString10 =
							@"insert into TB_MST_SETTLEMENTTYPE
                              (SETTLEMENTTYPENAME,
                               ISCURRENCYSETTLEMENT,
                               REMARKS,
                               ACCOUNTID,
                               VALUEFLAG,
                               CREATEUSERID,
                               UPDATEUSERID,
                               SUBJECTID)
                            values
                              ('(报销)', '0', '报销平账时用', :ACCOUNTID, '9', :createUserid, :createUserid, null)";
						OracleParameter[] parmeters10 = new OracleParameter[]
						{
							new OracleParameter(":ACCOUNTID",Convert.ToInt32(accountID)),
							new OracleParameter(":createUserid",sUserInfo.UserID),
						};
						oracleTrConn.ExecuteNonQuery(sqlString10, parmeters10);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新帐套信息
						string sqlString = "UPDATE TP_MST_Account SET "
											// 编码不允许修改
											//+ " AccountCode = :accountCode,"
											+ " AccountName = :accountName,"
											+ " Remarks = :remarks,"
											+ " ValueFlag = :valueFlag,"
											//+ " UpdateTime = :updateTime,"
											+ " UpdateUserID = :updateUserID"
											+ " WHERE AccountID = :accountID";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
                            //new OracleParameter(":accountCode",dataRow["AccountCode"].ToString()),
                            new OracleParameter(":accountName",dataRow["AccountName"].ToString()),
							new OracleParameter(":remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":valueFlag",dataRow["ValueFlag"].ToString()),
                            //new OracleParameter(":updateTime",DateTime.Now),
                            new OracleParameter(":updateUserID",sUserInfo.UserID),
							new OracleParameter(":accountID",dataRow["AccountID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlString, parmeters1);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return intResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		#endregion

		#region 报表工序基础信息

		/// <summary>
		/// 新建报表数据来源
		/// </summary>
		/// <param name="rptProcedureEntity">新建实体</param>
		/// <param name="dsSourse">工序数据源</param>
		/// <param name="userInfo">当前用户信息</param>
		/// <returns>
		/// 受影响行数
		/// </returns>
		public static int AddRptProcedure(RptProcedureEntity rptProcedureEntity, DataSet dsSourse, SUserInfo userInfo)
		{
			int RowsCount = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				StringBuilder sbSql = new StringBuilder();

				#region  添加报表数据来源信息
				//获取序列ID
				sbSql.Clear();
				sbSql.Append("select SEQ_MST_RPTPROCEDURE_ID.NEXTVAL from dual");
				int rptProcedureId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
				//添加缺陷扣罚策略主体信息
				sbSql.Clear();
				sbSql.Append(@"Insert into TP_MST_RptProcedure
                               (RptProcedureID,RptProcedureCode,RptProcedureName,RptProcedureType,
                               AccountID,
                               CreateUserID,UpdateUserID,displayno)
                               Values
                               (:RptProcedureID,:RptProcedureCode,:RptProcedureName,
                               :RptProcedureType,:AccountID,                               
                               :CreateUserID,:UpdateUserID,:displayno)");
				OracleParameter[] rptProcedureParas = new OracleParameter[] {
							new OracleParameter(":RptProcedureID",OracleDbType.Int32,
							rptProcedureId,ParameterDirection.Input),
							new OracleParameter(":RptProcedureCode",OracleDbType.NVarchar2,
							rptProcedureEntity.RptProcedureCode,ParameterDirection.Input),
							new OracleParameter(":RptProcedureName",OracleDbType.NVarchar2,
							rptProcedureEntity.RptProcedureName,ParameterDirection.Input),
							new OracleParameter(":RptProcedureType",OracleDbType.NVarchar2,
							rptProcedureEntity.RptProcedureTpye,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(":displayno",OracleDbType.Int32,
							rptProcedureEntity.DisplayNo,ParameterDirection.Input),
				};
				//连接数据库并返回结果
				RowsCount = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), rptProcedureParas);
				#endregion

				#region  添加数据来源工序信息
				if (dsSourse != null)
				{
					DataTable dtrptSProcedure = dsSourse.Tables[Constant.INT_IS_ZERO];
					foreach (DataRow drFor in dtrptSProcedure.Rows)
					{
						sbSql.Clear();
						//获得序列
						sbSql.Append("select SEQ_MST_RPTSPROCEDURE_ID.NEXTVAL from dual");
						int rptSProcedureId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
						//添加信息
						sbSql.Clear();
						sbSql.Append(@"Insert into TP_MST_RptSProcedure
                               (RptSProcedureID,ProcedureID,
                                ProcedureCode,ProcedureName,
                               RptProcedureID,
                               CreateUserID)
                               Values
                               (:RptSProcedureID,:ProcedureID,:ProcedureCode,
                               :ProcedureName,:RptProcedureID,:CreateUserID)");
						OracleParameter[] rptSProcedureParas = new OracleParameter[] {
							new OracleParameter(":RptSProcedureID",OracleDbType.Int32,
							rptSProcedureId,ParameterDirection.Input),
							new OracleParameter(":ProcedureID",OracleDbType.Int32,
							drFor["ProcedureID"],ParameterDirection.Input),
							new OracleParameter(":ProcedureCode",OracleDbType.NVarchar2,
							drFor["ProcedureCode"],ParameterDirection.Input),
							new OracleParameter(":ProcedureName",OracleDbType.NVarchar2,
							drFor["ProcedureName"],ParameterDirection.Input),
							new OracleParameter(":RptProcedureID",OracleDbType.Int32,
							rptProcedureId,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							};
						//连接数据库并返回结果
						RowsCount += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), rptSProcedureParas);
					}
				}
				#endregion

				#region  添加数据统计工序信息
				if (dsSourse != null)
				{
					DataTable dtrptTProcedure = dsSourse.Tables[Constant.INT_IS_ONE];
					foreach (DataRow drFor in dtrptTProcedure.Rows)
					{
						sbSql.Clear();
						//获得序列
						sbSql.Append("select SEQ_MST_RPTTPROCEDURE_ID.NEXTVAL from dual");
						int rptTProcedureId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
						//添加信息
						sbSql.Clear();
						sbSql.Append(@"Insert into TP_MST_RptTProcedure
                               (RptTProcedureID,ProcedureID,
                                ProcedureCode,ProcedureName,
                               RptProcedureID,
                               CreateUserID)
                               Values
                               (:RptTProcedureID,:ProcedureID,:ProcedureCode,
                               :ProcedureName,:RptProcedureID,:CreateUserID)");
						OracleParameter[] rptTProcedureParas = new OracleParameter[] {
							new OracleParameter(":RptTProcedureID",OracleDbType.Int32,
							rptTProcedureId,ParameterDirection.Input),
							new OracleParameter(":ProcedureID",OracleDbType.Int32,
							drFor["ProcedureID"],ParameterDirection.Input),
							new OracleParameter(":ProcedureCode",OracleDbType.NVarchar2,
							drFor["ProcedureCode"],ParameterDirection.Input),
							new OracleParameter(":ProcedureName",OracleDbType.NVarchar2,
							drFor["ProcedureName"],ParameterDirection.Input),
							new OracleParameter(":RptProcedureID",OracleDbType.Int32,
							rptProcedureId,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							};
						//连接数据库并返回结果
						RowsCount += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), rptTProcedureParas);
					}
				}
				#endregion

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

		/// <summary>
		/// 修改报表数据来源
		/// </summary>
		/// <param name="rptProcedureEntity">新建实体</param>
		/// <param name="dsSourse">工序数据源</param>
		/// <param name="userInfo">当前用户信息</param>
		/// <returns>
		/// 受影响行数
		/// </returns>
		public static int UpdateRptProcedure(RptProcedureEntity rptProcedureEntity, DataSet dsSourse, SUserInfo userInfo)
		{
			int RowsCount = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				StringBuilder sbSql = new StringBuilder();

				#region  修改报表数据来源信息
				//修改报表数据来源信息
				sbSql.Clear();
				sbSql.Append(@"Update TP_MST_RptProcedure
                               Set RptProcedureCode=:RptProcedureCode,
                                   RptProcedureName=:RptProcedureName,
                                   RptProcedureType=:RptProcedureType,
                                   UpdateUserID=:UpdateUserID,
                                   displayno=:displayno
                             Where RptProcedureID=:RptProcedureID
                               And OPTimeStamp=:OPTimeStamp");
				OracleParameter[] rptProcedureParas = new OracleParameter[] {
							new OracleParameter(":RptProcedureCode",OracleDbType.NVarchar2,
							rptProcedureEntity.RptProcedureCode,ParameterDirection.Input),
							new OracleParameter(":RptProcedureName",OracleDbType.NVarchar2,
							rptProcedureEntity.RptProcedureName,ParameterDirection.Input),
							new OracleParameter(":RptProcedureType",OracleDbType.NVarchar2,
							rptProcedureEntity.RptProcedureTpye,ParameterDirection.Input),
							new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							new OracleParameter(":RptProcedureID",OracleDbType.Int32,
							rptProcedureEntity.RptProcedureID,ParameterDirection.Input),
							new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							rptProcedureEntity.OPTimeStamp,ParameterDirection.Input),
							   new OracleParameter(":displayno",OracleDbType.Int32,
							rptProcedureEntity.DisplayNo,ParameterDirection.Input),
				};
				//连接数据库并返回结果
				RowsCount = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), rptProcedureParas);

				#endregion

				if (RowsCount == 1)
				{
					if (dsSourse != null)
					{
						#region 编辑数据来源工序信息
						DataTable dtrptSProcedure = dsSourse.Tables[Constant.INT_IS_ZERO];
						foreach (DataRow drFor in dtrptSProcedure.Rows)
						{
							if (drFor.RowState == DataRowState.Added) //添加
							{
								sbSql.Clear();
								//获得序列
								sbSql.Append("select SEQ_MST_RPTSPROCEDURE_ID.NEXTVAL from dual");
								int rptSProcedureId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
								//添加信息
								sbSql.Clear();
								sbSql.Append(@"Insert into TP_MST_RptSProcedure
                               (RptSProcedureID,ProcedureID,
                                ProcedureCode,ProcedureName,
                               RptProcedureID,
                               CreateUserID)
                               Values
                               (:RptSProcedureID,:ProcedureID,:ProcedureCode,
                               :ProcedureName,:RptProcedureID,:CreateUserID)");
								OracleParameter[] rptSProcedureParas = new OracleParameter[] {
							new OracleParameter(":RptSProcedureID",OracleDbType.Int32,
							rptSProcedureId,ParameterDirection.Input),
							new OracleParameter(":ProcedureID",OracleDbType.Int32,
							drFor["ProcedureID"],ParameterDirection.Input),
							new OracleParameter(":ProcedureCode",OracleDbType.NVarchar2,
							drFor["ProcedureCode"],ParameterDirection.Input),
							new OracleParameter(":ProcedureName",OracleDbType.NVarchar2,
							drFor["ProcedureName"],ParameterDirection.Input),
							new OracleParameter(":RptProcedureID",OracleDbType.Int32,
							rptProcedureEntity.RptProcedureID,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							};
								//连接数据库并返回结果
								RowsCount += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), rptSProcedureParas);
							}
							else if (drFor.RowState == DataRowState.Modified)
							{
								//修改报表数据来源信息
								sbSql.Clear();
								sbSql.Append(@"Update TP_MST_RptSProcedure
                               Set ProcedureID=:ProcedureID,
                                   ProcedureCode=:ProcedureCode,
                                   ProcedureName=:ProcedureName
                             Where RptSProcedureID=:RptSProcedureID");
								OracleParameter[] rptProcedureUpdateParas = new OracleParameter[] {
							new OracleParameter(":ProcedureID",OracleDbType.Int32,
							drFor["ProcedureID"],ParameterDirection.Input),
							new OracleParameter(":ProcedureCode",OracleDbType.NVarchar2,
							drFor["ProcedureCode"],ParameterDirection.Input),
							new OracleParameter(":ProcedureName",OracleDbType.NVarchar2,
							drFor["ProcedureName"],ParameterDirection.Input),
							new OracleParameter(":RptSProcedureID",OracleDbType.Int32,
							drFor["RptSProcedureID"],ParameterDirection.Input),
							 };
								//连接数据库并返回结果
								RowsCount = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), rptProcedureUpdateParas);
							}
							else if (drFor.RowState == DataRowState.Deleted)
							{
								sbSql.Clear();
								sbSql.Append(@"Delete From TP_MST_RptSProcedure
                                       Where RptSProcedureID = :RptSProcedureID
                                       ");
								OracleParameter[] rptProcedureDelParas = new OracleParameter[] {
							new OracleParameter(":RptSProcedureID",OracleDbType.Int32,
							drFor["RptSProcedureID",DataRowVersion.Original],ParameterDirection.Input),
							};
								RowsCount += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), rptProcedureDelParas);
							}
						}
						#endregion

						#region 编辑数据统计工序信息
						DataTable dtrptTProcedure = dsSourse.Tables[Constant.INT_IS_ONE];
						foreach (DataRow drFor in dtrptTProcedure.Rows)
						{
							if (drFor.RowState == DataRowState.Added) //添加
							{
								sbSql.Clear();
								//获得序列
								sbSql.Append("select SEQ_MST_RPTTPROCEDURE_ID.NEXTVAL from dual");
								int rptTProcedureId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
								//添加信息
								sbSql.Clear();
								sbSql.Append(@"Insert into TP_MST_RptTProcedure
                               (RptTProcedureID,ProcedureID,
                                ProcedureCode,ProcedureName,
                               RptProcedureID,
                               CreateUserID)
                               Values
                               (:RptTProcedureID,:ProcedureID,:ProcedureCode,
                               :ProcedureName,:RptProcedureID,:CreateUserID)");
								OracleParameter[] rptSProcedureParas = new OracleParameter[] {
							new OracleParameter(":RptTProcedureID",OracleDbType.Int32,
							rptTProcedureId,ParameterDirection.Input),
							new OracleParameter(":ProcedureID",OracleDbType.Int32,
							drFor["ProcedureID"],ParameterDirection.Input),
							new OracleParameter(":ProcedureCode",OracleDbType.NVarchar2,
							drFor["ProcedureCode"],ParameterDirection.Input),
							new OracleParameter(":ProcedureName",OracleDbType.NVarchar2,
							drFor["ProcedureName"],ParameterDirection.Input),
							new OracleParameter(":RptProcedureID",OracleDbType.Int32,
							rptProcedureEntity.RptProcedureID,ParameterDirection.Input),
							new OracleParameter(":CreateUserID",OracleDbType.Int32,
							userInfo.UserID,ParameterDirection.Input),
							};
								//连接数据库并返回结果
								RowsCount += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), rptSProcedureParas);
							}
							else if (drFor.RowState == DataRowState.Modified)
							{
								//修改报表数据来源信息
								sbSql.Clear();
								sbSql.Append(@"Update TP_MST_RptTProcedure
                               Set ProcedureID=:ProcedureID,
                                   ProcedureCode=:ProcedureCode,
                                   ProcedureName=:ProcedureName
                             Where RptTProcedureID=:RptTProcedureID");
								OracleParameter[] rptProcedureUpdateParas = new OracleParameter[] {
							new OracleParameter(":ProcedureID",OracleDbType.Int32,
							drFor["ProcedureID"],ParameterDirection.Input),
							new OracleParameter(":ProcedureCode",OracleDbType.NVarchar2,
							drFor["ProcedureCode"],ParameterDirection.Input),
							new OracleParameter(":ProcedureName",OracleDbType.NVarchar2,
							drFor["ProcedureName"],ParameterDirection.Input),
							new OracleParameter(":RptTProcedureID",OracleDbType.Int32,
							drFor["RptTProcedureID"],ParameterDirection.Input),
							 };
								//连接数据库并返回结果
								RowsCount = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), rptProcedureUpdateParas);
							}
							else if (drFor.RowState == DataRowState.Deleted)
							{
								sbSql.Clear();
								sbSql.Append(@"Delete From TP_MST_RptTProcedure
                                       Where RptTProcedureID = :RptTProcedureID
                                       ");
								OracleParameter[] rptProcedureDelParas = new OracleParameter[] {
							new OracleParameter(":RptTProcedureID",OracleDbType.Int32,
							drFor["RptTProcedureID",DataRowVersion.Original],ParameterDirection.Input),
							};
								RowsCount += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), rptProcedureDelParas);
							}
						}
						#endregion
					}
				}

				if (RowsCount == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				else
				{
					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="rptProcedureEntity">新建实体</param>
		/// <param name="userInfo">当前用户信息</param>
		/// <returns>
		/// 受影响行数
		/// </returns>
		public static int StopRptProcedure(RptProcedureEntity rptProcedureEntity, SUserInfo userInfo)
		{
			int RowsCount = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			ServiceResultEntity srEntity = new ServiceResultEntity();
			try
			{
				oracleTrConn.Connect();
				StringBuilder sbSql = new StringBuilder();

				#region  修改报表数据来源信息
				//修改报表数据来源信息
				sbSql.Clear();
				sbSql.Append(@"Update TP_MST_RptProcedure
                               Set ValueFlag = 0
                             Where RptProcedureID=:RptProcedureID
                               And OPTimeStamp=:OPTimeStamp");
				OracleParameter[] rptDelParas = new OracleParameter[] {

							new OracleParameter(":RptProcedureID",OracleDbType.NVarchar2,
							rptProcedureEntity.RptProcedureID,ParameterDirection.Input),
							new OracleParameter(":OPTimeStamp",OracleDbType.TimeStamp,
							rptProcedureEntity.OPTimeStamp,ParameterDirection.Input),
				};
				//连接数据库并返回结果
				RowsCount = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), rptDelParas);

				#endregion

				if (RowsCount == 1)
				{
					#region 删除相关工序信息

					sbSql.Clear();
					sbSql.Append(@"Delete From TP_MST_RptSProcedure
                                       Where RptProcedureID = :RptProcedureID
                                       ");
					OracleParameter[] DeleteRptSParas = new OracleParameter[] {
							new OracleParameter(":RptProcedureID",OracleDbType.Int32,
							rptProcedureEntity.RptProcedureID,ParameterDirection.Input),
						};
					RowsCount += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DeleteRptSParas);

					sbSql.Clear();
					sbSql.Append(@"Delete From TP_MST_RptTProcedure
                                       Where RptProcedureID = :RptProcedureID
                                       ");
					OracleParameter[] DeleteRPTTParas = new OracleParameter[] {
							new OracleParameter(":RptProcedureID",OracleDbType.Int32,
							rptProcedureEntity.RptProcedureID,ParameterDirection.Input),
						};
					//删除质量考核产品明细数据（右边对应列数据）
					RowsCount += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DeleteRPTTParas);

					#endregion
				}

				//如果插入失败则回滚事务并关闭
				if (RowsCount == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				else
				{
					oracleTrConn.Commit();
					oracleTrConn.Disconnect();
				}
				return RowsCount;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				srEntity.Exception = ex;
				srEntity.Status = Constant.ServiceResultStatus.SystemError;
				return RowsCount;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}



		#endregion

		#region 私有方法

		/// <summary>
		/// 获取上级组织机构中已经存在的组织机构数量
		/// </summary>
		/// <param name="oracleTrConn">事务</param>
		/// <param name="parentCode">上级部门Code</param>
		/// <param name="AccountID">帐套ID</param>
		/// <returns>int组织机构数量</returns>
		private static int GetOrgLevelMax(IDBTransaction oracleTrConn,
			string parentCode, string AccountID)
		{
			try
			{
				string sqlString = "SELECT MAX(OrganizationCode)"
					   + " FROM TP_MST_Organization"
					   + " WHERE OrganizationCode LIKE '" + parentCode + "%'"
					   + " AND LENGTH(OrganizationCode) = LENGTH('" + parentCode + "') + 3"
					   + " AND AccountID = " + AccountID;
				DataSet returnDataset = oracleTrConn.GetSqlResultToDs(sqlString);
				int orgCount = 0;
				if (returnDataset.Tables[0].Rows.Count != 0)
				{
					if (!string.IsNullOrEmpty(returnDataset.Tables[0].Rows[0][0] + ""))
					{
						string orgCode = Convert.ToString(returnDataset.Tables[0].Rows[0][0]);
						string tmpCode = orgCode.Substring(orgCode.Length - 3);
						orgCount = Convert.ToInt32(tmpCode);
					}
				}
				return orgCount;
			}
			catch (Exception ex)
			{
				throw ex;
			}
		}

		/// <summary>
		/// 判断该组织机构下是否存在员工
		/// </summary>
		/// <param name="oracleTrConn">事务</param>
		/// <param name="organizationID">组织机构ID</param>
		/// <param name="AccountID">帐套ID</param>
		/// <returns>
		/// true:存在
		/// false:不存在
		/// </returns>
		private static bool IsExistStaff(IDBTransaction oracleTrConn,
			int organizationID, string AccountID)
		{
			try
			{
				string sqlString = "SELECT STAFFID FROM TP_HR_STAFF"
					 + " WHERE OrganizationID = " + organizationID;
				DataSet returnDataset = oracleTrConn.GetSqlResultToDs(sqlString);
				if (returnDataset != null
					&& returnDataset.Tables.Count > 0
					&& returnDataset.Tables[0].Rows.Count > 0)
				{
					return true;
				}
				return false;
			}
			catch (Exception ex)
			{
				throw ex;
			}
		}

		#endregion

		/// <summary>
		/// 保存缺陷类别数据
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="dataDefectData">缺陷类别数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2014.09.10          任海          新建
		/// </remarks>
		public static int SaveDefectTypeData(DataTable dataDefectData, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (dataDefectData == null && dataDefectData.Rows.Count < Constant.INT_IS_ZERO)
				{
					return 0;
				}
				int returnResult = 1;
				oracleTrConn.Connect();

				#region 对要保存的产品缺陷数据进行必要的验证
				foreach (DataRow dataRow in dataDefectData.Rows)
				{
					// 新建产品缺陷
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的产品缺陷类别名称
						string sqlString = "SELECT Count(*) FROM TP_MST_DefectType WHERE AccountID = :AccountID and DefectTypeName =:DefectTypeName ";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":DefectTypeName",dataRow["DefectTypeName"].ToString())
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlString, oracleParameter);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = -1;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的产品缺陷类别名称
						string sqlStrings = "SELECT Count(*) FROM TP_MST_DefectType WHERE AccountID = :AccountID and DefectTypeName = :DefectTypeName and DefectTypeID <> :DefectTypeID";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":DefectTypeName",dataRow["DefectTypeName"]),
							new OracleParameter(":DefectTypeID",dataRow["DefectTypeID"])
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlStrings, oracleParameters);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = -1;
							break;
						}
						#endregion
					}
				}
				if (returnResult == -1)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnResult;
				}
				#endregion
				foreach (DataRow dataRow in dataDefectData.Rows)
				{
					// 新建产品缺陷
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增产品缺陷信息

						#region 向TP_MST_Defect插入数据
						string sqlInsertString = "INSERT INTO TP_MST_DefectType"
												+ "(DefectTypeName"
												+ ",DisplayNo"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:DefectTypeName"
												+ ",:DisplayNo"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":DefectTypeName",dataRow["DefectTypeName"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"]),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameter);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新产品缺陷信息
						string sqlUpdateString = "UPDATE TP_MST_DefectType SET "
											+ " DefectTypeName = :DefectTypeName,"
											+ " DisplayNo = :DisplayNo,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE DefectTypeID = :DefectTypeID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":DefectTypeName",dataRow["DefectTypeName"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"]),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":DefectTypeID",dataRow["DefectTypeID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParameter);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除产品缺陷信息
						string sqlDeleteString = "DELETE TP_MST_DefectType  WHERE DefectTypeID = :DefectTypeID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":DefectTypeID",dataRow["DefectTypeID",DataRowVersion.Original].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlDeleteString, oracleParameter);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存用户的功能权限
		/// </summary>
		/// </returns>
		public static FunRightResultEntity SaveUserFunctionRightList(DataTable userRightData, SUserInfo sUserInfo)
		{
			FunRightResultEntity result = new FunRightResultEntity();
			result.OperationStatus = 0;
			result.LicenseFunctions = "";
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				if (userRightData == null || userRightData.Rows.Count < 1)
				{
					return result;
				}
				oracleTrConn.Connect();
				//#region 删除数据
				//string sqlString1 = "DELETE TP_MST_UserRight WHERE UserID = :pUserID";
				//Oracle.ManagedDataAccess.Client.OracleParameter[] paras1 = new Oracle.ManagedDataAccess.Client.OracleParameter[] 
				//    {
				//        new Oracle.ManagedDataAccess.Client.OracleParameter(":pUserID", OracleDbType.Int32, userID, ParameterDirection.Input)
				//    };
				//#endregion
				//result.OperationStatus += oracleTrConn.ExecuteNonQuery(sqlString1, paras1);
				#region  增加新的数据
				// 对现有功能权限进行遍历
				foreach (DataRow dataRow in userRightData.Rows)
				{
					if (dataRow.RowState == DataRowState.Added)
					{
						string sqlString2 = "INSERT INTO TP_MST_UserRight "
											+ "(UserID"
											+ ",FunctionCode"
											+ ",CreateUserID)"
										+ " VALUES "
											+ "(:pUserID"
											+ ",:pFunctionCode"
											+ ",:pCreateUserID)";
						Oracle.ManagedDataAccess.Client.OracleParameter[] paras2 = new Oracle.ManagedDataAccess.Client.OracleParameter[]
							{
								new Oracle.ManagedDataAccess.Client.OracleParameter(":pUserID", OracleDbType.Int32, dataRow["UserID"], ParameterDirection.Input),
								new Oracle.ManagedDataAccess.Client.OracleParameter(":pFunctionCode",OracleDbType.Varchar2, dataRow["FunctionCode"].ToString(), ParameterDirection.Input),
								new Oracle.ManagedDataAccess.Client.OracleParameter(":pCreateUserID", OracleDbType.Int32, sUserInfo.UserID, ParameterDirection.Input)
							};
						result.OperationStatus += oracleTrConn.ExecuteNonQuery(sqlString2, paras2);
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						string sqlDelete = "delete from TP_MST_UserRight where UserID=:UserID and FunctionCode=:FunctionCode";
						Oracle.ManagedDataAccess.Client.OracleParameter[] paras2Delete = new Oracle.ManagedDataAccess.Client.OracleParameter[]
							{
								new Oracle.ManagedDataAccess.Client.OracleParameter(":UserID", OracleDbType.Int32, dataRow["UserID",DataRowVersion.Original], ParameterDirection.Input),
								new Oracle.ManagedDataAccess.Client.OracleParameter(":FunctionCode",OracleDbType.Varchar2, dataRow["FunctionCode",DataRowVersion.Original].ToString(), ParameterDirection.Input),
							};
						result.OperationStatus += oracleTrConn.ExecuteNonQuery(sqlDelete, paras2Delete);
					}

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

		/// <summary>
		/// 用户范围权限保存
		/// </summary>
		/// <param name="userRightData">用户权限记录集</param>
		/// <param name="userID">用户ID</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		public static int SaveUserRightList(DataTable userRightData, SUserInfo sUserInfo)
		{
			int returnRowCount = 0;//返回影响行数
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();

				foreach (DataRow dataRow in userRightData.Rows)
				{

					if (dataRow.RowState == DataRowState.Added)
					{
						if (Convert.ToInt32(dataRow["PurviewType"]) != -99)
						{
							string sqlString2 = "INSERT INTO TP_MST_UserPurview"
								   + "(UserID"
								   + " ,PurviewID"
								   + " ,PurviewType "
								   + " ,CreateUserID) "
								   + " VALUES "
									+ "(:UserID"
								   + " ,:PurviewID"
								   + " ,:PurviewType"
								   + " ,:CreateUserID) ";

							Oracle.ManagedDataAccess.Client.OracleParameter[] paras2 = new Oracle.ManagedDataAccess.Client.OracleParameter[]
						   {
							   new Oracle.ManagedDataAccess.Client.OracleParameter(":UserID",Convert.ToInt32(dataRow["UserID"])),
							   new Oracle.ManagedDataAccess.Client.OracleParameter(":PurviewID", Convert.ToInt32(dataRow["PurviewID"])),
							   new Oracle.ManagedDataAccess.Client.OracleParameter(":PurviewType",Convert.ToInt32(dataRow["PurviewType"])),
							   new Oracle.ManagedDataAccess.Client.OracleParameter(":CreateUserID",sUserInfo.UserID),
						   };
							returnRowCount += oracleTrConn.ExecuteNonQuery(sqlString2, paras2);
						}

					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						string sqlDelete = "delete from TP_MST_UserPurview where UserID=:UserID and PurviewID=:PurviewID and PurviewType=:PurviewType";
						Oracle.ManagedDataAccess.Client.OracleParameter[] paras2Delete = new Oracle.ManagedDataAccess.Client.OracleParameter[]
							{
								new Oracle.ManagedDataAccess.Client.OracleParameter(":UserID", OracleDbType.Int32, dataRow["UserID",DataRowVersion.Original], ParameterDirection.Input),
								new Oracle.ManagedDataAccess.Client.OracleParameter(":PurviewID",OracleDbType.Int32, dataRow["PurviewID",DataRowVersion.Original].ToString(), ParameterDirection.Input),
								new Oracle.ManagedDataAccess.Client.OracleParameter(":PurviewType",OracleDbType.Int32, dataRow["PurviewType",DataRowVersion.Original].ToString(), ParameterDirection.Input),
							};
						returnRowCount += oracleTrConn.ExecuteNonQuery(sqlDelete, paras2Delete);
					}
				}
				//// 顺序插入现有的权限数据
				//for (int i = 0; i < userRightData.Rows.Count; i++)
				//{
				//    // 对每一种权限进行遍历
				//    foreach (DataRow dataRow in userRightData.Tables[i].Rows)
				//    {
				//        if (Convert.ToBoolean(dataRow["RightFlag"]))
				//        {
				//            sql = "INSERT INTO TP_MST_UserPurview"
				//               + "(UserID"
				//               + " ,PurviewID"
				//               + " ,PurviewType "
				//               + " ,CreateUserID) "
				//               + " VALUES "
				//                + "(:UserID"
				//               + " ,:PurviewID"
				//               + " ,:PurviewType"
				//               + " ,:CreateUserID) ";
				//            paras = new Oracle.ManagedDataAccess.Client.OracleParameter[] 
				//           {
				//               new Oracle.ManagedDataAccess.Client.OracleParameter(":UserID",userID),
				//               new Oracle.ManagedDataAccess.Client.OracleParameter(":PurviewID", Convert.ToInt32(dataRow["PurviewID"])),
				//               new Oracle.ManagedDataAccess.Client.OracleParameter(":PurviewType",Convert.ToInt32(dataRow["PurviewType"])),
				//               new Oracle.ManagedDataAccess.Client.OracleParameter(":CreateUserID",sUserInfo.UserID),
				//           };
				//            returnRowCount += oracleTrConn.ExecuteNonQuery(sql, paras);
				//        }
				//    }
				//}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnRowCount;
			}
			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="sUserInfo">用户基本信息</param>
		/// <param name="datatLogoData">商标数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2015.11.12          王鑫          新建
		/// </remarks>
		public static int SaveLogoData(DataTable datatLogoData, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (datatLogoData == null && datatLogoData.Rows.Count < Constant.INT_IS_ZERO)
				{
					return Constant.INT_IS_THREE;
				}

				int returnResult = Constant.INT_IS_TWO;
				oracleTrConn.Connect();

				#region 对要保存的商标数据进行必要的验证
				foreach (DataRow dataRow in datatLogoData.Rows)
				{
					// 新建工种
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的商标代码
						string sqlString = "SELECT Count(*) FROM tp_mst_logo WHERE AccountID = :AccountID and LogoCode =:LogoCode ";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":LogoCode",dataRow["LogoCode"].ToString())
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlString, oracleParameter);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的商标代码
						string sqlStrings = "SELECT Count(*) FROM tp_mst_logo WHERE AccountID = :AccountID and LogoCode = :LogoCode and LogoID <> :LogoID";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":LogoCode",dataRow["LogoCode"]),
							new OracleParameter(":LogoID",dataRow["LogoID"])
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlStrings, oracleParameters);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
				}
				if (returnResult == Constant.INT_IS_ONE)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnResult;
				}
				#endregion
				foreach (DataRow dataRow in datatLogoData.Rows)
				{
					// 新建工种
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增工种信息

						#region 向商标插入数据
						string sqlInsertString = "INSERT INTO TP_MST_Logo "
												+ "(LogoCode"
												+ ",LogoName"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID,isdefault,displayno, TagCode)"
										+ " VALUES "
												+ "(:LogoCode"
												+ ",:LogoName"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID,:isdefault,:displayno,:TagCode)";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":LogoCode",dataRow["LogoCode"].ToString()),
							new OracleParameter(":LogoName",dataRow["LogoName"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID),
							new OracleParameter(":TagCode",dataRow["TagCode"].ToString()),
							new OracleParameter(":isdefault",dataRow["isdefault"].ToString()==""?"0":dataRow["isdefault"].ToString()),
							new OracleParameter(":displayno",dataRow["displayno"].ToString()==""?"1":dataRow["displayno"].ToString()),
						};
						oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameters);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新商标信息
						string sqlUpdateString = "UPDATE TP_MST_Logo SET "
											+ " LogoName = :LogoName,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime,"
											+ " isdefault = :isdefault,"
											+ " TagCode = :TagCode,"
											+ " displayno = :displayno"
											+ " WHERE LogoID = :LogoID";
						OracleParameter[] oracleParametere = new OracleParameter[]
						{
							new OracleParameter(":LogoName",dataRow["LogoName"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":LogoID",dataRow["LogoID"].ToString()),
							new OracleParameter(":TagCode",dataRow["TagCode"].ToString()),
							new OracleParameter(":isdefault",dataRow["isdefault"].ToString()==""?"0":dataRow["isdefault"].ToString()),
							new OracleParameter(":displayno",dataRow["displayno"].ToString()==""?"1":dataRow["displayno"].ToString()),
						};
						oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParametere);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除商标信息
						string sqlDeleteString = "DELETE TP_MST_Logo  WHERE LogoID = :LogoID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":LogoID",dataRow["LogoID",DataRowVersion.Original].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlDeleteString, oracleParameter);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存缺陷扣罚数据
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="dataDefectFineData">缺陷扣罚数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2016.1.5          王鑫          新建
		/// </remarks>
		public static int SaveDefectFineData(DataTable dataDefectFineData, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (dataDefectFineData == null && dataDefectFineData.Rows.Count < Constant.INT_IS_ZERO)
				{
					return Constant.INT_IS_THREE;
				}

				int returnResult = Constant.INT_IS_TWO;
				oracleTrConn.Connect();

				#region 对要保存的工种数据进行必要的验证
				foreach (DataRow dataRow in dataDefectFineData.Rows)
				{
					// 新建缺陷扣罚
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的缺陷扣罚代码
						string sqlString = "SELECT Count(*) FROM TP_MST_DefectFine WHERE AccountID = :AccountID and DefectFineCode =:DefectFineCode ";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":DefectFineCode",dataRow["DefectFineCode"].ToString())
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlString, oracleParameter);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的缺陷扣罚代码
						string sqlStrings = "SELECT Count(*) FROM TP_MST_DefectFine WHERE AccountID = :AccountID and DefectFineCode = :DefectFineCode and DefectFineID <> :DefectFineID";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":DefectFineCode",dataRow["DefectFineCode"]),
							new OracleParameter(":DefectFineID",dataRow["DefectFineID"])
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlStrings, oracleParameters);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
				}
				if (returnResult == Constant.INT_IS_ONE)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnResult;
				}
				#endregion
				foreach (DataRow dataRow in dataDefectFineData.Rows)
				{
					// 新建工种
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增工种信息

						#region 向T_MST_Jobs插入数据
						string sqlInsertString = "INSERT INTO TP_MST_DefectFine "
												+ "(DefectFineCode"
												+ ",DisplayNo"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:DefectFineCode"
												+ ",:DisplayNo"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":DefectFineCode",dataRow["DefectFineCode"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameters);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新工种信息
						string sqlUpdateString = "UPDATE TP_MST_DefectFine SET "
											+ " DefectFineCode = :DefectFineCode,"
											+ " DisplayNo = :DisplayNo,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE DefectFineID = :DefectFineID";
						OracleParameter[] oracleParametere = new OracleParameter[]
						{
							new OracleParameter(":DefectFineCode",dataRow["DefectFineCode"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":DefectFineID",dataRow["DefectFineID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParametere);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除工种信息
						string sqlDeleteString = "DELETE TP_MST_DefectFine  WHERE DefectFineID = :DefectFineID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":DefectFineID",dataRow["DefectFineID",DataRowVersion.Original].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlDeleteString, oracleParameter);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存缺陷扣除数据
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="dataDefectDeduction">缺陷扣除数数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2016.1.5          王鑫          新建
		/// </remarks>
		public static int SaveDefectDeduction(DataTable dataDefectDeduction, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (dataDefectDeduction == null && dataDefectDeduction.Rows.Count < Constant.INT_IS_ZERO)
				{
					return Constant.INT_IS_THREE;
				}

				int returnResult = Constant.INT_IS_TWO;
				oracleTrConn.Connect();

				#region 对要保存的数据进行必要的验证
				foreach (DataRow dataRow in dataDefectDeduction.Rows)
				{
					// 新建缺陷扣除数
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的缺陷除数代码
						string sqlString = "SELECT Count(*) FROM TP_MST_DefectDeduction WHERE AccountID = :AccountID and DefectDeductionNum =:DefectDeductionNum ";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":DefectDeductionNum",dataRow["DefectDeductionNum"].ToString())
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlString, oracleParameter);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的缺陷扣罚代码
						string sqlStrings = "SELECT Count(*) FROM TP_MST_DefectDeduction WHERE AccountID = :AccountID and DefectDeductionNum = :DefectDeductionNum and DefectDeductionID <> :DefectDeductionID";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":DefectDeductionNum",dataRow["DefectDeductionNum"]),
							new OracleParameter(":DefectDeductionID",dataRow["DefectDeductionID"])
						};
						string sqlReturnStr = oracleTrConn.GetSqlResultToStr(sqlStrings, oracleParameters);
						if (!Constant.INT_IS_ZERO.ToString().Equals(sqlReturnStr))
						{
							returnResult = Constant.INT_IS_ONE;
							break;
						}
						#endregion
					}
				}
				if (returnResult == Constant.INT_IS_ONE)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return returnResult;
				}
				#endregion
				foreach (DataRow dataRow in dataDefectDeduction.Rows)
				{
					// 新建工种
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增工种信息

						#region 向T_MST_Jobs插入数据
						string sqlInsertString = "INSERT INTO TP_MST_DefectDeduction "
												+ "(DefectDeductionNum"
												+ ",DisplayNo"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:DefectDeductionNum"
												+ ",:DisplayNo"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":DefectDeductionNum",dataRow["DefectDeductionNum"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameters);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新工种信息
						string sqlUpdateString = "UPDATE TP_MST_DefectDeduction SET "
											+ " DefectDeductionNum = :DefectDeductionNum,"
											+ " DisplayNo = :DisplayNo,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE DefectDeductionID = :DefectDeductionID";
						OracleParameter[] oracleParametere = new OracleParameter[]
						{
							new OracleParameter(":DefectDeductionNum",dataRow["DefectDeductionNum"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":DefectDeductionID",dataRow["DefectDeductionID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParametere);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除工种信息
						string sqlDeleteString = "DELETE TP_MST_DefectDeduction  WHERE DefectDeductionID = :DefectDeductionID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":DefectDeductionID",dataRow["DefectDeductionID",DataRowVersion.Original].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlDeleteString, oracleParameter);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存缺陷关系数据
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="dataDefectFineRelation">缺陷扣罚数据</param>
		/// <param name="dataDefectDeductionRelation">缺陷扣除数数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2016.1.5          王鑫          新建
		/// </remarks>
		public static int SaveDefectRelation(DataTable dataDefectFineRelation, DataTable dataDefectDeductionRelation, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				int returnResult = Constant.INT_IS_ZERO;
				oracleTrConn.Connect();
				// 删除表里的数据，重新添加
				string sqlString = "delete from TP_MST_DefectFineRelation";
				returnResult += oracleTrConn.ExecuteNonQuery(sqlString);

				sqlString = "delete from TP_MST_DefectDeductionRelation";
				returnResult += oracleTrConn.ExecuteNonQuery(sqlString);
				//

				// 插入缺陷扣罚数据
				foreach (DataRow dataRow in dataDefectFineRelation.Rows)
				{
					if (dataRow.RowState != DataRowState.Deleted)
					{
						string sqlExists = "select 1 from TP_MST_DefectFineRelation where DefectID=:DefectID and DefectFineID=:DefectFineID";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":DefectID",dataRow["DefectID"].ToString()),
							new OracleParameter(":DefectFineID",dataRow["DefectFineID"].ToString()),
						};
						DataSet ds = oracleTrConn.GetSqlResultToDs(sqlExists, oracleParameters);
						if (ds != null && ds.Tables[0].Rows.Count == 0)
						{

							string sqlInsertString = "INSERT INTO TP_MST_DefectFineRelation "
														+ "(DefectID"
														+ ",DefectFineID"
														+ ",UpdateUserID"
														+ ",CreateUserID)"
												+ " VALUES "
														 + "(:DefectID"
														+ ",:DefectFineID"
														+ ",:UpdateUserID"
														+ ",:CreateUserID)";
							oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":DefectID",dataRow["DefectID"].ToString()),
							new OracleParameter(":DefectFineID",dataRow["DefectFineID"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
							oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameters);
						}
					}
				}


				// 插入缺陷扣除数数据
				foreach (DataRow dataRow in dataDefectDeductionRelation.Rows)
				{
					if (dataRow.RowState != DataRowState.Deleted)
					{
						string sqlExists = "select 1 from TP_MST_DefectDeductionRelation where DefectID=:DefectID and DefectDeductionID=:DefectDeductionID";
						OracleParameter[] oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":DefectID",dataRow["DefectID"].ToString()),
							new OracleParameter(":DefectDeductionID",dataRow["DefectDeductionID"].ToString()),
						};
						DataSet ds = oracleTrConn.GetSqlResultToDs(sqlExists, oracleParameters);
						if (ds != null && ds.Tables[0].Rows.Count == 0)
						{
							string sqlInsertString = "INSERT INTO TP_MST_DefectDeductionRelation "
														+ "(DefectID"
														+ ",DefectDeductionID"
														+ ",UpdateUserID"
														+ ",CreateUserID)"
												+ " VALUES "
														 + "(:DefectID"
														+ ",:DefectDeductionID"
														+ ",:UpdateUserID"
														+ ",:CreateUserID)";
							oracleParameters = new OracleParameter[]
						{
							new OracleParameter(":DefectID",dataRow["DefectID"].ToString()),
							new OracleParameter(":DefectDeductionID",dataRow["DefectDeductionID"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
							oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameters);
						}
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存半成品缺陷数据
		/// </summary>
		/// <param name="dataDefectData">缺陷数据</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2016.06.22          王鑫          新建
		/// </remarks>
		public static int SaveSemicheckDefect(DataTable dataDefectData, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (dataDefectData == null && dataDefectData.Rows.Count < 0)
				{
					return 3;
				}
				int intResult = 2;
				oracleTrConn.Connect();
				#region 对要保存的帐套数据进行必要的验证
				foreach (DataRow dataRow in dataDefectData.Rows)
				{
					// 新建缺陷位置
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的位置代码
						string sqlString1 = "SELECT Count(*) FROM tp_mst_semicheckdefect WHERE AccountID = :AccountID and DefectCode =:DefectCode ";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							 new OracleParameter(":DefectCode",dataRow["DefectCode"].ToString())
						};
						string strTemp1 = oracleTrConn.GetSqlResultToStr(sqlString1, parmeters1);
						if (strTemp1 != "0")
						{
							intResult = 1;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的位置代码
						string sqlString2 = "SELECT Count(*) FROM tp_mst_semicheckdefect WHERE AccountID = :AccountID and DefectCode = :DefectCode and DefectID <> :DefectID";
						OracleParameter[] parmeters2 = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":DefectCode",dataRow["DefectCode"]),
							 new OracleParameter(":DefectID",dataRow["DefectID"])
						};
						string strTemp1 = oracleTrConn.GetSqlResultToStr(sqlString2, parmeters2);
						if (strTemp1 != "0")
						{
							intResult = 1;
							break;
						}
						#endregion
					}
				}
				if (intResult == 1)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return intResult;
				}
				#endregion
				//string accountID = "";  // 存储新插入账套ID
				//string userID = "";     //用户ID
				foreach (DataRow dataRow in dataDefectData.Rows)
				{
					// 新建缺陷
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增缺陷信息

						#region 向tp_mst_semicheckdefect插入数据
						string sqlString1 = "INSERT INTO tp_mst_semicheckdefect "
												+ "(DefectCode"
												+ ",DefectName"
												+ ",Remarks"
												+ ",DisplayNo"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:DefectCode"
												+ ",:DefectName"
												+ ",:Remarks"
												+ ",:DisplayNo"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":DefectCode",dataRow["DefectCode"].ToString()),
							new OracleParameter(":DefectName",dataRow["DefectName"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"]),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlString1, parmeters1);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新缺陷信息
						string sqlString = "UPDATE tp_mst_semicheckdefect SET "
											+ " DefectCode = :DefectCode,"
											+ " DefectName = :DefectName,"
											+ " Remarks = :Remarks,"
											+ " DisplayNo = :DisplayNo,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE DefectID = :DefectID";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":DefectCode",dataRow["DefectCode"].ToString()),
							new OracleParameter(":DefectName",dataRow["DefectName"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"]),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":DefectID",dataRow["DefectID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlString, parmeters1);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除缺陷信息
						string sqlDeleteString = "DELETE tp_mst_semicheckdefect  WHERE DefectID = :DefectID";
						OracleParameter[] parmeters2 = new OracleParameter[]
						{
							new OracleParameter(":DefectID",dataRow["DefectID",DataRowVersion.Original].ToString())
						};

						oracleTrConn.ExecuteNonQuery(sqlDeleteString, parmeters2);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return intResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存半成品缺陷位置数据
		/// </summary>
		/// <param name="dataDefectData">缺陷数据</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2016.06.23          王鑫          新建
		/// </remarks>
		public static int SaveScdefectPosition(DataTable dataDefectData, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (dataDefectData == null && dataDefectData.Rows.Count < 0)
				{
					return 3;
				}
				int intResult = 2;
				oracleTrConn.Connect();
				#region 对要保存的帐套数据进行必要的验证
				foreach (DataRow dataRow in dataDefectData.Rows)
				{
					// 新建缺陷位置
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 判断是否存在相同的位置代码
						string sqlString1 = "SELECT Count(*) FROM tp_mst_scdefectposition WHERE AccountID = :AccountID and DefectPositionCode =:DefectPositionCode ";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							 new OracleParameter(":DefectPositionCode",dataRow["DefectPositionCode"].ToString())
						};
						string strTemp1 = oracleTrConn.GetSqlResultToStr(sqlString1, parmeters1);
						if (strTemp1 != "0")
						{
							intResult = 1;
							break;
						}
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 判断是否存在相同的位置代码
						string sqlString2 = "SELECT Count(*) FROM tp_mst_scdefectposition WHERE AccountID = :AccountID and DefectPositionCode = :DefectPositionCode and DefectPositionID <> :DefectPositionID";
						OracleParameter[] parmeters2 = new OracleParameter[]
						{
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":DefectPositionCode",dataRow["DefectPositionCode"]),
							 new OracleParameter(":DefectPositionID",dataRow["DefectPositionID"])
						};
						string strTemp1 = oracleTrConn.GetSqlResultToStr(sqlString2, parmeters2);
						if (strTemp1 != "0")
						{
							intResult = 1;
							break;
						}
						#endregion
					}
				}
				if (intResult == 1)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
					return intResult;
				}
				#endregion
				//string accountID = "";  // 存储新插入账套ID
				//string userID = "";     //用户ID
				foreach (DataRow dataRow in dataDefectData.Rows)
				{
					// 新建缺陷位置
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增缺陷信息

						#region 向tp_mst_scdefectposition插入数据
						string sqlString1 = "INSERT INTO tp_mst_scdefectposition "
												+ "(DefectPositionCode"
												+ ",DefectPositionName"
												+ ",Remarks"
												+ ",DisplayNo"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:DefectPositionCode"
												+ ",:DefectPositionName"
												+ ",:Remarks"
												+ ",:DisplayNo"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":DefectPositionCode",dataRow["DefectPositionCode"].ToString()),
							new OracleParameter(":DefectPositionName",dataRow["DefectPositionName"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"]),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlString1, parmeters1);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新缺陷信息
						string sqlString = "UPDATE tp_mst_scdefectposition SET "
											+ " DefectPositionCode = :DefectPositionCode,"
											+ " DefectPositionName = :DefectPositionName,"
											+ " Remarks = :Remarks,"
											+ " DisplayNo = :DisplayNo,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE DefectPositionID = :DefectPositionID";
						OracleParameter[] parmeters1 = new OracleParameter[]
						{
							new OracleParameter(":DefectPositionCode",dataRow["DefectPositionCode"].ToString()),
							new OracleParameter(":DefectPositionName",dataRow["DefectPositionName"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"]),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":DefectPositionID",dataRow["DefectPositionID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlString, parmeters1);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除缺陷信息
						string sqlDeleteString = "DELETE tp_mst_scdefectposition  WHERE DefectPositionID = :DefectPositionID";
						OracleParameter[] parmeters2 = new OracleParameter[]
						{
							new OracleParameter(":DefectPositionID",dataRow["DefectPositionID",DataRowVersion.Original].ToString())
						};

						oracleTrConn.ExecuteNonQuery(sqlDeleteString, parmeters2);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return intResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存工艺数据
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="datatData">工艺数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2016.07.19			王鑫			新建
		/// </remarks>
		public static int SaveTecDepData(SUserInfo sUserInfo, DataTable datatData)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (datatData == null && datatData.Rows.Count < Constant.INT_IS_ZERO)
				{
					return Constant.INT_IS_THREE;
				}
				int returnResult = Constant.INT_IS_TWO;
				oracleTrConn.Connect();
				foreach (DataRow dataRow in datatData.Rows)
				{
					// 新建工艺
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增窑炉信息

						#region 向T_MST_Kiln插入数据
						string sqlInsertString = "INSERT INTO TP_MST_TecDep "
												+ "(Name"
												+ ",TypeFlag"
												+ ",TechnologyFlag"
												+ ",DisplayNo"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",CreateTime"
												+ ",UpdateTime"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:Name"
												+ ",:TypeFlag"
												+ ",:TechnologyFlag"
												+ ",:DisplayNo"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",sysdate"
												+ ",sysdate"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":Name",dataRow["Name"].ToString()),
							new OracleParameter(":TypeFlag",dataRow["TypeFlag"].ToString()),
							new OracleParameter(":TechnologyFlag",dataRow["TechnologyFlag"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"].ToString()==""?"0":dataRow["DisplayNo"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameter);
						#endregion

						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新窑炉信息
						string sqlUpdateString = "UPDATE TP_MST_TecDep SET "
											+ " Name = :Name,"
											+ " TypeFlag = :TypeFlag,"
											+ " TechnologyFlag = :TechnologyFlag,"
											+ " DisplayNo = :DisplayNo,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID,"
											+ " UpdateTime = :UpdateTime"
											+ " WHERE ID = :ID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":Name",dataRow["Name"].ToString()),
							new OracleParameter(":TypeFlag",dataRow["TypeFlag"].ToString()),
							new OracleParameter(":TechnologyFlag",dataRow["TechnologyFlag"].ToString()),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"].ToString()==""?"0":dataRow["DisplayNo"].ToString()),
							new OracleParameter(":Remarks",dataRow["Remarks"].ToString()),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"].ToString()),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":UpdateTime",DateTime.Now),
							new OracleParameter(":ID",dataRow["ID"].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParameter);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除窑炉信息
						string sqlDeleteString = "DELETE TP_MST_TecDep  WHERE ID = :ID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":ID",dataRow["ID",DataRowVersion.Original].ToString())
						};
						oracleTrConn.ExecuteNonQuery(sqlDeleteString, oracleParameter);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return returnResult;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 保存配置信息
		/// </summary>
		/// <param name="tecDepEntity">配置实体</param>
		/// <param name="user">用户基本信息</param>
		/// <returns>返回受影响行数</returns>
		/// <remarks>
		/// 王鑫              2016.07.19              新建
		/// </remarks>
		public static int SaveTransfer(TecDepEntity tecDepEntity, SUserInfo user)
		{
			int returnRows = 0;
			int detailReturn = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				// 获得账务日期
				// DateTime accountDate = CommonModuleLogic.CommonModuleLogic.GetAccountDate(oracleTrConn, user);
				if (tecDepEntity.PTID == 0)
				{
					//获取配置主表序列ID
					StringBuilder sbSql = new StringBuilder();
					sbSql.Append("select SEQ_MST_RPT_Transfer_ID.nextval from dual");
					int id = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));
					sbSql.Clear();

					//添加主表配置信息
					sbSql.Append("Insert into TP_MST_RPT_Transfer");
					sbSql.Append("(PTID,Name,LineID,DisplayNo,GroutingDateBegin,");
					sbSql.Append(" Remarks,AccountID,ValueFlag,");
					sbSql.Append("CreateUserID,UpdateUserID)");
					sbSql.Append("values(:PTID,:Name,:LineID,:DisplayNo,:GroutingDateBegin,");
					sbSql.Append(":Remarks,:AccountID,:ValueFlag,");
					sbSql.Append(":CreateUserID,:UpdateUserID)");
					OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":PTID",OracleDbType.Int32,
							id,ParameterDirection.Input),
						new OracleParameter(":Name",OracleDbType.NVarchar2,
							tecDepEntity.Name,ParameterDirection.Input),
						new OracleParameter(":LineID",OracleDbType.Int32,
							tecDepEntity.LineID,ParameterDirection.Input),
						new OracleParameter(":DisplayNo",OracleDbType.Int32,
							tecDepEntity.DisplayNo,ParameterDirection.Input),
						new OracleParameter(":GroutingDateBegin",OracleDbType.Date,
							tecDepEntity.GroutingDateBegin,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							tecDepEntity.Remarks,ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":ValueFlag",OracleDbType.Int32,
							tecDepEntity.ValueFlag,ParameterDirection.Input),
						new OracleParameter(":CreateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
					};

					//执行插入SQL语句
					returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

					//此处添加明细信息（循环）
					foreach (DataRow detailInfo in tecDepEntity.TransferSetting.Tables[0].Rows)
					{
						//获取配置明细序列索引
						sbSql.Clear();
						sbSql.Append("select SEQ_MST_RPT_TransferSetting_ID.nextval from dual");
						int detailId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));

						sbSql.Clear();
						//插入配置细信息
						sbSql.Append("Insert into TP_MST_RPT_TransferSetting");
						sbSql.Append("(PTSID,PTID,PROCEDUREID,OUTTECDEPID,INTECDEPID,PERPROCEDUREID,AccountID,DisplayNo)");
						sbSql.Append("Values(:PTSID,:PTID,:PROCEDUREID,:OUTTECDEPID,:INTECDEPID,:PERPROCEDUREID,:AccountID,:DisplayNo)");
						OracleParameter[] DetailParas = new OracleParameter[] {
						new OracleParameter(":PTSID",OracleDbType.Int32,
							detailId,ParameterDirection.Input),
						new OracleParameter(":PTID",OracleDbType.Int32,
							id,ParameterDirection.Input),
						new OracleParameter(":PROCEDUREID",OracleDbType.Int32,
							detailInfo["PROCEDUREID"],ParameterDirection.Input),
						new OracleParameter(":OUTTECDEPID",OracleDbType.Int32,
							detailInfo["OUTTECDEPID"],ParameterDirection.Input),
						new OracleParameter(":INTECDEPID",OracleDbType.Int32,
							detailInfo["INTECDEPID"],ParameterDirection.Input),
						new OracleParameter(":PERPROCEDUREID",OracleDbType.Int32,
							detailInfo["PERPROCEDUREID"],ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":DisplayNo",OracleDbType.Int32,
							  detailInfo["DisplayNo"],ParameterDirection.Input)

					};
						//执行插入语句并累加成功插入次数
						detailReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);
					}
				}
				else
				{
					// 编辑
					//更改主表配置信息
					StringBuilder sbSql = new StringBuilder();
					sbSql.Append("Update TP_MST_RPT_Transfer");
					sbSql.Append(" Set  Name=:Name,");
					sbSql.Append(" LineID=:LineID,");
					sbSql.Append(" DisplayNo=:DisplayNo,");
					sbSql.Append(" GroutingDateBegin=:GroutingDateBegin,");
					sbSql.Append(" Remarks=:Remarks,");
					sbSql.Append(" ValueFlag=:ValueFlag,");
					sbSql.Append(" UpdateUserID=:UpdateUserID ");
					sbSql.Append(" where PTID =:PTID");

					OracleParameter[] Paras = new OracleParameter[] {
						new OracleParameter(":PTID",OracleDbType.Int32,
							tecDepEntity.PTID,ParameterDirection.Input),
						new OracleParameter(":Name",OracleDbType.NVarchar2,
							tecDepEntity.Name,ParameterDirection.Input),
						new OracleParameter(":LineID",OracleDbType.Int32,
							tecDepEntity.LineID,ParameterDirection.Input),
						new OracleParameter(":DisplayNo",OracleDbType.Int32,
							tecDepEntity.DisplayNo,ParameterDirection.Input),
						new OracleParameter(":GroutingDateBegin",OracleDbType.Date,
							tecDepEntity.GroutingDateBegin,ParameterDirection.Input),
						new OracleParameter(":Remarks",OracleDbType.NVarchar2,
							tecDepEntity.Remarks,ParameterDirection.Input),
						new OracleParameter(":ValueFlag",OracleDbType.Int32,
							tecDepEntity.ValueFlag,ParameterDirection.Input),
						new OracleParameter(":UpdateUserID",OracleDbType.Int32,
							user.UserID,ParameterDirection.Input),
					};
					//执行插入SQL语句
					returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

					// 删除配置明细信息
					sbSql.Clear();
					sbSql.Append("delete from  TP_MST_RPT_TransferSetting where  PTID =:PTID");
					Paras = new OracleParameter[] {
						new OracleParameter(":PTID",OracleDbType.Int32,
							tecDepEntity.PTID,ParameterDirection.Input)
					};
					//执行SQL语句
					returnRows = oracleTrConn.ExecuteNonQuery(sbSql.ToString(), Paras);

					//此处添加明细信息（循环）
					foreach (DataRow detailInfo in tecDepEntity.TransferSetting.Tables[0].Rows)
					{
						//获取配置明细序列索引
						sbSql.Clear();
						sbSql.Append("select SEQ_MST_RPT_TransferSetting_ID.nextval from dual");
						int detailId = Convert.ToInt32(oracleTrConn.GetSqlResultToStr(sbSql.ToString()));

						sbSql.Clear();
						//插入配置细信息
						sbSql.Append("Insert into TP_MST_RPT_TransferSetting");
						sbSql.Append("(PTSID,PTID,PROCEDUREID,OUTTECDEPID,INTECDEPID,PERPROCEDUREID,AccountID,DisplayNo)");
						sbSql.Append("Values(:PTSID,:PTID,:PROCEDUREID,:OUTTECDEPID,:INTECDEPID,:PERPROCEDUREID,:AccountID,:DisplayNo)");
						OracleParameter[] DetailParas = new OracleParameter[] {
						new OracleParameter(":PTSID",OracleDbType.Int32,
							detailId,ParameterDirection.Input),
						new OracleParameter(":PTID",OracleDbType.Int32,
							tecDepEntity.PTID,ParameterDirection.Input),
						new OracleParameter(":PROCEDUREID",OracleDbType.Int32,
							detailInfo["PROCEDUREID"],ParameterDirection.Input),
						new OracleParameter(":OUTTECDEPID",OracleDbType.Int32,
							detailInfo["OUTTECDEPID"],ParameterDirection.Input),
						new OracleParameter(":INTECDEPID",OracleDbType.Int32,
							detailInfo["INTECDEPID"],ParameterDirection.Input),
						new OracleParameter(":PERPROCEDUREID",OracleDbType.Decimal,
							detailInfo["PERPROCEDUREID"],ParameterDirection.Input),
						new OracleParameter(":AccountID",OracleDbType.Int32,
							user.AccountID,ParameterDirection.Input),
						new OracleParameter(":DisplayNo",OracleDbType.Int32,
							 detailInfo["DisplayNo"],ParameterDirection.Input)

					};
						//执行插入语句并累加成功插入次数
						detailReturn += oracleTrConn.ExecuteNonQuery(sbSql.ToString(), DetailParas);
					}

				}
				//如果有插入不成功的情况，回滚事务，否则提交
				if (returnRows == 0 || detailReturn == 0)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				else
				{
					oracleTrConn.Commit();
					oracleTrConn.Disconnect();
				}
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return returnRows;
		}

		#region 产品工序配置
		/// <summary>
		/// 产品工序配置
		/// </summary>
		/// <param name="cre"></param>
		/// <param name="user"></param>
		/// <returns></returns>
		public static ServiceResultEntity SetGoodsToProcedure(ClientRequestEntity cre, SUserInfo user)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			ServiceResultEntity sre = new ServiceResultEntity();
			try
			{
				oracleTrConn.Connect();
				int type = (int)cre.Properties["Type"];
				string sqlString = null;
				// 设置产品工序
				if (type == 1)
				{
					sqlString = "INSERT INTO TP_PC_ProcedureGoods\n" +
					"  (productionlineid, procedureid, NODENO, goodsid, Createuserid)\n" +
					"  SELECT p.productionlineid, p.procedureid, p.NODENO, g.goodsid, " + user.UserID + "\n" +
					"    FROM tp_pc_procedure p\n" +
					"   INNER JOIN (SELECT goods.goodsid\n" +
					"                 FROM tp_mst_goods goods\n" +
					"                WHERE goods.goodsid IN (" + cre.Properties["GoodsIDs"] + ")) g\n" +
					"      ON 1 = 1\n" +
					"   WHERE p.valueflag = '1'\n" +
					(cre.Properties["ProductionLineID"] == null ? "" : "     AND p.productionlineid = " + cre.Properties["ProductionLineID"] + "\n") +
					(cre.Properties["ProcedureIDs"] == null ? "" : "     AND p.procedureid IN (" + cre.Properties["ProcedureIDs"] + ")\n") +
					"     AND NOT EXISTS (SELECT 1\n" +
					"            FROM TP_PC_ProcedureGoods pg\n" +
					"           WHERE pg.procedureid = p.procedureid\n" +
					"             AND pg.goodsid = g.goodsid)";
				}
				else
				{
					sqlString = "DELETE FROM TP_PC_ProcedureGoods pg\n" +
					" WHERE pg.goodsid IN (" + cre.Properties["GoodsIDs"] + ")\n" +
					(cre.Properties["ProductionLineID"] == null ? "" : "     AND pg.productionlineid = " + cre.Properties["ProductionLineID"] + "\n") +
					(cre.Properties["ProcedureIDs"] == null ? "" : "     AND pg.procedureid IN (" + cre.Properties["ProcedureIDs"] + ")\n");
				}

				//执行插入SQL语句
				int returnRows = oracleTrConn.ExecuteNonQuery(sqlString);

				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 sre;
		}
		#endregion

		#region 成型报损原因
		/// <summary>
		/// 保存成型报损原因
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <param name="ScrapReasonData">成型报损原因数据</param>
		/// <returns>int</returns>
		/// <remarks>
		/// 2018.03.26          周兴          新建
		/// </remarks>
		public static ServiceResultEntity SaveScrapReasonData(DataTable ScrapReasonData, SUserInfo sUserInfo)
		{
			ServiceResultEntity result = new ServiceResultEntity();
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				// 检验参数的有效性
				if (ScrapReasonData == null && ScrapReasonData.Rows.Count < Constant.INT_IS_ZERO)
				{
					result.Result = Constant.INT_IS_THREE;
					return result;
				}
				result.Result = Constant.INT_IS_TWO;
				oracleTrConn.Connect();
				foreach (DataRow dataRow in ScrapReasonData.Rows)
				{
					// 新建
					if (dataRow.RowState == DataRowState.Added)
					{
						#region 新增
						string sqlInsertString = "INSERT INTO TP_MST_ScrapReason "
												+ "(ScrapReason"
												+ ",ScrapType"
												+ ",DisplayNo"
												+ ",Remarks"
												+ ",AccountID"
												+ ",ValueFlag"
												+ ",UpdateUserID"
												+ ",CreateUserID)"
										+ " VALUES "
												+ "(:ScrapReason"
												+ ",:ScrapType"
												+ ",:DisplayNo"
												+ ",:Remarks"
												+ ",:AccountID"
												+ ",:ValueFlag"
												+ ",:UpdateUserID"
												+ ",:CreateUserID)";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":ScrapReason",dataRow["ScrapReason"] + ""),
							new OracleParameter(":ScrapType",dataRow["ScrapType"] + ""),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"] + ""),
							new OracleParameter(":Remarks",dataRow["Remarks"] + ""),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"] + ""),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":CreateUserID",sUserInfo.UserID)
						};
						oracleTrConn.ExecuteNonQuery(sqlInsertString, oracleParameter);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Modified)
					{
						#region 更新数据字典信息
						string sqlUpdateString = "UPDATE TP_MST_ScrapReason SET "
											+ " ScrapReason = :ScrapReason,"
											+ " DisplayNo = :DisplayNo,"
											+ " Remarks = :Remarks,"
											+ " AccountID = :AccountID,"
											+ " ValueFlag = :ValueFlag,"
											+ " UpdateUserID = :UpdateUserID "
											+ " WHERE ScrapReasonID = :ScrapReasonID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":ScrapReason",dataRow["ScrapReason"]+ ""),
							new OracleParameter(":DisplayNo",dataRow["DisplayNo"]+ ""),
							new OracleParameter(":Remarks",dataRow["Remarks"]+ ""),
							new OracleParameter(":AccountID",sUserInfo.AccountID),
							new OracleParameter(":ValueFlag",dataRow["ValueFlag"]+ ""),
							new OracleParameter(":UpdateUserID",sUserInfo.UserID),
							new OracleParameter(":ScrapReasonID",dataRow["ScrapReasonID"])
						};
						oracleTrConn.ExecuteNonQuery(sqlUpdateString, oracleParameter);
						#endregion
					}
					else if (dataRow.RowState == DataRowState.Deleted)
					{
						#region 删除数据字典信息
						string sqlDeleteString = "DELETE TP_MST_ScrapReason  WHERE ScrapReasonID = :ScrapReasonID";
						OracleParameter[] oracleParameter = new OracleParameter[]
						{
							new OracleParameter(":ScrapReasonID",dataRow["ScrapReasonID",DataRowVersion.Original])
						};
						oracleTrConn.ExecuteNonQuery(sqlDeleteString, oracleParameter);
						#endregion
					}
				}
				oracleTrConn.Commit();
				oracleTrConn.Disconnect();
				return result;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
		}
		#endregion
	}
}