LIC-04: backend-api fuer lizenz-modul-verwaltungsoberflaeche (flag.List, adminapi-paket)
This commit is contained in:
sysops
@@ -0,0 +1,226 @@
|
||||
// Package adminapi implementiert Core LIC-04: das Backend-API fuer die
|
||||
// Lizenz-/Modul-Verwaltungsoberflaeche. Das Paket enthaelt KEINE eigene
|
||||
// Lizenz-/Flag-/Quota-Logik, sondern ist ein duenner Vermittler ueber
|
||||
// internal/license, internal/flag und internal/usage (Ticket-Vorgabe:
|
||||
// "Verwaltungsoberflaeche als duenner Client ... ohne eigene Lizenzlogik").
|
||||
package adminapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/flag"
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/license"
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/usage"
|
||||
)
|
||||
|
||||
// UsageMetrics sind die Metriken, die auf der Uebersichtsseite je Tenant
|
||||
// dargestellt werden (Akzeptanzkriterium 3). Neue Metriken hinzuzufuegen
|
||||
// beruehrt kein bestehendes Verhalten von internal/usage.
|
||||
var UsageMetrics = []string{"users", "storage_bytes", "api_calls"}
|
||||
|
||||
// FlagOverview ist ein Flag zusammen mit der fuer den Tenant ausgewerteten
|
||||
// Berechtigung, es umzuschalten (Akzeptanzkriterium 2).
|
||||
type FlagOverview struct {
|
||||
Key string `json:"key"`
|
||||
Enabled bool `json:"enabled"`
|
||||
Licensed bool `json:"licensed"`
|
||||
DenyGrund string `json:"deny_grund,omitempty"`
|
||||
}
|
||||
|
||||
// UsageOverview ist eine Metrik mit Zaehlerstand, Quota und Status
|
||||
// (Akzeptanzkriterium 3).
|
||||
type UsageOverview struct {
|
||||
Metric string `json:"metric"`
|
||||
Value int64 `json:"value"`
|
||||
Limit int64 `json:"limit"`
|
||||
Status usage.Status `json:"status"`
|
||||
}
|
||||
|
||||
// Overview ist die vollstaendige Antwort fuer die Uebersichtsseite
|
||||
// (Akzeptanzkriterium 1: Lizenzstatus/Laufzeit/Module auf einen Blick).
|
||||
type Overview struct {
|
||||
Plan string `json:"plan"`
|
||||
Modules []string `json:"modules"`
|
||||
IssuedAt string `json:"issued_at"`
|
||||
ValidUntil string `json:"valid_until"`
|
||||
Expired bool `json:"expired"`
|
||||
Flags []FlagOverview `json:"flags"`
|
||||
Usage []UsageOverview `json:"usage"`
|
||||
}
|
||||
|
||||
// ErrFlagNotLicensed wird geliefert, wenn ein Administrator versucht, ein
|
||||
// Flag zu aktivieren, dessen zugehoeriges Modul die Lizenz nicht umfasst
|
||||
// (Akzeptanzkriterium 2 / Pruefung 1).
|
||||
var ErrFlagNotLicensed = errors.New("adminapi: modul ist durch die aktuelle lizenz nicht freigeschaltet")
|
||||
|
||||
// Handler buendelt die drei Vorbedingungs-Dienste hinter einem gemeinsamen
|
||||
// HTTP-API fuer das Frontend.
|
||||
type Handler struct {
|
||||
licenseStore *license.Store
|
||||
flagStore *flag.Store
|
||||
flagService *flag.Service
|
||||
usageStore *usage.Store
|
||||
}
|
||||
|
||||
func NewHandler(licenseStore *license.Store, flagStore *flag.Store, flagService *flag.Service, usageStore *usage.Store) *Handler {
|
||||
return &Handler{licenseStore: licenseStore, flagStore: flagStore, flagService: flagService, usageStore: usageStore}
|
||||
}
|
||||
|
||||
// isModuleLicensed prueft, ob ein Flag-Schluessel als lizenziertes Modul
|
||||
// gilt. Konvention: ein Flag-Key der Form "module:<name>" ist an das
|
||||
// gleichnamige Modul in Payload.Modules gebunden; alle anderen Flag-Keys
|
||||
// gelten als lizenzunabhaengige, rein funktionale Schalter.
|
||||
func isModuleLicensed(key string, modules []string) (moduleName string, isModuleFlag bool, licensed bool) {
|
||||
const prefix = "module:"
|
||||
if !strings.HasPrefix(key, prefix) {
|
||||
return "", false, true
|
||||
}
|
||||
moduleName = strings.TrimPrefix(key, prefix)
|
||||
for _, m := range modules {
|
||||
if m == moduleName {
|
||||
return moduleName, true, true
|
||||
}
|
||||
}
|
||||
return moduleName, true, false
|
||||
}
|
||||
|
||||
// Overview liefert die kombinierte Uebersicht fuer einen Tenant
|
||||
// (Akzeptanzkriterium 1 + 3).
|
||||
func (h *Handler) Overview(ctx context.Context, tenantID string) (Overview, error) {
|
||||
lic, err := h.licenseStore.Status(ctx, tenantID)
|
||||
if err != nil {
|
||||
return Overview{}, fmt.Errorf("lizenzstatus lesen: %w", err)
|
||||
}
|
||||
_, expiredErr := h.licenseStore.RequireActive(ctx, tenantID)
|
||||
expired := errors.Is(expiredErr, license.ErrLicenseExpired)
|
||||
|
||||
flags, err := h.flagStore.List(ctx)
|
||||
if err != nil {
|
||||
return Overview{}, fmt.Errorf("flags lesen: %w", err)
|
||||
}
|
||||
|
||||
tenantSlug := tenantID // Auswertung erwartet den Tenant-Bezug als String; Aufloesung ID->Slug obliegt dem Aufrufer (siehe Handler-Tests).
|
||||
flagOverviews := make([]FlagOverview, 0, len(flags))
|
||||
for _, f := range flags {
|
||||
_, _, licensed := isModuleLicensed(f.Key, lic.Modules)
|
||||
fo := FlagOverview{
|
||||
Key: f.Key,
|
||||
Enabled: h.flagService.IsEnabled(ctx, tenantSlug, f.Key),
|
||||
Licensed: licensed,
|
||||
}
|
||||
if !licensed {
|
||||
fo.DenyGrund = "Modul ist im aktuellen Lizenzplan nicht enthalten"
|
||||
}
|
||||
flagOverviews = append(flagOverviews, fo)
|
||||
}
|
||||
|
||||
usageOverviews := make([]UsageOverview, 0, len(UsageMetrics))
|
||||
for _, metric := range UsageMetrics {
|
||||
value, limit, status, err := h.usageStore.Check(ctx, tenantID, metric)
|
||||
if err != nil {
|
||||
return Overview{}, fmt.Errorf("nutzungsstand lesen (%s): %w", metric, err)
|
||||
}
|
||||
usageOverviews = append(usageOverviews, UsageOverview{
|
||||
Metric: metric, Value: value, Limit: limit, Status: status,
|
||||
})
|
||||
}
|
||||
|
||||
return Overview{
|
||||
Plan: lic.Plan,
|
||||
Modules: lic.Modules,
|
||||
IssuedAt: lic.IssuedAt.Format("2006-01-02T15:04:05Z07:00"),
|
||||
ValidUntil: lic.ValidUntil.Format("2006-01-02T15:04:05Z07:00"),
|
||||
Expired: expired,
|
||||
Flags: flagOverviews,
|
||||
Usage: usageOverviews,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// ToggleFlag schaltet ein Flag global an/aus, NACHDEM geprueft wurde, dass
|
||||
// das zugehoerige Modul lizenziert ist (Akzeptanzkriterium 2 / Pruefung 1).
|
||||
// Ein nicht lizenziertes Modul wird mit ErrFlagNotLicensed abgelehnt, bevor
|
||||
// irgendein Schreibzugriff erfolgt.
|
||||
func (h *Handler) ToggleFlag(ctx context.Context, tenantID, key string, enabled bool) error {
|
||||
lic, err := h.licenseStore.Status(ctx, tenantID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("lizenzstatus lesen: %w", err)
|
||||
}
|
||||
|
||||
if enabled {
|
||||
if _, _, licensed := isModuleLicensed(key, lic.Modules); !licensed {
|
||||
return ErrFlagNotLicensed
|
||||
}
|
||||
}
|
||||
|
||||
existing, err := h.flagStore.Get(ctx, key)
|
||||
if err != nil && !errors.Is(err, flag.ErrNotFound) {
|
||||
return fmt.Errorf("flag lesen: %w", err)
|
||||
}
|
||||
existing.Key = key
|
||||
existing.Enabled = enabled
|
||||
|
||||
if err := h.flagStore.Set(ctx, existing); err != nil {
|
||||
return fmt.Errorf("flag speichern: %w", err)
|
||||
}
|
||||
h.flagService.Invalidate(key)
|
||||
return nil
|
||||
}
|
||||
|
||||
// --- HTTP-Bindung ---
|
||||
|
||||
func (h *Handler) OverviewHandler(w http.ResponseWriter, r *http.Request) {
|
||||
tenantID := r.URL.Query().Get("tenant")
|
||||
if tenantID == "" {
|
||||
writeError(w, http.StatusBadRequest, "tenant-parameter fehlt")
|
||||
return
|
||||
}
|
||||
overview, err := h.Overview(r.Context(), tenantID)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, err.Error())
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, overview)
|
||||
}
|
||||
|
||||
type toggleRequest struct {
|
||||
Tenant string `json:"tenant"`
|
||||
Key string `json:"key"`
|
||||
Enabled bool `json:"enabled"`
|
||||
}
|
||||
|
||||
func (h *Handler) ToggleFlagHandler(w http.ResponseWriter, r *http.Request) {
|
||||
var req toggleRequest
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
|
||||
return
|
||||
}
|
||||
if req.Tenant == "" || req.Key == "" {
|
||||
writeError(w, http.StatusBadRequest, "tenant und key sind erforderlich")
|
||||
return
|
||||
}
|
||||
|
||||
err := h.ToggleFlag(r.Context(), req.Tenant, req.Key, req.Enabled)
|
||||
switch {
|
||||
case err == nil:
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
case errors.Is(err, ErrFlagNotLicensed):
|
||||
writeError(w, http.StatusForbidden, ErrFlagNotLicensed.Error())
|
||||
default:
|
||||
writeError(w, http.StatusInternalServerError, err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, status int, body any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
_ = json.NewEncoder(w).Encode(body)
|
||||
}
|
||||
|
||||
func writeError(w http.ResponseWriter, status int, message string) {
|
||||
writeJSON(w, status, map[string]string{"error": message})
|
||||
}
|
||||
Reference in New Issue
Block a user