Optimize day and night algorithm, format date and time, batch process by date.

sunty

2024-05-31 f6ca7bb43270474fa876ff6ba62c6b2113b045ad

 EsApi.go

@@ -22,6 +22,757 @@
   }
}

//***********************重庆Start**********************************//

//判断时间是否再范围之内
func isTimeInRange(timeStr, startStr, endStr string) bool {
   layout := "15:04:05"

   timeStamp, err := time.Parse(layout, timeStr)
   if err != nil {
      fmt.Println("Error parsing timestamp:", err)
      return false
   }

   startTime, err := time.Parse(layout, startStr)
   if err != nil {
      fmt.Println("Error parsing start time:", err)
      return false
   }

   endTime, err := time.Parse(layout, endStr)
   if err != nil {
      fmt.Println("Error parsing end time:", err)
      return false
   }

   if startTime.After(endTime) {
      // 跨越日期的情况
      //fmt.Println("跨日期",timeStamp, timeStamp.After(startTime), timeStamp.Before(endTime))
      return timeStamp.After(startTime) || timeStamp.Before(endTime)
   } else {
      // 不跨越日期的情况
      //fmt.Println("不跨日期",timeStamp, timeStamp.After(startTime), timeStamp.Before(endTime))
      return timeStamp.After(startTime) && timeStamp.Before(endTime)
   }
}

//判断两个时间先后
func compareTimes(time1Str, time2Str string) int {
   layout := "15:04:05"

   time1, err := time.Parse(layout, time1Str)
   if err != nil {
      fmt.Println("Error parsing time 1:", err)
      return 0
   }

   time2, err := time.Parse(layout, time2Str)
   if err != nil {
      fmt.Println("Error parsing time 2:", err)
      return 0
   }

   if time1.Before(time2) {
      return -1 // time1 在 time2 之前
   } else if time1.After(time2) {
      return 1 // time1 在 time2 之后
   } else {
      return 0 // time1 和 time2 相等
   }
}

//判断日期相差几天
func daysBetweenDates(date1Str, date2Str string) int {
   layout := "2006-01-02"

   date1, err := time.Parse(layout, date1Str)
   if err != nil {
      fmt.Println("Error parsing date 1:", err)
      return 0
   }

   date2, err := time.Parse(layout, date2Str)
   if err != nil {
      fmt.Println("Error parsing date 2:", err)
      return 0
   }

   duration := date2.Sub(date1)
   days := int(duration.Hours() / 24)

   return days
}

//计算时间阈值
func checkTimeDifference(timestampStr1 string, timestampStr2 string, intervalInMinutes int) bool {
   layout := "2006-01-02 15:04:05"
   timestampStr1 = timestampStr1[:19]
   timestampStr2 = timestampStr2[:19]
   // 将字符串解析为时间
   time1, err := time.Parse(layout, timestampStr1)
   if err != nil {
      fmt.Println("时间解析失败:", err)
      return false
   }
   time2, err := time.Parse(layout, timestampStr2)
   if err != nil {
      fmt.Println("时间解析失败:", err)
      return false
   }

   // 计算时间差
   diff := time2.Sub(time1)

   // 检查时间差是否小于等于指定的间隔
   if diff.Minutes() <= float64(intervalInMinutes) {
      return true
   } else {
      return false
   }
}

////格式化时间hh:mm:ss:zzz to hh:mm:ss
//func formatTime(inputTime string) (string, error) {
//   parsedTime, err := time.Parse("15:04:05:000", inputTime)
//   if err != nil {
//      return "", err
//   }
//
//   formattedTime := parsedTime.Format("15:04:05")
//   return formattedTime, nil
//}

func decodeActivityId(frequency int, intervalInMinutes int, source []map[string]interface{}) ([]map[string]interface{}, error) {
   docInfo := make([]map[string]interface{}, 0)
   for _, info := range source {
      tmpInfo := make(map[string]interface{})
      documentNumber := info["key"].(string)
      tmpInfo["documentNumber"] = documentNumber
      //fmt.Println("documentNumber: ", documentNumber)
      topHits := info["top_hits"].(map[string]interface{})
      hits := topHits["hits"].(map[string]interface{})
      hitsResult := hits["hits"].([]interface{})
      dataId := make([]string, 0)
      picUrl := ""
      if hitsResult[0].(map[string]interface{})["_source"].(map[string]interface{})["baseInfo"] != nil {
         baseInfo := hitsResult[0].(map[string]interface{})["_source"].(map[string]interface{})["baseInfo"]
         if v, ok := baseInfo.([]interface{}); ok {
            picUrl = v[0].(map[string]interface{})["targetPicUrl"].(string)
         } else if v, ok := baseInfo.(map[string]interface{}); ok {
            picUrl = v["targetPicUrl"].(string)
         }
      } else {
         if hitsResult[0].(map[string]interface{})["_source"].(map[string]interface{})["targetInfo"] != nil {
            picUrl = hitsResult[0].(map[string]interface{})["_source"].(map[string]interface{})["targetInfo"].([]interface{})[0].(map[string]interface{})["picSmUrl"].(string)
         }
      }
      tmpInfo["picUrl"] = picUrl
      lastCaptureTime := ""
      for _, sourceInfo := range hitsResult {
         rSourceInfo := sourceInfo.(map[string]interface{})
         source := rSourceInfo["_source"].(map[string]interface{})
         captureTime := source["picDate"].(string)
         id := source["id"].(string)
         if lastCaptureTime != "" {
            if checkTimeDifference(lastCaptureTime[:19], captureTime[:19], intervalInMinutes) {
               //fmt.Println("时间小于连续阈值", lastCaptureTime, captureTime)
               continue
            }
         }
         lastCaptureTime = captureTime
         dataId = append(dataId, id)
      }

      if len(dataId) > frequency {
         tmpInfo["id"] = dataId
         docInfo = append(docInfo, tmpInfo)
      }
   }
   return docInfo, nil
}

