package labelFilter
|
|
import (
|
"basic.com/dbapi.git"
|
"basic.com/pubsub/protomsg.git"
|
"github.com/knetic/govaluate"
|
"ruleprocess/logger"
|
"ruleprocess/ruleserver"
|
"strconv"
|
"time"
|
)
|
|
func Judge(msg ruleserver.ResultMsg) {
|
// 装配成自己可以识别的数据
|
label := new(Label)
|
label.DataFormatToLabel(msg)
|
logger.Info("label的信息：", label.CameraName, label.DefenceLevel, label.Time)
|
if label.CameraName == "" {
|
logger.Error("无效数据，直接返回")
|
return
|
}
|
//拿到所有规则组
|
var api dbapi.EventPushApi
|
b, allRules := api.FindAllDetails()
|
logger.Info("查看所有规则组：", allRules)
|
if !b {
|
logger.Error("查询时间推送规则失败！")
|
}
|
//遍历所有的规则组，看看符合哪个规则组，就把数据插入到哪个规则组的目标机器上
|
for _, ruleGroup := range allRules {
|
if ruleGroup.Enable { // 大规则开关开启状态
|
// 先过时间规则
|
timeFlag := timeJudge(label, ruleGroup)
|
if !timeFlag {
|
logger.Info("不在规则的时间范围内，不推送！")
|
return
|
}
|
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 == "dbtable" {
|
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 == "alarmLevel" {
|
result += Connector + defenceJudge(label, rule)
|
}
|
}
|
// 得出总的判断结果
|
if result != "" {
|
logger.Info("总的判断结果：", result)
|
result = result[2:] // 把前两位字符去掉
|
expression, err := govaluate.NewEvaluableExpression(result);
|
if err != nil {
|
logger.Error("表达式有误，请检查！")
|
}
|
result, err1 := expression.Evaluate(nil)
|
if err1 != nil {
|
logger.Error("带入参数有误")
|
}
|
if result.(bool) {
|
logger.Info("通过规则，表达式为：", result)
|
// 推送服务器
|
pushData(ruleGroup.Urls, msg)
|
//os.Exit(1)
|
} else {
|
logger.Info("没通过规则,表达式为：", result)
|
//os.Exit(1)
|
}
|
}
|
}
|
}
|
|
//符合本规则组的就把数据推送到该目的服务器上
|
}
|
|
// 是否符合时间规则
|
func timeJudge(label *Label, groupRule protomsg.EventPush) bool {
|
timeNow := time.Now().Format("2006-01-02 15:04:05")
|
logger.Info("标签过滤器起始时间为：",groupRule.TimeStart,groupRule.TimeEnd)
|
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 {
|
expression, err := govaluate.NewEvaluableExpression("t1 < t2");
|
if err != nil {
|
logger.Error("表达式有误，请检查！")
|
}
|
parameters := make(map[string]interface{}, 8)
|
parameters["t1"] = time1
|
parameters["t2"] = time2
|
result, err1 := expression.Evaluate(parameters)
|
if err1 != nil {
|
logger.Error("带入参数有误")
|
}
|
return result.(bool)
|
}
|
|
// 是否符合摄像机规则
|
func cameraJudge(label *Label, rule *protomsg.EventPushRule) string {
|
formula := ""
|
if rule.TopicArg == "name" {
|
formula = "'" + label.CameraName + "'" + rule.Operator + "'" + rule.RuleValue + "'"
|
}
|
if rule.TopicArg == "addr" {
|
formula = "'" + label.CameraAddr + "'" + rule.Operator + "'" + rule.RuleValue + "'"
|
}
|
logger.Info("-------打印摄像机规则公式：",formula)
|
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"
|
}
|
|
// 是否符合底库规则
|
func baseJudge(label *Label, rule *protomsg.EventPushRule) string {
|
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);
|
logger.Info("-------打印底库规则公式：",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"
|
}
|
}
|
|
//是否符合人员规则
|
func personJudge(label *Label, rule *protomsg.EventPushRule) string {
|
for _, personGroup := range label.Persons {
|
for _, person := range personGroup.Args {
|
formula := ""
|
if rule.TopicArg == "sex" {
|
formula = strconv.Itoa(int(person.ThftRes.Gender)) + rule.Operator + rule.RuleValue
|
}
|
if rule.TopicArg == "race" {
|
formula = strconv.Itoa(int(person.ThftRes.Race)) + rule.Operator + rule.RuleValue
|
}
|
if rule.TopicArg == "age" {
|
formula = strconv.Itoa(int(person.ThftRes.Age)) + rule.Operator + rule.RuleValue
|
}
|
if rule.TopicArg == "otherInfo" {
|
// 其他这个值先这么处理
|
return "true"
|
}
|
logger.Info("-------打印人员规则公式：",formula)
|
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 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 + formate(rule.RuleValue)
|
logger.Info("-------打印人员等级规则公式：",formula)
|
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"
|
}
|
}
|
logger.Info("不符合人员规则")
|
return "false"
|
}
|
|
// 是否符合布防等级规则
|
func defenceJudge(label *Label, rule *protomsg.EventPushRule) string {
|
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 + formate(rule.RuleValue)
|
logger.Info("-------打印布防等级规则公式：",formula)
|
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"
|
}
|
}
|
|
// 是否符合任务规则
|
func taskJudge(label *Label, rule *protomsg.EventPushRule) string {
|
formula := "'"+label.TaskId +"'"+ rule.Operator +"'"+ rule.RuleValue+"'"
|
expression, err := govaluate.NewEvaluableExpression(formula);
|
logger.Info("-------打印任务规则公式：",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"
|
}
|
|
// 调用目标服务器的插入接口
|
func pushData(urls []*protomsg.PushUrl, data ruleserver.ResultMsg) {
|
for _, url := range urls {
|
logger.Debug("看看推送地址：",url.Url)
|
Push("tcp://192.168.1.123:40012", data)
|
}
|
}
|
|
// 把报警等级转化成汉字
|
func formate(str string) string {
|
var i string
|
if str == "一级" {
|
i = "1"
|
}
|
if str == "二级" {
|
i = "2"
|
}
|
if str == "三级" {
|
i = "3"
|
}
|
if str == "四级" {
|
i = "4"
|
}
|
if str == "五级" {
|
i = "5"
|
}
|
return i
|
}
|
