每个判断参数化

panlei

2019-08-05 73ebf65b71171e83d339f5d8a521af6c746989e8

 labelFilter/ruleForLabel.go

@@ -123,7 +123,7 @@
   }
   expression, err:= govaluate.NewEvaluableExpression(formula);
   if err != nil {
      logger.Error("表达式有误，请检查！")
      logger.Error("表达式有误，请检查！",formula)
      return "false"
   }
   result, err1:= expression.Evaluate(nil)
@@ -140,42 +140,100 @@

// 是否符合底库规则
func baseJudge(label *Label,rule *protomsg.EventPushRule) string{
   flag := "false"
   for _,personGroup := range label.Persons  {
      for _,arg := range personGroup.Args {
         for _,liker := range arg.Liker{
            if liker.TableId == rule.RuleValue {
               logger.Info("符合底库规则！")
               flag = "true"
   if rule.RuleValue == "all" {
      for _,personGroup := range label.Persons {
         for _, arg := range personGroup.Args {
            if len(arg.Liker) > 0 {
               logger.Info("满足全部底库规则")
               return "true"
            }
         }
      }
      return "false"
   } else {
      for _,personGroup := range label.Persons  {
         for _,arg := range personGroup.Args {
            for _,liker := range arg.Liker{
               formula := liker.TableId + rule.Operator + rule.RuleValue
               expression, err:= govaluate.NewEvaluableExpression(formula);
               if err != nil {
                  logger.Error("表达式有误，请检查！",formula)
                  //return "false"
               }
               result, err1:= expression.Evaluate(nil)
               if err1 != nil {
                  logger.Error("带入参数有误")
                  //return "false"
               }
               if result.(bool) {
                  logger.Info("符合底库规则!")
                  return "true"
               }
            }
         }
      }
      return "false"
   }
   return flag
}

//是否符合人员规则
func personJudge(label *Label,rule *protomsg.EventPushRule) string{
   for _,personGroup := range label.Persons  {
      for _,person := range personGroup.Args {
         if rule.TopicArg == "sex" && strconv.Itoa(int(person.ThftRes.Gender)) == rule.RuleValue{
            logger.Info("符合人员性别规则！")
            return  "true"
         formula := ""
         if rule.TopicArg == "sex"{
            formula = strconv.Itoa(int(person.ThftRes.Gender)) + rule.Operator + rule.RuleValue
         }
         if rule.TopicArg == "race" && strconv.Itoa(int(person.ThftRes.Race)) == rule.RuleValue {
            logger.Info("符合人员种族规则！")
         if rule.TopicArg == "race"{
            formula = strconv.Itoa(int(person.ThftRes.Race)) + rule.Operator + rule.RuleValue
            return "true"
         }
         if rule.TopicArg == "age" && strconv.Itoa(int(person.ThftRes.Age)) == rule.RuleValue {
            logger.Info("符合人员年龄规则！")
         if rule.TopicArg == "age"{
            formula = strconv.Itoa(int(person.ThftRes.Age)) + rule.Operator + rule.RuleValue
            return "true"
         }
         if rule.TopicArg == "others" {
            // 其他这个值先这么处理
            return "true"
         }
         expression, err:= govaluate.NewEvaluableExpression(formula);
         if err != nil {
            logger.Error("表达式有误，请检查！",formula)
            //return "false"
         }
         result, err1:= expression.Evaluate(nil)
         if err1 != nil {
            logger.Error("带入参数有误")
            //return "false"
         }
         if result.(bool) {
            logger.Info("符合人员规则！",formula)
            return "true"
         }
      }
      if strconv.Itoa(int(personGroup.AlarmLevel)) == rule.RuleValue {
      if rule.TopicArg == "monitorLevel" {
         if rule.RuleValue == "all" {
            if len(personGroup.Args) > 0 {
               logger.Info("符合人员等级为全部的规则")
               return "true"
            }
         } else {
            formula := strconv.Itoa(int(personGroup.AlarmLevel)) + rule.Operator + rule.RuleValue
            expression, err:= govaluate.NewEvaluableExpression(formula);
            if err != nil {
               logger.Error("表达式有误，请检查！",formula)
               //return "false"
            }
            result, err1:= expression.Evaluate(nil)
            if err1 != nil {
               logger.Error("带入参数有误")
               //return "false"
            }
            if result.(bool) {
               logger.Info("符合人员等级规则!")
               return "true"
            }
         }
         logger.Info("符合人员报警等级规则！")
         return "true"
      }
@@ -186,21 +244,42 @@

// 是否符合布防等级规则
func defenceJudge(label *Label,rule *protomsg.EventPushRule) string{
   for _,def := range label.DefenceLevel {
      if strconv.Itoa(int(def)) == rule.RuleValue {
         logger.Info("符合布防等级规则！")
   if rule.RuleValue == "all" { // 布防等级为全部时只有有布防等级即为通过
      if len(label.DefenceLevel) > 0 {
         logger.Info("符合布防等级规则，布防等级为全部")
         return "true"
      } else {
         logger.Info("不符合布防等级规则")
         return "false"
      }
   } else {
      for _,def := range label.DefenceLevel {
         formula := strconv.Itoa(int(def)) + rule.Operator + rule.RuleValue
         expression, err:= govaluate.NewEvaluableExpression(formula);
         if err != nil {
            logger.Error("表达式有误，请检查！",formula)
            //return "false"
         }
         result, err1:= expression.Evaluate(nil)
         if err1 != nil {
            logger.Error("带入参数有误")
            //return "false"
         }
         if result.(bool) {
            logger.Info("符合布防等级规则!")
            return "true"
         }
      }
      logger.Info("不符合布防等级规则")
      return "false"
   }
   logger.Info("不符合布防等级规则")
   return "false"
}
// 是否符合任务规则
func taskJudge(label *Label,rule *protomsg.EventPushRule) string{
   formula := label.TaskId + rule.Operator + rule.RuleValue
   expression, err:= govaluate.NewEvaluableExpression(formula);
   if err != nil {
      logger.Error("表达式有误，请检查！")
      logger.Error("表达式有误，请检查！",formula)
      return "false"
   }
   result, err1:= expression.Evaluate(nil)