package controllers
|
|
import (
|
"bytes"
|
"encoding/base64"
|
"encoding/json"
|
"fmt"
|
"image"
|
"io/ioutil"
|
"os"
|
"path/filepath"
|
"sort"
|
"strconv"
|
"strings"
|
"unsafe"
|
"vamicro/camera-common/models"
|
commonSv "vamicro/camera-common/service"
|
service2 "vamicro/saas-service/service"
|
scs "vamicro/scene-service/controllers"
|
|
"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"
|
"vamicro/camera-common/vo"
|
"vamicro/config"
|
"vamicro/extend/util"
|
"vamicro/gb28181-service/cache"
|
gbModels "vamicro/gb28181-service/models"
|
"vamicro/gb28181-service/service"
|
)
|
|
type Gb28181Controller struct {
|
}
|
|
// @Summary 获取所有摄像机列表及信息
|
// @Description "获取所有摄像机列表及信息"
|
// @Produce json
|
// @Tags gb28181
|
// @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/gb28181/camera/showAll [get]
|
func (gbc Gb28181Controller) 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("", cameraName, cameraType, cameraId, areaId, linkWhere)
|
if err != nil {
|
return &bhomeclient.Reply{Msg: err.Error()}
|
} else {
|
return &bhomeclient.Reply{Success: true, Data: cams}
|
}
|
}
|
|
// @Summary 更新摄像机
|
// @Description "用于更新摄像机操作"
|
// @Accept json
|
// @Produce json
|
// @Tags gb28181
|
// @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/gb28181/camera/update [put]
|
func (gbc Gb28181Controller) 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)
|
var sv commonSv.CameraService
|
if b, e := sv.CameraUpdate(camVo); b {
|
sv := service.NewGb28181Service(h.Bk)
|
sv.AddDbChangeMsg(protomsg.DbAction_Update)
|
return &bhomeclient.Reply{Success: true, Data: camVo.Copy2Camera()}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: e.Error()}
|
}
|
}
|
|
// @Summary 显示摄像机
|
// @Description "显示摄像机"
|
// @Produce json
|
// @Tags gb28181
|
// @Param cid 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/gb28181/camera/show [get]
|
func (gbc Gb28181Controller) CameraSel(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var cam models.Camera
|
cid := c.Query("cid")
|
|
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}
|
//处理摄像机的状态
|
var crApi bhomedbapi.CameraRuleApi
|
if cam.RunType == models.TYPE_RUNTYPE_POLL || cam.RunType == models.TYPE_RUNTYPE_REALTIME {
|
if crApi.ExistRunningTask(cam.Id) {
|
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
|
}
|
}
|
}
|
}
|
}
|
return &bhomeclient.Reply{Success: true, Data: m}
|
}
|
|
// @Summary 显示gb28181树形结构
|
// @Description 显示gb28181树形结构
|
// @Produce json
|
// @Tags 国标目录树
|
// @Param parentId query string true "区域的id"
|
// @Param searchType query int true "查询类型（0:全部，1:分析摄像机，2:监控摄像机, 3:联动摄像机）"
|
// @Param cameraName query string false "摄像机名称"
|
// @Success 200 {string} json "{"code":200, msg:"目录结构数据"}"
|
// @Failure 500 {string} json "{"code":500, msg:"返回错误信息"}"
|
// @Router /data/api-v/gb28181/tree [get]
|
func (gbc Gb28181Controller) CameraGb28181Tree(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var aram models.Area
|
var searchType = 0
|
var err error
|
|
parentId := c.Query("parentId")
|
if parentId == "" {
|
parentId = "0"
|
}
|
searchTypeStr := c.Query("searchType")
|
cameraName := c.Query("cameraName")
|
treeType := models.TYPE_GB28181_TREE //国标树
|
isPlatformStr := c.Query("isPlatform")
|
isPlatform, _ := strconv.Atoi(isPlatformStr) //单机获取本机摄像机，平台获取所有摄像机
|
|
if searchTypeStr != "" {
|
searchType, err = strconv.Atoi(searchTypeStr)
|
if err != nil {
|
logger.Debug("err:", err)
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
}
|
|
areas, err := aram.Find(parentId, cameraName, util.FiledbyStuct(models.TreeNode{}), treeType)
|
if err != nil {
|
logger.Debug("area.Find err:", err)
|
return &bhomeclient.Reply{Success: false, Msg: err.Error()}
|
}
|
|
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 cam models.Camera
|
cams, err := cam.Find(searchType, cameraName, models.TYPE_GB28181_CAMERA, isPlatform, linkWhere) //查国标摄像机
|
if err != nil {
|
logger.Debug("cam.Find err:", err)
|
return &bhomeclient.Reply{Success: false, Msg: err.Error()}
|
}
|
|
var totalCams models.CamTreeNodeList
|
totalCams = cams
|
sort.Sort(totalCams)
|
|
rAreas := models.RecursiveArea(areas, cams, searchType)
|
|
allRules, e2 := cache.GetCameraRules()
|
ruleM := make(map[string]protomsg.CameraAndRules)
|
if e2 == nil && allRules != nil {
|
for _, r := range allRules {
|
if r.CameraInfo != nil {
|
ruleM[r.CameraInfo.Id] = r
|
}
|
}
|
}
|
|
var totalAreas models.AreaList
|
totalAreas = rAreas
|
sort.Sort(totalAreas)
|
|
arr := menuFormat(totalAreas, parentId, totalCams, treeType, ruleM)
|
for _, camE := range totalCams {
|
if camE.Areaid == "0" {
|
isRunnig := false
|
isAI := false
|
camera := models.Camera{}
|
rows, e := camera.SelectById(camE.Id)
|
if rows > 0 && e == nil {
|
isRunnig = camera.IsRunning
|
if crInfo, ok := ruleM[camera.Id]; ok && crInfo.Rules != nil && len(crInfo.Rules) > 0 && (camera.RunType == models.TYPE_RUNTYPE_POLL || camera.RunType == models.TYPE_RUNTYPE_REALTIME) {
|
isAI = true
|
}
|
//if camera.RunType == models.TYPE_RUNTYPE_POLL || camera.RunType == models.TYPE_RUNTYPE_REALTIME {
|
// isAI = true
|
//}
|
}
|
arr = append(arr, models.TreeMenu{
|
Id: camE.Id,
|
Type: "4",
|
Name: camE.Name,
|
IsRunning: isRunnig,
|
IsAI: isAI,
|
Rtsp: camE.Rtsp,
|
CameraType: treeType,
|
})
|
}
|
}
|
return &bhomeclient.Reply{Success: true, Data: arr}
|
}
|
|
// 将区域和摄像机数组转换目录树形结构
|
func menuFormat(dbArr []models.Area, parentId string, dbCams []models.CameraTreeNode, treeType int, ruleM map[string]protomsg.CameraAndRules) []models.TreeMenu {
|
var arr []models.TreeMenu
|
for _, area := range dbArr {
|
if parentId == area.Parentid {
|
tmp := models.TreeMenu{}
|
tmp.Id = area.Id
|
tmp.Type = "MENU"
|
tmp.Name = area.Name
|
|
sontmp := menuFormat(dbArr, area.Id, dbCams, treeType, ruleM)
|
tmp.Areanodes = sontmp
|
|
for _, val := range dbCams {
|
if val.Areaid == area.Id {
|
camtmp := models.TreeMenu{}
|
camtmp.Id = val.Id
|
camtmp.Name = val.Name
|
camtmp.Type = "4"
|
isRunnig := false
|
isAI := false
|
camera := models.Camera{}
|
rows, e := camera.SelectById(val.Id)
|
if rows > 0 && e == nil {
|
isRunnig = camera.IsRunning
|
if crInfo, ok := ruleM[camera.Id]; ok && crInfo.Rules != nil && len(crInfo.Rules) > 0 && (camera.RunType == models.TYPE_RUNTYPE_POLL || camera.RunType == models.TYPE_RUNTYPE_REALTIME) {
|
isAI = true
|
}
|
//if camera.RunType == models.TYPE_RUNTYPE_POLL || camera.RunType == models.TYPE_RUNTYPE_REALTIME {
|
// isAI = true
|
//}
|
}
|
camtmp.IsAI = isAI
|
camtmp.IsRunning = isRunnig
|
camtmp.Rtsp = val.Rtsp
|
camtmp.CameraType = treeType
|
tmp.Areanodes = append(tmp.Areanodes, camtmp)
|
}
|
}
|
arr = append(arr, tmp)
|
}
|
}
|
return arr
|
}
|
|
// @Summary 刷新Gb28181平台树
|
// @Description 刷新Gb28181平台树
|
// @Produce json
|
// @Tags 国标目录树
|
// @Param id formData string false "国标平台id"
|
// @Success 200 {string} json "{"code":200, data:"",msg:"请求成功", success:true}"
|
// @Failure 200 {string} json "{"code":500, data:"",msg:"请求失败", success:false}"
|
// @Router /data/api-v/gb28181/treeRefresh [post]
|
func (gbc Gb28181Controller) Gb28181TreeRefresh(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
id := c.PostForm("id")
|
sv := service.NewGb28181Service(h.Bk)
|
if b, d := sv.RefreshById(id); b {
|
return &bhomeclient.Reply{Success: true, Msg: "刷新成功", Data: d}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "刷新失败"}
|
}
|
}
|
|
// @Summary 获取国标资源
|
// @Description 获取国标资源
|
// @Produce json
|
// @Tags 国标资源
|
// @Success 200 {string} json "{"code":200, data:"",msg:"请求成功", success:true}"
|
// @Failure 200 {string} json "{"code":500, data:"",msg:"请求失败", success:false}"
|
// @Router /data/api-v/gb28181/getAllChannel [post]
|
func (gbc Gb28181Controller) GetAllChannel(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
sv := service.NewGb28181Service(h.Bk)
|
if b, d := sv.RefreshAllChannel(); b {
|
return &bhomeclient.Reply{Success: true, Msg: "刷新成功", Data: d}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "刷新失败"}
|
}
|
}
|
|
// @Summary 删除Gb28181平台
|
// @Description 删除Gb28181平台
|
// @Produce json
|
// @Tags 国标目录树
|
// @Success 200 {string} json "{"code":200, data:"",msg:"请求成功", success:true}"
|
// @Failure 200 {string} json "{"code":500, data:"",msg:"请求失败", success:false}"
|
// @Router /data/api-v/gb28181/treeDelete [post]
|
func (gbc Gb28181Controller) Gb28181TreeDelete(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
sv := service.NewGb28181Service(h.Bk)
|
if sv.Delete() {
|
return &bhomeclient.Reply{Success: true, Msg: "删除成功"}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "删除失败"}
|
}
|
}
|
|
// @Summary 获取国标区域列表
|
// @Description 获取国标区域列表
|
// @Produce json
|
// @Tags gb28181
|
// @Param parentId query int true "parentId"
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:"成功信息"}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:"错误信息内容"}"
|
// @Router /data/api-v/gb28181/findAreaByParentId [get]
|
func (gbc Gb28181Controller) FindAreaByParentId(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
parentIdStr := c.Query("parentId")
|
if parentIdStr == "" {
|
parentIdStr = "0"
|
}
|
parentId, err := strconv.Atoi(parentIdStr)
|
if err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
var gbaE gbModels.GbCodeArea
|
list, _ := gbaE.FindByParentId(parentId)
|
if list == nil {
|
list = []gbModels.GbCodeArea{}
|
}
|
return &bhomeclient.Reply{Success: true, Data: list}
|
}
|
|
// @Summary 生成新的国标id
|
// @Description 生成新的国标id
|
// @Produce json
|
// @Tags gb28181
|
// @Param code query 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/gb28181/newGbId [get]
|
func (gbc Gb28181Controller) NewGbId(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
areaCode := c.Query("code")
|
if areaCode == "" {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
|
//生成新的国标id,生成规则：系统编码 =中心编码（8位） + 行业编码（2） + 类型编码（11-13位） + 序号（最后7位）
|
//1.code为6位行政区划编码,后面需要接2位的基层接入单位编号
|
if len(areaCode) >= 6 {
|
areaCode = areaCode[:6]
|
}
|
areaCode = areaCode + "00"
|
newGbCode := areaCode
|
//2.行业编码，第9、10位
|
//00 社会治安路面接入
|
//01 社会治安社区接入
|
//02 社会治安内部接入
|
//03 社会治安其他接入
|
//04 交通路面接入
|
//05 交通卡口接入
|
//06 交通内部接入
|
//07 交通其他接入
|
//08 城市管理接入
|
//09 卫生环保接入
|
//10 商检海关接入
|
//11 教育部门接入
|
newGbCode += "01"
|
|
//设备或用户的具体类型,其中的前端设备包含公安系统和非公安系统的前端设备,
|
//终端用户包含公安系统和非公安系统的终端用户。由3位数字组成，即20位国标编码中的第11、12、13位。
|
//3.设备或用户的具体类型,第11、12、13位
|
//111 DVR编码
|
//112 视频服务器编码
|
//113 编码器编码
|
//114 解码器编码
|
//115 视频切换矩阵编码
|
//116 音频切换矩阵编码
|
//117 报警控制器编码
|
//118 网络视频录像机(NVR)编码
|
//130 混合硬盘录像机(HVR)编码
|
//119~130 扩展的前端主设备类型
|
//131 摄像机编码
|
//132 网络摄像机（IPC）编码
|
//133 显示器编码
|
//134 报警输入设备编码（如红外、烟感、门禁等报警设备）
|
//135 报警输出设备编码（如警灯、警铃等设备）
|
//136 语音输入设备编码
|
//137 语音输出设备
|
//138 移动传输设备编码
|
newGbCode += "112"
|
|
//4. 14位为网络标识 (0、1、2、3、4为监控报警专网，5为公安信息网，6为政务网，7为Internet网，
|
// 8为社会资源接入网，9为预留)
|
newGbCode += "1"
|
|
//5.序号指设备或用户的序号。由6位数字组成，即20位国标编码中的15-20位。
|
newGbCode += "000001"
|
logger.Debug("newGbCode：", newGbCode)
|
return &bhomeclient.Reply{Success: true, Data: newGbCode}
|
}
|
|
// @Summary GB28181设置查询
|
// @Description GB28181设置信息查询
|
// @Accept json
|
// @Produce json
|
// @Tags gb28181
|
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
|
// @Failure 500 {string} json "{"code":500, msg:"返回错误信息", success:false}"
|
// @Router /data/api-v/gb28181/configShow [GET]
|
func (gbc Gb28181Controller) Gb28181ConfigShow(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var conf gbModels.Gb28181Config
|
conf.Select()
|
proId := ""
|
cityId := ""
|
zoneId := ""
|
if conf.PublicId != "" && len(conf.PublicId) > 6 {
|
confAreaId := conf.PublicId[:6]
|
var tmpArea gbModels.GbCodeArea
|
tId, _ := strconv.Atoi(confAreaId)
|
rows, _ := tmpArea.SelectById(tId)
|
if rows > 0 {
|
if tmpArea.Level == 3 {
|
zoneId = confAreaId
|
cityId = strconv.Itoa(tmpArea.ParentId)
|
var cityArea gbModels.GbCodeArea
|
crows, _ := cityArea.SelectById(tmpArea.ParentId)
|
if crows > 0 {
|
proId = strconv.Itoa(cityArea.ParentId)
|
}
|
} else if tmpArea.Level == 2 {
|
cityId = confAreaId
|
proId = strconv.Itoa(tmpArea.ParentId)
|
} else if tmpArea.Level == 1 {
|
proId = confAreaId
|
}
|
}
|
}
|
m := util.Struct2Map(conf)
|
m["proId"] = proId
|
m["cityId"] = cityId
|
m["zoneId"] = zoneId
|
return &bhomeclient.Reply{Success: true, Data: m}
|
}
|
|
// @Summary GB28181设置信息修改
|
// @Description GB28181设置修改
|
// @Accept json
|
// @Produce json
|
// @Tags gb28181
|
// @Param config body models.Gb28181Config true "GB28181设置数据"
|
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
|
// @Failure 500 {string} json "{"code":500, msg:"返回错误信息", success:false}"
|
// @Router /data/api-v/gb28181/configEdit [POST]
|
func (gbc Gb28181Controller) Gb28181ConfigEdit(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var reqCon gbModels.Gb28181Config // 前台数据绑定
|
if err := c.BindJSON(&reqCon); err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
logger.Debug("gbConfig:", reqCon)
|
|
sv := service.NewGb28181Service(h.Bk)
|
if sv.Edit(reqCon) {
|
return &bhomeclient.Reply{Success: true, Msg: "保存成功"}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "保存失败"}
|
}
|
|
}
|
|
type Gb28181config struct {
|
GbConfig gbModels.Gb28181Config `json:"gbConfig"`
|
}
|
|
func (gbc Gb28181Controller) SaasGb28181ConfigEdit(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var reqCon Gb28181config // 前台数据绑定
|
if err := c.BindJSON(&reqCon); err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
|
}
|
logger.Debug("gbConfig:", reqCon)
|
|
sv := service.NewGb28181Service(h.Bk)
|
if sv.Edit(reqCon.GbConfig) {
|
return &bhomeclient.Reply{Success: true, Msg: "保存成功"}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "保存失败"}
|
}
|
|
}
|
|
// @Security ApiKeyAuth
|
// @Summary 获取国标下级接入平台列表
|
// @Description 获取国标下级接入平台列表
|
// @Produce json
|
// @Tags gb28181
|
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:"成功信息"}"
|
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:"错误信息内容"}"
|
// @Router /data/api-v/gb28181/getAllSubServer [get]
|
func (gbc Gb28181Controller) GetAllSubServer(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
sv := service.NewGb28181Service(h.Bk)
|
b, d := sv.GetAllSubServer()
|
if b {
|
return &bhomeclient.Reply{Success: true, Data: d}
|
} else {
|
return &bhomeclient.Reply{Msg: "获取失败"}
|
}
|
}
|
|
func (gbc Gb28181Controller) GetGb28181VssTable(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
sv := service.NewGb28181Service(h.Bk)
|
data := sv.GetGb28181VssTable()
|
return &bhomeclient.Reply{Success: true, Data: data}
|
}
|
|
type SaveMenus struct {
|
Menus []service.GbTreeMenu `json:"checkedMenus"`
|
}
|
|
func (gbc Gb28181Controller) SaveGb28181CamTree(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var reqBody SaveMenus
|
if err := c.BindJSON(&reqBody); err != nil {
|
return &bhomeclient.Reply{Msg: "参数有误"}
|
}
|
sv := service.NewGb28181Service(h.Bk)
|
if b, err := sv.SaveGb28181CamTree(reqBody.Menus); b {
|
return &bhomeclient.Reply{Success: true, Msg: "保存成功"}
|
} else {
|
return &bhomeclient.Reply{Msg: "保存失败:" + err.Error()}
|
}
|
}
|
|
// @Summary 获取运行类型获取摄像机列表
|
// @Description 获取运行类型获取摄像机列表
|
// @Produce json
|
// @Tags gb28181
|
// @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/gb28181/camera/getCamerasByRunType [get]
|
func (gbc Gb28181Controller) 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: "参数有误"}
|
}
|
var sv commonSv.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 gb28181
|
// @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/gb28181/camera/updateRunEnable [post]
|
func (gbc Gb28181Controller) 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: "参数有误"}
|
}
|
|
var sv commonSv.CameraService
|
if sv.UpdateRunEnable(cameraId, runEnable) {
|
sv := service.NewGb28181Service(h.Bk)
|
sv.AddDbChangeMsg(protomsg.DbAction_Update)
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功"}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "更新失败"}
|
}
|
}
|
|
// @Summary 摄像机轮询和实时状态切换
|
// @Description 摄像机轮询和实时状态切换
|
// @Produce json
|
// @Tags gb28181
|
// @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/gb28181/camera/changeRunType [post]
|
func (gbc Gb28181Controller) 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: "参数有误"}
|
}
|
|
var sv commonSv.CameraService
|
if sv.ChangeRunType(ccrVo) {
|
sv := service.NewGb28181Service(h.Bk)
|
sv.AddDbChangeMsg(protomsg.DbAction_Update)
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功"}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "更新失败"}
|
}
|
}
|
|
// @Summary 摄像机is_running状态切换
|
// @Description 摄像机is_running状态切换
|
// @Produce json
|
// @Tags gb28181
|
// @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/gb28181/camera/updateIsRunningState [post]
|
func (gbc Gb28181Controller) 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: "参数有误"}
|
}
|
|
var sv commonSv.CameraService
|
if sv.UpdateIsRunningState(cameraId, isRunning) {
|
sv := service.NewGb28181Service(h.Bk)
|
sv.AddDbChangeMsg(protomsg.DbAction_Update)
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功"}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "更新失败"}
|
}
|
}
|
|
type IsRunningArg struct {
|
CameraIds []string `json:"cameraIds"`
|
}
|
|
// @Router /data/api-v/gb28181/camera/updateIsRunningAll [post]
|
func (gbc Gb28181Controller) UpdateIsRunningAll(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
var reqBody IsRunningArg
|
c.BindJSON(&reqBody)
|
logger.Debug("UpdateIsRunningAll cameraId:", reqBody.CameraIds)
|
|
var sv commonSv.CameraService
|
if sv.UpdateIsRunningAll(reqBody.CameraIds) {
|
sv := service.NewGb28181Service(h.Bk)
|
sv.AddDbChangeMsg(protomsg.DbAction_Update)
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功"}
|
} else {
|
return &bhomeclient.Reply{Success: false, Msg: "更新失败"}
|
}
|
}
|
|
// @Summary 更新摄像机快照
|
// @Description 更新摄像机快照
|
// @Produce json
|
// @Tags gb28181
|
// @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/gb28181/camera/updateSnapshotUrl [post]
|
func (gbc Gb28181Controller) UpdateSnapshot(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
cameraId := c.Query("cameraId")
|
logger.Debug("cameraId:", cameraId)
|
if cameraId == "" {
|
return &bhomeclient.Reply{Msg: "参数有误"}
|
}
|
|
var csv commonSv.CameraService
|
flag, camInfo := csv.GetById(cameraId)
|
if !flag {
|
return &bhomeclient.Reply{Msg: "获取摄像机失败"}
|
}
|
|
//////////////////////////////////////////////////
|
/*
|
将capture的图片保存在本地
|
因为网页请求时有5s超时，在此期间很可能拿不到图片
|
*/
|
|
const baseMapDir = "./gb28181BaseMapDir/"
|
|
baseMapFile := baseMapDir + cameraId
|
rep := &bhomeclient.Reply{Msg: "未查找到预存的图片"}
|
|
if _, base64Str, _ := service.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 := service.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: "更新失败"}
|
}
|
}
|
|
if csv.UpdateSnapshot(cameraId, filename) {
|
return &bhomeclient.Reply{Success: true, Msg: "更新成功", Data: map[string]string{
|
"cameraId": cameraId,
|
"snapshotUrl": filename,
|
"base64": base64Str,
|
}}
|
} else {
|
return &bhomeclient.Reply{Msg: "更新失败"}
|
}
|
}
|
|
// @Security ApiKeyAuth
|
// @Summary 获取国标摄像机底图,不存储,返回base64
|
// @Description 获取国标摄像机底图,不存储,返回base64
|
// @Produce json
|
// @Tags 摄像机
|
// @Param id 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/gb28181/camera/capture [get]
|
func (gbc Gb28181Controller) Capture(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
id := c.Query("id")
|
if id == "" {
|
return &bhomeclient.Reply{Msg: "参数有误"}
|
}
|
b, err := service.CaptureBase64(id)
|
if err != nil {
|
return &bhomeclient.Reply{Msg: err.Error()}
|
}
|
strBase64 := base64.StdEncoding.EncodeToString(b)
|
return &bhomeclient.Reply{Success: true, Data: strBase64}
|
}
|
|
func (gbc Gb28181Controller) TreeSelected(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
sv := service.NewGb28181Service(h.Bk)
|
tree := sv.GetGbCurrentTree()
|
return &bhomeclient.Reply{Success: true, Data: tree}
|
}
|
|
// @Summary 在地图上获取摄像机列表
|
// @Description 在地图上获取摄像机列表
|
// @Produce json
|
// @Tags gb28181
|
// @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/gb28181/camera/findOnMap [post]
|
func (gbc Gb28181Controller) 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 gb28181
|
// @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/gb28181/camera/updatePos [post]
|
func (gbc Gb28181Controller) 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 gb28181
|
// @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/gb28181/camera/nodeCamera [get]
|
func (gbc Gb28181Controller) NodeCamera(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
searchType, _ := strconv.Atoi(c.Query("searchType"))
|
camName := c.Query("cameraName")
|
var camE models.Camera
|
|
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, ",")
|
}
|
|
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 gb28181
|
// @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/gb28181/camera/coord [get]
|
func (gbc Gb28181Controller) 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 := service.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
|
}
|
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 gb28181
|
// @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/gb28181/camera/updateCoord [post]
|
func (gbc Gb28181Controller) 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: "更新失败"}
|
}
|
}
|
|
// @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/gb28181/GetSyncCameraData [post]
|
func (gbc Gb28181Controller) GetSyncCameraData(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
|
// 获取设备相继信息
|
var camS commonSv.CameraService
|
camera, err := camS.GetSyncCamera()
|
if err != nil {
|
return &bhomeclient.Reply{Success: false, Msg: "获取摄像机信息失败", Data: camera}
|
}
|
return &bhomeclient.Reply{Success: true, Msg: "获取成功", Data: camera}
|
}
|
|
func (gbc Gb28181Controller) 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 := commonSv.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()
|
|
gsv := service.NewGb28181Service(h.Bk)
|
gsv.AddDbChangeMsg(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: "保存成功"}
|
}
|
