intelligent_monitoring_backend/Code/backend/internal/api/camera.go

package api

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"go_backend/internal/dbs"
	"go_backend/internal/model"
	"gorm.io/gorm"
	"strconv"
)

type CameraVO struct {
	ID               int32       `json:"id"`
	CameraID         string      `json:"camera_id"`
	DisplayName      string      `json:"display_name"`
	ParentCategoryID []int       `json:"parent_category_id"`
	ViewPriority     int32       `json:"view_priority"`
	Status           string      `json:"status"`
	Type             string      `json:"type"`
	IPAddress        string      `json:"ip_address"`
	IsDeleted        bool        `json:"is_deleted"`
	CreateTime       string      `json:"create_time"`
	DeletedTime      string      `json:"deleted_time"`
	UpdateTime       string      `json:"update_time"`
	ChildVO          []*CameraVO `json:"child"`
}

func GetAllCamerasIncludeFolder(router *gin.RouterGroup) {
	router.GET("/camerasList", func(c *gin.Context) {
		db := dbs.GetGormDB()
		cameraVOList, _ := getCameraListMethod(false, db)
		Success(c, cameraVOList)
	})
}

func GetAllCameras(router *gin.RouterGroup) {
	router.GET("/camerasOnly", func(c *gin.Context) {
		db := dbs.GetGormDB()
		_, cameraList := getCameraListMethod(true, db)
		cameraVOList := make([]*CameraVO, 0)
		for _, camera := range cameraList {
			// 查看缓存Map中有无对应address，有的话直接读取
			var address string
			cameraId, _ := strconv.Atoi(camera.CameraID)
			if _, exists := Camera2AddressMap[cameraId]; exists {
				address = Camera2AddressMap[cameraId]
			} else {
				address = mergeAddress(*camera, db)
				Camera2AddressMap[cameraId] = address
			}
			vo := transVO(*camera)
			vo.DisplayName = address
			cameraVOList = append(cameraVOList, &vo)
		}
		Success(c, cameraVOList)
	})
}

func getCameraListMethod(isCameraOnly bool, db *gorm.DB) ([]*CameraVO, []*model.Camera) {
	cameras := make([]model.Camera, 0)
	db.Find(&cameras)

	cameraMap := make(map[int][]model.Camera)

	for _, camera := range cameras {
		cameraMap[int(camera.ViewPriority)] = append(cameraMap[(int(camera.ViewPriority))], camera)
	}

	cameraList := make([]*model.Camera, 0)
	cameraVOList := make([]*CameraVO, 0)
	level := 0

	cameraRecord := make(map[int]*CameraVO)

	for priority, cameraArray := range cameraMap {
		if priority == 0 {
			for _, camera := range cameraArray {
				vo := transVO(camera)
				if isCameraOnly {
					if camera.Type == "camera" {
						cameraList = append(cameraList, &camera)
					}
				} else {
					cameraVOList = append(cameraVOList, &vo)
				}
				cameraRecord[int(camera.ID)] = &vo
			}
			level += 1
			continue
		}

		if priority == level {
			tempRecord := make(map[int]*CameraVO)

			for _, camera := range cameraArray {
				vo := transVO(camera)
				parentId := vo.ParentCategoryID[len(vo.ParentCategoryID)-1]
				if pointer, exists := cameraRecord[parentId]; exists {
					if isCameraOnly {
						if camera.Type == "camera" {
							cameraList = append(cameraList, &camera)
						}
					}
					pointer.ChildVO = append(pointer.ChildVO, &vo)
					newParent := make([]int, 0)
					for _, id := range pointer.ParentCategoryID {
						newParent = append(newParent, id)
					}
					newParent = append(newParent, parentId)
					vo.ParentCategoryID = newParent
					tempRecord[int(vo.ID)] = &vo
				}
			}
			cameraRecord = tempRecord
			level += 1
		}
	}
	return cameraVOList, cameraList
}

type Node struct {
	ParentID    int    `json:"parent_id"`
	DisplayName string `json:"display_name"`
	Ip          string `json:"ip"`
}

func CreateNode(router *gin.RouterGroup) {
	router.POST("/camera/addNode", func(c *gin.Context) {
		var req Node
		err := c.ShouldBindJSON(&req)
		if err != nil {
			fmt.Println("ctx.ShouldBindJSON err: ", err)
			c.JSON(400, gin.H{"error": err.Error()})
			return
		}
		newNode := model.Camera{
			ParentCategoryID: int32(req.ParentID),
			DisplayName:      req.DisplayName,
			IPAddress:        req.Ip,
		}
		db := dbs.GetGormDB()
		db.Create(&newNode)
		Success(c, "success")
	})
}

type ModifyNodeData struct {
	Id          int    `json:"id"`
	DisplayName string `json:"display_name"`
	Ip          string `json:"ip"`
}

func ModifyNode(router *gin.RouterGroup) {
	router.POST("/camera/modify", func(c *gin.Context) {
		var req ModifyNodeData
		err := c.ShouldBindJSON(&req)
		if err != nil {
			fmt.Println("ctx.ShouldBindJSON err: ", err)
			c.JSON(400, gin.H{"error": err.Error()})
			return
		}
		node := model.Camera{
			ID:        int32(req.Id),
			IPAddress: req.Ip,
		}
		if req.DisplayName != "" {
			node.DisplayName = req.DisplayName
		}
		db := dbs.GetGormDB()
		result := db.Updates(&node)

		Success(c, result)
	})
}

func transVO(camera model.Camera) CameraVO {
	vo := CameraVO{
		ID:               camera.ID,
		CameraID:         camera.CameraID,
		DisplayName:      camera.DisplayName,
		ParentCategoryID: make([]int, 1),
		ViewPriority:     camera.ViewPriority,
		Status:           camera.Status,
		Type:             camera.Type,
		IPAddress:        camera.IPAddress,
		IsDeleted:        camera.IsDeleted,
		CreateTime:       camera.CreateTime,
		DeletedTime:      camera.DeletedTime,
		UpdateTime:       camera.UpdateTime,
		ChildVO:          make([]*CameraVO, 0),
	}
	vo.ParentCategoryID[0] = int(camera.ParentCategoryID)
	return vo
}