func DayNightActivityQuery(comIds []string, cameraIds []string, docNumber string, startDateStr string, endDateStr string, activeHour string, frequency int,
   intervalInMinutes int, indexName string, serverIp string, serverPort string) (map[string]interface{}, error) {
   esURL := "http://" + serverIp + ":" + serverPort + "/" + indexName + "/_search"
   hours := strings.Split(activeHour, "-")
   startTimeStr := hours[0]
   endTimeStr := hours[1]
   layoutTime := "15:04:05"
   startTime, err := time.Parse(layoutTime, startTimeStr)
   if err != nil {
      return nil, err
   }
   endTime, err := time.Parse(layoutTime, endTimeStr)
   if err != nil {
      return nil, err
   }
   layoutDate := "2006-01-02"
   startDate, err := time.Parse(layoutDate, startDateStr)
   if err != nil {
      fmt.Println("Error parsing start time:", err)
      return nil, err
   }

   endDate, err := time.Parse(layoutDate, endDateStr)
   if err != nil {
      fmt.Println("Error parsing end time:", err)
      return nil, err
   }
   rangePicDate := make([]string, 0)
   if startTime.Before(endTime) {
      for !startDate.After(endDate) {
         sDateTime := startDate.Format(layoutDate) + " " + startTimeStr
         eDateTime := startDate.Format(layoutDate) + " " + endTimeStr
         rangePicDate = append(rangePicDate, `
               {
                       "range": {
                           "picDate": {
                               "gte": "`+sDateTime+`",
                               "lt": "`+eDateTime+`"
                           }
                       }
                   }`)
         startDate = startDate.AddDate(0, 0, 1)
      }
   } else if startTime.After(endTime) {
      if startDate.Year() == endDate.Year() && startDate.Month() == endDate.Month() && startDate.Day() == endDate.Day() {
         fmt.Println("跨日期不支持单日查询")
         return nil, errors.New("跨日期不支持单日查询！")
      }
      for !startDate.After(endDate) {
         sDateTime := startDate.Format(layoutDate) + " " + startTimeStr
         startDate = startDate.AddDate(0, 0, 1)
         //fendDate := startDate.AddDate(0, 0, 1)
         if startDate.Year() == endDate.Year() && startDate.Month() == endDate.Month() && startDate.Day() == endDate.Day() {
            eDateTime := startDate.Format(layoutDate) + " " + endTimeStr
            rangePicDate = append(rangePicDate, `
               {
                       "range": {
                           "picDate": {
                               "gte": "`+sDateTime+`",
                               "lt": "`+eDateTime+`"
                           }
                       }
                   }`)
            //fmt.Println("startDate: ", startDate, "/t endDate: ", endDate)
            break
         }
         eDateTime := startDate.Format(layoutDate) + " " + endTimeStr
         rangePicDate = append(rangePicDate, `
               {
                       "range": {
                           "picDate": {
                               "gte": "`+sDateTime+`",
                               "lt": "`+eDateTime+`"
                           }
                       }
                   }`)
      }
   }
   //fmt.Println(rangePicDate)
   //return nil, nil
   filterDocIdAttr := ""
   if docNumber != "" {
      filterDocIdAttr = "{\"term\": {\"documentNumber\": \"" + docNumber + "\"}},"
   }
   comIdsStr := ""
   if comIds != nil && len(comIds) > 0 {
      esComIds := strings.Replace(strings.Trim(fmt.Sprint(comIds), "[]"), " ", "\",\"", -1)
      comIdsStr = "{\"terms\":{\"communityId\":[\"" + esComIds + "\"]}},"
   }
   cameraIdsStr := ""
   if comIds != nil && len(cameraIds) > 0 {
      esCameraIds := strings.Replace(strings.Trim(fmt.Sprint(cameraIds), "[]"), " ", "\",\"", -1)
      cameraIdsStr = "{\"terms\":{\"cameraId\":[\"" + esCameraIds + "\"]}},"
   }

   var result = make(map[string]interface{})
   docInfos := make([]map[string]interface{}, 0)
   for _, rpd := range rangePicDate {
      //if comIdsStr != "" || filterDocIdAttr != "" || cameraIdsStr != "" {
      //   rpd += ","
      //}
      queryDSL := `
      {
          "size": 0,
          "query": {
              "bool": {
                  "filter": [
                   ` + comIdsStr + `
                  ` + cameraIdsStr + `
                  ` + filterDocIdAttr + `
                       ` + rpd + `
                  ],
                  "must_not": [
                      {
                          "term": {
                              "documentNumber": ""
                          }
                      }
                  ]
              }
          },
          "aggs": {
              "group_by_documentnumber": {
                  "terms": {
                      "field": "documentNumber",
                      "size": 100000
                  },
               "aggs": {
                  "top_hits": {
                         "top_hits": {
                             "_source": [
                           "id",
                                 "picDate",
                           "baseInfo.targetPicUrl",
                           "targetInfo.picSmUrl"
                        ],
                              "size": 100000,
                              "sort": [
                                  {
                                      "picDate": {
                                          "order": "asc"
                                      }
                                  }
                              ]
                     }
                  }
                  }
              }
          }
      }`
      fmt.Println(esURL)
      fmt.Println(queryDSL)
      buf, err := EsReq("POST", esURL, []byte(queryDSL))
      if err != nil {
         return nil, err
      }
      source, err := SourceAggregationList(buf)
      if err != nil {
         return nil, err
      }
      //fmt.Println(source)
      //docResult 本次查询结果
      docResult, err := decodeActivityId(frequency, intervalInMinutes, source)
      if err != nil {
         return nil, err
      }
      if len(docResult) == 0 {
         continue
      }
      if len(docInfos) == 0 {
         docInfos = append(docInfos, docResult...)
         continue
      }
      for _, dr := range docResult {
         var found bool
         for _, di := range docInfos {
            if dr["documentNumber"].(string) == di["documentNumber"].(string) {
               // 找到了相同的documentNumber，将id合并到di["id"]中
               ids, ok := di["id"].([]string)
               if !ok {
                  // 如果id不是字符串切片类型，则进行初始化
                  ids = []string{}
               }
               ids = append(ids, dr["id"].([]string)...)
               di["id"] = ids
               //docInfos[diIndex] = di // 更新原始docInfos中的值
               found = true
               break
            }
         }
         if !found {
            // 没有找到相同的documentNumber，将dr添加到docInfos中
            docInfos = append(docInfos, dr)
         }
      }
   }
   if len(docInfos) == 0 {
      return nil, nil
   }
   DataInfos, err := GetInfosByIds(docInfos[0]["id"].([]string), indexName, serverIp, serverPort)
   result["documentNumbers"] = docInfos
   result["datalist"] = DataInfos
   return result, nil
}

