package esutil
|
|
import (
|
"basic.com/pubsub/protomsg.git"
|
"bytes"
|
"encoding/base64"
|
"encoding/json"
|
"errors"
|
"fmt"
|
"github.com/spf13/viper"
|
"io/ioutil"
|
"log"
|
"math"
|
"net/http"
|
"time"
|
)
|
|
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.Id, ok = source["id"].(string)
|
if !ok {
|
continue
|
}
|
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
|
}
|
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
|
}
|
|
// 解析抓拍库人员结构
|
func AIOceanAnalysis(sources []map[string]interface{}) (tmpinfos []protomsg.AIOcean) {
|
var ok bool
|
for _, source := range sources {
|
var tmpinfo protomsg.AIOcean
|
tmpinfo.Id, ok = source["id"].(string)
|
if !ok {
|
continue
|
}
|
tmpinfo.CameraId, ok = source["cameraId"].(string)
|
if !ok {
|
continue
|
}
|
tmpinfo.CameraAddr, ok = source["cameraAddr"].(string)
|
if !ok {
|
continue
|
}
|
tmpinfo.AnalyServerId, ok = source["analyServerId"].(string)
|
tmpinfo.AnalyServerName, ok = source["analyServerName"].(string)
|
tmpinfo.AnalyServerIp, ok = source["analyServerIp"].(string)
|
tmpinfo.ClusterId, ok = source["clusterId"].(string)
|
tmpinfo.TaskId, ok = source["taskId"].(string)
|
tmpinfo.TaskName, ok = source["taskName"].(string)
|
tmpinfo.SdkName, ok = source["sdkName"].(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 {
|
for _, v := range source["targetInfo"].([]interface{}) {
|
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)
|
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)
|
ti.TargetLocation = &protomsg.TargetLocation{
|
TopLeft: &protomsg.Location{
|
X: tx,
|
Y: ty,
|
},
|
BottomRight: &protomsg.Location{
|
X: bx,
|
Y: by,
|
},
|
}
|
tmpinfo.TargetInfo = append(tmpinfo.TargetInfo, &ti)
|
}
|
|
}
|
tmpinfo.OtherLabels, ok = source["otherLabels"].(string)
|
tmpinfo.ShowLabels, ok = source["showLabels"].(string)
|
tmpinfo.LikeDate, ok = source["likeDate"].(string)
|
if source["baseInfo"] != nil {
|
for _, v := range source["baseInfo"].([]interface{}) {
|
m := v.(map[string]interface{})
|
var bi protomsg.BaseInfo
|
bi.TableId, ok = m["tableId"].(string)
|
bi.TableName, ok = m["tableName"].(string)
|
bi.CompareScore, ok = m["compareScore"].(float64)
|
bi.BwType, ok = m["bwType"].(string)
|
bi.TargetId, ok = m["targetId"].(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)
|
bi.Content, ok = m["content"].(string)
|
tmpinfo.BaseInfo = append(tmpinfo.BaseInfo, &bi)
|
}
|
}
|
tmpinfo.IsAlarm, ok = source["isAlarm"].(bool)
|
tmpinfo.IsAckAlarm, ok = source["isAckAlarm"].(bool)
|
if source["alarmRules"] != nil {
|
for _, v := range source["alarmRules"].([]interface{}) {
|
m := v.(map[string]interface{})
|
var ar protomsg.AlarmRules
|
ar.GroupId, ok = m["groupId"].(string)
|
ar.AlarmLevel, ok = m["alarmLevel"].(string)
|
ar.RuleText, ok = m["ruleText"].(string)
|
ar.DefenceState, ok = m["defenceState"].(bool)
|
ar.LinkInfo, ok = m["linkInfo"].(string)
|
tmpinfo.AlarmRules = append(tmpinfo.AlarmRules, &ar)
|
}
|
|
}
|
tmpinfo.IsCollect, ok = source["isCollect"].(bool)
|
tmpinfo.IsDelete, ok = source["isDelete"].(bool)
|
tmpinfo.Content, ok = source["content"].(string)
|
tmpinfo.LinkTag, ok = source["linkTag"].(string)
|
if source["linkTagInfo"] != nil {
|
for _, v := range source["linkTagInfo"].([]interface{}) {
|
var lti protomsg.EsDataBase
|
lm := v.(map[string]interface{})
|
lti.Id, ok = lm["id"].(string)
|
if !ok {
|
continue
|
}
|
lti.CameraId, ok = lm["cameraId"].(string)
|
if !ok {
|
continue
|
}
|
lti.CameraAddr, ok = lm["cameraAddr"].(string)
|
if !ok {
|
continue
|
}
|
lti.AnalyServerId, ok = lm["analyServerId"].(string)
|
lti.AnalyServerName, ok = lm["analyServerName"].(string)
|
lti.AnalyServerIp, ok = lm["analyServerIp"].(string)
|
lti.ClusterId, ok = lm["clusterId"].(string)
|
lti.TaskId, ok = lm["taskId"].(string)
|
lti.TaskName, ok = lm["taskName"].(string)
|
lti.SdkName, ok = lm["sdkName"].(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 {
|
for _, v := range lm["targetInfo"].([]interface{}) {
|
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)
|
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)
|
ti.TargetLocation = &protomsg.TargetLocation{
|
TopLeft: &protomsg.Location{
|
X: tx,
|
Y: ty,
|
},
|
BottomRight: &protomsg.Location{
|
X: bx,
|
Y: by,
|
},
|
}
|
lti.TargetInfo = append(lti.TargetInfo, &ti)
|
}
|
|
}
|
lti.OtherLabels, ok = lm["otherLabels"].(string)
|
lti.ShowLabels, ok = lm["showLabels"].(string)
|
lti.LikeDate, ok = lm["likeDate"].(string)
|
if lm["baseInfo"] != nil {
|
for _, v := range lm["baseInfo"].([]interface{}) {
|
m := v.(map[string]interface{})
|
var bi protomsg.BaseInfo
|
bi.TableId, ok = m["tableId"].(string)
|
bi.TableName, ok = m["tableName"].(string)
|
bi.CompareScore, ok = m["compareScore"].(float64)
|
bi.BwType, ok = m["bwType"].(string)
|
bi.TargetId, ok = m["targetId"].(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)
|
bi.Content, ok = m["content"].(string)
|
tmpinfo.BaseInfo = append(tmpinfo.BaseInfo, &bi)
|
}
|
}
|
lti.IsAlarm, ok = lm["isAlarm"].(bool)
|
lti.IsAckAlarm, ok = lm["isAckAlarm"].(bool)
|
if lm["alarmRules"] != nil {
|
for _, v := range lm["alarmRules"].([]interface{}) {
|
m := v.(map[string]interface{})
|
var ar protomsg.AlarmRules
|
ar.GroupId, ok = m["groupId"].(string)
|
ar.AlarmLevel, ok = m["alarmLevel"].(string)
|
ar.RuleText, ok = m["ruleText"].(string)
|
ar.DefenceState, ok = m["defenceState"].(bool)
|
ar.LinkInfo, ok = m["linkInfo"].(string)
|
lti.AlarmRules = append(lti.AlarmRules, &ar)
|
}
|
|
}
|
lti.IsCollect, ok = lm["isCollect"].(bool)
|
lti.IsDelete, ok = lm["isDelete"].(bool)
|
lti.Content, ok = lm["content"].(string)
|
tmpinfo.LinkTagInfo = append(tmpinfo.LinkTagInfo, <i)
|
}
|
}
|
tmpinfos = append(tmpinfos, tmpinfo)
|
}
|
return tmpinfos
|
}
|
|
// 解析底库人员结构
|
func Dbpersonbyid(sources []map[string]interface{}) (tmpinfos []protomsg.Dbperson) {
|
var ok bool
|
|
var tmpinfo protomsg.Dbperson
|
for _, source := range sources {
|
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 !ok {
|
continue
|
}
|
|
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)
|
//Isnil("monitorLevel",ok)
|
tmpinfo.UpdateTime, ok = source["updateTime"].(string)
|
//Isnil("updateTime",ok)
|
tmpinfo.Age, ok = source["age"].(string)
|
//Isnil("age", ok)
|
|
isDelete, ok := source["isDelete"].(float64)
|
if ok {
|
tmpinfo.IsDelete = int32(isDelete)
|
}
|
//Isnil("isDelete", ok)
|
|
enable, ok := source["enable"].(float64)
|
if ok {
|
tmpinfo.Enable = int32(enable)
|
}
|
//Isnil("endTime", ok)
|
|
tmpinfo.Reserved, ok = source["reserved"].(string)
|
//Isnil("reserved",ok)
|
tmpinfo.PicDesc, ok = source["picDesc"].(string)
|
//Isnil("picDesc",ok)
|
tmpinfo.CreateTime, ok = source["createTime"].(string)
|
//Isnil("createTime",ok)
|
tmpinfo.CreateBy, ok = source["createBy"].(string)
|
//Isnil("createBy",ok)
|
|
//根据 tableid 获取 tablename
|
//name, _:= Dbtablename(tmpinfo.TableId)
|
//tmpinfo.TableName= name
|
tmpinfos = append(tmpinfos, tmpinfo)
|
}
|
|
return tmpinfos
|
}
|
|
// 解析底库结构
|
func Dbtablebyid(sources []map[string]interface{}) (tmpinfos []protomsg.Dbtable) {
|
var ok bool
|
|
var tmpinfo protomsg.Dbtable
|
for _, source := range sources {
|
|
tmpinfo.Id, ok = source["id"].(string)
|
if !ok {
|
continue
|
}
|
tmpinfo.TableName, ok = source["tableName"].(string)
|
//Isnil("tableName", ok)
|
tmpinfo.TableType, ok = source["tableType"].(string)
|
//Isnil("tableType", ok)
|
tmpinfo.CreateBy, ok = source["createBy"].(string)
|
//Isnil("createBy", ok)
|
tmpinfo.TableDesc, ok = source["tableDesc"].(string)
|
//Isnil("tableDesc", ok)
|
tmpinfo.BwType, ok = source["bwType"].(string)
|
//Isnil("bwType", ok)
|
tmpinfo.StartTime, ok = source["startTime"].(string)
|
//Isnil("startTime", ok)
|
tmpinfo.EndTime, ok = source["endTime"].(string)
|
//Isnil("endTime", ok)
|
|
isDelete, ok := source["isDelete"].(float64)
|
if ok {
|
tmpinfo.IsDelete = int32(isDelete)
|
}
|
//Isnil("isDelete", ok)
|
|
enable, ok := source["enable"].(float64)
|
if ok {
|
tmpinfo.Enable = int32(enable)
|
}
|
//Isnil("endTime", ok)
|
|
tmpinfo.CreateTime, ok = source["createTime"].(string)
|
//Isnil("createTime", ok)
|
tmpinfo.UpdateTime, ok = source["updateTime"].(string)
|
//Isnil("updateTime", ok)
|
tmpinfo.IsForever, ok = source["isForever"].(string)
|
//Isnil("isForever", ok)
|
tmpinfo.IsSync, ok = source["isSync"].(string)
|
//Isnil("isSync", ok)
|
tmpinfo.AnalyServerId, ok = source["analyServerId"].(string)
|
//Isnil("analyServerId", ok)
|
|
tmpinfos = append(tmpinfos, tmpinfo)
|
}
|
|
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)
|
out, ok := info.(map[string]interface{})
|
if !ok {
|
return nil, errors.New("http response interface can not change map[string]interface{}")
|
}
|
|
middle, ok := out["hits"].(map[string]interface{})
|
if !ok {
|
return nil, errors.New("first hits change error!")
|
}
|
for _, in := range middle["hits"].([]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
|
}
|
sources = append(sources, source)
|
}
|
return sources, nil
|
}
|
|
func Sourcelistforscroll(buf []byte) (datasource map[string]interface{}, err error) {
|
var data = make(map[string]interface{})
|
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{}")
|
}
|
scroll_id, ok := out["_scroll_id"].(string)
|
if !ok {
|
return nil, errors.New("first hits change error!")
|
}
|
|
//fmt.Println("middle: ",scroll_id)
|
middle, ok := out["hits"].(map[string]interface{})
|
//fmt.Println("middle: ",out)
|
if !ok {
|
return nil, errors.New("first hits change error!")
|
}
|
var sources = make([]map[string]interface{}, 0)
|
for _, in := range middle["hits"].([]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
|
}
|
sources = append(sources, source)
|
}
|
|
data["sourcelist"] = sources
|
data["scroll_id"] = scroll_id
|
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 SourceAggregationList(buf []byte) (sources []map[string]interface{}, err 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!")
|
}
|
//fmt.Println("本次共匹配条数为: ", out["hits"].(map[string]interface{})["total"].(float64))
|
documentAggregations := middle["group_by_documentnumber"].(map[string]interface{})
|
buckets := documentAggregations["buckets"].([]interface{})
|
if len(buckets) == 0 {
|
return nil, nil
|
}
|
for _, in := range buckets {
|
tmpbuf, ok := in.(map[string]interface{})
|
if !ok {
|
return nil, errors.New("")
|
}
|
sources = append(sources, tmpbuf)
|
}
|
return sources, nil
|
}
|
|
func EsReq(method string, url string, parama []byte) (buf []byte, err error) {
|
//defer elapsed("page")()
|
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 !")
|
return nil, err
|
}
|
|
resp, err := client.Do(request)
|
if err != nil {
|
fmt.Println("request error: ", err)
|
return nil, err
|
}
|
|
defer resp.Body.Close()
|
body, err := ioutil.ReadAll(resp.Body)
|
if err != nil {
|
fmt.Println(err)
|
return nil, err
|
}
|
return body, nil
|
}
|
|
// 计算时间
|
func elapsed(what string) func() {
|
start := time.Now()
|
return func() {
|
fmt.Printf("%s took %v\n", what, time.Since(start))
|
}
|
}
|
|
// 赋值时检测是否能够赋值
|
//func //Isnil(key string, ok bool){
|
// if !ok {
|
// 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))
|
}
|
