start working on the frontend side

backend/internal/monitoring/handler.go

@@ -0,0 +1,184 @@
+package monitoring
+
+import (
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/atlasos/calypso/internal/common/database"
+	"github.com/atlasos/calypso/internal/common/logger"
+	"github.com/atlasos/calypso/internal/iam"
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+)
+
+// Handler handles monitoring API requests
+type Handler struct {
+	alertService  *AlertService
+	metricsService *MetricsService
+	eventHub     *EventHub
+	db           *database.DB
+	logger       *logger.Logger
+}
+
+// NewHandler creates a new monitoring handler
+func NewHandler(db *database.DB, log *logger.Logger, alertService *AlertService, metricsService *MetricsService, eventHub *EventHub) *Handler {
+	return &Handler{
+		alertService:   alertService,
+		metricsService: metricsService,
+		eventHub:       eventHub,
+		db:             db,
+		logger:         log,
+	}
+}
+
+// ListAlerts lists alerts with optional filters
+func (h *Handler) ListAlerts(c *gin.Context) {
+	filters := &AlertFilters{}
+
+	// Parse query parameters
+	if severity := c.Query("severity"); severity != "" {
+		filters.Severity = AlertSeverity(severity)
+	}
+	if source := c.Query("source"); source != "" {
+		filters.Source = AlertSource(source)
+	}
+	if acknowledged := c.Query("acknowledged"); acknowledged != "" {
+		ack, err := strconv.ParseBool(acknowledged)
+		if err == nil {
+			filters.IsAcknowledged = &ack
+		}
+	}
+	if resourceType := c.Query("resource_type"); resourceType != "" {
+		filters.ResourceType = resourceType
+	}
+	if resourceID := c.Query("resource_id"); resourceID != "" {
+		filters.ResourceID = resourceID
+	}
+	if limitStr := c.Query("limit"); limitStr != "" {
+		if limit, err := strconv.Atoi(limitStr); err == nil && limit > 0 {
+			filters.Limit = limit
+		}
+	}
+
+	alerts, err := h.alertService.ListAlerts(c.Request.Context(), filters)
+	if err != nil {
+		h.logger.Error("Failed to list alerts", "error", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list alerts"})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"alerts": alerts})
+}
+
+// GetAlert retrieves a single alert
+func (h *Handler) GetAlert(c *gin.Context) {
+	alertID := c.Param("id")
+
+	alert, err := h.alertService.GetAlert(c.Request.Context(), alertID)
+	if err != nil {
+		h.logger.Error("Failed to get alert", "alert_id", alertID, "error", err)
+		c.JSON(http.StatusNotFound, gin.H{"error": "alert not found"})
+		return
+	}
+
+	c.JSON(http.StatusOK, alert)
+}
+
+// AcknowledgeAlert acknowledges an alert
+func (h *Handler) AcknowledgeAlert(c *gin.Context) {
+	alertID := c.Param("id")
+
+	// Get current user
+	user, exists := c.Get("user")
+	if !exists {
+		c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"})
+		return
+	}
+
+	authUser, ok := user.(*iam.User)
+	if !ok {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "invalid user context"})
+		return
+	}
+
+	if err := h.alertService.AcknowledgeAlert(c.Request.Context(), alertID, authUser.ID); err != nil {
+		h.logger.Error("Failed to acknowledge alert", "alert_id", alertID, "error", err)
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "alert acknowledged"})
+}
+
+// ResolveAlert resolves an alert
+func (h *Handler) ResolveAlert(c *gin.Context) {
+	alertID := c.Param("id")
+
+	if err := h.alertService.ResolveAlert(c.Request.Context(), alertID); err != nil {
+		h.logger.Error("Failed to resolve alert", "alert_id", alertID, "error", err)
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "alert resolved"})
+}
+
+// GetMetrics retrieves current system metrics
+func (h *Handler) GetMetrics(c *gin.Context) {
+	metrics, err := h.metricsService.CollectMetrics(c.Request.Context())
+	if err != nil {
+		h.logger.Error("Failed to collect metrics", "error", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to collect metrics"})
+		return
+	}
+
+	c.JSON(http.StatusOK, metrics)
+}
+
+// WebSocketHandler handles WebSocket connections for event streaming
+func (h *Handler) WebSocketHandler(c *gin.Context) {
+	// Upgrade connection to WebSocket
+	upgrader := websocket.Upgrader{
+		CheckOrigin: func(r *http.Request) bool {
+			// Allow all origins for now (should be restricted in production)
+			return true
+		},
+	}
+
+	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		h.logger.Error("Failed to upgrade WebSocket connection", "error", err)
+		return
+	}
+
+	// Register client
+	h.eventHub.register <- conn
+
+	// Keep connection alive and handle ping/pong
+	go func() {
+		defer func() {
+			h.eventHub.unregister <- conn
+		}()
+
+		conn.SetReadDeadline(time.Now().Add(60 * time.Second))
+		conn.SetPongHandler(func(string) error {
+			conn.SetReadDeadline(time.Now().Add(60 * time.Second))
+			return nil
+		})
+
+		// Send ping every 30 seconds
+		ticker := time.NewTicker(30 * time.Second)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ticker.C:
+				if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
+					return
+				}
+			}
+		}
+	}()
+}
+