Ejemplo n.º 1
0
        /// <summary>
        /// Get Empty Condition PM Data Table
        /// </summary>
        /// <returns></returns>
        /// Owner:Andy Gao 2011-08-08 15:32:16
        private DataTable GetEmptyConditionPMDataTable()
        {
            DataTable dataTable = EMS_PM_CONDITION_FIELDS.CreateDataTable(true);

            dataTable.Columns.Add(EMS_PM_CONDITION_FIELDS.FIELD_NOTIFY_USER_NAME);
            dataTable.Columns.Add(EMS_PM_CONDITION_FIELDS.FIELD_NOTIFY_CC_USER_NAME);
            dataTable.Columns.Add(EMS_EQUIPMENT_CHANGE_STATES_FIELDS.FIELD_EQUIPMENT_CHANGE_STATE_NAME);
            dataTable.Columns.Add(EMS_EQUIPMENT_CHANGE_REASONS_FIELDS.FIELD_EQUIPMENT_CHANGE_REASON_NAME);
            dataTable.Columns.Add(EMS_EQUIPMENTS_FIELDS.FIELD_EQUIPMENT_NAME);
            dataTable.Columns.Add(EMS_CHECKLIST_FIELDS.FIELD_CHECKLIST_NAME);

            return(dataTable);
        }
Ejemplo n.º 2
0
        public override bool Insert()
        {
            DataSet reqDS = new DataSet();

            DataTable conditionPMDataTable = EMS_PM_CONDITION_FIELDS.CreateDataTable(false);

            Dictionary <string, string> dataRow = new Dictionary <string, string>()
            {
                { EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_KEY, conditionKey },
                { EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_NAME, conditionName },
                { EMS_PM_CONDITION_FIELDS.FIELD_EQUIPMENT_KEY, equipmentKey },
                { EMS_PM_CONDITION_FIELDS.FIELD_CHECKLIST_KEY, checkListKey },
                { EMS_PM_CONDITION_FIELDS.FIELD_DESCRIPTION, description },
                { EMS_PM_CONDITION_FIELDS.FIELD_COUNTER_TYPE, counterType },
                { EMS_PM_CONDITION_FIELDS.FIELD_COUNTER_WARNNING, counterWarnning },
                { EMS_PM_CONDITION_FIELDS.FIELD_COUNTER_TARGET, counterTarget },
                { EMS_PM_CONDITION_FIELDS.FIELD_COUNTER_TOTAL, counterTotal },
                { EMS_PM_CONDITION_FIELDS.FIELD_NOTIFY_USER_KEY, notifyUserKey },
                { EMS_PM_CONDITION_FIELDS.FIELD_NOTIFY_CC_USER_KEY, notifyCCUserKey },
                { EMS_PM_CONDITION_FIELDS.FIELD_EQUIPMENT_CHANGE_STATE_KEY, equipmentChangeStateKey },
                { EMS_PM_CONDITION_FIELDS.FIELD_EQUIPMENT_CHANGE_REASON_KEY, equipmentChangeReasonKey },

                { EMS_PM_CONDITION_FIELDS.FIELD_CREATOR, Creator },
                { EMS_PM_CONDITION_FIELDS.FIELD_CREATE_TIMEZONE_KEY, CreateTimeZone },
                { EMS_PM_CONDITION_FIELDS.FIELD_CREATE_TIME, string.Empty }
            };

            FanHai.Hemera.Utils.Common.Utils.AddKeyValuesToDataTable(ref conditionPMDataTable, dataRow);

            conditionPMDataTable.AcceptChanges();

            reqDS.Tables.Add(conditionPMDataTable);

            string msg;

            DataSet resDS = FanHai.Hemera.Utils.Common.Utils.ExecuteEngineMethod("FanHai.Hemera.Modules.EMS.EquipmentConditionPMEngine, FanHai.Hemera.Modules.EMS", "InsertConditionPM", reqDS, out msg);

            if (string.IsNullOrEmpty(msg))
            {
                CreateTime = resDS.ExtendedProperties.ContainsKey(PARAMETERS.OUTPUT_EDIT_TIME) ? resDS.ExtendedProperties[PARAMETERS.OUTPUT_EDIT_TIME].ToString() : string.Empty;

                return(true);
            }
            else
            {
                MessageService.ShowError(msg);

                return(false);
            }
        }
