Skip to content

The only tool you need to know what is happening and how to fix it.

5.2 KB
Raw Blame
package controllers

import (
	"github.com/tracewayapp/traceway/backend/app/middleware"
	"github.com/tracewayapp/traceway/backend/app/models"
	"github.com/tracewayapp/traceway/backend/app/repositories/telemetry"
	"net/http"
	"net/url"
	"time"

	"github.com/gin-gonic/gin"
	traceway "go.tracewayapp.com"
)

type taskController struct{}

type TaskSearchRequest struct {
	FromDate      time.Time        `json:"fromDate"`
	ToDate        time.Time        `json:"toDate"`
	OrderBy       string           `json:"orderBy"`
	SortDirection string           `json:"sortDirection"`
	Pagination    PaginationParams `json:"pagination"`
	Search        string           `json:"search"`
	RootFilter    string           `json:"rootFilter"`
}

type TaskInstancesRequest struct {
	FromDate      time.Time        `json:"fromDate"`
	ToDate        time.Time        `json:"toDate"`
	OrderBy       string           `json:"orderBy"`
	SortDirection string           `json:"sortDirection"`
	Pagination    PaginationParams `json:"pagination"`
}

type TaskInstancesResponse struct {
	Data       []models.Task           `json:"data"`
	Stats      *models.TaskDetailStats `json:"stats"`
	Pagination Pagination              `json:"pagination"`
}

func (e taskController) FindAllTasks(c *gin.Context) {
	projectId, err := middleware.GetProjectId(c)
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
		return
	}

	var request TaskSearchRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		middleware.RejectBindError(c, err, err.Error())
		return
	}

	span := traceway.StartSpan(c, "loading tasks")
	tasks, total, err := telemetry.TaskRepository.FindAll(c, projectId, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy)
	span.End()
	if err != nil {
		c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading tasks: %w", err))
		return
	}

	c.JSON(http.StatusOK, PaginatedResponse[models.Task]{
		Data: tasks,
		Pagination: Pagination{
			Page:       request.Pagination.Page,
			PageSize:   request.Pagination.PageSize,
			Total:      total,
			TotalPages: (total + int64(request.Pagination.PageSize) - 1) / int64(request.Pagination.PageSize),
		},
	})
}

func (e taskController) FindGroupedByTaskName(c *gin.Context) {
	projectId, err := middleware.GetProjectId(c)
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
		return
	}

	var request TaskSearchRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		middleware.RejectBindError(c, err, err.Error())
		return
	}

	span := traceway.StartSpan(c, "loading grouped tasks")
	stats, total, err := telemetry.TaskRepository.FindGroupedByTaskName(c, projectId, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy, request.SortDirection, request.Search, request.RootFilter)
	span.End()
	if err != nil {
		c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading stats by name: %w", err))
		return
	}

	c.JSON(http.StatusOK, PaginatedResponse[models.TaskStats]{
		Data: stats,
		Pagination: Pagination{
			Page:       request.Pagination.Page,
			PageSize:   request.Pagination.PageSize,
			Total:      total,
			TotalPages: (total + int64(request.Pagination.PageSize) - 1) / int64(request.Pagination.PageSize),
		},
	})
}

func (e taskController) FindByTaskName(c *gin.Context) {
	projectId, err := middleware.GetProjectId(c)
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
		return
	}

	rawTaskName := c.Query("task")
	if rawTaskName == "" {
		c.JSON(http.StatusBadRequest, gin.H{"error": "task is required"})
		return
	}

	// URL decode the task name
	taskName, err := url.PathUnescape(rawTaskName)
	if err != nil {
		taskName = rawTaskName // fallback to raw value if decoding fails
	}

	var request TaskInstancesRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		middleware.RejectBindError(c, err, err.Error())
		return
	}

	span := traceway.StartSpan(c, "loading task instances")
	tasks, total, err := telemetry.TaskRepository.FindByTaskName(c, projectId, taskName, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy, request.SortDirection)
	span.End()
	if err != nil {
		c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading tasks by name: %w", err))
		return
	}

	// Get aggregate stats for this task
	span = traceway.StartSpan(c, "loading task stats")
	stats, err := telemetry.TaskRepository.GetTaskStats(c, projectId, taskName, request.FromDate, request.ToDate)
	span.End()
	if err != nil {
		// Don't fail the request if stats fail, just return nil stats
		stats = nil
	}

	c.JSON(http.StatusOK, TaskInstancesResponse{
		Data:  tasks,
		Stats: stats,
		Pagination: Pagination{
			Page:       request.Pagination.Page,
			PageSize:   request.Pagination.PageSize,
			Total:      total,
			TotalPages: (total + int64(request.Pagination.PageSize) - 1) / int64(request.Pagination.PageSize),
		},
	})
}

var TaskController = taskController{}