fix

sunty

2020-10-23 e189b1942c8130d473a1a4128c3d9ef5edfaa564

 EsClient.go

@@ -476,7 +476,174 @@
   return tmpinfos
}

func SourceAggregations(buf [] byte, thresholdTime float64) (sources map[string]interface{}, err error) {
func FaceSourceAggregations(buf []byte, thresholdTime int, thresholdStayTime int) (sources []map[string]interface{}, err error) {
   loc, err := time.LoadLocation("Asia/Shanghai")
   if err != nil {
      return nil, errors.New("时区设置错误")
   }
   var info interface{}
   json.Unmarshal(buf, &info)
   out, ok := info.(map[string]interface{})
   if !ok {
      return nil, errors.New("http response interface can not change map[string]interface{}")
   }
   middle, ok := out["aggregations"].(map[string]interface{})
   if !ok {
      return nil, errors.New("first hits change error!")
   }
   bucketsAggs := middle["buckets_aggs"].(map[string]interface{})
   buckets := bucketsAggs["buckets"].([]interface{})
   if len(buckets) == 0 {
      return nil, nil
   }
   allSource := make([]map[string]interface{}, 0)
   for _, inf := range buckets {
      hitsSources := make([]map[string]interface{}, 0)
      topAttentionHits := inf.(map[string]interface{})["top_attention_hits"].(map[string]interface{})
      middleHits := topAttentionHits["hits"].(map[string]interface{})
      finalHits := middleHits["hits"].([]interface{})
      startTime := ""
      indexLength := len(finalHits)
      point := 0
      for _, in := range finalHits {
         point = point + 1
         tmpHitSource := make(map[string]interface{})
         tmpBuf, ok := in.(map[string]interface{})
         if !ok {
            fmt.Println("change to source error!")
            continue
         }
         source, ok := tmpBuf["_source"].(map[string]interface{})
         if !ok {
            fmt.Println("change _source error!")
            continue
         }
         baseInfo := source["baseInfo"].([]interface{})[0].(map[string]interface{})
         targetInfo := source["targetInfo"].([]interface{})[0].(map[string]interface{})
         tmpTime := source["picDate"].(string)
         mTime, err := time.ParseInLocation("2006-01-02 15:04:05", tmpTime, loc)
         if err != nil {
            return nil, errors.New("时间解析错误")
         }

         sTime := tmpTime
         eTime := mTime.Add(time.Second * 1).Format("2006-01-02 15:04:05")
         stayTime := 1.0
         if startTime != "" && point <= indexLength {
            sinTime, _ := time.ParseInLocation("2006-01-02 15:04:05", startTime, loc)
            passTime := math.Abs(mTime.Sub(sinTime).Seconds())
            hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
            //fmt.Println("passTime:   ", passTime)
            if int(passTime) <= thresholdTime {
               if point == indexLength {
                  hitStartTime := hitsSources[len(hitsSources)-1]["startTime"].(string)
                  realStartTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitStartTime, loc)
                  stayTime = math.Abs(mTime.Sub(realStartTime).Seconds())
                  hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
                  hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
                  startTime = ""
               } else {
                  startTime = tmpTime
                  hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
               }
               continue
            } else {
               hitStartTime := hitsSources[len(hitsSources)-1]["startTime"].(string)
               hitEndTime := hitsSources[len(hitsSources)-1]["endTime"].(string)
               realStartTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitStartTime, loc)
               realEndTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitEndTime, loc)
               stayTime = math.Abs(realEndTime.Sub(realStartTime).Seconds())
               if sinTime.Sub(mTime).Seconds() == 0{
                  sinTime.Add(time.Second * 1)
                  sinTime.Format("2006-01-02 15:04:05")
                  hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
                  stayTime = 1
               } else if stayTime == 0{
                  stayTime = 1
                  hitsSources[len(hitsSources)-1]["endTime"] = realEndTime.Add(time.Second*1).Format("2006-01-02 15:04:05")
               }
               hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
               if point == indexLength {
                  stayTime = 1
               }
               startTime = ""
            }
         }
         //fmt.Println("========================================================")
         startTime = tmpTime
         tmpHitSource["faceId"] = baseInfo["targetId"].(string)
         if targetInfo["areaId"] == nil {
            continue
         }
         tmpHitSource["areaId"] = targetInfo["areaId"].(string)
         tmpHitSource["startTime"] = sTime
         tmpHitSource["faceImg"] = targetInfo["picSmUrl"].(string)
         tmpHitSource["endTime"] = eTime
         tmpHitSource["stayTime"] = stayTime
         hitsSources = append(hitsSources, tmpHitSource)
      }
      allSource = append(allSource, hitsSources...)
   }
   return allSource, nil
}

