fix AIOceanVideoUrlbyid

sunty

2024-03-13 e8ccaf9b65f7975c2a472188d969c08f6e15a142

 EsClient.go

@@ -3,97 +3,103 @@
import (
   "basic.com/pubsub/protomsg.git"
   "bytes"
   "encoding/base64"
   "encoding/json"
   "errors"
   "fmt"
   "io"
   "github.com/spf13/viper"
   "io/ioutil"
   "log"
   "math"
   "net/http"
   "strings"
   "time"
)

func GetEsDataReq(url string, parama string, isSource bool) map[string]interface{} {
   //fmt.Println("es 查询请求路径" + url) //  配置信息 获取
   var dat map[string]interface{}
   req, err := http.NewRequest("POST", url, strings.NewReader(parama))
   req.Header.Add("Content-Type", "application/json")
   timeout := time.Duration(10 * time.Second) //超时时间50ms
   client := &http.Client{Timeout: timeout}
   resp, err := client.Do(req)
   if err != nil {
      fmt.Println(err)
      return dat
   }
   defer resp.Body.Close()
   dec := json.NewDecoder(resp.Body)
   if err := dec.Decode(&dat); err == io.EOF {
      fmt.Println(err.Error())
      return dat
   } else if err != nil {
      fmt.Println(err.Error())
      return dat
   }
   // 是否需要 解析 es 返回的 source
   if isSource {
      dat = dat["hits"].(map[string]interface{})
      var data = make(map[string]interface{}, 2)
      data["total"] = dat["total"]
      sources := []interface{}{}
      for _, value := range dat["hits"].([]interface{}) {
         source := value.(map[string]interface{})["_source"].(map[string]interface{})
         //source["id"] = source["id"]
         /*sdkType := source["sdkType"]
         if sdkType != nil {
            sdk, _ := strconv.Atoi(sdkType.(string))
            source["sdkType"] = sdkTypeToValue(sdk)
         }*/
         sources = append(sources, source)
      }
      data["datalist"] = sources
      return data
   } else {
      return dat
   }
}

