修改日志模块儿，修改sdkmsg相关内容（sdkId和sdkName不再传了）

panlei

2019-07-09 4108e6734c74b279aab8fe6ace886f4c134ed63b

修改日志模块儿，修改sdkmsg相关内容（sdkId和sdkName不再传了）

 go.mod

@@ -5,7 +5,7 @@
require (
    basic.com/dbapi.git v0.0.0-20190701055817-73bca225181f
    basic.com/pubsub/cache.git v0.0.0-20190708074039-d25f504c5fab
    basic.com/pubsub/protomsg.git v0.0.0-20190708093242-02e81455712c
    basic.com/pubsub/protomsg.git v0.0.0-20190709070734-b34c868adcc2
    basic.com/valib/deliver.git v0.0.0-20190531095353-25d8c3b20051
    basic.com/valib/gopherdiscovery.git v0.0.0-20190605034340-15d89d8b4e28
    basic.com/valib/gosdk.git v0.0.0-20190531034110-0062fdaaa05a // indirect

 go.sum

@@ -4,6 +4,8 @@
basic.com/pubsub/cache.git v0.0.0-20190708074039-d25f504c5fab/go.mod h1:gHLJZz2ee1cGL0X0ae69fs56bAxkDgEQwDhhXZJNUcY=
basic.com/pubsub/protomsg.git v0.0.0-20190708093242-02e81455712c h1:p6bCit0NDQvC9ziK9Zf815LXgTYWxjr4mn99gcdehyk=
basic.com/pubsub/protomsg.git v0.0.0-20190708093242-02e81455712c/go.mod h1:un5NV5VWQoblVLZfx1Rt5vyLgwR0jI92d3VJhfrJhWU=
basic.com/pubsub/protomsg.git v0.0.0-20190709070734-b34c868adcc2 h1:ygh9CQPS48KmXv+PNUrOcrMqIiDZOs11apnQdu9oGEY=
basic.com/pubsub/protomsg.git v0.0.0-20190709070734-b34c868adcc2/go.mod h1:un5NV5VWQoblVLZfx1Rt5vyLgwR0jI92d3VJhfrJhWU=
basic.com/valib/deliver.git v0.0.0-20190531095353-25d8c3b20051 h1:9flC2o3kasaM2Y6I+mY+mxmve/pyAY/UzGQZLT3lFHM=
basic.com/valib/deliver.git v0.0.0-20190531095353-25d8c3b20051/go.mod h1:bkYiTUGzckyNOjAgn9rB/DOjFzwoSHJlruuWQ6hu6IY=
basic.com/valib/gopherdiscovery.git v0.0.0-20190605034340-15d89d8b4e28 h1:3hejanzPEBvZSSvjIqayB83/6/6SLLrX9oNZAdiYELg=

 logger/logger.go

@@ -55,8 +55,8 @@

func init()  {
    logFile.saveMode = ByDay    // 默认按天保存
    logFile.saveDays = 15        // 默认保存三天的
    logFile.level = ErrorLevel
    logFile.saveDays = 7        // 默认保存三天的
    logFile.level = DebugLevel
    logFile.filesize = 1024 * 1024 * 10    // 默认10M， 需要设置 saveMode 为 BySize
}


 main.go

@@ -26,13 +26,9 @@
var pubPort = flag.Int("pubPort",50007,"pubsub port") //数据更新
var initchan = make(chan bool)
func init () {
    var logFile = "./info.log"
    var logSaveDays    =    15

    // 日志初始化
    logger.Config(logFile, logger.DebugLevel)
    logger.SetSaveDays(logSaveDays)
    logger.Info("loginit success !")
    logger.Config("./info.log", logger.DebugLevel)
    logger.Info("日志初始化成功！")

}
func main() {
@@ -127,8 +123,7 @@
        if sdkinfo.Sdktype == "Yolo" {
            arg := ruleserver.SdkData{}
            arg.TaskId = m.Tasklab.Taskid
            arg.SdkId = sdkinfo.Sdkid
            arg.SdkName = sdkinfo.SdkName
            arg.IpcId = sdkinfo.Ipcid
            arg.IsYolo = true
            bdata, err := util.UnCompress(m.Data)
            if err != nil {
@@ -149,7 +144,7 @@
                    logger.Info("解析YOLO sdk数据时出现错误", err)
                    continue
                }
                logger.Info("------当前算法name",sdkinfo.SdkName,"--------------看看yolo中有几个目标：",len(yoloParam.Infos))
                logger.Info("--------------看看yolo中有几个目标：",len(yoloParam.Infos))
                for _, info := range yoloParam.Infos {
                    if info.Typ == 0 {
                        photoMap := ruleserver.PhotoMap{Rects: rectFormat(info.RcObj), Score: float64(info.Prob)*100,IsYolo:true}
@@ -165,8 +160,7 @@
        if sdkinfo.Sdktype == "FaceDetect" { // 人脸检测
            arg := ruleserver.SdkData{}
            arg.TaskId = m.Tasklab.Taskid
            arg.SdkId = sdkinfo.Sdkid
            arg.SdkName = sdkinfo.SdkName
            arg.IpcId = sdkinfo.Ipcid
            arg.IsYolo = false
            bdata, err := util.UnCompress(m.Data)
            if err != nil {
@@ -186,7 +180,7 @@
                    logger.Info("解析FACE sdk数据时出现错误", err)
                    continue
                }
                logger.Info("------当前算法name",sdkinfo.SdkName,"--------------看看人脸检测中有几个目标：",len(faceParam.Faces))
                logger.Info("--------------看看人脸检测中有几个目标：",len(faceParam.Faces))
                for _, info := range faceParam.Faces {
                    photoMap := ruleserver.PhotoMap{Rects: rectFormat(info.Pos.RcFace), Score: float64(info.Pos.Quality)*100, IsYolo:false,ThftRes:*(info.Result),Feature:info.Feats}
                    arg.Photo = append(arg.Photo, photoMap)

 ruleserver/ruleToformula.go

@@ -14,9 +14,11 @@
    "basic.com/pubsub/protomsg.git"
    "github.com/knetic/govaluate"
)
func init () {

func init() {
    bigCache.Init()
}

// 任务
type Task struct {
    camID     string //摄像机ID
@@ -65,7 +67,6 @@
    Size       float64 // 区域内的目标的尺寸
    IsYolo     bool    // 是否是yolo数据
    Location   Rect    // 记下每个目标的位置参数，最后给结果装配人脸数据的时候用的到
    SdkName    string
    Feature    []byte
    ThftRes    protomsg.ThftResult
    Liker      []*protomsg.Baseinfo
@@ -100,7 +101,6 @@
    Rects   Rect    // 矩形区域参数
    Score   float64 // 相似度得分（有多大程度像一个目标。人脸，人体或车等等）
    IsYolo  bool    // 是否是yolo数据
    SdkName string
    ThftRes protomsg.ThftResult
    Feature []byte
}
@@ -108,8 +108,7 @@
// 每个算法对于当前帧画面自己提取的数据
type SdkData struct {
    TaskId      string
    SdkId       string
    SdkName     string
    IpcId       string
    IsYolo      bool
    Photo       []PhotoMap // yolo算法结构，也可以存人脸的数据，毕竟人脸中能用规则来测的还是那些参数
    KeepRight   bool       // 是否靠右行 算法判断的与上一帧图像的比较结果
@@ -185,7 +184,7 @@

// 把sdk从数据帧上提取的按照区域分类归置
func SdkDataFormat(cameraId string, arg *SdkData, cameraPolygons []protomsg.CameraPolygon) {
    logger.Info("--------看看解析出来的数据---",*arg)
    logger.Info("--------看看解析出来的数据---", *arg)
    for _, polygon := range cameraPolygons {
        //logger.Println("++++++在这儿看一下区域啊:", polygon.Polygon)
        areaMap := AreaMap{cameraId: cameraId, areaId: polygon.Id, areaJson: polygon.Polygon, triggerLine: polygon.TriggerLine, directionLine: polygon.DirectionLine}
@@ -237,8 +236,8 @@
    compareFlag := false
    // 看看是否有只配人脸比对算法但没有配对比库的规则，如果有，则比对对象为全部底库
    for j := 0; j < len(groupRule.Rules); j++ {
        if groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a972" {
            if groupRule.Rules[j].SdkArgAlias == "compareBase" {
        if groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a972" { // 配了人脸比对
            if groupRule.Rules[j].SdkArgAlias == "compareBase" { // 配了比对的底库
                compareFlag = true
            }
        }
@@ -252,14 +251,17 @@
        // 只有是人脸对比并且配置的参数是对比底库才走（若配的对比阈值则不走）
        if groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a972" && groupRule.Rules[j].SdkArgAlias == "compareBase" {
            for _, sdkData := range args.Sdkdata {
                if sdkData.SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" { // 搜索到人脸检测的sdkdata 现在关于人脸的只有他一个sdk，全找他
                if sdkData.IpcId == "812b674b-2375-4589-919a-5c1c3278a97e" { // 搜索到人脸检测的sdkdata 现在关于人脸的只有他一个sdk，全找他
                    for _, areaMap := range sdkData.AreaMapList {
                        // 拿区域中每个人脸特征值去对比，填充其liker
                        if groupRule.Rules[j].PolygonId == areaMap.areaId {
                            for _, arg := range areaMap.args {
                                bytes := bigCache.Getdbpersonmsg("", arg.Feature, true)
                                var m map[string]float32
                                json.Unmarshal(bytes, &m)
                                err1 := json.Unmarshal(bytes, &m)
                                if err1 != nil {
                                    logger.Error("getBaseInfo解压错误", err1)
                                }
                                for key, val := range m {
                                    fmt.Println(key)
                                    baseinfo := protomsg.Baseinfo{}
@@ -284,14 +286,28 @@
    logger.Info("+++++++++++规则开始运行+++++++++++++++++当前规则--：", *groupRule)
    Compare(args, groupRule)
    resultSplice := []*LittleRuleResult{}
    sdkNames := ""
    // 先过完条件规则
    for j := 0; j < len(groupRule.Rules); j++ {
        for _, sdkData := range args.Sdkdata {
            for _, areaMap := range sdkData.AreaMapList {
                ruleResult := filterRule(groupRule.Rules[j], &areaMap)
                if ruleResult.Result != "" {
                    logger.Info("条件规则结果：", ruleResult.Result)
                    resultSplice = append(resultSplice, &ruleResult)
            // 根据规则的sdkId查出其对应的ipcId，用ipcId去找该比对的数据
            sdk, err := cache.GetSdkById(groupRule.Rules[j].SdkId)
            if err != nil {
                logger.Error("没查到sdk的信息---", err)
            }
            ipcId := sdk.IpcId
            sdkName := sdk.SdkName
            if ipcId == sdkData.IpcId {
                for _, areaMap := range sdkData.AreaMapList {
                    ruleResult := filterRule(groupRule.Rules[j], &areaMap)
                    if ruleResult.Result != "" {
                        logger.Info("条件规则结果：", ruleResult.Result)
                        // 如果此结果为真且当前过的是yolo算法，应记下此规则所对应的sdkName,另外，还要去重
                        if ruleResult.Result == "true" && ipcId == "" && !strings.Contains(sdkNames, sdkName) {
                            sdkNames = sdkName + ","
                        }
                        resultSplice = append(resultSplice, &ruleResult)
                    }
                }
            }
        }
@@ -300,11 +316,23 @@
    // 再过其他数据 这步直接得到结果（真或假） 过目标数量
    for j := 0; j < len(groupRule.Rules); j++ {
        for _, sdkData := range args.Sdkdata {
            for _, areaMap := range sdkData.AreaMapList {
                ruleResult := transferParameters(groupRule.Rules[j], &areaMap)
                if ruleResult.Result != "" {
                    logger.Info("数量规则结果：", ruleResult.Result)
                    resultSplice = append(resultSplice, &ruleResult)
            // 根据规则的sdkId查出其对应的ipcId，用ipcId去找该比对的数据
            sdk, err := cache.GetSdkById(groupRule.Rules[j].SdkId)
            if err != nil {
                logger.Error("没查到sdk的信息---", err)
            }
            ipcId := sdk.IpcId
            sdkName := sdk.SdkName
            if ipcId == sdkData.IpcId {
                for _, areaMap := range sdkData.AreaMapList {
                    ruleResult := transferParameters(groupRule.Rules[j], &areaMap)
                    if ruleResult.Result != "" {
                        logger.Info("数量规则结果：", ruleResult.Result)
                        if ruleResult.Result == "true" && ipcId == "" && !strings.Contains(sdkNames, sdkName) {
                            sdkNames = sdkName + ","
                        }
                        resultSplice = append(resultSplice, &ruleResult)
                    }
                }
            }
        }
@@ -312,11 +340,22 @@
    // 这步过的是时间规则（时间段等）
    for j := 0; j < len(groupRule.Rules); j++ {
        for _, sdkData := range args.Sdkdata {
            for _, areaMap := range sdkData.AreaMapList {
                ruleResult := timeRuleResult(groupRule.Rules[j], &areaMap)
                if ruleResult.Result != "" {
                    logger.Info("时间规则结果：", ruleResult.Result)
                    resultSplice = append(resultSplice, &ruleResult)
            sdk, err := cache.GetSdkById(groupRule.Rules[j].SdkId)
            if err != nil {
                logger.Error("没查到sdk的信息---", err)
            }
            ipcId := sdk.IpcId
            sdkName := sdk.SdkName
            if ipcId == sdkData.IpcId {
                for _, areaMap := range sdkData.AreaMapList {
                    ruleResult := timeRuleResult(groupRule.Rules[j], &areaMap)
                    if ruleResult.Result != "" {
                        logger.Info("时间规则结果：", ruleResult.Result)
                        if ruleResult.Result == "true" && ipcId == "" && !strings.Contains(sdkNames, sdkName) {
                            sdkNames = sdkName + ","
                        }
                        resultSplice = append(resultSplice, &ruleResult)
                    }
                }
            }
        }
@@ -324,8 +363,15 @@
    // 最后过持续时间等时间维度的条件
    for j := 0; j < len(groupRule.Rules); j++ {
        for _, sdkData := range args.Sdkdata {
            for _, areaMap := range sdkData.AreaMapList {
                duration(groupRule.Rules[j], &areaMap)
            sdk, err := cache.GetSdkById(groupRule.Rules[j].SdkId)
            if err != nil {
                logger.Error("没查到sdk的信息---", err)
            }
            ipcId := sdk.IpcId
            if ipcId == sdkData.IpcId {
                for _, areaMap := range sdkData.AreaMapList {
                    duration(groupRule.Rules[j], &areaMap)
                }
            }
        }
    }
@@ -398,36 +444,27 @@
            }
            if flag {
                logger.Warn("___________________________________________________________________________终于走完万里长征")
                // 如果成功了我应该找到规则中涉及到的sdk，记录下他们的sdkname
                sdkName := ""
                for j := 0; j < len(groupRule.Rules); j++ {
                    for _, sdkData := range args.Sdkdata {
                        if groupRule.Rules[j].SdkId == sdkData.SdkId && sdkData.IsYolo && !strings.Contains(sdkName, sdkData.SdkName) { // 只记录yolo符合规则的sdk 同时要避免重复拼接
                            sdkName = sdkData.SdkName + " "
                // 把他们的位置数据也传下去
                locations := []Rect{}
                for _, sdkData := range args.Sdkdata {
                    for _, areaMap := range sdkData.AreaMapList {
                        for j := 0; j < len(groupRule.Rules); j++ {
                            locations = append(locations, putYolosToResult(groupRule.Rules[j], &areaMap)...)
                        }
                    }
                }
                if sdkName != "" {
                    // 把他们的位置数据也传下去
                    locations := []Rect{}
                    for _, sdkData := range args.Sdkdata {
                        for _, areaMap := range sdkData.AreaMapList {
                            for j := 0; j < len(groupRule.Rules); j++ {
                                locations = append(locations, putYolosToResult(groupRule.Rules[j], &areaMap)...)
                            }
                        }
                    }
                    //// 配了人脸的算法才把人脸的数据甩出来打标签
                    //flag11 := false
                    //for j := 0; j < len(groupRule.Rules); j++ {
                    //    if groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" || groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a971" {
                    //        flag11 = true
                    //    }
                    //}
                    //if flag11 {
                    //    args.RuleResult["face"] = faces
                    //}
                    args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkName, groupRule.GroupId, groupRule.AlarmLevel, groupRule.GroupText, locations})
                //// 配了人脸的算法才把人脸的数据甩出来打标签
                //flag11 := false
                //for j := 0; j < len(groupRule.Rules); j++ {
                //    if groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" || groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a971" {
                //        flag11 = true
                //    }
                //}
                //if flag11 {
                //    args.RuleResult["face"] = faces
                //}
                if sdkNames != "" {
                    args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkNames, groupRule.GroupId, groupRule.AlarmLevel, groupRule.GroupText, locations})
                    logger.Info("-------------------yolo结果标签", args.RuleResult["yolo"].([]Result))
                }
                if args.RuleResult["face"] != nil {
@@ -445,7 +482,7 @@

func putFaceToResult(rule *protomsg.Rule, am *AreaMap) []Arg {
    faces := []Arg{}
    if rule.SdkId == am.sdkId && rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" || rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a972" {
    if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" || rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a972" {
        if len(am.filterData) > 0 {
            for _, data := range am.filterData {
                faces = append(faces, data)
@@ -458,7 +495,7 @@

func putYolosToResult(rule *protomsg.Rule, am *AreaMap) []Rect {
    locations := []Rect{}
    if rule.SdkId == am.sdkId && rule.SdkId != "812b674b-2375-4589-919a-5c1c3278a97e" && rule.SdkId != "812b674b-2375-4589-919a-5c1c3278a972" {
    if rule.SdkId != "812b674b-2375-4589-919a-5c1c3278a97e" && rule.SdkId != "812b674b-2375-4589-919a-5c1c3278a972" {
        if len(am.filterData) > 0 {
            for _, data := range am.filterData {
                locations = append(locations, data.Location)
@@ -491,14 +528,12 @@
        if threshold <= obj.Score && size <= float64(obj.Rects.Width*obj.Rects.Height) && intersectionper <= PgsInterPercent(areaPoints, obj.Rects, widthScale, heigthScale) {
            // 这步要备齐表达式里所需要的所有参数
            a.targetNum++
            arg1 := Arg{obj.Score, PgsInterPercent(areaPoints, obj.Rects, widthScale, heigthScale), float64(obj.Rects.Width * obj.Rects.Height), obj.IsYolo, obj.Rects, obj.SdkName, obj.Feature, obj.ThftRes, []*protomsg.Baseinfo{}}
            arg1 := Arg{obj.Score, PgsInterPercent(areaPoints, obj.Rects, widthScale, heigthScale), float64(obj.Rects.Width * obj.Rects.Height), obj.IsYolo, obj.Rects, obj.Feature, obj.ThftRes, []*protomsg.Baseinfo{}}
            //logger.Println("放进去的arg：-------", arg1)
            a.args = append(a.args, arg1)
            a.filterData = append(a.filterData, arg1)
        }
    }
    a.sdkId = arg.SdkId
    a.sdkName = arg.SdkName
    a.time = time.Unix(time.Now().Unix(), 0).String()[11:16]
    a.keepRight = arg.KeepRight
    a.isStatic = arg.IsStatic
@@ -604,18 +639,8 @@
                result, _ := expression.Evaluate(nil) // 得到数学公式的结果
                if result.(bool) {
                    logger.Info("___________________________________________________________________联动任务报警")
                    sdkName := ""
                    for j := 0; j < len(groupRule.Rules); j++ {
                        for _, sdkData := range args.Sdkdata {
                            if groupRule.Rules[j].SdkId == sdkData.SdkId && sdkData.IsYolo && !strings.Contains(sdkName, sdkData.SdkName) { // 只记录yolo符合规则的sdk 同时要避免重复拼接
                                sdkName = sdkData.SdkName + " "
                            }
                        }
                    }
                    if sdkName != "" {
                        args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkName, groupRule.GroupId, groupRule.AlarmLevel, groupRule.GroupText, []Rect{}})
                        logger.Info("-------------------yolo结果标签", args.RuleResult["yolo"].([]Result))
                    }
                    args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, "", groupRule.GroupId, groupRule.AlarmLevel, groupRule.GroupText, []Rect{}})
                    logger.Info("-------------------yolo结果标签", args.RuleResult["yolo"].([]Result))
                    if args.RuleResult["face"] != nil {
                        logger.Info("-------------------face结果标签", args.RuleResult["face"].([]Arg))
                    }
@@ -641,8 +666,8 @@
func filterRule(rule *protomsg.Rule, am *AreaMap) LittleRuleResult {
    if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" || rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a972" {
        // 处理的是人脸算法 如果这条规则配置的是人脸算法，过滤完条件之后直接得出结果，因为肯定没有数量条件，自己拼接
        logger.Info("规则的算法id和区域的算法id：", rule.SdkId, "===", am.sdkId)
        if rule.SdkId == am.sdkId && rule.PolygonId == am.areaId { // 算法和区域都得对的上
        //logger.Info("规则的算法id和区域的算法id：", rule.SdkId, "===", am.sdkId)
        if rule.PolygonId == am.areaId { // 算法和区域都得对的上

            if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a972" && rule.SdkArgAlias != "time_rule" {
                // 只需要过滤阈值，过滤完后数组长度大于0即为报警，但要考虑如何对每一张都报警呢
@@ -729,7 +754,7 @@
        }
    } else {
        // 处理的都是yolo数据
        if rule.SdkId == am.sdkId && rule.PolygonId == am.areaId { // 首先这条规则得是这个算法的规则，其次规则所对应的区域id要跟区域数据的id对的上
        if rule.PolygonId == am.areaId { // 首先这条规则得是这个算法的规则，其次规则所对应的区域id要跟区域数据的id对的上
            if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
                logger.Info("----------当前条件规则：---------", rule)
                var args []Arg
@@ -777,7 +802,7 @@

// 都过滤完条件之后看看是否要创建一个定时器元素 创建定时器的条件：是否有靠右行，个体静止等自带定时器含义的算法以及是否有持续时间
func duration(rule *protomsg.Rule, am *AreaMap) {
    if rule.SdkId == am.sdkId && rule.PolygonId == am.areaId { // 首先规则所对应的区域id要跟区域数据的id对的上  配置的算法要对的上
    if rule.PolygonId == am.areaId { // 首先规则所对应的区域id要跟区域数据的id对的上  配置的算法要对的上
        if rule.SdkArgAlias == "duration" { //
            // 先看看定时器元素队列中是否有这个摄像机这个区域的定时器,如果有就不能再次创建了
            var flag bool = true
@@ -816,7 +841,7 @@

// 给数据库的规则表达式代参 args: 一条子规则，区域数据
func transferParameters(rule *protomsg.Rule, am *AreaMap) LittleRuleResult {
    if rule.SdkId == am.sdkId && rule.PolygonId == am.areaId { // 首先规则所对应的区域id要跟区域数据的id对的上
    if rule.PolygonId == am.areaId { // 首先规则所对应的区域id要跟区域数据的id对的上
        if rule.SdkArgAlias == "targetNum" { // 如果参数是要区域内目标数量 即yolo 人脸不会有数量
            //logger.Info("得出结果阶段", "比较的规则是：", rule)
            if rule.Operator == "" {
@@ -851,7 +876,7 @@
    return LittleRuleResult{}
}
func timeRuleResult(rule *protomsg.Rule, am *AreaMap) LittleRuleResult {
    if rule.PolygonId == am.areaId && rule.SdkId == am.sdkId { // 首先规则所对应的区域id要跟区域数据的id对的上
    if rule.PolygonId == am.areaId { // 首先规则所对应的区域id要跟区域数据的id对的上
        if rule.SdkArgAlias == "time_rule" { // 判断是否符合时间规则
            logger.Info("----------当前时间规则：---------", rule)
            // 根据放值字段里存的时间规则的id去另一个表里查需要比对的时间段（比如当前时间是周三，应根据区域id查出其周三的几个布防时间段，数组）
@@ -939,7 +964,10 @@
    //}
    _, cameraTimeRule := cache.GetTimeRuleById(id)
    var timeRangeList []day
    json.Unmarshal([]byte(cameraTimeRule.TimeRule), &timeRangeList)
    err := json.Unmarshal([]byte(cameraTimeRule.TimeRule), &timeRangeList)
    if err != nil {
        logger.Error("取时间规则时反序列化错误！")
    }
    for _, timerange := range timeRangeList {
        if timerange.Day == index {
            //logger.Println("取到的时间规则：", timerange.TimeRange)