Beispiel #1
0
        public void UpdateAllAlarmRules(int alarmRuleCatalogId, Edit input)
        {
            DBHelper._AlarmRuleItem dbhelp = new DBHelper._AlarmRuleItem();

            List <AlarmRuleItem> existAlarmRuleItemList = dbhelp.GetAllByAlarmRuleCatalogId(alarmRuleCatalogId);
            List <AlarmRuleItem> addList = new List <AlarmRuleItem>();

            dbhelp.Delete(existAlarmRuleItemList);

            foreach (var tmp in input.AlarmRules)
            {
                AlarmRuleItem alarmRuleItem = new AlarmRuleItem();
                alarmRuleItem.AlarmRuleCatalogId = alarmRuleCatalogId;
                alarmRuleItem.Ordering           = tmp.Ordering;
                alarmRuleItem.MessageElementId   = tmp.MessageElementId;
                alarmRuleItem.EqualOperation     = tmp.EqualOperation;
                alarmRuleItem.Value            = tmp.Value;
                alarmRuleItem.BitWiseOperation = tmp.BitWiseOperation;

                if (tmp.MessageElementParentId != null)
                {
                    alarmRuleItem.MessageElementParentId = tmp.MessageElementParentId;
                }

                addList.Add(alarmRuleItem);
            }

            dbhelp.Add(addList);
        }
Beispiel #2
0
        private Dictionary <string, RuleEngineItem> createRuleEngineItem(int alarmRuleCatalogId)
        {
            DBHelper._AlarmRuleItem dbhelperAlarmRuleItem = new DBHelper._AlarmRuleItem();
            var detailForRuleEngineModelList = dbhelperAlarmRuleItem.GetAllByAlarmRuleCatalogIdForRuleEngine(alarmRuleCatalogId);

            Dictionary <string, RuleEngineItem> ruleEngineItems = new Dictionary <string, RuleEngineItem>();

            int index = 0;

            foreach (var detailForRuleEngineModel in detailForRuleEngineModelList)
            {
                RuleEngineItem rei = new RuleEngineItem();
                rei.ElementName    = detailForRuleEngineModel.MessageElementFullName;
                rei.DataType       = AlarmRuleItemEngineUtility.GetSupportDataType(detailForRuleEngineModel.MessageElementDataType);
                rei.OrderOperation = detailForRuleEngineModel.BitWiseOperation;
                rei.Result         = false;

                ConsoleLog.WriteMessageAlarmLogToConsole("--ElementName={0}, BitWiseOperation={1}", rei.ElementName, rei.OrderOperation);

                if (rei.DataType == SupportDataTypeEnum.String &&
                    (string.IsNullOrEmpty(detailForRuleEngineModel.Value) || detailForRuleEngineModel.Value.ToLower().Equals("null")))
                {
                    detailForRuleEngineModel.Value = "null";
                }

                if (rei.DataType == SupportDataTypeEnum.Numeric || rei.DataType == SupportDataTypeEnum.Bool)
                {
                    rei.Equality = createCompiledRuleFunc(rei.DataType, detailForRuleEngineModel.EqualOperation, detailForRuleEngineModel.Value);
                }
                else
                {
                    // SupportDataTypeEnum.String
                    rei.Equality         = null;
                    rei.StringRightValue = detailForRuleEngineModel.Value;

                    if (detailForRuleEngineModel.EqualOperation.Equals("=") || detailForRuleEngineModel.EqualOperation.Equals("!="))
                    {
                        rei.StringEqualOperation = detailForRuleEngineModel.EqualOperation;
                    }
                    else
                    {
                        throw new ArgumentNullException("String equal operation is not supported - " + detailForRuleEngineModel.EqualOperation);
                    }

                    ConsoleLog.WriteMessageAlarmLogToConsole("----ruleText=({0} {1} {2})", rei.ElementName, detailForRuleEngineModel.EqualOperation, rei.StringRightValue);
                }

                // Add the index to avoid the duplicate key
                ruleEngineItems.Add(rei.ElementName + "-" + index, rei);
                index++;
            }

            return(ruleEngineItems);
        }
Beispiel #3
0
        public List <Detail> GetAllAlarmRuleItemByAlarmRuleCatalogId(int alarmRuleCatalogId)
        {
            DBHelper._AlarmRuleItem dbhelp = new DBHelper._AlarmRuleItem();

            return(dbhelp.GetAllByAlarmRuleCatalogId(alarmRuleCatalogId).Select(s => new Detail()
            {
                Id = s.Id,
                AlarmRuleCatalogId = s.AlarmRuleCatalogId,
                Ordering = s.Ordering,
                MessageElementParentId = s.MessageElementParentId,
                MessageElementId = s.MessageElementId,
                MessageElementName = s.MessageElement1.ElementName,
                EqualOperation = s.EqualOperation,
                Value = s.Value,
                BitWiseOperation = s.BitWiseOperation
            }).ToList <Detail>());
        }
Beispiel #4
0
        public Detail getAlarmRuleItemById(int id)
        {
            DBHelper._AlarmRuleItem dbhelp        = new DBHelper._AlarmRuleItem();
            AlarmRuleItem           alarmRuleItem = dbhelp.GetByid(id);

            return(new Detail()
            {
                Id = alarmRuleItem.Id,
                AlarmRuleCatalogId = alarmRuleItem.AlarmRuleCatalogId,
                Ordering = alarmRuleItem.Ordering,
                MessageElementParentId = alarmRuleItem.MessageElementParentId,
                MessageElementId = alarmRuleItem.MessageElementId,
                MessageElementName = alarmRuleItem.MessageElement1.ElementName,
                EqualOperation = alarmRuleItem.EqualOperation,
                Value = alarmRuleItem.Value,
                BitWiseOperation = alarmRuleItem.BitWiseOperation
            });
        }
Beispiel #5
0
 public IHttpActionResult test(int alarmRuleCatalogId)
 {
     DBHelper._AlarmRuleItem model = new DBHelper._AlarmRuleItem();
     return(Ok(model.GetAllByAlarmRuleCatalogIdForRuleEngine(alarmRuleCatalogId)));
 }