~jinersong/ruleprocess.git

			@@ -1,27 +1,85 @@
			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("查询时间推送规则失败！")
			}
			//遍历所有的规则组，看看符合哪个规则组，就把数据插入到哪个规则组的目标机器上

			//先判断时间规则，不符合此规则，直接略过

			//遍历规则组中的小规则，每个小规则得出一个string类型的bool值，然后用 && 或 \|\| 拼接起来

			//得出总的判断结果
			for _,ruleGroup := range allRules {
			// 先过时间规则
			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("带入参数有误")
			}
			if result.(bool) {
			logger.Info("通过规则，表达式为：",result)
			// 推送服务器
			pushData(ruleGroup.IpPorts,result.(ruleserver.ResultMsg))
			} else {
			logger.Info("没通过规则,表达式为：",result)
			}
			}
			}

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

			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{
			@@ -40,25 +98,95 @@
			}

			// 是否符合摄像机规则
			func cameraJudge(label Label,rule Rule) string{
			return "true"
			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 Rule) string{
			return "true"
			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 Rule) string{
			return "true"
			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 Rule) string{
			return "true"
			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 (data ruleserver.ResultMsg){
			func pushData (urls []*protomsg.PushIpPort, data ruleserver.ResultMsg){

			}