Ejemplo n.º 3
0
        public override bool Update()
        {
            DataSet reqDS = new DataSet();

            reqDS.ExtendedProperties.Add(PARAMETERS.INPUT_KEY, conditionKey);
            reqDS.ExtendedProperties.Add(PARAMETERS.INPUT_EDITOR, Editor);
            reqDS.ExtendedProperties.Add(PARAMETERS.INPUT_EDIT_TIME, EditTime);

            this.DirtyList.Add(EMS_PM_CONDITION_FIELDS.FIELD_EDIT_TIME, new DirtyItem(EMS_PM_CONDITION_FIELDS.FIELD_EDIT_TIME, string.Empty, string.Empty));

            Editor       = PropertyService.Get(PROPERTY_FIELDS.USER_NAME);
            EditTimeZone = PropertyService.Get(PROPERTY_FIELDS.TIMEZONE);

            DataTable conditionPMDataTable = EMS_PM_CONDITION_FIELDS.CreateDataTable(false);

            FanHai.Hemera.Utils.Common.Utils.AddKeyValuesToDataTable(ref conditionPMDataTable, this.DirtyList);

            conditionPMDataTable.AcceptChanges();

            reqDS.Tables.Add(conditionPMDataTable);

            string msg;

            DataSet resDS = FanHai.Hemera.Utils.Common.Utils.ExecuteEngineMethod("FanHai.Hemera.Modules.EMS.EquipmentConditionPMEngine, FanHai.Hemera.Modules.EMS", "UpdateConditionPM", reqDS, out msg);

            if (string.IsNullOrEmpty(msg))
            {
                EditTime = resDS.ExtendedProperties.ContainsKey(PARAMETERS.OUTPUT_EDIT_TIME) ? resDS.ExtendedProperties[PARAMETERS.OUTPUT_EDIT_TIME].ToString() : string.Empty;

                return(true);
            }
            else
            {
                MessageService.ShowError(msg);

                return(false);
            }
        }
