nexarch/workflow/internal/taskapi/taskapi.go

// Package taskapi ist die HTTP-Bindung fuer die Aufgaben-Oberflaeche
// (TSK-04): GET /tasks fuer Liste und Kanban-Ansicht zusammen, PATCH
// /tasks/{id}/status fuer die Drag&Drop-Statusaenderung. Nutzeridentitaet
// aus X-User-Id, Tenant-Kontext aus X-Tenant-Slug -- gleiches Muster wie
// backchannelapi (VOR-04/VOR-06): der Tenant-Kontext des anfragenden Nutzers
// muss zur eigenen Instanz passen und optional gegen Core bestaetigt werden,
// bevor Aufgaben zurueckgegeben werden (Akzeptanzkriterium 5). In
// cmd/workflow-app setzt bearerauth beide Header aus dem verifizierten
// Token. Issue #369: zusaetzlich Rechtepruefung workflow.task.read/write.
package taskapi

import (
	"encoding/json"
	"errors"
	"log"
	"net/http"

	"gitea.perlbach24.de/scripte/nexarch/common/policyclient"
	"gitea.perlbach24.de/scripte/nexarch/workflow/internal/task"
)

const (
	permissionTaskRead  = "workflow.task.read"
	permissionTaskWrite = "workflow.task.write"
)

type Server struct {
	store         *task.Store
	ownTenantSlug string
	policy        *policyclient.Client
}

func NewServer(store *task.Store, ownTenantSlug string) *Server {
	return &Server{store: store, ownTenantSlug: ownTenantSlug}
}

// WithPolicy aktiviert die Rechtepruefung gegen Core (POST /authorize).
func (s *Server) WithPolicy(client *policyclient.Client) *Server {
	s.policy = client
	return s
}

func (s *Server) RegisterRoutes(mux *http.ServeMux) {
	mux.HandleFunc("GET /tasks", s.requireAuth(permissionTaskRead, s.handleList))
	mux.HandleFunc("PATCH /tasks/{id}/status", s.requireAuth(permissionTaskWrite, s.handleSetStatus))
}

func (s *Server) requireAuth(permission string, next http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if r.Header.Get("X-User-Id") == "" {
			writeError(w, http.StatusUnauthorized, "X-User-Id fehlt")
			return
		}
		tenantSlug := r.Header.Get("X-Tenant-Slug")
		if tenantSlug == "" {
			writeError(w, http.StatusUnauthorized, "X-Tenant-Slug fehlt")
			return
		}
		if tenantSlug != s.ownTenantSlug {
			log.Printf("taskapi: tenant-kontext abgelehnt (angefragt=%q, instanz=%q)", tenantSlug, s.ownTenantSlug)
			writeError(w, http.StatusForbidden, "nicht berechtigt")
			return
		}
		if s.policy != nil {
			allowed, err := s.policy.Allowed(r.Context(), tenantSlug, roleOf(r), permission)
			if err != nil {
				writeError(w, http.StatusServiceUnavailable, "berechtigungsdienst nicht erreichbar")
				return
			}
			if !allowed {
				writeError(w, http.StatusForbidden, "keine berechtigung")
				return
			}
		}
		next(w, r)
	}
}

func (s *Server) handleList(w http.ResponseWriter, r *http.Request) {
	tasks, err := s.store.ListAll(r.Context())
	if err != nil {
		writeError(w, http.StatusInternalServerError, "aufgaben konnten nicht gelesen werden")
		return
	}
	writeJSON(w, http.StatusOK, tasks)
}

type setStatusRequest struct {
	Status string `json:"status"`
}

func (s *Server) handleSetStatus(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	var req setStatusRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "ungueltige anfrage")
		return
	}
	err := s.store.SetStatus(r.Context(), id, task.Status(req.Status))
	switch {
	case err == nil:
		w.WriteHeader(http.StatusNoContent)
	case errors.Is(err, task.ErrInvalidStatus):
		writeError(w, http.StatusBadRequest, "ungueltiger status")
	case errors.Is(err, task.ErrNotFound):
		writeError(w, http.StatusNotFound, "aufgabe nicht gefunden")
	default:
		writeError(w, http.StatusInternalServerError, "status konnte nicht gesetzt werden")
	}
}

func writeJSON(w http.ResponseWriter, status int, v any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(v)
}

func writeError(w http.ResponseWriter, status int, msg string) {
	writeJSON(w, status, map[string]string{"error": msg})
}

func roleOf(r *http.Request) string {
	if role := r.Header.Get("X-User-Role"); role != "" {
		return role
	}
	return "user"
}