type acmInfo struct {
   documentNumber string
   camerasInfos   []camerasInfo
}

type camerasInfo struct {
   cameraId     string
   captureInfos []captureInfo
}

type captureInfo struct {
   id      string
   picDate string
}

func addSecondsToTimestamp(timestamp string, seconds int) (string, error) {
   parsedTime, err := time.Parse("2006-01-02 15:04:05", timestamp)
   if err != nil {
      return "", err
   }
   newTime := parsedTime.Add(time.Second * time.Duration(seconds))
   newTimestamp := newTime.Format("2006-01-02 15:04:05")
   return newTimestamp, nil
}

func decodeInfo(intervalInMinutes int, source []map[string]interface{}) ([]acmInfo, error) {
   acmInfos := make([]acmInfo, 0)
   for _, info := range source {
      var aInfo acmInfo
      documentNumber := info["key"].(string)
      aInfo.documentNumber = documentNumber
      groupByCameraId := info["group_by_cameraId"].(map[string]interface{})
      cameraBuckets := groupByCameraId["buckets"].([]interface{})
      for _, cameraInfo := range cameraBuckets {
         var camsInfo camerasInfo
         cInfo := cameraInfo.(map[string]interface{})
         cameraId := cInfo["key"].(string)
         camsInfo.cameraId = cameraId
         dataBuckets := cInfo["top_hits"].(map[string]interface{})["hits"].(map[string]interface{})["hits"].([]interface{})
         markTime := ""
         for _, dataInfo := range dataBuckets {
            var capInfo captureInfo
            dInfo := dataInfo.(map[string]interface{})
            dSource := dInfo["_source"].(map[string]interface{})
            id := dSource["id"].(string)
            picDate := dSource["picDate"].(string)
            //addFlag := false
            if markTime == "" {
               //addFlag = true
               markTime = picDate
            } else {
               if checkTimeDifference(markTime, picDate, intervalInMinutes) {
                  //fmt.Println(markTime, picDate)
                  markTime = picDate
                  continue
               }
               markTime = picDate
            }
            capInfo.id = id
            capInfo.picDate = picDate
            camsInfo.captureInfos = append(camsInfo.captureInfos, capInfo)
         }
         aInfo.camerasInfos = append(aInfo.camerasInfos, camsInfo)
      }
      acmInfos = append(acmInfos, aInfo)
   }
   return acmInfos, nil
}

type addResultIds struct {
   documentNumber string
   unionIds       []unionId
}

type unionId struct {
   baseId   string
   targetId string
}

func addResultInfo(source []map[string]interface{}, targetAddResultIds *[]addResultIds, bId string) {
   found := false
   for _, info := range source {
      documentNumber := info["key"].(string)
      dataBuckets := info["top_hits"].(map[string]interface{})["hits"].(map[string]interface{})["hits"].([]interface{})
      id := dataBuckets[0].(map[string]interface{})["_source"].(map[string]interface{})["id"].(string)
      //fmt.Println("documentNumber: ", documentNumber, "\tid: ", id)
      for i, docInfo := range *targetAddResultIds {
         if documentNumber == docInfo.documentNumber {
            //fmt.Println("新更新")
            (*targetAddResultIds)[i].unionIds = append((*targetAddResultIds)[i].unionIds, unionId{baseId: bId, targetId: id})
            found = true
            break
         }
      }
      if !found {
         //fmt.Println("新添加")
         var targetAddResultId addResultIds
         targetAddResultId.documentNumber = documentNumber
         targetAddResultId.unionIds = append(targetAddResultId.unionIds, unionId{baseId: bId, targetId: id})
         *targetAddResultIds = append(*targetAddResultIds, targetAddResultId)
      }

   }
}

