add refresh token to resp

liuxiaolong

2020-06-05 7c811247ecf143e08c576986a884bedadc57dd66

 controllers/dbtableperson.go

@@ -1,70 +1,117 @@
package controllers

import (
   "encoding/json"
   "fmt"
   "log"
   "basic.com/dbapi.git"
   "basic.com/fileServer/WeedFSClient.git"
   "basic.com/pubsub/protomsg.git"
   "basic.com/valib/logger.git"
   "encoding/base64"
   "io/ioutil"
   "sort"
   "strconv"
   "time"
   "webserver/cache"
   "webserver/service"

   "github.com/gin-gonic/gin"
   "github.com/satori/go.uuid"
   "webserver/extend/code"
   "webserver/extend/config"
   "webserver/extend/esutil"
   "webserver/extend/util"
   "webserver/models"

   esApi "basic.com/pubsub/esutil.git"
)

type DbPersonController struct {
}

// @Security ApiKeyAuth
// @Summary 添加底库人员
// @Description 添加底库人员
// @Accept  json
// @Produce json
// @Tags dbperson 底库人员
// @Param obj body models.Dbtablepersons true "底库人员数据"
// @Success 200 {object} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Failure 400 {object} json code.RequestParamError
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500, msg:"返回错误信息", success:false}"
// @Router /data/api-v/dbperson/addDbPerson [PUT]
func (dbc DbPersonController) AddDbPerson(c *gin.Context) {
   dbperson := new(models.Dbtablepersons)
   c.BindJSON(&dbperson)
   if dbperson.TableId == "" {
   err := c.BindJSON(&dbperson)
   if err!=nil || dbperson.TableId == "" {
      // 底库id不存在
      c.JSON(401, "TableId 不存在")
      util.ResponseFormat(c,code.RequestParamError,"参数有误")
      return
   }
   result := addDbPerson(dbperson)
   if result["success"].(bool) {
      //code.Success.Message = "添加底库人员成功"
      util.ResponseFormat(c, code.Success, result["data"])
   var pApi dbapi.DbPersonApi
   paramBody := util.Struct2Map(dbperson)
   b, data := pApi.AddDbPerson(paramBody)
   if b {
      util.ResponseFormat(c, code.AddSuccess, data)
   } else {
      //code.ServiceInsideError.Message += result["msg"].(string)
      util.ResponseFormat(c, code.ServiceInsideError, result["data"])
      util.ResponseFormat(c, code.ComError, "")
   }
}


type MultiCarNo struct {
   TableId string `json:"tableId" binding:"required"`
   CarNos []string `json:"carNos" binding:"required"`
}

// @Security ApiKeyAuth
// @Summary 批量添加底库车辆
// @Description 批量添加底库车辆
// @Accept  json
// @Produce json
// @Tags dbperson 底库人员
// @Param reqBody body controllers.MultiCarNo true "批量车牌号"
// @Success 200 {string} json "{"code":200, msg:"", success:true}"
// @Failure 500 {string} json "{"code":500, msg:"", success:false}"
// @Router /data/api-v/dbperson/multiUploadCarNo [post]
func (dbc DbPersonController) MultiUploadCarNo(c *gin.Context) {
   var reqBody  MultiCarNo
   err := c.BindJSON(&reqBody)
   if err != nil {
      util.ResponseFormat(c, code.RequestParamError, "")
      return
   }
   logger.Debug("multiUploadCarNo reqBody:", reqBody)
   var pApi dbapi.DbPersonApi
   paramBody := util.Struct2Map(reqBody)
   if pApi.MultiUploadCarNo(paramBody) {
      util.ResponseFormat(c,code.UploadSuccess,"上传成功")
   } else {
      util.ResponseFormat(c,code.ComError,"")
   }
}

func addDbPerson(dbperson *models.Dbtablepersons) (result map[string]interface{}) {

   personId := uuid.NewV4().String() //  以后替代 依据生成规则
   dbperson.Id = personId
   dbperson.PriInsert()
   url := "http://" + config.EsInfo.Masterip + ":" + config.EsInfo.Httpport +
      "/" + config.EsInfo.EsIndex.Dbtablepersons.IndexName + "/" + config.EsInfo.EsIndex.Dbtablepersons.IndexType + "/" + personId + "?refresh=wait_for"
   personbytes, e := json.Marshal(dbperson)
   if e != nil {
      fmt.Print("Json marshaling failed：%s\n", e)

   var pApi dbapi.DbPersonApi
   paramBody := util.Struct2Map(dbperson)
   b, d := pApi.AddDbPerson(paramBody)
   result = map[string]interface{}{}
   if b {
      result["code"] = 200
      personMap := util.Struct2Map(d)
      data := make(map[string]interface{})
      data["uuid"] = personMap["id"]
      result["data"] = data
      result["success"] = true
      result["msg"] = "添加成功"
   } else {
      result["data"] = nil
      result["success"] = false
      result["msg"] = "服务器异常"
      result["code"] = 500
   }
   params := string(personbytes)
   fmt.Print("请求url:%s;\n 请求参数params:%s", url, params)
   data, _ := esutil.PutEsDataReq(url, params)
   //c.JSON(200, changeEsRespData(data, "添加人员成功"))
   result = changeEsRespData(data, "添加成功")
   return result
}

// @Security ApiKeyAuth
// @Summary 修改底库人员
// @Description 修改底库人员
// @Accept  json
@@ -76,34 +123,238 @@
// @Router /data/api-v/dbperson/updateDbPerson [POST]
func (dbc DbPersonController) UpdateDbPerson(c *gin.Context) {
   var dbperson models.Dbtablepersons
   c.BindJSON(&dbperson)
   personid := dbperson.Id
   if personid == "" {
   err := c.BindJSON(&dbperson)
   if err !=nil || dbperson.Id == "" {
      util.ResponseFormat(c, code.RequestParamError, nil)
      return
   }
   dbperson.PriUpdate()
   url := "http://" + config.EsInfo.Masterip + ":" + config.EsInfo.Httpport +
      "/" + config.EsInfo.EsIndex.Dbtablepersons.IndexName + "/" + config.EsInfo.EsIndex.Dbtablepersons.IndexType + "/" + personid + "/_update?refresh=wait_for"
   dbTableByte, err := json.Marshal(dbperson)
   if err != nil {
      log.Fatalf("Json marshaling failed：%s", err)
   }
   //fmt.Printf("%s\n", dbTableByte)
   params := "{\"doc\":" + string(dbTableByte) + "}"
   fmt.Print("请求url:%s;\n 请求参数params:%s", url, params)
   data := esutil.GetEsDataReq(url, params, false)
   //c.JSON(200,  changeEsRespData(data,"修改成功"))
   result := changeEsRespData(data, "修改成功")
   if result["success"].(bool) {
      //code.Success.Message = "修改底库人员成功"
      util.ResponseFormat(c, code.Success, result["data"])
   var pApi dbapi.DbPersonApi
   paramBody := util.Struct2Map(dbperson)
   b, data := pApi.UpdateDbPerson(paramBody)
   if b {
      util.ResponseFormat(c, code.UpdateSuccess, data)
   } else {
      //code.ServiceInsideError.Message += result["msg"].(string)
      util.ResponseFormat(c, code.ServiceInsideError, result["data"])
      util.ResponseFormat(c, code.UpdateFail, "")
   }
}

// @Security ApiKeyAuth
// @Summary 底库人员以图搜图
// @Description 底库人员以图搜图
// @Accept  json
// @Produce json
// @Tags dbperson 底库人员
// @Param condition body models.EsSearch true "底库以图搜图参数"
// @Success 200 {string} json "{"code":200, msg:"", success:true}"
// @Failure 500 {string} json "{"code":500, msg:"", success:false}"
// @Router /data/api-v/dbperson/queryDbPersonsByCompare [POST]
func (dbc DbPersonController) QueryDbPersonsByCompare(c *gin.Context) {
   var searchBody models.EsSearch
   err := c.BindJSON(&searchBody)
   if err !=nil || searchBody.PicUrl == "" || len(searchBody.DataBases) == 0{
      util.ResponseFormat(c, code.RequestParamError, "参数有误")
      return
   }
   var faceB []byte
   if face,ok := faceExtractedMap[searchBody.PicUrl];!ok{
      util.ResponseFormat(c, code.RequestParamError, "请重新上传图片")
      return
   } else {
      faceB = face.FaceBytes
   }

   analyServerId := ""
   conf, e := cache.GetServerInfo()
   if e ==nil && conf.ServerId != "" {
      analyServerId = conf.ServerId
   } else {
      util.ResponseFormat(c, code.ComError, "analyServerId为空，配置有误")
      return
   }

   arg := protomsg.CompareArgs{
      FaceFeature: faceB,
      CompareThreshold: searchBody.Threshold,
   }
   arg.TableIds = searchBody.DataBases
   arg.AnalyServerId = analyServerId
   compareService := service.NewFaceCompareService(arg)
   var totalData service.CompareList

   dbPersonTargets := compareService.CompareDbPersons()
   if dbPersonTargets !=nil {
      totalData = append(totalData,*dbPersonTargets...)
   }

   service.SetCompResultByNum(&service.CompareOnce{
      CompareNum: compareService.CompareNum,
      CompareData: &totalData,
   })

   m := make(map[string]interface{},3)
   if totalData != nil && totalData.Len() > 0{
      sort.Sort(totalData)
      total := totalData.Len()

      m["compareNum"] = compareService.CompareNum
      m["total"] = total
      var sCompResult protomsg.SdkCompareResult
      if total <= searchBody.Size {
         sCompResult.CompareResult = totalData
      } else {
         sCompResult.CompareResult = totalData[0:searchBody.Size]
      }
      resultList := FillDbPersonDataToCompareResult(&sCompResult)
      m["totalList"] = resultList

   } else {
      m["total"] = 0
      m["compareNum"] = compareService.CompareNum
      m["totalList"] = []CompareResult{}
   }
   util.ResponseFormat(c,code.Success,m)
}

//填充向前端返回的数据
func FillDbPersonDataToCompareResult(compResult *protomsg.SdkCompareResult) []models.DbPersonsCompVo {

   var resultList = make([]models.DbPersonsCompVo, len(compResult.CompareResult))
   dbPersonM := make(map[string]ScoreIndex, 0)
   personIds := make([]string,0)

   for idx,v :=range compResult.CompareResult{
      dbPersonM[v.Id] = ScoreIndex{
         Index: idx,
         CompareScore: float64(v.CompareScore),
      }
      personIds = append(personIds,v.Id)
   }
   logger.Debug("comp len(personIds):", len(personIds))

   var dbpersons []protomsg.Dbperson
   if len(personIds) >0 {
      var dbpApi dbapi.DbPersonApi
      dbpersons, _ = dbpApi.Dbpersoninfosbyid(personIds)
   }

   if len(dbpersons) >0 {
      //var dtApi dbapi.DbTableApi
      for _,p :=range dbpersons {
         var dbP models.DbPersonsCompVo

         dbP.Id = p.Id
         dbP.TableId = p.TableId
         dbP.FaceFeature = p.FaceFeature
         dbP.PersonPicUrl = p.PersonPicUrl
         dbP.PersonName = p.PersonName
         dbP.Age = p.Age
         dbP.Sex = p.Sex
         dbP.IdCard = p.IdCard
         dbP.PhoneNum = p.PhoneNum
         dbP.MonitorLevel = p.MonitorLevel
         dbP.Reserved = p.Reserved
         dbP.IsDelete = int(p.IsDelete)
         dbP.Enable = int(p.Enable)
         dbP.CreateTime = p.CreateTime
         dbP.UpdateTime = p.UpdateTime
         dbP.CreateBy = p.CreateBy
         dbP.CompareScore = dbPersonM[p.Id].CompareScore
         //dbTableInfos, _ := dtApi.DbtablesById([]string{ p.TableId })
         //if dbTableInfos !=nil{
         //   dbP.BwType = dbTableInfos[0].BwType
         //   dbP.TableName = dbTableInfos[0].TableName
         //}
         resultList[dbPersonM[p.Id].Index] = dbP
      }
   }

   return  resultList
}

// @Security ApiKeyAuth
// @Summary 更新底库人脸照片
// @Description 更新底库人脸照片
// @Accept multipart/form-data
// @Produce json
// @Tags dbperson 底库人员
// @Param id formData string true "人员id"
// @Param file formData file true "人脸图片"
// @Success 200 {string} json "{"code":200, msg:"", success:true}"
// @Failure 500 {string} json "{"code":500, msg:"", success:false}"
// @Router /data/api-v/dbperson/updateFace [POST]
func (dbc DbPersonController) UpdateFace(c *gin.Context) {
   file, header, err := c.Request.FormFile("file")
   id := c.Request.FormValue("id")
   if err != nil || id == "" {
      util.ResponseFormat(c,code.RequestParamError,"参数有误")
      return
   }
   //文件的名称
   filename := header.Filename
   defer file.Close()
   // weedfs 上传
   fileBytes, err := ioutil.ReadAll(file)
   if err !=nil {
      util.ResponseFormat(c,code.ComError,"图片读取失败")
      return
   }

   //将上传的图片交人脸检测和人脸提取，获得特征
   var faceBase64=""
   faceArr, err, pI := service.GetFaceFeaFromSdk(fileBytes, time.Second*5)
   if faceArr ==nil {
      util.ResponseFormat(c,code.ComError,"未到提取人脸")
      return
   }
   var rcFace *protomsg.Rect
   if err ==nil && len(faceArr) >0 {
      if len(faceArr) >1 {
         util.ResponseFormat(c,code.ComError,"人脸大于一张，请换一张人脸图片")
         return
      }
      for _,r := range faceArr {
         //拿到人脸的坐标
         rcFace = r.Pos.RcFace

         faceBase64 = base64.StdEncoding.EncodeToString(r.Feats)//获取提取到的第一张人脸特征
         break
      }
   }
   localConf, err2 := cache.GetServerInfo()
   if err2 !=nil || localConf.WebPicIp == "" {
      logger.Debug("localConfig is wrong!!!")
      return
   }
   var weedfsUri = "http://"+localConf.WebPicIp+":"+strconv.Itoa(int(localConf.WebPicPort))+"/submit?collection=persistent"
   //根据人脸坐标扣出人脸小图
   t1 := time.Now()
   cutFaceImgData,_ := util.SubCutImg(pI, rcFace, 20)
   logger.Debug("SubImg用时：", time.Since(t1))
   t1 = time.Now()
   weedFilePath, e := WeedFSClient.UploadFile(weedfsUri, filename, cutFaceImgData)
   logger.Debug("上传到weedfs用时:", time.Since(t1))
   t1 = time.Now()
   if e != nil {
      util.ResponseFormat(c,code.ComError,"人脸上传失败")
      return
   }
   m := map[string]interface{} {
      "faceFeature": faceBase64,
      "personPicUrl": weedFilePath,
   }
   util.ResponseFormat(c,code.Success, m)

   //var dbpApi dbapi.DbPersonApi
   //b,d := dbpApi.UpdateFace(id,faceBase64,weedFilePath)
   //if b {
   //   util.ResponseFormat(c,code.UpdateSuccess,d)
   //} else {
   //   util.ResponseFormat(c,code.UpdateFail,"更新人脸失败")
   //}
}

// @Security ApiKeyAuth
// @Summary 删除底库人员
// @Description 删除库人员
// @Accept  x-www-form-urlencoded
@@ -115,207 +366,241 @@
// @Router /data/api-v/dbperson/deleteDbPersonById/{uuid} [POST]

func (dbc DbPersonController) DeleteDbPerson(c *gin.Context) {
   uuid := c.Params.ByName("uuid")
   url := "http://" + config.EsInfo.Masterip + ":" + config.EsInfo.Httpport +
      "/" + config.EsInfo.EsIndex.Dbtablepersons.IndexName + "/" + config.EsInfo.EsIndex.Dbtablepersons.IndexType + "/" + uuid + "/_update?refresh=wait_for"
   params := "{\"doc\":{\"isDelete\":\"1\",\"updateTime\":\"" + time.Now().Format("2006-01-02 15:04:05") + "\"}}"
   fmt.Print("删除请求url:%s;\n 请求参数params:%s", url, params)

   data := esutil.GetEsDataReq(url, params, false)

   //c.JSON(200, changeEsRespData(data,"删除成功"))
   result := changeEsRespData(data, "删除成功")
   if result["success"].(bool) {
      //code.Success.Message = "删除底库人员成功"
      util.ResponseFormat(c, code.Success, result["data"])
   id := c.Params.ByName("uuid")
   if id == "" {
      util.ResponseFormat(c,code.RequestParamError,"参数有误")
      return
   }
   var pApi dbapi.DbPersonApi
   b, data := pApi.DeleteDbPerson(id)
   if b {
      util.ResponseFormat(c, code.Success, data)
   } else {
      //code.ServiceInsideError.Message += result["msg"].(string)
      util.ResponseFormat(c, code.ServiceInsideError, result["data"])
      util.ResponseFormat(c, code.ServiceInsideError, "删除失败")
   }
}

type DelMultiPerson []string

// @Security ApiKeyAuth
// @Summary 删除底库人员
// @Description 删除库人员
// @Accept  json
// @Produce json
// @Tags dbperson 底库人员
// @Param uuids body []string true "底库人员ids "
// @Param uuids body controllers.DelMultiPerson true "底库人员ids "
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/dbperson/deleteMoreDbPerson [POST]
func (dbc DbPersonController) DeleteMoreDbPerson(c *gin.Context) {
   uuids := make([]string, 0, 5)
   c.BindJSON(&uuids)
   bytes, _ := json.Marshal(uuids)
   s := string(bytes)
   url := "http://" + config.EsInfo.Masterip + ":" + config.EsInfo.Httpport +
      "/" + config.EsInfo.EsIndex.Dbtablepersons.IndexName + "/_update_by_query?refresh=wait_for" //   + config.EsInfo.EsIndex.Dbtablepersons.IndexType + "/"  + "/" + s
   params := "{\"script\":{\"lang\":\"painless\",\"inline\":\"ctx._source.isDelete = \\\"1\\\";" +
      "ctx._source.updateTime = \\\"" + time.Now().Format("2006-01-02 15:04:05") + "\\\"\"},\"query\":{\"terms\":{\"_id\":" + s + "}}}"
   fmt.Print("删除请求url:%s;\n 请求参数params:%s", url, params)
   data := esutil.GetEsDataReq(url, params, false)
   //c.JSON(200, changeEsRespData(data,"删除成功"))
   //result := changeEsRespData(data, "删除成功")
   if data["error"] == nil {
      //code.Success.Message = "删除底库人员成功"
   var uuids DelMultiPerson
   err := c.BindJSON(&uuids)
   if err !=nil || len(uuids)==0{
      util.ResponseFormat(c,code.RequestParamError,"参数有误")
      return
   }
   logger.Debug("DeleteMoreDbPerson len(uuids):",len(uuids))
   var pApi dbapi.DbPersonApi
   m := map[string]interface{}{
      "ids": uuids,
   }
   b, _ := pApi.DeleteMoreDbPerson(m)
   if b {
      util.ResponseFormat(c, code.Success, "删除底库人员成功")
   } else {
      //code.ServiceInsideError.Message += result["msg"].(string)
      util.ResponseFormat(c, code.ServiceInsideError, data["error"])
      util.ResponseFormat(c, code.ServiceInsideError, "删除失败")
   }
}

// @Security ApiKeyAuth
// @Summary 查询底库人员列表
// @Description 查询库人员列表
// @Accept  json
// @Produce json
// @Tags dbperson 底库人员
// @Param reqMap body map false "{"tableId":"","orderName":"uuid","orderType":"desc","contentValue":"","page":1,"size":8}"
// @Param reqMap body controllers.DbtSearch false "{"tableId":"","orderName":"id","orderType":"desc","contentValue":"","page":1,"size":8}"
// @Success 200 {string} json "{"code":200, "msg":"目录结构数据", "success":true,"data":{}}"
// @Failure 500 {string} json "{code:500,  msg:"返回错误信息", success:false,data:{}}"
// @Router /data/api-v/dbperson/queryDbPersonsByTbId [POST]
func (dbc DbPersonController) QueryDbPersonsByTbId(c *gin.Context) {
   url := "http://" + config.EsInfo.Masterip + ":" + config.EsInfo.Httpport +
      "/" + config.EsInfo.EsIndex.Dbtablepersons.IndexName + "/_search"
   reqBody := make(map[string]interface{}, 5)
   c.BindJSON(&reqBody)
   tableId := ""
   if reqBody["tableId"] != nil {
      tableId = reqBody["tableId"].(string)
   //reqBody := make(map[string]interface{}, 5)
   var reqBody DbtSearch
   err := c.BindJSON(&reqBody)
   if err !=nil || reqBody.Page <=0 || reqBody.Size <=0 {
      util.ResponseFormat(c,code.RequestParamError,"参数有误")
      return
   }
   orderName := "_id"
   if reqBody["orderName"] != nil {
      orderName = reqBody["orderName"].(string)

   if reqBody.TableId == "" {
      util.ResponseFormat(c,code.RequestParamError,"参数有误，底库id不能为空")
      return
   }
   orderName := "id"
   if reqBody.OrderName != "" {
      orderName = reqBody.OrderName
   } // 列名
   orderType := "desc"
   if reqBody["orderType"] != nil {
      orderType = reqBody["orderType"].(string)
   } // 列类型
   contentValue := ""
   if reqBody["contentValue"] != nil {
      contentValue = reqBody["contentValue"].(string)
   } //输入框内容
   if reqBody.OrderType != "" {
      orderType = reqBody.OrderType
   }
   //搜索内容
   contentValue := reqBody.ContentValue

   page := 1
   if reqBody["page"] != nil {
      page = int(reqBody["page"].(float64))
   if reqBody.Page >1 {
      page = reqBody.Page
   } // 页码
   size := 8
   if reqBody["size"] != nil {
      size = int(reqBody["size"].(float64))
   if reqBody.Size >8 {
      size = reqBody.Size
   } // 条数
   from := (page - 1) * size
   syncTerm := ""
   contentParam := ""
   if tableId == "all" || tableId == "" {
      // / 所有人员
   } else {
      syncTerm = "{\"term\":{\"tableId\":\"" + tableId + "\"}}" // 底库人员
   }
   if contentValue != "" {
      contentParam = ",\"must\":[{\"multi_match\":{\"query\":\"" + contentValue + "\",\"type\":\"best_fields\"," +
         "\"fields\":[\"personName\",\"sex\",\"idCard\",\"phoneNum\"],\"tie_breaker\":0.3}}]"
   }

   if orderType == "desc" {
      orderType = "desc"
   } else {
      orderType = "asc"
   }

   params := "{\"query\":{\"bool\":{\"must_not\":[" +
      "{\"term\":{\"isDelete\":\"1\"}}],\"filter\":[" + syncTerm + "]" + contentParam + "}},\"from\":" + strconv.Itoa(from) + ",\"size\":" + strconv.Itoa(size) + ",\"sort\":{\"" + orderName + "\":{\"order\":\"" + orderType + "\"}}}"
   fmt.Print("请求url:%s;\n 请求参数params:%s", url, params)
   data := esutil.GetEsDataReq(url, params, true)
   //c.JSON(200, data)
   util.ResponseFormat(c, code.Success, data)
   var pApi dbapi.DbPersonApi
   paramBody := map[string]interface{}{
      "tableId": reqBody.TableId,
      "orderName":orderName,
      "orderType":orderType,
      "contentValue":contentValue,
      "page":page,
      "size":size,
   }
   b, data := pApi.QueryDbPersonsByTbId(paramBody)
   if b{
      util.ResponseFormat(c,code.Success,data)
   } else {
      util.ResponseFormat(c,code.ComError,[]interface{}{})
   }
}

// @Summary 查询底库人员列表
// @Description 查询库人员列表
type JoinDbTVo struct {
   CaptureId string       `json:"captureId"`
   TableIds  []string       `json:"tableIds"`
}

// @Security ApiKeyAuth
// @Summary 抓拍人员加入底库
// @Description 抓拍人员加入底库
// @Accept  json
// @Produce json
// @Tags dbperson 底库人员
// @Param reqMap body map false "{"tableId":"","orderName":"uuid","orderType":"desc","contentValue":"","page":1,"size":8}"
// @Success 200 {string} json "{"code":200, "msg":"目录结构数据", "success":true,"data":{}}"
// @Failure 500 {string} json "{code:500,  msg:"返回错误信息", success:false,data:{}}"
// @Router /data/api-v/dbperson/queryDbPersonsByCampare [POST]
func (dbc DbPersonController) QueryDbPersonsByCampare(c *gin.Context) {
   url := "http://" + config.EsInfo.Masterip + ":" + config.EsInfo.Httpport +
      "/" + config.EsInfo.EsIndex.Dbtablepersons.IndexName + "/_search" // ?refresh=wait_for
   reqBody := make(map[string]interface{}, 5)
// @Param obj body controllers.JoinDbTVo true "底库数据"
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/dbperson/joinDbTable [POST]
func (dbc *DbPersonController) JoinDbTable(c *gin.Context) {
   var reqBody JoinDbTVo
   c.BindJSON(&reqBody)
   tableId := ""
   if reqBody["tableId"] != nil {
      tableId = reqBody["tableId"].(string)
   }
   orderName := "_id"
   if reqBody["orderName"] != nil {
      orderName = reqBody["orderName"].(string)
   } // 列名
   orderType := "desc"
   if reqBody["orderType"] != nil {
      orderType = reqBody["orderType"].(string)
   } // 列类型
   faceUrl := ""
   var threshold float32
   if reqBody["faceUrl"] != nil && reqBody["threshold"] != nil {
      faceUrl = reqBody["faceUrl"].(string)
      threshold = float32(reqBody["threshold"].(float64))
   } else {
      util.ResponseFormat(c, code.RequestParamError, nil) // 图片路径有问题
   if reqBody.CaptureId == "" || len(reqBody.TableIds) ==0 {
      util.ResponseFormat(c,code.RequestParamError, "参数有误")
      return
   }
   //输入框内容
   page := 1
   if reqBody["page"] != nil {
      page = int(reqBody["page"].(float64))
   } // 页码
   size := 8
   if reqBody["size"] != nil {
      size = int(reqBody["size"].(float64))
   } // 条数
   from := (page - 1) * size
   syncTerm := ""
   contentParam := ""
   if tableId == "all" || tableId == "" {
      // / 所有人员
   } else {
      syncTerm = "{\"term\":{\"tableId\":\"" + tableId + "\"}}" // 底库人员
   localConf, err := cache.GetServerInfo()
   if err !=nil || localConf.AlarmIp == "" || localConf.AlarmPort <=0 {
      util.ResponseFormat(c,code.ComError,"报警设置有误")
      return
   }
   if orderType == "desc" {
      orderType = "desc"
   } else {
      orderType = "asc"
   }
   aiOceans, e := esApi.AIOceaninfosbyid([]string{reqBody.CaptureId}, config.EsInfo.EsIndex.AiOcean.IndexName, localConf.AlarmIp, strconv.Itoa(int(localConf.AlarmPort)))
   if e ==nil && aiOceans !=nil && len(aiOceans) == 1{
      var personPicUrl = ""//人脸图片
      var feature = ""//特征
      if aiOceans[0].TargetInfo !=nil && len(aiOceans[0].TargetInfo) >0 {
         personPicUrl = aiOceans[0].TargetInfo[0].PicSmUrl
      }
      fea, e2 := esApi.GetVideoPersonFaceFeatureById(reqBody.CaptureId, config.EsInfo.EsIndex.AiOcean.IndexName, localConf.AlarmIp, strconv.Itoa(int(localConf.AlarmPort)))
      if e2 == nil && fea !="" {
         feature = fea
      }
      if personPicUrl != "" && feature != "" {
         //将这张抓拍的照片下载下来上传到collection=persistent的集合中，防止被清理掉
         picB, e3 := util.DownLoad("http://" + personPicUrl)
         if e3 == nil {
            var weedfsUri = "http://"+localConf.WebPicIp+":"+strconv.Itoa(int(localConf.WebPicPort))+"/submit?collection=persistent"
            newPersonPicUrl, e4 := WeedFSClient.UploadFile(weedfsUri, "capturePerson", picB)
            if e4 == nil {
               var dbpApi dbapi.DbPersonApi
               b,d := dbpApi.JoinDbTable(reqBody.TableIds, feature, newPersonPicUrl)
               if b {
                  util.ResponseFormat(c,code.Success,d)
                  return
               } else {
                  util.ResponseFormat(c,code.ComError,"加入失败")
                  return
               }
            }
         }

   //params := "{\"query\":{\"bool\":{\"filter\":[" +
   //   "{\"term\":{\"isDelete\":\"0\"}}" + syncTerm + "]" + contentParam + "}},\"from\":" + strconv.Itoa(from) + ",\"size\":" + strconv.Itoa(size) + ",\"sort\":{\"" + orderName + "\":{\"order\":\"" + orderType + "\"}}}"
   params := "{\"query\":{\"bool\":{\"must_not\":[" +
      "{\"term\":{\"isDelete\":\"1\"}}],\"filter\":[" + syncTerm + "]" + contentParam + "}},\"from\":" + strconv.Itoa(from) + ",\"size\":" + strconv.Itoa(size) + ",\"sort\":{\"" + orderName + "\":{\"order\":\"" + orderType + "\"}}}"
   fmt.Print("请求url:%s;\n 请求参数params:%s", url, params)
   data := esutil.GetEsDataReq(url, params, true)
   featByte := make([]byte, 0, 1024)
   if len(faceUrl) > 3 { //   linux
      /*fileName := picUrl   // picIp 定义在 fileController weedfs 文件服务器 访问 路径 前缀
      detect := gorun.GetSimpleFaceDetect(fileName)
      if len(detect) != 1 {
         util.ResponseFormat(c,code.TooManyFeatureFindError,"图片特征值过多")
         return
      }else {
         featByte = detect[0]["feature"].([]byte)
      }*/ //   linux
      }
   }
   to := page * size
   datalist := sourceCompare(data["datalist"].([]interface{}), false, featByte, threshold)
   total := len(datalist)
   if from > total {
      from = total
   }
   if to > total {
      to = total
   }
   data["datalist"] = datalist[from:to]
   data["total"] = len(datalist)
   //c.JSON(200, data)
   util.ResponseFormat(c, code.Success, data)
   util.ResponseFormat(c,code.ComError,"加入失败")
}

type DbtSearch struct {
   TableId string       `json:"tableId"`
   OrderName string    `json:"orderName"`
   OrderType string    `json:"orderType"`
   ContentValue string `json:"contentValue"`
   Page int          `json:"page"`
   Size int          `json:"size"`
}

type DbPersonMove struct {
   PersonId string `json:"personId"`
   TableIds []string `json:"tableIds"`
}

// @Security ApiKeyAuth
// @Summary 人员移动
// @Description 人员移动
// @Accept  json
// @Produce json
// @Tags dbperson 底库人员
// @Param obj body controllers.DbPersonMove true "移动参数"
// @Success 200 {string} json "{"code":200, msg:"", success:true}"
// @Failure 500 {string} json "{"code":500, msg:"", success:false}"
// @Router /data/api-v/dbperson/move [POST]
func (dbc *DbPersonController) Move(c *gin.Context) {
   var reqBody DbPersonMove
   c.BindJSON(&reqBody)
   if reqBody.PersonId == "" || len(reqBody.TableIds) == 0 {
      util.ResponseFormat(c,code.RequestParamError, "参数有误")
      return
   }
   var dbpApi dbapi.DbPersonApi
   b,d := dbpApi.Move(reqBody.PersonId, reqBody.TableIds)
   if b {
      util.ResponseFormat(c,code.Success,d)
   } else {
      util.ResponseFormat(c,code.ComError,"")
   }
}

// @Security ApiKeyAuth
// @Summary 人员复制
// @Description 人员复制
// @Accept  json
// @Produce json
// @Tags dbperson 底库人员
// @Param obj body controllers.DbPersonMove true "复制参数"
// @Success 200 {string} json "{"code":200, msg:"", success:true}"
// @Failure 500 {string} json "{"code":500, msg:"", success:false}"
// @Router /data/api-v/dbperson/copy [POST]
func (dbc *DbPersonController) Copy(c *gin.Context) {
   var reqBody DbPersonMove
   c.BindJSON(&reqBody)
   if reqBody.PersonId == "" || len(reqBody.TableIds) == 0 {
      util.ResponseFormat(c,code.RequestParamError, "参数有误")
      return
   }
   var dbpApi dbapi.DbPersonApi
   b,d := dbpApi.Copy(reqBody.PersonId, reqBody.TableIds)
   if b {
      util.ResponseFormat(c,code.Success,d)
   } else {
      util.ResponseFormat(c,code.ComError,"")
   }
}