package service
|
|
import (
|
"bytes"
|
"encoding/json"
|
"errors"
|
"fmt"
|
"strconv"
|
"strings"
|
"time"
|
"vamicro/camera-common/models"
|
"vamicro/config"
|
"vamicro/extend/util"
|
gbModels "vamicro/gb28181-service/models"
|
|
"basic.com/gb28181api.git"
|
"basic.com/pubsub/protomsg.git"
|
"basic.com/valib/bhomeclient.git"
|
"basic.com/valib/bhomedbapi.git"
|
"basic.com/valib/logger.git"
|
"github.com/jinzhu/gorm"
|
uuid "github.com/satori/go.uuid"
|
)
|
|
type Gb28181Service struct {
|
bk bhomeclient.Broker
|
}
|
|
func NewGb28181Service(broker bhomeclient.Broker) *Gb28181Service {
|
return &Gb28181Service{
|
bk: broker,
|
}
|
}
|
|
func (s Gb28181Service) Edit(gbConfig gbModels.Gb28181Config) bool {
|
timeUnix := time.Now().Unix()
|
fmtTimeStr := time.Unix(timeUnix, 0).Format("2006-01-02 15:04:05")
|
gbConfig.UpdateTime = fmtTimeStr
|
var gbConf gbModels.Gb28181Config
|
rows, _ := gbConf.Select()
|
if rows > 0 { //已存在，编辑
|
gbConfig.Id = gbConf.Id
|
gbConfig.ServerPort = 8060
|
data := util.Struct2Map(gbConfig)
|
if err := models.GetDB().Table(gbConf.TableName()).Updates(data).Error; err != nil {
|
return false
|
}
|
} else { //新增
|
gbConfig.Id = uuid.NewV4().String()
|
gbConfig.ServerPort = 8060
|
if err := models.GetDB().Table(gbConf.TableName()).Create(&gbConfig).Error; err != nil {
|
return false
|
}
|
}
|
|
setGbIp := getGbIp()
|
if setGbIp != "" {
|
//接入国标的平台树
|
var gbApi gb28181api.Gb28181Api
|
gb28181api.Init(setGbIp, gbConfig.ServerPort)
|
//设置国标平台基础配置
|
gbApi.SetPlatformServerInfo(gb28181api.GbServerInfo{
|
Name: "贝思科国标服务",
|
PublicID: gbConfig.PublicId,
|
GbServerPort: gbConfig.GbServerPort,
|
RtspServrPort: 7554,
|
HTTPClientIP: "",
|
HTTPClientPort: gbConfig.ServerPort,
|
RegisterAuth: gbConfig.IsAuth,
|
GbPasswd: gbConfig.Password,
|
})
|
//先更新资源
|
gbApi.UpdateAllResource()
|
} else {
|
logger.Error("刷新国标服务时，setGbIp不能为空!!!!")
|
return false
|
}
|
|
return true
|
}
|
|
type gbDevAndArea struct {
|
PublicId string
|
ParentId string
|
}
|
|
type VssTable struct {
|
Vd []gbModels.VssDev `json:"vd"`
|
Du map[string]gbModels.VssDomainUnit `json:"du"`
|
Vc map[string]gbModels.VssChannel `json:"vc"`
|
GbCam []models.Camera `json:"gbCam"`
|
}
|
|
//获取国标服务使用的ip(可能是漂移ip)
|
func getGbIp() string {
|
setGbIp := ""
|
localIp, _, _ := util.GetLocalIP(config.Server.NetworkAdapter) //没有配置，则取本机ip
|
var clusterApi bhomedbapi.ClusterApi
|
b, c := clusterApi.FindCluster()
|
logger.Debug("FindCluster b:", b, " c:", c)
|
if b && c.Nodes != nil && len(c.Nodes) > 0 {
|
//在集群内，则非漂移master节点，使用漂移ip，否则使用本机ip。此处漂移master节点，使用漂移ip访问不到本机，这个原因是iptables转换策略改的是本机入的，漂移ip会给到本机的8060，
|
//但是本机出的不走这个策略，所以本机使用漂移ip访问不到本机的8060
|
driftMasterId := ""
|
for _, n := range c.Nodes {
|
if n.DriftState == "master" { //查看当前漂移master节点是否是本机
|
driftMasterId = n.NodeId
|
break
|
}
|
}
|
if driftMasterId != "" {
|
if driftMasterId == config.Server.AnalyServerId { //当前节点是漂移master
|
setGbIp = localIp
|
} else {
|
setGbIp = c.VirtualIp //取漂移ip
|
}
|
}
|
} else {
|
setGbIp = localIp
|
}
|
return setGbIp
|
}
|
|
func (s Gb28181Service) GetAllSubServer() (bool, interface{}) {
|
setGbIp := getGbIp()
|
if setGbIp == "" {
|
return false, errors.New("获取国标ip失败")
|
}
|
var gbConfig gbModels.Gb28181Config
|
rows, _ := gbConfig.Select()
|
if rows == 0 { //已存在，编辑
|
return false, errors.New("请先设置国标配置")
|
}
|
gbConfig.ServerPort = 8060
|
var gbApi gb28181api.Gb28181Api
|
gb28181api.Init(setGbIp, gbConfig.ServerPort)
|
devices, b := gbApi.GetAllDevices()
|
return b, devices
|
}
|
|
// UpdateGb28181Data 从videosvr的sqlite3.db中获取数据, 写入到当前数据库的同步表
|
func (s Gb28181Service) UpdateGb28181Data() (bool, error) {
|
setGbIp := getGbIp()
|
if setGbIp == "" {
|
return false, errors.New("获取国标ip失败")
|
}
|
|
var gbConfig gbModels.Gb28181Config
|
rows, _ := gbConfig.Select()
|
if rows == 0 { //已存在，编辑
|
return false, errors.New("请先设置国标配置")
|
}
|
|
gbConfig.ServerPort = 8060
|
var gbApi gb28181api.Gb28181Api
|
gb28181api.Init(setGbIp, gbConfig.ServerPort)
|
|
var err error
|
tx := models.GetDB().Begin()
|
defer func() {
|
if err != nil && tx != nil {
|
tx.Rollback()
|
logger.Debug("updateGb28181Data err:", err)
|
}
|
}()
|
|
// 清除旧数据,以videosvr数据为准
|
err = tx.Exec("delete from " + gbModels.VssDev{}.TableName() + "").Error
|
if err != nil {
|
return false, err
|
}
|
|
err = tx.Exec("delete from " + gbModels.VssDomainUnit{}.TableName() + "").Error
|
if err != nil {
|
return false, err
|
}
|
|
err = tx.Exec("delete from " + gbModels.VssChannel{}.TableName() + "").Error
|
if err != nil {
|
return false, err
|
}
|
|
// 获取所有下级
|
devices, flag := gbApi.GetAllDevices()
|
logger.Debug("gb28181 group devices:", devices)
|
|
if flag && devices != nil && len(devices) > 0 {
|
if err = batchSaveGbDev(tx, devices); err != nil {
|
return false, err
|
}
|
|
for _, d := range devices {
|
|
// 获取下级的所有通道个目录. 数据来源于vsschannel表, resType = 1 是通道, resType = 2 表示目录
|
allCams, allGroups, b := gbApi.GetAllCamerasAndGroupsByDevID(d.PublicID)
|
logger.Debug("publicId:", d.PublicID, " b:", b, " len(allCams):", len(allCams), " len(allGroups)", len(allGroups))
|
|
if b && len(allCams) > 0 {
|
//t1 := time.Now()
|
if err = batchSaveGbChannel(tx, allCams); err != nil {
|
logger.Debug("batchSaveGbChannel err:", err)
|
return false, err
|
}
|
//logger.Debug("batchSaveGbChannel耗时:", time.Since(t1))
|
}
|
|
// 将resType = 2 的区域信息, 合并到domainUnit表.
|
// 该功能后来被屏蔽过, 应该是和domainUnit的数据有冲突. 一个通道出现了两个组织. 所以干脆以domainUnit为准, 忽略了这里的组织
|
// 但是也有可能导致结构不全, 比如普洱国标整合了这些区域信息后就是正确的.
|
// 可根据不同的结构可以进行调整. 暂时先放开, 保证有尽可能多的的组织结构
|
if len(allGroups) > 0 {
|
//t1 := time.Now()
|
if err = batchSaveGbDomainUnit(tx, allGroups); err != nil {
|
return false, err
|
}
|
//logger.Debug("batchSaveGbDomainUnit耗时:", time.Since(t1))
|
}
|
}
|
}
|
|
// 获取所有国标区域
|
domainUnits, b := gbApi.GetAllDomainUnit()
|
logger.Debug("gb28181 gb units:", len(domainUnits))
|
if b && domainUnits != nil && len(domainUnits) > 0 {
|
if err = batchSaveGbDomainUnit(tx, domainUnits); err != nil {
|
return false, err
|
}
|
}
|
|
tx.Commit()
|
return true, nil
|
}
|
|
func batchSaveGbDev(tx *gorm.DB, dArr []gb28181api.DeviceInfo) error {
|
var buffer bytes.Buffer
|
sql := "insert into `" + gbModels.VssDev{}.TableName() + "` (`publicId`,`name`,`ip`,`port`,`corp`,`parentId`,`username`,`passwd`,`devMode`,`alive`) values "
|
if _, err := buffer.WriteString(sql); err != nil {
|
return err
|
}
|
for i, d := range dArr {
|
if i == len(dArr)-1 {
|
buffer.WriteString(fmt.Sprintf("('%s','%s','%s',%d,'%s','%s','%s','%s','%s',%d);", d.PublicID, d.Name, d.IP, d.Port, d.Corp, d.Parentid, d.Username, d.Passwd, d.Devmode, d.Alive))
|
} else {
|
buffer.WriteString(fmt.Sprintf("('%s','%s','%s',%d,'%s','%s','%s','%s','%s',%d),", d.PublicID, d.Name, d.IP, d.Port, d.Corp, d.Parentid, d.Username, d.Passwd, d.Devmode, d.Alive))
|
}
|
}
|
return tx.Exec(buffer.String()).Error
|
}
|
|
func batchSaveGbChannel(tx *gorm.DB, arr []gb28181api.CameraInfo) error {
|
var buffer bytes.Buffer
|
sql := "insert into `" + gbModels.VssChannel{}.TableName() + "` (`publicId`,`devPubId`,`resType`,`name`,`alive`,`corp`,`model`,`owner`,`civilCode`,`address`,`parentId`,`ip`,`port`,`longitude`,`latitude`,`ptzType`,`streamType`,`realRtspUrl`) values "
|
if _, err := buffer.WriteString(sql); err != nil {
|
return err
|
}
|
for i, c := range arr {
|
if i == len(arr)-1 {
|
buffer.WriteString(fmt.Sprintf("('%s','%s',%d,'%s',%d,'%s','%s','%s','%s','%s','%s','%s',%d,%f,%f,%d,%d,'%s');", c.PublicID, c.DevPubID, c.ResType, c.Name, c.Alive, c.Corp, c.Model, c.Owner, c.CivilCode, c.Address, c.ParentID, c.IP, c.Port, c.Latitude, c.Latitude, c.PtzType, c.StreamType, c.RealRtspURL))
|
} else {
|
buffer.WriteString(fmt.Sprintf("('%s','%s',%d,'%s',%d,'%s','%s','%s','%s','%s','%s','%s',%d,%f,%f,%d,%d,'%s'),", c.PublicID, c.DevPubID, c.ResType, c.Name, c.Alive, c.Corp, c.Model, c.Owner, c.CivilCode, c.Address, c.ParentID, c.IP, c.Port, c.Latitude, c.Latitude, c.PtzType, c.StreamType, c.RealRtspURL))
|
}
|
}
|
return tx.Exec(buffer.String()).Error
|
}
|
|
func batchSaveGbDomainUnit(tx *gorm.DB, uArr []gb28181api.DomainUnit) error {
|
var buffer bytes.Buffer
|
sql := "insert into `" + gbModels.VssDomainUnit{}.TableName() + "` (`publicId`,`devPubId`,`resType`,`name`,`parentId`,`totalNum`,`onlineNum`) values "
|
if _, err := buffer.WriteString(sql); err != nil {
|
return err
|
}
|
for i, u := range uArr {
|
if i == len(uArr)-1 {
|
buffer.WriteString(fmt.Sprintf("('%s','%s',%d,'%s','%s',%d,%d);", u.PublicID, u.DevPubID, u.ResType, u.Name, u.ParentID, u.TotalNum, u.OnlineNum))
|
} else {
|
buffer.WriteString(fmt.Sprintf("('%s','%s',%d,'%s','%s',%d,%d),", u.PublicID, u.DevPubID, u.ResType, u.Name, u.ParentID, u.TotalNum, u.OnlineNum))
|
}
|
}
|
|
return tx.Exec(buffer.String()).Error
|
}
|
|
func GetPidsByRecursion(uIdMap *map[string]gbDevAndArea, parentId string, pIds *string) {
|
if unit, ok := (*uIdMap)[parentId]; ok {
|
*pIds = "," + parentId + "," + *pIds
|
GetPidsByRecursion(uIdMap, unit.ParentId, pIds)
|
} else {
|
*pIds = ",0," + *pIds
|
*pIds = strings.Replace(*pIds, ",,", ",", -1)
|
return
|
}
|
}
|
|
type GbTreeMenu struct {
|
Id string `json:"id"`
|
Name string `json:"name"`
|
Type string `json:"type"`
|
Children []GbTreeMenu `json:"children"`
|
Checked bool `json:"checked"` //是否选中
|
Alive int `json:"alive"` //是否存活,取决于国标库是否动态更新
|
civilCode string
|
parentId string
|
}
|
|
//获取当前国标的目录树结构
|
func (s Gb28181Service) GetGbCurrentTree() []GbTreeMenu {
|
menus := make([]GbTreeMenu, 0)
|
var gbConfig gbModels.Gb28181Config
|
if rows, _ := gbConfig.Select(); rows == 0 {
|
return menus
|
}
|
|
var vssDevices gbModels.VssDev
|
var vssDomainUnit gbModels.VssDomainUnit
|
var vssChannel gbModels.VssChannel
|
devices, _ := vssDevices.FindAll()
|
domainUnits, _ := vssDomainUnit.FindAll()
|
gbAllCamAndGroups, _ := vssChannel.FindAll()
|
|
channelsArry := make([]gbModels.VssChannel, 0)
|
groupArr := make([]gbModels.VssChannel, 0)
|
civilM := make(map[string]gbModels.VssChannel, 0)
|
for _, gcg := range gbAllCamAndGroups {
|
if gcg.ResType == 1 { //摄像机资源
|
channelsArry = append(channelsArry, gcg)
|
} else if gcg.ResType == 2 { //group资源
|
civilM[gcg.CivilCode] = gcg
|
civilM[gcg.PublicID] = gcg
|
groupArr = append(groupArr, gcg)
|
}
|
}
|
|
// 查询当前保存的摄像机, 添加已选择的标志
|
var camCursor models.Camera
|
selectedCams, _ := camCursor.FindCamerasByType(models.TYPE_GB28181_CAMERA, "")
|
logger.Debug("GetGbCurrentTree len(selectedCams):", len(selectedCams))
|
|
ncM := make(map[string]string, 0)
|
selectedCamsMap := make(map[string]models.Camera)
|
for _, gc := range selectedCams {
|
selectedCamsMap[gc.Id] = gc
|
ncM[gc.Id] = gc.Id
|
}
|
|
unitMap := make(map[string]gbModels.VssDomainUnit, 0)
|
for _, u := range domainUnits {
|
unitMap[u.PublicID] = u
|
}
|
|
movedM := make(map[string]string, 0)
|
for _, d := range devices {
|
mu := GbTreeMenu{
|
Id: d.PublicID,
|
Name: d.Name,
|
}
|
if mu.Name == "" {
|
mu.Name = mu.Id
|
}
|
if len(d.PublicID) > 13 && d.PublicID[10:13] == "132" { //表示这个设备是摄像机,并且不在下级平台下
|
mu.Type = "camera"
|
mu.Alive = d.Alive
|
if _, ok := selectedCamsMap[mu.Id]; ok {
|
mu.Checked = true
|
ncM[mu.Id] = mu.Id
|
}
|
movedM[mu.Id] = mu.Id
|
} else {
|
mu.Type = "menu"
|
|
logger.Debug("len(groupArr): ", len(groupArr))
|
rootChk := false
|
for _, tmpChan := range groupArr {
|
if tmpChan.ParentId == d.PublicID {
|
child := GbTreeMenu{
|
Id: tmpChan.PublicID,
|
Name: tmpChan.Name,
|
Type: "menu",
|
parentId: d.PublicID,
|
civilCode: tmpChan.CivilCode,
|
}
|
|
recurseGbMenu(d.PublicID, &child, &domainUnits, unitMap, civilM, &groupArr, &channelsArry, selectedCamsMap, movedM, ncM)
|
if _, chk := ncM[child.Id]; chk {
|
child.Checked = true
|
rootChk = true
|
}
|
mu.Children = append(mu.Children, child)
|
}
|
}
|
|
for _, tmpUnit := range domainUnits {
|
if tmpUnit.ParentID == d.PublicID || tmpUnit.ParentID == "" {
|
child := GbTreeMenu{
|
Id: tmpUnit.PublicID,
|
Name: tmpUnit.Name,
|
Type: "menu",
|
parentId: d.PublicID,
|
civilCode: tmpUnit.PublicID,
|
}
|
|
recurseGbMenu(d.PublicID, &child, &domainUnits, unitMap, civilM, &groupArr, &channelsArry, selectedCamsMap, movedM, ncM)
|
if _, chk := ncM[child.Id]; chk {
|
child.Checked = true
|
rootChk = true
|
}
|
mu.Children = append(mu.Children, child)
|
}
|
}
|
mu.Checked = rootChk
|
}
|
|
menus = append(menus, mu)
|
}
|
|
logger.Debug("len(movedM):", len(movedM), " len(channelsArry):", len(channelsArry))
|
invalidMenu := GbTreeMenu{
|
Id: "invalid",
|
Name: "无上级分组！！！",
|
Type: "menu",
|
parentId: "",
|
}
|
var ignoredPIds []string
|
invalidMenuMap := make(map[string][]GbTreeMenu, 0)
|
for _, c := range channelsArry {
|
if _, ok := movedM[c.PublicID]; !ok {
|
ignoredPIds = append(ignoredPIds, c.PublicID)
|
if cvArr, cvO := invalidMenuMap[c.CivilCode]; !cvO {
|
chk := false
|
if _, chk = ncM[c.PublicID]; chk {
|
chk = true
|
ncM[c.CivilCode] = c.CivilCode
|
}
|
invalidMenuMap[c.CivilCode] = append([]GbTreeMenu{}, GbTreeMenu{
|
Id: c.PublicID,
|
Name: c.Name,
|
Type: "camera",
|
parentId: invalidMenu.Id,
|
Alive: c.Alive,
|
Checked: chk,
|
})
|
} else {
|
chk := false
|
if _, chk = ncM[c.PublicID]; chk {
|
chk = true
|
ncM[c.CivilCode] = c.CivilCode
|
}
|
cvArr = append(cvArr, GbTreeMenu{
|
Id: c.PublicID,
|
Name: c.Name,
|
Type: "camera",
|
parentId: invalidMenu.Id,
|
Alive: c.Alive,
|
Checked: chk,
|
})
|
invalidMenuMap[c.CivilCode] = cvArr
|
}
|
|
movedM[c.PublicID] = c.PublicID
|
}
|
}
|
for k, v := range invalidMenuMap {
|
icName := k
|
if chd, cvIn := civilM[k]; cvIn {
|
icName = chd.Name
|
}
|
|
invalidChild := GbTreeMenu{
|
Id: k,
|
Name: icName,
|
Type: "menu",
|
Children: v,
|
parentId: "invalid",
|
}
|
if _, chk := ncM[invalidChild.Id]; chk {
|
invalidChild.Checked = true
|
invalidMenu.Checked = true
|
}
|
invalidMenu.Children = append(invalidMenu.Children, invalidChild)
|
}
|
|
if len(invalidMenu.Children) > 0 {
|
menus = append(menus, invalidMenu)
|
}
|
|
logger.Debug("len(ignoredIds):", len(ignoredPIds))
|
|
//logger.Debug("menus", menus)
|
|
return menus
|
}
|
|
//获取当前国标的所有摄像机资源信息, 平铺树
|
func (s Gb28181Service) GetGbCameras() []GbTreeMenu {
|
var vssChannel gbModels.VssChannel
|
gbAllCamAndGroups, _ := vssChannel.FindAll()
|
|
channelsArry := make([]GbTreeMenu, 0)
|
for _, gcg := range gbAllCamAndGroups {
|
if gcg.ResType == 1 { //摄像机资源
|
channelsArry = append(channelsArry, GbTreeMenu{
|
Id: gcg.PublicID,
|
Name: gcg.Name,
|
Type: "camera",
|
Children: nil,
|
Checked: false,
|
Alive: gcg.Alive,
|
civilCode: gcg.CivilCode,
|
parentId: gcg.ParentId,
|
})
|
}
|
}
|
|
return channelsArry
|
}
|
|
func recurseGbMenu(devPubId string, mu *GbTreeMenu, uArr *[]gbModels.VssDomainUnit, unitM map[string]gbModels.VssDomainUnit, civilM map[string]gbModels.VssChannel, groupArr *[]gbModels.VssChannel, cArr *[]gbModels.VssChannel, gbcM map[string]models.Camera, movedM map[string]string, ncm map[string]string) {
|
//递归处理所有下级资源组,以及资源组下的摄像机
|
for _, cGroup := range *groupArr {
|
if cGroup.ParentId == mu.Id || cGroup.ParentId == mu.civilCode {
|
child := GbTreeMenu{
|
Id: cGroup.PublicID,
|
Name: cGroup.Name,
|
Type: "menu",
|
civilCode: cGroup.ChanPubID,
|
parentId: mu.Id,
|
}
|
|
recurseGbMenu(devPubId, &child, uArr, unitM, civilM, groupArr, cArr, gbcM, movedM, ncm)
|
if _, chk := ncm[child.Id]; chk {
|
child.Checked = true
|
ncm[mu.Id] = mu.Id
|
}
|
mu.Children = append(mu.Children, child)
|
}
|
}
|
|
//递归处理所有下级行政区域,以及区域下的摄像机
|
for _, u := range *uArr {
|
if u.ParentID == mu.Id {
|
child := GbTreeMenu{
|
Id: u.PublicID,
|
Name: u.Name,
|
Type: "menu",
|
civilCode: u.PublicID,
|
parentId: mu.Id,
|
}
|
|
recurseGbMenu(devPubId, &child, uArr, unitM, civilM, groupArr, cArr, gbcM, movedM, ncm)
|
if _, chk := ncm[child.Id]; chk {
|
child.Checked = true
|
ncm[mu.Id] = mu.Id
|
}
|
mu.Children = append(mu.Children, child)
|
}
|
}
|
|
//有些摄像机是挂在当前这一级平台下的
|
parentChecked := false
|
for _, c := range *cArr {
|
if c.DevPubID == devPubId {
|
if _, ok := movedM[c.PublicID]; !ok { //未处理过此摄像机
|
if c.ParentId != "" {
|
_, in := unitM[c.ParentId]
|
_, inUnitCiv := unitM[c.CivilCode]
|
_, inCivil := civilM[c.CivilCode]
|
_, inChanPub := civilM[c.ParentId]
|
//如果目录树中没有此摄像机的parentId，并且civilCode表中也没有，则挂到平台根目录下
|
if !in && !inCivil && !inUnitCiv && !inChanPub {
|
cu := GbTreeMenu{
|
Id: c.PublicID,
|
Name: c.Name,
|
Type: "camera",
|
Alive: c.Alive,
|
}
|
if _, ok := gbcM[cu.Id]; ok {
|
cu.Checked = true
|
parentChecked = true
|
ncm[cu.Id] = cu.Id
|
}
|
|
mu.Children = append(mu.Children, cu)
|
|
movedM[c.PublicID] = c.PublicID
|
} else {
|
if c.ParentId == mu.Id || c.CivilCode == mu.Id || c.CivilCode == mu.civilCode {
|
cu := GbTreeMenu{
|
Id: c.PublicID,
|
Name: c.Name,
|
Type: "camera",
|
Alive: c.Alive,
|
}
|
if _, ok := gbcM[cu.Id]; ok {
|
cu.Checked = true
|
parentChecked = true
|
ncm[cu.Id] = cu.Id
|
}
|
mu.Children = append(mu.Children, cu)
|
|
movedM[c.PublicID] = c.PublicID
|
}
|
}
|
} else {
|
//摄像机的parentId为空，则挂到根目录下
|
cu := GbTreeMenu{
|
Id: c.PublicID,
|
Name: c.Name,
|
Type: "camera",
|
Alive: c.Alive,
|
}
|
if _, ok := gbcM[cu.Id]; ok {
|
cu.Checked = true
|
parentChecked = true
|
ncm[cu.Id] = cu.Id
|
}
|
|
mu.Children = append(mu.Children, cu)
|
|
movedM[c.PublicID] = c.PublicID
|
}
|
}
|
}
|
}
|
mu.Checked = parentChecked
|
if parentChecked {
|
ncm[mu.Id] = mu.Id
|
}
|
}
|
|
//刷新后保存国标摄像机的配置，（目前的需求是国标摄像机配置路数不能超过500路）
|
func (s Gb28181Service) SaveGb28181CamTree(reqBody []GbTreeMenu) (bool, error) {
|
logger.Debug("SaveGb28181CamTree reqBody:", reqBody)
|
//首先检查待配置的摄像机数量是否超过限制路数
|
totalCount := 0
|
recurseGbMenuCount(reqBody, &totalCount)
|
limit := config.Server.GbCamCount
|
if limit <= 0 {
|
limit = 500
|
}
|
if totalCount > limit {
|
return false, errors.New("国标摄像机数量最高不能超过:" + strconv.Itoa(limit) + "路")
|
}
|
var vd gbModels.VssDev
|
var du gbModels.VssDomainUnit
|
var vc gbModels.VssChannel
|
devices, _ := vd.FindAll()
|
uM := du.FindAllMap()
|
gbcM := vc.FindAllMap() //VSSChannelTbl表中可能保存有目录结构,resType=2
|
for _, d := range devices {
|
if len(d.PublicID) > 13 && d.PublicID[10:13] == "132" { //是个摄像机
|
logger.Debug("SaveGb28181CamTree d:", d)
|
} else { //是个平台
|
if _, ok := uM[d.PublicID]; !ok {
|
logger.Debug("SaveGb28181CamTree not contain d.id=>", d.PublicID, " d.name=>", d.Name)
|
uM[d.PublicID] = gbModels.VssDomainUnit{
|
DevPubID: d.PublicID,
|
PublicID: d.PublicID,
|
Name: d.Name,
|
}
|
}
|
}
|
}
|
var gbcModel models.Camera
|
gbCams, _ := gbcModel.FindCamerasByType(models.TYPE_GB28181_CAMERA, "")
|
logger.Debug("GetGbCurrentTree len(gbCams):", len(gbCams))
|
camCache := make(map[string]models.Camera, 0)
|
for _, gc := range gbCams {
|
camCache[gc.Id] = gc
|
}
|
//1.摄像机所属的目录吸入area表中
|
//2.摄像机写入camera表中
|
//3.建立camera和area的关联关系
|
var err error
|
tx := models.GetDB().Begin()
|
defer func() {
|
if err != nil && tx != nil {
|
tx.Rollback()
|
logger.Debug("saveGb28181CamTree err:", err)
|
}
|
}()
|
//清除旧的数据
|
err = tx.Exec("delete from " + models.Camera{}.TableName() + " where type=1").Error
|
if err != nil {
|
return false, err
|
}
|
err = tx.Exec("delete from " + models.Area{}.TableName() + " where type=1").Error
|
if err != nil {
|
return false, err
|
}
|
err = tx.Exec("delete from " + models.CameraArea{}.TableName() + " where cameraId not in (select id from cameras)").Error
|
if err != nil {
|
return false, err
|
}
|
|
//写入新的国标摄像机
|
uIdMap := make(map[string]gbDevAndArea, 0)
|
if err = recurseInsertGbCamOrUnit(tx, reqBody, uM, gbcM, uIdMap, "0", camCache); err != nil {
|
logger.Debug("recurseInsertGbCamOrUnit err:", err)
|
return false, err
|
}
|
|
tx.Commit()
|
logger.Debug("SaveGb28181CamTree end!")
|
s.AddDbChangeMsg(protomsg.DbAction_Update)
|
return true, nil
|
}
|
|
func (s Gb28181Service) GetGb28181VssTable() VssTable {
|
var vd gbModels.VssDev
|
var du gbModels.VssDomainUnit
|
var vc gbModels.VssChannel
|
devices, _ := vd.FindAll()
|
uM := du.FindAllMap()
|
gbcM := vc.FindAllMap()
|
var gbcModel models.Camera
|
gbCams, _ := gbcModel.FindCamerasByType(models.TYPE_GB28181_CAMERA, "")
|
var vssTable VssTable
|
vssTable.Vd = devices
|
vssTable.Du = uM
|
vssTable.Vc = gbcM
|
vssTable.GbCam = gbCams
|
return vssTable
|
}
|
|
func recurseInsertGbCamOrUnit(tx *gorm.DB, menus []GbTreeMenu, uM map[string]gbModels.VssDomainUnit, cM map[string]gbModels.VssChannel, uIdMap map[string]gbDevAndArea, parentId string, cc map[string]models.Camera) error {
|
for _, u := range menus {
|
if u.Type == "menu" {
|
uIdMap[u.Id] = gbDevAndArea{
|
PublicId: u.Id,
|
ParentId: parentId,
|
}
|
gbArea := models.Area{
|
Id: u.Id,
|
Name: u.Name,
|
Parentid: parentId,
|
Type: models.TYPE_GB28181_TREE,
|
}
|
if _, ok := uIdMap[parentId]; !ok {
|
gbArea.Parentid = "0"
|
}
|
//递归得到parentids
|
parentIds := ""
|
GetPidsByRecursion(&uIdMap, gbArea.Parentid, &parentIds)
|
gbArea.Parentids = parentIds
|
|
if u.Name == "" {
|
gbArea.Name = u.Id
|
}
|
var areaE models.Area
|
rows, _ := areaE.SelectbyId(gbArea.Id)
|
logger.Debug("recurseInsertGbCamOrUnit areaE.SelectById rows:", rows)
|
if rows > 0 {
|
gbArea.Alias = areaE.Alias
|
}
|
if err := tx.Table("area").Create(&gbArea).Error; err != nil {
|
return err
|
}
|
|
if err := recurseInsertGbCamOrUnit(tx, u.Children, uM, cM, uIdMap, u.Id, cc); err != nil {
|
logger.Debug("recurseInsertGbCamOrUnit err:", err)
|
return err
|
}
|
} else {
|
if gbCam, ok := cM[u.Id]; ok { //摄像机
|
cameraE := models.Camera{
|
Id: gbCam.PublicID,
|
Name: gbCam.Name,
|
Ip: gbCam.IP,
|
Port: gbCam.Port,
|
Rtsp: gbCam.RealRtspUrl,
|
|
Addr: gbCam.Name,
|
Alias: gbCam.Name, //别名默认取国标摄像机的名称
|
Longitude: float32(gbCam.Longitude),
|
Latitude: float32(gbCam.Latitude),
|
Type: models.TYPE_GB28181_CAMERA, //国标摄像机
|
Floor: models.Default_Layer,
|
}
|
if stc, sin := cc[cameraE.Id]; sin {
|
cameraE.RunType = stc.RunType //保留之前配置的运行状态
|
cameraE.RunServerId = stc.RunServerId
|
} else {
|
cameraE.RunType = models.TYPE_RUNTYPE_VIDEO
|
}
|
if err := tx.Table("cameras").Create(&cameraE).Error; err != nil {
|
return err
|
}
|
|
//关联摄像机和目录树
|
if err := tx.Table("camera_area").Create(&models.CameraArea{Cameraid: gbCam.PublicID, Areaid: parentId}).Error; err != nil {
|
return err
|
}
|
}
|
}
|
}
|
return nil
|
}
|
|
//递归获取国标树的摄像机数量
|
func recurseGbMenuCount(menus []GbTreeMenu, count *int) {
|
if menus != nil && len(menus) > 0 {
|
for _, u := range menus {
|
if u.Type == "camera" {
|
*count++
|
} else {
|
recurseGbMenuCount(u.Children, count)
|
}
|
}
|
}
|
}
|
|
//刷新国标树和设备
|
func (s Gb28181Service) RefreshById(id string) (bool, []GbTreeMenu) {
|
if b, _ := s.UpdateGb28181Data(); b {
|
data := s.GetGbCurrentTree()
|
return true, data
|
}
|
|
return false, []GbTreeMenu{}
|
}
|
|
//刷新国标树和设备
|
func (s Gb28181Service) RefreshAllChannel() (bool, []GbTreeMenu) {
|
if b, _ := s.UpdateGb28181Data(); b {
|
data := s.GetGbCameras()
|
return true, data
|
}
|
|
return false, []GbTreeMenu{}
|
}
|
|
//删除国标
|
func (s Gb28181Service) Delete() bool {
|
var err error
|
tx := models.GetDB().Begin()
|
defer func() {
|
if err != nil && tx != nil {
|
tx.Rollback()
|
}
|
}()
|
if err = tx.Exec("delete from area where type=1").Error; err != nil {
|
return false
|
}
|
if err = tx.Exec("delete from cameras where type=1").Error; err != nil {
|
return false
|
}
|
if err = tx.Exec("delete from camera_area where areaId in (select id from area where type=1)").Error; err != nil {
|
return false
|
}
|
tx.Commit()
|
s.AddDbChangeMsg(protomsg.DbAction_Update)
|
return false
|
}
|
|
//摄像机表有更新
|
func (s Gb28181Service) AddDbChangeMsg(action protomsg.DbAction) {
|
dbMsg := protomsg.DbChangeMessage{
|
Table: protomsg.TableChanged_T_Camera,
|
Action: action,
|
}
|
pb, _ := json.Marshal(dbMsg)
|
s.bk.Publish("gb28181-service", pb)
|
|
//cameraPolygon有更新
|
pMsg := protomsg.DbChangeMessage{
|
Table: protomsg.TableChanged_T_CameraPolygon,
|
Action: action,
|
}
|
ppm, _ := json.Marshal(pMsg)
|
s.bk.Publish("gb28181-service", ppm)
|
}
|
