Skip to content

Modern Docker Management, Designed for Everyone

feat: events are now shown in the ui (#355)

Kyle Mendell49f51c420d62
diff --git a/backend/internal/api/container_handler.go b/backend/internal/api/container_handler.go
index b02c56c5e..d9c9522c6 100644
--- a/backend/internal/api/container_handler.go
+++ b/backend/internal/api/container_handler.go
@@ -10,6 +10,7 @@ import (
"github.com/docker/go-connections/nat"
"github.com/gin-gonic/gin"
"github.com/ofkm/arcane-backend/internal/dto"
+ "github.com/ofkm/arcane-backend/internal/middleware"
"github.com/ofkm/arcane-backend/internal/services"
"github.com/ofkm/arcane-backend/internal/utils"
)
@@ -47,7 +48,12 @@ func (h *ContainerHandler) PullImage(c *gin.Context) {
return
}
- err = h.imageService.PullImage(c.Request.Context(), imageName, c.Writer)
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ err = h.imageService.PullImage(c.Request.Context(), imageName, c.Writer, *currentUser)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
@@ -136,7 +142,12 @@ func (h *ContainerHandler) GetByID(c *gin.Context) {
func (h *ContainerHandler) Start(c *gin.Context) {
id := c.Param("containerId")
- if err := h.containerService.StartContainer(c.Request.Context(), id); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.containerService.StartContainer(c.Request.Context(), id, *currentUser); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"error": err.Error(),
@@ -153,7 +164,12 @@ func (h *ContainerHandler) Start(c *gin.Context) {
func (h *ContainerHandler) Stop(c *gin.Context) {
id := c.Param("containerId")
- if err := h.containerService.StopContainer(c.Request.Context(), id); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.containerService.StopContainer(c.Request.Context(), id, *currentUser); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"error": err.Error(),
@@ -170,7 +186,12 @@ func (h *ContainerHandler) Stop(c *gin.Context) {
func (h *ContainerHandler) Restart(c *gin.Context) {
id := c.Param("containerId")
- if err := h.containerService.RestartContainer(c.Request.Context(), id); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.containerService.RestartContainer(c.Request.Context(), id, *currentUser); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"error": err.Error(),
@@ -208,7 +229,12 @@ func (h *ContainerHandler) Delete(c *gin.Context) {
force := c.Query("force") == "true"
removeVolumes := c.Query("volumes") == "true"
- if err := h.containerService.DeleteContainer(c.Request.Context(), id, force, removeVolumes); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.containerService.DeleteContainer(c.Request.Context(), id, force, removeVolumes, *currentUser); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"error": err.Error(),
@@ -323,12 +349,18 @@ func (h *ContainerHandler) Create(c *gin.Context) {
}
}
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
containerJSON, err := h.containerService.CreateContainer(
c.Request.Context(),
config,
hostConfig,
networkingConfig,
req.Name,
+ *currentUser,
)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
diff --git a/backend/internal/api/event_handler.go b/backend/internal/api/event_handler.go
new file mode 100644
index 000000000..401a24bf0
--- /dev/null
+++ b/backend/internal/api/event_handler.go
@@ -0,0 +1,176 @@
+package api
+
+import (
+ "net/http"
+ "strconv"
+ "time"
+
+ "github.com/gin-gonic/gin"
+ "github.com/ofkm/arcane-backend/internal/dto"
+ "github.com/ofkm/arcane-backend/internal/services"
+ "github.com/ofkm/arcane-backend/internal/utils"
+)
+
+type EventHandler struct {
+ eventService *services.EventService
+}
+
+func NewEventHandler(eventService *services.EventService) *EventHandler {
+ return &EventHandler{
+ eventService: eventService,
+ }
+}
+
+func (h *EventHandler) ListEvents(c *gin.Context) {
+ var req utils.SortedPaginationRequest
+ if err := c.ShouldBindQuery(&req); err != nil {
+ c.JSON(http.StatusBadRequest, gin.H{
+ "success": false,
+ "error": "Invalid pagination or sort parameters: " + err.Error(),
+ })
+ return
+ }
+
+ if req.Pagination.Page == 0 {
+ req.Pagination.Page = 1
+ }
+ if req.Pagination.Limit == 0 {
+ req.Pagination.Limit = 20
+ }
+
+ events, pagination, err := h.eventService.ListEventsPaginated(c.Request.Context(), req)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{
+ "success": false,
+ "error": "Failed to list events: " + err.Error(),
+ })
+ return
+ }
+
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "data": events,
+ "pagination": pagination,
+ })
+}
+
+func (h *EventHandler) GetEventsByEnvironment(c *gin.Context) {
+ environmentID := c.Param("environmentId")
+ if environmentID == "" {
+ c.JSON(http.StatusBadRequest, gin.H{
+ "success": false,
+ "error": "Environment ID is required",
+ })
+ return
+ }
+
+ var req utils.SortedPaginationRequest
+ if err := c.ShouldBindQuery(&req); err != nil {
+ c.JSON(http.StatusBadRequest, gin.H{
+ "success": false,
+ "error": "Invalid pagination or sort parameters: " + err.Error(),
+ })
+ return
+ }
+
+ if req.Pagination.Page == 0 {
+ req.Pagination.Page = 1
+ }
+ if req.Pagination.Limit == 0 {
+ req.Pagination.Limit = 20
+ }
+
+ events, pagination, err := h.eventService.GetEventsByEnvironmentPaginated(c.Request.Context(), environmentID, req)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{
+ "success": false,
+ "error": "Failed to list events: " + err.Error(),
+ })
+ return
+ }
+
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "data": events,
+ "pagination": pagination,
+ })
+}
+
+func (h *EventHandler) CreateEvent(c *gin.Context) {
+ var req dto.CreateEventDto
+ if err := c.ShouldBindJSON(&req); err != nil {
+ c.JSON(http.StatusBadRequest, gin.H{
+ "success": false,
+ "error": "Invalid request body: " + err.Error(),
+ })
+ return
+ }
+
+ event, err := h.eventService.CreateEventFromDto(c.Request.Context(), req)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{
+ "success": false,
+ "error": "Failed to create event: " + err.Error(),
+ })
+ return
+ }
+
+ c.JSON(http.StatusCreated, gin.H{
+ "success": true,
+ "data": event,
+ })
+}
+
+func (h *EventHandler) DeleteEvent(c *gin.Context) {
+ eventID := c.Param("eventId")
+ if eventID == "" {
+ c.JSON(http.StatusBadRequest, gin.H{
+ "success": false,
+ "error": "Event ID is required",
+ })
+ return
+ }
+
+ if err := h.eventService.DeleteEvent(c.Request.Context(), eventID); err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{
+ "success": false,
+ "error": "Failed to delete event: " + err.Error(),
+ })
+ return
+ }
+
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "message": "Event deleted successfully",
+ })
+}
+
+func (h *EventHandler) DeleteOldEvents(c *gin.Context) {
+ daysStr := c.Query("days")
+ if daysStr == "" {
+ daysStr = c.Query("olderThanDays")
+ }
+
+ days, err := strconv.Atoi(daysStr)
+ if err != nil || days <= 0 {
+ c.JSON(http.StatusBadRequest, gin.H{
+ "success": false,
+ "error": "Invalid or missing 'days' parameter",
+ })
+ return
+ }
+
+ duration := time.Duration(days) * 24 * time.Hour
+ if err := h.eventService.DeleteOldEvents(c.Request.Context(), duration); err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{
+ "success": false,
+ "error": "Failed to delete old events: " + err.Error(),
+ })
+ return
+ }
+
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "message": "Old events deleted successfully",
+ })
+}
diff --git a/backend/internal/api/image_handler.go b/backend/internal/api/image_handler.go
index c4dbde5d1..2859bff8e 100644
--- a/backend/internal/api/image_handler.go
+++ b/backend/internal/api/image_handler.go
@@ -8,6 +8,7 @@ import (
"github.com/gin-gonic/gin"
"github.com/ofkm/arcane-backend/internal/dto"
+ "github.com/ofkm/arcane-backend/internal/middleware"
"github.com/ofkm/arcane-backend/internal/services"
"github.com/ofkm/arcane-backend/internal/utils"
)
@@ -79,7 +80,12 @@ func (h *ImageHandler) Remove(c *gin.Context) {
id := c.Param("imageId")
force := c.Query("force") == "true"
- if err := h.imageService.RemoveImage(c.Request.Context(), id, force); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.imageService.RemoveImage(c.Request.Context(), id, force, *currentUser); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"error": err.Error(),
@@ -110,7 +116,12 @@ func (h *ImageHandler) Pull(c *gin.Context) {
c.Writer.Header().Set("Connection", "keep-alive")
c.Writer.Header().Set("X-Accel-Buffering", "no")
- err := h.imageService.PullImage(ctx, req.ImageName, c.Writer)
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ err := h.imageService.PullImage(ctx, req.ImageName, c.Writer, *currentUser)
if err != nil {
if !c.Writer.Written() {
diff --git a/backend/internal/api/network_handler.go b/backend/internal/api/network_handler.go
index b60cf7e87..4e0eec89a 100644
--- a/backend/internal/api/network_handler.go
+++ b/backend/internal/api/network_handler.go
@@ -5,6 +5,7 @@ import (
"github.com/docker/docker/api/types/network"
"github.com/gin-gonic/gin"
+ "github.com/ofkm/arcane-backend/internal/middleware"
"github.com/ofkm/arcane-backend/internal/services"
"github.com/ofkm/arcane-backend/internal/utils"
)
@@ -121,7 +122,12 @@ func (h *NetworkHandler) Create(c *gin.Context) {
return
}
- response, err := h.networkService.CreateNetwork(c.Request.Context(), req.Name, req.Options)
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ response, err := h.networkService.CreateNetwork(c.Request.Context(), req.Name, req.Options, *currentUser)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
@@ -139,7 +145,12 @@ func (h *NetworkHandler) Create(c *gin.Context) {
func (h *NetworkHandler) Remove(c *gin.Context) {
id := c.Param("networkId")
- if err := h.networkService.RemoveNetwork(c.Request.Context(), id); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.networkService.RemoveNetwork(c.Request.Context(), id, *currentUser); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"error": err.Error(),
@@ -169,7 +180,12 @@ func (h *NetworkHandler) ConnectContainer(c *gin.Context) {
return
}
- if err := h.networkService.ConnectContainer(c.Request.Context(), networkID, req.ContainerID, req.Config); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.networkService.ConnectContainer(c.Request.Context(), networkID, req.ContainerID, req.Config, *currentUser); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"error": err.Error(),
@@ -199,7 +215,12 @@ func (h *NetworkHandler) DisconnectContainer(c *gin.Context) {
return
}
- if err := h.networkService.DisconnectContainer(c.Request.Context(), networkID, req.ContainerID, req.Force); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.networkService.DisconnectContainer(c.Request.Context(), networkID, req.ContainerID, req.Force, *currentUser); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"error": err.Error(),
diff --git a/backend/internal/api/routes.go b/backend/internal/api/routes.go
index a16f35b40..6894fcbce 100644
--- a/backend/internal/api/routes.go
+++ b/backend/internal/api/routes.go
@@ -25,6 +25,7 @@ type Services struct {
ContainerRegistry *services.ContainerRegistryService
System *services.SystemService
AutoUpdate *services.AutoUpdateService
+ Event *services.EventService
}
func SetupRoutes(r *gin.Engine, services *Services, appConfig *config.Config) {
@@ -46,6 +47,7 @@ func SetupRoutes(r *gin.Engine, services *Services, appConfig *config.Config) {
setupAutoUpdateRoutes(api, services)
setupConverterRoutes(api, services)
setupImageUpdateRoutes(api, services)
+ setupEventRoutes(api, services)
}
func setupContainerRegistryRoutes(api *gin.RouterGroup, services *Services) {
@@ -351,3 +353,15 @@ func setupTemplateRoutes(router *gin.RouterGroup, services *Services) {
templatesAuth.DELETE("/registries/:id", templateHandler.DeleteRegistry)
}
}
+
+func setupEventRoutes(api *gin.RouterGroup, services *Services) {
+ events := api.Group("/events")
+ events.Use(middleware.AuthMiddleware(services.Auth))
+
+ eventHandler := NewEventHandler(services.Event)
+
+ events.GET("", eventHandler.ListEvents)
+ events.POST("", eventHandler.CreateEvent)
+ events.DELETE("/:eventId", eventHandler.DeleteEvent)
+ events.GET("/environment/:environmentId", eventHandler.GetEventsByEnvironment)
+}
diff --git a/backend/internal/api/stack_handler.go b/backend/internal/api/stack_handler.go
index baf087f3e..543779a6a 100644
--- a/backend/internal/api/stack_handler.go
+++ b/backend/internal/api/stack_handler.go
@@ -10,6 +10,7 @@ import (
"github.com/gin-gonic/gin"
"github.com/ofkm/arcane-backend/internal/dto"
+ "github.com/ofkm/arcane-backend/internal/middleware"
"github.com/ofkm/arcane-backend/internal/models"
"github.com/ofkm/arcane-backend/internal/services"
"github.com/ofkm/arcane-backend/internal/utils"
@@ -67,7 +68,12 @@ func (h *StackHandler) CreateStack(c *gin.Context) {
return
}
- stack, err := h.stackService.CreateStack(c.Request.Context(), req.Name, req.ComposeContent, req.EnvContent)
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ stack, err := h.stackService.CreateStack(c.Request.Context(), req.Name, req.ComposeContent, req.EnvContent, *currentUser)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
@@ -254,7 +260,12 @@ func (h *StackHandler) DeleteStack(c *gin.Context) {
stackID = c.Param("id")
}
- err := h.stackService.DeleteStack(c.Request.Context(), stackID)
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ err := h.stackService.DeleteStack(c.Request.Context(), stackID, *currentUser)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
@@ -283,7 +294,12 @@ func (h *StackHandler) StartStack(c *gin.Context) {
return
}
- if err := h.stackService.DeployStack(c.Request.Context(), stackID); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.stackService.DeployStack(c.Request.Context(), stackID, *currentUser); err != nil {
c.JSON(http.StatusBadRequest, gin.H{
"success": false,
"error": err.Error(),
@@ -303,7 +319,12 @@ func (h *StackHandler) StopStack(c *gin.Context) {
stackID = c.Param("id")
}
- if err := h.stackService.StopStack(c.Request.Context(), stackID); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.stackService.StopStack(c.Request.Context(), stackID, *currentUser); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"error": "Failed to stop stack",
@@ -323,7 +344,12 @@ func (h *StackHandler) RestartStack(c *gin.Context) {
stackID = c.Param("id")
}
- if err := h.stackService.RestartStack(c.Request.Context(), stackID); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.stackService.RestartStack(c.Request.Context(), stackID, *currentUser); err != nil {
c.JSON(http.StatusBadRequest, gin.H{
"success": false,
"error": err.Error(),
@@ -351,7 +377,12 @@ func (h *StackHandler) RedeployStack(c *gin.Context) {
}
}
- if err := h.stackService.RedeployStack(c.Request.Context(), stackID, req.Profiles, req.EnvOverrides); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.stackService.RedeployStack(c.Request.Context(), stackID, req.Profiles, req.EnvOverrides, *currentUser); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"error": fmt.Sprintf("Failed to redeploy stack: %v", err),
@@ -371,7 +402,12 @@ func (h *StackHandler) DownStack(c *gin.Context) {
stackID = c.Param("id")
}
- if err := h.stackService.DownStack(c.Request.Context(), stackID); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.stackService.DownStack(c.Request.Context(), stackID, *currentUser); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"error": fmt.Sprintf("Failed to bring down stack: %v", err),
@@ -399,7 +435,12 @@ func (h *StackHandler) DestroyStack(c *gin.Context) {
}
}
- if err := h.stackService.DestroyStack(c.Request.Context(), stackID, req.RemoveFiles, req.RemoveVolumes); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.stackService.DestroyStack(c.Request.Context(), stackID, req.RemoveFiles, req.RemoveVolumes, *currentUser); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"error": fmt.Sprintf("Failed to destroy stack: %v", err),
@@ -443,7 +484,12 @@ func (h *StackHandler) DeployStack(c *gin.Context) {
return
}
- if err := h.stackService.DeployStack(c.Request.Context(), stackID); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.stackService.DeployStack(c.Request.Context(), stackID, *currentUser); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"error": err.Error(),
diff --git a/backend/internal/api/volume_handler.go b/backend/internal/api/volume_handler.go
index addc71316..2a9f08272 100644
--- a/backend/internal/api/volume_handler.go
+++ b/backend/internal/api/volume_handler.go
@@ -5,6 +5,7 @@ import (
"github.com/docker/docker/api/types/volume"
"github.com/gin-gonic/gin"
+ "github.com/ofkm/arcane-backend/internal/middleware"
"github.com/ofkm/arcane-backend/internal/services"
"github.com/ofkm/arcane-backend/internal/utils"
)
@@ -120,7 +121,12 @@ func (h *VolumeHandler) Create(c *gin.Context) {
DriverOpts: req.Options,
}
- response, err := h.volumeService.CreateVolume(c.Request.Context(), options)
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ response, err := h.volumeService.CreateVolume(c.Request.Context(), options, *currentUser)
if err != nil {
c.JSON(500, gin.H{
"error": err.Error(),
@@ -139,7 +145,12 @@ func (h *VolumeHandler) Remove(c *gin.Context) {
name := c.Param("volumeName")
force := c.Query("force") == "true"
- if err := h.volumeService.DeleteVolume(c.Request.Context(), name, force); err != nil {
+ currentUser, exists := middleware.GetCurrentUser(c)
+ if !exists || currentUser == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+ if err := h.volumeService.DeleteVolume(c.Request.Context(), name, force, *currentUser); err != nil {
c.JSON(500, gin.H{
"error": err.Error(),
})
diff --git a/backend/internal/bootstrap/jobs_bootstrap.go b/backend/internal/bootstrap/jobs_bootstrap.go
index 020b1cfd1..a0d2e5649 100644
--- a/backend/internal/bootstrap/jobs_bootstrap.go
+++ b/backend/internal/bootstrap/jobs_bootstrap.go
@@ -25,4 +25,8 @@ func registerJobs(appCtx context.Context, scheduler *job.Scheduler, appServices
if err := job.RegisterStackSyncJob(appCtx, scheduler, appServices.Stack); err != nil {
slog.ErrorContext(appCtx, "Failed to register stack sync job", slog.Any("error", err))
}
+
+ if err := job.RegisterEventCleanupJob(appCtx, scheduler, appServices.Event); err != nil {
+ slog.ErrorContext(appCtx, "Failed to register event cleanup job", slog.Any("error", err))
+ }
}
diff --git a/backend/internal/bootstrap/services_bootstrap.go b/backend/internal/bootstrap/services_bootstrap.go
index 3948d11f0..213a167c7 100644
--- a/backend/internal/bootstrap/services_bootstrap.go
+++ b/backend/internal/bootstrap/services_bootstrap.go
@@ -11,22 +11,23 @@ import (
func initializeServices(db *database.DB, cfg *config.Config) (*api.Services, *services.DockerClientService, error) {
log.Println("Initializing services...")
+ eventService := services.NewEventService(db)
converterService := services.NewConverterService()
settingsService := services.NewSettingsService(db, cfg)
dockerClientService := services.NewDockerClientService(db)
userService := services.NewUserService(db)
- stackService := services.NewStackService(db, settingsService)
+ stackService := services.NewStackService(db, settingsService, eventService)
environmentService := services.NewEnvironmentService(db)
- containerService := services.NewContainerService(db, dockerClientService)
+ containerService := services.NewContainerService(db, eventService, dockerClientService)
containerRegistry := services.NewContainerRegistryService(db)
- imageUpdate := services.NewImageUpdateService(db, settingsService, containerRegistry, dockerClientService)
- imageService := services.NewImageService(db, dockerClientService, containerRegistry, imageUpdate)
- volumeService := services.NewVolumeService(db, dockerClientService)
- networkService := services.NewNetworkService(db, dockerClientService)
+ imageUpdate := services.NewImageUpdateService(db, settingsService, containerRegistry, dockerClientService, eventService)
+ imageService := services.NewImageService(db, dockerClientService, containerRegistry, imageUpdate, eventService)
+ volumeService := services.NewVolumeService(db, dockerClientService, eventService)
+ networkService := services.NewNetworkService(db, dockerClientService, eventService)
templateService := services.NewTemplateService(db)
- authService := services.NewAuthService(userService, settingsService, cfg.JWTSecret, cfg)
+ authService := services.NewAuthService(userService, settingsService, eventService, cfg.JWTSecret, cfg)
oidcService := services.NewOidcService(authService, cfg)
- autoUpdate := services.NewAutoUpdateService(db, dockerClientService, settingsService, containerService, stackService, imageService, imageUpdate, containerRegistry)
+ autoUpdate := services.NewAutoUpdateService(db, dockerClientService, settingsService, containerService, stackService, imageService, imageUpdate, containerRegistry, eventService)
systemService := services.NewSystemService(db, dockerClientService, containerService, imageService, volumeService, networkService, settingsService)
appServices := &api.Services{
@@ -47,6 +48,7 @@ func initializeServices(db *database.DB, cfg *config.Config) (*api.Services, *se
System: systemService,
AutoUpdate: autoUpdate,
ImageUpdate: imageUpdate,
+ Event: eventService,
}
return appServices, dockerClientService, nil
diff --git a/backend/internal/dto/event_dto.go b/backend/internal/dto/event_dto.go
new file mode 100644
index 000000000..03f79b845
--- /dev/null
+++ b/backend/internal/dto/event_dto.go
@@ -0,0 +1,45 @@
+package dto
+
+import "time"
+
+type EventDto struct {
+ ID string `json:"id"`
+ Type string `json:"type"`
+ Severity string `json:"severity"`
+ Title string `json:"title"`
+ Description string `json:"description,omitempty"`
+ ResourceType *string `json:"resourceType,omitempty"`
+ ResourceID *string `json:"resourceId,omitempty"`
+ ResourceName *string `json:"resourceName,omitempty"`
+ UserID *string `json:"userId,omitempty"`
+ Username *string `json:"username,omitempty"`
+ EnvironmentID *string `json:"environmentId,omitempty"`
+ Metadata map[string]interface{} `json:"metadata,omitempty"`
+ Timestamp time.Time `json:"timestamp"`
+ CreatedAt time.Time `json:"createdAt"`
+ UpdatedAt *time.Time `json:"updatedAt,omitempty"`
+}
+
+type CreateEventDto struct {
+ Type string `json:"type" binding:"required"`
+ Severity string `json:"severity,omitempty"`
+ Title string `json:"title" binding:"required"`
+ Description string `json:"description,omitempty"`
+ ResourceType *string `json:"resourceType,omitempty"`
+ ResourceID *string `json:"resourceId,omitempty"`
+ ResourceName *string `json:"resourceName,omitempty"`
+ UserID *string `json:"userId,omitempty"`
+ Username *string `json:"username,omitempty"`
+ EnvironmentID *string `json:"environmentId,omitempty"`
+ Metadata map[string]interface{} `json:"metadata,omitempty"`
+}
+
+type EventListDto struct {
+ Events []EventDto `json:"events"`
+ Total int `json:"total"`
+ Page int `json:"page"`
+ PageSize int `json:"pageSize"`
+ TotalPages int `json:"totalPages"`
+ HasNext bool `json:"hasNext"`
+ HasPrevious bool `json:"hasPrevious"`
+}
diff --git a/backend/internal/job/event_cleanup_job.go b/backend/internal/job/event_cleanup_job.go
new file mode 100644
index 000000000..9517b4894
--- /dev/null
+++ b/backend/internal/job/event_cleanup_job.go
@@ -0,0 +1,61 @@
+package job
+
+import (
+ "context"
+ "fmt"
+ "log/slog"
+ "time"
+
+ "github.com/go-co-op/gocron/v2"
+ "github.com/ofkm/arcane-backend/internal/services"
+)
+
+const EventCleanupJobName = "EventCleanup"
+
+func RegisterEventCleanupJob(
+ ctx context.Context,
+ scheduler *Scheduler,
+ eventService *services.EventService,
+) error {
+ slog.InfoContext(ctx, "Registering event cleanup job", "jobName", EventCleanupJobName)
+
+ taskFunc := func(jobCtx context.Context) error {
+ slog.InfoContext(jobCtx, "Running event cleanup job", "jobName", EventCleanupJobName)
+
+ // Delete events older than 36 hours
+ olderThan := 36 * time.Hour
+ if err := eventService.DeleteOldEvents(jobCtx, olderThan); err != nil {
+ slog.ErrorContext(jobCtx, "Failed to delete old events",
+ "jobName", EventCleanupJobName,
+ "olderThan", olderThan.String(),
+ slog.Any("error", err))
+ return err
+ }
+
+ slog.InfoContext(jobCtx, "Event cleanup job completed successfully",
+ "jobName", EventCleanupJobName,
+ "olderThan", olderThan.String())
+ return nil
+ }
+
+ // Run every 6 hours to keep the cleanup regular but not too frequent
+ jobDefinition := gocron.DurationJob(6 * time.Hour)
+
+ err := scheduler.RegisterJob(
+ ctx,
+ EventCleanupJobName,
+ jobDefinition,
+ taskFunc,
+ false, // Don't run immediately on startup
+ )
+
+ if err != nil {
+ return fmt.Errorf("failed to register event cleanup job %q: %w", EventCleanupJobName, err)
+ }
+
+ slog.InfoContext(ctx, "Event cleanup job registered successfully",
+ "jobName", EventCleanupJobName,
+ "interval", "6h",
+ "retention", "36h")
+ return nil
+}
diff --git a/backend/internal/middleware/auth_middleware.go b/backend/internal/middleware/auth_middleware.go
index 438164e65..d918f498b 100644
--- a/backend/internal/middleware/auth_middleware.go
+++ b/backend/internal/middleware/auth_middleware.go
@@ -39,7 +39,10 @@ func AuthMiddleware(authService *services.AuthService) gin.HandlerFunc {
c.Abort()
return
}
+
+ // Store in Gin context for handlers
c.Set("currentUser", user)
+
c.Next()
}
}
diff --git a/backend/internal/models/event.go b/backend/internal/models/event.go
new file mode 100644
index 000000000..8aabc1048
--- /dev/null
+++ b/backend/internal/models/event.go
@@ -0,0 +1,68 @@
+package models
+
+import (
+ "time"
+)
+
+type EventType string
+type EventSeverity string
+
+const (
+ // Event types
+ EventTypeContainerStart EventType = "container.start"
+ EventTypeContainerStop EventType = "container.stop"
+ EventTypeContainerRestart EventType = "container.restart"
+ EventTypeContainerDelete EventType = "container.delete"
+ EventTypeContainerCreate EventType = "container.create"
+ EventTypeContainerScan EventType = "container.scan"
+ EventTypeContainerUpdate EventType = "container.update"
+
+ EventTypeImagePull EventType = "image.pull"
+ EventTypeImageDelete EventType = "image.delete"
+ EventTypeImageScan EventType = "image.scan"
+
+ EventTypeStackDeploy EventType = "project.deploy"
+ EventTypeStackDelete EventType = "project.delete"
+ EventTypeStackStart EventType = "project.start"
+ EventTypeStackStop EventType = "project.stop"
+ EventTypeStackCreate EventType = "project.create"
+ EventTypeStackUpdate EventType = "project.update"
+
+ EventTypeVolumeCreate EventType = "volume.create"
+ EventTypeVolumeDelete EventType = "volume.delete"
+
+ EventTypeNetworkCreate EventType = "network.create"
+ EventTypeNetworkDelete EventType = "network.delete"
+
+ EventTypeSystemPrune EventType = "system.prune"
+ EventTypeUserLogin EventType = "user.login"
+ EventTypeUserLogout EventType = "user.logout"
+ EventTypeSystemAutoUpdate EventType = "system.auto_update"
+
+ // Event severities
+ EventSeverityInfo EventSeverity = "info"
+ EventSeverityWarning EventSeverity = "warning"
+ EventSeverityError EventSeverity = "error"
+ EventSeveritySuccess EventSeverity = "success"
+)
+
+type Event struct {
+ ID string `json:"id" gorm:"primaryKey" sortable:"true"`
+ Type EventType `json:"type" gorm:"not null" sortable:"true"`
+ Severity EventSeverity `json:"severity" gorm:"not null" sortable:"true"`
+ Title string `json:"title" gorm:"not null" sortable:"true"`
+ Description string `json:"description"`
+ ResourceType *string `json:"resourceType,omitempty" gorm:"index" sortable:"true"`
+ ResourceID *string `json:"resourceId,omitempty" gorm:"index" sortable:"true"`
+ ResourceName *string `json:"resourceName,omitempty" sortable:"true"`
+ UserID *string `json:"userId,omitempty" gorm:"index" sortable:"true"`
+ Username *string `json:"username,omitempty" sortable:"true"`
+ EnvironmentID *string `json:"environmentId,omitempty" gorm:"index"`
+ Metadata JSON `json:"metadata,omitempty" gorm:"type:text"`
+ Timestamp time.Time `json:"timestamp" gorm:"not null;index" sortable:"true"`
+ BaseModel
+}
+
+func (Event) TableName() string {
+ return "events"
+}
diff --git a/backend/internal/services/auth_service.go b/backend/internal/services/auth_service.go
index afe130dc4..c16d48edb 100644
--- a/backend/internal/services/auth_service.go
+++ b/backend/internal/services/auth_service.go
@@ -10,6 +10,7 @@ import (
"strings"
"time"
+ "github.com/gin-gonic/gin"
"github.com/golang-jwt/jwt/v5"
"github.com/ofkm/arcane-backend/internal/config"
"github.com/ofkm/arcane-backend/internal/models"
@@ -73,16 +74,18 @@ type UserClaims struct {
type AuthService struct {
userService *UserService
settingsService *SettingsService
+ eventService *EventService
jwtSecret []byte
accessExpiry time.Duration
refreshExpiry time.Duration
config *config.Config
}
-func NewAuthService(userService *UserService, settingsService *SettingsService, jwtSecret string, cfg *config.Config) *AuthService {
+func NewAuthService(userService *UserService, settingsService *SettingsService, eventService *EventService, jwtSecret string, cfg *config.Config) *AuthService {
return &AuthService{
userService: userService,
settingsService: settingsService,
+ eventService: eventService,
jwtSecret: utils.CheckOrGenerateJwtSecret(jwtSecret),
accessExpiry: 30 * time.Minute,
refreshExpiry: 7 * 24 * time.Hour,
@@ -90,6 +93,13 @@ func NewAuthService(userService *UserService, settingsService *SettingsService,
}
}
+func getClientIP(ctx context.Context) string {
+ if ginCtx, ok := ctx.(*gin.Context); ok {
+ return ginCtx.ClientIP()
+ }
+ return ""
+}
+
func (s *AuthService) getAuthSettings(ctx context.Context) (*AuthSettings, error) {
settings, err := s.settingsService.GetSettings(ctx)
if err != nil {
@@ -255,6 +265,15 @@ func (s *AuthService) Login(ctx context.Context, username, password string) (*mo
return nil, nil, err
}
+ metadata := models.JSON{
+ "action": "login",
+ "method": "local",
+ "ipAddress": getClientIP(ctx),
+ }
+ if logErr := s.eventService.LogUserEvent(ctx, models.EventTypeUserLogin, user.ID, user.Username, metadata); logErr != nil {
+ fmt.Printf("Could not log user login action: %s\n", logErr)
+ }
+
return user, tokenPair, nil
}
@@ -278,6 +297,7 @@ func (s *AuthService) OidcLogin(ctx context.Context, userInfo OidcUserInfo) (*mo
return nil, nil, err
}
+ isNewUser := false
if user != nil {
if userInfo.Name != "" && user.DisplayName == nil {
user.DisplayName = &userInfo.Name
@@ -293,6 +313,7 @@ func (s *AuthService) OidcLogin(ctx context.Context, userInfo OidcUserInfo) (*mo
return nil, nil, err
}
} else {
+ isNewUser = true
username := generateUsernameFromEmail(userInfo.Email, userInfo.Subject)
var displayName string
@@ -326,9 +347,35 @@ func (s *AuthService) OidcLogin(ctx context.Context, userInfo OidcUserInfo) (*mo
return nil, nil, err
}
+ // Log user login event
+ metadata := models.JSON{
+ "action": "login",
+ "method": "oidc",
+ "newUser": isNewUser,
+ "subject": userInfo.Subject,
+ "ipAddress": "", // Could be extracted from context if available
+ }
+ if logErr := s.eventService.LogUserEvent(ctx, models.EventTypeUserLogin, user.ID, user.Username, metadata); logErr != nil {
+ fmt.Printf("Could not log OIDC user login action: %s\n", logErr)
+ }
+
return user, tokenPair, nil
}
+// Add a logout method to log logout events
+func (s *AuthService) Logout(ctx context.Context, user *models.User) error {
+ // Log user logout event
+ metadata := models.JSON{
+ "action": "logout",
+ "ipAddress": "", // Could be extracted from context if available
+ }
+ if logErr := s.eventService.LogUserEvent(ctx, models.EventTypeUserLogout, user.ID, user.Username, metadata); logErr != nil {
+ fmt.Printf("Could not log user logout action: %s\n", logErr)
+ }
+
+ return nil
+}
+
func (s *AuthService) RefreshToken(ctx context.Context, refreshToken string) (*TokenPair, error) {
token, err := jwt.ParseWithClaims(refreshToken, &jwt.RegisteredClaims{},
func(t *jwt.Token) (interface{}, error) {
diff --git a/backend/internal/services/auto_update_service.go b/backend/internal/services/auto_update_service.go
index 1b60dae20..45dcae240 100644
--- a/backend/internal/services/auto_update_service.go
+++ b/backend/internal/services/auto_update_service.go
@@ -34,6 +34,7 @@ type AutoUpdateService struct {
imageService *ImageService
imageUpdateService *ImageUpdateService
registryService *ContainerRegistryService
+ eventService *EventService
updatingContainers map[string]bool
updatingStacks map[string]bool
mutex sync.RWMutex
@@ -48,6 +49,7 @@ func NewAutoUpdateService(
imageService *ImageService,
imageUpdateService *ImageUpdateService,
registryService *ContainerRegistryService,
+ eventService *EventService,
) *AutoUpdateService {
return &AutoUpdateService{
db: db,
@@ -58,6 +60,7 @@ func NewAutoUpdateService(
imageService: imageService,
imageUpdateService: imageUpdateService,
registryService: registryService,
+ eventService: eventService, // Add this line
updatingContainers: make(map[string]bool),
updatingStacks: make(map[string]bool),
}
@@ -71,6 +74,27 @@ func (s *AutoUpdateService) CheckForUpdates(ctx context.Context, req dto.AutoUpd
Results: []dto.AutoUpdateResourceResult{},
}
+ // Log auto-update check start event
+ metadata := models.JSON{
+ "action": "check_start",
+ "type": req.Type,
+ "dryRun": req.DryRun,
+ "forceUpdate": req.ForceUpdate,
+ "resourceCount": len(req.ResourceIds),
+ }
+ if _, logErr := s.eventService.CreateEvent(ctx, CreateEventRequest{
+ Type: models.EventTypeSystemAutoUpdate,
+ Severity: models.EventSeverityInfo,
+ Title: "Auto-update check started",
+ Description: fmt.Sprintf("Auto-update check initiated for type: %s", req.Type),
+ UserID: &systemUser.ID,
+ Username: &systemUser.Username,
+ EnvironmentID: utils.Ptr("0"),
+ Metadata: metadata,
+ }); logErr != nil {
+ log.Printf("Failed to log auto-update start event: %v", logErr)
+ }
+
// Get individual setting instead of full settings struct
autoUpdateEnabled := s.settingsService.GetBoolSetting(ctx, "autoUpdateEnabled", false)
@@ -78,6 +102,25 @@ func (s *AutoUpdateService) CheckForUpdates(ctx context.Context, req dto.AutoUpd
result.Skipped = 1
result.EndTime = time.Now().Format(time.RFC3339)
result.Duration = time.Since(startTime).String()
+
+ // Log skipped event
+ skipMetadata := models.JSON{
+ "action": "check_skipped",
+ "reason": "auto_update_disabled",
+ }
+ if _, logErr := s.eventService.CreateEvent(ctx, CreateEventRequest{
+ Type: models.EventTypeSystemAutoUpdate,
+ Severity: models.EventSeverityInfo,
+ Title: "Auto-update check skipped",
+ Description: "Auto-update is disabled and force update was not requested",
+ UserID: &systemUser.ID,
+ Username: &systemUser.Username,
+ EnvironmentID: utils.Ptr("0"),
+ Metadata: skipMetadata,
+ }); logErr != nil {
+ log.Printf("Failed to log auto-update skip event: %v", logErr)
+ }
+
return result, nil
}
@@ -93,6 +136,35 @@ func (s *AutoUpdateService) CheckForUpdates(ctx context.Context, req dto.AutoUpd
result.EndTime = time.Now().Format(time.RFC3339)
result.Duration = time.Since(startTime).String()
+
+ // Log auto-update check completion event
+ completionMetadata := models.JSON{
+ "action": "check_completed",
+ "duration": result.Duration,
+ "checked": result.Checked,
+ "updated": result.Updated,
+ "failed": result.Failed,
+ "skipped": result.Skipped,
+ "success": result.Success,
+ }
+ severity := models.EventSeveritySuccess
+ if result.Failed > 0 {
+ severity = models.EventSeverityWarning
+ }
+
+ if _, logErr := s.eventService.CreateEvent(ctx, CreateEventRequest{
+ Type: models.EventTypeSystemAutoUpdate,
+ Severity: severity,
+ Title: "Auto-update check completed",
+ Description: fmt.Sprintf("Auto-update completed: %d checked, %d updated, %d failed", result.Checked, result.Updated, result.Failed),
+ UserID: &systemUser.ID,
+ Username: &systemUser.Username,
+ EnvironmentID: utils.Ptr("0"),
+ Metadata: completionMetadata,
+ }); logErr != nil {
+ log.Printf("Failed to log auto-update completion event: %v", logErr)
+ }
+
return result, nil
}
@@ -266,6 +338,15 @@ func (s *AutoUpdateService) pullImageWithAuth(ctx context.Context, imageRef stri
reader, err := dockerClient.ImagePull(ctx, imageRef, pullOptions)
if err != nil {
+ // Log image pull failure event
+ metadata := models.JSON{
+ "action": "auto_pull_failed",
+ "imageRef": imageRef,
+ "error": err.Error(),
+ }
+ if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImagePull, "", imageRef, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
+ log.Printf("Failed to log image pull failure event: %v", logErr)
+ }
return fmt.Errorf("failed to pull image %s: %w", imageRef, err)
}
defer reader.Close()
@@ -274,6 +355,15 @@ func (s *AutoUpdateService) pullImageWithAuth(ctx context.Context, imageRef stri
return fmt.Errorf("failed to complete image pull: %w", err)
}
+ // Log successful image pull event
+ metadata := models.JSON{
+ "action": "auto_pull_success",
+ "imageRef": imageRef,
+ }
+ if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImagePull, "", imageRef, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
+ log.Printf("Failed to log image pull success event: %v", logErr)
+ }
+
log.Printf("Successfully pulled image: %s", imageRef)
return nil
}
@@ -503,7 +593,8 @@ func (s *AutoUpdateService) updateContainerWithLatestImage(
}
defer dockerClient.Close()
- log.Printf("Pulling latest image %s for container %s", newImageRef, s.getContainerName(cnt))
+ containerName := s.getContainerName(cnt)
+ log.Printf("Pulling latest image %s for container %s", newImageRef, containerName)
pullOptions := image.PullOptions{}
@@ -520,6 +611,17 @@ func (s *AutoUpdateService) updateContainerWithLatestImage(
reader, err := dockerClient.ImagePull(ctx, newImageRef, pullOptions)
if err != nil {
+ // Log container update failure event
+ metadata := models.JSON{
+ "action": "auto_update_failed",
+ "oldImage": containerJSON.Config.Image,
+ "newImage": newImageRef,
+ "error": err.Error(),
+ "step": "image_pull",
+ }
+ if logErr := s.eventService.LogContainerEvent(ctx, models.EventTypeContainerUpdate, cnt.ID, containerName, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
+ log.Printf("Failed to log container update failure event: %v", logErr)
+ }
return fmt.Errorf("failed to pull image %s: %w", newImageRef, err)
}
defer reader.Close()
@@ -528,6 +630,15 @@ func (s *AutoUpdateService) updateContainerWithLatestImage(
return fmt.Errorf("failed to complete image pull: %w", err)
}
+ // Log container stop event
+ stopMetadata := models.JSON{
+ "action": "auto_update_stop",
+ "reason": "updating_image",
+ }
+ if logErr := s.eventService.LogContainerEvent(ctx, models.EventTypeContainerStop, cnt.ID, containerName, systemUser.ID, systemUser.Username, "0", stopMetadata); logErr != nil {
+ log.Printf("Failed to log container stop event: %v", logErr)
+ }
+
if err := dockerClient.ContainerStop(ctx, cnt.ID, container.StopOptions{}); err != nil {
return fmt.Errorf("failed to stop container: %w", err)
}
@@ -536,6 +647,15 @@ func (s *AutoUpdateService) updateContainerWithLatestImage(
return fmt.Errorf("failed to remove old container: %w", err)
}
+ // Log container delete event
+ deleteMetadata := models.JSON{
+ "action": "auto_update_delete",
+ "reason": "replacing_with_updated_image",
+ }
+ if logErr := s.eventService.LogContainerEvent(ctx, models.EventTypeContainerDelete, cnt.ID, containerName, systemUser.ID, systemUser.Username, "0", deleteMetadata); logErr != nil {
+ log.Printf("Failed to log container delete event: %v", logErr)
+ }
+
containerJSON.Config.Image = newImageRef
resp, err := dockerClient.ContainerCreate(
@@ -552,15 +672,37 @@ func (s *AutoUpdateService) updateContainerWithLatestImage(
return fmt.Errorf("failed to create new container: %w", err)
}
+ // Log container create event
+ createMetadata := models.JSON{
+ "action": "auto_update_create",
+ "oldImage": containerJSON.Config.Image,
+ "newImage": newImageRef,
+ "newImageId": resp.ID,
+ }
+ if logErr := s.eventService.LogContainerEvent(ctx, models.EventTypeContainerCreate, resp.ID, containerName, systemUser.ID, systemUser.Username, "0", createMetadata); logErr != nil {
+ log.Printf("Failed to log container create event: %v", logErr)
+ }
+
if err := dockerClient.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {
return fmt.Errorf("failed to start new container: %w", err)
}
- log.Printf("Successfully updated container %s with image %s", s.getContainerName(cnt), newImageRef)
+ // Log container start event
+ startMetadata := models.JSON{
+ "action": "auto_update_start",
+ "oldImage": containerJSON.Config.Image,
+ "newImage": newImageRef,
+ "newImageId": resp.ID,
+ }
+ if logErr := s.eventService.LogContainerEvent(ctx, models.EventTypeContainerStart, resp.ID, containerName, systemUser.ID, systemUser.Username, "0", startMetadata); logErr != nil {
+ log.Printf("Failed to log container start event: %v", logErr)
+ }
+
+ log.Printf("Successfully updated container %s with image %s", containerName, newImageRef)
return nil
}
-// Helper method to construct image reference with new tag
+// Helper method to construct image reference with new tag - KEEPING THIS FUNCTION
func (s *AutoUpdateService) constructImageRefWithTag(imageRef, newTag string) string {
parts := strings.Split(imageRef, ":")
if len(parts) > 1 {
@@ -680,16 +822,49 @@ func (s *AutoUpdateService) updateStack(
) error {
log.Printf("Updating stack: %s", stack.Name)
+ // Log stack update start event
+ updateMetadata := models.JSON{
+ "action": "auto_update_start",
+ "reason": "image_updates_available",
+ }
+ if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackUpdate, stack.ID, stack.Name, systemUser.ID, systemUser.Username, "0", updateMetadata); logErr != nil {
+ log.Printf("Failed to log stack update start event: %v", logErr)
+ }
+
log.Printf("Pulling latest images for stack: %s", stack.Name)
if err := s.stackService.PullStackImages(ctx, stack.ID); err != nil {
log.Printf("Warning: Failed to pull some images: %v", err)
+ // Log image pull warning
+ pullWarningMetadata := models.JSON{
+ "action": "auto_update_pull_warning",
+ "error": err.Error(),
+ }
+ if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackUpdate, stack.ID, stack.Name, systemUser.ID, systemUser.Username, "0", pullWarningMetadata); logErr != nil {
+ log.Printf("Failed to log stack pull warning event: %v", logErr)
+ }
}
log.Printf("Redeploying stack: %s", stack.Name)
- if err := s.stackService.RedeployStack(ctx, stack.ID, nil, nil); err != nil {
+ if err := s.stackService.RedeployStack(ctx, stack.ID, nil, nil, systemUser); err != nil {
+ // Log stack update failure event
+ failureMetadata := models.JSON{
+ "action": "auto_update_failed",
+ "error": err.Error(),
+ }
+ if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackUpdate, stack.ID, stack.Name, systemUser.ID, systemUser.Username, "0", failureMetadata); logErr != nil {
+ log.Printf("Failed to log stack update failure event: %v", logErr)
+ }
return fmt.Errorf("failed to redeploy stack: %w", err)
}
+ // Log stack update success event
+ successMetadata := models.JSON{
+ "action": "auto_update_success",
+ }
+ if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackUpdate, stack.ID, stack.Name, systemUser.ID, systemUser.Username, "0", successMetadata); logErr != nil {
+ log.Printf("Failed to log stack update success event: %v", logErr)
+ }
+
log.Printf("Successfully updated stack: %s", stack.Name)
return nil
}
diff --git a/backend/internal/services/container_service.go b/backend/internal/services/container_service.go
index 9f526f36f..ce779569c 100644
--- a/backend/internal/services/container_service.go
+++ b/backend/internal/services/container_service.go
@@ -22,10 +22,11 @@ import (
type ContainerService struct {
db *database.DB
dockerService *DockerClientService
+ eventService *EventService
}
-func NewContainerService(db *database.DB, dockerService *DockerClientService) *ContainerService {
- return &ContainerService{db: db, dockerService: dockerService}
+func NewContainerService(db *database.DB, eventService *EventService, dockerService *DockerClientService) *ContainerService {
+ return &ContainerService{db: db, eventService: eventService, dockerService: dockerService}
}
func (s *ContainerService) PullContainerImage(ctx context.Context, containerID string) error {
@@ -70,34 +71,65 @@ func (s *ContainerService) ListContainers(ctx context.Context, includeAll bool)
return containers, nil
}
-func (s *ContainerService) StartContainer(ctx context.Context, containerID string) error {
+func (s *ContainerService) StartContainer(ctx context.Context, containerID string, user models.User) error {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
defer dockerClient.Close()
+ metadata := models.JSON{
+ "action": "start",
+ "containerId": containerID,
+ }
+
+ err = s.eventService.LogContainerEvent(ctx, models.EventTypeContainerStart, containerID, "name", user.ID, user.Username, "0", metadata)
+
+ if err != nil {
+ fmt.Printf("Could not log container start action: %s\n", err)
+ }
+
return dockerClient.ContainerStart(ctx, containerID, container.StartOptions{})
}
-func (s *ContainerService) StopContainer(ctx context.Context, containerID string) error {
+func (s *ContainerService) StopContainer(ctx context.Context, containerID string, user models.User) error {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
defer dockerClient.Close()
+ metadata := models.JSON{
+ "action": "stop",
+ "containerId": containerID,
+ }
+
+ err = s.eventService.LogContainerEvent(ctx, models.EventTypeContainerStop, containerID, "name", user.ID, user.Username, "0", metadata)
+ if err != nil {
+ return fmt.Errorf("failed to log action: %w", err)
+ }
+
timeout := 30
return dockerClient.ContainerStop(ctx, containerID, container.StopOptions{Timeout: &timeout})
}
-func (s *ContainerService) RestartContainer(ctx context.Context, containerID string) error {
+func (s *ContainerService) RestartContainer(ctx context.Context, containerID string, user models.User) error {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
defer dockerClient.Close()
+ metadata := models.JSON{
+ "action": "restart",
+ "containerId": containerID,
+ }
+
+ err = s.eventService.LogContainerEvent(ctx, models.EventTypeContainerRestart, containerID, "name", user.ID, user.Username, "0", metadata)
+ if err != nil {
+ return fmt.Errorf("failed to log action: %w", err)
+ }
+
return dockerClient.ContainerRestart(ctx, containerID, container.StopOptions{})
}
@@ -174,7 +206,7 @@ func (s *ContainerService) UpdateContainerStatus(ctx context.Context, id, status
return nil
}
-func (s *ContainerService) DeleteContainer(ctx context.Context, containerID string, force bool, removeVolumes bool) error {
+func (s *ContainerService) DeleteContainer(ctx context.Context, containerID string, force bool, removeVolumes bool, user models.User) error {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
@@ -190,10 +222,20 @@ func (s *ContainerService) DeleteContainer(ctx context.Context, containerID stri
return fmt.Errorf("failed to delete container: %w", err)
}
+ metadata := models.JSON{
+ "action": "delete",
+ "containerId": containerID,
+ }
+
+ err = s.eventService.LogContainerEvent(ctx, models.EventTypeContainerDelete, containerID, "name", user.ID, user.Username, "0", metadata)
+ if err != nil {
+ return fmt.Errorf("failed to log action: %w", err)
+ }
+
return nil
}
-func (s *ContainerService) CreateContainer(ctx context.Context, config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, containerName string) (*container.InspectResponse, error) {
+func (s *ContainerService) CreateContainer(ctx context.Context, config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, containerName string, user models.User) (*container.InspectResponse, error) {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
@@ -219,6 +261,15 @@ func (s *ContainerService) CreateContainer(ctx context.Context, config *containe
return nil, fmt.Errorf("failed to create container: %w", err)
}
+ metadata := models.JSON{
+ "action": "create",
+ "containerId": resp.ID,
+ }
+
+ if logErr := s.eventService.LogContainerEvent(ctx, models.EventTypeContainerCreate, resp.ID, "name", user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log container stop action: %s\n", logErr)
+ }
+
if err := dockerClient.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {
_ = dockerClient.ContainerRemove(ctx, resp.ID, container.RemoveOptions{Force: true})
return nil, fmt.Errorf("failed to start container: %w", err)
diff --git a/backend/internal/services/event_service.go b/backend/internal/services/event_service.go
new file mode 100644
index 000000000..179eb9b9d
--- /dev/null
+++ b/backend/internal/services/event_service.go
@@ -0,0 +1,433 @@
+package services
+
+import (
+ "context"
+ "fmt"
+ "time"
+
+ "github.com/google/uuid"
+ "github.com/ofkm/arcane-backend/internal/database"
+ "github.com/ofkm/arcane-backend/internal/dto"
+ "github.com/ofkm/arcane-backend/internal/models"
+ "github.com/ofkm/arcane-backend/internal/utils"
+)
+
+type EventService struct {
+ db *database.DB
+}
+
+func NewEventService(db *database.DB) *EventService {
+ return &EventService{db: db}
+}
+
+type CreateEventRequest struct {
+ Type models.EventType `json:"type"`
+ Severity models.EventSeverity `json:"severity,omitempty"`
+ Title string `json:"title"`
+ Description string `json:"description,omitempty"`
+ ResourceType *string `json:"resourceType,omitempty"`
+ ResourceID *string `json:"resourceId,omitempty"`
+ ResourceName *string `json:"resourceName,omitempty"`
+ UserID *string `json:"userId,omitempty"`
+ Username *string `json:"username,omitempty"`
+ EnvironmentID *string `json:"environmentId,omitempty"`
+ Metadata models.JSON `json:"metadata,omitempty"`
+}
+
+func (s *EventService) CreateEvent(ctx context.Context, req CreateEventRequest) (*models.Event, error) {
+ severity := req.Severity
+ if severity == "" {
+ severity = models.EventSeverityInfo
+ }
+
+ event := &models.Event{
+ ID: uuid.New().String(),
+ Type: req.Type,
+ Severity: severity,
+ Title: req.Title,
+ Description: req.Description,
+ ResourceType: req.ResourceType,
+ ResourceID: req.ResourceID,
+ ResourceName: req.ResourceName,
+ UserID: req.UserID,
+ Username: req.Username,
+ EnvironmentID: req.EnvironmentID,
+ Metadata: req.Metadata,
+ Timestamp: time.Now(),
+ BaseModel: models.BaseModel{
+ CreatedAt: time.Now(),
+ },
+ }
+
+ if err := s.db.WithContext(ctx).Create(event).Error; err != nil {
+ return nil, fmt.Errorf("failed to create event: %w", err)
+ }
+
+ return event, nil
+}
+
+func (s *EventService) CreateEventFromDto(ctx context.Context, req dto.CreateEventDto) (*dto.EventDto, error) {
+ severity := models.EventSeverity(req.Severity)
+ if severity == "" {
+ severity = models.EventSeverityInfo
+ }
+
+ metadata := models.JSON{}
+ if req.Metadata != nil {
+ metadata = models.JSON(req.Metadata)
+ }
+
+ createReq := CreateEventRequest{
+ Type: models.EventType(req.Type),
+ Severity: severity,
+ Title: req.Title,
+ Description: req.Description,
+ ResourceType: req.ResourceType,
+ ResourceID: req.ResourceID,
+ ResourceName: req.ResourceName,
+ UserID: req.UserID,
+ Username: req.Username,
+ EnvironmentID: req.EnvironmentID,
+ Metadata: metadata,
+ }
+
+ event, err := s.CreateEvent(ctx, createReq)
+ if err != nil {
+ return nil, err
+ }
+
+ return s.toEventDto(event), nil
+}
+
+func (s *EventService) ListEventsPaginated(ctx context.Context, req utils.SortedPaginationRequest) ([]dto.EventDto, utils.PaginationResponse, error) {
+ var events []models.Event
+
+ query := s.db.WithContext(ctx).Model(&models.Event{})
+
+ // Apply search filter - fix the Where clause structure
+ if req.Search != "" {
+ searchQuery := "%" + req.Search + "%"
+ query = query.Where("title LIKE ? OR description LIKE ? OR resource_name LIKE ? OR username LIKE ?",
+ searchQuery, searchQuery, searchQuery, searchQuery)
+ }
+
+ // Apply filters if any
+ if req.Filters != nil {
+ for key, value := range req.Filters {
+ if value != nil && value != "" {
+ switch key {
+ case "severity":
+ query = query.Where("severity = ?", value)
+ case "type":
+ query = query.Where("type = ?", value)
+ case "resourceType":
+ query = query.Where("resource_type = ?", value)
+ case "username":
+ query = query.Where("username = ?", value)
+ case "environmentId":
+ query = query.Where("environment_id = ?", value)
+ }
+ }
+ }
+ }
+
+ pagination, err := utils.PaginateAndSort(req, query, &events)
+ if err != nil {
+ return nil, utils.PaginationResponse{}, fmt.Errorf("failed to paginate events: %w", err)
+ }
+
+ eventDtos := make([]dto.EventDto, len(events))
+ for i, event := range events {
+ eventDtos[i] = *s.toEventDto(&event)
+ }
+
+ return eventDtos, pagination, nil
+}
+
+func (s *EventService) GetEventsByEnvironmentPaginated(ctx context.Context, environmentID string, req utils.SortedPaginationRequest) ([]dto.EventDto, utils.PaginationResponse, error) {
+ var events []models.Event
+
+ query := s.db.WithContext(ctx).Model(&models.Event{}).Where("environment_id = ?", environmentID)
+
+ // Apply search filter - fix the Where clause structure
+ if req.Search != "" {
+ searchQuery := "%" + req.Search + "%"
+ query = query.Where("title LIKE ? OR description LIKE ? OR resource_name LIKE ? OR username LIKE ?",
+ searchQuery, searchQuery, searchQuery, searchQuery)
+ }
+
+ // Apply filters if any
+ if req.Filters != nil {
+ for key, value := range req.Filters {
+ if value != nil && value != "" {
+ switch key {
+ case "severity":
+ query = query.Where("severity = ?", value)
+ case "type":
+ query = query.Where("type = ?", value)
+ case "resourceType":
+ query = query.Where("resource_type = ?", value)
+ case "username":
+ query = query.Where("username = ?", value)
+ }
+ }
+ }
+ }
+
+ pagination, err := utils.PaginateAndSort(req, query, &events)
+ if err != nil {
+ return nil, utils.PaginationResponse{}, fmt.Errorf("failed to paginate events: %w", err)
+ }
+
+ eventDtos := make([]dto.EventDto, len(events))
+ for i, event := range events {
+ eventDtos[i] = *s.toEventDto(&event)
+ }
+
+ return eventDtos, pagination, nil
+}
+
+func (s *EventService) DeleteEvent(ctx context.Context, eventID string) error {
+ result := s.db.WithContext(ctx).Delete(&models.Event{}, "id = ?", eventID)
+ if result.Error != nil {
+ return fmt.Errorf("failed to delete event: %w", result.Error)
+ }
+ if result.RowsAffected == 0 {
+ return fmt.Errorf("event not found")
+ }
+ return nil
+}
+
+func (s *EventService) DeleteOldEvents(ctx context.Context, olderThan time.Duration) error {
+ cutoff := time.Now().Add(-olderThan)
+ result := s.db.WithContext(ctx).Where("timestamp < ?", cutoff).Delete(&models.Event{})
+ if result.Error != nil {
+ return fmt.Errorf("failed to delete old events: %w", result.Error)
+ }
+ return nil
+}
+
+func (s *EventService) LogContainerEvent(ctx context.Context, eventType models.EventType, containerID, containerName, userID, username, environmentID string, metadata models.JSON) error {
+ title := s.generateEventTitle(eventType, containerName)
+ description := s.generateEventDescription(eventType, "container", containerName)
+ severity := s.getEventSeverity(eventType)
+
+ resourceType := "container"
+ _, err := s.CreateEvent(ctx, CreateEventRequest{
+ Type: eventType,
+ Severity: severity,
+ Title: title,
+ Description: description,
+ ResourceType: &resourceType,
+ ResourceID: &containerID,
+ ResourceName: &containerName,
+ UserID: &userID,
+ Username: &username,
+ EnvironmentID: &environmentID,
+ Metadata: metadata,
+ })
+ return err
+}
+
+func (s *EventService) LogImageEvent(ctx context.Context, eventType models.EventType, imageID, imageName, userID, username, environmentID string, metadata models.JSON) error {
+ title := s.generateEventTitle(eventType, imageName)
+ description := s.generateEventDescription(eventType, "image", imageName)
+ severity := s.getEventSeverity(eventType)
+
+ resourceType := "image"
+ _, err := s.CreateEvent(ctx, CreateEventRequest{
+ Type: eventType,
+ Severity: severity,
+ Title: title,
+ Description: description,
+ ResourceType: &resourceType,
+ ResourceID: &imageID,
+ ResourceName: &imageName,
+ UserID: &userID,
+ Username: &username,
+ EnvironmentID: &environmentID,
+ Metadata: metadata,
+ })
+ return err
+}
+
+func (s *EventService) LogStackEvent(ctx context.Context, eventType models.EventType, stackID, stackName, userID, username, environmentID string, metadata models.JSON) error {
+ title := s.generateEventTitle(eventType, stackName)
+ description := s.generateEventDescription(eventType, "stack", stackName)
+ severity := s.getEventSeverity(eventType)
+
+ resourceType := "stack"
+ _, err := s.CreateEvent(ctx, CreateEventRequest{
+ Type: eventType,
+ Severity: severity,
+ Title: title,
+ Description: description,
+ ResourceType: &resourceType,
+ ResourceID: &stackID,
+ ResourceName: &stackName,
+ UserID: &userID,
+ Username: &username,
+ EnvironmentID: &environmentID,
+ Metadata: metadata,
+ })
+ return err
+}
+
+func (s *EventService) LogUserEvent(ctx context.Context, eventType models.EventType, userID, username string, metadata models.JSON) error {
+ title := s.generateEventTitle(eventType, username)
+ description := s.generateEventDescription(eventType, "user", username)
+ severity := s.getEventSeverity(eventType)
+
+ _, err := s.CreateEvent(ctx, CreateEventRequest{
+ Type: eventType,
+ Severity: severity,
+ Title: title,
+ Description: description,
+ UserID: &userID,
+ Username: &username,
+ Metadata: metadata,
+ })
+ return err
+}
+
+func (s *EventService) LogVolumeEvent(ctx context.Context, eventType models.EventType, volumeID, volumeName, userID, username, environmentID string, metadata models.JSON) error {
+ title := s.generateEventTitle(eventType, volumeName)
+ description := s.generateEventDescription(eventType, "volume", volumeName)
+ severity := s.getEventSeverity(eventType)
+
+ resourceType := "volume"
+ _, err := s.CreateEvent(ctx, CreateEventRequest{
+ Type: eventType,
+ Severity: severity,
+ Title: title,
+ Description: description,
+ ResourceType: &resourceType,
+ ResourceID: &volumeID,
+ ResourceName: &volumeName,
+ UserID: &userID,
+ Username: &username,
+ EnvironmentID: &environmentID,
+ Metadata: metadata,
+ })
+ return err
+}
+
+func (s *EventService) LogNetworkEvent(ctx context.Context, eventType models.EventType, networkID, networkName, userID, username, environmentID string, metadata models.JSON) error {
+ title := s.generateEventTitle(eventType, networkName)
+ description := s.generateEventDescription(eventType, "network", networkName)
+ severity := s.getEventSeverity(eventType)
+
+ resourceType := "network"
+ _, err := s.CreateEvent(ctx, CreateEventRequest{
+ Type: eventType,
+ Severity: severity,
+ Title: title,
+ Description: description,
+ ResourceType: &resourceType,
+ ResourceID: &networkID,
+ ResourceName: &networkName,
+ UserID: &userID,
+ Username: &username,
+ EnvironmentID: &environmentID,
+ Metadata: metadata,
+ })
+ return err
+}
+
+func (s *EventService) toEventDto(event *models.Event) *dto.EventDto {
+ var metadata map[string]interface{}
+ if event.Metadata != nil {
+ metadata = map[string]interface{}(event.Metadata)
+ }
+
+ return &dto.EventDto{
+ ID: event.ID,
+ Type: string(event.Type),
+ Severity: string(event.Severity),
+ Title: event.Title,
+ Description: event.Description,
+ ResourceType: event.ResourceType,
+ ResourceID: event.ResourceID,
+ ResourceName: event.ResourceName,
+ UserID: event.UserID,
+ Username: event.Username,
+ EnvironmentID: event.EnvironmentID,
+ Metadata: metadata,
+ Timestamp: event.Timestamp,
+ CreatedAt: event.CreatedAt,
+ UpdatedAt: event.UpdatedAt,
+ }
+}
+
+func (s *EventService) generateEventTitle(eventType models.EventType, resourceName string) string {
+ switch eventType {
+ case models.EventTypeContainerStart:
+ return fmt.Sprintf("Container started: %s", resourceName)
+ case models.EventTypeContainerStop:
+ return fmt.Sprintf("Container stopped: %s", resourceName)
+ case models.EventTypeContainerRestart:
+ return fmt.Sprintf("Container restarted: %s", resourceName)
+ case models.EventTypeContainerDelete:
+ return fmt.Sprintf("Container deleted: %s", resourceName)
+ case models.EventTypeContainerCreate:
+ return fmt.Sprintf("Container created: %s", resourceName)
+ case models.EventTypeContainerScan:
+ return fmt.Sprintf("Container scanned: %s", resourceName)
+ case models.EventTypeImagePull:
+ return fmt.Sprintf("Image pulled: %s", resourceName)
+ case models.EventTypeImageDelete:
+ return fmt.Sprintf("Image deleted: %s", resourceName)
+ case models.EventTypeImageScan:
+ return fmt.Sprintf("Image scanned: %s", resourceName)
+ case models.EventTypeStackDeploy:
+ return fmt.Sprintf("Stack deployed: %s", resourceName)
+ case models.EventTypeStackDelete:
+ return fmt.Sprintf("Stack deleted: %s", resourceName)
+ case models.EventTypeStackStart:
+ return fmt.Sprintf("Stack started: %s", resourceName)
+ case models.EventTypeStackStop:
+ return fmt.Sprintf("Stack stopped: %s", resourceName)
+ case models.EventTypeUserLogin:
+ return fmt.Sprintf("User logged in: %s", resourceName)
+ case models.EventTypeUserLogout:
+ return fmt.Sprintf("User logged out: %s", resourceName)
+ case models.EventTypeSystemPrune:
+ return "System prune completed"
+ case models.EventTypeVolumeCreate:
+ return fmt.Sprintf("Volume created: %s", resourceName)
+ case models.EventTypeVolumeDelete:
+ return fmt.Sprintf("Volume deleted: %s", resourceName)
+ case models.EventTypeNetworkCreate:
+ return fmt.Sprintf("Network created: %s", resourceName)
+ case models.EventTypeNetworkDelete:
+ return fmt.Sprintf("Network deleted: %s", resourceName)
+ default:
+ return fmt.Sprintf("Event: %s", string(eventType))
+ }
+}
+
+func (s *EventService) generateEventDescription(eventType models.EventType, resourceType, resourceName string) string {
+ switch eventType {
+ case models.EventTypeContainerScan, models.EventTypeImageScan:
+ return fmt.Sprintf("Security scan completed for %s '%s'", resourceType, resourceName)
+ case models.EventTypeVolumeCreate, models.EventTypeVolumeDelete:
+ return fmt.Sprintf("%s operation performed on %s '%s'", string(eventType), resourceType, resourceName)
+ case models.EventTypeNetworkCreate, models.EventTypeNetworkDelete:
+ return fmt.Sprintf("%s operation performed on %s '%s'", string(eventType), resourceType, resourceName)
+ default:
+ return fmt.Sprintf("%s operation performed on %s '%s'", string(eventType), resourceType, resourceName)
+ }
+}
+
+func (s *EventService) getEventSeverity(eventType models.EventType) models.EventSeverity {
+ switch eventType {
+ case models.EventTypeContainerDelete, models.EventTypeImageDelete, models.EventTypeStackDelete, models.EventTypeVolumeDelete, models.EventTypeNetworkDelete:
+ return models.EventSeverityWarning
+ case models.EventTypeContainerStart, models.EventTypeContainerCreate, models.EventTypeImagePull, models.EventTypeStackDeploy, models.EventTypeVolumeCreate, models.EventTypeNetworkCreate:
+ return models.EventSeveritySuccess
+ case models.EventTypeUserLogin, models.EventTypeUserLogout:
+ return models.EventSeverityInfo
+ default:
+ return models.EventSeverityInfo
+ }
+}
diff --git a/backend/internal/services/image_service.go b/backend/internal/services/image_service.go
index 3e7c4471a..954be7ecb 100644
--- a/backend/internal/services/image_service.go
+++ b/backend/internal/services/image_service.go
@@ -29,14 +29,16 @@ type ImageService struct {
dockerService *DockerClientService
imageUpdateService *ImageUpdateService
registryService *ContainerRegistryService
+ eventService *EventService
}
-func NewImageService(db *database.DB, dockerService *DockerClientService, registryService *ContainerRegistryService, imageUpdateService *ImageUpdateService) *ImageService {
+func NewImageService(db *database.DB, dockerService *DockerClientService, registryService *ContainerRegistryService, imageUpdateService *ImageUpdateService, eventService *EventService) *ImageService {
return &ImageService{
db: db,
dockerService: dockerService,
registryService: registryService,
imageUpdateService: imageUpdateService,
+ eventService: eventService,
}
}
@@ -74,13 +76,22 @@ func (s *ImageService) GetImageByID(ctx context.Context, id string) (*image.Insp
return &image, nil
}
-func (s *ImageService) RemoveImage(ctx context.Context, id string, force bool) error {
+func (s *ImageService) RemoveImage(ctx context.Context, id string, force bool, user models.User) error {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
defer dockerClient.Close()
+ // Get image details for logging before deletion
+ imageDetails, inspectErr := dockerClient.ImageInspect(ctx, id)
+ var imageName string
+ if inspectErr == nil && len(imageDetails.RepoTags) > 0 {
+ imageName = imageDetails.RepoTags[0]
+ } else {
+ imageName = id
+ }
+
options := image.RemoveOptions{
Force: force,
PruneChildren: true,
@@ -93,10 +104,20 @@ func (s *ImageService) RemoveImage(ctx context.Context, id string, force bool) e
s.db.WithContext(ctx).Delete(&models.Image{}, "id = ?", id)
+ // Log image deletion event
+ metadata := models.JSON{
+ "action": "delete",
+ "imageId": id,
+ "force": force,
+ }
+ if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageDelete, id, imageName, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log image deletion action: %s\n", logErr)
+ }
+
return nil
}
-func (s *ImageService) PullImage(ctx context.Context, imageName string, progressWriter io.Writer) error {
+func (s *ImageService) PullImage(ctx context.Context, imageName string, progressWriter io.Writer, user models.User) error {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
@@ -155,6 +176,15 @@ func (s *ImageService) PullImage(ctx context.Context, imageName string, progress
}
}
+ // Log image pull event
+ metadata := models.JSON{
+ "action": "pull",
+ "imageName": imageName,
+ }
+ if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImagePull, "", imageName, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log image pull action: %s\n", logErr)
+ }
+
return nil
}
@@ -275,6 +305,17 @@ func (s *ImageService) PruneImages(ctx context.Context, dangling bool) (*image.P
return nil, fmt.Errorf("failed to prune images: %w", err)
}
+ // Log image prune event using system user since this is typically a system operation
+ metadata := models.JSON{
+ "action": "prune",
+ "dangling": dangling,
+ "imagesDeleted": len(report.ImagesDeleted),
+ "spaceReclaimed": report.SpaceReclaimed,
+ }
+ if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageDelete, "", "bulk_prune", systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log image prune action: %s\n", logErr)
+ }
+
return &report, nil
}
diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.go
index 40b52ded9..1427da5f8 100644
--- a/backend/internal/services/image_update_service.go
+++ b/backend/internal/services/image_update_service.go
@@ -20,6 +20,7 @@ type ImageUpdateService struct {
settingsService *SettingsService
registryService *ContainerRegistryService
dockerService *DockerClientService
+ eventService *EventService
}
type UpdateResult struct {
@@ -70,12 +71,13 @@ type AvailableVersions struct {
Latest string `json:"latest,omitempty"`
}
-func NewImageUpdateService(db *database.DB, settingsService *SettingsService, registryService *ContainerRegistryService, dockerService *DockerClientService) *ImageUpdateService {
+func NewImageUpdateService(db *database.DB, settingsService *SettingsService, registryService *ContainerRegistryService, dockerService *DockerClientService, eventService *EventService) *ImageUpdateService {
return &ImageUpdateService{
db: db,
settingsService: settingsService,
registryService: registryService,
dockerService: dockerService,
+ eventService: eventService,
}
}
@@ -100,6 +102,20 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
CheckTime: time.Now(),
ResponseTimeMs: int(time.Since(startTime).Milliseconds()),
}
+
+ // Log error event
+ metadata := models.JSON{
+ "action": "check_update",
+ "imageRef": imageRef,
+ "error": err.Error(),
+ "checkType": "digest",
+ }
+ if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageScan, "", imageRef, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "Failed to log image update check error event",
+ slog.String("imageRef", imageRef),
+ slog.String("error", logErr.Error()))
+ }
+
if saveErr := s.saveUpdateResult(ctx, imageRef, result); saveErr != nil {
slog.WarnContext(ctx, "Failed to save update result",
slog.String("imageRef", imageRef),
@@ -116,6 +132,20 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
CheckTime: time.Now(),
ResponseTimeMs: int(time.Since(startTime).Milliseconds()),
}
+
+ // Log error event
+ metadata := models.JSON{
+ "action": "check_update",
+ "imageRef": imageRef,
+ "error": err.Error(),
+ "checkType": "tag",
+ }
+ if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageScan, "", imageRef, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "Failed to log image update check error event",
+ slog.String("imageRef", imageRef),
+ slog.String("error", logErr.Error()))
+ }
+
if saveErr := s.saveUpdateResult(ctx, imageRef, result); saveErr != nil {
slog.WarnContext(ctx, "Failed to save update result",
slog.String("imageRef", imageRef),
@@ -125,6 +155,23 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
}
if tagResult.HasUpdate {
tagResult.ResponseTimeMs = int(time.Since(startTime).Milliseconds())
+
+ // Log successful tag update check
+ metadata := models.JSON{
+ "action": "check_update",
+ "imageRef": imageRef,
+ "hasUpdate": true,
+ "updateType": "tag",
+ "currentVersion": tagResult.CurrentVersion,
+ "latestVersion": tagResult.LatestVersion,
+ "responseTimeMs": tagResult.ResponseTimeMs,
+ }
+ if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageScan, "", imageRef, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "Failed to log image update check event",
+ slog.String("imageRef", imageRef),
+ slog.String("error", logErr.Error()))
+ }
+
if saveErr := s.saveUpdateResult(ctx, imageRef, tagResult); saveErr != nil {
slog.WarnContext(ctx, "Failed to save update result",
slog.String("imageRef", imageRef),
@@ -135,6 +182,23 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
}
digestResult.ResponseTimeMs = int(time.Since(startTime).Milliseconds())
+
+ // Log successful digest update check
+ metadata := models.JSON{
+ "action": "check_update",
+ "imageRef": imageRef,
+ "hasUpdate": digestResult.HasUpdate,
+ "updateType": "digest",
+ "currentDigest": digestResult.CurrentDigest,
+ "latestDigest": digestResult.LatestDigest,
+ "responseTimeMs": digestResult.ResponseTimeMs,
+ }
+ if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageScan, "", imageRef, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "Failed to log image update check event",
+ slog.String("imageRef", imageRef),
+ slog.String("error", logErr.Error()))
+ }
+
if saveErr := s.saveUpdateResult(ctx, imageRef, digestResult); saveErr != nil {
slog.WarnContext(ctx, "Failed to save update result",
slog.String("imageRef", imageRef),
@@ -613,6 +677,17 @@ func (s *ImageUpdateService) isSpecialTag(tag string) bool {
func (s *ImageUpdateService) CheckImageUpdateByID(ctx context.Context, imageID string) (*UpdateResult, error) {
imageRef, err := s.getImageRefByID(ctx, imageID)
if err != nil {
+ // Log error event
+ metadata := models.JSON{
+ "action": "check_update_by_id",
+ "imageID": imageID,
+ "error": err.Error(),
+ }
+ if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageScan, imageID, "", systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "Failed to log image update check by ID error event",
+ slog.String("imageID", imageID),
+ slog.String("error", logErr.Error()))
+ }
return nil, fmt.Errorf("failed to get image reference: %w", err)
}
@@ -735,12 +810,41 @@ func (s *ImageUpdateService) CheckAllImages(ctx context.Context, limit int) (map
}
func (s *ImageUpdateService) TriggerBulkUpdateCheck(ctx context.Context, imageIDs []string) error {
+ // Log bulk update check start
+ metadata := models.JSON{
+ "action": "bulk_update_check",
+ "imageIDs": imageIDs,
+ "count": len(imageIDs),
+ }
+ if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageScan, "", "bulk_check", systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "Failed to log bulk update check start event",
+ slog.String("error", logErr.Error()))
+ }
+
+ successCount := 0
+ errorCount := 0
+
for _, imageID := range imageIDs {
_, err := s.CheckImageUpdateByID(ctx, imageID)
if err != nil {
+ errorCount++
continue
}
+ successCount++
}
+
+ // Log bulk update check completion
+ completionMetadata := models.JSON{
+ "action": "bulk_update_check_complete",
+ "totalImages": len(imageIDs),
+ "successCount": successCount,
+ "errorCount": errorCount,
+ }
+ if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageScan, "", "bulk_check_complete", systemUser.ID, systemUser.Username, "0", completionMetadata); logErr != nil {
+ slog.WarnContext(ctx, "Failed to log bulk update check completion event",
+ slog.String("error", logErr.Error()))
+ }
+
return nil
}
diff --git a/backend/internal/services/network_service.go b/backend/internal/services/network_service.go
index de521c885..504e00b98 100644
--- a/backend/internal/services/network_service.go
+++ b/backend/internal/services/network_service.go
@@ -8,16 +8,22 @@ import (
"github.com/docker/docker/api/types/filters"
"github.com/docker/docker/api/types/network"
"github.com/ofkm/arcane-backend/internal/database"
+ "github.com/ofkm/arcane-backend/internal/models"
"github.com/ofkm/arcane-backend/internal/utils"
)
type NetworkService struct {
db *database.DB
dockerService *DockerClientService
+ eventService *EventService
}
-func NewNetworkService(db *database.DB, dockerService *DockerClientService) *NetworkService {
- return &NetworkService{db: db, dockerService: dockerService}
+func NewNetworkService(db *database.DB, dockerService *DockerClientService, eventService *EventService) *NetworkService {
+ return &NetworkService{
+ db: db,
+ dockerService: dockerService,
+ eventService: eventService,
+ }
}
// ListNetworks returns live Docker networks
@@ -64,7 +70,7 @@ func (s *NetworkService) GetNetworkByID(ctx context.Context, id string) (*networ
}
// CreateNetwork creates a Docker network
-func (s *NetworkService) CreateNetwork(ctx context.Context, name string, options network.CreateOptions) (*network.CreateResponse, error) {
+func (s *NetworkService) CreateNetwork(ctx context.Context, name string, options network.CreateOptions, user models.User) (*network.CreateResponse, error) {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
@@ -76,26 +82,54 @@ func (s *NetworkService) CreateNetwork(ctx context.Context, name string, options
return nil, fmt.Errorf("failed to create network: %w", err)
}
+ // Log network creation event
+ metadata := models.JSON{
+ "action": "create",
+ "driver": options.Driver,
+ "name": name,
+ }
+ if logErr := s.eventService.LogNetworkEvent(ctx, models.EventTypeNetworkCreate, response.ID, name, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log network creation action: %s\n", logErr)
+ }
+
return &response, nil
}
// RemoveNetwork removes a Docker network
-func (s *NetworkService) RemoveNetwork(ctx context.Context, id string) error {
+func (s *NetworkService) RemoveNetwork(ctx context.Context, id string, user models.User) error {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
defer dockerClient.Close()
+ // Get network details for logging before deletion
+ networkDetails, inspectErr := dockerClient.NetworkInspect(ctx, id, network.InspectOptions{})
+ var networkName string
+ if inspectErr == nil {
+ networkName = networkDetails.Name
+ } else {
+ networkName = id
+ }
+
if err := dockerClient.NetworkRemove(ctx, id); err != nil {
return fmt.Errorf("failed to remove network: %w", err)
}
+ // Log network deletion event
+ metadata := models.JSON{
+ "action": "delete",
+ "networkId": id,
+ }
+ if logErr := s.eventService.LogNetworkEvent(ctx, models.EventTypeNetworkDelete, id, networkName, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log network deletion action: %s\n", logErr)
+ }
+
return nil
}
// ConnectContainer connects a container to a network
-func (s *NetworkService) ConnectContainer(ctx context.Context, networkID, containerID string, config *network.EndpointSettings) error {
+func (s *NetworkService) ConnectContainer(ctx context.Context, networkID, containerID string, config *network.EndpointSettings, user models.User) error {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
@@ -106,21 +140,56 @@ func (s *NetworkService) ConnectContainer(ctx context.Context, networkID, contai
return fmt.Errorf("failed to connect container to network: %w", err)
}
+ // Get network name for logging
+ networkDetails, _ := dockerClient.NetworkInspect(ctx, networkID, network.InspectOptions{})
+ networkName := networkDetails.Name
+ if networkName == "" {
+ networkName = networkID
+ }
+
+ // Log network connect event
+ metadata := models.JSON{
+ "action": "connect_container",
+ "networkId": networkID,
+ "containerId": containerID,
+ }
+ if logErr := s.eventService.LogNetworkEvent(ctx, models.EventTypeNetworkCreate, networkID, networkName, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log network connect action: %s\n", logErr)
+ }
+
return nil
}
// DisconnectContainer disconnects a container from a network
-func (s *NetworkService) DisconnectContainer(ctx context.Context, networkID, containerID string, force bool) error {
+func (s *NetworkService) DisconnectContainer(ctx context.Context, networkID, containerID string, force bool, user models.User) error {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
defer dockerClient.Close()
+ // Get network name for logging
+ networkDetails, _ := dockerClient.NetworkInspect(ctx, networkID, network.InspectOptions{})
+ networkName := networkDetails.Name
+ if networkName == "" {
+ networkName = networkID
+ }
+
if err := dockerClient.NetworkDisconnect(ctx, networkID, containerID, force); err != nil {
return fmt.Errorf("failed to disconnect container from network: %w", err)
}
+ // Log network disconnect event
+ metadata := models.JSON{
+ "action": "disconnect_container",
+ "networkId": networkID,
+ "containerId": containerID,
+ "force": force,
+ }
+ if logErr := s.eventService.LogNetworkEvent(ctx, models.EventTypeNetworkDelete, networkID, networkName, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log network disconnect action: %s\n", logErr)
+ }
+
return nil
}
@@ -139,6 +208,15 @@ func (s *NetworkService) PruneNetworks(ctx context.Context) (*network.PruneRepor
return nil, fmt.Errorf("failed to prune networks: %w", err)
}
+ // Log network prune event using system user since this is typically a system operation
+ metadata := models.JSON{
+ "action": "prune",
+ "networksDeleted": len(report.NetworksDeleted),
+ }
+ if logErr := s.eventService.LogNetworkEvent(ctx, models.EventTypeNetworkDelete, "", "bulk_prune", systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log network prune action: %s\n", logErr)
+ }
+
return &report, nil
}
diff --git a/backend/internal/services/stack_service.go b/backend/internal/services/stack_service.go
index 6d465c8eb..07a40c5a6 100644
--- a/backend/internal/services/stack_service.go
+++ b/backend/internal/services/stack_service.go
@@ -32,12 +32,14 @@ type StackServiceInfo struct {
type StackService struct {
db *database.DB
settingsService *SettingsService
+ eventService *EventService
}
-func NewStackService(db *database.DB, settingsService *SettingsService) *StackService {
+func NewStackService(db *database.DB, settingsService *SettingsService, eventService *EventService) *StackService {
return &StackService{
db: db,
settingsService: settingsService,
+ eventService: eventService,
}
}
@@ -51,7 +53,7 @@ type StackInfo struct {
ComposeYAML string `json:"compose_yaml,omitempty"`
}
-func (s *StackService) CreateStack(ctx context.Context, name, composeContent string, envContent *string) (*models.Stack, error) {
+func (s *StackService) CreateStack(ctx context.Context, name, composeContent string, envContent *string, user models.User) (*models.Stack, error) {
stackID := uuid.New().String()
folderName := s.sanitizeStackName(name)
@@ -92,10 +94,21 @@ func (s *StackService) CreateStack(ctx context.Context, name, composeContent str
return nil, fmt.Errorf("failed to save stack files: %w", err)
}
+ // Log stack creation event
+ metadata := models.JSON{
+ "action": "create",
+ "stackId": stackID,
+ "stackName": name,
+ "path": stackPath,
+ }
+ if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackCreate, stackID, name, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log stack creation action: %s\n", logErr)
+ }
+
return stack, nil
}
-func (s *StackService) DeployStack(ctx context.Context, stackID string) error {
+func (s *StackService) DeployStack(ctx context.Context, stackID string, user models.User) error {
stack, err := s.GetStackByID(ctx, stackID)
if err != nil {
return fmt.Errorf("failed to get stack: %w", err)
@@ -128,10 +141,20 @@ func (s *StackService) DeployStack(ctx context.Context, stackID string) error {
return fmt.Errorf("failed to deploy stack: %w\nCommand output: %s", err, string(output))
}
+ // Log stack deployment event
+ metadata := models.JSON{
+ "action": "deploy",
+ "stackId": stackID,
+ "stackName": stack.Name,
+ }
+ if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackDeploy, stackID, stack.Name, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log stack deployment action: %s\n", logErr)
+ }
+
return s.updateStackStatusAndCounts(ctx, stackID, models.StackStatusRunning)
}
-func (s *StackService) StopStack(ctx context.Context, stackID string) error {
+func (s *StackService) StopStack(ctx context.Context, stackID string, user models.User) error {
stack, err := s.GetStackByID(ctx, stackID)
if err != nil {
return err
@@ -158,11 +181,21 @@ func (s *StackService) StopStack(ctx context.Context, stackID string) error {
return fmt.Errorf("failed to stop stack: %w\nOutput: %s", err, string(output))
}
+ // Log stack stop event
+ metadata := models.JSON{
+ "action": "stop",
+ "stackId": stackID,
+ "stackName": stack.Name,
+ }
+ if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackStop, stackID, stack.Name, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log stack stop action: %s\n", logErr)
+ }
+
// Update status and counts after successful stop
return s.updateStackStatusAndCounts(ctx, stackID, models.StackStatusStopped)
}
-func (s *StackService) DownStack(ctx context.Context, stackID string) error {
+func (s *StackService) DownStack(ctx context.Context, stackID string, user models.User) error {
stack, err := s.GetStackByID(ctx, stackID)
if err != nil {
return err
@@ -189,6 +222,16 @@ func (s *StackService) DownStack(ctx context.Context, stackID string) error {
return fmt.Errorf("failed to bring down stack: %w\nOutput: %s", err, string(output))
}
+ // Log stack down event
+ metadata := models.JSON{
+ "action": "down",
+ "stackId": stackID,
+ "stackName": stack.Name,
+ }
+ if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackStop, stackID, stack.Name, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log stack down action: %s\n", logErr)
+ }
+
return s.updateStackStatusAndCounts(ctx, stackID, models.StackStatusStopped)
}
@@ -348,7 +391,7 @@ func (s *StackService) getProcessedComposeYAML(ctx context.Context, stackID stri
return string(projectYAML), nil
}
-func (s *StackService) RestartStack(ctx context.Context, stackID string) error {
+func (s *StackService) RestartStack(ctx context.Context, stackID string, user models.User) error {
stack, err := s.GetStackByID(ctx, stackID)
if err != nil {
return err
@@ -375,6 +418,16 @@ func (s *StackService) RestartStack(ctx context.Context, stackID string) error {
return fmt.Errorf("failed to restart stack: %w\nOutput: %s", err, string(output))
}
+ // Log stack restart event
+ metadata := models.JSON{
+ "action": "restart",
+ "stackId": stackID,
+ "stackName": stack.Name,
+ }
+ if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackStart, stackID, stack.Name, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log stack restart action: %s\n", logErr)
+ }
+
// Update status and counts after restart
return s.updateStackStatusAndCounts(ctx, stackID, models.StackStatusRunning)
}
@@ -514,7 +567,7 @@ func (s *StackService) SyncAllStacksFromFilesystem(ctx context.Context) error {
if errors.Is(err, gorm.ErrRecordNotFound) {
// Auto-import external stack
- if _, importErr := s.ImportExternalStack(ctx, dirName, dirName); importErr != nil {
+ if _, importErr := s.ImportExternalStack(ctx, dirName, dirName, systemUser); importErr != nil {
fmt.Printf("Warning: failed to auto-import stack %s: %v\n", dirName, importErr)
}
} else if err == nil {
@@ -649,14 +702,14 @@ func (s *StackService) GetStackContent(ctx context.Context, stackID string) (com
return composeContent, envContent, nil
}
-func (s *StackService) DeleteStack(ctx context.Context, stackID string) error {
+func (s *StackService) DeleteStack(ctx context.Context, stackID string, user models.User) error {
stack, err := s.GetStackByID(ctx, stackID)
if err != nil {
return err
}
if stack.Status == models.StackStatusRunning {
- if err := s.DownStack(ctx, stackID); err != nil {
+ if err := s.DownStack(ctx, stackID, systemUser); err != nil {
fmt.Printf("Warning: failed to stop stack before deletion: %v\n", err)
}
}
@@ -669,16 +722,27 @@ func (s *StackService) DeleteStack(ctx context.Context, stackID string) error {
fmt.Printf("Warning: failed to remove stack directory %s: %v\n", stack.Path, err)
}
+ // Log stack deletion event
+ metadata := models.JSON{
+ "action": "delete",
+ "stackId": stackID,
+ "stackName": stack.Name,
+ "path": stack.Path,
+ }
+ if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackDelete, stackID, stack.Name, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log stack deletion action: %s\n", logErr)
+ }
+
return nil
}
-func (s *StackService) DestroyStack(ctx context.Context, stackID string, removeFiles, removeVolumes bool) error {
+func (s *StackService) DestroyStack(ctx context.Context, stackID string, removeFiles, removeVolumes bool, user models.User) error {
stack, err := s.GetStackByID(ctx, stackID)
if err != nil {
return err
}
- if err := s.DownStack(ctx, stackID); err != nil {
+ if err := s.DownStack(ctx, stackID, systemUser); err != nil {
fmt.Printf("Warning: failed to bring down stack: %v\n", err)
}
@@ -704,19 +768,47 @@ func (s *StackService) DestroyStack(ctx context.Context, stackID string, removeF
}
}
+ // Log stack destroy event
+ metadata := models.JSON{
+ "action": "destroy",
+ "stackId": stackID,
+ "stackName": stack.Name,
+ "removeFiles": removeFiles,
+ "removeVolumes": removeVolumes,
+ }
+ if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackDelete, stackID, stack.Name, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log stack destroy action: %s\n", logErr)
+ }
+
return nil
}
-func (s *StackService) RedeployStack(ctx context.Context, stackID string, profiles []string, envOverrides map[string]string) error {
+func (s *StackService) RedeployStack(ctx context.Context, stackID string, profiles []string, envOverrides map[string]string, user models.User) error {
+ stack, err := s.GetStackByID(ctx, stackID)
+ if err != nil {
+ return err
+ }
+
if err := s.PullStackImages(ctx, stackID); err != nil {
fmt.Printf("Warning: failed to pull images: %v\n", err)
}
- if err := s.StopStack(ctx, stackID); err != nil {
+ if err := s.StopStack(ctx, stackID, systemUser); err != nil {
return fmt.Errorf("failed to stop stack for redeploy: %w", err)
}
- return s.DeployStack(ctx, stackID)
+ // Log stack redeploy event
+ metadata := models.JSON{
+ "action": "redeploy",
+ "stackId": stackID,
+ "stackName": stack.Name,
+ "profiles": profiles,
+ }
+ if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackDeploy, stackID, stack.Name, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log stack redeploy action: %s\n", logErr)
+ }
+
+ return s.DeployStack(ctx, stackID, systemUser)
}
// DiscoverExternalStacks scans the configured stacks directory and returns any
@@ -1232,8 +1324,8 @@ func (s *StackService) getServiceCounts(services []StackServiceInfo) (total int,
}
// ImportExternalStack creates a DB record for a compose directory
-// that isn’t yet tracked by Arcane.
-func (s *StackService) ImportExternalStack(ctx context.Context, dirName, stackName string) (*models.Stack, error) {
+// that isn't yet tracked by Arcane.
+func (s *StackService) ImportExternalStack(ctx context.Context, dirName, stackName string, user models.User) (*models.Stack, error) {
// base path that DiscoverExternalStacks scanned
stacksDir, err := s.getStacksDirectory(ctx)
if err != nil {
@@ -1248,7 +1340,7 @@ func (s *StackService) ImportExternalStack(ctx context.Context, dirName, stackNa
// probe live status & counts
status, svcCount, runCount, err := s.getLiveStackStatus(ctx, path, stackName)
if err != nil {
- // we’ll still import it, but mark unknown
+ // we'll still import it, but mark unknown
status = models.StackStatusUnknown
}
@@ -1266,5 +1358,19 @@ func (s *StackService) ImportExternalStack(ctx context.Context, dirName, stackNa
if err := s.db.WithContext(ctx).Create(stack).Error; err != nil {
return nil, fmt.Errorf("failed to import external stack: %w", err)
}
+
+ // Log stack import event
+ metadata := models.JSON{
+ "action": "import",
+ "stackId": stack.ID,
+ "stackName": stackName,
+ "dirName": dirName,
+ "path": path,
+ "isExternal": true,
+ }
+ if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackCreate, stack.ID, stackName, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log stack import action: %s\n", logErr)
+ }
+
return stack, nil
}
diff --git a/backend/internal/services/system_service.go b/backend/internal/services/system_service.go
index 43dc6acd7..65b24773d 100644
--- a/backend/internal/services/system_service.go
+++ b/backend/internal/services/system_service.go
@@ -9,6 +9,7 @@ import (
"github.com/docker/docker/api/types/filters"
"github.com/ofkm/arcane-backend/internal/database"
"github.com/ofkm/arcane-backend/internal/dto"
+ "github.com/ofkm/arcane-backend/internal/models"
)
type SystemService struct {
@@ -59,6 +60,11 @@ type ContainerActionResult struct {
Errors []string `json:"errors,omitempty"`
}
+var systemUser = models.User{
+ Username: "System",
+ ID: "0",
+}
+
func (s *SystemService) PruneAll(ctx context.Context, req dto.PruneSystemDto) (*PruneAllResult, error) {
slog.InfoContext(ctx, "Starting selective prune operation",
slog.Bool("containers", req.Containers),
@@ -159,7 +165,7 @@ func (s *SystemService) StartAllContainers(ctx context.Context) (*ContainerActio
for _, container := range containers {
if container.State != "running" {
- if err := s.containerService.StartContainer(ctx, container.ID); err != nil {
+ if err := s.containerService.StartContainer(ctx, container.ID, systemUser); err != nil {
result.Failed = append(result.Failed, container.ID)
result.Errors = append(result.Errors, fmt.Sprintf("Failed to start container %s: %v", container.ID, err))
result.Success = false
@@ -186,7 +192,7 @@ func (s *SystemService) StartAllStoppedContainers(ctx context.Context) (*Contain
for _, container := range containers {
if container.State == "exited" {
- if err := s.containerService.StartContainer(ctx, container.ID); err != nil {
+ if err := s.containerService.StartContainer(ctx, container.ID, systemUser); err != nil {
result.Failed = append(result.Failed, container.ID)
result.Errors = append(result.Errors, fmt.Sprintf("Failed to start container %s: %v", container.ID, err))
result.Success = false
@@ -212,7 +218,7 @@ func (s *SystemService) StopAllContainers(ctx context.Context) (*ContainerAction
}
for _, cont := range containers {
- if err := s.containerService.StopContainer(ctx, cont.ID); err != nil {
+ if err := s.containerService.StopContainer(ctx, cont.ID, systemUser); err != nil {
result.Failed = append(result.Failed, cont.ID)
result.Errors = append(result.Errors, fmt.Sprintf("Failed to stop container %s: %v", cont.ID, err))
result.Success = false
diff --git a/backend/internal/services/volume_service.go b/backend/internal/services/volume_service.go
index fd02fc432..4fcb4b67b 100644
--- a/backend/internal/services/volume_service.go
+++ b/backend/internal/services/volume_service.go
@@ -17,10 +17,15 @@ import (
type VolumeService struct {
db *database.DB
dockerService *DockerClientService
+ eventService *EventService
}
-func NewVolumeService(db *database.DB, dockerService *DockerClientService) *VolumeService {
- return &VolumeService{db: db, dockerService: dockerService}
+func NewVolumeService(db *database.DB, dockerService *DockerClientService, eventService *EventService) *VolumeService {
+ return &VolumeService{
+ db: db,
+ dockerService: dockerService,
+ eventService: eventService,
+ }
}
func (s *VolumeService) ListVolumes(ctx context.Context) ([]volume.Volume, error) {
@@ -59,7 +64,7 @@ func (s *VolumeService) GetVolumeByName(ctx context.Context, name string) (*volu
return &vol, nil
}
-func (s *VolumeService) CreateVolume(ctx context.Context, options volume.CreateOptions) (*volume.Volume, error) {
+func (s *VolumeService) CreateVolume(ctx context.Context, options volume.CreateOptions, user models.User) (*volume.Volume, error) {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
@@ -82,10 +87,20 @@ func (s *VolumeService) CreateVolume(ctx context.Context, options volume.CreateO
s.db.WithContext(ctx).Create(dbVolume)
}
+ // Log volume creation event
+ metadata := models.JSON{
+ "action": "create",
+ "driver": vol.Driver,
+ "name": vol.Name,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeCreate, vol.Name, vol.Name, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log volume creation action: %s\n", logErr)
+ }
+
return &vol, nil
}
-func (s *VolumeService) DeleteVolume(ctx context.Context, name string, force bool) error {
+func (s *VolumeService) DeleteVolume(ctx context.Context, name string, force bool, user models.User) error {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
@@ -100,6 +115,16 @@ func (s *VolumeService) DeleteVolume(ctx context.Context, name string, force boo
s.db.WithContext(ctx).Delete(&models.Volume{}, "name = ?", name)
}
+ // Log volume deletion event
+ metadata := models.JSON{
+ "action": "delete",
+ "name": name,
+ "force": force,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeDelete, name, name, user.ID, user.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log volume deletion action: %s\n", logErr)
+ }
+
return nil
}
@@ -117,6 +142,16 @@ func (s *VolumeService) PruneVolumes(ctx context.Context) (*volume.PruneReport,
return nil, fmt.Errorf("failed to prune volumes: %w", err)
}
+ // Log volume prune event using system user since this is typically a system operation
+ metadata := models.JSON{
+ "action": "prune",
+ "volumesDeleted": len(report.VolumesDeleted),
+ "spaceReclaimed": report.SpaceReclaimed,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeDelete, "", "bulk_prune", systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
+ fmt.Printf("Could not log volume prune action: %s\n", logErr)
+ }
+
return &report, nil
}
diff --git a/backend/resources/migrations/postgres/001_initial_schema.down.sql b/backend/resources/migrations/postgres/001_initial_schema.down.sql
index 47e3cad9c..ef08827be 100644
--- a/backend/resources/migrations/postgres/001_initial_schema.down.sql
+++ b/backend/resources/migrations/postgres/001_initial_schema.down.sql
@@ -11,6 +11,7 @@ DROP INDEX IF EXISTS idx_user_sessions_token;
DROP INDEX IF EXISTS idx_user_sessions_user_id;
DROP INDEX IF EXISTS idx_settings_public;
DROP INDEX IF EXISTS idx_settings_key;
+DROP INDEX IF EXISTS idx_events_timestamp;
DROP TABLE IF EXISTS auto_update_records;
DROP TABLE IF EXISTS container_registries;
diff --git a/backend/resources/migrations/postgres/002_create_events_table.down.sql b/backend/resources/migrations/postgres/002_create_events_table.down.sql
new file mode 100644
index 000000000..d11cf905c
--- /dev/null
+++ b/backend/resources/migrations/postgres/002_create_events_table.down.sql
@@ -0,0 +1,9 @@
+DROP INDEX IF EXISTS idx_events_timestamp;
+DROP INDEX IF EXISTS idx_events_environment_id;
+DROP INDEX IF EXISTS idx_events_user_id;
+DROP INDEX IF EXISTS idx_events_resource_id;
+DROP INDEX IF EXISTS idx_events_resource_type;
+DROP INDEX IF EXISTS idx_events_severity;
+DROP INDEX IF EXISTS idx_events_type;
+
+DROP TABLE IF EXISTS events;
\ No newline at end of file
diff --git a/backend/resources/migrations/postgres/002_create_events_table.up.sql b/backend/resources/migrations/postgres/002_create_events_table.up.sql
new file mode 100644
index 000000000..79a8c5d18
--- /dev/null
+++ b/backend/resources/migrations/postgres/002_create_events_table.up.sql
@@ -0,0 +1,26 @@
+CREATE TABLE IF NOT EXISTS events (
+ id TEXT PRIMARY KEY,
+ type TEXT NOT NULL,
+ severity TEXT NOT NULL DEFAULT 'info',
+ title TEXT NOT NULL,
+ description TEXT,
+ resource_type TEXT,
+ resource_id TEXT,
+ resource_name TEXT,
+ user_id TEXT,
+ username TEXT,
+ environment_id TEXT,
+ metadata JSONB,
+ timestamp TIMESTAMPTZ NOT NULL,
+ created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMPTZ,
+ FOREIGN KEY (environment_id) REFERENCES environments(id) ON DELETE SET NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
+CREATE INDEX IF NOT EXISTS idx_events_severity ON events(severity);
+CREATE INDEX IF NOT EXISTS idx_events_resource_type ON events(resource_type);
+CREATE INDEX IF NOT EXISTS idx_events_resource_id ON events(resource_id);
+CREATE INDEX IF NOT EXISTS idx_events_user_id ON events(user_id);
+CREATE INDEX IF NOT EXISTS idx_events_environment_id ON events(environment_id);
+CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
\ No newline at end of file
diff --git a/backend/resources/migrations/sqlite/002_create_events_table.down.sql b/backend/resources/migrations/sqlite/002_create_events_table.down.sql
new file mode 100644
index 000000000..d11cf905c
--- /dev/null
+++ b/backend/resources/migrations/sqlite/002_create_events_table.down.sql
@@ -0,0 +1,9 @@
+DROP INDEX IF EXISTS idx_events_timestamp;
+DROP INDEX IF EXISTS idx_events_environment_id;
+DROP INDEX IF EXISTS idx_events_user_id;
+DROP INDEX IF EXISTS idx_events_resource_id;
+DROP INDEX IF EXISTS idx_events_resource_type;
+DROP INDEX IF EXISTS idx_events_severity;
+DROP INDEX IF EXISTS idx_events_type;
+
+DROP TABLE IF EXISTS events;
\ No newline at end of file
diff --git a/backend/resources/migrations/sqlite/002_create_events_table.up.sql b/backend/resources/migrations/sqlite/002_create_events_table.up.sql
new file mode 100644
index 000000000..a81f30d6a
--- /dev/null
+++ b/backend/resources/migrations/sqlite/002_create_events_table.up.sql
@@ -0,0 +1,26 @@
+CREATE TABLE IF NOT EXISTS events (
+ id TEXT PRIMARY KEY,
+ type TEXT NOT NULL,
+ severity TEXT NOT NULL DEFAULT 'info',
+ title TEXT NOT NULL,
+ description TEXT,
+ resource_type TEXT,
+ resource_id TEXT,
+ resource_name TEXT,
+ user_id TEXT,
+ username TEXT,
+ environment_id TEXT,
+ metadata TEXT,
+ timestamp DATETIME NOT NULL,
+ created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ updated_at DATETIME,
+ FOREIGN KEY (environment_id) REFERENCES environments(id) ON DELETE SET NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
+CREATE INDEX IF NOT EXISTS idx_events_severity ON events(severity);
+CREATE INDEX IF NOT EXISTS idx_events_resource_type ON events(resource_type);
+CREATE INDEX IF NOT EXISTS idx_events_resource_id ON events(resource_id);
+CREATE INDEX IF NOT EXISTS idx_events_user_id ON events(user_id);
+CREATE INDEX IF NOT EXISTS idx_events_environment_id ON events(environment_id);
+CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
\ No newline at end of file
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 1f2e14128..b0b2feacf 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "arcane",
- "version": "0.15.1",
+ "version": "1.0.0-preview.1",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "arcane",
- "version": "0.15.1",
+ "version": "1.0.0-preview.1",
"dependencies": {
"@codemirror/lang-yaml": "^6.1.2",
"@codemirror/legacy-modes": "^6.5.1",
@@ -26,13 +26,13 @@
"@eslint/compat": "^1.3.1",
"@eslint/js": "^9.31.0",
"@internationalized/date": "^3.8.2",
- "@lucide/svelte": "^0.515.0",
+ "@lucide/svelte": "^0.525.0",
"@sveltejs/kit": "^2.25.2",
"@sveltejs/vite-plugin-svelte": "^6.1.0",
"@tailwindcss/vite": "^4.1.11",
"@types/dockerode": "^3.3.42",
"@types/js-yaml": "^4.0.9",
- "bits-ui": "^2.8.11",
+ "bits-ui": "^2.9.1",
"clsx": "^2.1.1",
"eslint": "^9.31.0",
"eslint-plugin-svelte": "^3.11.0",
@@ -1171,9 +1171,9 @@
}
},
"node_modules/@lucide/svelte": {
- "version": "0.515.0",
- "resolved": "https://registry.npmjs.org/@lucide/svelte/-/svelte-0.515.0.tgz",
- "integrity": "sha512-CEAyqcZmNBfYzVgaRmK2RFJP5tnbXxekRyDk0XX/eZQRfsJmkDvmQwXNX8C869BgNeryzmrRyjHhUL6g9ZOHNA==",
+ "version": "0.525.0",
+ "resolved": "https://registry.npmjs.org/@lucide/svelte/-/svelte-0.525.0.tgz",
+ "integrity": "sha512-dyUxkXzepagLUzL8jHQNdeH286nC66ClLACsg+Neu/bjkRJWPWMzkT+H0DKlE70QdkicGCfs1ZGmXCc351hmZA==",
"dev": true,
"license": "ISC",
"peerDependencies": {
@@ -2512,9 +2512,9 @@
"license": "MIT"
},
"node_modules/bits-ui": {
- "version": "2.8.11",
- "resolved": "https://registry.npmjs.org/bits-ui/-/bits-ui-2.8.11.tgz",
- "integrity": "sha512-lKN9rAk69my6j7H1D4B87r8LrHuEtfEsf1xCixBj9yViql2BdI3f04HyyyT7T1GOCpgb9+8b0B+nm3LN81Konw==",
+ "version": "2.9.1",
+ "resolved": "https://registry.npmjs.org/bits-ui/-/bits-ui-2.9.1.tgz",
+ "integrity": "sha512-Fdtc1TKppfEio6fl0XzkrDG8DSvfbYJdrOh4j5KzaGh0kYA6BskMGIXL4JmsZxUS+O5ESFypNjrQ9z9qs3xAdQ==",
"dev": true,
"license": "MIT",
"dependencies": {
diff --git a/frontend/package.json b/frontend/package.json
index e3a26c608..a0cc6e23d 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -31,13 +31,13 @@
"@eslint/compat": "^1.3.1",
"@eslint/js": "^9.31.0",
"@internationalized/date": "^3.8.2",
- "@lucide/svelte": "^0.515.0",
+ "@lucide/svelte": "^0.525.0",
"@sveltejs/kit": "^2.25.2",
"@sveltejs/vite-plugin-svelte": "^6.1.0",
"@tailwindcss/vite": "^4.1.11",
"@types/dockerode": "^3.3.42",
"@types/js-yaml": "^4.0.9",
- "bits-ui": "^2.8.11",
+ "bits-ui": "^2.9.1",
"clsx": "^2.1.1",
"eslint": "^9.31.0",
"eslint-plugin-svelte": "^3.11.0",
diff --git a/frontend/src/lib/components/ui/button/button.svelte b/frontend/src/lib/components/ui/button/button.svelte
index cee02c35f..4daf4535c 100644
--- a/frontend/src/lib/components/ui/button/button.svelte
+++ b/frontend/src/lib/components/ui/button/button.svelte
@@ -1,128 +1,80 @@
-<!--
- Installed from @ieedan/shadcn-svelte-extras
--->
-
<script lang="ts" module>
- import type { WithChildren, WithoutChildren } from 'bits-ui';
- import type { HTMLAnchorAttributes, HTMLButtonAttributes } from 'svelte/elements';
- import { type VariantProps, tv } from 'tailwind-variants';
+ import { cn, type WithElementRef } from "$lib/utils.js";
+ import type { HTMLAnchorAttributes, HTMLButtonAttributes } from "svelte/elements";
+ import { type VariantProps, tv } from "tailwind-variants";
export const buttonVariants = tv({
- base: "aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive focus-visible:border-ring focus-visible:ring-ring/50 relative inline-flex shrink-0 items-center justify-center gap-2 overflow-hidden rounded-md text-sm font-medium whitespace-nowrap outline-hidden transition-all select-none focus-visible:ring-[3px] disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+ base: "focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive inline-flex shrink-0 items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium outline-none transition-all focus-visible:ring-[3px] disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 [&_svg:not([class*='size-'])]:size-4 [&_svg]:pointer-events-none [&_svg]:shrink-0",
variants: {
variant: {
- default: 'bg-primary text-primary-foreground hover:bg-primary/90 shadow-2xs',
+ default: "bg-primary text-primary-foreground shadow-xs hover:bg-primary/90",
destructive:
- 'bg-destructive hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:bg-destructive/60 dark:focus-visible:ring-destructive/40 text-white shadow-2xs',
+ "bg-destructive shadow-xs hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60 text-white",
outline:
- 'bg-background hover:bg-accent hover:text-accent-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 border shadow-2xs',
- secondary: 'bg-secondary text-secondary-foreground hover:bg-secondary/80 shadow-2xs',
- ghost: 'hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50',
- link: 'text-primary underline-offset-4 hover:underline'
+ "bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50 border",
+ secondary: "bg-secondary text-secondary-foreground shadow-xs hover:bg-secondary/80",
+ ghost: "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
+ link: "text-primary underline-offset-4 hover:underline",
},
size: {
- default: 'h-9 px-4 py-2 has-[>svg]:px-3',
- sm: 'h-8 gap-1.5 rounded-md px-3 has-[>svg]:px-2.5',
- lg: 'h-10 rounded-md px-6 has-[>svg]:px-4',
- icon: 'size-9'
- }
+ default: "h-9 px-4 py-2 has-[>svg]:px-3",
+ sm: "h-8 gap-1.5 rounded-md px-3 has-[>svg]:px-2.5",
+ lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
+ icon: "size-9",
+ },
},
defaultVariants: {
- variant: 'default',
- size: 'default'
- }
+ variant: "default",
+ size: "default",
+ },
});
- export type ButtonVariant = VariantProps<typeof buttonVariants>['variant'];
- export type ButtonSize = VariantProps<typeof buttonVariants>['size'];
-
- export type ButtonPropsWithoutHTML = WithChildren<{
- ref?: HTMLElement | null;
- variant?: ButtonVariant;
- size?: ButtonSize;
- loading?: boolean;
- onClickPromise?: (
- e: MouseEvent & {
- currentTarget: EventTarget & HTMLButtonElement;
- }
- ) => Promise<void>;
- }>;
+ export type ButtonVariant = VariantProps<typeof buttonVariants>["variant"];
+ export type ButtonSize = VariantProps<typeof buttonVariants>["size"];
- export type AnchorElementProps = ButtonPropsWithoutHTML &
- WithoutChildren<Omit<HTMLAnchorAttributes, 'href' | 'type'>> & {
- href: HTMLAnchorAttributes['href'];
- type?: never;
- disabled?: HTMLButtonAttributes['disabled'];
+ export type ButtonProps = WithElementRef<HTMLButtonAttributes> &
+ WithElementRef<HTMLAnchorAttributes> & {
+ variant?: ButtonVariant;
+ size?: ButtonSize;
};
-
- export type ButtonElementProps = ButtonPropsWithoutHTML &
- WithoutChildren<Omit<HTMLButtonAttributes, 'type' | 'href'>> & {
- type?: HTMLButtonAttributes['type'];
- href?: never;
- disabled?: HTMLButtonAttributes['disabled'];
- };
-
- export type ButtonProps = AnchorElementProps | ButtonElementProps;
</script>
<script lang="ts">
- import { cn } from '$lib/utils/utils.js';
- import LoaderCircleIcon from '@lucide/svelte/icons/loader-circle';
-
let {
+ class: className,
+ variant = "default",
+ size = "default",
ref = $bindable(null),
- variant = 'default',
- size = 'default',
href = undefined,
- type = 'button',
- loading = false,
- disabled = false,
- tabindex = 0,
- onclick,
- onClickPromise,
- class: className,
+ type = "button",
+ disabled,
children,
- ...rest
+ ...restProps
}: ButtonProps = $props();
</script>
-<!-- This approach to disabled links is inspired by bits-ui see: https://github.com/huntabyte/bits-ui/pull/1055 -->
-<svelte:element
- this={href ? 'a' : 'button'}
- {...rest}
- data-slot="button"
- type={href ? undefined : type}
- href={href && !disabled ? href : undefined}
- disabled={href ? undefined : disabled || loading}
- aria-disabled={href ? disabled : undefined}
- role={href && disabled ? 'link' : undefined}
- tabindex={href && disabled ? -1 : tabindex}
- class={cn(buttonVariants({ variant, size }), className)}
- bind:this={ref}
- onclick={async (
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- e: any
- ) => {
- onclick?.(e);
-
- if (type === undefined) return;
-
- if (onClickPromise) {
- loading = true;
-
- await onClickPromise(e);
-
- loading = false;
- }
- }}
->
- {#if type !== undefined && loading}
- <div class="absolute flex size-full place-items-center justify-center bg-inherit">
- <div class="flex animate-spin place-items-center justify-center">
- <LoaderCircleIcon class="size-4" />
- </div>
- </div>
- <span class="sr-only">Loading</span>
- {/if}
- {@render children?.()}
-</svelte:element>
+{#if href}
+ <a
+ bind:this={ref}
+ data-slot="button"
+ class={cn(buttonVariants({ variant, size }), className)}
+ href={disabled ? undefined : href}
+ aria-disabled={disabled}
+ role={disabled ? "link" : undefined}
+ tabindex={disabled ? -1 : undefined}
+ {...restProps}
+ >
+ {@render children?.()}
+ </a>
+{:else}
+ <button
+ bind:this={ref}
+ data-slot="button"
+ class={cn(buttonVariants({ variant, size }), className)}
+ {type}
+ {disabled}
+ {...restProps}
+ >
+ {@render children?.()}
+ </button>
+{/if}
diff --git a/frontend/src/lib/components/ui/button/index.ts b/frontend/src/lib/components/ui/button/index.ts
index 34c3e590c..fb585d768 100644
--- a/frontend/src/lib/components/ui/button/index.ts
+++ b/frontend/src/lib/components/ui/button/index.ts
@@ -1,16 +1,9 @@
-/*
- Installed from @ieedan/shadcn-svelte-extras
-*/
-
import Root, {
type ButtonProps,
type ButtonSize,
type ButtonVariant,
- type AnchorElementProps,
- type ButtonElementProps,
- type ButtonPropsWithoutHTML,
- buttonVariants
-} from './button.svelte';
+ buttonVariants,
+} from "./button.svelte";
export {
Root,
@@ -21,7 +14,4 @@ export {
type ButtonProps,
type ButtonSize,
type ButtonVariant,
- type AnchorElementProps,
- type ButtonElementProps,
- type ButtonPropsWithoutHTML
};
diff --git a/frontend/src/lib/components/ui/dropdown-button/dropdown-button-content.svelte b/frontend/src/lib/components/ui/dropdown-button/dropdown-button-content.svelte
index 92999a739..69797fe62 100644
--- a/frontend/src/lib/components/ui/dropdown-button/dropdown-button-content.svelte
+++ b/frontend/src/lib/components/ui/dropdown-button/dropdown-button-content.svelte
@@ -1,30 +1,34 @@
<script lang="ts" module>
- import { cn, type WithElementRef } from '$lib/utils.js';
- import { DropdownMenu as DropdownMenuPrimitive } from 'bits-ui';
+ import { cn } from "$lib/utils.js";
+ import { DropdownMenu as DropdownMenuPrimitive } from "bits-ui";
- export type DropdownButtonContentProps = DropdownMenuPrimitive.ContentProps;
+ export type DropdownButtonContentProps = DropdownMenuPrimitive.ContentProps;
</script>
<script lang="ts">
- let {
- ref = $bindable(null),
- sideOffset = 4,
- portalProps,
- class: className,
- ...restProps
- }: DropdownMenuPrimitive.ContentProps & {
- portalProps?: DropdownMenuPrimitive.PortalProps;
- } = $props();
+ let {
+ ref = $bindable(null),
+ sideOffset = 4,
+ portalProps,
+ class: className,
+ children,
+ ...restProps
+ }: DropdownMenuPrimitive.ContentProps & {
+ portalProps?: DropdownMenuPrimitive.PortalProps;
+ } = $props();
</script>
<DropdownMenuPrimitive.Portal {...portalProps}>
- <DropdownMenuPrimitive.Content
- bind:ref
- {sideOffset}
- class={cn(
- 'bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 min-w-32 overflow-hidden rounded-md border p-1 shadow-md outline-none',
- className
- )}
- {...restProps}
- />
+ <DropdownMenuPrimitive.Content
+ bind:ref
+ {sideOffset}
+ class={cn(
+ "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 min-w-32 overflow-hidden rounded-md border p-1 shadow-md outline-none",
+ className
+ )}
+ {...restProps}
+ >
+ <DropdownMenuPrimitive.Arrow />
+ {@render children?.()}
+ </DropdownMenuPrimitive.Content>
</DropdownMenuPrimitive.Portal>
diff --git a/frontend/src/lib/components/ui/dropdown-button/dropdown-button-item.svelte b/frontend/src/lib/components/ui/dropdown-button/dropdown-button-item.svelte
index 9d51edccb..a5ea6fa2a 100644
--- a/frontend/src/lib/components/ui/dropdown-button/dropdown-button-item.svelte
+++ b/frontend/src/lib/components/ui/dropdown-button/dropdown-button-item.svelte
@@ -5,11 +5,4 @@
let { ref = $bindable(null), class: className, ...restProps }: DropdownMenuPrimitive.ItemProps = $props();
</script>
-<DropdownMenuPrimitive.Item
- bind:ref
- class={cn(
- 'data-highlighted:bg-accent data-highlighted:text-accent-foreground relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm transition-colors outline-none select-none data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0',
- className
- )}
- {...restProps}
-/>
+<DropdownMenuPrimitive.Item bind:ref class={cn('data-highlighted:bg-accent data-highlighted:text-accent-foreground relative flex cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none transition-colors data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0', className)} {...restProps} />
diff --git a/frontend/src/lib/components/ui/dropdown-button/dropdown-button-separator.svelte b/frontend/src/lib/components/ui/dropdown-button/dropdown-button-separator.svelte
index a80137d96..a22739f84 100644
--- a/frontend/src/lib/components/ui/dropdown-button/dropdown-button-separator.svelte
+++ b/frontend/src/lib/components/ui/dropdown-button/dropdown-button-separator.svelte
@@ -1,13 +1,22 @@
<script lang="ts" module>
- import { cn, type WithElementRef } from '$lib/utils.js';
+ import { cn } from "$lib/utils.js";
- export type DropdownButtonSeparatorProps = DropdownMenuPrimitive.SeparatorProps;
+ export type DropdownButtonSeparatorProps =
+ DropdownMenuPrimitive.SeparatorProps;
</script>
<script lang="ts">
- import { DropdownMenu as DropdownMenuPrimitive } from 'bits-ui';
+ import { DropdownMenu as DropdownMenuPrimitive } from "bits-ui";
- let { ref = $bindable(null), class: className, ...restProps }: DropdownMenuPrimitive.SeparatorProps = $props();
+ let {
+ ref = $bindable(null),
+ class: className,
+ ...restProps
+ }: DropdownMenuPrimitive.SeparatorProps = $props();
</script>
-<DropdownMenuPrimitive.Separator bind:ref class={cn('bg-muted -mx-1 my-1 h-px', className)} {...restProps} />
+<DropdownMenuPrimitive.Separator
+ bind:ref
+ class={cn("bg-muted -mx-1 my-1 h-px", className)}
+ {...restProps}
+/>
diff --git a/frontend/src/lib/components/ui/dropdown-button/dropdown-button-trigger.svelte b/frontend/src/lib/components/ui/dropdown-button/dropdown-button-trigger.svelte
index 473660c03..91ab61c20 100644
--- a/frontend/src/lib/components/ui/dropdown-button/dropdown-button-trigger.svelte
+++ b/frontend/src/lib/components/ui/dropdown-button/dropdown-button-trigger.svelte
@@ -1,25 +1,25 @@
<script lang="ts" module>
- import { cn, type WithElementRef } from '$lib/utils.js';
- import type { HTMLButtonAttributes } from 'svelte/elements';
- import { buttonVariants, type ButtonVariant, type ButtonSize } from '$lib/components/ui/button/button.svelte';
+ import { cn, type WithElementRef } from '$lib/utils.js';
+ import type { HTMLButtonAttributes } from 'svelte/elements';
+ import { buttonVariants, type ButtonVariant, type ButtonSize } from '$lib/components/ui/button/button.svelte';
- export type DropdownButtonTriggerProps = WithElementRef<HTMLButtonAttributes> & {
- variant?: ButtonVariant;
- size?: ButtonSize;
- builders?: any[];
- };
+ export type DropdownButtonTriggerProps = WithElementRef<HTMLButtonAttributes> & {
+ variant?: ButtonVariant;
+ size?: ButtonSize;
+ builders?: any[];
+ };
</script>
<script lang="ts">
- import { ChevronDown } from '@lucide/svelte';
+ import ChevronDown from '@lucide/svelte/icons/chevron-down';
- let { class: className, variant = 'default', size = 'default', ref = $bindable(null), type = 'button', disabled, builders = [], children, ...restProps }: DropdownButtonTriggerProps = $props();
+ let { class: className, variant = 'default', size = 'default', ref = $bindable(null), type = 'button', disabled, builders = [], children, ...restProps }: DropdownButtonTriggerProps = $props();
</script>
-<button bind:this={ref} use:builders[0] data-slot="dropdown-button-trigger" class={cn(buttonVariants({ variant, size }), 'border-l-background/20 rounded-l-none border-l px-2', className)} {type} {disabled} {...restProps}>
- {#if children}
- {@render children()}
- {:else}
- <ChevronDown class="size-4" />
- {/if}
+<button bind:this={ref} use:builders[0] data-slot="dropdown-button-trigger" class={cn(buttonVariants({ variant, size }), 'rounded-l-none px-2 border-l border-l-background/20', className)} {type} {disabled} {...restProps}>
+ {#if children}
+ {@render children()}
+ {:else}
+ <ChevronDown class="size-4" />
+ {/if}
</button>
diff --git a/frontend/src/lib/components/ui/dropdown-button/dropdown-button.svelte b/frontend/src/lib/components/ui/dropdown-button/dropdown-button.svelte
index de378a57d..b9c5e5648 100644
--- a/frontend/src/lib/components/ui/dropdown-button/dropdown-button.svelte
+++ b/frontend/src/lib/components/ui/dropdown-button/dropdown-button.svelte
@@ -1,14 +1,94 @@
<script lang="ts" module>
- import { cn, type WithElementRef } from '$lib/utils.js';
- import type { HTMLAttributes } from 'svelte/elements';
+ import { cn, type WithElementRef } from '$lib/utils.js';
+ import type { HTMLAttributes } from 'svelte/elements';
+ import type { ButtonVariant, ButtonSize } from '$lib/components/ui/button/button.svelte';
- export type DropdownButtonProps = WithElementRef<HTMLAttributes<HTMLDivElement>>;
+ export type DropdownButtonOption = {
+ label: string;
+ value: string;
+ disabled?: boolean;
+ onclick?: () => void;
+ };
+
+ export type DropdownButtonProps = WithElementRef<HTMLAttributes<HTMLDivElement>> & {
+ // Simple mode props
+ mainButtonText?: string;
+ options?: DropdownButtonOption[];
+ onMainButtonClick?: () => void;
+ variant?: ButtonVariant;
+ size?: ButtonSize;
+ align?: 'start' | 'center' | 'end';
+ disabled?: boolean;
+ // Composable mode
+ simple?: boolean;
+ };
</script>
<script lang="ts">
- let { class: className, ref = $bindable(null), children, ...restProps }: DropdownButtonProps = $props();
+ import { DropdownMenu as DropdownMenuPrimitive } from 'bits-ui';
+ import Main from './dropdown-button-main.svelte';
+ import Trigger from './dropdown-button-trigger.svelte';
+ import Content from './dropdown-button-content.svelte';
+ import Item from './dropdown-button-item.svelte';
+
+ let {
+ class: className,
+ ref = $bindable(null),
+ children,
+ // Simple mode props
+ mainButtonText,
+ options,
+ onMainButtonClick,
+ variant = 'default',
+ size = 'default',
+ align = 'end',
+ disabled = false,
+ simple = false,
+ ...restProps
+ }: DropdownButtonProps = $props();
+
+ // Determine if we're in simple mode
+ const isSimpleMode = $derived(simple || (mainButtonText && options));
+
+ function handleMainClick() {
+ if (onMainButtonClick) {
+ onMainButtonClick();
+ }
+ }
+
+ function handleOptionClick(option: DropdownButtonOption) {
+ if (option.onclick) {
+ option.onclick();
+ }
+ }
</script>
-<div bind:this={ref} data-slot="dropdown-button" class={cn('flex', className)} {...restProps}>
- {@render children?.()}
-</div>
+{#if isSimpleMode && mainButtonText && options}
+ <!-- Simple Mode: All-in-one component -->
+ <DropdownMenuPrimitive.Root>
+ <div bind:this={ref} data-slot="dropdown-button" class={cn('flex', className)} {...restProps}>
+ <Main {variant} {size} {disabled} onclick={handleMainClick}>
+ {mainButtonText}
+ </Main>
+
+ <DropdownMenuPrimitive.Trigger>
+ {#snippet child({ props })}
+ <Trigger {variant} {size} {disabled} {...props} />
+ {/snippet}
+ </DropdownMenuPrimitive.Trigger>
+ </div>
+
+ <Content {align} class="min-w-[200px]">
+ {#each options as option (option.value)}
+ <Item disabled={option.disabled} onclick={() => handleOptionClick(option)}>
+ {option.label}
+ </Item>
+ {/each}
+ </Content>
+ </DropdownMenuPrimitive.Root>
+{:else}
+ <!-- Composable Mode: Just the wrapper div -->
+ <div bind:this={ref} data-slot="dropdown-button" class={cn('flex', className)} {...restProps}>
+ {@render children?.()}
+ </div>
+{/if}
diff --git a/frontend/src/lib/components/ui/dropdown-button/index.ts b/frontend/src/lib/components/ui/dropdown-button/index.ts
index 3898acffa..739ff7f55 100644
--- a/frontend/src/lib/components/ui/dropdown-button/index.ts
+++ b/frontend/src/lib/components/ui/dropdown-button/index.ts
@@ -10,21 +10,24 @@ const DropdownRoot = DropdownMenuPrimitive.Root;
const DropdownTrigger = DropdownMenuPrimitive.Trigger;
export {
- Root,
- Main,
- Trigger,
- Content,
- Item,
- Separator,
- DropdownRoot,
- DropdownTrigger,
- //
- Root as DropdownButton,
- Main as DropdownButtonMain,
- Trigger as DropdownButtonTrigger,
- Content as DropdownButtonContent,
- Item as DropdownButtonItem,
- Separator as DropdownButtonSeparator,
- DropdownRoot as DropdownButtonRoot,
- DropdownTrigger as DropdownButtonPrimitiveTrigger
+ Root,
+ Main,
+ Trigger,
+ Content,
+ Item,
+ Separator,
+ DropdownRoot,
+ DropdownTrigger,
+ //
+ Root as DropdownButton,
+ Main as DropdownButtonMain,
+ Trigger as DropdownButtonTrigger,
+ Content as DropdownButtonContent,
+ Item as DropdownButtonItem,
+ Separator as DropdownButtonSeparator,
+ DropdownRoot as DropdownButtonRoot,
+ DropdownTrigger as DropdownButtonPrimitiveTrigger,
};
+
+// Re-export types
+export type { DropdownButtonOption, DropdownButtonProps } from './dropdown-button.svelte';
diff --git a/frontend/src/lib/config/sidebar-config.ts b/frontend/src/lib/config/sidebar-config.ts
index 7ac703a42..bd99de38b 100644
--- a/frontend/src/lib/config/sidebar-config.ts
+++ b/frontend/src/lib/config/sidebar-config.ts
@@ -12,7 +12,8 @@ import {
UserIcon,
Shield,
ComputerIcon,
- LockKeyholeIcon
+ LockKeyholeIcon,
+ LucideAlarmClock
} from '@lucide/svelte';
export type SidebarItem = {
@@ -58,6 +59,7 @@ export const sidebarItems: Record<string, SidebarItem[]> = {
items: [
{ title: 'General', url: '/settings/general', icon: SettingsIcon },
{ title: 'Docker', url: '/settings/docker', icon: DatabaseIcon },
+ { title: 'Events', url: '/settings/events', icon: LucideAlarmClock },
{ title: 'Users', url: '/settings/users', icon: UserIcon },
{ title: 'Security', url: '/settings/security', icon: Shield }
]
diff --git a/frontend/src/lib/services/api/event-api-service.ts b/frontend/src/lib/services/api/event-api-service.ts
new file mode 100644
index 000000000..e26b2358d
--- /dev/null
+++ b/frontend/src/lib/services/api/event-api-service.ts
@@ -0,0 +1,141 @@
+import BaseAPIService from './api-service';
+import type {
+ PaginationRequest,
+ SortRequest,
+ PaginatedApiResponse
+} from '$lib/types/pagination.type';
+import type { Event, CreateEvent } from '$lib/types/event.type';
+
+export default class EventAPIService extends BaseAPIService {
+ async list(filters?: Record<string, string>) {
+ return this.handleResponse(this.api.get('/events', { params: { filters } }));
+ }
+
+ async getEvents(
+ pagination?: PaginationRequest,
+ sort?: SortRequest,
+ search?: string,
+ filters?: Record<string, string>
+ ): Promise<PaginatedApiResponse<Event>> {
+ const params: any = {};
+
+ if (pagination) {
+ params.page = pagination.page;
+ params.limit = pagination.limit;
+ }
+
+ if (sort) {
+ params.sortColumn = sort.column;
+ params.sortDirection = sort.direction;
+ }
+
+ if (search) {
+ params.search = search;
+ }
+
+ if (filters) {
+ Object.entries(filters).forEach(([key, value]) => {
+ if (value !== undefined && value !== null && value !== '') {
+ params[key] = value;
+ }
+ });
+ }
+
+ return this.handleResponse(this.api.get('/events', { params }));
+ }
+
+ async listPaginated(
+ pagination?: PaginationRequest,
+ sort?: SortRequest,
+ search?: string,
+ filters?: Record<string, string>
+ ): Promise<PaginatedApiResponse<Event>> {
+ const params: any = {};
+
+ if (pagination) {
+ params['pagination[page]'] = pagination.page;
+ params['pagination[limit]'] = pagination.limit;
+ }
+
+ if (sort) {
+ params['sort[column]'] = sort.column;
+ params['sort[direction]'] = sort.direction;
+ }
+
+ if (search) {
+ params.search = search;
+ }
+
+ if (filters) {
+ Object.entries(filters).forEach(([key, value]) => {
+ if (value !== undefined && value !== null && value !== '') {
+ params[key] = value;
+ }
+ });
+ }
+
+ return this.handleResponse(this.api.get('/events', { params }));
+ }
+
+ async listByEnvironmentPaginated(
+ environmentId: string,
+ pagination?: PaginationRequest,
+ sort?: SortRequest,
+ search?: string,
+ filters?: Record<string, string>
+ ): Promise<PaginatedApiResponse<Event>> {
+ const params: any = {};
+
+ if (pagination) {
+ params.page = pagination.page;
+ params.limit = pagination.limit;
+ }
+
+ if (sort) {
+ params.sortColumn = sort.column;
+ params.sortDirection = sort.direction;
+ }
+
+ if (search) {
+ params.search = search;
+ }
+
+ if (filters) {
+ Object.entries(filters).forEach(([key, value]) => {
+ if (value !== undefined && value !== null && value !== '') {
+ params[key] = value;
+ }
+ });
+ }
+
+ return this.handleResponse(this.api.get(`/environments/${environmentId}/events`, { params }));
+ }
+
+ async get(id: string): Promise<Event> {
+ return this.handleResponse(this.api.get(`/events/${id}`));
+ }
+
+ async create(event: CreateEvent): Promise<Event> {
+ return this.handleResponse(this.api.post('/events', event));
+ }
+
+ async delete(id: string): Promise<void> {
+ return this.handleResponse(this.api.delete(`/events/${id}`));
+ }
+
+ async deleteOldEvents(olderThanDays: number): Promise<void> {
+ return this.handleResponse(
+ this.api.delete('/events/cleanup', {
+ params: { olderThanDays }
+ })
+ );
+ }
+
+ async getEventTypes(): Promise<string[]> {
+ return this.handleResponse(this.api.get('/events/types'));
+ }
+
+ async getEventSeverities(): Promise<string[]> {
+ return this.handleResponse(this.api.get('/events/severities'));
+ }
+}
diff --git a/frontend/src/lib/services/api/index.ts b/frontend/src/lib/services/api/index.ts
index 6e6d0d5ca..0c9ac95b2 100644
--- a/frontend/src/lib/services/api/index.ts
+++ b/frontend/src/lib/services/api/index.ts
@@ -12,6 +12,7 @@ import ConverterAPIService from './converter-api-service';
import ContainerRegistryAPIService from './container-registry-api-service';
import { EnvironmentAPIService } from './environment-api-service';
import EnvironmentManagementAPIService from './environment-management-api-service';
+import EventAPIService from './event-api-service';
export const imageAPI = new ImageAPIService();
export const imageUpdateAPI = new ImageUpdateAPIService();
@@ -27,6 +28,7 @@ export const containerRegistryAPI = new ContainerRegistryAPIService();
export const autoUpdateAPI = new AutoUpdateAPIService();
export const environmentAPI = new EnvironmentAPIService();
export const environmentManagementAPI = new EnvironmentManagementAPIService();
+export const eventAPI = new EventAPIService();
interface APIServices {
image: ImageAPIService;
@@ -43,6 +45,7 @@ interface APIServices {
autoUpdate: AutoUpdateAPIService;
environment: EnvironmentAPIService;
environmentManagement: EnvironmentManagementAPIService;
+ event: EventAPIService;
}
const apiServices: APIServices = {
@@ -59,7 +62,8 @@ const apiServices: APIServices = {
containerRegistry: containerRegistryAPI,
autoUpdate: autoUpdateAPI,
environment: environmentAPI,
- environmentManagement: environmentManagementAPI
+ environmentManagement: environmentManagementAPI,
+ event: eventAPI
};
export default apiServices;
diff --git a/frontend/src/lib/types/event.type.ts b/frontend/src/lib/types/event.type.ts
new file mode 100644
index 000000000..4a7f69342
--- /dev/null
+++ b/frontend/src/lib/types/event.type.ts
@@ -0,0 +1,41 @@
+export interface Event {
+ id: string;
+ type: string;
+ severity: 'info' | 'warning' | 'error' | 'success';
+ title: string;
+ description?: string;
+ resourceType?: string;
+ resourceId?: string;
+ resourceName?: string;
+ userId?: string;
+ username?: string;
+ environmentId?: string;
+ metadata?: Record<string, any>;
+ timestamp: string;
+ createdAt: string;
+ updatedAt?: string;
+}
+
+export interface CreateEvent {
+ type: string;
+ severity?: 'info' | 'warning' | 'error' | 'success';
+ title: string;
+ description?: string;
+ resourceType?: string;
+ resourceId?: string;
+ resourceName?: string;
+ userId?: string;
+ username?: string;
+ environmentId?: string;
+ metadata?: Record<string, any>;
+}
+
+export interface EventListResponse {
+ events: Event[];
+ total: number;
+ page: number;
+ pageSize: number;
+ totalPages: number;
+ hasNext: boolean;
+ hasPrevious: boolean;
+}
diff --git a/frontend/src/routes/settings/events/+page.svelte b/frontend/src/routes/settings/events/+page.svelte
new file mode 100644
index 000000000..2715e7600
--- /dev/null
+++ b/frontend/src/routes/settings/events/+page.svelte
@@ -0,0 +1,140 @@
+<script lang="ts">
+ import { Activity, RefreshCw } from '@lucide/svelte';
+ import { toast } from 'svelte-sonner';
+ import { tryCatch } from '$lib/utils/try-catch';
+ import { handleApiResultWithCallbacks } from '$lib/utils/api.util';
+ import type { PageData } from './$types';
+ import StatCard from '$lib/components/stat-card.svelte';
+ import type { Event } from '$lib/types/event.type';
+ import { eventAPI } from '$lib/services/api';
+ import type { SearchPaginationSortRequest, Paginated } from '$lib/types/pagination.type';
+ import EventTable from './event-table.svelte';
+
+ let { data }: { data: PageData } = $props();
+
+ let events = $state<Paginated<Event>>(data.events);
+ let selectedIds = $state<string[]>([]);
+ let requestOptions = $state<SearchPaginationSortRequest>(data.eventRequestOptions);
+
+ let isLoading = $state({
+ refreshing: false,
+ deleting: false
+ });
+
+ const infoEvents = $derived(
+ events?.data?.filter((e: Event) => e.severity === 'info').length || 0
+ );
+ const warningEvents = $derived(
+ events?.data?.filter((e: Event) => e.severity === 'warning').length || 0
+ );
+ const errorEvents = $derived(
+ events?.data?.filter((e: Event) => e.severity === 'error').length || 0
+ );
+ const successEvents = $derived(
+ events?.data?.filter((e: Event) => e.severity === 'success').length || 0
+ );
+ const totalEvents = $derived(events?.pagination?.totalItems || 0);
+
+ async function loadEvents() {
+ try {
+ isLoading.refreshing = true;
+ const response = await eventAPI.listPaginated(
+ requestOptions.pagination,
+ requestOptions.sort,
+ requestOptions.search,
+ requestOptions.filters
+ );
+ events = response;
+ } catch (err) {
+ console.error('Failed to load events:', err);
+ toast.error('Failed to load events');
+ events = {
+ data: [],
+ pagination: {
+ totalPages: 0,
+ totalItems: 0,
+ currentPage: 1,
+ itemsPerPage: 20
+ }
+ };
+ } finally {
+ isLoading.refreshing = false;
+ }
+ }
+
+ async function onRefresh(options: SearchPaginationSortRequest) {
+ requestOptions = options;
+ await loadEvents();
+ return events;
+ }
+
+ async function onEventsChanged() {
+ await refreshEvents();
+ }
+
+ async function refreshEvents() {
+ isLoading.refreshing = true;
+ try {
+ await loadEvents();
+ } catch (error) {
+ console.error('Failed to refresh events:', error);
+ toast.error('Failed to refresh events');
+ } finally {
+ isLoading.refreshing = false;
+ }
+ }
+</script>
+
+<div class="flex h-full flex-col space-y-6">
+ <div class="flex items-center justify-between">
+ <div class="space-y-1">
+ <h2 class="text-2xl font-semibold tracking-tight">Event Log</h2>
+ <p class="text-sm text-muted-foreground">Monitor events that have taken place in Arcane.</p>
+ </div>
+ </div>
+
+ <div class="grid gap-4 md:grid-cols-5">
+ <StatCard
+ title="Total Events"
+ value={totalEvents}
+ icon={Activity}
+ subtitle="All recorded events"
+ />
+ <StatCard
+ title="Info"
+ value={infoEvents}
+ icon={Activity}
+ iconColor="text-blue-500"
+ bgColor="bg-blue-500/10"
+ subtitle="Information events"
+ />
+ <StatCard
+ title="Success"
+ value={successEvents}
+ icon={Activity}
+ iconColor="text-green-500"
+ bgColor="bg-green-500/10"
+ subtitle="Successful operations"
+ />
+ <StatCard
+ title="Warning"
+ value={warningEvents}
+ icon={Activity}
+ iconColor="text-yellow-500"
+ bgColor="bg-yellow-500/10"
+ subtitle="Warning events"
+ />
+ <StatCard
+ title="Error"
+ value={errorEvents}
+ icon={Activity}
+ iconColor="text-red-500"
+ bgColor="bg-red-500/10"
+ subtitle="Error events"
+ />
+ </div>
+
+ <div class="flex-1 overflow-hidden">
+ <EventTable {events} bind:selectedIds bind:requestOptions {onRefresh} {onEventsChanged} />
+ </div>
+</div>
diff --git a/frontend/src/routes/settings/events/+page.ts b/frontend/src/routes/settings/events/+page.ts
new file mode 100644
index 000000000..f5288854a
--- /dev/null
+++ b/frontend/src/routes/settings/events/+page.ts
@@ -0,0 +1,25 @@
+import { eventAPI } from '$lib/services/api';
+import type { SearchPaginationSortRequest } from '$lib/types/pagination.type';
+import type { PageLoad } from './$types';
+
+export const load: PageLoad = async () => {
+ const eventRequestOptions: SearchPaginationSortRequest = {
+ pagination: {
+ page: 1,
+ limit: 20
+ },
+ sort: {
+ column: 'timestamp',
+ direction: 'desc' as const
+ }
+ };
+
+ const events = await eventAPI.listPaginated(
+ eventRequestOptions.pagination,
+ eventRequestOptions.sort,
+ eventRequestOptions.search,
+ eventRequestOptions.filters
+ );
+
+ return { events, eventRequestOptions };
+};
diff --git a/frontend/src/routes/settings/events/event-table.svelte b/frontend/src/routes/settings/events/event-table.svelte
new file mode 100644
index 000000000..16bcfafd7
--- /dev/null
+++ b/frontend/src/routes/settings/events/event-table.svelte
@@ -0,0 +1,236 @@
+<script lang="ts">
+ import ArcaneTable from '$lib/components/arcane-table.svelte';
+ import { Button } from '$lib/components/ui/button/index.js';
+ import { Trash2, Activity, Ellipsis } from '@lucide/svelte';
+ import * as Card from '$lib/components/ui/card/index.js';
+ import { toast } from 'svelte-sonner';
+ import * as DropdownMenu from '$lib/components/ui/dropdown-menu/index.js';
+ import { openConfirmDialog } from '$lib/components/confirm-dialog';
+ import * as Table from '$lib/components/ui/table';
+ import StatusBadge from '$lib/components/badges/status-badge.svelte';
+ import { Badge } from '$lib/components/ui/badge';
+ import { handleApiResultWithCallbacks } from '$lib/utils/api.util';
+ import { tryCatch } from '$lib/utils/try-catch';
+ import ArcaneButton from '$lib/components/arcane-button.svelte';
+ import { formatDistanceToNow } from 'date-fns';
+ import { eventAPI } from '$lib/services/api';
+ import type { Paginated, SearchPaginationSortRequest } from '$lib/types/pagination.type';
+ import type { Event } from '$lib/types/event.type';
+
+ let {
+ events,
+ selectedIds = $bindable(),
+ requestOptions = $bindable(),
+ onRefresh,
+ onEventsChanged
+ }: {
+ events: Paginated<Event>;
+ selectedIds: string[];
+ requestOptions: SearchPaginationSortRequest;
+ onRefresh: (options: SearchPaginationSortRequest) => Promise<any>;
+ onEventsChanged: () => Promise<void>;
+ } = $props();
+
+ let isLoading = $state({
+ removing: false
+ });
+
+ type EventWithId = Event & { id: string };
+
+ const eventsWithId = $derived(
+ (events.data || []).map((event) => ({
+ ...event,
+ id: event.id
+ }))
+ );
+
+ const paginatedEvents: Paginated<EventWithId> = $derived({
+ data: eventsWithId as EventWithId[],
+ pagination: events.pagination
+ });
+
+ async function handleDeleteSelected() {
+ if (selectedIds.length === 0) return;
+
+ openConfirmDialog({
+ title: `Delete ${selectedIds.length} Event${selectedIds.length > 1 ? 's' : ''}`,
+ message: `Are you sure you want to delete the selected event${selectedIds.length > 1 ? 's' : ''}? This action cannot be undone.`,
+ confirm: {
+ label: 'Delete',
+ destructive: true,
+ action: async () => {
+ isLoading.removing = true;
+ let successCount = 0;
+ let failureCount = 0;
+
+ for (const eventId of selectedIds) {
+ const result = await tryCatch(eventAPI.delete(eventId));
+ handleApiResultWithCallbacks({
+ result,
+ message: `Failed to delete event ${eventId}`,
+ setLoadingState: () => {},
+ onSuccess: () => {
+ successCount++;
+ }
+ });
+
+ if (result.error) {
+ failureCount++;
+ }
+ }
+
+ isLoading.removing = false;
+
+ if (successCount > 0) {
+ toast.success(
+ `Successfully deleted ${successCount} event${successCount > 1 ? 's' : ''}`
+ );
+ await onEventsChanged();
+ }
+
+ if (failureCount > 0) {
+ toast.error(`Failed to delete ${failureCount} event${failureCount > 1 ? 's' : ''}`);
+ }
+
+ selectedIds = [];
+ }
+ }
+ });
+ }
+
+ async function handleDeleteEvent(eventId: string, title: string) {
+ openConfirmDialog({
+ title: `Delete Event`,
+ message: `Are you sure you want to delete the event "${title}"? This action cannot be undone.`,
+ confirm: {
+ label: 'Delete',
+ destructive: true,
+ action: async () => {
+ isLoading.removing = true;
+ handleApiResultWithCallbacks({
+ result: await tryCatch(eventAPI.delete(eventId)),
+ message: `Failed to delete event "${title}"`,
+ setLoadingState: (value) => (isLoading.removing = value),
+ onSuccess: async () => {
+ toast.success(`Event "${title}" deleted successfully.`);
+ await onEventsChanged();
+ }
+ });
+ }
+ }
+ });
+ }
+
+ function getSeverityBadgeVariant(severity: string) {
+ switch (severity) {
+ case 'success':
+ return 'green';
+ case 'error':
+ return 'red';
+ case 'warning':
+ return 'amber';
+ case 'info':
+ default:
+ return 'blue';
+ }
+ }
+
+ function formatTimestamp(timestamp: string) {
+ const date = new Date(timestamp);
+ return formatDistanceToNow(date, { addSuffix: true });
+ }
+</script>
+
+{#if eventsWithId.length > 0}
+ <Card.Root class="border shadow-sm">
+ <Card.Header class="px-6">
+ <div class="flex items-center justify-between">
+ <Card.Title>Events List</Card.Title>
+ <div class="flex items-center gap-2">
+ {#if selectedIds.length > 0}
+ <ArcaneButton
+ action="remove"
+ onClick={handleDeleteSelected}
+ loading={isLoading.removing}
+ disabled={isLoading.removing}
+ />
+ {/if}
+ </div>
+ </div>
+ </Card.Header>
+ <Card.Content>
+ <ArcaneTable
+ items={paginatedEvents}
+ bind:requestOptions
+ bind:selectedIds
+ {onRefresh}
+ columns={[
+ { label: 'Severity', sortColumn: 'severity' },
+ { label: 'Type', sortColumn: 'type' },
+ { label: 'Resource', sortColumn: 'resourceType' },
+ { label: 'User', sortColumn: 'username' },
+ { label: 'Time', sortColumn: 'timestamp' },
+ { label: ' ' }
+ ]}
+ filterPlaceholder="Search events..."
+ noResultsMessage="No events found"
+ >
+ {#snippet rows({ item })}
+ <Table.Cell>
+ <StatusBadge text={item.severity} variant={getSeverityBadgeVariant(item.severity)} />
+ </Table.Cell>
+ <Table.Cell>
+ <Badge variant="outline">{item.type}</Badge>
+ </Table.Cell>
+ <Table.Cell>
+ {#if item.resourceType}
+ <div class="space-y-1">
+ <span class="text-sm">{item.resourceType}</span>
+ {#if item.resourceName}
+ <p class="text-xs text-muted-foreground">{item.resourceName}</p>
+ {/if}
+ </div>
+ {:else}
+ -
+ {/if}
+ </Table.Cell>
+ <Table.Cell>{item.username || '-'}</Table.Cell>
+ <Table.Cell>
+ <span class="text-sm">{formatTimestamp(item.timestamp)}</span>
+ </Table.Cell>
+ <Table.Cell>
+ <DropdownMenu.Root>
+ <DropdownMenu.Trigger>
+ {#snippet child({ props })}
+ <Button {...props} variant="ghost" size="icon" class="relative size-8 p-0">
+ <span class="sr-only">Open menu</span>
+ <Ellipsis />
+ </Button>
+ {/snippet}
+ </DropdownMenu.Trigger>
+ <DropdownMenu.Content align="end">
+ <DropdownMenu.Group>
+ <DropdownMenu.Item
+ variant="destructive"
+ onclick={() => handleDeleteEvent(item.id, item.title)}
+ >
+ <Trash2 class="size-4" />
+ Delete
+ </DropdownMenu.Item>
+ </DropdownMenu.Group>
+ </DropdownMenu.Content>
+ </DropdownMenu.Root>
+ </Table.Cell>
+ {/snippet}
+ </ArcaneTable>
+ </Card.Content>
+ </Card.Root>
+{:else}
+ <div class="flex flex-col items-center justify-center px-6 py-12 text-center">
+ <Activity class="text-muted-foreground mb-4 size-12 opacity-40" />
+ <p class="text-lg font-medium">No events found</p>
+ <p class="text-muted-foreground mt-1 max-w-md text-sm">
+ Events will appear here as they are generated by system activities
+ </p>
+ </div>
+{/if}