Ejemplo n.º 4
0
        public DataSet DeleteCheckList(DataSet reqDS)
        {
            DataSet resDS = new DataSet();

            if (reqDS != null &&
                reqDS.ExtendedProperties.ContainsKey(PARAMETERS.INPUT_KEY) &&
                reqDS.ExtendedProperties.ContainsKey(PARAMETERS.INPUT_EDITOR) &&
                reqDS.ExtendedProperties.ContainsKey(PARAMETERS.INPUT_EDIT_TIME))
            {
                string checkListKey = reqDS.ExtendedProperties[PARAMETERS.INPUT_KEY].ToString();
                string editor       = reqDS.ExtendedProperties[PARAMETERS.INPUT_EDITOR].ToString();
                string editTime     = reqDS.ExtendedProperties[PARAMETERS.INPUT_EDIT_TIME].ToString();

                try
                {
                    EMS_CHECKLIST_FIELDS checkListFields = new EMS_CHECKLIST_FIELDS();

                    #region Build Delete SQL Conditions

                    Conditions conditions = new Conditions();

                    Condition condition;

                    if (string.IsNullOrEmpty(checkListKey))
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_CHECKLIST_FIELDS.FIELD_CHECKLIST_KEY,
                                                  GlobalEnums.DatabaseCompareOperator.Null, string.Empty);
                    }
                    else
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_CHECKLIST_FIELDS.FIELD_CHECKLIST_KEY,
                                                  GlobalEnums.DatabaseCompareOperator.Equal, checkListKey);
                    }

                    conditions.Add(condition);

                    if (string.IsNullOrEmpty(editor))
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_CHECKLIST_FIELDS.FIELD_EDITOR,
                                                  GlobalEnums.DatabaseCompareOperator.Null, string.Empty);
                    }
                    else
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_CHECKLIST_FIELDS.FIELD_EDITOR,
                                                  GlobalEnums.DatabaseCompareOperator.Equal, editor);
                    }

                    conditions.Add(condition);

                    if (string.IsNullOrEmpty(editTime))
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_CHECKLIST_FIELDS.FIELD_EDIT_TIME,
                                                  GlobalEnums.DatabaseCompareOperator.Null, string.Empty);
                    }
                    else
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_CHECKLIST_FIELDS.FIELD_EDIT_TIME,
                                                  GlobalEnums.DatabaseCompareOperator.Equal, editTime);
                    }

                    conditions.Add(condition);

                    List <Conditions> conditionsList = new List <Conditions>()
                    {
                        conditions
                    };

                    #endregion

                    List <string> sqlStringList = DatabaseTable.BuildDeleteSqlStatements(checkListFields, conditionsList);

                    string sqlString = string.Empty;

                    if (sqlStringList.Count > 0)
                    {
                        sqlString = sqlStringList[0];
                    }

                    using (DbConnection connection = db.CreateConnection())
                    {
                        connection.Open();

                        using (DbTransaction transaction = connection.BeginTransaction())
                        {
                            try
                            {
                                #region Validate Check List Jobs Reference

                                conditions = new Conditions();

                                conditions.Add(GlobalEnums.DatabaseLogicOperator.And, EMS_CHECKLIST_JOBS_FIELDS.FIELD_CHECKLIST_KEY, GlobalEnums.DatabaseCompareOperator.Equal, checkListKey);

                                EMS_CHECKLIST_JOBS_FIELDS checkListJobsFields = new EMS_CHECKLIST_JOBS_FIELDS();

                                List <string> interestColumns = new List <string>()
                                {
                                    EMS_CHECKLIST_JOBS_FIELDS.FIELD_CHECKLIST_KEY
                                };

                                string checkSqlString = DatabaseTable.BuildQuerySqlStatement(checkListJobsFields, interestColumns, conditions);

                                object scalar = db.ExecuteScalar(transaction, CommandType.Text, checkSqlString);

                                if (scalar != null && scalar != DBNull.Value)
                                {
                                    throw new Exception("检查表单已经关联检查表单任务,不能删除!");
                                }

                                #endregion

                                #region Validate PM Schedule Reference

                                conditions = new Conditions();

                                conditions.Add(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_SCHEDULE_FIELDS.FIELD_CHECKLIST_KEY, GlobalEnums.DatabaseCompareOperator.Equal, checkListKey);

                                EMS_PM_SCHEDULE_FIELDS schedulePMFields = new EMS_PM_SCHEDULE_FIELDS();

                                interestColumns = new List <string>()
                                {
                                    EMS_PM_SCHEDULE_FIELDS.FIELD_SCHEDULE_KEY
                                };

                                checkSqlString = DatabaseTable.BuildQuerySqlStatement(schedulePMFields, interestColumns, conditions);

                                scalar = db.ExecuteScalar(transaction, CommandType.Text, checkSqlString);

                                if (scalar != null && scalar != DBNull.Value)
                                {
                                    throw new Exception("检查表单已经关联计划PM,不能删除!");
                                }

                                #endregion

                                #region Validate PM Condition Reference

                                conditions = new Conditions();

                                conditions.Add(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_CHECKLIST_KEY, GlobalEnums.DatabaseCompareOperator.Equal, checkListKey);

                                EMS_PM_CONDITION_FIELDS conditionPMFields = new EMS_PM_CONDITION_FIELDS();

                                interestColumns = new List <string>()
                                {
                                    EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_KEY
                                };

                                checkSqlString = DatabaseTable.BuildQuerySqlStatement(conditionPMFields, interestColumns, conditions);

                                scalar = db.ExecuteScalar(transaction, CommandType.Text, checkSqlString);

                                if (scalar != null && scalar != DBNull.Value)
                                {
                                    throw new Exception("检查表单已经关联条件PM,不能删除!");
                                }

                                #endregion

                                #region Delete Check List Items Data

                                db.ExecuteNonQuery(transaction, CommandType.Text, string.Format("DELETE EMS_CHECKLIST_ITEM WHERE CHECKLIST_KEY = '{0}'", checkListKey));

                                #endregion

                                #region Delete Check List Data

                                if (db.ExecuteNonQuery(transaction, CommandType.Text, sqlString) <= 0)
                                {
                                    throw new Exception("数据处理失败,请重新刷新数据后再提交!");
                                }

                                #endregion

                                transaction.Commit();
                            }
                            catch
                            {
                                transaction.Rollback();

                                throw;
                            }
                            finally
                            {
                                connection.Close();
                            }
                        }
                    }

                    resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, string.Empty);
                }
                catch (Exception ex)
                {
                    resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, ex.Message);

                    LogService.LogError("DeleteCheckList Error: " + ex.Message);
                }
            }
            else
            {
                resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, "提交数据不存在,请重新提交!");
            }

            return(resDS);
        }
