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 "
                           + " OR (PurviewType =:PurviewType AND PurviewID IN (SELECT OrganizationID FROM TP_MST_Organization WHERE ValueFlag = 1))) ";
                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  增加新的数据
                // 对现有功能权限进行遍历
                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);
                    }
                }
                #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
    }
}