nexarch/ai/internal/extractapi/extractapi.go

// Package extractapi ist die HTTP-Bindung fuer Rechnungsdaten-Extraktion
// (EXT-02) samt Plausibilitaetspruefung und Confidence-Score (EXT-03),
// damit eine Oberflaeche (EXT-04) Vorschlaege samt Konfidenz anzeigen kann,
// bevor der Nutzer sie bestaetigt oder korrigiert. Aufrufer ist das
// anfragende Modul (DMS/Mail) bzw. dessen eigene Backend-for-Frontend-Route,
// nicht der Endnutzer direkt — Service-Token-Pflicht wie summaryapi/
// semanticsearchapi, fail closed. Die eigentliche Uebernahme in die
// Metadaten des aufrufenden Moduls ist nicht Bestandteil dieses Pakets
// (EXT-04 "Nicht Bestandteil").
package extractapi

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

	"gitea.perlbach24.de/scripte/nexarch/ai/internal/extractvalidate"
	"gitea.perlbach24.de/scripte/nexarch/ai/internal/invoiceextract"
	"gitea.perlbach24.de/scripte/nexarch/common/svcauth"
)

type Server struct {
	extractor    *invoiceextract.Extractor
	rules        extractvalidate.RuleSet
	serviceToken string
}

func NewServer(extractor *invoiceextract.Extractor, rules extractvalidate.RuleSet, serviceToken string) *Server {
	return &Server{extractor: extractor, rules: rules, serviceToken: serviceToken}
}

func (s *Server) RegisterRoutes(mux *http.ServeMux) {
	mux.HandleFunc("POST /invoices/extract", s.requireAuth(s.handleInvoiceExtract))
}

func (s *Server) requireAuth(next http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		got := r.Header.Get("X-Service-Token")
		if !svcauth.Equal(got, s.serviceToken) {
			writeError(w, http.StatusUnauthorized, "service-token fehlt oder ist ungueltig")
			return
		}
		next(w, r)
	}
}

type invoiceExtractRequest struct {
	Text string `json:"text"`
}

type fieldSuggestion struct {
	Value      string   `json:"value"`
	Present    bool     `json:"present"`
	Confidence float64  `json:"confidence"`
	Plausible  bool     `json:"plausible"`
	Reasons    []string `json:"reasons,omitempty"`
}

type invoiceExtractResponse struct {
	Fields       map[string]fieldSuggestion `json:"fields"`
	OverallScore float64                    `json:"overall_score"`
	Valid        bool                       `json:"valid"`
	RejectReason string                     `json:"reject_reason,omitempty"`
}

func (s *Server) handleInvoiceExtract(w http.ResponseWriter, r *http.Request) {
	var req invoiceExtractRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
		return
	}
	if req.Text == "" {
		writeError(w, http.StatusBadRequest, "leerer dokumenttext")
		return
	}

	result, err := s.extractor.Extract(r.Context(), req.Text)
	if err != nil {
		writeError(w, http.StatusInternalServerError, "extraktion fehlgeschlagen")
		return
	}

	validation := extractvalidate.Validate(result.Fields, s.rules)

	fields := make(map[string]fieldSuggestion, len(result.Fields.Fields))
	for name, fr := range result.Fields.Fields {
		fv := validation.Fields[name]
		fields[name] = fieldSuggestion{
			Value:      fr.Value,
			Present:    fr.Present,
			Confidence: fv.Confidence,
			Plausible:  fv.Plausible,
			Reasons:    fv.Reasons,
		}
	}

	writeJSON(w, http.StatusOK, invoiceExtractResponse{
		Fields:       fields,
		OverallScore: validation.OverallScore,
		Valid:        result.Valid,
		RejectReason: result.RejectReason,
	})
}

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, message string) {
	writeJSON(w, status, map[string]string{"error": message})
}