func removeDuplicates(nums []string) []string {
   result := make([]string, 0)
   seen := make(map[string]bool)

   for _, num := range nums {
      if !seen[num] {
         result = append(result, num)
         seen[num] = true
      }
   }

   return result
}

func findAnalyzeCoordinatedMovementsInfos(infos []acmInfo, docNumber string, beforeTime int, afterTime int, frequency int,
   indexName string, serverIp string, serverPort string) (map[string]interface{}, error) {
   //baseAddResultIds := make([]addResultIds, 0)
   targetAddResultIds := make([]addResultIds, 0)
   esURL := "http://" + serverIp + ":" + serverPort + "/" + indexName + "/_search"
   for _, info := range infos {
      for _, cInfo := range info.camerasInfos {
         for _, pInfo := range cInfo.captureInfos {
            gteDate, err := addSecondsToTimestamp(pInfo.picDate[:19], beforeTime)
            if err != nil {
               fmt.Println(err)
            }
            lteDate, err := addSecondsToTimestamp(pInfo.picDate[:19], afterTime)
            if err != nil {
               fmt.Println(err)
            }
            queryDSL := `
               {
                   "size": 0,
                   "query": {
                       "bool": {
                           "filter": [
                               {
                                   "range": {
                                       "picDate": {
                                           "gte": "` + gteDate + `",
                                           "lte": "` + lteDate + `"
                                       }
                                   }
                               },
                               {
                                   "term": {
                                       "cameraId": "` + cInfo.cameraId + `"
                                   }
                               }
                           ],            
                        "must_not": [
                                  {
                                   "term": {
                                          "documentNumber": "` + docNumber + `"
                                   }
                                }
                        ]
                       }
                   },
                   "aggs": {
                       "group_by_documentnumber": {
                           "terms": {
                               "field": "documentNumber",
                               "size": 100000
                           },
                           "aggs": {
                               "top_hits": {
                                   "top_hits": {
                                       "_source": [
                                           "id",
                                           "cameraId",
                                           "picDate"
                                       ],
                                       "size": 10000,
                                       "sort": [
                                           {
                                               "picDate": {
                                                   "order": "asc"
                                               }
                                           }
                                       ]
                                   }
                               }
                           }
                       }
                   }
               }`
            //fmt.Println(esURL, queryDSL)
            buf, err := EsReq("POST", esURL, []byte(queryDSL))
            if err != nil {
               return nil, err
            }
            source, err := SourceAggregationList(buf)
            if err != nil {
               return nil, err
            }
            //fmt.Println("pInfo.id: ", pInfo.id)
            addResultInfo(source, &targetAddResultIds, pInfo.id)
            //fmt.Println("targetAddResultIds: ", targetAddResultIds)
            if err != nil {
               return nil, err
            }
            //fmt.Println(source)
         }
      }
   }
   //fmt.Println("targetAddResultIds: ", targetAddResultIds)
   baseIds := make([]string, 0)
   targetIds := make([]string, 0)
   for _, tAIdInfo := range targetAddResultIds {
      if len(tAIdInfo.unionIds) >= frequency {
         for _, unionId := range tAIdInfo.unionIds {
            baseIds = append(baseIds, unionId.baseId)
            targetIds = append(targetIds, unionId.targetId)
         }
      }
   }

   rdbaseIds := removeDuplicates(baseIds)
   rdtargetIds := removeDuplicates(targetIds)
   baseInfos, err := GetInfosByIds(rdbaseIds, indexName, serverIp, serverPort)
   if err != nil {
      return nil, err
   }
   targetInfos, err := GetInfosByIds(rdtargetIds, indexName, serverIp, serverPort)
   if err != nil {
      return nil, err
   }
   docNumberMap := make(map[string][]interface{})
   for _, tinfo := range targetInfos {
      docNumber := tinfo["documentNumber"].(string)
      docNumberMap[docNumber] = append(docNumberMap[docNumber], tinfo)
   }
   targetRecordInfos := make([]map[string]interface{}, 0)
   for docNumber, infos := range docNumberMap {
      ifs := make(map[string]interface{})
      ifs["documentNumber"] = docNumber
      ifs["recordInfos"] = infos
      targetRecordInfos = append(targetRecordInfos, ifs)
   }
   result := make(map[string]interface{})
   result["baseRecordInfo"] = baseInfos
   result["targetRecordInfo"] = targetRecordInfos
   return result, nil
}

