---

panlei

2019-08-02 37ffeb19d83534c80d306602a5cc094da024e04f

 labelFilter/ruleForLabel.go

@@ -1,16 +1,88 @@
package labelFilter

import (
   "basic.com/dbapi.git"
   "basic.com/pubsub/protomsg.git"
   "github.com/knetic/govaluate"
   "ruleprocess/logger"
   "ruleprocess/ruleserver"
   "strconv"
   "time"
)

func Judge(){
func Judge(label *Label, result ruleserver.ResultMsg){
   //拿到所有规则组
   var api dbapi.EventPushApi
   b,allRules := api.FindAllDetails()
   if !b {
      logger.Error("查询时间推送规则失败！")
   }
   //遍历所有的规则组，看看符合哪个规则组，就把数据插入到哪个规则组的目标机器上
   for _,ruleGroup := range allRules {
      if ruleGroup.Enable {  // 大规则开关开启状态
         // 先过时间规则
         timeJudge(label,ruleGroup)
         result := ""
         var Connector string
         if ruleGroup.IsSatisfyAll {
            Connector = "&&"
         } else {
            Connector = "||"
         }
         for _,rule := range ruleGroup.Rules {
            // 过每一个小规则
            if rule.TopicType == "camera" {
               result = Connector + cameraJudge(label,rule)
            }
            if rule.TopicType == "baseLibrary" {
               result = Connector + baseJudge(label,rule)
            }
            if rule.TopicType == "task" {
               result = Connector + taskJudge(label,rule)
            }
            if rule.TopicType == "person" {
               result = Connector + taskJudge(label,rule)
            }
            if rule.TopicType == "defence" {
               result = Connector + defenceJudge(label,rule)
            }
         }
         // 得出总的判断结果
         if result != "" {
            result = result[2:] // 把前两位字符去掉
            expression, err:= govaluate.NewEvaluableExpression(result);
            if err != nil {
               logger.Error("表达式有误，请检查！")
            }
            result, err1:= expression.Evaluate(nil)
            if err1 != nil {
               logger.Error("带入参数有误")
            }
            logger.Warn("规则判断结果是：",)
            if result.(bool) {
               logger.Info("通过规则，表达式为：",result)
               // 推送服务器
               pushData(ruleGroup.Urls,result.(ruleserver.ResultMsg))
            } else {
               logger.Info("没通过规则,表达式为：",result)
            }
         }
      }
   }

   //符合本规则组的就把数据推送到该目的服务器上
}
//
func timeJudge(label *Label,groupRule *GroupRule){

// 是否符合时间规则
func timeJudge(label *Label,groupRule protomsg.EventPush) string{
   timeNow := time.Now().Format("2006-01-02 15:04:05")
   flag1 := isBefore(groupRule.TimeStart,timeNow)
   flag2 := isBefore(timeNow,groupRule.TimeEnd)
   if flag1 && flag2 {
      return "true"
   } else {
      logger.Info("不在规定的时间范围内！")
      return "false"
   }
}
// 传入两个时间的字符串，判断第一个时间是否小于第二个时间
func isBefore(time1 string,time2 string) bool{
@@ -26,4 +98,98 @@
      logger.Error("带入参数有误")
   }
   return result.(bool)
}

// 是否符合摄像机规则
func cameraJudge(label *Label,rule *protomsg.EventPushRule) string{
   if rule.TopicArg == "cameraName" {
      if label.CameraName == rule.RuleValue {
         logger.Info("符合摄像机名称规则")
         return "true"
      } else {
         logger.Info("不符合摄像机名称规则")
         return "false"
      }
   }
   if rule.TopicArg == "cameraLocation" {
      if label.CameraAddr == rule.RuleValue {
         logger.Info("符合摄像机位置规则")
         return "true"
      } else {
         logger.Info("不符合摄像机位置规则")
         return "false"
      }
   }
   return ""
}

// 是否符合底库规则
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"
            }
         }
      }
   }
   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"
         }
         if rule.TopicArg == "race" && strconv.Itoa(int(person.ThftRes.Race)) == rule.RuleValue {
            logger.Info("符合人员种族规则！")
            return "true"
         }
         if rule.TopicArg == "age" && strconv.Itoa(int(person.ThftRes.Age)) == rule.RuleValue {
            logger.Info("符合人员年龄规则！")
            return "true"
         }
         if rule.TopicArg == "others" {
            // 其他这个值先这么处理
            return "true"
         }
      }
      if strconv.Itoa(int(personGroup.AlarmLevel)) == rule.RuleValue {
         logger.Info("符合人员报警等级规则！")
         return "true"
      }
   }
   logger.Info("不符合人员规则")
   return "false"
}

// 是否符合布防等级规则
func defenceJudge(label *Label,rule *protomsg.EventPushRule) string{
   for _,def := range label.DefenceLevel {
      if strconv.Itoa(int(def)) == rule.RuleValue {
         logger.Info("符合布防等级规则！")
         return "true"
      }
   }
   logger.Info("不符合布防等级规则")
   return "false"
}
// 是否符合任务规则
func taskJudge(label *Label,rule *protomsg.EventPushRule) string{
   if label.TaskId == rule.RuleValue {
      logger.Info("符合任务规则!")
      return "true"
   }
   logger.Info("不符合任务规则")
   return "false"
}
// 调用目标服务器的插入接口
func pushData (urls []*protomsg.PushUrl, data ruleserver.ResultMsg){

}