Ejemplo n.º 5
0
        public DataSet DeleteConditionPM(DataSet reqDS)
        {
            DataSet resDS = new DataSet();

            if (reqDS != null &&
                reqDS.ExtendedProperties.ContainsKey(PARAMETERS.INPUT_KEY) &&
                reqDS.ExtendedProperties.ContainsKey(PARAMETERS.INPUT_EDITOR) &&
                reqDS.ExtendedProperties.ContainsKey(PARAMETERS.INPUT_EDIT_TIME))
            {
                string conditionKey = reqDS.ExtendedProperties[PARAMETERS.INPUT_KEY].ToString();
                string editor       = reqDS.ExtendedProperties[PARAMETERS.INPUT_EDITOR].ToString();
                string editTime     = reqDS.ExtendedProperties[PARAMETERS.INPUT_EDIT_TIME].ToString();

                try
                {
                    EMS_PM_CONDITION_FIELDS conditionPMFields = new EMS_PM_CONDITION_FIELDS();

                    #region Build Delete SQL Conditions

                    Conditions conditions = new Conditions();

                    Condition condition;

                    if (string.IsNullOrEmpty(conditionKey))
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_KEY,
                                                  GlobalEnums.DatabaseCompareOperator.Null, string.Empty);
                    }
                    else
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_KEY,
                                                  GlobalEnums.DatabaseCompareOperator.Equal, conditionKey);
                    }

                    conditions.Add(condition);

                    if (string.IsNullOrEmpty(editor))
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_EDITOR,
                                                  GlobalEnums.DatabaseCompareOperator.Null, string.Empty);
                    }
                    else
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_EDITOR,
                                                  GlobalEnums.DatabaseCompareOperator.Equal, editor);
                    }

                    conditions.Add(condition);

                    if (string.IsNullOrEmpty(editTime))
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_EDIT_TIME,
                                                  GlobalEnums.DatabaseCompareOperator.Null, string.Empty);
                    }
                    else
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_EDIT_TIME,
                                                  GlobalEnums.DatabaseCompareOperator.Equal, editTime);
                    }

                    conditions.Add(condition);

                    List <Conditions> conditionsList = new List <Conditions>()
                    {
                        conditions
                    };

                    #endregion

                    List <string> sqlStringList = DatabaseTable.BuildDeleteSqlStatements(conditionPMFields, conditionsList);

                    if (sqlStringList.Count > 0)
                    {
                        #region Delete Condition PM Data

                        if (db.ExecuteNonQuery(CommandType.Text, sqlStringList[0]) > 0)
                        {
                            resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, string.Empty);
                        }
                        else
                        {
                            throw new Exception("数据处理失败,请重新刷新数据后再提交!");
                        }

                        #endregion
                    }
                    else
                    {
                        resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, "提交数据不存在,请重新提交!");
                    }
                }
                catch (Exception ex)
                {
                    resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, ex.Message);

                    LogService.LogError("DeleteConditionPM Error: " + ex.Message);
                }
            }
            else
            {
                resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, "提交数据不存在,请重新提交!");
            }

            return(resDS);
        }