func SourceDeduplication(buf [] byte) ([]map[string]interface{}, error) {
   var info interface{}
   json.Unmarshal(buf, &info)
   out, ok := info.(map[string]interface{})
   if !ok {
      return nil, errors.New("http response interface can not change map[string]interface{}")
   }
   middle, ok := out["aggregations"].(map[string]interface{})
   if !ok {
      return nil, errors.New("first hits change error!")
   }
   bucketsAggs := middle["buckets_aggs"].(map[string]interface{})
   buckets := bucketsAggs["buckets"].([]interface{})
   if len(buckets) == 0 {
      return nil, nil
   }
   faceId := make([]map[string]interface{}, 0)
   for _, in := range buckets {
      tmpInfo := make(map[string]interface{})
      topAttentionHits := in.(map[string]interface{})["top_attention_hits"].(map[string]interface{})
      middleHits := topAttentionHits["hits"].(map[string]interface{})
      finalHits := middleHits["hits"].([]interface{})
      tmpInfo["faceId"] = in.(map[string]interface{})["key"].(map[string]interface{})["faceId"].(string)
      tmpInfo["lastTime"] = finalHits[0].(map[string]interface{})["_source"].(map[string]interface{})["picDate"].(string)
      faceId = append(faceId, tmpInfo)
   }
   return faceId, nil
}

//解析聚合计数结构
func SourceStatistics(buf [] byte) ([]map[string]interface{}, error) {
   var info interface{}
   json.Unmarshal(buf, &info)
   out, ok := info.(map[string]interface{})
   if !ok {
      return nil, errors.New("http response interface can not change map[string]interface{}")
   }
   middle, ok := out["aggregations"].(map[string]interface{})
   if !ok {
      return nil, errors.New("first hits change error!")
   }
   bucketsAggs := middle["buckets_aggs"].(map[string]interface{})
   buckets := bucketsAggs["buckets"].([]interface{})
   if len(buckets) == 0 {
      return nil, nil
   }
   resultData := make([]map[string]interface{}, 0)
   for _, pick := range buckets {
      data := make(map[string]interface{}, 0)
      data["areaId"] = pick.(map[string]interface{})["key"].(map[string]interface{})["areaId"].(string)
      data["peopleNum"] = int(pick.(map[string]interface{})["doc_count"].(float64))
      resultData = append(resultData, data)
   }
   return resultData, nil
}