func AnalyzeCoordinatedMovements(comIds []string, docNumber string, startDate string, endDate string, beforeTime int, afterTime int, frequency int,
   intervalInMinutes int, indexName string, serverIp string, serverPort string) (map[string]interface{}, error) {
   esURL := "http://" + serverIp + ":" + serverPort + "/" + indexName + "/_search"
   //判断社区IDs
   comIdsStr := ""
   if comIds == nil || len(comIds) > 0 {
      esComIds := strings.Replace(strings.Trim(fmt.Sprint(comIds), "[]"), " ", "\",\"", -1)
      comIdsStr = "{\"terms\":{\"communityId\":[\"" + esComIds + "\"]}},"
   }
   queryDSL := `
   {
       "size": 0,
       "query": {
           "bool": {
               "filter": [
                   {
                       "range": {
                           "picDate": {
                               "gte": "` + startDate + `",
                               "lte": "` + endDate + `"
                           }
                       }
                   },
               ` + comIdsStr + `
                   {
                       "term": {
                           "documentNumber": "` + docNumber + `"
                       }
                   }
               ]
           }
       },
       "aggs": {
           "group_by_documentnumber": {
               "terms": {
                   "field": "documentNumber",
                   "size": 100000
               },
               "aggs": {
                   "group_by_cameraId": {
                       "terms": {
                           "field": "cameraId",
                           "size": 10000
                       },
                       "aggs": {
                           "top_hits": {
                               "top_hits": {
                                   "_source": [
                                       "id",
                                       "cameraId",
                                       "picDate"
                                   ],
                                   "size": 10000,
                                   "sort": [
                                       {
                                           "picDate": {
                                               "order": "asc"
                                           }
                                       }
                                   ]
                               }
                           }
                       }
                   }
               }
           }
       }
   }`
   //fmt.Println(esURL)
   //fmt.Println(queryDSL)
   buf, err := EsReq("POST", esURL, []byte(queryDSL))
   if err != nil {
      return nil, err
   }
   source, err := SourceAggregationList(buf)
   if err != nil {
      return nil, err
   }
   docResult, err := decodeInfo(intervalInMinutes, source)
   if err != nil {
      return nil, err
   }
   //fmt.Println(docResult)
   result, err := findAnalyzeCoordinatedMovementsInfos(docResult, docNumber, beforeTime, afterTime, frequency, indexName, serverIp, serverPort)
   if err != nil {
      return nil, err
   }
   //fmt.Println(result)
   return result, nil
}

func GetInfosByIds(ids []string, indexName string, serverIp string, serverPort string) ([]map[string]interface{}, error) {
   captureIds := strings.Replace(strings.Trim(fmt.Sprint(ids), "[]"), " ", "\",\"", -1)
   esURL := "http://" + serverIp + ":" + serverPort + "/" + indexName + "/_search"
   queryDSL := `
            {
               "query": {
                  "bool": {
                     "filter": [{
                        "terms": {
                           "id": [
                              "` + captureIds + `"
                           ]
                        }
                     }]
                  }
               },
                "size":1000000,
            "sort":[{"picDate":{"order":"desc"}}],
            "_source": {"includes":[],"excludes":["*.feature"]}
            }
`
   buf, err := EsReq("POST", esURL, []byte(queryDSL))
   if err != nil {
      return nil, err
   }
   sources, err := Sourcelist(buf)
   if err != nil {
      return nil, err
   }

   return sources, nil
}

// ***********************重庆End************************************//
// 根据抓拍人员id查询抓拍人员信息
func AIOceaninfosbyid(id []string, indexName string, serverIp string, serverPort string) ([]protomsg.AIOcean, error) {
   var aIOceanInfo []protomsg.AIOcean
@@ -56,7 +807,43 @@
   return aIOcean, nil
}

//根据抓拍库人员id查询特征值
// 根据抓拍人员id查询视频地址
func AIOceanVideoUrlbyid(id string, indexName string, serverIp string, serverPort string) (string, error) {
   //var aIOceanInfo []protomsg.AIOcean
   //videopersonsPersonId := strings.Replace(strings.Trim(fmt.Sprint(id), "[]"), " ", "\",\"", -1)
   var dbinfoRequest = `
      {
          "query": {
              "bool": {
                  "filter": [
                      {
                          "term": {
                                "id": "` + id + `"
                          }
                      }
                  ]
              }
          },
          "_source": [
              "videoUrl"
          ]
      }
        `
   buf, err := EsReq("POST", "http://"+serverIp+":"+serverPort+"/"+indexName+"/_search", []byte(dbinfoRequest))
   if err != nil {
      return "", err
   }

   sources, err := Sourcelist(buf)
   if err != nil {
      return "", err
   }
   videoUrl := sources[0]["videoUrl"].(string)
   //aIOcean := AIOceanAnalysis(sources)
   return videoUrl, nil
}

