yovision/Sense/server/app/sense/device/apis/device.go

package apis

import (
	"encoding/json"
	"errors"
	"io"
	"net/http"
	"strings"

	"github.com/gin-gonic/gin"
	"github.com/go-admin-team/go-admin-core/sdk/api"
	"github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth/user"

	"git.ilapage.cn/ila/yovision/Sense/server/app/sense/credential"
	deviceService "git.ilapage.cn/ila/yovision/Sense/server/app/sense/device/service"
	"git.ilapage.cn/ila/yovision/Sense/server/app/sense/device/service/dto"
	"git.ilapage.cn/ila/yovision/Sense/server/app/sense/quota"
)

type Device struct{ api.Api }

func (e Device) GetPage(c *gin.Context) {
	service := deviceService.Device{}
	req := dto.PageReq{}
	if err := e.MakeContext(c).MakeOrm().Bind(&req).MakeService(&service.Service).Errors; err != nil {
		e.Error(http.StatusBadRequest, err, "查询条件格式不正确")
		return
	}
	list := make([]dto.DeviceResponse, 0)
	var count int64
	if err := service.GetPage(&req, &list, &count); err != nil {
		e.Error(http.StatusInternalServerError, err, "设备列表查询失败")
		return
	}
	e.PageOK(list, int(count), req.GetPageIndex(), req.GetPageSize(), "查询成功")
}

func (e Device) Get(c *gin.Context) {
	service := deviceService.Device{}
	if err := e.MakeContext(c).MakeOrm().MakeService(&service.Service).Errors; err != nil {
		e.Error(http.StatusInternalServerError, err, "服务初始化失败")
		return
	}
	var response dto.DeviceResponse
	if err := service.Get(c.Param("id"), &response); err != nil {
		e.writeServiceError(err)
		return
	}
	e.OK(response, "查询成功")
}

func (e Device) Insert(c *gin.Context) {
	service := deviceService.Device{}
	if err := e.MakeContext(c).MakeOrm().MakeService(&service.Service).Errors; err != nil {
		e.Error(http.StatusInternalServerError, err, "服务初始化失败")
		return
	}
	req := dto.CreateReq{}
	if err := bindStrictJSON(c, &req); err != nil {
		e.Error(http.StatusBadRequest, err, "请求内容格式不正确")
		return
	}
	req.CreateBy = user.GetUserId(c)
	var response dto.DeviceResponse
	if err := service.Insert(&req, &response); err != nil {
		e.writeServiceError(err)
		return
	}
	e.OK(response, "设备创建成功")
}

func (e Device) Update(c *gin.Context) {
	service := deviceService.Device{}
	if err := e.MakeContext(c).MakeOrm().MakeService(&service.Service).Errors; err != nil {
		e.Error(http.StatusInternalServerError, err, "服务初始化失败")
		return
	}
	req := dto.UpdateReq{ID: c.Param("id"), UpdateBy: user.GetUserId(c)}
	if err := bindStrictJSON(c, &req); err != nil {
		e.Error(http.StatusBadRequest, err, "请求内容格式不正确")
		return
	}
	var response dto.DeviceResponse
	if err := service.Update(&req, &response); err != nil {
		e.writeServiceError(err)
		return
	}
	e.OK(response, "设备更新成功")
}

func (e Device) Disable(c *gin.Context) {
	service := deviceService.Device{}
	if err := e.MakeContext(c).MakeOrm().MakeService(&service.Service).Errors; err != nil {
		e.Error(http.StatusInternalServerError, err, "服务初始化失败")
		return
	}
	req := dto.DisableReq{ID: c.Param("id"), UpdateBy: user.GetUserId(c)}
	if err := bindStrictJSON(c, &req); err != nil {
		e.Error(http.StatusBadRequest, err, "请求内容格式不正确")
		return
	}
	var response dto.DeviceResponse
	if err := service.Disable(&req, &response); err != nil {
		e.writeServiceError(err)
		return
	}
	e.OK(response, "设备已停用")
}

func (e Device) Enable(c *gin.Context) {
	service := deviceService.Device{}
	if err := e.MakeContext(c).MakeOrm().MakeService(&service.Service).Errors; err != nil {
		e.Error(http.StatusInternalServerError, err, "服务初始化失败")
		return
	}
	req := dto.EnableReq{ID: c.Param("id"), UpdateBy: user.GetUserId(c)}
	if err := bindStrictJSON(c, &req); err != nil {
		e.Error(http.StatusBadRequest, err, "请求内容格式不正确")
		return
	}
	var response dto.DeviceResponse
	if err := service.Enable(&req, &response); err != nil {
		e.writeServiceError(err)
		return
	}
	e.OK(response, "设备已启用，请重新完成视频接入验证")
}

func (e Device) UpdateCredentials(c *gin.Context) {
	service := deviceService.Device{}
	if err := e.MakeContext(c).MakeOrm().MakeService(&service.Service).Errors; err != nil {
		e.Error(http.StatusInternalServerError, err, "服务初始化失败")
		return
	}
	req := dto.CredentialUpdateReq{ID: c.Param("id"), UpdateBy: user.GetUserId(c)}
	if err := bindStrictJSON(c, &req); err != nil {
		e.Error(http.StatusBadRequest, err, "请求内容格式不正确")
		return
	}
	var response dto.DeviceResponse
	if err := service.UpdateCredentials(&req, &response); err != nil {
		e.writeServiceError(err)
		return
	}
	e.OK(response, "凭据已安全更新，已请求重新验证")
}

func (e Device) writeServiceError(err error) {
	switch {
	case errors.Is(err, deviceService.ErrInvalidDevice):
		e.Error(http.StatusBadRequest, err, "设备信息不符合要求")
	case errors.Is(err, deviceService.ErrDeviceNotFound):
		e.Error(http.StatusNotFound, err, err.Error())
	case errors.Is(err, deviceService.ErrVersionConflict):
		e.Error(http.StatusConflict, err, err.Error())
	case errors.Is(err, quota.ErrExceeded):
		e.Error(http.StatusConflict, err, "当前配额已满，无法新增或启用设备")
	case errors.Is(err, quota.ErrUnavailable):
		e.Error(http.StatusServiceUnavailable, err, "配额配置不可读取，已拒绝新增或启用设备")
	case errors.Is(err, credential.ErrKeyUnavailable):
		e.Error(http.StatusServiceUnavailable, err, "摄像头凭据安全配置不可用")
	default:
		e.Error(http.StatusInternalServerError, err, "设备操作失败")
	}
}

func bindStrictJSON(c *gin.Context, target any) error {
	if !strings.HasPrefix(strings.ToLower(strings.TrimSpace(c.GetHeader("Content-Type"))), "application/json") {
		return errors.New("content type must be application/json")
	}
	decoder := json.NewDecoder(http.MaxBytesReader(c.Writer, c.Request.Body, 64<<10))
	decoder.DisallowUnknownFields()
	if err := decoder.Decode(target); err != nil {
		return err
	}
	if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
		if err == nil {
			return errors.New("request body must contain one JSON object")
		}
		return err
	}
	return nil
}