Revert "Adminbereich mit Rollen und Nutzerauswertung ergänzen"

This reverts commit e432943ea7.
This commit is contained in:
Eugenius Naumenko
2026-10-10 20:27:55 +00:00
parent e432943ea7
commit 2447537652
14 changed files with 18 additions and 634 deletions
-25
View File
@@ -6,34 +6,9 @@ type User struct {
ID string `json:"id"`
Email string `json:"email"`
UILanguage string `json:"ui_language"`
Role string `json:"role"`
CreatedAt time.Time `json:"created_at"`
}
type AdminOverview struct {
UsersTotal int `json:"users_total"`
UsersActive7Days int `json:"users_active_7_days"`
AttemptsTotal int `json:"attempts_total"`
ExercisesGenerated int `json:"exercises_generated"`
AverageScore float64 `json:"average_score"`
}
type AdminUser struct {
ID string `json:"id"`
Email string `json:"email"`
Role string `json:"role"`
CreatedAt time.Time `json:"created_at"`
Attempts int `json:"attempts"`
AverageScore float64 `json:"average_score"`
LastAttempt *time.Time `json:"last_attempt,omitempty"`
}
type AdminUserPage struct {
Users []AdminUser `json:"users"`
Total int `json:"total"`
Page int `json:"page"`
}
type LearnerProfile struct {
ID string `json:"id"`
UserID string `json:"user_id"`
-39
View File
@@ -1,39 +0,0 @@
package httpapi
import (
"net/http"
"strconv"
"strings"
)
func (s *Server) adminOverview(w http.ResponseWriter, r *http.Request) {
overview, err := s.store.AdminOverview(r.Context())
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
writeJSON(w, http.StatusOK, overview)
}
func (s *Server) adminUsers(w http.ResponseWriter, r *http.Request) {
search := strings.TrimSpace(r.URL.Query().Get("search"))
if len(search) > 100 {
writeError(w, http.StatusBadRequest, nil)
return
}
page := 1
if value := r.URL.Query().Get("page"); value != "" {
parsed, err := strconv.Atoi(value)
if err != nil || parsed < 1 || parsed > 100000 {
writeError(w, http.StatusBadRequest, nil)
return
}
page = parsed
}
users, err := s.store.AdminUsers(r.Context(), search, page)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
writeJSON(w, http.StatusOK, users)
}
-84
View File
@@ -1,84 +0,0 @@
package httpapi
import (
"context"
"io"
"log/slog"
"net/http"
"net/http/httptest"
"testing"
"speech-learning-api/internal/config"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/services"
)
type adminTestStore struct {
DataStore
role string
}
func (s *adminTestStore) GetUser(_ context.Context, id string) (domain.User, error) {
return domain.User{ID: id, Role: s.role}, nil
}
func (s *adminTestStore) AdminOverview(_ context.Context) (domain.AdminOverview, error) {
return domain.AdminOverview{UsersTotal: 3}, nil
}
func (s *adminTestStore) AdminUsers(_ context.Context, _ string, page int) (domain.AdminUserPage, error) {
return domain.AdminUserPage{Page: page}, nil
}
func (s *adminTestStore) DebugStatus(_ context.Context) domain.DebugDBStatus {
return domain.DebugDBStatus{OK: true}
}
func TestAdminRoutesRequireCurrentAdminRole(t *testing.T) {
data := &adminTestStore{role: "learner"}
auth := services.NewAuthService(nil, "test-secret")
server := &Server{
cfg: config.Config{DebugEnabled: true},
store: data, auth: auth,
logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
}
token, err := auth.IssueToken("usr_1")
if err != nil {
t.Fatal(err)
}
for _, testCase := range []struct {
path string
}{
{"/admin/overview"},
{"/admin/users"},
{"/debug/status"},
} {
t.Run(testCase.path, func(t *testing.T) {
handler := server.Routes()
request := func(withToken bool) int {
req := httptest.NewRequest(http.MethodGet, testCase.path, nil)
if withToken {
req.Header.Set("Authorization", "Bearer "+token)
}
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, req)
return recorder.Code
}
data.role = "learner"
if got := request(false); got != http.StatusUnauthorized {
t.Fatalf("anonymous status = %d, want 401", got)
}
if got := request(true); got != http.StatusForbidden {
t.Fatalf("learner status = %d, want 403", got)
}
data.role = "admin"
if got := request(true); got != http.StatusOK {
t.Fatalf("admin status = %d, want 200", got)
}
data.role = "learner"
if got := request(true); got != http.StatusForbidden {
t.Fatalf("demoted admin status = %d, want 403", got)
}
})
}
}
-17
View File
@@ -125,23 +125,6 @@ func (s *Server) requireAuth(next http.Handler) http.Handler {
})
}
// Admin rights are read from PostgreSQL for every request. A previously
// issued token does not preserve privileges after an account is demoted.
func (s *Server) requireAdmin(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
user, err := s.store.GetUser(r.Context(), currentUserID(r))
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
if user.Role != "admin" {
writeError(w, http.StatusForbidden, nil)
return
}
next.ServeHTTP(w, r)
})
}
func currentUserID(r *http.Request) string {
value, _ := r.Context().Value(userIDKey).(string)
return value
+5 -9
View File
@@ -26,8 +26,6 @@ type DataStore interface {
GetExercise(ctx context.Context, id, userID string) (domain.Exercise, error)
SaveAttempt(ctx context.Context, attempt domain.Attempt) (domain.Attempt, error)
Progress(ctx context.Context, userID string, limit int) (domain.ProgressSummary, error)
AdminOverview(ctx context.Context) (domain.AdminOverview, error)
AdminUsers(ctx context.Context, search string, page int) (domain.AdminUserPage, error)
CreateConversationSession(ctx context.Context, userID, targetLanguage, cefrLevel string) (domain.ConversationSession, error)
SaveConversationTurn(ctx context.Context, turn domain.ConversationTurn) (domain.ConversationTurn, error)
DebugStatus(ctx context.Context) domain.DebugDBStatus
@@ -64,14 +62,12 @@ func (s *Server) Routes() http.Handler {
mux.Handle("POST /practice/attempts", s.requireAuth(http.HandlerFunc(s.createAttempt)))
mux.Handle("POST /conversation/start", s.requireAuth(http.HandlerFunc(s.startConversation)))
mux.Handle("POST /conversation/{id}/turn", s.requireAuth(http.HandlerFunc(s.conversationTurn)))
mux.Handle("GET /admin/overview", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.adminOverview))))
mux.Handle("GET /admin/users", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.adminUsers))))
if s.cfg.DebugEnabled {
mux.Handle("GET /debug/status", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugStatus))))
mux.Handle("GET /debug/db", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugDB))))
mux.Handle("GET /debug/flowise", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugFlowise))))
mux.Handle("GET /debug/azure", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugAzure))))
mux.Handle("GET /debug/runtime", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugRuntime))))
mux.Handle("GET /debug/status", s.requireAuth(http.HandlerFunc(s.debugStatus)))
mux.Handle("GET /debug/db", s.requireAuth(http.HandlerFunc(s.debugDB)))
mux.Handle("GET /debug/flowise", s.requireAuth(http.HandlerFunc(s.debugFlowise)))
mux.Handle("GET /debug/azure", s.requireAuth(http.HandlerFunc(s.debugAzure)))
mux.Handle("GET /debug/runtime", s.requireAuth(http.HandlerFunc(s.debugRuntime)))
}
return s.requestID(s.requestLogging(s.cors(mux)))
-71
View File
@@ -1,71 +0,0 @@
package store
import (
"context"
"database/sql"
"strings"
"speech-learning-api/internal/domain"
)
func (s *PostgresStore) AdminOverview(ctx context.Context) (domain.AdminOverview, error) {
var overview domain.AdminOverview
err := s.db.QueryRowContext(ctx, `
SELECT
(SELECT COUNT(*) FROM users),
(SELECT COUNT(DISTINCT user_id) FROM attempts WHERE created_at >= now() - interval '7 days'),
(SELECT COUNT(*) FROM attempts),
(SELECT COUNT(*) FROM exercises WHERE source = 'flowise'),
(SELECT COALESCE(AVG(overall_score), 0) FROM attempts)
`).Scan(&overview.UsersTotal, &overview.UsersActive7Days, &overview.AttemptsTotal,
&overview.ExercisesGenerated, &overview.AverageScore)
return overview, err
}
func (s *PostgresStore) AdminUsers(ctx context.Context, search string, page int) (domain.AdminUserPage, error) {
if page < 1 {
page = 1
}
search = strings.TrimSpace(search)
result := domain.AdminUserPage{Users: []domain.AdminUser{}, Page: page}
if err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM users WHERE ($1 = '' OR email ILIKE '%' || $1 || '%')
`, search).Scan(&result.Total); err != nil {
return domain.AdminUserPage{}, err
}
rows, err := s.db.QueryContext(ctx, `
WITH selected AS (
SELECT id, email, role, created_at
FROM users
WHERE ($1 = '' OR email ILIKE '%' || $1 || '%')
ORDER BY created_at DESC, id DESC
LIMIT 25 OFFSET $2
)
SELECT u.id, u.email, u.role, u.created_at,
a.attempts, a.average_score, a.last_attempt
FROM selected u
LEFT JOIN LATERAL (
SELECT COUNT(*) AS attempts, COALESCE(AVG(overall_score), 0) AS average_score,
MAX(created_at) AS last_attempt
FROM attempts WHERE user_id = u.id
) a ON true
ORDER BY u.created_at DESC, u.id DESC
`, search, (page-1)*25)
if err != nil {
return domain.AdminUserPage{}, err
}
defer rows.Close()
for rows.Next() {
var user domain.AdminUser
var last sql.NullTime
if err := rows.Scan(&user.ID, &user.Email, &user.Role, &user.CreatedAt,
&user.Attempts, &user.AverageScore, &last); err != nil {
return domain.AdminUserPage{}, err
}
if last.Valid {
user.LastAttempt = &last.Time
}
result.Users = append(result.Users, user)
}
return result, rows.Err()
}
+6 -11
View File
@@ -142,9 +142,9 @@ func (s *PostgresStore) CreateUser(ctx context.Context, email, passwordHash, uiL
row := s.db.QueryRowContext(ctx, `
INSERT INTO users (id, email, password_hash, ui_language)
VALUES ($1, $2, $3, $4)
RETURNING id, email, ui_language, role, created_at
RETURNING id, email, ui_language, created_at
`, user.ID, user.Email, passwordHash, uiLanguage)
if err := row.Scan(&user.ID, &user.Email, &user.UILanguage, &user.Role, &user.CreatedAt); err != nil {
if err := row.Scan(&user.ID, &user.Email, &user.UILanguage, &user.CreatedAt); err != nil {
return domain.User{}, err
}
return user, nil
@@ -154,11 +154,11 @@ func (s *PostgresStore) GetPasswordHashByEmail(ctx context.Context, email string
var user domain.User
var hash string
row := s.db.QueryRowContext(ctx, `
SELECT id, email, password_hash, ui_language, role, created_at
SELECT id, email, password_hash, ui_language, created_at
FROM users
WHERE email = $1
`, strings.ToLower(strings.TrimSpace(email)))
if err := row.Scan(&user.ID, &user.Email, &hash, &user.UILanguage, &user.Role, &user.CreatedAt); err != nil {
if err := row.Scan(&user.ID, &user.Email, &hash, &user.UILanguage, &user.CreatedAt); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return domain.User{}, "", ErrNotFound
}
@@ -170,11 +170,11 @@ func (s *PostgresStore) GetPasswordHashByEmail(ctx context.Context, email string
func (s *PostgresStore) GetUser(ctx context.Context, id string) (domain.User, error) {
var user domain.User
row := s.db.QueryRowContext(ctx, `
SELECT id, email, ui_language, role, created_at
SELECT id, email, ui_language, created_at
FROM users
WHERE id = $1
`, id)
if err := row.Scan(&user.ID, &user.Email, &user.UILanguage, &user.Role, &user.CreatedAt); err != nil {
if err := row.Scan(&user.ID, &user.Email, &user.UILanguage, &user.CreatedAt); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return domain.User{}, ErrNotFound
}
@@ -558,11 +558,6 @@ CREATE TABLE IF NOT EXISTS users (
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
-- Existing installations receive the role on startup; public registration
-- continues to create only learner accounts.
ALTER TABLE users ADD COLUMN IF NOT EXISTS role TEXT NOT NULL DEFAULT 'learner'
CHECK (role IN ('learner', 'admin'));
CREATE TABLE IF NOT EXISTS learner_profiles (
id TEXT PRIMARY KEY,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-11
View File
@@ -1,11 +0,0 @@
import { request } from './client';
import type { AdminOverview, AdminUserPage } from './types';
export function fetchAdminOverview() {
return request<AdminOverview>('/admin/overview');
}
export function fetchAdminUsers(search: string, page: number) {
const params = new URLSearchParams({ search, page: String(page) });
return request<AdminUserPage>(`/admin/users?${params}`);
}
+1 -5
View File
@@ -1,9 +1,5 @@
import { request, setToken } from './client';
import type { AuthResult, LearnerProfile, User } from './types';
export function fetchMe() {
return request<{ user: User; profile: LearnerProfile }>('/me');
}
import type { AuthResult } from './types';
export async function register(email: string, password: string) {
const result = await request<AuthResult>('/auth/register', {
-25
View File
@@ -2,34 +2,9 @@ export type User = {
id: string;
email: string;
ui_language: string;
role: 'learner' | 'admin';
created_at: string;
};
export type AdminOverview = {
users_total: number;
users_active_7_days: number;
attempts_total: number;
exercises_generated: number;
average_score: number;
};
export type AdminUser = {
id: string;
email: string;
role: 'learner' | 'admin';
created_at: string;
attempts: number;
average_score: number;
last_attempt?: string;
};
export type AdminUserPage = {
users: AdminUser[];
total: number;
page: number;
};
export type LearnerProfile = {
id: string;
user_id: string;
+5 -60
View File
@@ -1,10 +1,8 @@
import { BookOpen, Bug, ChartNoAxesColumnIncreasing, LogOut, Mic, MessageCircle, Shield } from 'lucide-react';
import { BookOpen, Bug, ChartNoAxesColumnIncreasing, LogOut, Mic, MessageCircle } from 'lucide-react';
import { useEffect, useState } from 'react';
import { fetchMe } from '../api/auth';
import { ApiError, clearToken, getToken } from '../api/client';
import { clearToken, getToken } from '../api/client';
import { fetchDebugStatus } from '../api/debug';
import type { Exercise, Lesson, User } from '../api/types';
import { AdminPage } from '../pages/AdminPage';
import type { Exercise, Lesson } from '../api/types';
import { DashboardPage } from '../pages/DashboardPage';
import { LoginPage } from '../pages/LoginPage';
import { RegisterPage } from '../pages/RegisterPage';
@@ -17,38 +15,11 @@ import { useHashRoute } from './useHashRoute';
export function App() {
const [route, setRoute] = useHashRoute(getToken() ? 'dashboard' : 'login');
const [debugAvailable, setDebugAvailable] = useState(false);
const [user, setUser] = useState<User | null>(null);
const [authError, setAuthError] = useState('');
const [authRevision, setAuthRevision] = useState(0);
const [practiceSelection, setPracticeSelection] = useState<{ lesson: Lesson; exercise: Exercise } | null>(null);
const authed = Boolean(getToken());
useEffect(() => {
if (!authed) {
setUser(null);
return;
}
let cancelled = false;
setAuthError('');
fetchMe().then(({ user: currentUser }) => {
if (!cancelled) {
setUser(currentUser);
setAuthError('');
}
}).catch((error) => {
if (cancelled) return;
if (error instanceof ApiError && error.status === 401) {
clearToken();
setRoute('login');
} else {
setAuthError(error instanceof Error ? error.message : 'Konto konnte nicht geladen werden.');
}
});
return () => { cancelled = true; };
}, [authed, authRevision]);
useEffect(() => {
if (!authed || user?.role !== 'admin') {
setDebugAvailable(false);
return;
}
@@ -63,21 +34,18 @@ export function App() {
return () => {
cancelled = true;
};
}, [authed, user?.role]);
}, [authed]);
useEffect(() => {
if (route !== 'practice') setPracticeSelection(null);
}, [route]);
function handleAuthed() {
setUser(null);
setAuthRevision((value) => value + 1);
setRoute('dashboard');
}
function logout() {
clearToken();
setUser(null);
setPracticeSelection(null);
setRoute('login');
}
@@ -99,23 +67,6 @@ export function App() {
);
}
if (!user) {
return (
<main className="auth-shell">
<div className="auth-panel">
<h1>Konto wird geladen</h1>
{authError ? (
<>
<p className="form-error" role="alert">{authError}</p>
<button className="primary-button" onClick={() => setAuthRevision((value) => value + 1)}>Erneut versuchen</button>
<button className="link-button" onClick={logout}>Abmelden</button>
</>
) : <p className="muted">Bitte einen Moment warten.</p>}
</div>
</main>
);
}
return (
<div className="app-shell">
<aside className="sidebar" aria-label="Navigation">
@@ -140,11 +91,6 @@ export function App() {
<button className={route === 'progress' ? 'active' : ''} onClick={() => setRoute('progress')}>
<ChartNoAxesColumnIncreasing size={18} /> Fortschritt
</button>
{user.role === 'admin' && (
<button className={route === 'admin' ? 'active' : ''} onClick={() => setRoute('admin')}>
<Shield size={18} /> Adminbereich
</button>
)}
{debugAvailable && (
<button className={route === 'debug' ? 'active' : ''} onClick={() => setRoute('debug')}>
<Bug size={18} /> Debug
@@ -162,8 +108,7 @@ export function App() {
{route === 'practice' && <PracticePage initialSelection={practiceSelection} />}
{route === 'conversation' && <ConversationPage />}
{route === 'progress' && <ProgressPage />}
{route === 'admin' && (user.role === 'admin' ? <AdminPage /> : <p className="form-error">Kein Zugriff auf den Adminbereich.</p>)}
{route === 'debug' && debugAvailable && <DebugPage />}
{route === 'debug' && <DebugPage />}
</main>
</div>
);
-124
View File
@@ -340,118 +340,6 @@ input:focus {
gap: 14px;
}
.admin-view {
max-width: 1280px;
}
.admin-metrics {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(175px, 1fr));
gap: 14px;
}
.admin-users,
.admin-product {
display: grid;
gap: 18px;
}
.admin-section-head {
display: flex;
justify-content: space-between;
align-items: flex-start;
gap: 20px;
}
.admin-section-head h2,
.admin-product h2 {
margin: 0;
}
.admin-section-head p,
.admin-product p {
margin-bottom: 0;
}
.admin-count,
.admin-role {
display: inline-flex;
padding: 5px 10px;
border-radius: 999px;
color: #0e5f47;
background: #e5f4ec;
font-size: 0.82rem;
font-weight: 800;
white-space: nowrap;
}
.admin-role-staff {
color: #4a397f;
background: #eeeafb;
}
.admin-search {
max-width: 520px;
}
.admin-search .action-row {
flex-wrap: nowrap;
}
.admin-table-wrap {
overflow-x: auto;
}
.admin-table {
width: 100%;
min-width: 780px;
border-collapse: collapse;
text-align: left;
}
.admin-table th,
.admin-table td {
padding: 13px 10px;
border-bottom: 1px solid #e2e7e4;
}
.admin-table th {
color: #526158;
font-size: 0.82rem;
}
.admin-table td small {
display: block;
margin-top: 3px;
color: #657269;
}
.admin-empty {
padding: 15px 10px;
}
.admin-pagination {
display: flex;
align-items: center;
justify-content: flex-end;
gap: 12px;
}
.admin-next-steps {
display: flex;
flex-wrap: wrap;
gap: 8px;
}
.admin-next-steps span {
padding: 8px 10px;
border-radius: 8px;
background: #f1f4f2;
color: #526158;
font-weight: 700;
font-size: 0.85rem;
}
.debug-card {
display: grid;
align-content: start;
@@ -659,16 +547,4 @@ input:focus {
.target-text {
font-size: 1.3rem;
}
.admin-section-head {
display: grid;
}
.admin-search .action-row {
flex-wrap: wrap;
}
.admin-pagination {
justify-content: space-between;
}
}
-116
View File
@@ -1,116 +0,0 @@
import { useEffect, useState, type FormEvent } from 'react';
import { fetchAdminOverview, fetchAdminUsers } from '../api/admin';
import type { AdminOverview, AdminUserPage } from '../api/types';
function formatDate(value?: string) {
return value ? new Date(value).toLocaleDateString('de-DE') : 'Noch kein Versuch';
}
export function AdminPage() {
const [overview, setOverview] = useState<AdminOverview | null>(null);
const [users, setUsers] = useState<AdminUserPage | null>(null);
const [searchInput, setSearchInput] = useState('');
const [search, setSearch] = useState('');
const [page, setPage] = useState(1);
const [overviewError, setOverviewError] = useState('');
const [usersError, setUsersError] = useState('');
useEffect(() => {
let cancelled = false;
fetchAdminOverview()
.then((data) => { if (!cancelled) setOverview(data); })
.catch((error) => { if (!cancelled) setOverviewError(error instanceof Error ? error.message : 'Kennzahlen konnten nicht geladen werden.'); });
return () => { cancelled = true; };
}, []);
useEffect(() => {
let cancelled = false;
fetchAdminUsers(search, page)
.then((data) => { if (!cancelled) { setUsers(data); setUsersError(''); } })
.catch((error) => { if (!cancelled) setUsersError(error instanceof Error ? error.message : 'Nutzer konnten nicht geladen werden.'); });
return () => { cancelled = true; };
}, [search, page]);
function submitSearch(event: FormEvent<HTMLFormElement>) {
event.preventDefault();
setPage(1);
setSearch(searchInput.trim());
}
return (
<div className="view-stack admin-view">
<header className="view-header">
<div>
<p className="eyebrow">Verwaltung</p>
<h1>Adminbereich</h1>
<p className="muted">Nutzer und Lernaktivität im Blick.</p>
</div>
</header>
{overviewError && <p className="form-error" role="alert">{overviewError}</p>}
<section className="admin-metrics" aria-label="Produktkennzahlen">
<div className="panel metric"><span>Nutzer gesamt</span><strong>{overview?.users_total ?? '–'}</strong></div>
<div className="panel metric"><span>Aktiv in 7 Tagen</span><strong>{overview?.users_active_7_days ?? '–'}</strong></div>
<div className="panel metric"><span>Sprechversuche</span><strong>{overview?.attempts_total ?? '–'}</strong></div>
<div className="panel metric"><span>Flowise-Übungen</span><strong>{overview?.exercises_generated ?? '–'}</strong></div>
<div className="panel metric"><span>Ø Bewertung</span><strong>{overview ? Math.round(overview.average_score) : '–'}</strong></div>
</section>
<section className="panel admin-users">
<div className="admin-section-head">
<div>
<h2>Nutzer</h2>
<p className="muted">Konten und Lernaktivität. Suche nach E-Mail-Adresse.</p>
</div>
<span className="admin-count">{users?.total ?? '–'} Treffer</span>
</div>
<form className="admin-search" onSubmit={submitSearch}>
<label htmlFor="admin-user-search">E-Mail suchen</label>
<div className="action-row">
<input id="admin-user-search" type="search" value={searchInput} maxLength={100}
onChange={(event) => setSearchInput(event.target.value)} placeholder="name@beispiel.de" />
<button className="primary-button" type="submit">Suchen</button>
</div>
</form>
{usersError && <p className="form-error" role="alert">{usersError}</p>}
<div className="admin-table-wrap">
<table className="admin-table">
<thead><tr><th>Nutzer</th><th>Rolle</th><th>Registriert</th><th>Versuche</th><th>Ø Bewertung</th><th>Letzter Versuch</th></tr></thead>
<tbody>
{(users?.users ?? []).map((user) => (
<tr key={user.id}>
<td><strong>{user.email}</strong><small>{user.id}</small></td>
<td><span className={user.role === 'admin' ? 'admin-role admin-role-staff' : 'admin-role'}>{user.role === 'admin' ? 'Admin' : 'Lernende'}</span></td>
<td>{formatDate(user.created_at)}</td>
<td>{user.attempts}</td>
<td>{user.attempts > 0 ? Math.round(user.average_score) : '–'}</td>
<td>{formatDate(user.last_attempt)}</td>
</tr>
))}
</tbody>
</table>
{users && users.users.length === 0 && <p className="muted admin-empty">Keine passenden Nutzer gefunden.</p>}
{!users && !usersError && <p className="muted admin-empty">Lade Nutzer...</p>}
</div>
<div className="admin-pagination">
<button className="ghost-button" disabled={page <= 1} onClick={() => setPage(page - 1)}>Zurück</button>
<span>Seite {page} von {Math.max(1, Math.ceil((users?.total ?? 0) / 25))}</span>
<button className="ghost-button" disabled={!users || page * 25 >= users.total} onClick={() => setPage(page + 1)}>Weiter</button>
</div>
</section>
<section className="panel admin-product">
<div>
<p className="eyebrow">Produktbetrieb</p>
<h2>Verkauf und Zugänge</h2>
<p>Tarife, Zahlungen und Berechtigungen für gekaufte Inhalte sind noch nicht angeschlossen. Deshalb zeigt dieser Bereich keine erfundenen Umsatz- oder Abozahlen.</p>
</div>
<div className="admin-next-steps">
<span>Als Nächstes: Produktkatalog</span>
<span>Dann: Zahlungsanbieter und Webhooks</span>
<span>Danach: Zugangsrechte pro Kauf</span>
</div>
</section>
</div>
);
}