// 根据抓拍库人员id查询特征值
func GetVideoPersonFaceFeatureById(id string, indexName string, serverIp string, serverPort string) (string, error) {
   var jsonDSL = `
            {
@@ -86,7 +873,7 @@
   return feature, nil
}

//根据目标id查询已追加条数
// 根据目标id查询已追加条数
func GetLinkTagInfoSize(id string, indexName string, serverIp string, serverPort string) (size int, err error) {
   url := "http://" + serverIp + ":" + serverPort + "/" + indexName + "/_search"
   queryDSL := `{
@@ -112,7 +899,7 @@
   return size, nil
}

//根据目标id追加跟踪信息
// 根据目标id追加跟踪信息
func AppendTargetInfo(id string, targetInfo string, indexName string, serverIp string, serverPort string, updateTime string) (string, error) {
   if targetInfo == "" {
      return "", errors.New("append data is nil")
@@ -257,20 +1044,23 @@
   if err != nil {
      return nil, err
   }
   if len(source) == 0 {
      return source, nil
   }
   faceSource := make([]map[string]interface{}, 0)
   for index, info := range source {
      if int(info["stayTime"].(float64)) > thresholdStayTime {
         faceSource = append(faceSource, source[index])
      }
   }
   mapsSort := MapsSort{}
   mapsSort.Key = "endTime"
   mapsSort.MapList = faceSource
   sort.Sort(&mapsSort)
   if len(faceSource) > total {
      mapsSort := MapsSort{}
      mapsSort.Key = "endTime"
      mapsSort.MapList = faceSource
      sort.Sort(&mapsSort)
      return mapsSort.MapList[:total], nil
   }
   return faceSource, nil
   return mapsSort.MapList, nil
}

func GetFaceDataByTimeAndId(startTime string, endTime string, id string, thresholdTime int, thresholdStayTime int, serverIp string, serverPort string, indexName string) (resData []map[string]interface{}, err error) {
@@ -355,13 +1145,20 @@
   if err != nil {
      return nil, err
   }
   if len(source) == 0 {
      return source, nil
   }
   faceSource := make([]map[string]interface{}, 0)
   for index, info := range source {
      if int(info["stayTime"].(float64)) > thresholdStayTime {
         faceSource = append(faceSource, source[index])
      }
   }
   return faceSource, nil
   mapsSort := MapsSort{}
   mapsSort.Key = "startTime"
   mapsSort.MapList = faceSource
   sort.Sort(&mapsSort)
   return mapsSort.MapList, nil
}

func GetFaceIdDeduplication(startTime string, endTime string, serverIp string, serverPort string, indexName string) (ids []map[string]interface{}, err error) {
@@ -434,7 +1231,7 @@
   if err1 != nil {
      return nil, err1
   }
   if len(ids) > 0 {
   if len(ids) > 1 {
      mapsSort := MapsSort{}
      mapsSort.Key = "lastTime"
      mapsSort.MapList = ids
@@ -444,7 +1241,7 @@
   return ids, nil
}

//统计各个区域人数
// 统计各个区域人数
func StatisticsEveryAreaPersonsNumber(startTime string, endTime string, serverIp string, serverPort string, indexName string) ([]map[string]interface{}, error) {
   var requestUrl = "http://" + serverIp + ":" + serverPort + "/" + indexName + "/_search"
   var requestBody = `{
@@ -571,7 +1368,7 @@

}

//根据时间范围，摄像机列表，分组聚合人脸列表,返回分组数据
// 根据时间范围，摄像机列表，分组聚合人脸列表,返回分组数据
func GetFaceDataBucketsByCameraIdAndTimeReturnByGrouped(cameraId []string, personId []string, startTime string, endTime string, thresholdTime float64, serverIp string, ServerPort string, indexName string) (buckersDate map[string]interface{}, err error) {
   var filterArr []string
   if cameraId != nil && len(cameraId) > 0 {
@@ -677,7 +1474,7 @@
   return sources, nil
}

//根据时间范围，摄像机列表，分组聚合人脸列表
// 根据时间范围，摄像机列表，分组聚合人脸列表
func GetFaceDataBucketsByCameraIdAndTime(cameraId []string, personId []string, startTime string, endTime string, thresholdTime float64, serverIp string, ServerPort string, indexName string) (buckersDate map[string]interface{}, err error) {
   var filterArr []string
   if cameraId != nil && len(cameraId) > 0 {
@@ -778,7 +1575,7 @@
   return sources, nil
}

//根据抓拍人员id更新（picurl）图片地址
// 根据抓拍人员id更新（picurl）图片地址
func UpdatePicUrlById(id string, picUrl string, indexName string, serverIp string, serverPort string) (err error) {
   updateTime := time.Now().Format("2006-01-02 15:04:05")
   tRes, err := AIOceaninfosbyid([]string{id}, indexName, serverIp, serverPort)
@@ -841,7 +1638,7 @@
   return nil
}

//根据抓拍人员id更新（videourl）摄像机地址
// 根据抓拍人员id更新（videourl）摄像机地址
func UpdateVideourlById(id string, videoUrl string, indexName string, serverIp string, serverPort string, command int) (statu int, err error) {

   var info interface{}
@@ -878,23 +1675,30 @@
      return statu, errors.New("http response interface can not change map[string]interface{}")
   }
   middle, ok := out["updated"].(float64)
   if !ok {
   batches, ok1 := out["batches"].(float64)
   if !ok || !ok1 {
      logPrint("first updated change error!")
      statu = 500
      return statu, errors.New("first updated change error!")
   }
   if middle == 1 {
      statu = 200
      return statu, nil
   }
   if middle == 0 {
      statu = 201
      return statu, errors.New("已经修改")
   if batches == 0 {
      logPrint("no such doc in database")
      statu = 400
      return statu, errors.New("目标数据不存在")
   } else {
      if middle == 1 {
         statu = 200
         return statu, nil
      }
      if middle == 0 {
         statu = 201
         return statu, errors.New("已经修改")
      }
   }
   return statu, nil
}

//获取当前节点抓拍库所有人员ID*缓存*
// 获取当前节点抓拍库所有人员ID*缓存*
func GetAllLocalVideopersonsId(compareArgs protomsg.CompareArgs, indexName string, serverIp string, serverPort string, alarmLevelTypes string) (capturetable []string) {
   queryStr := ""
   queryBody := compareArgs.InputValue
@@ -934,7 +1738,12 @@
   isCollectStr := ""
   isCollect := compareArgs.Collection
   if isCollect != "" {
      isCollectStr = "{\"term\":{\"isCollect\":\"" + isCollect + "\"}},"
      //isCollectStr = "{\"term\":{\"isCollect\":\"" + isCollect + "\"}},"
      if isCollect == "1" {
         isCollectStr = "{\"term\":{\"isCollect\":true}},"
      } else if isCollect == "0" {
         isCollectStr = "{\"term\":{\"isCollect\":false}},"
      }
   }

   //判断布防等级
@@ -1058,7 +1867,7 @@
   return capturetable
}

//初始化实时抓拍
// 初始化实时抓拍
func InitRealTimeCapture(serverIp string, serverPort string, indexName string, isAlarm string, category string, quantity int) ([]protomsg.AIOcean, error) {
   var aIOceanInfo []protomsg.AIOcean
   url := "http://" + serverIp + ":" + serverPort +
@@ -1075,7 +1884,7 @@
   if category != "all" {
      filterArr = append(filterArr, `            {
               "term":{
                  "targetInfo.targetType":"`+category+`"
                  "targetInfo.targetType.raw":"`+category+`"
               }
            }`)

@@ -1095,7 +1904,7 @@
   "sort":[{"picDate":{"order":"desc"}}],
   "_source": {"includes":[],"excludes":["*.feature"]}
   }`
   logPrint(DSLJson)
   //logPrint(DSLJson)
   buf, err := EsReq("POST", url, []byte(DSLJson))
   if err != nil {
      return aIOceanInfo, err
@@ -1111,7 +1920,7 @@
   return aIOcean, nil
}

//实时抓拍
// 实时抓拍
func RealTimeCapture(serverIp string, serverPort string, indexName string, isAlarm bool) ([]protomsg.AIOcean, error) {
   var aIOceanInfo []protomsg.AIOcean
   url := "http://" + serverIp + ":" + serverPort +
@@ -1155,7 +1964,7 @@
   return aIOcean, nil
}

//综合统计
// 综合统计
func StatisticsComprehensive(serverIp string, serverPort string, indexName string, isAlarm string) (total int, err error) {
   url := "http://" + serverIp + ":" + serverPort +
      "/" + indexName + "/_search"
@@ -1185,7 +1994,6 @@
         }
      }
   }`
   //logPrint(DSLJson)
   buf, err := EsReq("POST", url, []byte(DSLJson))
   if err != nil {
      return total, err
@@ -1205,7 +2013,7 @@
   return total, nil
}

//实时报警任务比率
// 实时报警任务比率
func RealTimeAlarmTaskRate(serverIp string, serverPort string, indexName string) (sources []map[string]interface{}, err error) {
   url := "http://" + serverIp + ":" + serverPort +
      "/" + indexName + "/_search"
@@ -1223,9 +2031,9 @@
      }
   },
   "aggs":{
      "sdkName_status":{
      "taskName_status":{
         "terms":{
            "field":"sdkName.raw"
            "field":"taskName.raw"
         }
      }
   }
@@ -1244,11 +2052,11 @@
   if !ok {
      return nil, errors.New("first hits change error!")
   }
   sdkName_status, ok := middle["sdkName_status"].(map[string]interface{})
   sdkName_status, ok := middle["taskName_status"].(map[string]interface{})
   if !ok {
      return nil, errors.New("first hits change error!")
   }

   //fmt.Println(sdkName_status)
   for _, in := range sdkName_status["buckets"].([]interface{}) {
      var source = make(map[string]interface{}, 0)
      tmpbuf, ok := in.(map[string]interface{})
@@ -1266,11 +2074,20 @@
   return sources, nil
}

//聚合任务列表，taskId+taskName
func AggregateTaskList(serverIp string, serverPort string, indexName string, analyServerId string) (sources []map[string]interface{}, err error) {
// 聚合任务列表，taskId+taskName
func AggregateTaskList(serverIp string, serverPort string, indexName string, analyServerId string, cameraIds []string) (sources []map[string]interface{}, err error) {
   url := "http://" + serverIp + ":" + serverPort +
      "/" + indexName + "/_search"
   serverFilterStr := ""
   cameIdFilterStr := ""
   if cameraIds != nil && len(cameraIds) > 0 {
      cameIdsStr := strings.Replace(strings.Trim(fmt.Sprint(cameraIds), "[]"), " ", "\",\"", -1)
      cameIdFilterStr = `,{
            "term": {
            "cameraId": "` + cameIdsStr + `"
               }
                }`
   }
   if analyServerId != "" {
      serverFilterStr = `,
         "query": {
@@ -1279,8 +2096,9 @@
            {
            "term": {
            "analyServerId": "` + analyServerId + `"
               }
            }
            }
             ` + cameIdFilterStr + `
         ]
         }
      }`
@@ -1352,7 +2170,7 @@

}

//添加即将删除信号
// 添加即将删除信号
func AddDeleteSignal() {

}
@@ -1393,7 +2211,7 @@

}

//查询时间段数据 *缓存*
// 查询时间段数据 *缓存*
func GetPeriodInfos(serverIp string, serverPort string, startTime string, endTime string, indexName string, shards string, targetType string) ([]*protomsg.MultiFeaCache, error) {
   var capdbinfo []*protomsg.MultiFeaCache
   url := "http://" + serverIp + ":" + serverPort + "/" + indexName + "/_search?preference=_shards:" + shards + "|_only_local"
@@ -1571,8 +2389,8 @@
   return dbinfos, nil
}

//************************CORN TASK*******************************
//查询日期范围内是否还存在数据
// ************************CORN TASK*******************************
// 查询日期范围内是否还存在数据
func QueryAnalyServerData(serverIp string, serverPort string, indexName string, startTime string, endTime string, analyServerId string) (result bool, err error) {
   url := "http://" + serverIp + ":" + serverPort + "/" + indexName + "/_search"
   deleteJson := `{
@@ -1611,8 +2429,45 @@
   return result, nil
}