Ejemplo n.º 6
0
        public DataSet UpdateConditionPM(DataSet reqDS)
        {
            DataSet resDS = new DataSet();

            if (reqDS != null &&
                reqDS.Tables.Contains(EMS_PM_CONDITION_FIELDS.DATABASE_TABLE_NAME) &&
                reqDS.ExtendedProperties.ContainsKey(PARAMETERS.INPUT_KEY) &&
                reqDS.ExtendedProperties.ContainsKey(PARAMETERS.INPUT_EDITOR) &&
                reqDS.ExtendedProperties.ContainsKey(PARAMETERS.INPUT_EDIT_TIME))
            {
                DataTable conditionPMDataTable = reqDS.Tables[EMS_PM_CONDITION_FIELDS.DATABASE_TABLE_NAME];

                string conditionKey = reqDS.ExtendedProperties[PARAMETERS.INPUT_KEY].ToString();
                string editor       = reqDS.ExtendedProperties[PARAMETERS.INPUT_EDITOR].ToString();
                string editTime     = reqDS.ExtendedProperties[PARAMETERS.INPUT_EDIT_TIME].ToString();

                try
                {
                    EMS_PM_CONDITION_FIELDS conditionPMFields = new EMS_PM_CONDITION_FIELDS();

                    #region Build Update SQL Conditions

                    Conditions conditions = new Conditions();

                    Condition condition;

                    if (string.IsNullOrEmpty(conditionKey))
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_KEY,
                                                  GlobalEnums.DatabaseCompareOperator.Null, string.Empty);
                    }
                    else
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_KEY,
                                                  GlobalEnums.DatabaseCompareOperator.Equal, conditionKey);
                    }

                    conditions.Add(condition);

                    if (string.IsNullOrEmpty(editor))
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_EDITOR,
                                                  GlobalEnums.DatabaseCompareOperator.Null, string.Empty);
                    }
                    else
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_EDITOR,
                                                  GlobalEnums.DatabaseCompareOperator.Equal, editor);
                    }

                    conditions.Add(condition);

                    if (string.IsNullOrEmpty(editTime))
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_EDIT_TIME,
                                                  GlobalEnums.DatabaseCompareOperator.Null, string.Empty);
                    }
                    else
                    {
                        condition = new Condition(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_EDIT_TIME,
                                                  GlobalEnums.DatabaseCompareOperator.Equal, editTime);
                    }

                    conditions.Add(condition);

                    List <Conditions> conditionsList = new List <Conditions>()
                    {
                        conditions
                    };

                    #endregion

                    List <string> sqlStringList = DatabaseTable.BuildUpdateSqlStatements(conditionPMFields, conditionPMDataTable, conditionsList);

                    if (sqlStringList.Count > 0 && conditionPMDataTable.Rows.Count > 0)
                    {
                        string conditionName = conditionPMDataTable.Rows[0][EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_NAME].ToString();
                        string sqlString     = sqlStringList[0];

                        using (DbConnection connection = db.CreateConnection())
                        {
                            connection.Open();

                            using (DbTransaction transaction = connection.BeginTransaction())
                            {
                                try
                                {
                                    #region Validate Condition PM Name

                                    if (!string.IsNullOrEmpty(conditionName))
                                    {
                                        conditions = new Conditions();

                                        conditions.Add(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_NAME, GlobalEnums.DatabaseCompareOperator.Equal, conditionName);

                                        conditions.Add(GlobalEnums.DatabaseLogicOperator.And, EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_KEY, GlobalEnums.DatabaseCompareOperator.NotEqual, conditionKey);

                                        string returnData = AllCommonFunctions.GetSpecifyTableColumnData(conditionPMFields, EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_NAME, conditions, transaction);

                                        if (!string.IsNullOrEmpty(returnData))
                                        {
                                            throw new Exception("条件PM名称已存在!");
                                        }
                                    }

                                    #endregion

                                    #region Update Condition PM Data

                                    if (db.ExecuteNonQuery(transaction, CommandType.Text, sqlString) > 0)
                                    {
                                        editTime = AllCommonFunctions.GetSpecifyTableColumnData(conditionPMFields, EMS_PM_CONDITION_FIELDS.FIELD_EDIT_TIME, EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_KEY, conditionKey, transaction);
                                    }
                                    else
                                    {
                                        throw new Exception("数据处理失败,请重新刷新数据后再提交!");
                                    }

                                    #endregion

                                    transaction.Commit();
                                }
                                catch
                                {
                                    transaction.Rollback();

                                    throw;
                                }
                                finally
                                {
                                    connection.Close();
                                }
                            }
                        }

                        resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, string.Empty);
                        resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_EDIT_TIME, editTime);
                    }
                    else
                    {
                        resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, "提交数据不存在,请重新提交!");
                    }
                }
                catch (Exception ex)
                {
                    resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, ex.Message);

                    LogService.LogError("UpdateConditionPM Error: " + ex.Message);
                }
            }
            else
            {
                resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, "提交数据不存在,请重新提交!");
            }

            return(resDS);
        }
