package controllers
|
|
import (
|
"bytes"
|
"database/sql"
|
"encoding/json"
|
"fmt"
|
"image"
|
"path/filepath"
|
|
// "fmt"
|
// "io/ioutil"
|
// "os"
|
// "path/filepath"
|
// "unsafe"
|
|
"strconv"
|
"strings"
|
"vamicro/camera-common/models"
|
"vamicro/camera-common/service"
|
"vamicro/camera-common/vo"
|
"vamicro/camera-service/cache"
|
csv "vamicro/camera-service/service"
|
service2 "vamicro/saas-service/service"
|
|
"basic.com/pubsub/protomsg.git"
|
"basic.com/valib/bhomeclient.git"
|
"basic.com/valib/bhomedbapi.git"
|
"basic.com/valib/go-aiot.git/aiotProto/aiot"
|
"basic.com/valib/logger.git"
|
|
//"vamicro/camera-common/service/uniquelCoordinate"
|
commonModel "vamicro/api-gateway/models"
|
"vamicro/config"
|
"vamicro/extend/util"
|
scs "vamicro/scene-service/controllers"
|
)
|
|
type CameraController struct {
|
}
|
|
// @Summary 添加摄像机
|
// @Description "传入 区域的id（areaid）和摄像机名字(name) 必须， 其他参数可以在摄像机配置点击保存进行添加"
|
// @Accept json
|
// @Produce json
|
// @Tags camera
|
// @Param cameraStruct body vo.CameraEditVo true "struct of camera;the areaid of area's id and name of camera;must need"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"请求处理成功", data:"成功信息"}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:"错误信息内容"}"
|
// @Router /data/api-v/camera/add [post]
|
func (cc CameraController) CameraAdd(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var camVo vo.CameraEditVo
|
if err := c.BindJSON(&camVo); err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
|
sv := service.CameraService{}
|
b, camE, err := sv.CameraAdd(camVo)
|
if b {
|
cc.addDbChangeMsg(h.Bk, protomsg.TableChanged_T_Camera, camVo.Id, protomsg.DbAction_Insert, "")
|
cc.addDbChangeMsg(h.Bk, protomsg.TableChanged_T_CameraPolygon, "", protomsg.DbAction_Insert, "")
|
_, _ = service2.DoBusReq("/data/api-v/saas/syncCamera", config.Server.AnalyServerId, aiot.RequestMethod_Post, aiot.RequestContentType_ApplicationJson, map[string]interface{}{})
|
return &bhomeclient.Reply{Success: true, Data: camE}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: err.Error()}
|
}
|
|
}
|
|
// @Summary 更新摄像机
|
// @Description "用于更新摄像机操作"
|
// @Accept json
|
// @Produce json
|
// @Tags camera
|
// @Param cam body vo.CameraEditVo true "id:摄像机id default:cid0 (string), areaid:摄像机关联区域id default:1 (int), name:摄像机名字 default:Testname(string) 必填； 其他参数可配 "
|
// @Success 200 {string} json "{"code":200, success:true, msg:"请求处理成功", data:"修改后的摄像机信息"}"
|
// @Failure 500 {string} json "{"code":500, success:false msg:"null",data:"错误信息内容"}"
|
// @Router /data/api-v/camera/update [put]
|
func (cc CameraController) CameraUpdate(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var camVo vo.CameraEditVo
|
|
err := c.BindJSON(&camVo)
|
if err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
logger.Debug("update sensors:", camVo.Sensors)
|
sv := service.CameraService{}
|
if b, err := sv.CameraUpdate(camVo); b {
|
cc.addDbChangeMsg(h.Bk, protomsg.TableChanged_T_Camera, camVo.Id, protomsg.DbAction_Update, "")
|
_, _ = service2.DoBusReq("/data/api-v/saas/syncCamera", config.Server.AnalyServerId, aiot.RequestMethod_Post, aiot.RequestContentType_ApplicationJson, map[string]interface{}{})
|
return &bhomeclient.Reply{Success: true, Data: camVo.Copy2Camera()}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: err.Error()}
|
}
|
}
|
|
// @Summary "删除摄像机"
|
// @Description "根据摄像机id删除摄像机"
|
// @Produce json
|
// @Tags camera
|
// @Param cid query string true "摄像机id example: cid0"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"请求处理成功", data:"删除成功"}"
|
// @Failure 500 {string} json "{"code":500, success:false msg:"",data:"错误信息内容"}"
|
// @Router /data/api-v/camera/del [delete]
|
func (cc CameraController) CameraDel(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var cam models.Camera
|
cid := c.Query("id")
|
logger.Debug("CameraDel.id:", cid)
|
if cid == "" {
|
return &bhomeclient.Reply{Msg: "参数有误，摄像机id不能为空"}
|
}
|
rows, _ := cam.Delete(cid)
|
if rows == 0 {
|
return &bhomeclient.Reply{Success: true, Msg: "记录不存在"}
|
}
|
pMsg := protomsg.DbChangeMessage{ //需要重新计算算力占用情况
|
Table: protomsg.TableChanged_T_Camera,
|
Action: protomsg.DbAction_Delete,
|
}
|
pb, _ := json.Marshal(pMsg)
|
h.Bk.Publish(csv.ProcName, pb)
|
_, _ = service2.DoBusReq("/data/api-v/saas/syncCamera", config.Server.AnalyServerId, aiot.RequestMethod_Post, aiot.RequestContentType_ApplicationJson, map[string]interface{}{})
|
return &bhomeclient.Reply{Success: true, Msg: "删除成功"}
|
}
|
|
// @Summary 显示摄像机
|
// @Description "显示摄像机"
|
// @Produce json
|
// @Tags camera
|
// @Param id path string true "摄像机id"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"", data:""}"
|
// @Router /data/api-v/camera/show [get]
|
func (cc CameraController) CameraSel(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var cam models.Camera
|
cid := c.Query("id")
|
|
rows, err := cam.SelectById(cid)
|
if err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
if rows == 0 {
|
return &bhomeclient.Reply{Success: false, Msg: "没有记录"}
|
}
|
m := util.Struct2Map(cam)
|
var sor models.Sensor
|
sensors, _ := sor.FindByCameraId(cid)
|
if sensors != nil {
|
m["sensors"] = sensors
|
} else {
|
m["sensors"] = []models.Sensor{}
|
}
|
|
//摄像机分辨率
|
dRe0 := models.Resolution{
|
Width: 0,
|
Height: 0,
|
}
|
dRe1 := models.Resolution{
|
Width: 1920,
|
Height: 1080,
|
}
|
dRe2 := models.Resolution{
|
Width: 2688,
|
Height: 1520,
|
}
|
|
m["resolutions"] = []models.Resolution{dRe0, dRe1, dRe2}
|
|
//获取督查任务
|
tasks := models.GetTasks()
|
//处理摄像机的状态
|
//var crApi bhomedbapi.CameraRuleApi
|
if cam.RunType == models.TYPE_RUNTYPE_POLL || cam.RunType == models.TYPE_RUNTYPE_REALTIME {
|
//if crApi.ExistRunningTask(cam.Id) {
|
if taskInfo, ok := tasks[cam.Id]; ok && taskInfo != nil && len(taskInfo) > 0 {
|
if cam.IsRunning {
|
m["status"] = models.Camera_Status_Doing
|
} else {
|
m["status"] = models.Camera_Status_Wait
|
}
|
} else {
|
m["status"] = models.Camera_Status_NoRule
|
}
|
} else {
|
m["status"] = models.Camera_Status_Err
|
}
|
if cam.RunServerId != "" {
|
if cam.RunServerId == config.Server.AnalyServerId {
|
lc, e := cache.GetServerInfo()
|
if e == nil {
|
m["runServerName"] = lc.ServerName
|
}
|
} else { //属于其他服务器
|
var cluApi bhomedbapi.ClusterApi
|
flag, info := cluApi.FindCluster()
|
if flag && info.ClusterId != "" && len(info.Nodes) > 0 {
|
for _, n := range info.Nodes {
|
if cam.RunServerId == n.NodeId {
|
m["runServerName"] = n.NodeName
|
break
|
}
|
}
|
}
|
}
|
}
|
//_, _ = service2.DoBusReq("/data/api-v/saas/syncCamera", config.Server.AnalyServerId, aiot.RequestMethod_Post, aiot.RequestContentType_ApplicationJson, map[string]interface{}{})
|
return &bhomeclient.Reply{Success: true, Data: m}
|
}
|
|
// @Summary 获取所有摄像机列表及信息
|
// @Description "获取所有摄像机列表及信息"
|
// @Produce json
|
// @Tags camera
|
// @Param cameraName query string false "摄像机名称"
|
// @Param runType query string false "0:全部，1：分析，2：监控，3：联动"
|
// @Param cameraId query string false "摄像机id"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/showAll [get]
|
func (cc CameraController) GetAllCameras(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
cameraName := c.Query("cameraName")
|
cameraType, _ := strconv.Atoi(c.Query("runType"))
|
cameraId := c.Query("cameraId")
|
areaId := c.Query("areaId")
|
var cam models.Camera
|
|
lkMap := make(map[string]string)
|
linkWhere := ""
|
if cameraType == 3 { //查联动
|
var crApi bhomedbapi.CameraRuleApi
|
lb, lkList := crApi.FindAllCameraLink()
|
if !lb {
|
return &bhomeclient.Reply{Msg: "查询联动配置失败"}
|
}
|
if len(lkList) == 0 {
|
return &bhomeclient.Reply{Success: true, Data: []struct{}{}}
|
}
|
for _, lc := range lkList {
|
cArr := strings.Split(lc.CameraIds, ",")
|
for _, lcId := range cArr {
|
if _, ok := lkMap[lcId]; !ok {
|
lkMap[lcId] = lcId
|
}
|
}
|
}
|
for k := range lkMap {
|
linkWhere += "'" + k + "',"
|
}
|
linkWhere = strings.TrimRight(linkWhere, ",")
|
}
|
|
cams, err := cam.FindAllByServer(config.Server.AnalyServerId, cameraName, cameraType, cameraId, areaId, linkWhere)
|
if err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: err.Error()}
|
}
|
return &bhomeclient.Reply{Success: true, Data: cams}
|
}
|
|
// @Summary 获取运行类型获取摄像机列表
|
// @Description 获取运行类型获取摄像机列表
|
// @Produce json
|
// @Tags camera
|
// @Param runType query int true "0：查轮询，1：查实时"
|
// @Param cameraName query string false "查询条件"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/getCamerasByRunType [get]
|
func (cc CameraController) GetCamerasByRunType(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
runTypeStr := c.Query("runType")
|
cameraName := c.Query("cameraName")
|
logger.Debug("runType:", runTypeStr)
|
logger.Debug("cameraName:", cameraName)
|
runType, err := strconv.Atoi(runTypeStr)
|
if err != nil || (runType != 0 && runType != 1) {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
sv := service.CameraService{}
|
list, err := sv.GetCamerasByRunType(runType, cameraName)
|
if err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: err.Error()}
|
} else {
|
return &bhomeclient.Reply{Success: true, Data: list}
|
}
|
}
|
|
// @Summary 切换摄像机运行实时或轮询的开关
|
// @Description 切换摄像机运行实时或轮询的开关
|
// @Produce json
|
// @Tags camera
|
// @Param cameraId formData string true "摄像机id"
|
// @Param runEnable formData bool true "开启：true，关闭：false"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/updateRunEnable [post]
|
func (cc CameraController) UpdateRunEnable(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
cameraId := c.PostForm("cameraId")
|
enableStr := c.PostForm("runEnable")
|
runEnable, _ := strconv.ParseBool(enableStr)
|
if cameraId == "" {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
|
sv := service.CameraService{}
|
if sv.UpdateRunEnable(cameraId, runEnable) {
|
cc.addDbChangeMsg(h.Bk, protomsg.TableChanged_T_Camera, cameraId, protomsg.DbAction_Update, "")
|
_, _ = service2.DoBusReq("/data/api-v/saas/syncCamera", config.Server.AnalyServerId, aiot.RequestMethod_Post, aiot.RequestContentType_ApplicationJson, map[string]interface{}{})
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功"}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "更新失败"}
|
}
|
}
|
|
// @Summary 摄像机轮询和实时状态切换
|
// @Description 摄像机轮询和实时状态切换
|
// @Produce json
|
// @Tags camera
|
// @Param changeRunBody body vo.CameraChangeRunVo true "参数结构体,0：实时切轮询，1：轮询切实时"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/changeRunType [post]
|
func (cc CameraController) ChangeRunType(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var ccrVo vo.CameraChangeRunVo
|
if err := c.BindJSON(&ccrVo); err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
|
sv := service.CameraService{}
|
if sv.ChangeRunType(ccrVo) {
|
//cIds := strings.Join(ccrVo.CameraIds, ",")
|
//cc.addDbChangeMsg(h.Bk, protomsg.TableChanged_T_Camera, cIds, protomsg.DbAction_Update, "")
|
// _, _ = service2.DoBusReq("/data/api-v/saas/syncCamera", config.Server.AnalyServerId, aiot.RequestMethod_Post, aiot.RequestContentType_ApplicationJson, map[string]interface{}{})
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功"}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "更新失败"}
|
}
|
}
|
|
// @Summary 摄像机is_running状态切换
|
// @Description 摄像机is_running状态切换
|
// @Produce json
|
// @Tags camera
|
// @Param cameraId formData string true "摄像机id"
|
// @Param is_running formData bool true "解码中：true，停止解码：false"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/updateIsRunningState [post]
|
func (cc CameraController) UpdateIsRunningState(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
cameraId := c.PostForm("cameraId")
|
isRunningStr := c.PostForm("isRunning")
|
isRunning, _ := strconv.ParseBool(isRunningStr)
|
if cameraId == "" {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
|
sv := service.CameraService{}
|
if sv.UpdateIsRunningState(cameraId, isRunning) {
|
_, _ = service2.DoBusReq("/data/api-v/saas/syncCamera", config.Server.AnalyServerId, aiot.RequestMethod_Post, aiot.RequestContentType_ApplicationJson, map[string]interface{}{})
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功"}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "更新失败"}
|
}
|
}
|
|
type IsRunningArg struct {
|
CameraIds []string `json:"cameraIds"`
|
}
|
|
func (cc CameraController) UpdateIsRunningAll(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var reqBody IsRunningArg
|
c.BindJSON(&reqBody)
|
logger.Debug("UpdateIsRunningAll cameraId:", reqBody.CameraIds)
|
|
sv := service.CameraService{}
|
if sv.UpdateIsRunningAll(reqBody.CameraIds) {
|
_, _ = service2.DoBusReq("/data/api-v/saas/syncCamera", config.Server.AnalyServerId, aiot.RequestMethod_Post, aiot.RequestContentType_ApplicationJson, map[string]interface{}{})
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功"}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "更新失败"}
|
}
|
}
|
|
const (
|
File_Img_Id_Pre = "img_"
|
File_Video_Id_Pre = "video_"
|
File_Audio_Id_Pre = "audio_"
|
)
|
|
// @Summary 更新摄像机快照
|
// @Description 更新摄像机快照
|
// @Produce json
|
// @Tags camera
|
// @Param cameraId formData string true "摄像机id"
|
// @Param snapshot formData string true "快照地址"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/updateSnapshotUrl [post]
|
func (cc CameraController) UpdateSnapshot(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
cameraId := c.Query("cameraId")
|
logger.Debug("cameraId:", cameraId)
|
if cameraId == "" {
|
return &bhomeclient.Reply{Msg: "参数有误"}
|
}
|
if strings.HasPrefix(cameraId, File_Video_Id_Pre) || strings.HasPrefix(cameraId, File_Img_Id_Pre) || strings.HasPrefix(cameraId, File_Audio_Id_Pre) {
|
var fileApi bhomedbapi.FileAnalysisApi
|
b, d := fileApi.Show(cameraId)
|
if b {
|
var file protomsg.FileAnalysis
|
bytes, _ := json.Marshal(d)
|
err := json.Unmarshal(bytes, &file)
|
if err == nil {
|
return &bhomeclient.Reply{Success: true, Data: map[string]string{
|
"cameraId": cameraId,
|
"snapshotUrl": file.SnapshotUrl,
|
}}
|
} else {
|
return &bhomeclient.Reply{Msg: "更新失败"}
|
}
|
} else {
|
return &bhomeclient.Reply{Msg: "更新失败"}
|
}
|
}
|
|
sv := service.CameraService{}
|
flag, camInfo := sv.GetById(cameraId)
|
if !flag {
|
return &bhomeclient.Reply{Msg: "获取摄像机失败"}
|
}
|
|
//////////////////////////////////////////////////
|
/*
|
将capture的图片保存在本地
|
因为网页请求时有5s超时，在此期间很可能拿不到图片
|
*/
|
// const baseMapDir = "./cameraBaseMapDir/"
|
|
// baseMapFile := baseMapDir + cameraId
|
// rep := &bhomeclient.Reply{Msg: "未查找到预存的图片"}
|
|
// if _, base64Str, _ := csv.UpdateCapture(camInfo.Type, camInfo.Rtsp, "", camInfo.Name); len(base64Str) > 0 {
|
|
// rep = &bhomeclient.Reply{
|
// Success: true,
|
// Msg: "从本地[cameraBaseMapDir]获取图片base64",
|
// Data: map[string]string{
|
// "cameraId": cameraId,
|
// "snapshotUrl": "",
|
// "base64": base64Str,
|
// },
|
// }
|
|
// _, err := os.Stat(baseMapDir)
|
// if os.IsNotExist(err) {
|
// if err := os.MkdirAll(baseMapDir, 0755); err != nil {
|
// logger.Debug("======>> 未获取到图片文件夹")
|
// fmt.Println("======>> 未获取到图片文件夹")
|
// }
|
// logger.Debug("======>> create basemap directory")
|
// fmt.Println("======>> create basemap directory")
|
// }
|
// tmp := (*[2]uintptr)(unsafe.Pointer(&base64Str))
|
// tmp2 := [3]uintptr{tmp[0], tmp[1], tmp[1]}
|
// b64 := *(*[]byte)(unsafe.Pointer(&tmp2))
|
// if err := ioutil.WriteFile(baseMapFile, b64, 0644); err != nil {
|
// logger.Debug("======>> WriteFile Image BaseMap Failed")
|
// fmt.Println("======>> WriteFile Image BaseMap Failed")
|
// }
|
// } else {
|
// // 首先查找是否存在此照片
|
// found := false
|
// filepath.Walk(baseMapDir, func(path string, info os.FileInfo, err error) error {
|
// if err != nil {
|
// return err
|
// }
|
// if !info.IsDir() && info.Name() == cameraId {
|
// found = true
|
// return nil
|
// }
|
// return nil
|
// })
|
|
// if found {
|
// if image, err := ioutil.ReadFile(baseMapFile); err == nil {
|
// logger.Debug("======>> 获取图片，发送回去")
|
// fmt.Println("======>> 获取图片，发送回去")
|
// rep = &bhomeclient.Reply{
|
// Success: true,
|
// Msg: "从本地[cameraBaseMapDir]获取图片base64",
|
// Data: map[string]string{
|
// "cameraId": cameraId,
|
// "snapshotUrl": "",
|
// "base64": *(*string)(unsafe.Pointer(&image)),
|
// },
|
// }
|
// }
|
// }
|
// }
|
|
// return rep
|
|
/*
|
将capture的图片保存在本地
|
因为网页请求时有5s超时，在此期间很可能拿不到图片
|
*/
|
//////////////////////////////////////////////////
|
var sysApi bhomedbapi.SysSetApi
|
sb, sysconf := sysApi.GetServerInfo()
|
if !sb || sysconf.WebPicIp == "" {
|
return &bhomeclient.Reply{Msg: "未获取到图片服务器ip"}
|
}
|
weedfsUri := "http://" + sysconf.WebPicIp + ":" + strconv.Itoa(int(sysconf.WebPicPort)) + "/submit?collection=" + sysconf.ServerId + "-persistent"
|
filename, base64Str, err := csv.UpdateCapture(camInfo.Type, camInfo.Rtsp, weedfsUri, camInfo.Name)
|
if err != nil {
|
logger.Debug("UpdateSnapshotUrl.err:", err)
|
if base64Str != "" { //上传到图片服务器失败
|
return &bhomeclient.Reply{Msg: "上传失败，返回base64", Data: map[string]string{
|
"cameraId": cameraId,
|
"snapshotUrl": "",
|
"base64": base64Str,
|
}}
|
} else {
|
return &bhomeclient.Reply{Msg: "更新失败,原因:" + err.Error()}
|
}
|
}
|
|
if sv.UpdateSnapshot(cameraId, filename) {
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功", Data: map[string]string{
|
"cameraId": cameraId,
|
"snapshotUrl": filename,
|
"base64": base64Str,
|
}}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "更新失败"}
|
}
|
}
|
|
// @Summary 更新摄像机快照
|
// @Description 更新摄像机快照
|
// @Produce json
|
// @Tags camera
|
// @Param id formData string true "摄像机id"
|
// @Param type formData int true "摄像机类型"
|
// @Param rtsp formData string true "摄像机rtsp地址"
|
// @Param name formData string true "摄像机名称"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/updateSnapshotSaaS [get]
|
func (cc CameraController) UpdateSnapshotSaaS(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
cameraId := c.Query("id")
|
name := c.Query("name")
|
typeStr := c.Query("type")
|
rtsp := c.Query("rtsp")
|
logger.Debug("cameraId: ", cameraId, "name: ", name, "type: ", typeStr, "rtsp: ", rtsp)
|
if cameraId == "" || rtsp == "" || name == "" {
|
return &bhomeclient.Reply{Msg: "参数有误"}
|
}
|
camType, err := strconv.Atoi(typeStr)
|
if err != nil || (camType != 0 && camType != 1) {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
if strings.HasPrefix(cameraId, File_Video_Id_Pre) || strings.HasPrefix(cameraId, File_Img_Id_Pre) || strings.HasPrefix(cameraId, File_Audio_Id_Pre) {
|
var fileApi bhomedbapi.FileAnalysisApi
|
b, d := fileApi.Show(cameraId)
|
if b {
|
var file protomsg.FileAnalysis
|
bytes, _ := json.Marshal(d)
|
err := json.Unmarshal(bytes, &file)
|
if err == nil {
|
return &bhomeclient.Reply{Success: true, Data: map[string]string{
|
"cameraId": cameraId,
|
"snapshotUrl": file.SnapshotUrl,
|
}}
|
} else {
|
return &bhomeclient.Reply{Msg: "更新失败"}
|
}
|
} else {
|
return &bhomeclient.Reply{Msg: "更新失败"}
|
}
|
}
|
|
sv := service.CameraService{}
|
var sysApi bhomedbapi.SysSetApi
|
sb, sysconf := sysApi.GetServerInfo()
|
if !sb || sysconf.WebPicIp == "" {
|
return &bhomeclient.Reply{Msg: "未获取到图片服务器ip"}
|
}
|
weedfsUri := "http://" + sysconf.WebPicIp + ":" + strconv.Itoa(int(sysconf.WebPicPort)) + "/submit?collection=" + sysconf.ServerId + "-persistent"
|
filename, base64Str, err := csv.UpdateCapture(camType, rtsp, weedfsUri, name)
|
if err != nil {
|
logger.Debug("UpdateSnapshotUrl.err:", err)
|
if base64Str != "" { //上传到图片服务器失败
|
return &bhomeclient.Reply{Success: true, Msg: "上传失败，返回base64", Data: map[string]string{
|
"cameraId": cameraId,
|
"snapshotUrl": "",
|
"base64": base64Str,
|
}}
|
} else {
|
return &bhomeclient.Reply{Msg: "更新失败,原因:" + err.Error()}
|
}
|
}
|
|
if sv.UpdateSnapshot(cameraId, filename) {
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功", Data: map[string]string{
|
"cameraId": cameraId,
|
"snapshotUrl": filename,
|
"base64": base64Str,
|
}}
|
} else {
|
return &bhomeclient.Reply{Success: true, Msg: "更新失败，返回base64", Data: map[string]string{
|
"cameraId": cameraId,
|
"snapshotUrl": filename,
|
"base64": base64Str,
|
}}
|
}
|
}
|
|
// 拖拽到其他组织
|
// 需要 当前camid , 以及修改后的areaid // 直接使用camera update api interface.
|
|
// @Summary 将摄像机挂到指定的目录树下
|
// @Description 将摄像机挂到指定的目录树下
|
// @Produce json
|
// @Tags camera
|
// @Param cameraId formData string true "摄像机id"
|
// @Param areaId formData string true "目录区域id"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"请求处理成功", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:"错误信息内容"}"
|
// @Router /data/api-v/camera/updateCameraArea [post]
|
func (cc CameraController) UpdateCameraArea(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
cameraId := c.PostForm("cameraId")
|
areaId := c.PostForm("areaId")
|
if cameraId == "" || areaId == "" {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
var caE models.CameraArea
|
if caE.UpdateArea(cameraId, areaId) {
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功"}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "更新失败"}
|
}
|
}
|
|
// @Summary 删除某一个目录树下的指定摄像机
|
// @Description 删除某一个目录树下的指定摄像机
|
// @Produce json
|
// @Tags camera
|
// @Param cameraId path string true "摄像机id"
|
// @Param areaId path string true "指定目录区域id"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"请求处理成功", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:"错误信息内容"}"
|
// @Router /data/api-v/camera/cameraAreaDel [get]
|
func (cc CameraController) CameraAreaDel(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
//cameraId := c.Param("cameraId")
|
//areaId := c.Param("areaId")
|
//logger.Debug(cameraId)
|
//logger.Debug(areaId)
|
return nil
|
}
|
|
// @Summary 在地图上获取摄像机列表
|
// @Description 在地图上获取摄像机列表
|
// @Produce json
|
// @Tags camera
|
// @Param quryArg body vo.CameraQueryVo true "摄像机列表查询"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/findOnMap [post]
|
func (cc CameraController) FindOnMap(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var searchArg vo.CameraQueryVo
|
err := c.BindJSON(&searchArg)
|
if err != nil {
|
return &bhomeclient.Reply{Msg: "参数有误"}
|
}
|
logger.Debug("isOnMap:", searchArg.IsOnMap)
|
logger.Debug("floorStr:", searchArg.Floor)
|
logger.Debug("cameraName:", searchArg.CameraName)
|
var cam models.Camera
|
cams, err := cam.FindBy(searchArg.IsOnMap, searchArg.Floor, searchArg.CameraName)
|
if err != nil {
|
return &bhomeclient.Reply{Msg: "查询失败"}
|
}
|
return &bhomeclient.Reply{Success: true, Data: cams}
|
}
|
|
// @Summary 更新摄像机地图位置
|
// @Description 更新摄像机地图位置
|
// @Produce json
|
// @Tags camera
|
// @Param posArg body vo.CameraPosVo true "摄像机位置更新参数"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/updatePos [post]
|
func (cc CameraController) UpdatePos(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var arg vo.CameraPosVo
|
err := c.BindJSON(&arg)
|
if err != nil || arg.Id == "" {
|
return &bhomeclient.Reply{Msg: "参数有误"}
|
}
|
var cam models.Camera
|
if cam.UpdatePos(arg.Id, arg.Floor, arg.Longitude, arg.Latitude) {
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功"}
|
} else {
|
return &bhomeclient.Reply{Msg: "更新失败"}
|
}
|
}
|
|
// @Summary 获取集群中各节点的摄像机
|
// @Description 获取集群中各节点的摄像机
|
// @Produce json
|
// @Tags camera
|
// @Param searchType query int true "查询类型（0：全部，1：分析摄像机，2：监控摄像机, 3:联动摄像机）"
|
// @Param cameraName query string false "摄像机名称"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/nodeCamera [get]
|
func (cc CameraController) NodeCamera(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
searchType, _ := strconv.Atoi(c.Query("searchType"))
|
camName := c.Query("cameraName")
|
|
lkMap := make(map[string]string)
|
linkWhere := ""
|
if searchType == 3 { //查联动
|
var crApi bhomedbapi.CameraRuleApi
|
lb, lkList := crApi.FindAllCameraLink()
|
if !lb {
|
return &bhomeclient.Reply{Msg: "查询联动配置失败"}
|
}
|
if len(lkList) == 0 {
|
return &bhomeclient.Reply{Success: true, Data: []struct{}{}}
|
}
|
for _, lc := range lkList {
|
cArr := strings.Split(lc.CameraIds, ",")
|
for _, lcId := range cArr {
|
if _, ok := lkMap[lcId]; !ok {
|
lkMap[lcId] = lcId
|
}
|
}
|
}
|
for k := range lkMap {
|
linkWhere += "'" + k + "',"
|
}
|
linkWhere = strings.TrimRight(linkWhere, ",")
|
}
|
|
var camE models.Camera
|
allCams, _ := camE.FindAllByServer("", camName, searchType, "", "", linkWhere)
|
|
result := make([]models.TreeMenu, 0)
|
var clusterApi bhomedbapi.ClusterApi
|
b, ci := clusterApi.FindCluster()
|
if b {
|
if ci.Nodes != nil && len(ci.Nodes) > 0 {
|
for _, n := range ci.Nodes {
|
result = append(result, models.TreeMenu{
|
Id: n.NodeId,
|
Name: n.NodeName,
|
Type: "MENU",
|
Areanodes: getCamsByNodeId(allCams, n.NodeId),
|
})
|
}
|
}
|
}
|
return &bhomeclient.Reply{Success: true, Data: result}
|
}
|
|
func getCamsByNodeId(cams []models.Camera, nodeId string) []models.TreeMenu {
|
arr := make([]models.TreeMenu, 0)
|
|
if cams != nil {
|
var camRuleApi bhomedbapi.CameraRuleApi
|
for _, c := range cams {
|
if c.RunServerId == nodeId {
|
isRunnig := false
|
isAI := false
|
camera := models.Camera{}
|
rows, e := camera.SelectById(c.Id)
|
|
if rows > 0 && e == nil {
|
isRunnig = camera.IsRunning
|
isAI = camRuleApi.ExistRunningTask(c.Id) && (camera.RunType == models.TYPE_RUNTYPE_POLL || camera.RunType == models.TYPE_RUNTYPE_REALTIME)
|
}
|
arr = append(arr, models.TreeMenu{
|
Id: c.Id,
|
Type: "4",
|
Name: c.Name,
|
IsAI: isAI, //是否AI摄像机
|
IsRunning: isRunnig,
|
Rtsp: c.Rtsp,
|
CameraType: -1,
|
})
|
}
|
}
|
}
|
|
return arr
|
}
|
|
// @Summary 获取摄像机的坐标标定信息
|
// @Description 获取摄像机的坐标标定信息
|
// @Produce json
|
// @Tags camera
|
// @Param cameraId query string true "摄像机id"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/coord [get]
|
func (cc CameraController) Coord(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
cameraId := c.Query("cameraId")
|
if cameraId == "" {
|
return &bhomeclient.Reply{Msg: "参数有误"}
|
}
|
logger.Debug("coord cameraId:", cameraId)
|
var camE models.Camera
|
rows, err := camE.SelectById(cameraId)
|
if err == nil && rows > 0 {
|
var snapShotUrl = ""
|
if camE.SnapshotUrl == "" {
|
var sysApi bhomedbapi.SysSetApi
|
sb, sysconf := sysApi.GetServerInfo()
|
if !sb || sysconf.WebPicIp == "" {
|
return &bhomeclient.Reply{Msg: "未获取到图片服务器ip"}
|
}
|
weedfsUri := "http://" + sysconf.WebPicIp + ":" + strconv.Itoa(int(sysconf.WebPicPort)) + "/submit?collection=" + sysconf.ServerId + "-persistent"
|
//没有底图需要先刷新底图
|
snapUrl, _, err := csv.UpdateCapture(camE.Type, camE.Rtsp, weedfsUri, camE.Name)
|
if err != nil {
|
return &bhomeclient.Reply{Msg: err.Error()}
|
}
|
snapShotUrl = snapUrl
|
} else {
|
snapShotUrl = camE.SnapshotUrl
|
}
|
if !strings.HasPrefix(snapShotUrl, "http://") {
|
snapShotUrl = "http://" + snapShotUrl
|
}
|
|
result := vo.CoordTransShow{
|
Coords: make([]vo.CoordTrans, 0),
|
PanoramaCoords: make([]vo.CPoint, 0),
|
}
|
if camE.CoordTransform == "" {
|
return &bhomeclient.Reply{Success: true, Data: result}
|
} else {
|
var coords []vo.CoordTrans
|
err := json.Unmarshal([]byte(camE.CoordTransform), &coords)
|
if err != nil {
|
logger.Debug("unmarshal CoordTransform err:", err)
|
return &bhomeclient.Reply{Msg: "坐标转换失败"}
|
}
|
result.Coords = coords
|
}
|
if len(result.Coords) == 0 {
|
result.PanoramaCoords = make([]vo.CPoint, 0)
|
return &bhomeclient.Reply{Success: true, Data: result}
|
}
|
bts, dE := util.DownLoad(snapShotUrl)
|
if dE != nil {
|
return &bhomeclient.Reply{Msg: "获取摄像机底图失败"}
|
}
|
reader := bytes.NewReader(bts)
|
im, _, err := image.DecodeConfig(reader)
|
if err != nil {
|
return &bhomeclient.Reply{Msg: "获取底图分辨率宽高失败"}
|
}
|
w := im.Width
|
h := im.Height
|
logger.Debug("coord w:", w, "h", h)
|
/*args, e := json.Marshal(map[string]interface{}{
|
"coordTrans": result.Coords,
|
"w": w,
|
"h": h,
|
})
|
if e != nil {
|
return &bhomeclient.Reply{Msg:e.Error()}
|
}
|
panoCoordStr := uniquelCoordinate.TransCoord(string(args))
|
if panoCoordStr != "" {
|
logger.Debug("panoCoordStr:", panoCoordStr)
|
var cresult vo.CCoordResult
|
err = json.Unmarshal([]byte(panoCoordStr), &cresult)
|
if err != nil {
|
logger.Debug("将panoCoordStr 转化为CCoordResult失败,err:", err)
|
result.PanoramaCoords = make([]vo.CPoint, 0)
|
} else {
|
result.PanoramaCoords = cresult.Result
|
}
|
}*/
|
|
return &bhomeclient.Reply{Success: true, Data: result}
|
} else {
|
return &bhomeclient.Reply{Msg: "摄像机查询失败"}
|
}
|
}
|
|
// @Summary 更新摄像机的坐标标定信息
|
// @Description 更新摄像机的坐标标定信息
|
// @Produce json
|
// @Tags camera
|
// @Param reqBody body vo.CoordSetVo true "摄像机坐标转换参数"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/updateCoord [post]
|
func (cc CameraController) UpdateCoord(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var reqBody vo.CoordSetVo
|
err := c.BindJSON(&reqBody)
|
if err != nil || reqBody.CameraId == "" {
|
return &bhomeclient.Reply{Msg: "参数有误"}
|
}
|
//有时候会出现x0和y0相同，但是x1和y1不一样的bug
|
m := make(map[string]vo.CoordTrans)
|
newList := make([]vo.CoordTrans, 0)
|
for _, ct := range reqBody.Coords {
|
k := strconv.Itoa(ct.X0) + ":" + strconv.Itoa(ct.Y0)
|
if _, exist := m[k]; !exist {
|
newList = append(newList, ct)
|
m[k] = ct
|
}
|
}
|
reqBody.Coords = newList //去除重复的
|
bts, err := json.Marshal(reqBody.Coords)
|
if err != nil {
|
return &bhomeclient.Reply{Msg: "坐标转换失败"}
|
}
|
var camE models.Camera
|
if camE.UpdateCoordTrans(reqBody.CameraId, string(bts)) {
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功"}
|
} else {
|
return &bhomeclient.Reply{Msg: "更新失败"}
|
}
|
}
|
|
func (cc CameraController) addDbChangeMsg(bk bhomeclient.Broker, tChanged protomsg.TableChanged, id string, action protomsg.DbAction, info string) {
|
dbMsg := protomsg.DbChangeMessage{
|
Table: tChanged,
|
Id: id,
|
Action: action,
|
Info: info,
|
}
|
pb, _ := json.Marshal(dbMsg)
|
bk.Publish(csv.ProcName, pb)
|
}
|
|
// @Summary 获取要同步的摄像机信息数据
|
// @Description 获取要同步的摄像机信息数据
|
// @Produce json
|
// @Tags camera
|
// @Param reqBody body vo.CoordSetVo true ""
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/GetSyncCameraData [post]
|
func (cc CameraController) GetSyncCameraData(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
// 获取设备相继信息
|
var camS service.CameraService
|
camera, err := camS.GetSyncCamera()
|
if err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: "获取摄像机信息失败", Data: camera}
|
}
|
return &bhomeclient.Reply{Success: true, Msg: "获取成功", Data: camera}
|
}
|
|
// @Summary 获取要同步的摄像机传感器信息数据
|
// @Description 获取要同步的摄像机传感器信息数据
|
// @Produce json
|
// @Tags camera
|
// @Param reqBody body vo.CoordSetVo true ""
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
|
// @Router /data/api-v/camera/GetSyncSensorData [post]
|
func (cc CameraController) GetSyncSensorData(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
// 获取设备相继信息
|
var camS service.CameraService
|
camera, err := camS.GetSyncSensor()
|
if err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: "获取摄像机传感器信息失败", Data: camera}
|
}
|
return &bhomeclient.Reply{Success: true, Msg: "获取成功", Data: camera}
|
}
|
|
func (cc CameraController) SaveNotExistOrUpdate(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var reqBody scs.SyncCameraAndArea
|
if e := c.BindJSON(&reqBody); e != nil {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
|
var err error
|
tx := models.GetDB().Begin()
|
defer func() {
|
if err != nil && tx != nil {
|
logger.Error("SaveNotExistOrUpdate rollback err:", err)
|
tx.Rollback()
|
}
|
}()
|
sv := service.CameraService{}
|
for _, cam := range reqBody.Cams {
|
if err = sv.SaveNotExistOrUpdate(tx, cam); err != nil {
|
logger.Error("SaveNotExistOrUpdate err:", err)
|
return &bhomeclient.Reply{Msg: err.Error()}
|
}
|
}
|
if err = sv.SaveOrUpdateAreas(tx, reqBody.Areas, reqBody.CamAndArea); err != nil {
|
logger.Error("SaveOrUpdateAreas err:", err)
|
return &bhomeclient.Reply{Msg: err.Error()}
|
}
|
|
tx.Commit()
|
|
cc.addDbChangeMsg(h.Bk, protomsg.TableChanged_T_Camera, "", protomsg.DbAction_Update, "")
|
cc.addDbChangeMsg(h.Bk, protomsg.TableChanged_T_CameraPolygon, "", protomsg.DbAction_Update, "")
|
_, _ = service2.DoBusReq("/data/api-v/saas/syncCamera", config.Server.AnalyServerId, aiot.RequestMethod_Post, aiot.RequestContentType_ApplicationJson, map[string]interface{}{})
|
return &bhomeclient.Reply{Success: true, Msg: "保存成功"}
|
}
|
|
/**
|
* 获取抓拍记录
|
*/
|
func (cc CameraController) GetRecord(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
|
//绑定json和结构体
|
info := models.RecordReq{}
|
if err := c.BindJSON(&info); err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
page := info.Page
|
pageSize := info.PageSize
|
idsStr := info.Ids
|
TaskIds := info.TaskIds
|
TaskName := info.TaskName
|
videoIdStr := info.VideoIds
|
Warning := info.Warning
|
|
filter := "zh_desc_class != '' "
|
|
//根据id获取记录
|
var ids []string
|
if len(idsStr) > 0 {
|
for _, tmp := range idsStr {
|
id, _ := strconv.ParseInt(tmp, 10, 64)
|
if id > 0 {
|
ids = append(ids, tmp)
|
}
|
}
|
filter += fmt.Sprintf(" and %s in [%s]", "id", strings.Join(ids, ","))
|
}
|
|
//根据视频id查询
|
var videoIds []string
|
if len(videoIdStr) > 0 {
|
for _, tmp := range videoIdStr {
|
if len(tmp) > 0 {
|
videoIds = append(videoIds, tmp)
|
}
|
}
|
//根据id查询视频id
|
var vids []int64
|
cameras, _ := models.GetCameraIds(videoIds)
|
for _, camera := range cameras {
|
if len(camera.Id) > 0 {
|
vids = append(vids, camera.VideoId)
|
}
|
}
|
idStr := make([]string, len(vids))
|
for i, id := range vids {
|
idStr[i] = strconv.FormatInt(id, 10)
|
}
|
filter += fmt.Sprintf(" and %s in [%s]", "video_point_id", strings.Join(idStr, ","))
|
}
|
|
//根据任务查询
|
if len(TaskIds) > 0 {
|
filter += fmt.Sprintf(" and array_contains(task_id, %d)", TaskIds[0])
|
}
|
|
//根据任务名称
|
if len(TaskName) > 0 {
|
quotedNames := make([]string, len(TaskName))
|
for i, name := range TaskName {
|
quotedNames[i] = "'" + name + "'" // 每个元素加单引号
|
}
|
filter += fmt.Sprintf(" and %s in [%s]", "task_name", strings.Join(quotedNames, ","))
|
} else {
|
if Warning > 0 {
|
return &bhomeclient.Reply{Success: true, Msg: "获取成功", Data: nil}
|
}
|
}
|
|
//是否预警
|
if Warning > 0 {
|
filter += fmt.Sprintf(" and is_waning == %d", Warning)
|
}
|
|
//filter += " ORDER BY detect_time DESC"
|
if len(filter) > 0 {
|
logger.Error("filter err:", filter)
|
}
|
|
result, err := models.GetWithPage("smartobject", int64(page), int64(pageSize), filter)
|
// 通用响应
|
if err != nil {
|
if err == sql.ErrNoRows {
|
return &bhomeclient.Reply{Success: false, Msg: "数据为空"}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "获取列表失败"}
|
}
|
}
|
//组织数据
|
//重新组织数据
|
basePath := commonModel.GetBasePath()
|
|
tmpAllDate := make(map[string]interface{})
|
tmpDate := make(map[string][]interface{})
|
|
for _, v := range result.Items {
|
|
sources := make(map[string]interface{}, 0)
|
|
temp := models.StaticRecord{
|
Id: v.Id,
|
TaskId: v.TaskId,
|
RuleId: v.RuleId,
|
EventLevelId: v.EventLevelId,
|
VideoPointId: v.VideoPointId,
|
DetectId: v.DetectId,
|
ImagePath: v.ImagePath,
|
VideoPath: v.VideoPath,
|
DetectTime: v.DetectTime,
|
IsWarning: v.IsWarning,
|
DetectNum: v.DetectNum,
|
TaskName: v.TaskName,
|
ZhDescClass: v.ZhDescClass,
|
EventLevelName: v.EventLevelName,
|
KnowledgeId: v.KnowledgeId,
|
Suggestion: v.Suggestion,
|
RiskDescription: v.RiskDescription,
|
IsDesc: v.IsDesc,
|
PicMaxUrl: []string{v.ImagePath},
|
PicSrcUrl: []string{v.ImagePath},
|
PicWH: models.PicWidHei{PicH: 720, PicW: 1280},
|
VideoUrl: v.VideoPath,
|
AnalyServerName: "智能服务节点",
|
Content: v.CameraName,
|
PicDate: v.PicDate,
|
LikeDate: v.LikeDate,
|
}
|
|
//任务名称
|
items, _ := models.GetTaskByIds(v.TaskId)
|
temp.TaskNames = items
|
|
//视频内容
|
items4, _ := models.GetVideoById(v.VideoPointId)
|
temp.VideoName = items4.Name
|
temp.CameraAddr = items4.Addr
|
|
//检查内容
|
items2, _ := models.GetCheckByIds(v.DetectId)
|
temp.CheckNames = items2
|
|
//规则内容
|
items3, _ := models.GetRuleByIds(v.RuleId)
|
temp.RuleNames = items3
|
|
//事件
|
items5, _ := models.GetEventByIds(v.EventLevelId)
|
temp.EventLevels = items5
|
|
//知识库
|
items6, _ := models.GetKnowledgeDocumentByIds(v.KnowledgeId)
|
// 知识库路径
|
var KnowledgePath = "/txt/zs/"
|
for i := range items6 {
|
filePath := filepath.Join(basePath + KnowledgePath + items6[i].Title)
|
newPath := filepath.ToSlash(filePath)
|
items6[i].FileUrl = newPath
|
}
|
temp.KnowledgeDocuments = items6
|
|
sources["list"] = []interface{}{
|
temp,
|
}
|
|
sources["activeObject"] = temp
|
|
tmpDate["datalist"] = append(tmpDate["datalist"], sources)
|
|
}
|
tmpAllDate["datalist"] = tmpDate["datalist"]
|
|
var pageRes = &models.PaginatedResult2{
|
Pagination: result.Pagination,
|
Items: tmpAllDate,
|
}
|
return &bhomeclient.Reply{Success: true, Msg: "获取成功", Data: pageRes}
|
}
|
|
/**
|
*获取督查任务
|
*/
|
func (cc CameraController) GetTasks(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
//绑定json和结构体
|
|
info := models.Video{}
|
if err := c.BindJSON(&info); err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
|
var tasks []models.Task
|
|
if len(info.VideoIds) > 0 {
|
tasks, _ = models.GetListTask(info.VideoIds)
|
}
|
|
return &bhomeclient.Reply{Success: true, Msg: "获取成功", Data: tasks}
|
|
}
|
|
// 获取所有
|
func (cc CameraController) GetAllTasks(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
//绑定json和结构体
|
|
var tasks []models.TaskAggregate
|
tasks, _ = models.GetAllTask()
|
|
return &bhomeclient.Reply{Success: true, Msg: "获取成功", Data: tasks}
|
|
}
|
