breakpilot-pwa/consent-service/internal/handlers/deadline_handlers.go

package handlers

import (
	"net/http"

	"github.com/breakpilot/consent-service/internal/middleware"
	"github.com/breakpilot/consent-service/internal/services"
	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
)

// DeadlineHandler handles deadline-related requests
type DeadlineHandler struct {
	deadlineService *services.DeadlineService
}

// NewDeadlineHandler creates a new deadline handler
func NewDeadlineHandler(deadlineService *services.DeadlineService) *DeadlineHandler {
	return &DeadlineHandler{
		deadlineService: deadlineService,
	}
}

// GetPendingDeadlines returns all pending consent deadlines for the current user
func (h *DeadlineHandler) GetPendingDeadlines(c *gin.Context) {
	userID, err := middleware.GetUserID(c)
	if err != nil || userID == uuid.Nil {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid user"})
		return
	}

	deadlines, err := h.deadlineService.GetPendingDeadlines(c.Request.Context(), userID)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch deadlines"})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"deadlines": deadlines,
		"count":     len(deadlines),
	})
}

// GetSuspensionStatus returns the current suspension status for a user
func (h *DeadlineHandler) GetSuspensionStatus(c *gin.Context) {
	userID, err := middleware.GetUserID(c)
	if err != nil || userID == uuid.Nil {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid user"})
		return
	}

	suspended, err := h.deadlineService.IsUserSuspended(c.Request.Context(), userID)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to check suspension status"})
		return
	}

	response := gin.H{
		"suspended": suspended,
	}

	if suspended {
		suspension, err := h.deadlineService.GetAccountSuspension(c.Request.Context(), userID)
		if err == nil && suspension != nil {
			response["reason"] = suspension.Reason
			response["suspended_at"] = suspension.SuspendedAt
			response["details"] = suspension.Details
		}

		deadlines, err := h.deadlineService.GetPendingDeadlines(c.Request.Context(), userID)
		if err == nil {
			response["pending_deadlines"] = deadlines
		}
	}

	c.JSON(http.StatusOK, response)
}

// TriggerDeadlineProcessing manually triggers deadline processing (admin only)
func (h *DeadlineHandler) TriggerDeadlineProcessing(c *gin.Context) {
	if !middleware.IsAdmin(c) {
		c.JSON(http.StatusForbidden, gin.H{"error": "Admin access required"})
		return
	}

	if err := h.deadlineService.ProcessDailyDeadlines(c.Request.Context()); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to process deadlines"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Deadline processing completed"})
}