geo/server/internal/tenant/transport/desktop_monitoring_handler.go

package transport

import (
	"errors"
	"io"
	"strconv"

	"github.com/gin-gonic/gin"

	"github.com/geo-platform/tenant-api/internal/bootstrap"
	"github.com/geo-platform/tenant-api/internal/shared/response"
	"github.com/geo-platform/tenant-api/internal/tenant/app"
)

type DesktopMonitoringHandler struct {
	svc *app.MonitoringCallbackService
}

func NewDesktopMonitoringHandler(a *bootstrap.App) *DesktopMonitoringHandler {
	return &DesktopMonitoringHandler{
		svc: app.NewMonitoringCallbackService(a.DB, a.MonitoringDB, a.RabbitMQ, a.LLM, a.Logger),
	}
}

func (h *DesktopMonitoringHandler) Lease(c *gin.Context) {
	var req app.MonitoringLeaseTasksRequest
	if err := c.ShouldBindJSON(&req); err != nil && !errors.Is(err, io.EOF) {
		response.Error(c, response.ErrBadRequest(40041, "invalid_monitoring_lease_request", err.Error()))
		return
	}

	data, err := h.svc.LeaseTasksForDesktopClient(c.Request.Context(), MustDesktopClient(c.Request.Context()), req)
	if err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, data)
}

func (h *DesktopMonitoringHandler) Resume(c *gin.Context) {
	var req app.MonitoringResumeTasksRequest
	if err := c.ShouldBindJSON(&req); err != nil && !errors.Is(err, io.EOF) {
		response.Error(c, response.ErrBadRequest(40041, "invalid_monitoring_resume_request", err.Error()))
		return
	}

	data, err := h.svc.ResumeTasksForDesktopClient(c.Request.Context(), MustDesktopClient(c.Request.Context()), req)
	if err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, data)
}

func (h *DesktopMonitoringHandler) Result(c *gin.Context) {
	taskID, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		response.Error(c, response.ErrBadRequest(40041, "invalid_monitoring_task_id", "monitoring task id must be an integer"))
		return
	}

	var req app.MonitoringTaskResultRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, response.ErrBadRequest(40041, "invalid_monitoring_result_request", err.Error()))
		return
	}

	data, svcErr := h.svc.HandleTaskResultForDesktopClient(c.Request.Context(), MustDesktopClient(c.Request.Context()), taskID, req)
	if svcErr != nil {
		response.Error(c, svcErr)
		return
	}
	response.Success(c, data)
}

func (h *DesktopMonitoringHandler) Skip(c *gin.Context) {
	taskID, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		response.Error(c, response.ErrBadRequest(40041, "invalid_monitoring_task_id", "monitoring task id must be an integer"))
		return
	}

	var req app.MonitoringSkipTaskRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, response.ErrBadRequest(40041, "invalid_monitoring_skip_request", err.Error()))
		return
	}

	data, svcErr := h.svc.SkipTaskForDesktopClient(c.Request.Context(), MustDesktopClient(c.Request.Context()), taskID, req)
	if svcErr != nil {
		response.Error(c, svcErr)
		return
	}
	response.Success(c, data)
}

func (h *DesktopMonitoringHandler) Cancel(c *gin.Context) {
	taskID, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		response.Error(c, response.ErrBadRequest(40041, "invalid_monitoring_task_id", "monitoring task id must be an integer"))
		return
	}

	var req app.MonitoringCancelTaskRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, response.ErrBadRequest(40041, "invalid_monitoring_cancel_request", err.Error()))
		return
	}

	data, svcErr := h.svc.CancelTaskForDesktopClient(c.Request.Context(), MustDesktopClient(c.Request.Context()), taskID, req)
	if svcErr != nil {
		response.Error(c, svcErr)
		return
	}
	response.Success(c, data)
}