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

package transport

import (
	"errors"
	"io"
	"strconv"
	"strings"

	"github.com/gin-gonic/gin"
	"github.com/google/uuid"

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

type DesktopTaskHandler struct {
	svc        *app.DesktopTaskService
	publishSvc *app.PublishJobService
}

func NewDesktopTaskHandler(a *bootstrap.App) *DesktopTaskHandler {
	return &DesktopTaskHandler{
		svc: app.NewDesktopTaskServiceWithConfig(
			a.DB,
			a.MonitoringDB,
			a.RabbitMQ,
			a.Logger,
			a.ConfigStore,
		).WithCache(a.Cache).WithRedis(a.Redis),
		publishSvc: app.NewPublishJobServiceWithConfig(
			a.DB,
			a.RabbitMQ,
			a.Redis,
			a.Logger,
			a.ConfigStore,
		).WithCache(a.Cache),
	}
}

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

	var routeTaskID *uuid.UUID
	if rawID := c.Param("id"); rawID != "" {
		parsed, err := uuid.Parse(rawID)
		if err != nil {
			response.Error(c, response.ErrBadRequest(40084, "invalid_desktop_task_id", "task id must be a uuid"))
			return
		}
		routeTaskID = &parsed
	}

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

func (h *DesktopTaskHandler) ListPublish(c *gin.Context) {
	req, ok := parseListPublishTasksRequest(c)
	if !ok {
		return
	}
	data, err := h.svc.ListPublishTasks(c.Request.Context(), MustDesktopClient(c.Request.Context()), req)
	if err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, data)
}

func (h *DesktopTaskHandler) TenantListPublish(c *gin.Context) {
	req, ok := parseListPublishTasksRequest(c)
	if !ok {
		return
	}
	data, err := h.svc.ListTenantPublishTasks(c.Request.Context(), auth.MustActor(c.Request.Context()), req)
	if err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, data)
}

func (h *DesktopTaskHandler) Extend(c *gin.Context) {
	desktopID, err := uuid.Parse(c.Param("id"))
	if err != nil {
		response.Error(c, response.ErrBadRequest(40084, "invalid_desktop_task_id", "task id must be a uuid"))
		return
	}

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

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

func (h *DesktopTaskHandler) MarkPublishSubmitStarted(c *gin.Context) {
	taskID, err := uuid.Parse(c.Param("id"))
	if err != nil {
		response.Error(c, response.ErrBadRequest(40084, "invalid_desktop_task_id", "task id must be a uuid"))
		return
	}

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

	if err := h.svc.MarkPublishSubmitStarted(c.Request.Context(), MustDesktopClient(c.Request.Context()), taskID, req.LeaseToken); err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, gin.H{"ok": true})
}

func (h *DesktopTaskHandler) Result(c *gin.Context) {
	desktopID, err := uuid.Parse(c.Param("id"))
	if err != nil {
		response.Error(c, response.ErrBadRequest(40084, "invalid_desktop_task_id", "task id must be a uuid"))
		return
	}

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

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

func (h *DesktopTaskHandler) RetryPublish(c *gin.Context) {
	desktopID, err := uuid.Parse(c.Param("id"))
	if err != nil {
		response.Error(c, response.ErrBadRequest(40084, "invalid_desktop_task_id", "task id must be a uuid"))
		return
	}

	data, err := h.publishSvc.RetryByDesktopTask(c.Request.Context(), MustDesktopClient(c.Request.Context()), desktopID)
	if err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, data)
}

func (h *DesktopTaskHandler) TenantRetryPublish(c *gin.Context) {
	desktopID, err := uuid.Parse(c.Param("id"))
	if err != nil {
		response.Error(c, response.ErrBadRequest(40084, "invalid_desktop_task_id", "task id must be a uuid"))
		return
	}

	data, err := h.publishSvc.RetryTenantDesktopTask(c.Request.Context(), auth.MustActor(c.Request.Context()), desktopID)
	if err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, data)
}

func (h *DesktopTaskHandler) Cancel(c *gin.Context) {
	desktopID, err := uuid.Parse(c.Param("id"))
	if err != nil {
		response.Error(c, response.ErrBadRequest(40084, "invalid_desktop_task_id", "task id must be a uuid"))
		return
	}

	var req app.CancelDesktopTaskRequest
	if err := c.ShouldBindJSON(&req); err != nil && !errors.Is(err, io.EOF) {
		response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
		return
	}

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

func parseListPublishTasksRequest(c *gin.Context) (app.ListPublishTasksRequest, bool) {
	req := app.ListPublishTasksRequest{
		Page:     1,
		PageSize: 10,
		Title:    strings.TrimSpace(c.Query("title")),
	}

	if rawPage := c.Query("page"); rawPage != "" {
		parsed, err := strconv.Atoi(rawPage)
		if err != nil || parsed <= 0 {
			response.Error(c, response.ErrBadRequest(40001, "invalid_params", "page must be a positive integer"))
			return req, false
		}
		req.Page = parsed
	}

	rawPageSize := c.Query("page_size")
	if rawPageSize == "" {
		rawPageSize = c.Query("limit")
	}
	if rawPageSize != "" {
		parsed, err := strconv.Atoi(rawPageSize)
		if err != nil || parsed <= 0 {
			response.Error(c, response.ErrBadRequest(40001, "invalid_params", "page_size must be a positive integer"))
			return req, false
		}
		req.PageSize = parsed
	}

	return req, true
}

func (h *DesktopTaskHandler) TenantCancel(c *gin.Context) {
	desktopID, err := uuid.Parse(c.Param("id"))
	if err != nil {
		response.Error(c, response.ErrBadRequest(40084, "invalid_desktop_task_id", "task id must be a uuid"))
		return
	}

	var req app.CancelDesktopTaskRequest
	if err := c.ShouldBindJSON(&req); err != nil && !errors.Is(err, io.EOF) {
		response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
		return
	}

	data, err := h.svc.TenantCancel(c.Request.Context(), auth.MustActor(c.Request.Context()), desktopID, req)
	if err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, data)
}

func (h *DesktopTaskHandler) Reconcile(c *gin.Context) {
	desktopID, err := uuid.Parse(c.Param("id"))
	if err != nil {
		response.Error(c, response.ErrBadRequest(40084, "invalid_desktop_task_id", "task id must be a uuid"))
		return
	}

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

	data, err := h.svc.Reconcile(c.Request.Context(), auth.MustActor(c.Request.Context()), desktopID, req)
	if err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, data)
}