func SourceAggregations(buf [] byte, thresholdTime float64, queryUseTime float64) (sources map[string]interface{}, err error) {
   s := make(map[string]interface{})
   loc, err := time.LoadLocation("Asia/Shanghai")
   if err != nil {
@@ -497,7 +664,7 @@
   if len(buckets) == 0 {
      return nil, nil
   }
   allSource := make([]map[string]interface{},0)
   allSource := make([]map[string]interface{}, 0)
   for _, inf := range buckets {
      //tmpSources := make(map[string]interface{}, 0)
      hitsSources := make([]map[string]interface{}, 0)
@@ -506,9 +673,12 @@
      topAttentionHits := inf.(map[string]interface{})["top_attention_hits"].(map[string]interface{})
      middleHits := topAttentionHits["hits"].(map[string]interface{})
      finalHits := middleHits["hits"].([]interface{})
      tmpHitSource := make(map[string]interface{})
      startTime := ""
      indexLength := len(finalHits)
      point := 0
      for _, in := range finalHits {
         point = point + 1
         tmpHitSource := make(map[string]interface{})
         tmpbuf, ok := in.(map[string]interface{})
         if !ok {
            fmt.Println("change to source error!")
@@ -528,19 +698,176 @@
         }

         sTime := tmpTime
         eTime := tmpTime
         if startTime != "" {
         eTime := mTime.Add(time.Second * 1).Format("2006-01-02 15:04:05")
         stayTime := 1.0
         if startTime != "" && point <= indexLength {
            sinTime, _ := time.ParseInLocation("2006-01-02 15:04:05", startTime, loc)
            if math.Abs(sinTime.Sub(mTime).Seconds()) <= thresholdTime {
               startTime = tmpTime
               hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
            passTime := math.Abs(mTime.Sub(sinTime).Seconds())
            hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
            //fmt.Println("passTime:   ", passTime)
            if passTime <= thresholdTime {
               if point == indexLength {
                  hitStartTime := hitsSources[len(hitsSources)-1]["startTime"].(string)
                  realStartTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitStartTime, loc)
                  stayTime = math.Abs(mTime.Sub(realStartTime).Seconds())
                  hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
                  hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
                  startTime = ""
               } else {
                  startTime = tmpTime
                  hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
               }
               continue
            } else {
               hitStartTime := hitsSources[len(hitsSources)-1]["startTime"].(string)
               hitEndTime := hitsSources[len(hitsSources)-1]["endTime"].(string)
               realStartTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitStartTime, loc)
               realEndTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitEndTime, loc)
               stayTime = math.Abs(realEndTime.Sub(realStartTime).Seconds())
               if sinTime.Sub(mTime).Seconds() == 0{
                  sinTime.Add(time.Second*1)
                  sinTime.Add(time.Second * 1)
                  sinTime.Format("2006-01-02 15:04:05")
                  hitsSources[len(hitsSources)-1]["endTime"] = sinTime
                  hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
                  stayTime = 1
               } else if stayTime == 0{
                  stayTime = 1
                  hitsSources[len(hitsSources)-1]["endTime"] = realEndTime.Add(time.Second*1).Format("2006-01-02 15:04:05")
               }
               hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
               if point == indexLength {
                  stayTime = 1
               }
               startTime = ""
            }
         }
         //fmt.Println("========================================================")
         startTime = tmpTime
         tmpHitSource["personId"] = baseInfo["targetId"].(string)
         tmpHitSource["cameraId"] = source["cameraId"].(string)
         tmpHitSource["cameraName"] = source["cameraName"].(string)
         tmpHitSource["cameraAddr"] = source["cameraAddr"].(string)
         tmpHitSource["targetScore"] = int(targetInfo["targetScore"].(float64))
         tmpHitSource["properties"] = source["showLabels"].(string)
         tmpHitSource["tableId"] = baseInfo["tableId"].(string)
         tmpHitSource["tableName"] = baseInfo["tableName"].(string)
         tmpHitSource["bwType"] = baseInfo["bwType"].(string)
         tmpHitSource["personName"] = baseInfo["targetName"].(string)
         tmpHitSource["compareScore"] = int(baseInfo["compareScore"].(float64))
         tmpHitSource["startTime"] = sTime
         tmpHitSource["startBackGroundPicUrl"] = source["picMaxUrl"].([]interface{})
         tmpHitSource["startFacePicUrl"] = targetInfo["picSmUrl"].(string)
         tmpHitSource["endTime"] = eTime
         tmpHitSource["stayTime"] = stayTime
         tmpHitSource["endTBackGroundPicUrl"] = source["picMaxUrl"].([]interface{})
         tmpHitSource["endTFacePicUrl"] = targetInfo["picSmUrl"].(string)
         if source["picWH"] != nil {
            tmpHitSource["picWH"] = source["picWH"].(map[string]interface{})
         }
         hitsSources = append(hitsSources, tmpHitSource)
      }
      allSource = append(allSource, hitsSources...)
   }
   count := len(allSource)
   //fmt.Println(count)
   s["count"] = count
   s["allSource"] = allSource
   s["queryUseTime"] = queryUseTime
   return s, nil
}

func SourceAggregationsReturnByGrouped(buf [] byte, thresholdTime float64) (sources []map[string]interface{}, err error) {
   loc, err := time.LoadLocation("Asia/Shanghai")
   if err != nil {
      return nil, errors.New("时区设置错误")
   }
   var info interface{}
   json.Unmarshal(buf, &info)
   out, ok := info.(map[string]interface{})
   if !ok {
      return nil, errors.New("http response interface can not change map[string]interface{}")
   }
   middle, ok := out["aggregations"].(map[string]interface{})
   if !ok {
      return nil, errors.New("first hits change error!")
   }
   bucketsAggs := middle["buckets_aggs"].(map[string]interface{})
   buckets := bucketsAggs["buckets"].([]interface{})
   if len(buckets) == 0 {
      return nil, nil
   }
   for _, inf := range buckets {
      tmpSources := make(map[string]interface{}, 0)
      hitsSources := make([]map[string]interface{}, 0)
      groupKey := inf.(map[string]interface{})["key"].(map[string]interface{})
      topAttentionHits := inf.(map[string]interface{})["top_attention_hits"].(map[string]interface{})
      middleHits := topAttentionHits["hits"].(map[string]interface{})
      finalHits := middleHits["hits"].([]interface{})
      indexLength := len(finalHits)
      point := 0
      startTime := ""
      //fmt.Println("finalHits: ",finalHits)
      for _, in := range finalHits {
         point = point + 1
         tmpHitSource := make(map[string]interface{})
         tmpbuf, ok := in.(map[string]interface{})
         if !ok {
            fmt.Println("change to source error!")
            continue
         }
         source, ok := tmpbuf["_source"].(map[string]interface{})
         if !ok {
            fmt.Println("change _source error!")
            continue
         }
         baseInfo := source["baseInfo"].([]interface{})[0].(map[string]interface{})
         targetInfo := source["targetInfo"].([]interface{})[0].(map[string]interface{})
         tmpTime := source["picDate"].(string)
         mTime, err := time.ParseInLocation("2006-01-02 15:04:05", tmpTime, loc)
         if err != nil {
            return nil, errors.New("时间解析错误")
         }

         sTime := tmpTime
         eTime := mTime.Add(time.Second * 1).Format("2006-01-02 15:04:05")
         stayTime := 1.0
         if startTime != "" && point <= indexLength {
            sinTime, _ := time.ParseInLocation("2006-01-02 15:04:05", startTime, loc)
            passTime := math.Abs(mTime.Sub(sinTime).Seconds())
            hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
            //fmt.Println("passTime:   ", passTime)
            if passTime <= thresholdTime {
               if point == indexLength {
                  hitStartTime := hitsSources[len(hitsSources)-1]["startTime"].(string)
                  realStartTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitStartTime, loc)
                  stayTime = math.Abs(mTime.Sub(realStartTime).Seconds())
                  hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
                  hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
                  startTime = ""
               } else {
                  startTime = tmpTime
                  hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
               }
               continue
            } else {
               hitStartTime := hitsSources[len(hitsSources)-1]["startTime"].(string)
               hitEndTime := hitsSources[len(hitsSources)-1]["endTime"].(string)
               realStartTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitStartTime, loc)
               realEndTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitEndTime, loc)
               stayTime = math.Abs(realEndTime.Sub(realStartTime).Seconds())
               if sinTime.Sub(mTime).Seconds() == 0{
                  sinTime.Add(time.Second * 1)
                  sinTime.Format("2006-01-02 15:04:05")
                  hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
                  stayTime = 1
               } else if stayTime == 0{
                  stayTime = 1
                  hitsSources[len(hitsSources)-1]["endTime"] = realEndTime.Add(time.Second*1).Format("2006-01-02 15:04:05")
               }
               hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
               if point == indexLength {
                  stayTime = 1
               }
               startTime = ""
            }
         }
         startTime = tmpTime
