feat: task trash, triage trash and retention settings for every area; admin can forbid keeping things for good

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/api/done_cleanup.go

@@ -2,16 +2,19 @@ package api
 
 import (
 	"encoding/json"
+	"errors"
 	"log/slog"
 	"net/http"
 	"time"
 
+	"github.com/go-chi/chi/v5"
 	"github.com/sandrodach/mindsift/internal/auth"
 	"github.com/sandrodach/mindsift/internal/storage"
 )
 
-// startDoneCleanupTicker deletes completed tasks whose delay ran out (storage/done_cleanup.go), once
-// shortly after the start and then every hour.
+// startDoneCleanupTicker runs the retention delays (storage/retention.go): completed tasks into the
+// task trash, the trashes and ticked-off list items emptied; once shortly after the start and then
+// every hour.
 func (s *Server) startDoneCleanupTicker() {
 	time.Sleep(2 * time.Minute)
 	s.runDoneCleanup(time.Now())
@@ -22,16 +25,27 @@ func (s *Server) startDoneCleanupTicker() {
 	}
 }
 
+// allowNeverRetention: RETENTION_ALLOW_NEVER if set, else the admin's switch in the system settings.
+func (s *Server) allowNeverRetention() bool {
+	if s.cfg.RetentionAllowNever != nil {
+		return *s.cfg.RetentionAllowNever
+	}
+	return s.store.RetentionAllowNeverSetting()
+}
+
 func (s *Server) runDoneCleanup(now time.Time) {
-	deleted, err := s.store.PurgeExpiredDoneTasks(now)
+	res, err := s.store.PurgeExpired(now, s.allowNeverRetention())
 	if err != nil {
-		slog.Error("Aufräumen erledigter Aufgaben fehlgeschlagen", "error", err)
-		return
+		slog.Error("Aufräumen nach Aufbewahrungsfristen fehlgeschlagen", "error", err)
 	}
-	if len(deleted) > 0 {
-		slog.Info("Erledigte Aufgaben aufgeräumt", "count", len(deleted))
+	if n := len(res.TasksToTrash) + len(res.TrashedTasks) + res.Discarded + len(res.Notes) + len(res.ListItems); n > 0 {
+		slog.Info("Aufbewahrungsfristen angewendet", "erledigte_in_papierkorb", len(res.TasksToTrash), "papierkorb_aufgaben", len(res.TrashedTasks),
+			"triage", res.Discarded, "notizen", len(res.Notes), "listeneintraege", len(res.ListItems))
+	}
+	s.broadcastDeletedTasks(res.TasksToTrash)
+	for _, it := range res.ListItems {
+		s.wsHub.BroadcastListEvent(it.ListID, "ITEM_DELETED", map[string]string{"itemId": it.ID, "listId": it.ListID})
 	}
-	s.broadcastDeletedTasks(deleted)
 }
 
 // broadcastDeletedTasks tells everyone who saw the tasks; there are no watcher notifications for this.
@@ -42,7 +56,8 @@ func (s *Server) broadcastDeletedTasks(deleted []storage.DeletedTask) {
 	}
 }
 
-// handleClearDoneTasks: "Erledigte leeren" for one task list (taskListId) or all the user can edit.
+// handleClearDoneTasks: "Erledigte leeren" (into the task trash) for one task list (taskListId) or all
+// the user can edit.
 func (s *Server) handleClearDoneTasks(w http.ResponseWriter, r *http.Request) {
 	userID := auth.GetUserID(r.Context())
 	var req struct {
@@ -57,3 +72,59 @@ func (s *Server) handleClearDoneTasks(w http.ResponseWriter, r *http.Request) {
 	s.broadcastDeletedTasks(deleted)
 	writeJSON(w, http.StatusOK, map[string]int{"deleted": len(deleted)})
 }
+
+// --- Task trash (storage/task_trash.go) ---
+
+// handleGetTaskTrash: GET /tasks/trash?taskListId= – the trashed tasks the user can see.
+func (s *Server) handleGetTaskTrash(w http.ResponseWriter, r *http.Request) {
+	items, err := s.store.GetTaskTrash(auth.GetUserID(r.Context()), r.URL.Query().Get("taskListId"))
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	writeJSON(w, http.StatusOK, items)
+}
+
+// handleRestoreTrashedTask puts a task back and tells everyone who sees it.
+func (s *Server) handleRestoreTrashedTask(w http.ResponseWriter, r *http.Request) {
+	task, err := s.store.RestoreTrashedTask(auth.GetUserID(r.Context()), chi.URLParam(r, "id"))
+	if err != nil {
+		writeTaskTrashError(w, err)
+		return
+	}
+	s.wsHub.BroadcastToUsers(s.taskAudience(task), "TASK_CREATED", task)
+	writeJSON(w, http.StatusOK, task)
+}
+
+func (s *Server) handlePurgeTrashedTask(w http.ResponseWriter, r *http.Request) {
+	if err := s.store.PurgeTrashedTask(auth.GetUserID(r.Context()), chi.URLParam(r, "id")); err != nil {
+		writeTaskTrashError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]bool{"deleted": true})
+}
+
+// handleEmptyTaskTrash: POST /tasks/trash/empty {taskListId} – one list or all the user may edit.
+func (s *Server) handleEmptyTaskTrash(w http.ResponseWriter, r *http.Request) {
+	var req struct {
+		TaskListID string `json:"taskListId"`
+	}
+	_ = json.NewDecoder(r.Body).Decode(&req)
+	ids, err := s.store.EmptyTaskTrash(auth.GetUserID(r.Context()), req.TaskListID)
+	if err != nil {
+		writeTaskTrashError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]int{"deleted": len(ids)})
+}
+
+func writeTaskTrashError(w http.ResponseWriter, err error) {
+	switch {
+	case errors.Is(err, storage.ErrNotInTaskTrash):
+		writeError(w, http.StatusNotFound, err.Error())
+	case errors.Is(err, storage.ErrTaskListReadOnly):
+		writeError(w, http.StatusForbidden, err.Error())
+	default:
+		writeError(w, http.StatusInternalServerError, err.Error())
+	}
+}