//按日期范围，服务器Id删除数据
func DeleteAnalyServerData(serverIp string, serverPort string, indexName string, startTime string, endTime string, analyServerId string) (result bool, err error) {
// 按日期范围，服务器Id删除数据
func DeleteByDocumentNumber(docNumber []string, serverIp string, serverPort string, indexName string) (total int, err error) {

   url := "http://" + serverIp + ":" + serverPort + "/" + indexName + "/_delete_by_query"
   docNumbers := strings.Replace(strings.Trim(fmt.Sprint(docNumber), "[]"), " ", "\",\"", -1)
   deleteJson := `{
   "query":{
      "bool":{
         "filter":[
         {
            "terms":{
               "documentNumber":["` + docNumbers + `"]
            }
         }	
         ]
      }
   }
}   `
   //fmt.Println(url)
   //fmt.Println(deleteJson)
   //return
   buf, err := EsReq("POST", url, []byte(deleteJson))
   if err != nil {
      return -1, errors.New("请求失败")
   }
   deleteRes, err := SourceDeleted(buf)
   if err != nil {
      return -1, errors.New("解码失败")
   }
   return deleteRes, nil
}

//func GetCaptureDaysByDocumentNumber(docNumber string, comId string, indexName string, serverIp string, serverPort string){
//   url := "http://" + serverIp + ":" + serverPort + "/" + indexName + "/_search"
//   queryDSL := ``
//}

// 按日期范围，服务器Id删除数据
func DeleteAnalyServerData(serverIp string, serverPort string, indexName string, startTime string, endTime string, analyServerId string) (total int, err error) {
   url := "http://" + serverIp + ":" + serverPort + "/" + indexName + "/_delete_by_query"
   deleteJson := `{
   "query":{
@@ -1634,23 +2489,20 @@
      }
   }
}   `
   fmt.Println(url)
   fmt.Println(deleteJson)
   buf, err := EsReq("POST", url, []byte(deleteJson))
   if err != nil {
      return false, errors.New("请求失败")
      return -1, errors.New("请求失败")
   }
   deleteRes, err := SourceDeleted(buf)
   if err != nil {
      return false, errors.New("解码失败")
      return -1, errors.New("解码失败")
   }
   if deleteRes == -1 {
      result = false
   } else {
      result = true
   }
   return result, nil
   return deleteRes, nil
}

//给所有节点追加删除任务信息
// 给所有节点追加删除任务信息
func AddDelTask(serverIp string, serverPort string, indexName string, startTime string, endTime string, analyServerId string) (result bool, err error) {
   url := "http://" + serverIp + ":" + serverPort + "/" + indexName + "/_update_by_query"
   addJson := `{
@@ -1693,7 +2545,7 @@
   return result, nil
}

//移除已执行完的删除任务
// 移除已执行完的删除任务
func DeleteDelTask(serverIp string, serverPort string, indexName string, analyServerId string) (result bool, err error) {
   url := "http://" + serverIp + ":" + serverPort + "/" + indexName + "/_update_by_query"
   deleteJson := `{
@@ -1726,3 +2578,66 @@
   }
   return result, nil
}

type ShardInfo struct {
   ShardIndex string `json:"shardIndex"` //分片所属索引名称
   ShardNum   int    `json:"shardNum"`   //分片号
   ShardRole  string `json:"shardRole"`  //分片角色(主分片：primary 副本分片：replica)
   ShardState string `json:"shardState"` //分片状态(启用：STARTED 未启用：UNASSIGNED)
   ShardDocs  int    `json:"shardDocs"`  //分片已保存文档数
   ShardStore string `json:"shardStore"` //分片当前存储数据大小
   ShardIp    string `json:"shardIp"`    //分片所在节点ip
   ShardNode  string `json:"shardNode"`  //分片所在节点名称
}

// 获取索引分片信息
func GetShardsByIndex(serverIp string, serverPort string, indexName string) ([]ShardInfo, error) {
   url := "http://" + serverIp + ":" + serverPort + "/_cat/shards?v"
   buf, err := EsReq("GET", url, []byte(""))
   if err != nil {
      return nil, err
   }
   var inf = []ShardInfo{}
   res := strings.Split(string(buf), "\n")[1:]
   for _, r := range res {
      if r != "" {

         inx := strings.Fields(r)
         index := inx[0]
         shard, _ := strconv.Atoi(inx[1])
         prired := inx[2]
         if prired == "r" {
            prired = "replica"
         }
         if prired == "p" {
            prired = "primary"
         }
         state := inx[3]
         docs := 0
         store := ""
         ip := ""
         node := ""
         if state == "STARTED" {
            docs, _ = strconv.Atoi(inx[4])
            store = inx[5]
            ip = inx[6]
            node = inx[7]
         }
         if index == indexName {
            inf = append(inf, ShardInfo{
               ShardIndex: index,
               ShardNum:   shard,
               ShardRole:  prired,
               ShardState: state,
               ShardDocs:  docs,
               ShardStore: store,
               ShardIp:    ip,
               ShardNode:  node,
            })

         }
      }

   }
   return inf, nil
}