func Parsesources(sources []map[string]interface{}) (esinfos []*protomsg.Esinfo) {
func Parsesources(sources []map[string]interface{}) (multiInfos []*protomsg.MultiFeaCache) {
   var ok bool
   for _, source := range sources {
      var multiInfo protomsg.MultiFeaCache
      var tmpinfo protomsg.Esinfo
      tmpinfo.FaceFeature, ok = source["faceFeature"].(string)
      if !ok {
         continue
      }

      tmpinfo.Id, ok = source["id"].(string)
      if !ok {
         continue
      }
      tmpinfo.Tableid, ok = source["tableId"].(string)
      if source["targetInfo"] != nil {
         for _, v := range source["targetInfo"].([]interface{}) {
            m := v.(map[string]interface{})
            tmpinfo.FaceFeature, ok = m["feature"].(string)
            if !ok {
               continue
            }
            if m["attachTarget"] != nil {
               multiInfo.AttachFeature, ok = m["attachTarget"].(map[string]interface{})["feature"].(string)
            }
            if m["targetLocation"] != nil {
               targetLocation := m["targetLocation"].(map[string]interface{})
               topLeft := targetLocation["topLeft"].(map[string]interface{})
               tx := topLeft["x"].(float64)
               ty := topLeft["y"].(float64)
               bottomRight := targetLocation["bottomRight"].(map[string]interface{})
               bx := bottomRight["x"].(float64)
               by := bottomRight["y"].(float64)
               multiInfo.TargetLocation = &protomsg.TargetLocation{
                  TopLeft: &protomsg.Location{
                     X: tx,
                     Y: ty,
                  },
                  BottomRight: &protomsg.Location{
                     X: bx,
                     Y: by,
                  },
               }
            }
         }
      }
      tmpinfo.AnalyServerId, ok = source["analyServerId"].(string)
      if !ok {
         continue
      }

      esinfos = append(esinfos, &tmpinfo)

      //        tmpinfo.PersonName,ok  =   source["personName"].(string)
      //            //Isnil("personName", ok)
      //        tmpinfo.PersonPicUrl,ok =  source["personPicUrl"].(string)
      //            //Isnil("personPicUrl", ok)
      //        tmpinfo.PhoneNum,ok     =  source["phoneNum"].(string)
      //            //Isnil("phoneNum", ok)
      //        tmpinfo.Sex,ok          =  source["sex"].(string)
      //            //Isnil("sex", ok)
      //        tmpinfo.Idcard,ok       =  source["idCard"].(string)
      //            //Isnil("idCard", ok)
      //        tmpinfo.MonitorLevel,ok =  source["monitorLevel"].(string)

      // 根据 tableid 获取 tablename
      //        name, _:= Dbtablename(tmpinfo.TableId)
      //        tmpinfo.TableName= name
      //        binfos.Infos = append(binfos.Infos, &tmpinfo)

      multiInfo.EsInfo = &tmpinfo
      multiInfo.CameraId, ok = source["cameraId"].(string)
      //fmt.Println(source["cameraId"])
      leis := make([]*protomsg.LinkEsInfo, 0)
      if source["linkTagInfo"] != nil {
         for _, v := range source["linkTagInfo"].([]interface{}) {
            var lei protomsg.LinkEsInfo
            mi := v.(map[string]interface{})
            lei.CameraId, ok = mi["cameraId"].(string)
            if mi["targetInfo"] != nil {
               for _, val := range mi["targetInfo"].([]interface{}) {
                  fmi := val.(map[string]interface{})
                  lei.Feature, ok = fmi["feature"].(string)
                  if fmi["targetLocation"] != nil {
                     targetLocation := fmi["targetLocation"].(map[string]interface{})
                     topLeft := targetLocation["topLeft"].(map[string]interface{})
                     tx := topLeft["x"].(float64)
                     ty := topLeft["y"].(float64)
                     bottomRight := targetLocation["bottomRight"].(map[string]interface{})
                     bx := bottomRight["x"].(float64)
                     by := bottomRight["y"].(float64)
                     multiInfo.TargetLocation = &protomsg.TargetLocation{
                        TopLeft: &protomsg.Location{
                           X: tx,
                           Y: ty,
                        },
                        BottomRight: &protomsg.Location{
                           X: bx,
                           Y: by,
                        },
                     }
                  }
                  lei.AttachFeature, ok = fmi["attachTarget"].(map[string]interface{})["feature"].(string)
               }
            }
            leis = append(leis, &lei)
         }
      }
      multiInfo.LinkEsInfo = leis
      multiInfos = append(multiInfos, &multiInfo)
   }
   return
}
@@ -122,7 +128,12 @@
      tmpinfo.TaskId, ok = source["taskId"].(string)
      tmpinfo.TaskName, ok = source["taskName"].(string)
      tmpinfo.SdkName, ok = source["sdkName"].(string)
      tmpinfo.PicMaxUrl, ok = source["picMaxUrl"].(string)

      if source["picMaxUrl"] != nil {
         for _, v := range source["picMaxUrl"].([]interface{}) {
            tmpinfo.PicMaxUrl = append(tmpinfo.PicMaxUrl, v.(string))
         }
      }
      tmpinfo.VideoUrl, ok = source["videoUrl"].(string)
      tmpinfo.PicDate, ok = source["picDate"].(string)
      if source["targetInfo"] != nil {
@@ -130,6 +141,7 @@
            m := v.(map[string]interface{})
            var ti protomsg.TargetInfo
            ti.TargetId, ok = m["targetId"].(string)
            ti.TargetType, ok = m["targetType"].(string)
            ti.TargetScore, ok = m["targetScore"].(float64)
            ti.Feature, ok = m["feature"].(string)
            ti.PicSmUrl, ok = m["picSmUrl"].(string)
@@ -166,7 +178,7 @@
            bi.CompareScore, ok = m["compareScore"].(float64)
            bi.BwType, ok = m["bwType"].(string)
            bi.TargetId, ok = m["targetId"].(string)
            bi.TableName, ok = m["tableName"].(string)
            bi.TargetName, ok = m["targetName"].(string)
            bi.TargetPicUrl, ok = m["targetPicUrl"].(string)
            bi.MonitorLevel, ok = m["monitorLevel"].(string)
            bi.Labels, ok = m["labels"].(string)
@@ -216,7 +228,11 @@
            lti.TaskId, ok = lm["taskId"].(string)
            lti.TaskName, ok = lm["taskName"].(string)
            lti.SdkName, ok = lm["sdkName"].(string)
            lti.PicMaxUrl, ok = lm["picMaxUrl"].(string)
            if lm["picMaxUrl"] != nil {
               for _, v := range lm["picMaxUrl"].([]interface{}) {
                  lti.PicMaxUrl = append(lti.PicMaxUrl, v.(string))
               }
            }
            lti.VideoUrl, ok = lm["videoUrl"].(string)
            lti.PicDate, ok = lm["picDate"].(string)
            if lm["targetInfo"] != nil {
@@ -224,6 +240,7 @@
                  m := v.(map[string]interface{})
                  var ti protomsg.TargetInfo
                  ti.TargetId, ok = m["targetId"].(string)
                  ti.TargetType, ok = m["targetType"].(string)
                  ti.TargetScore, ok = m["targetScore"].(float64)
                  ti.Feature, ok = m["feature"].(string)
                  ti.PicSmUrl, ok = m["picSmUrl"].(string)
@@ -260,7 +277,7 @@
                  bi.CompareScore, ok = m["compareScore"].(float64)
                  bi.BwType, ok = m["bwType"].(string)
                  bi.TargetId, ok = m["targetId"].(string)
                  bi.TableName, ok = m["tableName"].(string)
                  bi.TargetName, ok = m["targetName"].(string)
                  bi.TargetPicUrl, ok = m["targetPicUrl"].(string)
                  bi.MonitorLevel, ok = m["monitorLevel"].(string)
                  bi.Labels, ok = m["labels"].(string)
@@ -417,6 +434,476 @@
   return tmpinfos
}

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)
         if len(tmpTime) > 19 {
            tmpTime = tmpTime[:19]
         }
         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 {
      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 {
      //tmpSources := make(map[string]interface{}, 0)
      hitsSources := make([]map[string]interface{}, 0)
      //groupKey := inf.(map[string]interface{})["key"].(map[string]interface{})
      //docCount := int(inf.(map[string]interface{})["doc_count"].(float64))
      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)
         if len(tmpTime) > 19 {
            tmpTime = tmpTime[:19]
         }
         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 = ""
            }
         }
         //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)
         if len(tmpTime) > 19 {
            tmpTime = tmpTime[:19]
         }
         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
         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)
      }
      tmpSources["groupKey"] = groupKey
      tmpSources["hits_sources"] = hitsSources
      sources = append(sources, tmpSources)
   }
   return sources, 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) {
   var info interface{}
   json.Unmarshal(buf, &info)
@@ -484,14 +971,89 @@
   return data, nil
}