Ejemplo n.º 7
0
        public DataSet InsertConditionPM(DataSet reqDS)
        {
            DataSet resDS = new DataSet();

            if (reqDS != null && reqDS.Tables.Contains(EMS_PM_CONDITION_FIELDS.DATABASE_TABLE_NAME))
            {
                DataTable conditionPMDataTable = reqDS.Tables[EMS_PM_CONDITION_FIELDS.DATABASE_TABLE_NAME];

                if (conditionPMDataTable.Rows.Count > 0)
                {
                    try
                    {
                        EMS_PM_CONDITION_FIELDS conditionPMFields = new EMS_PM_CONDITION_FIELDS();

                        List <string> sqlStringList = DatabaseTable.BuildInsertSqlStatements(conditionPMFields, conditionPMDataTable);

                        string conditionKey  = conditionPMDataTable.Rows[0][EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_KEY].ToString();
                        string conditionName = conditionPMDataTable.Rows[0][EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_NAME].ToString();
                        string createTime    = string.Empty;
                        string sqlString     = string.Empty;

                        if (sqlStringList.Count > 0)
                        {
                            sqlString = sqlStringList[0];
                        }

                        using (DbConnection connection = db.CreateConnection())
                        {
                            connection.Open();

                            using (DbTransaction transaction = connection.BeginTransaction())
                            {
                                try
                                {
                                    #region Validate Condition PM Name

                                    string returnData = AllCommonFunctions.GetSpecifyTableColumnData(conditionPMFields, EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_NAME, EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_NAME, conditionName, transaction);

                                    if (!string.IsNullOrEmpty(returnData))
                                    {
                                        throw new Exception("条件PM名称已存在!");
                                    }

                                    #endregion

                                    #region Insert Condition PM Data

                                    if (db.ExecuteNonQuery(transaction, CommandType.Text, sqlString) > 0)
                                    {
                                        createTime = AllCommonFunctions.GetSpecifyTableColumnData(conditionPMFields, EMS_PM_CONDITION_FIELDS.FIELD_CREATE_TIME, EMS_PM_CONDITION_FIELDS.FIELD_CONDITION_KEY, conditionKey, transaction);
                                    }
                                    else
                                    {
                                        throw new Exception("数据处理失败,请重新刷新数据后再提交!");
                                    }

                                    #endregion

                                    transaction.Commit();
                                }
                                catch
                                {
                                    transaction.Rollback();

                                    throw;
                                }
                                finally
                                {
                                    connection.Close();
                                }
                            }
                        }

                        resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, string.Empty);
                        resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_EDIT_TIME, createTime);
                    }
                    catch (Exception ex)
                    {
                        resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, ex.Message);

                        LogService.LogError("InsertConditionPM Error: " + ex.Message);
                    }
                }
                else
                {
                    resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, "提交数据不存在,请重新提交!");
                }
            }
            else
            {
                resDS.ExtendedProperties.Add(PARAMETERS.OUTPUT_MESSAGE, "提交数据不存在,请重新提交!");
            }

            return(resDS);
        }