modelRT/handler/async_task_status_update_handler.go

// Package handler provides HTTP handlers for various endpoints.
package handler

import (
	"net/http"

	"modelRT/database"
	"modelRT/logger"
	"modelRT/network"
	"modelRT/orm"

	"github.com/gin-gonic/gin"
)

// AsyncTaskStatusUpdateHandler handles updating task status (internal use, not exposed via API)
func AsyncTaskStatusUpdateHandler(c *gin.Context) {
	ctx := c.Request.Context()
	var request network.AsyncTaskStatusUpdate

	if err := c.ShouldBindJSON(&request); err != nil {
		logger.Error(ctx, "failed to unmarshal async task status update request", "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "invalid request parameters",
		})
		return
	}

	// Validate status
	validStatus := map[string]bool{
		string(orm.AsyncTaskStatusSubmitted): true,
		string(orm.AsyncTaskStatusRunning):   true,
		string(orm.AsyncTaskStatusCompleted): true,
		string(orm.AsyncTaskStatusFailed):    true,
	}

	if !validStatus[request.Status] {
		logger.Error(ctx, "invalid task status", "status", request.Status)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "invalid task status",
		})
		return
	}

	pgClient := database.GetPostgresDBClient()
	if pgClient == nil {
		logger.Error(ctx, "database connection not found in context")
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "database connection error",
		})
		return
	}

	// Update task status
	status := orm.AsyncTaskStatus(request.Status)
	err := database.UpdateAsyncTaskStatus(ctx, pgClient, request.TaskID, status)
	if err != nil {
		logger.Error(ctx, "failed to update async task status", "task_id", request.TaskID, "status", request.Status, "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "failed to update task status",
		})
		return
	}

	// If task is completed or failed, update finished_at timestamp
	if request.Status == string(orm.AsyncTaskStatusCompleted) {
		err = database.CompleteAsyncTask(ctx, pgClient, request.TaskID, request.Timestamp)
	} else if request.Status == string(orm.AsyncTaskStatusFailed) {
		err = database.FailAsyncTask(ctx, pgClient, request.TaskID, request.Timestamp)
	}

	if err != nil {
		logger.Error(ctx, "failed to update async task completion timestamp", "task_id", request.TaskID, "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "failed to update task completion timestamp",
		})
		return
	}

	c.JSON(http.StatusOK, network.SuccessResponse{
		Code:    2000,
		Msg:     "task status updated successfully",
		Payload: nil,
	})
}