package service
|
|
import (
|
"errors"
|
"strconv"
|
"vamicro/config"
|
"vamicro/sync-service/models"
|
"vamicro/sync-service/vo"
|
|
"basic.com/pubsub/protomsg.git"
|
"basic.com/valib/bhomedbapi.git"
|
"basic.com/valib/logger.git"
|
uuid "github.com/satori/go.uuid"
|
)
|
|
type CameraService struct {
|
}
|
|
func (sv CameraService) CameraAdd(camVo vo.CameraEditVo) (bool, models.Camera) {
|
var sysApi bhomedbapi.SysSetApi
|
flag, sysconf := sysApi.GetServerInfo()
|
var realMax = 16
|
if flag && sysconf.RealMax > 0 {
|
realMax = int(sysconf.RealMax)
|
}
|
var err error
|
tx := models.GetDB().Begin()
|
defer func() {
|
if err != nil && tx != nil {
|
tx.Rollback()
|
}
|
}()
|
cam := camVo.Copy2Camera()
|
cam.Type = models.TYPE_LOCAL_CAMERA // 本地摄像机
|
var areaE models.Area
|
if camVo.AreaId != "0" {
|
if _, err = areaE.SelectbyId(camVo.AreaId); err != nil {
|
return false, cam
|
}
|
}
|
cam.Id = uuid.NewV4().String()
|
cam.RunServerId = config.Server.AnalyServerId
|
if camVo.RunType != models.TYPE_RUNTYPE_VIDEO && camVo.RunType != models.TYPE_RUNTYPE_POLL && camVo.RunType != models.TYPE_RUNTYPE_REALTIME {
|
cam.RunType = models.TYPE_RUNTYPE_VIDEO
|
} else {
|
cam.RunType = camVo.RunType
|
}
|
if cam.RunType == models.TYPE_RUNTYPE_REALTIME { //实时需要判断实时数量
|
realList, e := cam.GetCamerasByRunType(models.TYPE_RUNTYPE_REALTIME, "")
|
if e != nil || len(realList) >= realMax {
|
return false, cam
|
}
|
}
|
|
cam.RunEnable = true
|
cam.Floor = models.Default_Layer
|
|
//添加摄像机的时候不应该指定RunServerId,在哪台服务器上配了任务，RunServerId就是对应的那台服务器
|
if err = tx.Table("cameras").Create(&cam).Error; err != nil {
|
return false, cam
|
}
|
|
if err = tx.Table("camera_area").Create(&models.CameraArea{Cameraid: cam.Id, Areaid: camVo.AreaId}).Error; err != nil {
|
return false, cam
|
}
|
|
//处理传感器
|
if len(camVo.Sensors) > 0 {
|
for _, sor := range camVo.Sensors {
|
var sorE models.Sensor
|
exist := sorE.Exist(sor.Ip, sor.Port)
|
sorId := ""
|
if exist {
|
sorId = sorE.Id
|
} else {
|
sor.Id = uuid.NewV4().String()
|
if err = tx.Table(sor.TableName()).Create(&sor).Error; err != nil {
|
return false, cam
|
}
|
sorId = sor.Id
|
}
|
if err = tx.Exec("insert into camera_sensor(camera_id, sensor_id) select '" + cam.Id + "','" + sorId + "' where not exists (select 1 from camera_sensor where camera_id='" + cam.Id + "' and sensor_id='" + sorId + "')").Error; err != nil {
|
return false, cam
|
}
|
}
|
}
|
tx.Commit()
|
return true, cam
|
}
|
|
func (sv CameraService) CameraUpdate(camVo vo.CameraEditVo) bool {
|
cam := camVo.Copy2Camera()
|
var sysApi bhomedbapi.SysSetApi
|
flag, sysconf := sysApi.GetServerInfo()
|
var realMax = 16
|
if flag && sysconf.RealMax > 0 {
|
realMax = int(sysconf.RealMax)
|
}
|
|
var camTmp models.Camera
|
rows, err := camTmp.SelectById(cam.Id)
|
if err != nil || rows == 0 {
|
return false
|
}
|
|
cam.Floor = camTmp.Floor
|
if camTmp.RunServerId == "" { //未设置过run_server_id,此种情况是国标摄像机第一次保存,会选择目标服务器的id
|
cam.RunServerId = config.Server.AnalyServerId //此摄像机归属到本台分析服务器
|
//if cam.RunServerId == "" {
|
// return false
|
//}
|
} else {
|
cam.RunServerId = camTmp.RunServerId //虽然国标摄像机集群内共享，但是更新时不会修改归属
|
}
|
|
//过滤非法数据
|
if cam.RunType != models.TYPE_RUNTYPE_VIDEO && cam.RunType != models.TYPE_RUNTYPE_POLL && cam.RunType != models.TYPE_RUNTYPE_REALTIME {
|
cam.RunType = models.TYPE_RUNTYPE_VIDEO
|
}
|
if cam.RunType == models.TYPE_RUNTYPE_REALTIME {
|
if camTmp.RunType != models.TYPE_RUNTYPE_REALTIME { //由非实时到实时的切换时，需要判断当前的实时数量
|
realList, e := cam.GetCamerasByRunType(models.TYPE_RUNTYPE_REALTIME, "")
|
if e != nil || len(realList) >= realMax {
|
return false
|
}
|
}
|
}
|
//处理传感器
|
var camSensor models.CameraSensor
|
if !camSensor.DeleteByCamId(camVo.Id) {
|
logger.Debug("cameraSensor deleteByCameraId fail")
|
return false
|
}
|
|
if camVo.Sensors != nil && len(camVo.Sensors) > 0 {
|
for _, sor := range camVo.Sensors {
|
var sorE models.Sensor
|
exist := sorE.Exist(sor.Ip, sor.Port)
|
sorId := ""
|
if exist {
|
sorId = sorE.Id
|
if err = models.GetDB().Table(sor.TableName()).Where("id=?", sorId).Update(&sor).Error; err != nil {
|
return false
|
}
|
} else {
|
sor.Id = uuid.NewV4().String()
|
if err = models.GetDB().Table(sor.TableName()).Create(&sor).Error; err != nil {
|
return false
|
}
|
sorId = sor.Id
|
}
|
if err = models.GetDB().Exec("insert into camera_sensor(camera_id, sensor_id) select '" + cam.Id + "','" + sorId + "' where not exists (select 1 from camera_sensor where camera_id='" + camVo.Id + "' and sensor_id='" + sorId + "')").Error; err != nil {
|
return false
|
}
|
}
|
}
|
|
cam.IsRunning = camTmp.IsRunning
|
err = cam.Update()
|
if err != nil {
|
return false
|
}
|
return true
|
}
|
|
func (sv CameraService) GetCamerasByRunType(runType int, cameraName string) (cams []vo.CamSensorVo, err error) {
|
//指定当前机器为过滤条件
|
var cameraE models.Camera
|
list, err := cameraE.GetCamerasByRunType(runType, cameraName)
|
if err != nil {
|
return nil, err
|
}
|
var crApi bhomedbapi.CameraRuleApi
|
var sensorE models.Sensor
|
for _, cam := range list { //判断每一个摄像机是否有可运行的任务和规则
|
if crApi.ExistRunningTask(cam.Id) {
|
sensors, _ := sensorE.FindByCameraId(cam.Id)
|
var camSor vo.CamSensorVo
|
camSor.Camera = cam
|
if sensors != nil {
|
camSor.Sensors = sensors
|
} else {
|
camSor.Sensors = []models.Sensor{}
|
}
|
|
cams = append(cams, camSor)
|
}
|
}
|
return cams, nil
|
}
|
|
func (sv CameraService) UpdateIsRunningState(id string, isRunning bool) bool {
|
var cameraE models.Camera
|
return cameraE.UpdateIsRunningState(id, isRunning)
|
|
}
|
|
func (sv CameraService) UpdateIsRunningAll(camIds []string) bool {
|
var cameraE models.Camera
|
return cameraE.UpdateIsRunningAll(camIds)
|
}
|
|
func (sv CameraService) UpdateRunEnable(cameraId string, runEnable bool) bool {
|
var cameraE models.Camera
|
return cameraE.UpdateRunEnable(cameraId, runEnable)
|
}
|
|
// 1.判断本地摄像机的实时数量
|
// 2.判断是否安装有国标，以及国标实时摄像机的数量
|
func (sv CameraService) ChangeRunType(ccrVo vo.CameraChangeRunVo) bool {
|
var sysApi bhomedbapi.SysSetApi
|
flag, sysconf := sysApi.GetServerInfo()
|
var realMax = 16
|
if flag && sysconf.RealMax > 0 {
|
realMax = int(sysconf.RealMax)
|
}
|
|
var err error
|
tx := models.GetDB().Begin()
|
defer func() {
|
if err != nil && tx != nil {
|
tx.Rollback()
|
}
|
}()
|
for _, cameraId := range ccrVo.CameraIds {
|
var camE models.Camera
|
rows, e := camE.SelectById(cameraId)
|
if e == nil && rows > 0 {
|
if ccrVo.RunType == models.TYPE_RUNTYPE_REALTIME {
|
//非实时向实时切换
|
if camE.RunType != models.TYPE_RUNTYPE_REALTIME {
|
realList, e := camE.GetCamerasByRunType(models.TYPE_RUNTYPE_REALTIME, "")
|
if e != nil || len(realList) >= realMax {
|
err = errors.New("realTime cameras limit " + strconv.Itoa(realMax))
|
return false
|
}
|
} else {
|
continue
|
}
|
}
|
if camE.RunServerId == "" {
|
if err = tx.Exec("update cameras set run_type=?,run_server_id=?,is_running=0 where id=?", ccrVo.RunType, config.Server.AnalyServerId, cameraId).Error; err != nil {
|
return false
|
}
|
} else {
|
if err = tx.Exec("update cameras set run_type=?,is_running=0 where id=?", ccrVo.RunType, cameraId).Error; err != nil {
|
return false
|
}
|
}
|
|
}
|
}
|
tx.Commit()
|
return true
|
}
|
|
func (sv CameraService) UpdateSnapshot(cameraId string, snapshot string) bool {
|
var cameraE models.Camera
|
return cameraE.UpdateSnapshot(cameraId, snapshot)
|
}
|
|
func (sv CameraService) GetAllCamerasByServer(serverId string, cameraName string) (criList []vo.CameraRunInfo, err error) {
|
var cameraE models.Camera
|
list, err := cameraE.FindAllByServer(serverId, cameraName)
|
if err != nil {
|
return nil, err
|
}
|
serverName := ""
|
var syssetApi bhomedbapi.SysSetApi
|
fb, localConf := syssetApi.GetServerInfo()
|
if fb {
|
serverName = localConf.ServerName
|
}
|
nodesMap := make(map[string]protomsg.Node)
|
var clusterApi bhomedbapi.ClusterApi
|
flag, cInfo := clusterApi.FindCluster()
|
if flag && cInfo.Nodes != nil {
|
for _, node := range cInfo.Nodes {
|
nodesMap[node.Id] = *node
|
}
|
}
|
var crApi bhomedbapi.CameraRuleApi
|
|
if list != nil && len(list) > 0 {
|
for _, cE := range list {
|
var cri vo.CameraRunInfo
|
cri.CopyFromCamera(cE)
|
if cri.RunServerId != "" {
|
if cri.RunServerId == config.Server.AnalyServerId {
|
cri.RunServerName = serverName
|
} else {
|
if ne, ok := nodesMap[cri.RunServerId]; ok {
|
cri.RunServerName = ne.NodeName
|
}
|
}
|
}
|
fb, cgs := crApi.FindAllTaskById(cE.Id)
|
if fb && cgs.Rules != nil {
|
for _, g := range cgs.Rules {
|
var crTask vo.CameraRunTask
|
|
crTask.HasRule = g.Enable
|
crTask.TaskName = g.SceneName
|
cri.Tasks = append(cri.Tasks, crTask)
|
}
|
} else {
|
cri.Tasks = []vo.CameraRunTask{}
|
}
|
|
//处理摄像机的状态
|
if cE.RunType == models.TYPE_RUNTYPE_POLL || cE.RunType == models.TYPE_RUNTYPE_REALTIME {
|
if crApi.ExistRunningTask(cE.Id) {
|
if cE.IsRunning {
|
cri.Status = models.Camera_Status_Doing
|
} else {
|
cri.Status = models.Camera_Status_Wait
|
}
|
} else {
|
cri.Status = models.Camera_Status_NoRule
|
}
|
} else {
|
cri.Status = models.Camera_Status_Other
|
}
|
|
criList = append(criList, cri)
|
}
|
}
|
return criList, nil
|
}
|
|
// 通过摄像机id获取在哪台服务器上运行
|
func GetRunServerName(cameraId string) string {
|
var runServerName = ""
|
|
var camTmp models.Camera
|
rows, _ := camTmp.SelectById(cameraId)
|
if rows > 0 {
|
var syssetApi bhomedbapi.SysSetApi
|
fb, localConf := syssetApi.GetServerInfo()
|
if fb {
|
if camTmp.RunServerId == localConf.ServerId { //归属本台服务器
|
runServerName = localConf.ServerName
|
} else { //属于其他服务器
|
var clusterApi bhomedbapi.ClusterApi
|
flag, cInfo := clusterApi.FindCluster()
|
if flag {
|
if cInfo.Nodes != nil {
|
for _, n := range cInfo.Nodes {
|
if n.Id == camTmp.RunServerId {
|
runServerName = n.NodeName
|
break
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
return runServerName
|
}
|