func SourceCreated(buf []byte) (result bool, err error) {
   var info interface{}
   json.Unmarshal(buf, &info)
   out, ok := info.(map[string]interface{})
   if !ok {
      return false, errors.New("http response interface can not change map[string]interface{}")
   }

   middle, ok := out["result"].(string)
   if !ok {
      return false, errors.New("first total change error!")
   }
   if middle == "created" || middle == "updated" {
      result = true
   }
   return result, nil
}

func SourceDeleted(buf []byte) (total int, err error) {
   var info interface{}
   json.Unmarshal(buf, &info)
   out, ok := info.(map[string]interface{})
   if !ok {
      return -1, errors.New("http response interface can not change map[string]interface{}")
   }

   middle, ok := out["deleted"].(float64)
   if !ok {
      return -1, errors.New("first total change error!")
   }
   total = int(middle)
   return total, nil
}

func SourceUpdated(buf []byte) (total int, err error) {
   var info interface{}
   json.Unmarshal(buf, &info)
   out, ok := info.(map[string]interface{})
   if !ok {
      return -1, errors.New("http response interface can not change map[string]interface{}")
   }

   middle, ok := out["updated"].(float64)
   if !ok {
      return -1, errors.New("first total change error!")
   }
   total = int(middle)
   return total, nil
}

func SourceTotal(buf []byte) (total int, err error) {
   var info interface{}
   json.Unmarshal(buf, &info)
   out, ok := info.(map[string]interface{})
   if !ok {
      return -1, errors.New("http response interface can not change map[string]interface{}")
   }

   middle, ok := out["hits"].(map[string]interface{})
   if !ok {
      return -1, errors.New("first total change error!")
   }

   tmp,b := middle["total"].(map[string]interface{})
   if b != true {
      v := middle["total"].(float64)
      t := int(v)
      return t,nil
   }
   value := tmp["value"].(float64)
   total = int(value)
   return total, nil
}

func EsReq(method string, url string, parama []byte) (buf []byte, err error) {
   //defer elapsed("page")()
   timeout := time.Duration(10 * time.Second)
   timeout := time.Duration(100 * time.Second)
   client := http.Client{
      Timeout: timeout,
   }
   request, err := http.NewRequest(method, url, bytes.NewBuffer(parama))
   request.Header.Set("Content-type", "application/json")
   request.Header.Set("Authorization",Token)

   if err != nil {
      fmt.Println("build request fail !")
@@ -527,3 +1089,29 @@
//            fmt.Println(key, "is nil can not asign") 
//    }
//}

type account struct {
   Username string `mapstructure: "username"`
   Userpassword string `mapstructure: "userpassword"`
}


var Account = &account{}

var Token string

func init() {
   v := viper.New()
   v.SetConfigType("yaml")
   v.SetConfigName("pro")
   v.AddConfigPath("../config/")
   v.AddConfigPath("./config/")
   v.AddConfigPath("/opt/vasystem/config/")
   err := v.ReadInConfig()
   if err != nil {
      log.Fatal("err on parsing configuration file!",err)
   }
   v.UnmarshalKey("es.account",Account)

   Token = "Basic "+base64.StdEncoding.EncodeToString([]byte(Account.Username+":"+Account.Userpassword))
}