@@ -559,22 +886,55 @@
         tmpHitSource["startBackGroundPicUrl"] = source["picMaxUrl"].([]interface{})
         tmpHitSource["startFacePicUrl"] = targetInfo["picSmUrl"].(string)
         tmpHitSource["endTime"] = eTime
         tmpHitSource["stayTime"] = stayTime
         tmpHitSource["endTBackGroundPicUrl"] = source["picMaxUrl"].([]interface{})
         tmpHitSource["endTFacePicUrl"] = targetInfo["picSmUrl"].(string)
         if source["picWH"] != nil {
            tmpHitSource["picWH"] = source["picWH"].(map[string]interface{})
         }
         hitsSources = append(hitsSources, tmpHitSource)
      }
      allSource = append(allSource,hitsSources...)
   //   tmpSources["groupKey"] = groupKey
   //   tmpSources["doc_count"] = docCount
   //   tmpSources["hits_sources"] = hitsSources
   //   sources = append(sources, tmpSources)
      tmpSources["groupKey"] = groupKey
      tmpSources["hits_sources"] = hitsSources
      sources = append(sources, tmpSources)
   }
   count := len(allSource)
   fmt.Println(count)
   s["count"] = count
   s["allSource"] = allSource
   return sources, nil
}

   return s, nil
//解析抓拍库人员结构
func PerSonAnalysis(preData []map[string]interface{}) (sources []map[string]interface{}, err error) {
   loc, err := time.LoadLocation("Asia/Shanghai")
   if err != nil {
      return nil, errors.New("时区设置错误")
   }
   for _, key := range preData {
      source := make(map[string]interface{}, 0)
      info := key
      targetInfo := info["targetInfo"].([]interface{})[0].(map[string]interface{})
      startTime := info["picDate"].(string)
      endTime := info["updateTime"].(string)
      source["personId"] = targetInfo["belongsTargetId"].(string)
      source["cameraId"] = info["cameraId"].(string)
      source["cameraName"] = info["cameraName"].(string)
      source["cameraAddr"] = info["cameraAddr"].(string)
      source["targetScore"] = int(targetInfo["targetScore"].(float64))
      source["personRect"] = targetInfo["targetLocation"].(map[string]interface{})
      source["startTime"] = startTime
      pixMaxUrl := info["picMaxUrl"].([]interface{})
      source["startBackGroundPicUrl"] = pixMaxUrl[0]
      source["endTime"] = endTime
      startT, _ := time.ParseInLocation("2006-01-02 15:04:05", startTime, loc)
      endT, _ := time.ParseInLocation("2006-01-02 15:04:05", endTime, loc)
      stayTime := endT.Sub(startT).Seconds()
      source["stayTime"] = stayTime
      source["endBackGroundPicUrl"] = pixMaxUrl[len(pixMaxUrl)-1]
      if info["picWH"] != nil {
         source["picWH"] = info["picWH"].(map[string]interface{})
      }
      sources = append(sources, source)
   }

   return sources, nil
}

func Sourcelist(buf []byte) (sources []map[string]interface{}, err error) {