// Package trashapi implementiert DOC-12s Backend-Voraussetzung: HTTP- // Endpunkte für Papierkorb-Liste, Wiederherstellung (einzeln und in // Auswahl) und endgültiges Löschen. Ruft ausschließlich internal/trash auf, // keine eigene Papierkorb-Logik. package trashapi import ( "encoding/json" "errors" "net/http" "regexp" "strings" "time" "github.com/jackc/pgx/v5" "github.com/jackc/pgx/v5/pgxpool" "gitea.perlbach24.de/scripte/nexarch/dms/internal/legalhold" "gitea.perlbach24.de/scripte/nexarch/dms/internal/storage" "gitea.perlbach24.de/scripte/nexarch/dms/internal/trash" ) type Server struct { pool *pgxpool.Pool storageSvc *storage.Service retentionDuration time.Duration searchIndex trash.SearchIndexEnqueuer holds legalhold.Checker } // NewServer nimmt die Papierkorb-Frist als Parameter entgegen — der Aufrufer // (cmd/app) liest sie aus einer Umgebungsvariable, dieses Paket kennt keine // eigene Konfigurationsquelle. func NewServer(pool *pgxpool.Pool, storageSvc *storage.Service, retentionDuration time.Duration) *Server { return &Server{pool: pool, storageSvc: storageSvc, retentionDuration: retentionDuration} } // SetSearchIndexEnqueuer aktiviert SRC-02s Loeschungs-/Wiederherstellungs- // Propagation in den Suchindex — optional, damit bestehende Aufrufer/Tests // ohne Indexierungs-Pipeline unveraendert funktionieren. func (s *Server) SetSearchIndexEnqueuer(e trash.SearchIndexEnqueuer) { s.searchIndex = e } func (s *Server) SetLegalHoldChecker(c legalhold.Checker) { s.holds = c } func (s *Server) RegisterRoutes(mux *http.ServeMux) { mux.HandleFunc("GET /trash", s.handleList) mux.HandleFunc("POST /trash", s.handleTrash) mux.HandleFunc("POST /trash/restore", s.handleRestore) mux.HandleFunc("POST /trash/purge", s.handlePurge) } func requireCaller(w http.ResponseWriter, r *http.Request) (string, bool) { caller := strings.TrimSpace(r.URL.Query().Get("caller")) if caller == "" { writeError(w, http.StatusBadRequest, "fehlender pflicht-parameter \"caller\"") return "", false } return caller, true } func writeJSON(w http.ResponseWriter, v any) { w.Header().Set("Content-Type", "application/json") _ = json.NewEncoder(w).Encode(v) } func writeError(w http.ResponseWriter, status int, message string) { w.Header().Set("Content-Type", "application/json") w.WriteHeader(status) _ = json.NewEncoder(w).Encode(map[string]string{"error": message}) } type entryDTO struct { ID string `json:"id"` Type string `json:"type"` Name string `json:"name"` TrashedAt string `json:"trashed_at"` RemainingSeconds int64 `json:"remaining_seconds"` } // handleList liefert alle Papierkorb-Einträge mit Restlaufzeit // (Akzeptanzkriterium 1). Eine bereits abgelaufene Restlaufzeit wird als 0 // ausgegeben, nie negativ — der Aufräum-Job (DOC-11) entfernt solche // Einträge ohnehin zeitnah, ein negativer Wert wäre nur verwirrend. func (s *Server) handleList(w http.ResponseWriter, r *http.Request) { entries, err := trash.ListTrashed(r.Context(), s.pool) if err != nil { writeError(w, http.StatusInternalServerError, err.Error()) return } dtos := make([]entryDTO, len(entries)) for i, e := range entries { remaining := s.retentionDuration - time.Since(e.TrashedAt) remainingSeconds := int64(remaining.Seconds()) if remainingSeconds < 0 { remainingSeconds = 0 } dtos[i] = entryDTO{ ID: e.ID, Type: string(e.Type), Name: e.Name, TrashedAt: e.TrashedAt.UTC().Format(time.RFC3339), RemainingSeconds: remainingSeconds, } } writeJSON(w, dtos) } type selectionRequest struct { DocumentIDs []string `json:"document_ids"` FolderIDs []string `json:"folder_ids"` } type selectionResult struct { RestoredDocumentIDs []string `json:"restored_document_ids,omitempty"` RestoredFolderIDs []string `json:"restored_folder_ids,omitempty"` PurgedDocumentIDs []string `json:"purged_document_ids,omitempty"` PurgedFolderIDs []string `json:"purged_folder_ids,omitempty"` Failed map[string]string `json:"failed,omitempty"` } // handleRestore stellt eine Auswahl von Dokumenten UND Ordnern wieder her // (Akzeptanzkriterium 2: einzeln — Auswahl mit einem Element — UND in // Auswahl gleichermaßen über denselben Endpunkt). func (s *Server) handleRestore(w http.ResponseWriter, r *http.Request) { caller, ok := requireCaller(w, r) if !ok { return } var req selectionRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil { writeError(w, http.StatusBadRequest, "ungueltiger request-body: "+err.Error()) return } result := selectionResult{Failed: map[string]string{}} for _, id := range req.DocumentIDs { if err := trash.RestoreDocument(r.Context(), s.pool, s.searchIndex, id, caller); err != nil { result.Failed[id] = err.Error() continue } result.RestoredDocumentIDs = append(result.RestoredDocumentIDs, id) } for _, id := range req.FolderIDs { if err := trash.RestoreFolder(r.Context(), s.pool, s.searchIndex, id, caller); err != nil { result.Failed[id] = err.Error() continue } result.RestoredFolderIDs = append(result.RestoredFolderIDs, id) } if len(result.Failed) == 0 { result.Failed = nil } writeJSON(w, result) } // handlePurge löscht eine Auswahl von Dokumenten UND Ordnern sofort // endgültig (Akzeptanzkriterium 3) — die Bestätigung selbst liegt in der // Oberfläche (Dialog vor diesem Aufruf), dieser Endpunkt führt nur aus. func (s *Server) handlePurge(w http.ResponseWriter, r *http.Request) { caller, ok := requireCaller(w, r) if !ok { return } var req selectionRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil { writeError(w, http.StatusBadRequest, "ungueltiger request-body: "+err.Error()) return } result := selectionResult{Failed: map[string]string{}} for _, id := range req.DocumentIDs { if err := trash.PurgeDocumentNow(r.Context(), s.pool, s.storageSvc, s.searchIndex, s.holds, id, caller); err != nil { result.Failed[id] = err.Error() continue } result.PurgedDocumentIDs = append(result.PurgedDocumentIDs, id) } for _, id := range req.FolderIDs { if err := trash.PurgeFolderNow(r.Context(), s.pool, id, caller); err != nil { result.Failed[id] = err.Error() continue } result.PurgedFolderIDs = append(result.PurgedFolderIDs, id) } if len(result.Failed) == 0 { result.Failed = nil } writeJSON(w, result) } var uuidPattern = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`) type trashResult struct { TrashedDocumentIDs []string `json:"trashed_document_ids,omitempty"` TrashedFolderIDs []string `json:"trashed_folder_ids,omitempty"` Failed map[string]string `json:"failed,omitempty"` } // handleTrash verschiebt eine Auswahl von Dokumenten und Ordnern in den // Papierkorb. Bereits verschobene Objekte gelten als erledigt (kein zweiter // Audit-Eintrag); ein von einem anderen Nutzer ausgeliehenes Dokument wird // nicht verschoben. func (s *Server) handleTrash(w http.ResponseWriter, r *http.Request) { caller, ok := requireCaller(w, r) if !ok { return } var req selectionRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil { writeError(w, http.StatusBadRequest, "ungueltiger request-body: "+err.Error()) return } if len(req.DocumentIDs)+len(req.FolderIDs) == 0 { writeError(w, http.StatusBadRequest, "leere auswahl") return } result := trashResult{Failed: map[string]string{}} for _, id := range req.DocumentIDs { reason, already := s.checkTrashable(r, "documents", id, caller) if reason != "" { result.Failed[id] = reason continue } if !already { if err := trash.SoftDeleteDocument(r.Context(), s.pool, s.searchIndex, id, caller); err != nil { result.Failed[id] = err.Error() continue } } result.TrashedDocumentIDs = append(result.TrashedDocumentIDs, id) } for _, id := range req.FolderIDs { reason, already := s.checkTrashable(r, "folders", id, caller) if reason != "" { result.Failed[id] = reason continue } if !already { if err := trash.SoftDeleteFolder(r.Context(), s.pool, s.searchIndex, id, caller); err != nil { result.Failed[id] = err.Error() continue } } result.TrashedFolderIDs = append(result.TrashedFolderIDs, id) } if len(result.Failed) == 0 { result.Failed = nil } writeJSON(w, result) } // checkTrashable liefert einen Ablehnungsgrund ("" = verschiebbar) und ob // das Objekt schon im Papierkorb liegt. func (s *Server) checkTrashable(r *http.Request, kind, id, caller string) (reason string, alreadyTrashed bool) { if !uuidPattern.MatchString(id) { return "ungueltige id", false } var trashed, lockedByOther, foreignDocuments bool var err error if kind == "documents" { err = s.pool.QueryRow(r.Context(), ` SELECT d.trashed_at IS NOT NULL, EXISTS (SELECT 1 FROM document_locks l WHERE l.document_id = d.id AND l.lease_until > now() AND l.locked_by::text <> $2) FROM documents d WHERE d.id = $1 `, id, caller).Scan(&trashed, &lockedByOther) } else { err = s.pool.QueryRow(r.Context(), ` SELECT f.trashed_at IS NOT NULL, EXISTS (SELECT 1 FROM document_locks l JOIN documents d ON d.id = l.document_id WHERE l.lease_until > now() AND l.locked_by::text <> $2 AND d.trashed_at IS NULL AND d.folder_id IN (SELECT id FROM folders WHERE path LIKE f.path || '%')), EXISTS (SELECT 1 FROM documents d WHERE d.trashed_at IS NULL AND d.created_by::text <> $2 AND d.folder_id IN (SELECT id FROM folders WHERE path LIKE f.path || '%')) FROM folders f WHERE f.id = $1 `, id, caller).Scan(&trashed, &lockedByOther, &foreignDocuments) } switch { case errors.Is(err, pgx.ErrNoRows): return "nicht gefunden", false case err != nil: return "pruefung fehlgeschlagen", false case lockedByOther: return "gesperrt: von anderem nutzer ausgeliehen", false case foreignDocuments: return "ordner enthaelt dokumente anderer nutzer", false } return "", trashed }