Mehrsprachige Bedienung und versionierte Aufgabenvarianten einführen

Übersetzungskataloge, getrennte Sprachpräferenzen und einen versionierten Aufgabenpilot ergänzen. Historische Aufgaben und Bewertungen bleiben erhalten; äquivalente Ansichten teilen Nachweise. Lokal mit Race-Tests und PostgreSQL, Vet, Web-Build, Bank-Audits und Browser-Fixtures geprüft. Dieser Stand dient als Ausgangspunkt für die anschließend beauftragte Zusammenführung zur Muttersprache.
This commit is contained in:
Eugenius Naumenko
2026-11-07 16:26:26 +00:00
parent 87684ba0fd
commit f3d42ee2b6
68 changed files with 3895 additions and 481 deletions
+62 -41
View File
@@ -23,39 +23,59 @@ type CoursePack struct {
Reserves []AdaptiveTask `json:"reserves"`
}
type TaskOption struct {
ID string `json:"id"`
Label string `json:"label"`
ID string `json:"id"`
Label string `json:"label"`
Language string `json:"language,omitempty"`
Role string `json:"role,omitempty"`
}
type TaskKey struct {
CorrectOptionID string `json:"correct_option_id,omitempty"`
ReferenceAnswer string `json:"reference_answer,omitempty"`
Rubric []string `json:"rubric"`
Explanation string `json:"explanation"`
CorrectOptionID string `json:"correct_option_id,omitempty"`
ReferenceAnswer string `json:"reference_answer,omitempty"`
ReferenceAnswerLanguage string `json:"reference_answer_language,omitempty"`
Rubric []string `json:"rubric"`
Explanation string `json:"explanation"`
}
// TaskStimulus is public exercise material, separate from the instruction.
// Private listening text remains AudioText and is excluded by Public(false).
type TaskStimulus struct {
Role string `json:"role"`
Language string `json:"language"`
Text string `json:"text"`
}
type AdaptiveTask struct {
SchemaVersion int `json:"schema_version"`
ID string `json:"id,omitempty"`
ModuleID string `json:"module_id"`
OriginModuleKey string `json:"origin_module_key,omitempty"`
TargetLanguage string `json:"target_language"`
CourseVersion string `json:"course_version"`
CEFRLevel string `json:"cefr_level"`
Skill string `json:"skill"`
Kind string `json:"kind"`
Prompt string `json:"prompt"`
Passage string `json:"passage,omitempty"`
Options []TaskOption `json:"options,omitempty"`
ReferenceText string `json:"reference_text,omitempty"`
AudioText string `json:"audio_text,omitempty"`
AnswerKey *TaskKey `json:"answer_key,omitempty"`
Source string `json:"source,omitempty"`
BriefID string `json:"brief_id,omitempty"`
ExamID string `json:"exam_id,omitempty"`
Review bool `json:"review,omitempty"`
CreatedAt time.Time `json:"created_at,omitempty"`
SchemaVersion int `json:"schema_version"`
ID string `json:"id,omitempty"`
ModuleID string `json:"module_id"`
OriginModuleKey string `json:"origin_module_key,omitempty"`
TargetLanguage string `json:"target_language"`
CourseVersion string `json:"course_version"`
CEFRLevel string `json:"cefr_level"`
Skill string `json:"skill"`
Kind string `json:"kind"`
Prompt string `json:"prompt"`
Passage string `json:"passage,omitempty"`
Options []TaskOption `json:"options,omitempty"`
ReferenceText string `json:"reference_text,omitempty"`
AudioText string `json:"audio_text,omitempty"`
AnswerKey *TaskKey `json:"answer_key,omitempty"`
Source string `json:"source,omitempty"`
BriefID string `json:"brief_id,omitempty"`
ExamID string `json:"exam_id,omitempty"`
Review bool `json:"review,omitempty"`
CreatedAt time.Time `json:"created_at,omitempty"`
InstructionLanguage string `json:"instruction_language,omitempty"`
Instruction string `json:"instruction,omitempty"`
Stimulus *TaskStimulus `json:"stimulus,omitempty"`
VariantID string `json:"variant_id,omitempty"`
ContentRevision string `json:"content_revision,omitempty"`
CanonicalTaskID string `json:"canonical_task_id,omitempty"`
EvidenceTaskID string `json:"evidence_task_id,omitempty"`
}
func (t AdaptiveTask) Public(reveal bool) AdaptiveTask {
t.EvidenceTaskID = ""
if !reveal {
t.AnswerKey = nil
t.AudioText = ""
@@ -136,21 +156,22 @@ type CourseBrief struct {
Reason string `json:"reason"`
}
type CourseJob struct {
AIRevision int `json:"-"`
ID string `json:"id"`
UserID string `json:"-"`
Language string `json:"target_language"`
Kind string `json:"kind"`
ModuleID string `json:"module_id"`
Skill string `json:"skill,omitempty"`
SubjectID string `json:"subject_id,omitempty"`
Status string `json:"status"`
Stage string `json:"stage"`
TaskID string `json:"task_id,omitempty"`
Source string `json:"source,omitempty"`
Review bool `json:"review,omitempty"`
Error string `json:"error,omitempty"`
Lease string `json:"-"`
InstructionLanguage string `json:"instruction_language"`
AIRevision int `json:"-"`
ID string `json:"id"`
UserID string `json:"-"`
Language string `json:"target_language"`
Kind string `json:"kind"`
ModuleID string `json:"module_id"`
Skill string `json:"skill,omitempty"`
SubjectID string `json:"subject_id,omitempty"`
Status string `json:"status"`
Stage string `json:"stage"`
TaskID string `json:"task_id,omitempty"`
Source string `json:"source,omitempty"`
Review bool `json:"review,omitempty"`
Error string `json:"error,omitempty"`
Lease string `json:"-"`
}
type AdaptiveExam struct {
PreparationJobID string `json:"preparation_job_id,omitempty"`
+15
View File
@@ -9,3 +9,18 @@ type BankEntry struct {
Reviewed bool `json:"reviewed"`
Task AdaptiveTask `json:"task"`
}
// BankVariant references a reviewed base entry but has its own immutable revision.
// Only equivalent translations share a canonical identity with that base.
type BankVariant struct {
ModuleTitle string `json:"module_title"`
ModuleDescription string `json:"module_description"`
ID string `json:"id"`
Revision string `json:"revision"`
BaseEntryID string `json:"base_entry_id"`
CanonicalTaskID string `json:"canonical_task_id"`
InstructionLanguage string `json:"instruction_language"`
Equivalence string `json:"equivalence"`
Reviewed bool `json:"reviewed"`
Task AdaptiveTask `json:"task"`
}
+22 -5
View File
@@ -3,11 +3,28 @@ package domain
import "time"
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"`
ID string `json:"id"`
Email string `json:"email"`
UILanguage string `json:"ui_language"`
InstructionLanguage string `json:"instruction_language"`
Role string `json:"role"`
CreatedAt time.Time `json:"created_at"`
}
// ExplanationLanguage preserves compatibility with callers that construct users
// without the additive field; persisted accounts always have an explicit value.
func (u User) ExplanationLanguage() string {
if u.InstructionLanguage != "" {
return u.InstructionLanguage
}
if u.UILanguage != "" {
return u.UILanguage
}
return "de-DE"
}
func SupportedUILanguage(language string) bool {
return language == "de-DE" || language == "en-US"
}
type AdminOverview struct {
+49 -2
View File
@@ -34,6 +34,10 @@ func (s *Server) adaptiveProfile(w http.ResponseWriter, r *http.Request) (domain
return p, true
}
func adaptiveError(w http.ResponseWriter, err error) {
if errors.Is(err, store.ErrCourseVariantUnavailable) {
writeJSON(w, http.StatusConflict, map[string]string{"error": err.Error(), "code": "course_variant_unavailable"})
return
}
status := http.StatusInternalServerError
if errors.Is(err, store.ErrNotFound) {
status = http.StatusNotFound
@@ -72,7 +76,7 @@ func (s *Server) adaptiveCatalog(w http.ResponseWriter, r *http.Request) {
adaptiveError(w, err)
return
}
snap, err := s.course.Repo.Snapshot(r.Context(), user.ID, p.TargetLanguage, user.UILanguage)
snap, err := s.course.Repo.Snapshot(r.Context(), user.ID, p.TargetLanguage, user.ExplanationLanguage())
if err != nil {
adaptiveError(w, err)
return
@@ -112,7 +116,12 @@ func (s *Server) adaptiveCatalog(w http.ResponseWriter, r *http.Request) {
adaptiveError(w, err)
return
}
writeJSON(w, 200, map[string]any{"task_mode": s.course.Mode, "grading_available": s.course.EvaluationAvailable(r.Context()), "bank": inventory, "analysis_job": analysisJob, "profile": p, "modules": snap.Modules, "progress": snap.Progress, "analysis": snap.PreviousAnalysis, "facts_version": snap.FactsVersion, "enabled_languages": available, "languages": languages, "exams": exams})
instructionLanguages, err := s.course.Repo.InstructionLanguages(r.Context(), p.TargetLanguage)
if err != nil {
adaptiveError(w, err)
return
}
writeJSON(w, 200, map[string]any{"instruction_language": user.ExplanationLanguage(), "instruction_languages": instructionLanguages, "exam_available": s.course.Mode != "bank" || user.ExplanationLanguage() == "de-DE", "task_mode": s.course.Mode, "grading_available": s.course.EvaluationAvailable(r.Context()), "bank": inventory, "analysis_job": analysisJob, "profile": p, "modules": snap.Modules, "progress": snap.Progress, "analysis": snap.PreviousAnalysis, "facts_version": snap.FactsVersion, "enabled_languages": available, "languages": languages, "exams": exams})
}
func (s *Server) adaptiveNext(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
@@ -569,6 +578,24 @@ func (s *Server) adaptiveNewExam(w http.ResponseWriter, r *http.Request) {
writeError(w, 404, store.ErrNotFound)
return
}
if s.course.Mode == "bank" {
user, err := s.store.GetUser(r.Context(), currentUserID(r))
if err != nil {
adaptiveError(w, err)
return
}
if user.ExplanationLanguage() != "de-DE" {
exists, err := s.course.Repo.HasExamRequest(r.Context(), user.ID, p.TargetLanguage, input.RequestID)
if err != nil {
adaptiveError(w, err)
return
}
if !exists {
adaptiveError(w, store.ErrCourseVariantUnavailable)
return
}
}
}
exam, err := s.course.Repo.NewExam(r.Context(), currentUserID(r), p.TargetLanguage, input.RequestID)
if err != nil {
adaptiveError(w, err)
@@ -666,3 +693,23 @@ func legacyAdaptiveTask(t domain.AdaptiveTask) domain.CourseTask {
func writeLegacyAdaptiveTask(w http.ResponseWriter, t domain.AdaptiveTask) {
writeJSON(w, 200, domain.CoursePracticeResult{Task: legacyAdaptiveTask(t), Source: t.Source})
}
// Preference changes affect future jobs only. Task snapshots keep their original
// instructions, keys and evidence identity, including tasks in older exams.
func (s *Server) adaptiveInstructionLanguage(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
var input struct {
InstructionLanguage string `json:"instruction_language"`
}
if !adaptiveJSON(w, r, &input) {
return
}
if err := s.course.Repo.SetInstructionLanguage(r.Context(), currentUserID(r), p.TargetLanguage, input.InstructionLanguage); err != nil {
adaptiveError(w, err)
return
}
writeJSON(w, 200, map[string]string{"instruction_language": input.InstructionLanguage})
}
@@ -402,16 +402,25 @@ func TestBankBrowserSmoke(t *testing.T) {
stopDev()
t.Fatal("Vite did not start", devOutput.String())
}
node := exec.Command("node", "tests/course-bank.e2e.cjs")
node.Dir = web
node.Env = append(os.Environ(), "AI_E2E_API="+api.URL, "AI_E2E_TOKEN="+token, "AI_E2E_URL=http://localhost:15175")
output, err := node.CombinedOutput()
stopDev()
t.Log(string(output))
t.Log("Vite:", devOutput.String())
if err != nil {
t.Fatal(err)
for _, check := range []struct{ script, language string }{
{"tests/languages.e2e.cjs", "de-DE"},
{"tests/course-variants.e2e.cjs", "en-US"},
{"tests/course-bank.e2e.cjs", "de-DE"},
{"tests/course-bank.e2e.cjs", "en-US"},
} {
node := exec.Command("node", check.script)
node.Dir = web
node.Env = append(os.Environ(), "AI_E2E_API="+api.URL, "AI_E2E_TOKEN="+token, "AI_E2E_URL=http://localhost:15175")
node.Env = append(node.Env, "UI_E2E_LANGUAGE="+check.language)
output, err := node.CombinedOutput()
t.Log(string(output))
if err != nil {
stopDev()
t.Fatal(check.script, check.language, err)
}
}
stopDev()
t.Log("Vite:", devOutput.String())
}
func TestPronunciationBrowserSmoke(t *testing.T) {
@@ -126,7 +126,7 @@ func (s *Server) nextCoursePractice(w http.ResponseWriter, r *http.Request) {
}
request := domain.GenerateCourseTaskRequest{
Task: "generate_course_task", SchemaVersion: 1, TargetLanguage: detail.Module.TargetLanguage,
CEFRLevel: detail.Module.CEFRLevel, UILanguage: user.UILanguage, ModuleID: detail.Module.ID,
CEFRLevel: detail.Module.CEFRLevel, UILanguage: user.ExplanationLanguage(), ModuleID: detail.Module.ID,
Skill: selection.Goal.Skill, Kind: "choice", LearningGoal: selection.Goal,
LearningState: selection.State, AvoidPrompts: selection.AvoidPrompts,
}
+3 -2
View File
@@ -79,6 +79,7 @@ func (s *Server) Routes() http.Handler {
mux.Handle("POST /lessons/next", s.requireAuth(http.HandlerFunc(s.nextLesson)))
mux.Handle("GET /practice/exercises/{id}/audio", s.requireAuth(http.HandlerFunc(s.exerciseAudio)))
mux.Handle("POST /practice/attempts", s.requireAuth(http.HandlerFunc(s.createAttempt)))
mux.Handle("PUT /course/instruction-language", s.requireAuth(http.HandlerFunc(s.adaptiveInstructionLanguage)))
mux.Handle("GET /course/catalog", s.requireAuth(http.HandlerFunc(s.adaptiveCatalog)))
mux.Handle("POST /course/modules/{id}/tasks/next", s.requireAuth(http.HandlerFunc(s.adaptiveNext)))
mux.Handle("GET /course/modules/{id}/tasks", s.requireAuth(http.HandlerFunc(s.adaptiveHistory)))
@@ -195,7 +196,7 @@ func (s *Server) updatePreferences(w http.ResponseWriter, r *http.Request) {
writeError(w, http.StatusBadRequest, err)
return
}
profile, err := s.store.UpdatePreferences(r.Context(), currentUserID(r), req.UILanguage, req.TargetLanguage, valueOr(req.CEFRLevel, "A1"), req.DailyGoalMinutes)
profile, err := s.store.UpdatePreferences(r.Context(), currentUserID(r), req.UILanguage, req.TargetLanguage, req.CEFRLevel, req.DailyGoalMinutes)
if err != nil {
writeError(w, http.StatusBadRequest, err)
return
@@ -339,7 +340,7 @@ func (s *Server) nextAgentExercise(ctx context.Context, user domain.User, profil
Progress: progress,
TargetLanguage: profile.TargetLanguage,
CEFRLevel: profile.CEFRLevel,
UILanguage: user.UILanguage,
UILanguage: user.ExplanationLanguage(),
SessionID: flowiseSessionID(user.ID, profile.TargetLanguage, "practice"),
RecentWeakWords: progress.WeakWords,
PreferredType: "repeat_sentence",
@@ -155,6 +155,16 @@ func courseMember(s string, values []string) bool {
// Technical validity only. No word lists, English patterns, fixed objectives,
// fixed distractors, or linguistic judgement live in the application.
func ValidateAdaptiveTask(t domain.AdaptiveTask, language, module, skill string) error {
// Locale revisions and evidence identities are assigned by Go or the reviewed
// bank importer. Adding typed fields must not let model output claim them.
if t.VariantID != "" || t.ContentRevision != "" || t.CanonicalTaskID != "" || t.EvidenceTaskID != "" || t.InstructionLanguage != "" || t.Instruction != "" || t.Stimulus != nil || (t.AnswerKey != nil && t.AnswerKey.ReferenceAnswerLanguage != "") {
return errors.New("task contains server-owned variant metadata")
}
for _, option := range t.Options {
if option.Language != "" || option.Role != "" {
return errors.New("task contains server-owned option metadata")
}
}
if !courseText(t.ModuleID, 200) || !courseText(t.TargetLanguage, 50) || t.SchemaVersion != 2 || t.TargetLanguage != language || t.CourseVersion != domain.CourseVersion || t.CEFRLevel != "A1" || t.ModuleID != module || !courseMember(t.Skill, domain.CourseSkills) || (skill != "" && t.Skill != skill) {
return errors.New("task context mismatch")
}
+10 -3
View File
@@ -98,7 +98,11 @@ func (e *CourseEngine) snapshot(ctx context.Context, j domain.CourseJob) (domain
if err != nil {
return domain.CourseSnapshot{}, err
}
return e.Repo.Snapshot(ctx, j.UserID, j.Language, user.UILanguage)
instructionLanguage := j.InstructionLanguage
if instructionLanguage == "" {
instructionLanguage = user.ExplanationLanguage()
}
return e.Repo.Snapshot(ctx, j.UserID, j.Language, instructionLanguage)
}
func (e *CourseEngine) analyze(ctx context.Context, j domain.CourseJob) (domain.CourseSnapshot, error) {
snapshot, err := e.snapshot(ctx, j)
@@ -137,6 +141,9 @@ func (e *CourseEngine) Process(ctx context.Context, j domain.CourseJob) (*domain
}
return &t, err
case "exam":
if j.InstructionLanguage != "" && j.InstructionLanguage != "de-DE" {
return nil, store.ErrCourseVariantUnavailable
}
tasks, err := e.Repo.BankExam(ctx, j.UserID, j.Language, j.ModuleID)
if errors.Is(err, store.ErrNotFound) {
tasks, err = e.Repo.ReserveExam(ctx, j.UserID, j.Language, j.ModuleID)
@@ -538,7 +545,7 @@ func (e *CourseEngine) finalizeExam(ctx context.Context, j domain.CourseJob) err
var summary struct {
Summary string `json:"summary"`
}
err = e.Agent.Teacher(ctx, "summarize_course_exam", map[string]any{"target_language": j.Language, "ui_language": user.UILanguage, "exam": exam}, &summary)
err = e.Agent.Teacher(ctx, "summarize_course_exam", map[string]any{"target_language": j.Language, "ui_language": valueOr(j.InstructionLanguage, user.ExplanationLanguage()), "exam": exam}, &summary)
if err != nil {
return err
}
@@ -548,7 +555,7 @@ func (e *CourseEngine) finalizeExam(ctx context.Context, j domain.CourseJob) err
if err = e.Repo.ExamSummary(ctx, j.UserID, j.SubjectID, summary.Summary); err != nil {
return err
}
snapshot, err := e.Repo.Snapshot(ctx, j.UserID, j.Language, user.UILanguage)
snapshot, err := e.Repo.Snapshot(ctx, j.UserID, j.Language, user.ExplanationLanguage())
if err != nil {
return err
}
+3
View File
@@ -53,6 +53,9 @@ func (s *AuthService) Register(ctx context.Context, email, password, uiLanguage,
if uiLanguage == "" {
uiLanguage = "de-DE"
}
if !domain.SupportedUILanguage(uiLanguage) {
return AuthResult{}, errors.New("unsupported UI language")
}
if targetLanguage == "" {
targetLanguage = "en-US"
}
@@ -0,0 +1,218 @@
package services
import (
"bytes"
"context"
"encoding/json"
"errors"
"io"
"log/slog"
"testing"
"time"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/store"
)
func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
db, profiles := adaptiveTestDB(t)
ctx := context.Background()
user, err := profiles.CreateUser(ctx, "variants@example.test", "hash", "de-DE")
if err != nil {
t.Fatal(err)
}
if _, err = profiles.CreateLearnerProfile(ctx, user.ID, "en-US", "A1", 20); err != nil {
t.Fatal(err)
}
repo := store.NewAdaptiveStore(db)
engine := NewCourseEngine(repo, profiles, nil, slog.New(slog.NewTextHandler(io.Discard, nil)))
engine.Mode = "bank"
base, err := store.BundledBank()
if err != nil {
t.Fatal(err)
}
// Existing releases assigned ordinary task snapshots without locale metadata.
historical := func(skill string) domain.AdaptiveTask {
t.Helper()
var entry domain.BankEntry
for _, candidate := range base {
if candidate.Task.ModuleID == "a1_introductions_v1" && candidate.Task.Skill == skill && candidate.Task.Kind != "free_speech" && candidate.Task.Kind != "free_text" {
entry = candidate
break
}
}
task := entry.Task
task.ID = store.NewID("historic")
task.Source = "curated"
raw, _ := json.Marshal(task)
_, err := db.ExecContext(ctx, `INSERT INTO course_v2_tasks(id,module_id,language,version,owner_id,source,skill,kind,data,fingerprint,bank_entry_id,last_presented_at,presentation_count) VALUES($1,$2,$3,$4,$5,'curated',$6,$7,$8,$9,$10,now(),1)`, task.ID, task.ModuleID, task.TargetLanguage, task.CourseVersion, user.ID, task.Skill, task.Kind, raw, "bank:"+entry.ID, entry.ID)
if err != nil {
t.Fatal(err)
}
return task
}
old := historical("grammar")
oldSpeech := historical("speaking")
var before []byte
if err = db.QueryRowContext(ctx, `SELECT data FROM course_v2_tasks WHERE id=$1`, old.ID).Scan(&before); err != nil {
t.Fatal(err)
}
if _, _, err = engine.Submit(ctx, user.ID, "en-US", old.ID, "old-answer", old.AnswerKey.CorrectOptionID, nil); err != nil {
t.Fatal(err)
}
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "en-US"); err != nil {
t.Fatal(err)
}
run := func(skill, request string, changeAfterEnqueue bool) domain.AdaptiveTask {
t.Helper()
j, err := repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_introductions_v1", skill, "", request)
if err != nil {
t.Fatal(err)
}
if j.InstructionLanguage != "en-US" {
t.Fatal("job did not freeze explanation language", j)
}
if changeAfterEnqueue {
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "de-DE"); err != nil {
t.Fatal(err)
}
}
j, err = repo.Claim(ctx)
if err != nil {
t.Fatal(err)
}
task, err := engine.Process(ctx, j)
if err != nil {
t.Fatal(err)
}
if err = repo.Finish(ctx, j, task, ""); err != nil {
t.Fatal(err)
}
if task.InstructionLanguage != "en-US" || task.VariantID == "" || task.ContentRevision == "" || task.Instruction == "" {
t.Fatal("incomplete frozen variant", task)
}
return *task
}
first := run("grammar", "english-grammar-first", false)
if _, _, err = engine.Submit(ctx, user.ID, "en-US", first.ID, "english-first-answer", first.AnswerKey.CorrectOptionID, nil); err != nil {
t.Fatal(err)
}
translated := run("grammar", "english-grammar-second", true)
if !translated.Review || translated.EvidenceTaskID != old.ID {
t.Fatal("translation did not reuse existing evidence", translated, old)
}
if _, _, err = engine.Submit(ctx, user.ID, "en-US", translated.ID, "english-second-answer", translated.AnswerKey.CorrectOptionID, nil); err != nil {
t.Fatal(err)
}
replay, err := repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_introductions_v1", "grammar", "", "english-grammar-second")
if err != nil || replay.TaskID != translated.ID || replay.InstructionLanguage != "en-US" {
t.Fatal("locale change altered idempotent replay", replay, err)
}
snapshot, err := repo.Snapshot(ctx, user.ID, "en-US", "de-DE")
if err != nil {
t.Fatal(err)
}
found := false
for _, p := range snapshot.Progress {
if p.Skill == "grammar" && p.ModuleID == old.ModuleID {
found = true
if p.Attempts != 3 || p.DistinctTasks != 2 {
t.Fatalf("translation inflated task evidence: %+v", p)
}
}
}
if !found {
t.Fatal("missing graded evidence")
}
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "en-US"); err != nil {
t.Fatal(err)
}
inventory, err := repo.BankInventory(ctx, user.ID, "en-US")
if err != nil {
t.Fatal(err)
}
total := 0
for _, item := range inventory {
total += item.Total
if item.ModuleID != "a1_introductions_v1" {
t.Fatal("German fallback advertised as English", item)
}
}
if total != 12 {
t.Fatal("incorrect locale inventory", inventory)
}
// Local speech fixtures exercise the real observation path; no Azure is called.
speech := domain.PronunciationResult{Provider: "azure", Method: "scripted", Locale: "en-US", Alphabet: "IPA", OverallScore: 65, WordScores: []domain.WordScore{{Word: "name", Accuracy: 65, PhonemeScores: []domain.PhonemeScore{{Phoneme: "n", Accuracy: 60}}}}}
if _, _, err = engine.Submit(ctx, user.ID, "en-US", oldSpeech.ID, "old-speech", oldSpeech.ReferenceText, &speech); err != nil {
t.Fatal(err)
}
localizedSpeech := run("speaking", "localized-speech", false)
if localizedSpeech.Kind != "free_speech" { // The existing repeat may be scheduled after the unseen free task.
if localizedSpeech.Kind != "repeat_sentence" {
t.Fatal(localizedSpeech.Kind)
}
} else {
localizedSpeech = run("speaking", "localized-repeat", false)
}
if localizedSpeech.EvidenceTaskID != oldSpeech.ID {
t.Fatal("translated repeat changed evidence identity", localizedSpeech)
}
if _, _, err = engine.Submit(ctx, user.ID, "en-US", localizedSpeech.ID, "translated-speech", localizedSpeech.ReferenceText, &speech); err != nil {
t.Fatal(err)
}
profile, err := profiles.PronunciationProfile(ctx, user.ID, "en-US", time.Now().UTC().Add(time.Second))
if err != nil {
t.Fatal(err)
}
for _, target := range profile.Targets {
if target.Tasks != 1 || target.Samples != 1 {
t.Fatalf("translation inflated pronunciation density: %+v", target)
}
}
if len(profile.Targets) == 0 {
t.Fatal("missing fixture observations")
}
if err = profiles.Init(ctx); err != nil {
t.Fatal("restart after multiple locale assignments", err)
}
var after []byte
if err = db.QueryRowContext(ctx, `SELECT data FROM course_v2_tasks WHERE id=$1`, old.ID).Scan(&after); err != nil {
t.Fatal(err)
}
if !bytes.Equal(before, after) {
t.Fatal("historical snapshot was rewritten")
}
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "fr-FR"); !errors.Is(err, store.ErrCourseVariantUnavailable) {
t.Fatal("unsupported locale accepted", err)
}
// Missing reviewed variants must not silently select a German reserve.
if _, err = repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_family_v1", "grammar", "", "missing-variants"); err != nil {
t.Fatal(err)
}
job, err := repo.Claim(ctx)
if err != nil {
t.Fatal(err)
}
if _, err = engine.Process(ctx, job); !errors.Is(err, store.ErrCourseVariantUnavailable) {
t.Fatal("wrong-language fallback", err)
}
if err = repo.Finish(ctx, job, nil, "no reviewed variants"); err != nil {
t.Fatal(err)
}
history, err := repo.History(ctx, user.ID, "en-US", "a1_family_v1", 0)
if err != nil || len(history) != 0 {
t.Fatal("unsupported request assigned German content", history, err)
}
}
func TestModelCannotSetVariantEvidence(t *testing.T) {
entries, err := store.BundledBank()
if err != nil {
t.Fatal(err)
}
task := entries[0].Task
task.EvidenceTaskID = "another-assignment"
if ValidateAdaptiveTask(task, task.TargetLanguage, task.ModuleID, task.Skill) == nil {
t.Fatal("model-owned evidence identity accepted")
}
}
@@ -0,0 +1,107 @@
package services
import (
"context"
"testing"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/store"
)
func TestLanguagePreferencesPreserveCourseAndExplanations(t *testing.T) {
db, profiles := adaptiveTestDB(t)
ctx := context.Background()
user, err := profiles.CreateUser(ctx, "languages@example.test", "hash", "de-DE")
if err != nil {
t.Fatal(err)
}
original, err := profiles.CreateLearnerProfile(ctx, user.ID, "es-ES", "A2", 25)
if err != nil {
t.Fatal(err)
}
updated, err := profiles.UpdatePreferences(ctx, user.ID, "en-US", "", "", 0)
if err != nil {
t.Fatal(err)
}
if updated != original {
t.Fatalf("interface switch changed learning profile: before=%+v after=%+v", original, updated)
}
loaded, err := profiles.GetUser(ctx, user.ID)
if err != nil {
t.Fatal(err)
}
if loaded.UILanguage != "en-US" || loaded.InstructionLanguage != "de-DE" {
t.Fatalf("language roles conflated: %+v", loaded)
}
_, _, err = profiles.GetPasswordHashByEmail(ctx, user.Email)
if err != nil {
t.Fatal(err)
}
engine := NewCourseEngine(store.NewAdaptiveStore(db), profiles, nil, nil)
snapshot, err := engine.snapshot(ctx, domain.CourseJob{UserID: user.ID, Language: "es-ES"})
if err != nil {
t.Fatal(err)
}
if snapshot.UILanguage != "de-DE" {
t.Fatalf("model instructions follow interface language: %q", snapshot.UILanguage)
}
if _, err = profiles.UpdatePreferences(ctx, user.ID, "unsupported", "en-US", "A1", 10); err == nil {
t.Fatal("unsupported interface accepted")
}
active, err := profiles.GetPrimaryProfile(ctx, user.ID)
if err != nil || active != original {
t.Fatalf("rejected update changed active profile: %+v %v", active, err)
}
// A failed profile write must not commit the accompanying interface change.
if _, err = db.ExecContext(ctx, `ALTER TABLE learner_profiles ADD CONSTRAINT test_daily_limit CHECK(daily_goal_minutes<=60)`); err != nil {
t.Fatal(err)
}
if _, err = profiles.UpdatePreferences(ctx, user.ID, "de-DE", "en-US", "A1", 100); err == nil {
t.Fatal("expected profile constraint failure")
}
loaded, err = profiles.GetUser(ctx, user.ID)
if err != nil || loaded.UILanguage != "en-US" {
t.Fatalf("failed update changed interface: %+v %v", loaded, err)
}
active, err = profiles.GetPrimaryProfile(ctx, user.ID)
if err != nil || active != original {
t.Fatalf("failed update changed learning profile: %+v %v", active, err)
}
}
func TestInstructionLanguageMigrationPreservesLegacyPreference(t *testing.T) {
db, profiles := adaptiveTestDB(t)
ctx := context.Background()
user, err := profiles.CreateUser(ctx, "legacy-language@example.test", "hash", "fr-FR")
if err != nil {
t.Fatal(err)
}
// Simulate the previous schema in this disposable test schema only.
if _, err = db.ExecContext(ctx, `ALTER TABLE users DROP COLUMN instruction_language`); err != nil {
t.Fatal(err)
}
if err = profiles.Init(ctx); err != nil {
t.Fatal(err)
}
loaded, err := profiles.GetUser(ctx, user.ID)
if err != nil || loaded.InstructionLanguage != "fr-FR" {
t.Fatalf("legacy instruction preference lost: %+v %v", loaded, err)
}
if _, err = profiles.UpdatePreferences(ctx, user.ID, "en-US", "", "", 0); err != nil {
t.Fatal(err)
}
if err = profiles.Init(ctx); err != nil {
t.Fatal(err)
}
loaded, err = profiles.GetUser(ctx, user.ID)
if err != nil || loaded.UILanguage != "en-US" || loaded.InstructionLanguage != "fr-FR" {
t.Fatalf("repeated migration changed instruction preference: %+v %v", loaded, err)
}
result, err := NewAuthService(profiles, "language-test-only").Register(ctx, "new-language@example.test", "test-password", "en-US", "en-US", 15)
if err != nil {
t.Fatal(err)
}
if result.User.UILanguage != "en-US" || result.User.InstructionLanguage != "de-DE" {
t.Fatalf("new account did not keep German course explanations: %+v", result.User)
}
}
+8 -3
View File
@@ -89,7 +89,7 @@ func (s *AdaptiveStore) Task(ctx context.Context, user, language, id string) (do
t.BriefID = brief.String
t.ExamID = exam.String
if t.Source == "curated" && t.ExamID == "" {
t.Review = presentations > 1
t.Review = t.Review || presentations > 1
}
return t, nil
}
@@ -141,6 +141,7 @@ func fingerprint(t domain.AdaptiveTask) string {
return hex.EncodeToString(h[:])
}
func (s *AdaptiveStore) SaveTask(ctx context.Context, j domain.CourseJob, t domain.AdaptiveTask) (domain.AdaptiveTask, error) {
t.InstructionLanguage = j.InstructionLanguage
t.ID = NewID("a2")
if t.Source != "ai" {
t.Source = "flowise"
@@ -266,11 +267,15 @@ func (s *AdaptiveStore) Snapshot(ctx context.Context, user, language, uiLanguage
if err != nil {
return out, err
}
if err = s.localizeModuleLabels(ctx, language, uiLanguage, out.Modules); err != nil {
return out, err
}
err = s.db.QueryRowContext(ctx, `SELECT COALESCE((SELECT facts_version FROM course_v2_versions WHERE user_id=$1 AND language=$2 AND version=$3),0)`, user, language, domain.CourseVersion).Scan(&out.FactsVersion)
if err != nil {
return out, err
}
rows, err := s.db.QueryContext(ctx, `SELECT t.module_id,t.skill,count(*),count(DISTINCT t.id),avg((a.evaluation->>'score')::float8),(array_agg(a.id ORDER BY a.created_at DESC,a.id DESC))[1]
rows, err := s.db.QueryContext(ctx, `SELECT t.module_id,t.skill,count(*),count(DISTINCT COALESCE(NULLIF(t.data->>'evidence_task_id',''),t.id)),avg((a.evaluation->>'score')::float8),(array_agg(a.id ORDER BY a.created_at DESC,a.id DESC))[1]
FROM course_v2_attempts a JOIN course_v2_tasks t ON t.id=a.task_id WHERE a.user_id=$1 AND t.language=$2 AND t.version=$3 AND a.status='graded' AND NOT a.demo AND (a.exam_id IS NULL OR EXISTS(SELECT 1 FROM course_v2_exams e WHERE e.id=a.exam_id AND e.status='completed')) GROUP BY t.module_id,t.skill`, user, language, domain.CourseVersion)
if err != nil {
return out, err
@@ -422,7 +427,7 @@ func (s *AdaptiveStore) Submit(ctx context.Context, user, request string, t doma
return domain.AdaptiveAttempt{}, err
}
if actualID == id {
if err = recordPronunciation(ctx, tx, user, "course", actualID, "course:"+t.ID, t.TargetLanguage, t.ExamID, actualTime, *speech); err != nil {
if err = recordPronunciation(ctx, tx, user, "course", actualID, "course:"+valueOr(t.EvidenceTaskID, t.ID), t.TargetLanguage, t.ExamID, actualTime, *speech); err != nil {
return domain.AdaptiveAttempt{}, err
}
}
+3 -3
View File
@@ -11,7 +11,7 @@ import (
func (s *AdaptiveStore) Enqueue(ctx context.Context, user, language, kind, module, skill, subject, request string) (domain.CourseJob, error) {
id := NewID("job")
_, err := s.db.ExecContext(ctx, `INSERT INTO course_v2_jobs(id,user_id,language,version,kind,module_id,skill,subject_id,request_id) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9) ON CONFLICT(user_id,kind,request_id) DO NOTHING`, id, user, language, domain.CourseVersion, kind, module, skill, subject, request)
_, err := s.db.ExecContext(ctx, `INSERT INTO course_v2_jobs(id,user_id,language,version,kind,module_id,skill,subject_id,request_id,instruction_language) SELECT $1,$2,$3,$4,$5,$6,$7,$8,$9,COALESCE(NULLIF(u.instruction_language,''),NULLIF(u.ui_language,''),'de-DE') FROM users u WHERE u.id=$2 ON CONFLICT(user_id,kind,request_id) DO NOTHING`, id, user, language, domain.CourseVersion, kind, module, skill, subject, request)
if err != nil {
return domain.CourseJob{}, err
}
@@ -28,7 +28,7 @@ func (s *AdaptiveStore) Enqueue(ctx context.Context, user, language, kind, modul
func scanCourseJob(row interface{ Scan(...any) error }) (domain.CourseJob, error) {
var j domain.CourseJob
var result []byte
err := row.Scan(&j.ID, &j.UserID, &j.Language, &j.Kind, &j.ModuleID, &j.Skill, &j.SubjectID, &j.Status, &j.Stage, &j.Error, &j.Lease, &result, &j.AIRevision)
err := row.Scan(&j.ID, &j.UserID, &j.Language, &j.Kind, &j.ModuleID, &j.Skill, &j.SubjectID, &j.Status, &j.Stage, &j.Error, &j.Lease, &result, &j.AIRevision, &j.InstructionLanguage)
if errors.Is(err, sql.ErrNoRows) {
return j, ErrNotFound
}
@@ -51,7 +51,7 @@ func scanCourseJob(row interface{ Scan(...any) error }) (domain.CourseJob, error
return j, nil
}
const jobColumns = `id,user_id,language,kind,module_id,skill,subject_id,status,stage,error,lease,result,ai_revision`
const jobColumns = `id,user_id,language,kind,module_id,skill,subject_id,status,stage,error,lease,result,ai_revision,instruction_language`
func (s *AdaptiveStore) Job(ctx context.Context, user, language, id string) (domain.CourseJob, error) {
return scanCourseJob(s.db.QueryRowContext(ctx, `SELECT `+jobColumns+` FROM course_v2_jobs WHERE id=$1 AND user_id=$2 AND language=$3 AND version=$4`, id, user, language, domain.CourseVersion))
@@ -57,6 +57,9 @@ CREATE TABLE IF NOT EXISTS course_v2_jobs (
deliveries INT NOT NULL DEFAULT 0,created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
UNIQUE(user_id,kind,request_id)
);
ALTER TABLE course_v2_jobs ADD COLUMN IF NOT EXISTS instruction_language TEXT NOT NULL DEFAULT '';
-- Freeze the previous effective preference once for pre-existing queued jobs.
UPDATE course_v2_jobs j SET instruction_language=COALESCE(NULLIF(u.instruction_language,''),NULLIF(u.ui_language,''),'de-DE') FROM users u WHERE j.user_id=u.id AND j.instruction_language='';
ALTER TABLE course_v2_jobs ADD COLUMN IF NOT EXISTS ai_revision INT NOT NULL DEFAULT 0;
CREATE INDEX IF NOT EXISTS course_v2_queue ON course_v2_jobs(status,created_at);
UPDATE users u SET active_profile_id=(SELECT p.id FROM learner_profiles p WHERE p.user_id=u.id ORDER BY p.created_at,p.id LIMIT 1) WHERE active_profile_id IS NULL;
+50 -20
View File
@@ -29,7 +29,6 @@ ALTER TABLE course_v2_tasks ADD COLUMN IF NOT EXISTS bank_entry_id TEXT REFERENC
ALTER TABLE course_v2_tasks ADD COLUMN IF NOT EXISTS last_presented_at TIMESTAMPTZ;
ALTER TABLE course_v2_tasks ADD COLUMN IF NOT EXISTS presentation_count INT NOT NULL DEFAULT 0;
UPDATE course_v2_tasks SET presentation_count=1 WHERE source='curated' AND bank_entry_id IS NOT NULL AND presentation_count=0;
CREATE UNIQUE INDEX IF NOT EXISTS course_v2_bank_assignment ON course_v2_tasks(owner_id,bank_entry_id) WHERE exam_id IS NULL AND bank_entry_id IS NOT NULL;
ALTER TABLE course_v2_tasks DROP CONSTRAINT IF EXISTS course_v2_tasks_source_check;
ALTER TABLE course_v2_tasks ADD CONSTRAINT course_v2_tasks_source_check CHECK(source IN ('seed','flowise','ai','curated'));
ALTER TABLE course_v2_attempts DROP CONSTRAINT IF EXISTS course_v2_attempts_status_check;
@@ -201,15 +200,21 @@ func (s *AdaptiveStore) InstallBank(ctx context.Context) error {
return err
}
}
return tx.Commit()
if err = tx.Commit(); err != nil {
return err
}
return s.installVariants(ctx, entries)
}
type bankCandidate struct {
entry domain.BankEntry
taskID string
score float64
seen bool
presented int64
entry domain.BankEntry
bankEntryID string
variantID string
previousID string
taskID string
score float64
seen bool
presented int64
}
// AssignBankTask serializes selections per learner, including presentation of
@@ -245,9 +250,14 @@ func (s *AdaptiveStore) AssignBankTask(ctx context.Context, j domain.CourseJob)
return t, err
}
}
rows, err := tx.QueryContext(ctx, `SELECT b.data,COALESCE(t.id,''),COALESCE((SELECT (a.evaluation->>'score')::float8 FROM course_v2_attempts a WHERE a.task_id=t.id AND a.user_id=$1 AND a.status='graded' AND NOT a.demo ORDER BY a.created_at DESC,a.id DESC LIMIT 1),-1),COALESCE(extract(epoch from t.last_presented_at)::bigint,0)
FROM course_v2_bank b LEFT JOIN course_v2_tasks t ON t.bank_entry_id=b.id AND t.owner_id=$1 AND t.exam_id IS NULL
WHERE b.active AND b.language=$2 AND b.version=$3 AND b.module_id=$4 AND ($5='' OR b.skill=$5) AND ($6=false OR b.data->'task'->>'kind'='choice')`, j.UserID, j.Language, domain.CourseVersion, j.ModuleID, j.Skill, j.Kind == "legacy_next")
instructionLanguage := valueOr(j.InstructionLanguage, "de-DE")
rows, err := tx.QueryContext(ctx, availableBank+`
SELECT av.entry,COALESCE(t.id,''),COALESCE(graded.score,-1),COALESCE(extract(epoch from previous.last_presented_at)::bigint,0),av.base_id,av.variant_id,COALESCE(previous.id,'')
FROM available av
LEFT JOIN course_v2_tasks t ON t.bank_entry_id=av.base_id AND COALESCE(t.variant_id,'')=av.variant_id AND t.owner_id=$1 AND t.exam_id IS NULL
LEFT JOIN LATERAL (SELECT r.id,r.last_presented_at FROM course_v2_tasks r WHERE r.owner_id=$1 AND r.language=$2 AND r.version=$3 AND r.exam_id IS NULL AND COALESCE(NULLIF(r.data->>'canonical_task_id',''),r.bank_entry_id)=av.canonical_id ORDER BY r.last_presented_at DESC NULLS LAST,r.id LIMIT 1) previous ON true
LEFT JOIN LATERAL (SELECT (a.evaluation->>'score')::float8 AS score FROM course_v2_attempts a JOIN course_v2_tasks r ON r.id=a.task_id WHERE a.user_id=$1 AND r.owner_id=$1 AND r.language=$2 AND r.version=$3 AND r.exam_id IS NULL AND COALESCE(NULLIF(r.data->>'canonical_task_id',''),r.bank_entry_id)=av.canonical_id AND a.status='graded' AND NOT a.demo ORDER BY a.created_at DESC,a.id DESC LIMIT 1) graded ON true
WHERE av.module_id=$5 AND ($6='' OR av.skill=$6) AND ($7=false OR av.entry->'task'->>'kind'='choice')`, j.UserID, j.Language, domain.CourseVersion, instructionLanguage, j.ModuleID, j.Skill, j.Kind == "legacy_next")
if err != nil {
return domain.AdaptiveTask{}, err
}
@@ -255,7 +265,7 @@ func (s *AdaptiveStore) AssignBankTask(ctx context.Context, j domain.CourseJob)
for rows.Next() {
var c bankCandidate
var data []byte
if err = rows.Scan(&data, &c.taskID, &c.score, &c.presented); err != nil {
if err = rows.Scan(&data, &c.taskID, &c.score, &c.presented, &c.bankEntryID, &c.variantID, &c.previousID); err != nil {
rows.Close()
return domain.AdaptiveTask{}, err
}
@@ -263,7 +273,7 @@ func (s *AdaptiveStore) AssignBankTask(ctx context.Context, j domain.CourseJob)
rows.Close()
return domain.AdaptiveTask{}, err
}
c.seen = c.taskID != ""
c.seen = c.previousID != ""
candidates = append(candidates, c)
}
err = rows.Err()
@@ -272,6 +282,9 @@ func (s *AdaptiveStore) AssignBankTask(ctx context.Context, j domain.CourseJob)
return domain.AdaptiveTask{}, err
}
if len(candidates) == 0 {
if instructionLanguage != "de-DE" {
return domain.AdaptiveTask{}, ErrCourseVariantUnavailable
}
return domain.AdaptiveTask{}, ErrNotFound
}
type recent struct {
@@ -281,7 +294,7 @@ func (s *AdaptiveStore) AssignBankTask(ctx context.Context, j domain.CourseJob)
difficulty int
}
recentScores := []recent{}
rows, err = tx.QueryContext(ctx, `SELECT b.goal,(a.evaluation->>'score')::float8,t.id,b.difficulty FROM course_v2_attempts a JOIN course_v2_tasks t ON t.id=a.task_id JOIN course_v2_bank b ON b.id=t.bank_entry_id WHERE a.user_id=$1 AND t.language=$2 AND t.version=$3 AND t.module_id=$4 AND ($5='' OR t.skill=$5) AND a.status='graded' AND NOT a.demo AND a.exam_id IS NULL ORDER BY a.created_at DESC,a.id DESC LIMIT 5`, j.UserID, j.Language, domain.CourseVersion, j.ModuleID, j.Skill)
rows, err = tx.QueryContext(ctx, `SELECT b.goal,(a.evaluation->>'score')::float8,COALESCE(NULLIF(t.data->>'evidence_task_id',''),t.id),b.difficulty FROM course_v2_attempts a JOIN course_v2_tasks t ON t.id=a.task_id JOIN course_v2_bank b ON b.id=t.bank_entry_id WHERE a.user_id=$1 AND t.language=$2 AND t.version=$3 AND t.module_id=$4 AND ($5='' OR t.skill=$5) AND a.status='graded' AND NOT a.demo AND a.exam_id IS NULL ORDER BY a.created_at DESC,a.id DESC LIMIT 5`, j.UserID, j.Language, domain.CourseVersion, j.ModuleID, j.Skill)
if err != nil {
return domain.AdaptiveTask{}, err
}
@@ -334,15 +347,15 @@ func (s *AdaptiveStore) AssignBankTask(ctx context.Context, j domain.CourseJob)
}
sort.Slice(candidates, func(i, k int) bool {
a, b := candidates[i], candidates[k]
if a.seen && b.seen && (a.taskID == lastID) != (b.taskID == lastID) {
return b.taskID == lastID
if a.seen && b.seen && (a.previousID == lastID) != (b.previousID == lastID) {
return b.previousID == lastID
}
if rank(a) != rank(b) {
return rank(a) < rank(b)
}
if a.seen && b.seen {
if (a.taskID == lastID) != (b.taskID == lastID) {
return b.taskID == lastID
if (a.previousID == lastID) != (b.previousID == lastID) {
return b.previousID == lastID
}
if a.presented != b.presented {
return a.presented < b.presented
@@ -367,10 +380,23 @@ func (s *AdaptiveStore) AssignBankTask(ctx context.Context, j domain.CourseJob)
t.Source = "curated"
t.Review = chosen.seen
t.ID = chosen.taskID
if !chosen.seen {
if chosen.taskID == "" {
t.ID = NewID("a2")
if t.InstructionLanguage == "" {
t.InstructionLanguage = "de-DE"
}
if t.CanonicalTaskID == "" {
t.CanonicalTaskID = chosen.bankEntryID
}
// Reuse the earliest evidence identity without editing any historic snapshot.
err = tx.QueryRowContext(ctx, `SELECT COALESCE(NULLIF(data->>'evidence_task_id',''),id) FROM course_v2_tasks WHERE owner_id=$1 AND language=$2 AND version=$3 AND exam_id IS NULL AND COALESCE(NULLIF(data->>'canonical_task_id',''),bank_entry_id)=$4 ORDER BY created_at,id LIMIT 1`, j.UserID, j.Language, domain.CourseVersion, t.CanonicalTaskID).Scan(&t.EvidenceTaskID)
if errors.Is(err, sql.ErrNoRows) {
t.EvidenceTaskID = t.ID
} else if err != nil {
return t, err
}
data, _ := json.Marshal(t)
_, err = tx.ExecContext(ctx, `INSERT INTO course_v2_tasks(id,module_id,language,version,owner_id,source,skill,kind,data,fingerprint,bank_entry_id,last_presented_at,presentation_count) VALUES($1,$2,$3,$4,$5,'curated',$6,$7,$8,$9,$10,now(),1)`, t.ID, t.ModuleID, t.TargetLanguage, t.CourseVersion, j.UserID, t.Skill, t.Kind, data, "bank:"+chosen.entry.ID, chosen.entry.ID)
_, err = tx.ExecContext(ctx, `INSERT INTO course_v2_tasks(id,module_id,language,version,owner_id,source,skill,kind,data,fingerprint,bank_entry_id,variant_id,last_presented_at,presentation_count) VALUES($1,$2,$3,$4,$5,'curated',$6,$7,$8,$9,$10,NULLIF($11,''),now(),1)`, t.ID, t.ModuleID, t.TargetLanguage, t.CourseVersion, j.UserID, t.Skill, t.Kind, data, "bank:"+chosen.entry.ID, chosen.bankEntryID, chosen.variantID)
} else {
_, err = tx.ExecContext(ctx, `UPDATE course_v2_tasks SET last_presented_at=now(),presentation_count=presentation_count+1 WHERE id=$1`, t.ID)
}
@@ -434,7 +460,11 @@ type BankInventoryItem struct {
}
func (s *AdaptiveStore) BankInventory(ctx context.Context, user, language string) ([]BankInventoryItem, error) {
rows, err := s.db.QueryContext(ctx, `SELECT b.module_id,b.skill,count(*),count(*) FILTER(WHERE t.id IS NULL) FROM course_v2_bank b LEFT JOIN course_v2_tasks t ON t.bank_entry_id=b.id AND t.owner_id=$1 AND t.exam_id IS NULL WHERE b.active AND b.language=$2 AND b.version=$3 GROUP BY b.module_id,b.skill ORDER BY b.module_id,b.skill`, user, language, domain.CourseVersion)
var instructionLanguage string
if err := s.db.QueryRowContext(ctx, `SELECT instruction_language FROM users WHERE id=$1`, user).Scan(&instructionLanguage); err != nil {
return nil, err
}
rows, err := s.db.QueryContext(ctx, availableBank+` SELECT av.module_id,av.skill,count(*),count(*) FILTER(WHERE NOT EXISTS(SELECT 1 FROM course_v2_tasks t WHERE t.owner_id=$1 AND t.language=$2 AND t.version=$3 AND t.exam_id IS NULL AND COALESCE(NULLIF(t.data->>'canonical_task_id',''),t.bank_entry_id)=av.canonical_id)) FROM available av GROUP BY av.module_id,av.skill ORDER BY av.module_id,av.skill`, user, language, domain.CourseVersion, instructionLanguage)
if err != nil {
return nil, err
}
+270
View File
@@ -0,0 +1,270 @@
package store
import (
"context"
"crypto/sha256"
"database/sql"
"embed"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"strings"
"speech-learning-api/internal/domain"
)
//go:embed coursebank/variants/*.json
var variantFiles embed.FS
var ErrCourseVariantUnavailable = errors.New("no reviewed exercises are available for this explanation language")
const variantSchema = `
CREATE TABLE IF NOT EXISTS course_v2_bank_variants (
id TEXT PRIMARY KEY,base_entry_id TEXT NOT NULL REFERENCES course_v2_bank(id),
canonical_task_id TEXT NOT NULL,instruction_language TEXT NOT NULL,revision TEXT NOT NULL,
data JSONB NOT NULL,checksum TEXT NOT NULL,active BOOLEAN NOT NULL DEFAULT true);
CREATE UNIQUE INDEX IF NOT EXISTS course_v2_variant_active_presentation ON course_v2_bank_variants(base_entry_id,instruction_language) WHERE active;
CREATE INDEX IF NOT EXISTS course_v2_variant_lookup ON course_v2_bank_variants(instruction_language,base_entry_id) WHERE active;
ALTER TABLE course_v2_tasks ADD COLUMN IF NOT EXISTS variant_id TEXT REFERENCES course_v2_bank_variants(id);
CREATE INDEX IF NOT EXISTS course_v2_task_canonical ON course_v2_tasks(owner_id,language,version,(COALESCE(NULLIF(data->>'canonical_task_id',''),bank_entry_id))) WHERE exam_id IS NULL;
-- Separate frozen presentations are allowed; their evidence identity is shared
-- only when the editorial review classifies them as equivalent translations.
DROP INDEX IF EXISTS course_v2_bank_assignment;
CREATE UNIQUE INDEX IF NOT EXISTS course_v2_bank_variant_assignment ON course_v2_tasks(owner_id,bank_entry_id,COALESCE(variant_id,'')) WHERE exam_id IS NULL AND bank_entry_id IS NOT NULL;
`
func BundledVariants(base []domain.BankEntry) ([]domain.BankVariant, error) {
manifestData, err := variantFiles.ReadFile("coursebank/variants/manifest.json")
if err != nil {
return nil, err
}
var manifest struct {
Total int `json:"total"`
Files map[string]string `json:"files"`
}
if err = json.Unmarshal(manifestData, &manifest); err != nil {
return nil, err
}
variants := []domain.BankVariant{}
for name, digest := range manifest.Files {
if strings.ContainsAny(name, "/\\") || name == "manifest.json" {
return nil, errors.New("invalid variant manifest path")
}
data, err := variantFiles.ReadFile("coursebank/variants/" + name)
if err != nil {
return nil, err
}
sum := sha256.Sum256(data)
if hex.EncodeToString(sum[:]) != digest {
return nil, fmt.Errorf("variant checksum mismatch: %s", name)
}
var batch []domain.BankVariant
dec := json.NewDecoder(strings.NewReader(string(data)))
dec.DisallowUnknownFields()
if err = dec.Decode(&batch); err != nil {
return nil, err
}
variants = append(variants, batch...)
}
if len(variants) != manifest.Total || manifest.Total == 0 {
return nil, errors.New("invalid variant count")
}
return variants, ValidateVariants(base, variants)
}
func ValidateVariants(base []domain.BankEntry, variants []domain.BankVariant) error {
entries := map[string]domain.BankEntry{}
for _, entry := range base {
entries[entry.ID] = entry
}
seen := map[string]bool{}
presentations := map[string]bool{}
moduleLabels := map[string]string{}
for _, v := range variants {
original, ok := entries[v.BaseEntryID]
t := v.Task
b := original.Task
if !ok || v.ID == "" || seen[v.ID] || !v.Reviewed || v.Revision == "" || v.InstructionLanguage == "" || t.ID != "" || t.Source != "" || t.ExamID != "" || t.EvidenceTaskID != "" || t.VariantID != v.ID || t.ContentRevision != v.Revision || t.CanonicalTaskID != v.CanonicalTaskID || t.InstructionLanguage != v.InstructionLanguage || t.SchemaVersion != b.SchemaVersion || t.ModuleID != b.ModuleID || t.TargetLanguage != b.TargetLanguage || t.CourseVersion != b.CourseVersion || t.CEFRLevel != b.CEFRLevel || t.Skill != b.Skill || t.Kind != b.Kind || t.AnswerKey == nil || t.Instruction == "" || len([]rune(t.Prompt)) > 2000 || strings.Contains(t.Prompt, "<") {
return fmt.Errorf("invalid task variant: %s", v.ID)
}
if _, exists := entries[v.ID]; exists {
return fmt.Errorf("variant identity collides with a base entry: %s", v.ID)
}
if v.ModuleTitle == "" || v.ModuleDescription == "" {
return fmt.Errorf("variant module labels missing: %s", v.ID)
}
labelKey := t.ModuleID + ":" + v.InstructionLanguage
labelValue := v.ModuleTitle + "\n" + v.ModuleDescription
if previous, exists := moduleLabels[labelKey]; exists && previous != labelValue {
return fmt.Errorf("inconsistent module labels: %s", v.ID)
}
moduleLabels[labelKey] = labelValue
seen[v.ID] = true
presentation := v.BaseEntryID + ":" + v.InstructionLanguage
if presentations[presentation] {
return fmt.Errorf("duplicate active locale presentation: %s", v.ID)
}
presentations[presentation] = true
referenceLanguage := t.TargetLanguage
if t.Skill == "vocabulary" {
referenceLanguage = t.InstructionLanguage
}
if t.AnswerKey.ReferenceAnswerLanguage != referenceLanguage {
return fmt.Errorf("invalid reference language: %s", v.ID)
}
if (v.Equivalence != "translation" && v.Equivalence != "adaptation") || (v.Equivalence == "translation" && v.CanonicalTaskID != v.BaseEntryID) || (v.Equivalence == "adaptation" && v.CanonicalTaskID != v.ID) {
return fmt.Errorf("invalid variant identity: %s", v.ID)
}
prompt := t.Instruction
if t.Stimulus != nil {
stimulus := t.Stimulus
if stimulus.Text == "" || stimulus.Language == "" || (stimulus.Role == "target" && stimulus.Language != t.TargetLanguage) || !bankMember(stimulus.Role, []string{"target", "source", "context"}) || (stimulus.Role == "source" && stimulus.Language == t.TargetLanguage) || t.Skill == "listening" {
return fmt.Errorf("invalid public stimulus: %s", v.ID)
}
prompt += " " + stimulus.Text
}
if t.Prompt != prompt || t.AudioText != b.AudioText || t.Passage != b.Passage || t.ReferenceText != b.ReferenceText || len(t.Options) != len(b.Options) || t.AnswerKey.CorrectOptionID != b.AnswerKey.CorrectOptionID || t.AnswerKey.Explanation == "" || len(t.AnswerKey.Rubric) == 0 || t.AnswerKey.ReferenceAnswerLanguage == "" {
return fmt.Errorf("variant changes protected task content: %s", v.ID)
}
labels := map[string]bool{}
for i, option := range t.Options {
label := strings.ToLower(strings.TrimSpace(option.Label))
expectedRole := "target"
expectedLanguage := t.TargetLanguage
if t.Skill == "vocabulary" {
expectedRole = "meaning"
expectedLanguage = t.InstructionLanguage
}
if option.Role != expectedRole || option.Language != expectedLanguage {
return fmt.Errorf("invalid option language role: %s", v.ID)
}
if expectedRole == "meaning" && v.Equivalence == "translation" && t.InstructionLanguage == t.TargetLanguage {
return fmt.Errorf("same-language meanings need a reviewed adaptation: %s", v.ID)
}
if option.ID != b.Options[i].ID || option.Language == "" || label == "" || labels[label] || (v.Equivalence == "translation" && option.Role == "target" && option.Label != b.Options[i].Label) {
return fmt.Errorf("invalid variant options: %s", v.ID)
}
labels[label] = true
if option.ID == t.AnswerKey.CorrectOptionID && option.Label != t.AnswerKey.ReferenceAnswer {
return fmt.Errorf("variant reference/key mismatch: %s", v.ID)
}
}
if v.Equivalence == "translation" && t.Skill != "vocabulary" && t.AnswerKey.ReferenceAnswer != b.AnswerKey.ReferenceAnswer {
return fmt.Errorf("translation changes reference: %s", v.ID)
}
}
return nil
}
func (s *AdaptiveStore) installVariants(ctx context.Context, base []domain.BankEntry) error {
variants, err := BundledVariants(base)
if err != nil {
return err
}
if _, err = s.db.ExecContext(ctx, variantSchema); err != nil {
return err
}
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
if _, err = tx.ExecContext(ctx, `UPDATE course_v2_bank_variants v SET active=false FROM course_v2_bank b WHERE v.base_entry_id=b.id AND b.language='en-US' AND b.version=$1`, domain.CourseVersion); err != nil {
return err
}
for _, v := range variants {
data, err := json.Marshal(v)
if err != nil {
return err
}
sum := sha256.Sum256(data)
checksum := hex.EncodeToString(sum[:])
var old string
err = tx.QueryRowContext(ctx, `SELECT checksum FROM course_v2_bank_variants WHERE id=$1`, v.ID).Scan(&old)
if err == nil && old != checksum {
return fmt.Errorf("variant revision is immutable: %s", v.ID)
}
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO course_v2_bank_variants(id,base_entry_id,canonical_task_id,instruction_language,revision,data,checksum) VALUES($1,$2,$3,$4,$5,$6,$7) ON CONFLICT(id) DO UPDATE SET active=true`, v.ID, v.BaseEntryID, v.CanonicalTaskID, v.InstructionLanguage, v.Revision, data, checksum); err != nil {
return err
}
}
return tx.Commit()
}
// availableBank joins a locale presentation to its original curriculum entry.
// Existing German entries are left byte-for-byte intact in the bank.
const availableBank = `WITH available AS (
SELECT b.id AS base_id,''::text AS variant_id,b.id AS canonical_id,b.data AS entry,b.module_id,b.skill
FROM course_v2_bank b WHERE b.active AND b.language=$2 AND b.version=$3 AND $4='de-DE'
UNION ALL
SELECT b.id,v.id,v.canonical_task_id,jsonb_build_object('id',v.id,'revision',v.revision,'learning_goal_id',b.goal,'difficulty',b.difficulty,'reviewed',true,'task',v.data->'task'),b.module_id,b.skill
FROM course_v2_bank_variants v JOIN course_v2_bank b ON b.id=v.base_entry_id
WHERE v.active AND b.active AND b.language=$2 AND b.version=$3 AND v.instruction_language=$4
)`
func (s *AdaptiveStore) InstructionLanguages(ctx context.Context, language string) ([]string, error) {
rows, err := s.db.QueryContext(ctx, `SELECT 'de-DE' WHERE EXISTS(SELECT 1 FROM course_v2_bank WHERE active AND language=$1 AND version=$2) UNION SELECT DISTINCT v.instruction_language FROM course_v2_bank_variants v JOIN course_v2_bank b ON b.id=v.base_entry_id WHERE v.active AND b.active AND b.language=$1 AND b.version=$2 ORDER BY 1`, language, domain.CourseVersion)
if err != nil {
return nil, err
}
defer rows.Close()
out := []string{}
for rows.Next() {
var value string
if err = rows.Scan(&value); err != nil {
return nil, err
}
out = append(out, value)
}
return out, rows.Err()
}
func (s *AdaptiveStore) SetInstructionLanguage(ctx context.Context, user, language, instruction string) error {
options, err := s.InstructionLanguages(ctx, language)
if err != nil {
return err
}
if !bankMember(instruction, options) {
return ErrCourseVariantUnavailable
}
_, err = s.db.ExecContext(ctx, `UPDATE users SET instruction_language=$2 WHERE id=$1`, user, instruction)
return err
}
// A request replay may resume its frozen German exam after the learner has
// chosen another explanation language. Availability applies to new sessions.
func (s *AdaptiveStore) HasExamRequest(ctx context.Context, user, language, request string) (bool, error) {
var exists bool
err := s.db.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM course_v2_exams WHERE user_id=$1 AND language=$2 AND version=$3 AND request_id=$4)`, user, language, domain.CourseVersion, request).Scan(&exists)
return exists, err
}
// Module labels are derived display content, never a rewrite of stored course
// packs, task snapshots or learning-goal identifiers.
func (s *AdaptiveStore) localizeModuleLabels(ctx context.Context, language, instruction string, modules []domain.AdaptiveModule) error {
if instruction == "" || instruction == "de-DE" {
return nil
}
rows, err := s.db.QueryContext(ctx, `SELECT DISTINCT b.module_id,v.data->>'module_title',v.data->>'module_description' FROM course_v2_bank_variants v JOIN course_v2_bank b ON b.id=v.base_entry_id WHERE v.active AND b.active AND b.language=$1 AND b.version=$2 AND v.instruction_language=$3`, language, domain.CourseVersion, instruction)
if err != nil {
return err
}
defer rows.Close()
for rows.Next() {
var id, title, description string
if err = rows.Scan(&id, &title, &description); err != nil {
return err
}
for i := range modules {
if modules[i].ID == id {
modules[i].Title = title
modules[i].Description = description
}
}
}
return rows.Err()
}
@@ -0,0 +1,74 @@
package store
import (
"encoding/json"
"testing"
"speech-learning-api/internal/domain"
)
func TestReviewedVariantsRejectChangedIdentityAndLeakedMedia(t *testing.T) {
base, err := BundledBank()
if err != nil {
t.Fatal(err)
}
variants, err := BundledVariants(base)
if err != nil {
t.Fatal(err)
}
if len(variants) != 12 {
t.Fatal("unexpected pilot count", len(variants))
}
copyVariants := func() []domain.BankVariant {
raw, _ := json.Marshal(variants)
var out []domain.BankVariant
if err := json.Unmarshal(raw, &out); err != nil {
t.Fatal(err)
}
return out
}
t.Run("changed requirement is not a translation", func(t *testing.T) {
v := copyVariants()
for i := range v {
if v[i].Equivalence == "adaptation" {
v[i].Equivalence = "translation"
break
}
}
if ValidateVariants(base, v) == nil {
t.Fatal("adaptation with shared identity accepted")
}
})
t.Run("ambiguous options", func(t *testing.T) {
v := copyVariants()
v[0].Task.Options[1].Label = v[0].Task.Options[0].Label
if ValidateVariants(base, v) == nil {
t.Fatal("ambiguous options accepted")
}
})
t.Run("private listening content", func(t *testing.T) {
v := copyVariants()
for i := range v {
if v[i].Task.Skill == "listening" {
v[i].Task.Stimulus = &domain.TaskStimulus{Role: "target", Language: "en-US", Text: v[i].Task.AudioText}
break
}
}
if ValidateVariants(base, v) == nil {
t.Fatal("public listening transcript accepted")
}
})
t.Run("identity translation", func(t *testing.T) {
v := copyVariants()
v[0].Task.Stimulus.Role = "source"
if ValidateVariants(base, v) == nil {
t.Fatal("source and target identity translation accepted")
}
})
for _, v := range variants {
public := v.Task.Public(false)
if public.AnswerKey != nil || public.AudioText != "" || public.EvidenceTaskID != "" {
t.Fatal("private fields exposed", v.ID)
}
}
}
@@ -1,7 +1,7 @@
{
"revision": "en-A1-bank-v2",
"total": 840,
"editorial_review_sha256": "4cd23522372690392e0d6eae90ede2c918ed129296464035bf32bed30b8a8b7b",
"editorial_review_sha256": "a64cc0b862192e996265420c7e6d8ac82c3543449c97fbdd99dc816a270e141a",
"files": {
"introductions.grammar.json": "e166492fa3e9e13760620bda1af2c0bb6472d91216a4c46808360264450c5ebc",
"introductions.vocabulary.json": "d72c534e3c7422d85b2aa03f2988b77da31163637c70ac511ca07f278d1fdd81",
@@ -0,0 +1,630 @@
[
{
"id": "intro_en_explanations_v1_grammar_01",
"revision": "introductions-en-explanations-v1",
"base_entry_id": "a1bank_en_v1_introductions_grammar_01",
"canonical_task_id": "a1bank_en_v1_introductions_grammar_01",
"instruction_language": "en-US",
"module_title": "Greetings & introductions",
"module_description": "Greet people, introduce a name and origin; I am, my name is",
"equivalence": "translation",
"reviewed": true,
"task": {
"schema_version": 2,
"module_id": "a1_introductions_v1",
"origin_module_key": "introductions",
"target_language": "en-US",
"course_version": "a1-v2",
"cefr_level": "A1",
"skill": "grammar",
"kind": "choice",
"prompt": "Complete the sentence. I ___ Anna.",
"options": [
{
"id": "o1",
"label": "am",
"role": "target",
"language": "en-US"
},
{
"id": "o2",
"label": "is",
"role": "target",
"language": "en-US"
},
{
"id": "o3",
"label": "are",
"role": "target",
"language": "en-US"
}
],
"answer_key": {
"correct_option_id": "o1",
"reference_answer": "am",
"rubric": [
"Choose the one answer supported by the sentence, word meaning or supplied text."
],
"explanation": "Use am after I.",
"reference_answer_language": "en-US"
},
"instruction_language": "en-US",
"variant_id": "intro_en_explanations_v1_grammar_01",
"canonical_task_id": "a1bank_en_v1_introductions_grammar_01",
"content_revision": "introductions-en-explanations-v1",
"instruction": "Complete the sentence.",
"stimulus": {
"role": "target",
"language": "en-US",
"text": "I ___ Anna."
}
}
},
{
"id": "intro_en_explanations_v1_grammar_02",
"revision": "introductions-en-explanations-v1",
"base_entry_id": "a1bank_en_v1_introductions_grammar_02",
"canonical_task_id": "a1bank_en_v1_introductions_grammar_02",
"instruction_language": "en-US",
"module_title": "Greetings & introductions",
"module_description": "Greet people, introduce a name and origin; I am, my name is",
"equivalence": "translation",
"reviewed": true,
"task": {
"schema_version": 2,
"module_id": "a1_introductions_v1",
"origin_module_key": "introductions",
"target_language": "en-US",
"course_version": "a1-v2",
"cefr_level": "A1",
"skill": "grammar",
"kind": "choice",
"prompt": "Complete the sentence. You ___ my friend.",
"options": [
{
"id": "o1",
"label": "is",
"role": "target",
"language": "en-US"
},
{
"id": "o2",
"label": "are",
"role": "target",
"language": "en-US"
},
{
"id": "o3",
"label": "am",
"role": "target",
"language": "en-US"
}
],
"answer_key": {
"correct_option_id": "o2",
"reference_answer": "are",
"rubric": [
"Choose the one answer supported by the sentence, word meaning or supplied text."
],
"explanation": "Use are after you.",
"reference_answer_language": "en-US"
},
"instruction_language": "en-US",
"variant_id": "intro_en_explanations_v1_grammar_02",
"canonical_task_id": "a1bank_en_v1_introductions_grammar_02",
"content_revision": "introductions-en-explanations-v1",
"instruction": "Complete the sentence.",
"stimulus": {
"role": "target",
"language": "en-US",
"text": "You ___ my friend."
}
}
},
{
"id": "intro_en_explanations_v1_vocabulary_01",
"revision": "introductions-en-explanations-v1",
"base_entry_id": "a1bank_en_v1_introductions_vocabulary_01",
"canonical_task_id": "intro_en_explanations_v1_vocabulary_01",
"instruction_language": "en-US",
"module_title": "Greetings & introductions",
"module_description": "Greet people, introduce a name and origin; I am, my name is",
"equivalence": "adaptation",
"reviewed": true,
"task": {
"schema_version": 2,
"module_id": "a1_introductions_v1",
"origin_module_key": "introductions",
"target_language": "en-US",
"course_version": "a1-v2",
"cefr_level": "A1",
"skill": "vocabulary",
"kind": "choice",
"prompt": "What does hello mean in this sentence? Hello, I am Anna.",
"options": [
{
"id": "o1",
"label": "a greeting",
"role": "meaning",
"language": "en-US"
},
{
"id": "o2",
"label": "a farewell",
"role": "meaning",
"language": "en-US"
},
{
"id": "o3",
"label": "a polite request",
"role": "meaning",
"language": "en-US"
}
],
"answer_key": {
"correct_option_id": "o1",
"reference_answer": "a greeting",
"rubric": [
"Choose the one answer supported by the sentence, word meaning or supplied text."
],
"explanation": "Hello is a greeting. We use it when we meet someone.",
"reference_answer_language": "en-US"
},
"instruction_language": "en-US",
"variant_id": "intro_en_explanations_v1_vocabulary_01",
"canonical_task_id": "intro_en_explanations_v1_vocabulary_01",
"content_revision": "introductions-en-explanations-v1",
"instruction": "What does hello mean in this sentence?",
"stimulus": {
"role": "target",
"language": "en-US",
"text": "Hello, I am Anna."
}
}
},
{
"id": "intro_en_explanations_v1_vocabulary_02",
"revision": "introductions-en-explanations-v1",
"base_entry_id": "a1bank_en_v1_introductions_vocabulary_02",
"canonical_task_id": "intro_en_explanations_v1_vocabulary_02",
"instruction_language": "en-US",
"module_title": "Greetings & introductions",
"module_description": "Greet people, introduce a name and origin; I am, my name is",
"equivalence": "adaptation",
"reviewed": true,
"task": {
"schema_version": 2,
"module_id": "a1_introductions_v1",
"origin_module_key": "introductions",
"target_language": "en-US",
"course_version": "a1-v2",
"cefr_level": "A1",
"skill": "vocabulary",
"kind": "choice",
"prompt": "What does name mean in this sentence? My name is Ben.",
"options": [
{
"id": "o1",
"label": "where someone lives",
"role": "meaning",
"language": "en-US"
},
{
"id": "o2",
"label": "what a person is called",
"role": "meaning",
"language": "en-US"
},
{
"id": "o3",
"label": "how old someone is",
"role": "meaning",
"language": "en-US"
}
],
"answer_key": {
"correct_option_id": "o2",
"reference_answer": "what a person is called",
"rubric": [
"Choose the one answer supported by the sentence, word meaning or supplied text."
],
"explanation": "A name is what a person is called. The person's name here is Ben.",
"reference_answer_language": "en-US"
},
"instruction_language": "en-US",
"variant_id": "intro_en_explanations_v1_vocabulary_02",
"canonical_task_id": "intro_en_explanations_v1_vocabulary_02",
"content_revision": "introductions-en-explanations-v1",
"instruction": "What does name mean in this sentence?",
"stimulus": {
"role": "target",
"language": "en-US",
"text": "My name is Ben."
}
}
},
{
"id": "intro_en_explanations_v1_reading_01",
"revision": "introductions-en-explanations-v1",
"base_entry_id": "a1bank_en_v1_introductions_reading_01",
"canonical_task_id": "a1bank_en_v1_introductions_reading_01",
"instruction_language": "en-US",
"module_title": "Greetings & introductions",
"module_description": "Greet people, introduce a name and origin; I am, my name is",
"equivalence": "translation",
"reviewed": true,
"task": {
"schema_version": 2,
"module_id": "a1_introductions_v1",
"origin_module_key": "introductions",
"target_language": "en-US",
"course_version": "a1-v2",
"cefr_level": "A1",
"skill": "reading",
"kind": "choice",
"prompt": "What is the person's name?",
"passage": "My name is Anna. I am from Spain.",
"options": [
{
"id": "o1",
"label": "Anna",
"role": "target",
"language": "en-US"
},
{
"id": "o2",
"label": "Mia",
"role": "target",
"language": "en-US"
},
{
"id": "o3",
"label": "Eva",
"role": "target",
"language": "en-US"
}
],
"answer_key": {
"correct_option_id": "o1",
"reference_answer": "Anna",
"rubric": [
"Choose the one answer supported by the sentence, word meaning or supplied text."
],
"explanation": "The text says: My name is Anna. The correct answer is Anna.",
"reference_answer_language": "en-US"
},
"instruction_language": "en-US",
"variant_id": "intro_en_explanations_v1_reading_01",
"canonical_task_id": "a1bank_en_v1_introductions_reading_01",
"content_revision": "introductions-en-explanations-v1",
"instruction": "What is the person's name?"
}
},
{
"id": "intro_en_explanations_v1_reading_02",
"revision": "introductions-en-explanations-v1",
"base_entry_id": "a1bank_en_v1_introductions_reading_02",
"canonical_task_id": "a1bank_en_v1_introductions_reading_02",
"instruction_language": "en-US",
"module_title": "Greetings & introductions",
"module_description": "Greet people, introduce a name and origin; I am, my name is",
"equivalence": "translation",
"reviewed": true,
"task": {
"schema_version": 2,
"module_id": "a1_introductions_v1",
"origin_module_key": "introductions",
"target_language": "en-US",
"course_version": "a1-v2",
"cefr_level": "A1",
"skill": "reading",
"kind": "choice",
"prompt": "Which country is Ben from?",
"passage": "Ben is from Canada. He lives in London.",
"options": [
{
"id": "o1",
"label": "Italy",
"role": "target",
"language": "en-US"
},
{
"id": "o2",
"label": "Canada",
"role": "target",
"language": "en-US"
},
{
"id": "o3",
"label": "Germany",
"role": "target",
"language": "en-US"
}
],
"answer_key": {
"correct_option_id": "o2",
"reference_answer": "Canada",
"rubric": [
"Choose the one answer supported by the sentence, word meaning or supplied text."
],
"explanation": "The text says: Ben is from Canada. The correct answer is Canada.",
"reference_answer_language": "en-US"
},
"instruction_language": "en-US",
"variant_id": "intro_en_explanations_v1_reading_02",
"canonical_task_id": "a1bank_en_v1_introductions_reading_02",
"content_revision": "introductions-en-explanations-v1",
"instruction": "Which country is Ben from?"
}
},
{
"id": "intro_en_explanations_v1_listening_01",
"revision": "introductions-en-explanations-v1",
"base_entry_id": "a1bank_en_v1_introductions_listening_01",
"canonical_task_id": "a1bank_en_v1_introductions_listening_01",
"instruction_language": "en-US",
"module_title": "Greetings & introductions",
"module_description": "Greet people, introduce a name and origin; I am, my name is",
"equivalence": "translation",
"reviewed": true,
"task": {
"schema_version": 2,
"module_id": "a1_introductions_v1",
"origin_module_key": "introductions",
"target_language": "en-US",
"course_version": "a1-v2",
"cefr_level": "A1",
"skill": "listening",
"kind": "choice",
"prompt": "Which country is Anna from?",
"audio_text": "My name is Anna. I am from Spain.",
"options": [
{
"id": "o1",
"label": "Spain",
"role": "target",
"language": "en-US"
},
{
"id": "o2",
"label": "France",
"role": "target",
"language": "en-US"
},
{
"id": "o3",
"label": "Italy",
"role": "target",
"language": "en-US"
}
],
"answer_key": {
"correct_option_id": "o1",
"reference_answer": "Spain",
"rubric": [
"Choose the one answer supported by the sentence, word meaning or supplied text."
],
"explanation": "The recording says: I am from Spain. The correct answer is Spain.",
"reference_answer_language": "en-US"
},
"instruction_language": "en-US",
"variant_id": "intro_en_explanations_v1_listening_01",
"canonical_task_id": "a1bank_en_v1_introductions_listening_01",
"content_revision": "introductions-en-explanations-v1",
"instruction": "Which country is Anna from?"
}
},
{
"id": "intro_en_explanations_v1_listening_02",
"revision": "introductions-en-explanations-v1",
"base_entry_id": "a1bank_en_v1_introductions_listening_02",
"canonical_task_id": "a1bank_en_v1_introductions_listening_02",
"instruction_language": "en-US",
"module_title": "Greetings & introductions",
"module_description": "Greet people, introduce a name and origin; I am, my name is",
"equivalence": "translation",
"reviewed": true,
"task": {
"schema_version": 2,
"module_id": "a1_introductions_v1",
"origin_module_key": "introductions",
"target_language": "en-US",
"course_version": "a1-v2",
"cefr_level": "A1",
"skill": "listening",
"kind": "choice",
"prompt": "Where does Ben live?",
"audio_text": "Ben is from Canada. He lives in London.",
"options": [
{
"id": "o1",
"label": "Rome",
"role": "target",
"language": "en-US"
},
{
"id": "o2",
"label": "London",
"role": "target",
"language": "en-US"
},
{
"id": "o3",
"label": "Paris",
"role": "target",
"language": "en-US"
}
],
"answer_key": {
"correct_option_id": "o2",
"reference_answer": "London",
"rubric": [
"Choose the one answer supported by the sentence, word meaning or supplied text."
],
"explanation": "The recording says: He lives in London. The correct answer is London.",
"reference_answer_language": "en-US"
},
"instruction_language": "en-US",
"variant_id": "intro_en_explanations_v1_listening_02",
"canonical_task_id": "a1bank_en_v1_introductions_listening_02",
"content_revision": "introductions-en-explanations-v1",
"instruction": "Where does Ben live?"
}
},
{
"id": "intro_en_explanations_v1_speaking_01",
"revision": "introductions-en-explanations-v1",
"base_entry_id": "a1bank_en_v1_introductions_speaking_01",
"canonical_task_id": "a1bank_en_v1_introductions_speaking_01",
"instruction_language": "en-US",
"module_title": "Greetings & introductions",
"module_description": "Greet people, introduce a name and origin; I am, my name is",
"equivalence": "translation",
"reviewed": true,
"task": {
"schema_version": 2,
"module_id": "a1_introductions_v1",
"origin_module_key": "introductions",
"target_language": "en-US",
"course_version": "a1-v2",
"cefr_level": "A1",
"skill": "speaking",
"kind": "repeat_sentence",
"prompt": "Repeat the English sentence.",
"reference_text": "My name is Anna.",
"answer_key": {
"reference_answer": "My name is Anna.",
"rubric": [
"Repeat the displayed English sentence clearly.",
"Do not claim pronunciation or fluency errors without actual Azure measurements."
],
"explanation": "Repeat the complete sentence clearly. Pronunciation feedback uses only available speech measurements.",
"reference_answer_language": "en-US"
},
"instruction_language": "en-US",
"variant_id": "intro_en_explanations_v1_speaking_01",
"canonical_task_id": "a1bank_en_v1_introductions_speaking_01",
"content_revision": "introductions-en-explanations-v1",
"instruction": "Repeat the English sentence."
}
},
{
"id": "intro_en_explanations_v1_speaking_11",
"revision": "introductions-en-explanations-v1",
"base_entry_id": "a1bank_en_v2_introductions_speaking_11",
"canonical_task_id": "a1bank_en_v2_introductions_speaking_11",
"instruction_language": "en-US",
"module_title": "Greetings & introductions",
"module_description": "Greet people, introduce a name and origin; I am, my name is",
"equivalence": "translation",
"reviewed": true,
"task": {
"schema_version": 2,
"module_id": "a1_introductions_v1",
"origin_module_key": "introductions",
"target_language": "en-US",
"course_version": "a1-v2",
"cefr_level": "A1",
"skill": "speaking",
"kind": "free_speech",
"prompt": "Introduce yourself. Give a name and the country you are from. You may use real or invented details. Say two or three short English sentences in at most 30 seconds.",
"answer_key": {
"reference_answer": "My name is Nina. I am not from Germany. I am from Poland.",
"rubric": [
"Introduce one person with a name and country of origin.",
"Two or three short, understandable English sentences meet the required length.",
"Real or invented names and countries are allowed. Facts in the example are not mandatory.",
"Assess only the explicitly requested content and actual language errors. Do not penalise ambiguity in the task.",
"For this free-speech response, assess content and English formulations only. Azure pronunciation is displayed separately and is not part of this score."
],
"explanation": "The example is only one possible answer. You may choose your own name and country. Content and language are assessed separately from Azure pronunciation.",
"reference_answer_language": "en-US"
},
"instruction_language": "en-US",
"variant_id": "intro_en_explanations_v1_speaking_11",
"canonical_task_id": "a1bank_en_v2_introductions_speaking_11",
"content_revision": "introductions-en-explanations-v1",
"instruction": "Introduce yourself. Give a name and the country you are from. You may use real or invented details. Say two or three short English sentences in at most 30 seconds."
}
},
{
"id": "intro_en_explanations_v1_writing_01",
"revision": "introductions-en-explanations-v1",
"base_entry_id": "a1bank_en_v1_introductions_writing_01",
"canonical_task_id": "intro_en_explanations_v1_writing_01",
"instruction_language": "en-US",
"module_title": "Greetings & introductions",
"module_description": "Greet people, introduce a name and origin; I am, my name is",
"equivalence": "adaptation",
"reviewed": true,
"task": {
"schema_version": 2,
"module_id": "a1_introductions_v1",
"origin_module_key": "introductions",
"target_language": "en-US",
"course_version": "a1-v2",
"cefr_level": "A1",
"skill": "writing",
"kind": "short_text",
"prompt": "Write one short English sentence to introduce yourself. For this exercise, use the name Anna. Name: Anna",
"answer_key": {
"reference_answer": "My name is Anna.",
"rubric": [
"Write one understandable English sentence to introduce yourself using the explicitly requested name Anna.",
"Accept My name is Anna., I am Anna. and other correct equivalent formulations.",
"Consider actual A1 language errors proportionately. Do not invent additional requirements."
],
"explanation": "My name is Anna. and I am Anna. are both valid answers. Use the name Anna as requested; other correct ways to introduce yourself are allowed.",
"reference_answer_language": "en-US"
},
"instruction_language": "en-US",
"variant_id": "intro_en_explanations_v1_writing_01",
"canonical_task_id": "intro_en_explanations_v1_writing_01",
"content_revision": "introductions-en-explanations-v1",
"instruction": "Write one short English sentence to introduce yourself. For this exercise, use the name Anna.",
"stimulus": {
"role": "context",
"language": "en-US",
"text": "Name: Anna"
}
}
},
{
"id": "intro_en_explanations_v1_writing_11",
"revision": "introductions-en-explanations-v1",
"base_entry_id": "a1bank_en_v2_introductions_writing_11",
"canonical_task_id": "a1bank_en_v2_introductions_writing_11",
"instruction_language": "en-US",
"module_title": "Greetings & introductions",
"module_description": "Greet people, introduce a name and origin; I am, my name is",
"equivalence": "translation",
"reviewed": true,
"task": {
"schema_version": 2,
"module_id": "a1_introductions_v1",
"origin_module_key": "introductions",
"target_language": "en-US",
"course_version": "a1-v2",
"cefr_level": "A1",
"skill": "writing",
"kind": "free_text",
"prompt": "Introduce yourself. Give a name and the country you are from. You may use real or invented details. Write two or three short English sentences.",
"answer_key": {
"reference_answer": "My name is Nina. I am not from Germany. I am from Poland.",
"rubric": [
"Introduce one person with a name and country of origin.",
"Two or three short, understandable English sentences meet the required length.",
"Real or invented names and countries are allowed. Facts in the example are not mandatory.",
"Assess only the explicitly requested content and actual language errors. Do not penalise ambiguity in the task."
],
"explanation": "The example is only one possible answer. You may choose your own name and country. Only the explicitly requested information is required.",
"reference_answer_language": "en-US"
},
"instruction_language": "en-US",
"variant_id": "intro_en_explanations_v1_writing_11",
"canonical_task_id": "a1bank_en_v2_introductions_writing_11",
"content_revision": "introductions-en-explanations-v1",
"instruction": "Introduce yourself. Give a name and the country you are from. You may use real or invented details. Write two or three short English sentences."
}
}
]
@@ -0,0 +1,7 @@
{
"total": 12,
"editorial_review_sha256": "05cf8e999f341338101fa42d667e031ea6509a19f56b116b5af7329457a75368",
"files": {
"introductions.en-US.v1.json": "07f3a3935290760bd64935ca66825c6321654aa017cd45c5651b86ddd9fbdc39"
}
}
+1 -1
View File
@@ -131,7 +131,7 @@ func recordPronunciation(ctx context.Context, tx *sql.Tx, user, source, sourceID
// and free speech do not enter the scripted profile. Historical practice rows
// without metadata remain untouched and explicitly unverified.
func (s *PostgresStore) BackfillPronunciation(ctx context.Context) error {
rows, err := s.db.QueryContext(ctx, `SELECT a.id,a.user_id,a.task_id,t.language,COALESCE(a.exam_id,''),a.created_at,a.speech
rows, err := s.db.QueryContext(ctx, `SELECT a.id,a.user_id,COALESCE(NULLIF(t.data->>'evidence_task_id',''),a.task_id),t.language,COALESCE(a.exam_id,''),a.created_at,a.speech
FROM course_v2_attempts a JOIN course_v2_tasks t ON t.id=a.task_id
WHERE a.speech->>'provider'='azure' AND a.demo=false AND a.legacy_id IS NULL AND t.kind='repeat_sentence'
AND NOT EXISTS(SELECT 1 FROM pronunciation_assessments p WHERE p.source='course' AND p.source_id=a.id)`)
+48 -13
View File
@@ -182,9 +182,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, instruction_language, role, 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.InstructionLanguage, &user.Role, &user.CreatedAt); err != nil {
return domain.User{}, err
}
return user, nil
@@ -194,11 +194,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, instruction_language, role, 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.InstructionLanguage, &user.Role, &user.CreatedAt); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return domain.User{}, "", ErrNotFound
}
@@ -210,11 +210,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, instruction_language, role, 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.InstructionLanguage, &user.Role, &user.CreatedAt); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return domain.User{}, ErrNotFound
}
@@ -265,20 +265,48 @@ func (s *PostgresStore) GetPrimaryProfile(ctx context.Context, userID string) (d
}
func (s *PostgresStore) UpdatePreferences(ctx context.Context, userID, uiLanguage, targetLanguage, cefrLevel string, dailyGoalMinutes int) (domain.LearnerProfile, error) {
if uiLanguage != "" {
if _, err := s.db.ExecContext(ctx, `UPDATE users SET ui_language = $1 WHERE id = $2`, uiLanguage, userID); err != nil {
return domain.LearnerProfile{}, err
}
if uiLanguage != "" && !domain.SupportedUILanguage(uiLanguage) {
return domain.LearnerProfile{}, errors.New("unsupported UI language")
}
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return domain.LearnerProfile{}, err
}
defer tx.Rollback()
// Lock the account so partial preference updates preserve the active course
// and cannot race with another language/profile switch.
var accountID string
if err = tx.QueryRowContext(ctx, `SELECT id FROM users WHERE id=$1 FOR UPDATE`, userID).Scan(&accountID); err != nil {
return domain.LearnerProfile{}, err
}
var current domain.LearnerProfile
err = tx.QueryRowContext(ctx, `SELECT p.target_language,p.cefr_level,p.daily_goal_minutes
FROM learner_profiles p JOIN users u ON u.id=p.user_id WHERE p.user_id=$1
ORDER BY (p.id=u.active_profile_id) DESC NULLS LAST,p.created_at,p.id LIMIT 1`, userID).Scan(&current.TargetLanguage, &current.CEFRLevel, &current.DailyGoalMinutes)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return current, err
}
targetLanguage = valueOr(targetLanguage, valueOr(current.TargetLanguage, "en-US"))
cefrLevel = valueOr(cefrLevel, valueOr(current.CEFRLevel, "A1"))
if dailyGoalMinutes <= 0 {
dailyGoalMinutes = current.DailyGoalMinutes
}
if dailyGoalMinutes <= 0 {
dailyGoalMinutes = 10
}
profile, err := s.CreateLearnerProfile(ctx, userID, valueOr(targetLanguage, "en-US"), valueOr(cefrLevel, "A1"), dailyGoalMinutes)
var profile domain.LearnerProfile
err = tx.QueryRowContext(ctx, `INSERT INTO learner_profiles(id,user_id,target_language,cefr_level,daily_goal_minutes)
VALUES($1,$2,$3,$4,$5) ON CONFLICT(user_id,target_language) DO UPDATE SET
cefr_level=EXCLUDED.cefr_level,daily_goal_minutes=EXCLUDED.daily_goal_minutes
RETURNING id,user_id,target_language,cefr_level,daily_goal_minutes,created_at`, NewID("lrn"), userID, targetLanguage, cefrLevel, dailyGoalMinutes).Scan(&profile.ID, &profile.UserID, &profile.TargetLanguage, &profile.CEFRLevel, &profile.DailyGoalMinutes, &profile.CreatedAt)
if err != nil {
return profile, err
}
_, err = s.db.ExecContext(ctx, `UPDATE users SET active_profile_id=$2 WHERE id=$1`, userID, profile.ID)
return profile, err
_, err = tx.ExecContext(ctx, `UPDATE users SET active_profile_id=$2,ui_language=CASE WHEN $3='' THEN ui_language ELSE $3 END WHERE id=$1`, userID, profile.ID, uiLanguage)
if err != nil {
return profile, err
}
return profile, tx.Commit()
}
func (s *PostgresStore) ListLanguages(ctx context.Context) ([]domain.LanguageProfile, error) {
@@ -665,6 +693,13 @@ CREATE TABLE IF NOT EXISTS users (
ALTER TABLE users ADD COLUMN IF NOT EXISTS role TEXT NOT NULL DEFAULT 'learner'
CHECK (role IN ('learner', 'admin'));
-- Previously ui_language also selected the language of explanations. Preserve
-- that preference once, independently of all future interface-language changes.
ALTER TABLE users ADD COLUMN IF NOT EXISTS instruction_language TEXT;
UPDATE users SET instruction_language=ui_language WHERE instruction_language IS NULL;
ALTER TABLE users ALTER COLUMN instruction_language SET DEFAULT 'de-DE';
ALTER TABLE users ALTER COLUMN instruction_language SET NOT NULL;
CREATE TABLE IF NOT EXISTS learner_profiles (
id TEXT PRIMARY KEY,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+6 -4
View File
@@ -6,14 +6,15 @@ type PronunciationResult = { recognized_text: string; overall_score: number; acc
export const courseSkills = ['grammar', 'vocabulary', 'listening', 'reading', 'speaking', 'writing'] as const;
export type CourseSkill = typeof courseSkills[number];
export const courseSkillNames: Record<CourseSkill, string> = { grammar: 'Grammatik', vocabulary: 'Wortschatz', listening: 'Hören', reading: 'Lesen', speaking: 'Sprechen', writing: 'Schreiben' };
export type AdaptiveModule = { id: string; key: string; title: string; description: string; target_language: string; order: number; goals: string[] };
export type AdaptiveTask = {
schema_version: 2; id: string; module_id: string; target_language: string; skill: CourseSkill;
kind: 'choice' | 'short_text' | 'free_text' | 'repeat_sentence' | 'free_speech'; prompt: string;
options?: { id: string; label: string }[]; passage?: string; reference_text?: string; audio_text?: string;
instruction_language?: string; instruction?: string; stimulus?: { role: 'target' | 'source' | 'context'; language: string; text: string };
variant_id?: string; content_revision?: string; canonical_task_id?: string;
options?: { id: string; label: string; language?: string; role?: 'target' | 'meaning' }[]; passage?: string; reference_text?: string; audio_text?: string;
source: 'seed' | 'flowise' | 'ai' | 'curated'; exam_id?: string; review?: boolean;
answer_key?: { correct_option_id?: string; reference_answer?: string; explanation: string; rubric: string[] };
answer_key?: { correct_option_id?: string; reference_answer?: string; reference_answer_language?: string; explanation: string; rubric: string[] };
};
export type AdaptiveAttempt = {
id: string; task_id: string; answer: string; status: 'pending' | 'graded' | 'failed' | 'ungraded'; demo: boolean; exam_id?: string;
@@ -25,13 +26,14 @@ export type CourseAnalysis = {
modules: { module_id: string; strengths: string[]; weaknesses: string[]; recommendation: string; reason: string; ready_for_completion: boolean }[];
};
export type CourseCatalog = {
instruction_language?: string; instruction_languages?: string[]; exam_available?: boolean;
task_mode?: string; grading_available?: boolean; bank?: {module_id:string;skill:CourseSkill;total:number;unseen:number}[];
profile: LearnerProfile; modules: AdaptiveModule[];
progress: { module_id: string; skill: CourseSkill; attempts: number; distinct_tasks: number; average_score: number }[];
analysis_job?: CourseJob; analysis: CourseAnalysis | null; facts_version: number; enabled_languages: string[]; languages: LanguageProfile[];
exams: { id: string; target_language: string; status: string }[];
};
export type CourseJob = { id: string; kind: string; status: string; stage: string; task_id?: string; subject_id?: string; error?: string; source?: string; review?: boolean };
export type CourseJob = { instruction_language?: string; id: string; kind: string; status: string; stage: string; task_id?: string; subject_id?: string; error?: string; source?: string; review?: boolean };
export type AdaptiveExam = { id: string; status: string; target_language: string; tasks: AdaptiveTask[]; attempts: AdaptiveAttempt[]; scores?: Record<CourseSkill, number>; score?: number; summary?: string; summary_status?: string; summary_job_id?: string; preparation_job_id?: string };
export function courseRequestID() { return Array.from(crypto.getRandomValues(new Uint8Array(16)), (b) => b.toString(16).padStart(2, '0')).join(''); }
export const getCourseCatalog = () => request<CourseCatalog>('/course/catalog');
-4
View File
@@ -1,8 +1,4 @@
import { request } from './client';
export const aiActions: Record<string,string> = {
analyze_course_progress:'Lernanalyse', plan_course_task:'Aufgabenplanung', author_course_task:'Aufgabenautor', review_course_task:'Aufgabenprüfung',
author_course_exam:'Testautor · 12 Aufgaben', review_course_exam:'Testprüfung · 12 Aufgaben', evaluate_course_attempt:'Antwortbewertung', summarize_course_exam:'Testzusammenfassung', next_exercise:'Aussprachegenerierung'
};
export type AIProfile={action:string;version:number;enabled:boolean;provider:string;model:string;temperature:number|null;reasoning_effort:string;max_tokens:number;context_tokens:number;timeout_seconds:number;json_schema:boolean;pricing_set:boolean;input_microusd_per_million:number;cached_input_microusd_per_million:number;output_microusd_per_million:number};
export type AIBudget={monthly_limit_microusd:number;daily_limit_microusd:number;month_committed_microusd:number;day_committed_microusd:number;open_reservations_microusd:number;warning:boolean;currency:string};
export type AISettings={profiles:Record<string,AIProfile>;budget:AIBudget;providers:Record<string,boolean>;prompt_version:string;prompts:Record<string,string>;schemas:Record<string,string>};
+2 -2
View File
@@ -5,13 +5,13 @@ export function fetchMe() {
return request<{ user: User; profile: LearnerProfile }>('/me');
}
export async function register(email: string, password: string) {
export async function register(email: string, password: string, uiLanguage: string) {
const result = await request<AuthResult>('/auth/register', {
method: 'POST',
body: JSON.stringify({
email,
password,
ui_language: 'de-DE',
ui_language: uiLanguage,
target_language: 'en-US',
daily_goal_minutes: 10
})
+1 -1
View File
@@ -2,7 +2,7 @@ import { request } from './client';
import type { TeacherResponse } from './types';
export type ConversationResponse = {
session?: { id: string };
session?: { id: string; target_language?: string };
turn?: { text: string };
user_turn?: { text: string };
teacher_turn?: { text: string };
+1
View File
@@ -2,6 +2,7 @@ export type User = {
id: string;
email: string;
ui_language: string;
instruction_language: string;
role: 'learner' | 'admin';
created_at: string;
};
+47 -24
View File
@@ -1,7 +1,7 @@
import { BookOpen, Bug, ChartNoAxesColumnIncreasing, LogOut, Mic, MessageCircle, Shield } from 'lucide-react';
import { useEffect, useState } from 'react';
import { fetchMe } from '../api/auth';
import { ApiError, clearToken, getToken } from '../api/client';
import { ApiError, clearToken, getToken, request } from '../api/client';
import { fetchDebugStatus } from '../api/debug';
import type { Exercise, Lesson, User } from '../api/types';
import { AdminPage } from '../pages/AdminPage';
@@ -14,8 +14,11 @@ import { ConversationPage } from '../pages/ConversationPage';
import { CoursePage } from '../pages/CoursePage';
import { DebugPage } from '../pages/DebugPage';
import { useHashRoute } from './useHashRoute';
import { LanguagePicker } from '../components/LanguagePicker';
import { isUILanguage, useI18n, type UILanguage } from '../i18n/I18n';
export function App() {
const { setLanguage, t } = useI18n();
const [route, setRoute] = useHashRoute(getToken() ? 'dashboard' : 'login');
const [debugAvailable, setDebugAvailable] = useState(false);
const [user, setUser] = useState<User | null>(null);
@@ -34,6 +37,7 @@ export function App() {
fetchMe().then(({ user: currentUser }) => {
if (!cancelled) {
setUser(currentUser);
setLanguage(isUILanguage(currentUser.ui_language) ? currentUser.ui_language : 'de-DE');
setAuthError('');
}
}).catch((error) => {
@@ -42,7 +46,7 @@ export function App() {
clearToken();
setRoute('login');
} else {
setAuthError(error instanceof Error ? error.message : 'Konto konnte nicht geladen werden.');
setAuthError(error instanceof Error ? error.message : t('auth.loadError'));
}
});
return () => { cancelled = true; };
@@ -76,6 +80,16 @@ export function App() {
setRoute('dashboard');
}
async function changeUILanguage(next: UILanguage) {
await request('/me/preferences', { method: 'PATCH', body: JSON.stringify({ ui_language: next }) });
setUser((current) => current?.id === user?.id && current ? { ...current, ui_language: next } : current);
}
async function changeInstructionLanguage(next: string) {
await request('/course/instruction-language', { method: 'PUT', body: JSON.stringify({ instruction_language: next }) });
setUser((current) => current?.id === user?.id && current ? { ...current, instruction_language: next } : current);
}
function logout() {
clearToken();
setUser(null);
@@ -91,11 +105,14 @@ export function App() {
if (!authed) {
return (
<main className="auth-shell">
{route === 'register' ? (
<RegisterPage onDone={handleAuthed} onLogin={() => setRoute('login')} />
) : (
<LoginPage onDone={handleAuthed} onRegister={() => setRoute('register')} />
)}
<div className="auth-content">
<LanguagePicker />
{route === 'register' ? (
<RegisterPage onDone={handleAuthed} onLogin={() => setRoute('login')} />
) : (
<LoginPage onDone={handleAuthed} onRegister={() => setRoute('register')} />
)}
</div>
</main>
);
}
@@ -104,14 +121,14 @@ export function App() {
return (
<main className="auth-shell">
<div className="auth-panel">
<h1>Konto wird geladen</h1>
<h1>{t('auth.loading')}</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>
<button className="primary-button" onClick={() => setAuthRevision((value) => value + 1)}>{t('common.retry')}</button>
<button className="link-button" onClick={logout}>{t('auth.logout')}</button>
</>
) : <p className="muted">Bitte einen Moment warten.</p>}
) : <p className="muted">{t('auth.wait')}</p>}
</div>
</main>
);
@@ -119,55 +136,61 @@ export function App() {
return (
<div className="app-shell">
<aside className="sidebar" aria-label="Navigation">
<aside className="sidebar" aria-label={t('nav.label')}>
<div>
<div className="brand">
<div className="brand-mark">SL</div>
<div>
<strong>Speech Learning</strong>
<span>A1 Sprachlernen</span>
<strong>{t('app.name')}</strong>
<span>{t('app.level')}</span>
</div>
</div>
<nav className="nav-list">
<button className={route === 'dashboard' ? 'active' : ''} onClick={() => setRoute('dashboard')}>
<BookOpen size={18} /> Heute
<BookOpen size={18} /> {t('nav.today')}
</button>
<button className={route === 'practice' ? 'active' : ''} onClick={() => setRoute('practice')}>
<Mic size={18} /> Aussprache
<Mic size={18} /> {t('nav.practice')}
</button>
<button className={route === 'course' ? 'active' : ''} onClick={() => setRoute('course')}>
<BookOpen size={18} /> A1-Kurs
<BookOpen size={18} /> {t('nav.course')}
</button>
<button className={route === 'conversation' ? 'active' : ''} onClick={() => setRoute('conversation')}>
<MessageCircle size={18} /> Dialog
<MessageCircle size={18} /> {t('nav.conversation')}
</button>
<button className={route === 'progress' ? 'active' : ''} onClick={() => setRoute('progress')}>
<ChartNoAxesColumnIncreasing size={18} /> Fortschritt
<ChartNoAxesColumnIncreasing size={18} /> {t('nav.progress')}
</button>
{user.role === 'admin' && (
<button className={route === 'admin' ? 'active' : ''} onClick={() => setRoute('admin')}>
<Shield size={18} /> Adminbereich
<Shield size={18} /> {t('nav.admin')}
</button>
)}
{debugAvailable && (
<button className={route === 'debug' ? 'active' : ''} onClick={() => setRoute('debug')}>
<Bug size={18} /> Debug
<Bug size={18} /> {t('nav.debug')}
</button>
)}
</nav>
</div>
<button className="ghost-button" onClick={logout}>
<LogOut size={18} /> Logout
<LogOut size={18} /> {t('auth.logout')}
</button>
</aside>
<main className="main-view">
<div className="language-settings">
<LanguagePicker onChange={changeUILanguage} />
<p className="muted">{t('language.instructions', { language: user.instruction_language === 'en-US' ? t('language.en-US') : user.instruction_language === 'de-DE' ? t('language.de-DE') : user.instruction_language || t('language.de-DE') })}</p>
<p className="muted">{t('language.bank')}</p>
<p className="muted">{t('language.content')}</p>
</div>
{route === 'dashboard' && <DashboardPage onLoaded={(lesson, exercise) => setPracticeSelection({ lesson, exercise })} onPractice={openDashboardExercise} />}
{route === 'practice' && <PracticePage initialSelection={practiceSelection} />}
{route === 'course' && <CoursePage />}
{route === 'course' && <CoursePage onInstructionLanguageChange={changeInstructionLanguage} />}
{route === 'conversation' && <ConversationPage />}
{route === 'progress' && <ProgressPage />}
{route === 'admin' && (user.role === 'admin' ? <AdminPage /> : <p className="form-error">Kein Zugriff auf den Adminbereich.</p>)}
{route === 'admin' && (user.role === 'admin' ? <AdminPage /> : <p className="form-error">{t('auth.denied')}</p>)}
{route === 'debug' && debugAvailable && <DebugPage />}
</main>
</div>
+27
View File
@@ -781,3 +781,30 @@ input:focus {
.pronunciation-target { border-bottom: 1px solid var(--border, #dce2e8); padding-bottom: 1rem; }
.pronunciation-target p { margin: .35rem 0; }
.language-settings {
display: flex;
flex-wrap: wrap;
align-items: center;
gap: 0.75rem 1.5rem;
margin-bottom: 1.5rem;
}
.language-picker label {
display: grid;
gap: 0.35rem;
}
.language-settings p {
margin: 0;
}
.auth-content {
display: grid;
gap: 1rem;
width: min(100%, 420px);
}
.auth-content .auth-panel {
width: 100%;
}
+49 -43
View File
@@ -1,20 +1,26 @@
import { useLocalizedMessage } from '../i18n/useLocalizedMessage';
import { useAIActionNames } from '../i18n/labels';
import { useI18n } from '../i18n/I18n';
import { useEffect, useRef, useState } from 'react';
import { aiActions, getAISettings, saveAIProfile, saveAIBudget, getAIModels, getAIUsage, getAICall, resolveAICall, testAI, testAIQuality, type AISettings, type AIProfile, type AIUsage, type AICall } from '../api/ai';
import { getAISettings, saveAIProfile, saveAIBudget, getAIModels, getAIUsage, getAICall, resolveAICall, testAI, testAIQuality, type AISettings, type AIProfile, type AIUsage, type AICall } from '../api/ai';
import { courseRequestID } from '../api/adaptive';
const dollars=(micro:number)=>new Intl.NumberFormat('de-DE',{style:'currency',currency:'USD',minimumFractionDigits:4,maximumFractionDigits:6}).format(micro/1000000);
const micro=(value:string)=>Math.round(Number(value||0)*1000000);
export function AIAdmin(){
const { t, language } = useI18n();
const aiActions = useAIActionNames();
const dollars=(micro:number)=>new Intl.NumberFormat(language,{style:'currency',currency:'USD',minimumFractionDigits:4,maximumFractionDigits:6}).format(micro/1000000);
const [settings,setSettings]=useState<AISettings|null>(null),[profile,setProfile]=useState<AIProfile|null>(null),[action,setAction]=useState('evaluate_course_attempt');
const [error,setError]=useState(''),[notice,setNotice]=useState(''),[busy,setBusy]=useState(false);
const [error, setError] = useLocalizedMessage(),[notice, setNotice] = useLocalizedMessage(),[busy,setBusy]=useState(false);
const [month,setMonth]=useState(''),[day,setDay]=useState(''),[models,setModels]=useState<{id:string}[]>([]);
const [usage,setUsage]=useState<AIUsage|null>(null),[filters,setFilters]=useState({from:'',to:'',provider:'',model:'',user:'',action:''}),[offset,setOffset]=useState(0);
const [detail,setDetail]=useState<AICall|null>(null),[input,setInput]=useState(''),[testResult,setTestResult]=useState<unknown>(null),[resolveCost,setResolveCost]=useState(''),[reason,setReason]=useState('');
const detailPanel=useRef<HTMLDivElement>(null),detailTrigger=useRef<HTMLButtonElement|null>(null);
const [detailLoading,setDetailLoading]=useState(false),[detailError,setDetailError]=useState('');
const [detailLoading,setDetailLoading]=useState(false),[detailError, setDetailError] = useLocalizedMessage();
useEffect(()=>{if(detail||detailLoading||detailError){detailPanel.current?.focus({preventScroll:true});detailPanel.current?.scrollIntoView({block:'start',behavior:'smooth'});}},[detail,detailLoading,detailError]);
function closeDetail(){setDetail(null);setDetailError('');detailTrigger.current?.focus();}
async function openDetail(id:string,trigger:HTMLButtonElement){if(busy)return;detailTrigger.current=trigger;setDetail(null);setDetailError('');setDetailLoading(true);await run(async()=>{try{setDetail(await getAICall(id));setResolveCost('');setReason('')}catch(e){setDetailError(e instanceof Error?e.message:'Aufrufdetails konnten nicht geladen werden.')}finally{setDetailLoading(false)}});}
const fail=(e:unknown)=>setError(e instanceof Error?e.message:'KI-Verwaltung nicht verfügbar');
async function openDetail(id:string,trigger:HTMLButtonElement){if(busy)return;detailTrigger.current=trigger;setDetail(null);setDetailError('');setDetailLoading(true);await run(async()=>{try{setDetail(await getAICall(id));setResolveCost('');setReason('')}catch(e){setDetailError(e instanceof Error?e.message:{ key: 'ui.unable_to_load_call_details' })}finally{setDetailLoading(false)}});}
const fail=(e:unknown)=>setError(e instanceof Error?e.message:{ key: 'ui.ai_administration_unavailable' });
async function refresh(){const s=await getAISettings();setSettings(s);setMonth(String(s.budget.monthly_limit_microusd/1000000));setDay(String(s.budget.daily_limit_microusd/1000000));return s;}
async function refreshUsage(){const q=new URLSearchParams({offset:String(offset)});for(const [k,v]of Object.entries(filters)){if(v)q.set(k,k==='from'||k==='to'?new Date(v).toISOString():v);}setUsage(await getAIUsage(q));}
useEffect(()=>{let valid=true;getAISettings().then(s=>{if(valid){setSettings(s);setMonth(String(s.budget.monthly_limit_microusd/1000000));setDay(String(s.budget.daily_limit_microusd/1000000));}}).catch(e=>{if(valid)fail(e)});return()=>{valid=false}},[]);
@@ -22,50 +28,50 @@ export function AIAdmin(){
useEffect(()=>{let valid=true;const q=new URLSearchParams({offset:String(offset)});for(const [k,v]of Object.entries(filters)){if(v)q.set(k,k==='from'||k==='to'?new Date(v).toISOString():v);}getAIUsage(q).then(u=>{if(valid)setUsage(u)}).catch(e=>{if(valid)fail(e)});return()=>{valid=false}},[filters,offset]);
async function run(fn:()=>Promise<void>){if(busy)return;setBusy(true);setError('');setNotice('');try{await fn()}catch(e){fail(e)}finally{setBusy(false)}}
function field<K extends keyof AIProfile>(key:K,value:AIProfile[K]){setProfile(p=>p?{...p,[key]:value}:p)}
return <section className="view-stack ai-admin" aria-label="KI-Verwaltung">
<header><h2>KI-Einstellungen und Verbrauch</h2><p>Direkte Modellaufrufe aus Go. Beträge sind Schätzungen in USD; verbindlich ist die Anbieterrechnung. Tages- und Monatsgrenzen gelten in UTC.</p></header>
return <section className="view-stack ai-admin" aria-label={t('ui.ai_administration')}>
<header><h2>{t('ui.ai_settings_and_usage')}</h2><p>{t('ui.direct_model_calls_from_go_amounts_are_usd_estimates_the')}</p></header>
{error&&<p className="form-error" role="alert">{error}</p>}{notice&&<p role="status">{notice}</p>}
{!settings?<p>KI-Einstellungen werden geladen…</p>:<>
<div className="panel view-stack"><h3>Budget</h3><p>API-Zugänge: DeepSeek {settings.providers.deepseek?'konfiguriert':'nicht konfiguriert'} · Mistral {settings.providers.mistral?'konfiguriert':'nicht konfiguriert'}</p>
<p>Monat gebunden: {dollars(settings.budget.month_committed_microusd)} · Tag gebunden: {dollars(settings.budget.day_committed_microusd)} · Offene Reservierungen: {dollars(settings.budget.open_reservations_microusd)}</p>
{settings.budget.warning&&<p role="status">Mindestens 80 % eines Budgets sind belegt.</p>}
{settings.budget.monthly_limit_microusd===0&&<p>KI-Aufrufe sind gesperrt, bis ein positives Monatsbudget eingerichtet ist.</p>}
<div className="ai-form-grid"><label>Monatslimit in USD<input type="number" min="0" step="0.01" value={month} onChange={e=>setMonth(e.target.value)}/></label><label>Tageslimit in USD · 0 = kein Tageslimit<input type="number" min="0" step="0.01" value={day} onChange={e=>setDay(e.target.value)}/></label></div>
<button type="button" disabled={busy} onClick={()=>void run(async()=>{await saveAIBudget(micro(month),micro(day));await refresh();setNotice('Budget gespeichert.');})}>Budget speichern</button>
<p className="muted">Vor jedem Aufruf wird eine konservative Obergrenze reserviert. Unbekannter Verbrauch bleibt gebunden, bis du ihn mit der Anbieterrechnung abgleichst. Eine neue Aufgabe kann mehrere Aufrufe benötigen.</p></div>
<div className="panel view-stack"><h3>Modellprofile</h3><label>Arbeitsschritt<select value={action} disabled={busy} onChange={e=>setAction(e.target.value)}>{Object.entries(aiActions).map(([id,label])=><option key={id} value={id}>{label}</option>)}</select></label>
{profile&&<><p className="muted">Version {profile.version}. Änderungen gelten für neue Aufträge; laufende Aufträge behalten ihre Einstellungen.</p>
<div className="ai-form-grid"><label>Anbieter<select value={profile.provider} disabled={busy} onChange={e=>{field('provider',e.target.value);field('json_schema',false);field('reasoning_effort','');setModels([])}}><option value="mistral">Mistral</option><option value="deepseek">DeepSeek</option></select></label>
<label>Modell-ID<input list="ai-models" value={profile.model} onChange={e=>{field('model',e.target.value);field('reasoning_effort','')}}/><datalist id="ai-models">{models.map(m=><option key={m.id} value={m.id}/>)}</datalist></label>
<label>Maximale Ausgabetokens<input type="number" min="128" max="2097152" value={profile.max_tokens} onChange={e=>field('max_tokens',Number(e.target.value))}/></label>
<label>Kontextbudget · Ein- und Ausgabe<input type="number" min="128" max="2097152" value={profile.context_tokens} onChange={e=>field('context_tokens',Number(e.target.value))}/></label>
<label>Temperatur · leer = nicht senden<input type="number" min="0" max="2" step="0.1" value={profile.temperature??''} onChange={e=>field('temperature',e.target.value===''?null:Number(e.target.value))}/></label>
<label>Denkaufwand · nur bei Unterstützung<select value={profile.reasoning_effort} onChange={e=>field('reasoning_effort',e.target.value)}>{['','none','minimal','low','medium','high','xhigh','max'].map(v=><option key={v} value={v}>{v||'Nicht senden'}</option>)}</select></label>
<label>Zeitlimit in Sekunden<input type="number" min="5" max="90" value={profile.timeout_seconds} onChange={e=>field('timeout_seconds',Number(e.target.value))}/></label>
{!settings?<p>{t('ui.loading_ai_settings')}</p>:<>
<div className="panel view-stack"><h3>{t('ui.budget')}</h3><p>{t('ai.access', { deepseek: t(settings.providers.deepseek ? 'ui.configured' : 'ui.not_configured'), mistral: t(settings.providers.mistral ? 'ui.configured' : 'ui.not_configured') })}</p>
<p>{t('ai.committed', { month: dollars(settings.budget.month_committed_microusd), day: dollars(settings.budget.day_committed_microusd), open: dollars(settings.budget.open_reservations_microusd) })}</p>
{settings.budget.warning&&<p role="status">{t('ui.at_least_80_of_a_budget_is_committed')}</p>}
{settings.budget.monthly_limit_microusd===0&&<p>{t('ui.ai_calls_are_blocked_until_a_positive_monthly_budget_is')}</p>}
<div className="ai-form-grid"><label>{t('ui.monthly_limit_in_usd')}<input type="number" min="0" step="0.01" value={month} onChange={e=>setMonth(e.target.value)}/></label><label>{t('ui.daily_limit_in_usd_0_no_daily_limit')}<input type="number" min="0" step="0.01" value={day} onChange={e=>setDay(e.target.value)}/></label></div>
<button type="button" disabled={busy} onClick={()=>void run(async()=>{await saveAIBudget(micro(month),micro(day));await refresh();setNotice({ key: 'ui.budget_saved' });})}>{t('ui.save_budget')}</button>
<p className="muted">{t('ui.a_conservative_upper_limit_is_reserved_before_each_call_unknown')}</p></div>
<div className="panel view-stack"><h3>{t('ui.model_profiles')}</h3><label>{t('ui.action')}<select value={action} disabled={busy} onChange={e=>setAction(e.target.value)}>{Object.entries(aiActions).map(([id,label])=><option key={id} value={id}>{label}</option>)}</select></label>
{profile&&<><p className="muted">{t('ai.version', { version: profile.version })}</p>
<div className="ai-form-grid"><label>{t('ui.provider')}<select value={profile.provider} disabled={busy} onChange={e=>{field('provider',e.target.value);field('json_schema',false);field('reasoning_effort','');setModels([])}}><option value="mistral">Mistral</option><option value="deepseek">DeepSeek</option></select></label>
<label>{t('ui.model_id')}<input list="ai-models" value={profile.model} onChange={e=>{field('model',e.target.value);field('reasoning_effort','')}}/><datalist id="ai-models">{models.map(m=><option key={m.id} value={m.id}/>)}</datalist></label>
<label>{t('ui.maximum_output_tokens')}<input type="number" min="128" max="2097152" value={profile.max_tokens} onChange={e=>field('max_tokens',Number(e.target.value))}/></label>
<label>{t('ui.context_budget_input_and_output')}<input type="number" min="128" max="2097152" value={profile.context_tokens} onChange={e=>field('context_tokens',Number(e.target.value))}/></label>
<label>{t('ui.temperature_empty_do_not_send')}<input type="number" min="0" max="2" step="0.1" value={profile.temperature??''} onChange={e=>field('temperature',e.target.value===''?null:Number(e.target.value))}/></label>
<label>{t('ui.reasoning_effort_only_when_supported')}<select value={profile.reasoning_effort} onChange={e=>field('reasoning_effort',e.target.value)}>{['','none','minimal','low','medium','high','xhigh','max'].map(v=><option key={v} value={v}>{v||t('ui.do_not_send')}</option>)}</select></label>
<label>{t('ui.timeout_in_seconds')}<input type="number" min="5" max="90" value={profile.timeout_seconds} onChange={e=>field('timeout_seconds',Number(e.target.value))}/></label>
</div>
<button type="button" disabled={busy} onClick={()=>void run(async()=>{const result=await getAIModels(profile.provider);setModels(result.data);setNotice(`${result.data.length} Modelle geladen. Verbindung erfolgreich. Ein Testlauf erzeugt zusätzliche, erfasste Kosten.`)})}>Modellliste laden / Verbindung prüfen</button>
<p className="muted">Modellnamen und unterstützte Parameter beim Anbieter prüfen. Das Kontextbudget wird vor dem Versand konservativ begrenzt. Für zwölfteilige Tests ein ausreichend großes Profil konfigurieren.</p>
<h4>Preise in USD pro Million Tokens</h4><div className="ai-form-grid">{([['input_microusd_per_million','Eingabe'],['cached_input_microusd_per_million','Gecachte Eingabe'],['output_microusd_per_million','Ausgabe']]as const).map(([key,label])=><label key={key}>{label}<input type="number" min="0" max="1000" step="0.000001" value={profile[key]/1000000} onChange={e=>field(key,micro(e.target.value))}/></label>)}</div>
<label><input type="checkbox" checked={profile.pricing_set} onChange={e=>field('pricing_set',e.target.checked)}/>Preise mit aktuellen Anbieterpreisen abgeglichen</label>
<label><input type="checkbox" checked={profile.json_schema} disabled={profile.provider!=='mistral'} onChange={e=>field('json_schema',e.target.checked)}/>JSON-Schemamodus · nur bei unterstütztem Mistral-Modell</label>
<label><input type="checkbox" checked={profile.enabled} onChange={e=>field('enabled',e.target.checked)}/>Profil für neue KI-Aufträge aktivieren</label>
<button type="button" disabled={busy} onClick={()=>void run(async()=>{const result=await getAIModels(profile.provider);setModels(result.data);setNotice({ key: 'ui.value_models_loaded_connection_successful_a_test_run_incurs_additional', parameters: { value0: result.data.length } })})}>{t('ui.load_model_list_check_connection')}</button>
<p className="muted">{t('ui.check_model_names_and_supported_parameters_with_the_provider_the')}</p>
<h4>{t('ui.prices_in_usd_per_million_tokens')}</h4><div className="ai-form-grid">{([['input_microusd_per_million',t('ui.input')],['cached_input_microusd_per_million',t('ui.cached_input')],['output_microusd_per_million',t('ui.output')]]as const).map(([key,label])=><label key={key}>{label}<input type="number" min="0" max="1000" step="0.000001" value={profile[key]/1000000} onChange={e=>field(key,micro(e.target.value))}/></label>)}</div>
<label><input type="checkbox" checked={profile.pricing_set} onChange={e=>field('pricing_set',e.target.checked)}/>{t('ui.prices_checked_against_current_provider_pricing')}</label>
<label><input type="checkbox" checked={profile.json_schema} disabled={profile.provider!=='mistral'} onChange={e=>field('json_schema',e.target.checked)}/>{t('ui.json_schema_mode_only_for_supported_mistral_models')}</label>
<label><input type="checkbox" checked={profile.enabled} onChange={e=>field('enabled',e.target.checked)}/>{t('ui.enable_profile_for_new_ai_jobs')}</label>
{error&&<p className="form-error" role="alert">{error}</p>}
<button type="button" className="primary-button" disabled={busy} onClick={()=>void run(async()=>{await saveAIProfile(profile);await refresh();setNotice('Neue Profilversion gespeichert. Vor Freigabe mit richtigen und falschen Antworten testen.');})}>Modellprofil speichern</button>
<details><summary>Verwendeter Systemprompt und Ausgabeschema</summary><pre>{settings.prompts[action]}</pre><pre>{settings.schemas[action]||'Kein separates Schema; Vertragsprüfung in Go.'}</pre></details>
{action==='evaluate_course_attempt'&&<><button type="button" disabled={busy} onClick={()=>void run(async()=>{setTestResult(await testAIQuality(courseRequestID()));await refreshUsage();await refresh()})}>Bewertungsqualität prüfen · 2 kostenpflichtige Testfälle</button><button type="button" disabled={busy} onClick={()=>void run(async()=>{setTestResult(await testAIQuality(courseRequestID(),'writing'));await refreshUsage();await refresh()})}>Schreibbewertung prüfen · 2 kostenpflichtige Testfälle</button></>}
<button type="button" className="primary-button" disabled={busy} onClick={()=>void run(async()=>{await saveAIProfile(profile);await refresh();setNotice({ key: 'ui.new_profile_version_saved_test_with_correct_and_incorrect_answers' });})}>{t('ui.save_model_profile')}</button>
<details><summary>{t('ui.system_prompt_and_output_schema')}</summary><pre>{settings.prompts[action]}</pre><pre>{settings.schemas[action]||t('ui.no_separate_schema_contract_validation_in_go')}</pre></details>
{action==='evaluate_course_attempt'&&<><button type="button" disabled={busy} onClick={()=>void run(async()=>{setTestResult(await testAIQuality(courseRequestID()));await refreshUsage();await refresh()})}>{t('ui.check_evaluation_quality_2_paid_test_cases')}</button><button type="button" disabled={busy} onClick={()=>void run(async()=>{setTestResult(await testAIQuality(courseRequestID(),'writing'));await refreshUsage();await refresh()})}>{t('ui.check_writing_evaluation_2_paid_test_cases')}</button></>}
{testResult!=null&&<pre>{JSON.stringify(testResult,null,2)}</pre>}
<details><summary>Gespeichertes Profil testen · erzeugt API-Kosten</summary><p>Hier nur den Inhalt von input einfügen. Der Aufruf verändert keinen Kursfortschritt und wird auch für ein deaktiviertes Profil erfasst. Änderungen am Profil zuerst speichern.</p><textarea rows={8} value={input} onChange={e=>setInput(e.target.value)} aria-label="KI-Testeingabe"/>
<button type="button" disabled={busy||!input.trim()} onClick={()=>void run(async()=>{const result=await testAI(action,JSON.parse(input),courseRequestID());setTestResult(result);await refreshUsage();await refresh();})}>Kostenpflichtigen Test ausführen</button></details>
<details><summary>{t('ui.test_saved_profile_incurs_api_costs')}</summary><p>{t('ui.paste_only_the_content_of_input_here_this_call_does')}</p><textarea rows={8} value={input} onChange={e=>setInput(e.target.value)} aria-label={t('ui.ai_test_input')}/>
<button type="button" disabled={busy||!input.trim()} onClick={()=>void run(async()=>{const result=await testAI(action,JSON.parse(input),courseRequestID());setTestResult(result);await refreshUsage();await refresh();})}>{t('ui.run_paid_test')}</button></details>
</>}
</div></>}
<div className="panel view-stack"><h3>KI-Verbrauch</h3><div className="ai-form-grid">{(['from','to','provider','model','user','action']as const).map(key=><label key={key}>{{from:'Von',to:'Bis',provider:'Anbieter',model:'Modell',user:'Nutzer-ID',action:'Arbeitsschritt'}[key]}{key==='provider'||key==='action'?<select value={filters[key]} onChange={e=>{setOffset(0);setFilters({...filters,[key]:e.target.value})}}><option value="">Alle</option>{Object.entries(key==='provider'?{deepseek:'DeepSeek',mistral:'Mistral'}:aiActions).map(([id,label])=><option key={id} value={id}>{label}</option>)}</select>:<input type={key==='from'||key==='to'?'datetime-local':'text'} value={filters[key]} onChange={e=>{setOffset(0);setFilters({...filters,[key]:e.target.value})}}/>}</label>)}</div>
<button type="button" disabled={busy} onClick={()=>void run(async()=>{await refreshUsage();await refresh()})}>Verbrauch aktualisieren</button>
{(detail||detailLoading||detailError)&&<div ref={detailPanel} tabIndex={-1} className="panel view-stack" role="region" aria-label="KI-Aufrufdetails" aria-busy={detailLoading}><h3>Aufrufdetails</h3><button type="button" disabled={detailLoading} onClick={closeDetail}>Schließen</button>{detailLoading&&<p role="status">Aufrufdetails werden geladen…</p>}{detailError&&<p className="form-error" role="alert">{detailError}</p>}{detail&&<><pre>{JSON.stringify(detail,null,2)}</pre>
{detail.cost_microusd==null&&detail.status!=='running'&&<><p>Unbekannten Verbrauch anhand der Anbieterrechnung abgleichen. Der Eintrag und die Begründung bleiben erhalten.</p><label>Tatsächliche Kosten in USD<input type="number" min="0" step="0.000001" value={resolveCost} onChange={e=>setResolveCost(e.target.value)}/></label><label>Begründung<input value={reason} onChange={e=>setReason(e.target.value)}/></label><button type="button" disabled={busy||resolveCost===''||reason.length<5} onClick={()=>void run(async()=>{await resolveAICall(detail.id,micro(resolveCost),reason);setDetail(null);await refreshUsage();await refresh()})}>Abgleich speichern</button></>}
<div className="panel view-stack"><h3>{t('ui.ai_usage')}</h3><div className="ai-form-grid">{(['from','to','provider','model','user','action']as const).map(key=><label key={key}>{{from:t('ui.from'),to:t('ui.to'),provider:t('ui.provider'),model:t('ui.model'),user:t('ui.user_id'),action:t('ui.action')}[key]}{key==='provider'||key==='action'?<select value={filters[key]} onChange={e=>{setOffset(0);setFilters({...filters,[key]:e.target.value})}}><option value="">{t('ui.all')}</option>{Object.entries(key==='provider'?{deepseek:'DeepSeek',mistral:'Mistral'}:aiActions).map(([id,label])=><option key={id} value={id}>{label}</option>)}</select>:<input type={key==='from'||key==='to'?'datetime-local':'text'} value={filters[key]} onChange={e=>{setOffset(0);setFilters({...filters,[key]:e.target.value})}}/>}</label>)}</div>
<button type="button" disabled={busy} onClick={()=>void run(async()=>{await refreshUsage();await refresh()})}>{t('ui.refresh_usage')}</button>
{(detail||detailLoading||detailError)&&<div ref={detailPanel} tabIndex={-1} className="panel view-stack" role="region" aria-label={t('ui.ai_call_details')} aria-busy={detailLoading}><h3>{t('ui.call_details')}</h3><button type="button" disabled={detailLoading} onClick={closeDetail}>{t('ui.close')}</button>{detailLoading&&<p role="status">{t('ui.loading_call_details')}</p>}{detailError&&<p className="form-error" role="alert">{detailError}</p>}{detail&&<><pre>{JSON.stringify(detail,null,2)}</pre>
{detail.cost_microusd==null&&detail.status!=='running'&&<><p>{t('ui.reconcile_unknown_usage_with_the_provider_invoice_the_record_and')}</p><label>{t('ui.actual_cost_in_usd')}<input type="number" min="0" step="0.000001" value={resolveCost} onChange={e=>setResolveCost(e.target.value)}/></label><label>{t('ui.reason')}<input value={reason} onChange={e=>setReason(e.target.value)}/></label><button type="button" disabled={busy||resolveCost===''||reason.length<5} onClick={()=>void run(async()=>{await resolveAICall(detail.id,micro(resolveCost),reason);setDetail(null);await refreshUsage();await refresh()})}>{t('ui.save_reconciliation')}</button></>}
</>}</div>}
{usage&&<><p>{usage.total} Aufrufe · Eingabe {usage.input_tokens.toLocaleString('de-DE')} · Ausgabe {usage.output_tokens.toLocaleString('de-DE')} Tokens</p><p>Geschätzte Kosten {dollars(usage.estimated_cost_microusd)} · offene Reservierungen {dollars(usage.reserved_microusd)} · Verbrauch unbekannt bei {usage.unknown_usage_calls} Aufrufen</p>
<div className="admin-table-wrap"><table className="admin-table"><thead><tr><th>Zeit / Nutzer</th><th>Modell / Schritt</th><th>Status</th><th>Tokens Ein / Aus</th><th>Kosten</th><th>Details</th></tr></thead><tbody>{usage.calls.map(c=><tr key={c.id}><td>{new Date(c.created_at).toLocaleString('de-DE')}<small>{c.user_id}</small></td><td>{c.provider} · {c.model}<small>{aiActions[c.action]??c.action} · Profil v{c.profile.version}{c.test?' · Test':''}</small></td><td>{c.status}<small>{c.duration_ms} ms · Versuch {c.attempt}</small></td><td>{c.usage?`${c.usage.input_tokens} / ${c.usage.output_tokens}`:'Unbekannt'}</td><td>{c.cost_microusd==null?`Reserviert ${dollars(c.reserved_microusd)}`:dollars(c.cost_microusd)}</td><td><button type="button" disabled={busy} onClick={e=>void openDetail(c.id,e.currentTarget)}>Anzeigen</button></td></tr>)}</tbody></table></div>
<div className="action-row"><button type="button" disabled={offset===0} onClick={()=>setOffset(Math.max(0,offset-50))}>Zurück</button><span>{offset+1}–{Math.min(offset+50,usage.total)} von {usage.total}</span><button type="button" disabled={offset+50>=usage.total} onClick={()=>setOffset(offset+50)}>Weiter</button></div></>}
{usage&&<><p>{t('ai.tokens', { calls: usage.total.toLocaleString(language), input: usage.input_tokens.toLocaleString(language), output: usage.output_tokens.toLocaleString(language) })}</p><p>{t('ai.costs', { cost: dollars(usage.estimated_cost_microusd), reserved: dollars(usage.reserved_microusd), unknown: usage.unknown_usage_calls.toLocaleString(language) })}</p>
<div className="admin-table-wrap"><table className="admin-table"><thead><tr><th>{t('ui.time_user')}</th><th>{t('ui.model_action')}</th><th>{t('ui.status')}</th><th>{t('ui.tokens_in_out')}</th><th>{t('ui.cost')}</th><th>{t('ui.details')}</th></tr></thead><tbody>{usage.calls.map(c=><tr key={c.id}><td>{new Date(c.created_at).toLocaleString(language)}<small>{c.user_id}</small></td><td>{c.provider} · {c.model}<small>{aiActions[c.action]??c.action}{t('ai.profileVersion', { version: c.profile.version })}{c.test?t('ui.test'):''}</small></td><td>{c.status}<small>{t('ai.attempt', { ms: c.duration_ms.toLocaleString(language), attempt: c.attempt })}</small></td><td>{c.usage?`${c.usage.input_tokens} / ${c.usage.output_tokens}`:t('ui.unknown')}</td><td>{c.cost_microusd==null?t('ai.reserved', { cost: dollars(c.reserved_microusd) }):dollars(c.cost_microusd)}</td><td><button type="button" disabled={busy} onClick={e=>void openDetail(c.id,e.currentTarget)}>{t('ui.show')}</button></td></tr>)}</tbody></table></div>
<div className="action-row"><button type="button" disabled={offset===0} onClick={()=>setOffset(Math.max(0,offset-50))}>{t('ui.back')}</button><span>{t('ai.range', { from: usage.total === 0 ? 0 : offset+1, to: Math.min(offset+50,usage.total), total: usage.total })}</span><button type="button" disabled={offset+50>=usage.total} onClick={()=>setOffset(offset+50)}>{t('ui.next')}</button></div></>}
</div>
</section>
+25 -18
View File
@@ -1,15 +1,20 @@
import { useLocalizedMessage } from '../i18n/useLocalizedMessage';
import { useCourseSkillNames } from '../i18n/labels';
import { useI18n } from '../i18n/I18n';
import { useEffect, useRef, useState } from 'react';
import { answerCourseAudio, answerCourseTask, courseRequestID, courseSkillNames, getAdaptiveAudio, type AdaptiveAttempt, type AdaptiveTask } from '../api/adaptive';
import { answerCourseAudio, answerCourseTask, courseRequestID, getAdaptiveAudio, type AdaptiveAttempt, type AdaptiveTask } from '../api/adaptive';
import { AudioRecorder } from './AudioRecorder';
type Props = { task: AdaptiveTask; attempt: AdaptiveAttempt | null; locked: boolean; onAttempt: (attempt: AdaptiveAttempt) => void; onBusy: (value: boolean) => void; onRecording: (value: boolean) => void };
export function AdaptiveExercise({ task, attempt, locked, onAttempt, onRecording, onBusy }: Props) {
const { t } = useI18n();
const courseSkillNames = useCourseSkillNames();
const [answer, setAnswer] = useState('');
const [recording, setRecording] = useState(false);
const [audio, setAudio] = useState<Blob | null>(null);
const [audioURL, setAudioURL] = useState('');
const [busy, setBusy] = useState(false);
const [error, setError] = useState('');
const [error, setError] = useLocalizedMessage();
useEffect(() => { onBusy(busy); return () => onBusy(false); }, [busy, onBusy]);
const requestID = useRef<string | null>(null);
const playback = useRef<{ audio: HTMLAudioElement; url: string } | null>(null);
@@ -21,8 +26,8 @@ export function AdaptiveExercise({ task, attempt, locked, onAttempt, onRecording
const disabled = locked || busy || examAnswered || attempt?.status === 'pending';
async function play() {
setError(''); setBusy(true);
try { stopPlayback(); const blob = await getAdaptiveAudio(task.id); const url = URL.createObjectURL(blob); const player = new Audio(url); playback.current = { audio: player, url }; player.onended = stopPlayback; player.onerror = () => { stopPlayback(); setError('Audio konnte nicht abgespielt werden.'); }; await player.play(); }
catch (err) { stopPlayback(); setError(err instanceof Error ? err.message : 'Audio nicht verfügbar.'); }
try { stopPlayback(); const blob = await getAdaptiveAudio(task.id); const url = URL.createObjectURL(blob); const player = new Audio(url); playback.current = { audio: player, url }; player.onended = stopPlayback; player.onerror = () => { stopPlayback(); setError({ key: 'ui.unable_to_play_audio' }); }; await player.play(); }
catch (err) { stopPlayback(); setError(err instanceof Error ? err.message : { key: 'ui.audio_unavailable' }); }
finally { setBusy(false); }
}
async function submit() {
@@ -32,31 +37,33 @@ export function AdaptiveExercise({ task, attempt, locked, onAttempt, onRecording
requestID.current ??= courseRequestID();
const result = isSpeech ? await answerCourseAudio(task.id, audio!, requestID.current) : await answerCourseTask(task.id, answer, requestID.current);
requestID.current = null; onAttempt(result.attempt); setAudio(null);
} catch (err) { setError(err instanceof Error ? err.message : 'Antwort konnte nicht gespeichert werden.'); }
} catch (err) { setError(err instanceof Error ? err.message : { key: 'ui.unable_to_save_your_answer' }); }
finally { setBusy(false); }
}
return <div className="view-stack">
<p className="eyebrow">{courseSkillNames[task.skill]} · {task.source === 'curated' ? 'Aus geprüftem Aufgabenbestand' : task.source === 'ai' ? 'Mit KI erstellt' : task.source === 'flowise' ? 'Mit Flowise erstellt' : 'Geprüfte Ersatzaufgabe'}{task.review ? ' · Wiederholung' : ''}</p>
<h2>{task.prompt}</h2>
{task.kind==='free_speech'&&<p className="muted">Inhalt und Sprache werden von der KI bewertet. Der Azure-Aussprachewert wird getrennt angezeigt.</p>}
<p className="eyebrow">{courseSkillNames[task.skill]} · {task.source === 'curated' ? t('ui.from_the_reviewed_exercise_bank') : task.source === 'ai' ? t('ui.created_with_ai') : task.source === 'flowise' ? t('ui.created_with_flowise') : t('ui.reviewed_fallback_exercise')}{task.review ? t('ui.review') : ''}</p>
{task.instruction_language && <p className="muted">{t('course.taskLanguage', { language: task.instruction_language === 'de-DE' ? t('language.de-DE') : task.instruction_language === 'en-US' ? t('language.en-US') : task.instruction_language })}</p>}
<h2 lang={task.instruction_language ?? (task.source === 'curated' ? 'de-DE' : undefined)} dir="auto">{task.instruction ?? task.prompt}</h2>
{task.stimulus && <p className="course-passage" lang={task.stimulus.language} dir="auto">{task.stimulus.text}</p>}
{task.kind==='free_speech'&&<p className="muted">{t('ui.ai_evaluates_content_and_language_the_azure_pronunciation_score_is')}</p>}
{task.passage && <p className="course-passage" lang={task.target_language} dir="auto">{task.passage}</p>}
{task.reference_text && <p className="target-text" lang={task.target_language} dir="auto">{task.reference_text}</p>}
{(task.skill === 'listening' || task.kind === 'repeat_sentence') && <button type="button" className="ghost-button" disabled={busy || recording} onClick={() => void play()}>Anhören</button>}
{task.kind === 'choice' && <div className="course-options" role="group" aria-label="Antwortmöglichkeiten">{task.options?.map((option) => <label key={option.id} className="course-option" dir="auto"><input type="radio" name={task.id} checked={answer === option.id} value={option.id} disabled={disabled} onChange={() => { setAnswer(option.id); requestID.current = null; }} />{option.label}</label>)}</div>}
{(task.kind === 'free_text' || task.kind === 'short_text') && <label>Deine Antwort<textarea rows={task.kind === 'free_text' ? 5 : 2} maxLength={10000} lang={task.target_language} dir="auto" disabled={disabled} value={answer} onChange={(event) => { setAnswer(event.target.value); requestID.current = null; }} /></label>}
{(task.skill === 'listening' || task.kind === 'repeat_sentence') && <button type="button" className="ghost-button" disabled={busy || recording} onClick={() => void play()}>{t('ui.listen')}</button>}
{task.kind === 'choice' && <div className="course-options" role="group" aria-label={t('ui.answer_options')}>{task.options?.map((option) => <label key={option.id} className="course-option" lang={option.language} dir="auto"><input type="radio" name={task.id} checked={answer === option.id} value={option.id} disabled={disabled} onChange={() => { setAnswer(option.id); requestID.current = null; }} />{option.label}</label>)}</div>}
{(task.kind === 'free_text' || task.kind === 'short_text') && <label>{t('ui.your_answer')}<textarea rows={task.kind === 'free_text' ? 5 : 2} maxLength={10000} lang={task.target_language} dir="auto" disabled={disabled} value={answer} onChange={(event) => { setAnswer(event.target.value); requestID.current = null; }} /></label>}
{isSpeech && <>
<p className="muted">Bis zu 30 Sekunden. Du kannst die Aufnahme vor dem Absenden anhören.</p>
<p className="muted">{t('ui.up_to_30_seconds_you_can_listen_to_your_recording')}</p>
<AudioRecorder maxSeconds={30} disabled={disabled} onRecorded={setAudio} onRecordingStart={() => { setAudio(null); requestID.current = null; stopPlayback(); }} onRecordingChange={(value) => { setRecording(value); onRecording(value); }} />
{audioURL && <audio controls src={audioURL} />}
</>}
<button type="button" className="primary-button" onClick={() => void submit()} disabled={disabled || recording || (isSpeech ? !audio : !answer.trim())}>{busy ? 'Antwort wird verarbeitet…' : task.exam_id ? 'Testantwort speichern' : 'Antwort prüfen'}</button>
<button type="button" className="primary-button" onClick={() => void submit()} disabled={disabled || recording || (isSpeech ? !audio : !answer.trim())}>{busy ? t('ui.processing_answer') : task.exam_id ? t('ui.save_test_answer') : t('ui.check_answer')}</button>
{error && <p className="form-error" role="alert">{error}</p>}
{attempt && <div className="course-feedback" role="status">
{attempt.demo && <p>Demo-Messung: zählt nicht als Lernnachweis.</p>}
{task.exam_id && !attempt.evaluation ? <p>Testantwort gespeichert. Das Feedback erscheint, sobald alle zwölf Antworten bewertet sind.</p> : attempt.status === 'pending' ? <p>Antwort gespeichert. Der Lehrer-Agent bewertet sie.</p> : attempt.status === 'ungraded' ? <p>Antwort gespeichert – ohne verbindliche Note. Eine KI-Bewertung kann später angefordert werden.</p> : attempt.status === 'failed' ? <p>Die Bewertung steht noch aus. Du kannst sie erneut anfordern.</p> : attempt.evaluation && <><strong>{task.kind==='free_speech'?'Inhalt und Sprache: ':''}{Math.round(attempt.evaluation.score)} / 100 · {attempt.evaluation.verdict === 'correct' ? 'Richtig' : attempt.evaluation.verdict === 'partial' ? 'Teilweise richtig' : 'Noch üben'}</strong><p>{attempt.evaluation.feedback}</p>{attempt.evaluation.issues?.map((issue, i) => <p key={i}>{issue}</p>)}</>}
{task.kind==='free_speech'&&<p>Erkannter Text: {attempt.answer}</p>}
{attempt.speech && <p>Aussprache: {Math.round(attempt.speech.overall_score)} / 100</p>}
{task.answer_key && <><p>{task.answer_key.explanation}</p>{attempt?.status === 'ungraded' && <><p>Zum Selbstvergleich, ohne Benotung:</p><ul>{task.answer_key.rubric?.map((rule,i)=><li key={i}>{rule}</li>)}</ul></>}{task.answer_key.reference_answer && <p lang={task.target_language} dir="auto">Beispiel: {task.answer_key.reference_answer}</p>}{task.audio_text && <p lang={task.target_language} dir="auto">Hörtext: {task.audio_text}</p>}</>}
{attempt.demo && <p>{t('ui.demo_measurement_does_not_count_as_learning_evidence')}</p>}
{task.exam_id && !attempt.evaluation ? <p>{t('ui.test_answer_saved_feedback_appears_once_all_twelve_answers_have')}</p> : attempt.status === 'pending' ? <p>{t('ui.answer_saved_the_teacher_agent_is_evaluating_it')}</p> : attempt.status === 'ungraded' ? <p>{t('ui.answer_saved_without_a_grade_you_can_request_an_ai')}</p> : attempt.status === 'failed' ? <p>{t('ui.evaluation_is_still_pending_you_can_request_it_again')}</p> : attempt.evaluation && <><strong>{task.kind==='free_speech'?t('ui.content_and_language'):''}{Math.round(attempt.evaluation.score)} / 100 · {attempt.evaluation.verdict === 'correct' ? t('ui.correct') : attempt.evaluation.verdict === 'partial' ? t('ui.partially_correct') : t('ui.keep_practising')}</strong><p>{attempt.evaluation.feedback}</p>{attempt.evaluation.issues?.map((issue, i) => <p key={i}>{issue}</p>)}</>}
{task.kind==='free_speech'&&<p>{t('ui.recognised_text')} {attempt.answer}</p>}
{attempt.speech && <p>{t('ui.pronunciation')} {Math.round(attempt.speech.overall_score)} / 100</p>}
{task.answer_key && <><p>{task.answer_key.explanation}</p>{attempt?.status === 'ungraded' && <><p>{t('ui.for_self_comparison_without_grading')}</p><ul>{task.answer_key.rubric?.map((rule,i)=><li key={i}>{rule}</li>)}</ul></>}{task.answer_key.reference_answer && <p>{t('ui.example')} <span lang={task.answer_key.reference_answer_language ?? task.target_language} dir="auto">{task.answer_key.reference_answer}</span></p>}{task.audio_text && <p>{t('ui.listening_transcript')} <span lang={task.target_language} dir="auto">{task.audio_text}</span></p>}</>}
</div>}
</div>;
}
+15 -15
View File
@@ -1,3 +1,5 @@
import { useLocalizedMessage } from '../i18n/useLocalizedMessage';
import { useI18n } from '../i18n/I18n';
import { Mic, Square } from 'lucide-react';
import { useEffect, useId, useRef, useState } from 'react';
@@ -12,10 +14,11 @@ type Props = {
enableMonitoring?: boolean;
};
export function AudioRecorder({ onRecorded, onRecordingStart, onRecordingChange, disabled, buttonLabel = 'Aufnehmen', secondary, maxSeconds, enableMonitoring = false }: Props) {
export function AudioRecorder({ onRecorded, onRecordingStart, onRecordingChange, disabled, buttonLabel, secondary, maxSeconds, enableMonitoring = false }: Props) {
const { t } = useI18n();
const [recording, setRecording] = useState(false);
const [starting, setStarting] = useState(false);
const [error, setError] = useState('');
const [error, setError] = useLocalizedMessage();
const [monitoring, setMonitoring] = useState(false);
const [monitorVolume, setMonitorVolume] = useState(50);
const monitoringHintID = useId();
@@ -103,7 +106,7 @@ export function AudioRecorder({ onRecorded, onRecordingStart, onRecordingChange,
} catch (err) {
stream?.getTracks().forEach((track) => track.stop());
if (audioContext) void audioContext.close();
setError(err instanceof Error ? err.message : 'Mikrofon nicht verfuegbar');
setError(err instanceof Error ? err.message : { key: 'ui.microphone_unavailable' });
onRecordingChange?.(false);
} finally {
startingRef.current = false;
@@ -129,7 +132,7 @@ export function AudioRecorder({ onRecorded, onRecordingStart, onRecordingChange,
onRecordingChange?.(false);
const merged = mergeBuffers(chunks.current);
if (merged.length === 0) {
setError('Keine Aufnahme erkannt. Bitte erneut versuchen.');
setError({ key: 'ui.no_recording_detected_please_try_again' });
return;
}
const downsampled = downsampleBuffer(merged, sampleRate.current, 16000);
@@ -141,29 +144,26 @@ export function AudioRecorder({ onRecorded, onRecordingStart, onRecordingChange,
<div className="recorder">
{recording ? (
<button className="danger-button" onClick={stop} type="button">
<Square size={18} /> Stoppen
</button>
<Square size={18} /> {t('ui.stop')} </button>
) : (
<button className={secondary ? 'ghost-button' : 'primary-button'} onClick={start} type="button" disabled={disabled || starting}>
<Mic size={18} /> {starting ? 'Mikrofon wird gestartet...' : buttonLabel}
<Mic size={18} /> {starting ? t('ui.starting_microphone') : (buttonLabel ?? t('ui.record'))}
</button>
)}
{enableMonitoring && <div className="audio-monitoring" role="group" aria-label="Audio-Monitoring">
{enableMonitoring && <div className="audio-monitoring" role="group" aria-label={t('ui.audio_monitoring')}>
<label className="monitoring-toggle">
<input type="checkbox" role="switch" checked={monitoring}
onChange={(event) => setMonitoring(event.target.checked)} disabled={disabled || starting}
aria-describedby={monitoringHintID} />
<span className="monitoring-switch" aria-hidden="true" />
Eigene Stimme mithören
</label>
<span className="monitoring-switch" aria-hidden="true" />{t('ui.monitor_your_own_voice')} </label>
<label className="monitoring-volume">
<span>Mithörlautstärke: {monitorVolume} %</span>
<span>{t('recorder.volume', { volume: monitorVolume })}</span>
<input type="range" min="0" max="100" step="1" value={monitorVolume}
onChange={(event) => setMonitorVolume(Number(event.target.value))}
disabled={!monitoring || disabled || starting} aria-label="Mithörlautstärke"
aria-valuetext={`${monitorVolume} Prozent`} />
disabled={!monitoring || disabled || starting} aria-label={t('ui.monitoring_volume_2')}
aria-valuetext={t('recorder.percent', { volume: monitorVolume })} />
</label>
<p className="muted" id={monitoringHintID}>Während der Aufnahme mit Kopfhörern nutzen. Die eigene Stimme kann leicht verzögert sein.</p>
<p className="muted" id={monitoringHintID}>{t('ui.use_headphones_while_recording_you_may_hear_your_voice_with')}</p>
</div>}
{error && <span className="inline-error">{error}</span>}
</div>
@@ -0,0 +1,29 @@
import { useEffect, useRef, useState } from 'react';
import { uiLanguages, useI18n, type UILanguage } from '../i18n/I18n';
type Props = { onChange?: (language: UILanguage) => Promise<void> };
export function LanguagePicker({ onChange }: Props) {
const { language, setLanguage, t } = useI18n();
const [saving, setSaving] = useState(false);
const [failed, setFailed] = useState(false);
const active = useRef(true);
useEffect(() => { active.current = true; return () => { active.current = false; }; }, []);
async function change(next: UILanguage) {
setSaving(true);
setFailed(false);
try {
await onChange?.(next);
if (active.current) setLanguage(next);
} catch { if (active.current) setFailed(true); }
finally { if (active.current) setSaving(false); }
}
return <div className="language-picker" aria-busy={saving}>
<label>{t('language.label')}
<select value={language} disabled={saving} onChange={(event) => void change(event.target.value as UILanguage)}>
{uiLanguages.map((code) => <option key={code} value={code} lang={code}>{code === 'de-DE' ? 'Deutsch' : 'English'}</option>)}
</select>
</label>
{failed && <p className="form-error" role="alert">{t('language.saveError')}</p>}
</div>;
}
+6 -4
View File
@@ -1,3 +1,4 @@
import { useI18n } from '../i18n/I18n';
import type { WordScore } from '../api/types';
type Props = {
@@ -5,16 +6,17 @@ type Props = {
};
export function PhonemeAnalysis({ words }: Props) {
const { t } = useI18n();
const scoredWords = words.filter((word) => word.error_type?.toLowerCase() !== 'omission' && (word.phoneme_scores?.length ?? 0) > 0);
return (
<section className="panel result-panel phoneme-panel">
<h2>Lautanalyse</h2>
<h2>{t('ui.sound_analysis')}</h2>
{scoredWords.length === 0 ? (
<p className="muted">Für diese Aufnahme sind keine Lautwerte verfügbar.</p>
<p className="muted">{t('ui.no_sound_scores_are_available_for_this_recording')}</p>
) : (
<>
<p className="muted">Azure bewertet jeden Laut von 0 bis 100. Werte unter 75 markieren hier Übungsbedarf.</p>
<p className="muted">{t('ui.azure_scores_each_sound_from_0_to_100_scores_below')}</p>
{scoredWords.map((word, wordIndex) => (
<div className="phoneme-row" key={`${word.word}-${wordIndex}`}>
<strong>{word.word}</strong>
@@ -22,7 +24,7 @@ export function PhonemeAnalysis({ words }: Props) {
{word.phoneme_scores?.map((phoneme, phonemeIndex) => (
<span
className={`word word-${phoneme.highlight}`}
title={`${word.word}: Laut /${phoneme.phoneme}/, ${Math.round(phoneme.accuracy)} von 100 Punkten`}
title={t('phoneme.tooltip', { word: word.word, phoneme: phoneme.phoneme, score: Math.round(phoneme.accuracy) })}
key={`${phoneme.phoneme}-${phonemeIndex}`}
>
/{phoneme.phoneme}/ {Math.round(phoneme.accuracy)}
@@ -1,28 +1,51 @@
import { useEffect, useState } from 'react';
import { fetchPronunciationProfile, type PronunciationProfile, type PronunciationTarget } from '../api/pronunciation';
const states:Record<string,string>={limited:'Wenige Nachweise – nachprüfen',observed:'Noch uneinheitlich',needs_practice:'Wiederholt schwierig',improved:'Verbessert',stable:'Stabil mit Wiederholung'};
const trends:Record<string,string>={insufficient:'Entwicklung noch nicht ausreichend belegt',improving:'Entwicklung verbessert',declining:'Zuletzt wieder schwieriger',steady:'Zuletzt ähnlich'};
export function PronunciationOverview(){
const [profile,setProfile]=useState<PronunciationProfile|null>(null),[error,setError]=useState(''),[all,setAll]=useState(false);
useEffect(()=>{let valid=true;fetchPronunciationProfile().then(p=>{if(valid)setProfile(p)}).catch(e=>{if(valid)setError(e instanceof Error?e.message:'Ausspracheprofil nicht verfügbar')});return()=>{valid=false}},[]);
if(error)return <section className="panel result-panel" aria-label="Ausspracheprofil"><h2>Ausspracheprofil</h2><p className="form-error" role="alert">{error}</p></section>;
if(!profile)return <section className="panel result-panel" aria-label="Ausspracheprofil"><p>Lautprofil wird geladen…</p></section>;
function group(kind:PronunciationTarget['kind'],title:string){
const targets=profile!.targets.filter(t=>t.kind===kind);
return <section className="panel result-panel"><h3>{title}</h3>{!targets.length?<p className="muted">Noch keine bestätigten Messungen in diesem Bereich.</p>:<div className="view-stack">{(all?targets:targets.slice(0,6)).map(t=><article className="pronunciation-target" key={t.key}>
<strong>{kind==='phoneme'?`/${t.symbol}/`:t.symbol}</strong> <span>{states[t.state]??t.state}</span>
<p>{kind==='omission'?`${100-Math.round(t.mean)} % gewichteter Auslassungsanteil`:`${Math.round(t.mean)} / 100`} · {t.samples} unabhängige Beobachtung{t.samples===1?'':'en'} · {t.words} Wortkontext{t.words===1?'':'e'} · {t.tasks} Aufgabe{t.tasks===1?'':'n'}</p>
<p className="muted">{trends[t.trend]??t.trend}. Zuletzt: {new Date(t.last_seen).toLocaleDateString('de-DE')}.</p>
{kind==='phoneme'&&<p>Beispielwörter: {t.examples.slice(0,5).map(e=>`${e.word} (${Math.round(e.mean)} / 100)`).join(', ')}</p>}
{t.next_review&&<p>{t.review_due?'Wiederholung fällig':'Nächste Wiederholung'}: {new Date(t.next_review).toLocaleDateString('de-DE')}</p>}
</article>)}</div>}</section>;
}
return <section className="view-stack" aria-label="Ausspracheprofil"><header><h2>Dein Ausspracheprofil · {profile.language}</h2><p>Echte Azure-Nachsprechmessungen aus Aussprache und Kurs werden zusammen betrachtet. Neuere Ergebnisse zählen stärker; ein einzelner Ausreißer ergibt noch kein sicheres Lautproblem.</p><p>{profile.confirmed_recordings} berücksichtigte Aufnahmen im Zeitfenster von {profile.window_days} Tagen. Wiederholungen derselben Aufgabe am selben Tag zählen je Wort oder Laut als eine Beobachtung.</p></header>
{profile.unverified_history>0&&<p className="muted">{profile.unverified_history} ältere Versuche bleiben im Verlauf erhalten. Ihre Messherkunft ist nicht belegt; sie bestimmen dieses Profil nicht.</p>}
{!profile.targets.length&&<p>Für dein neues Lautprofil fehlen noch bestätigte Messungen. Sprich einen Satz im Aussprachebereich nach, um zu beginnen.</p>}
{group('phoneme','Laute über verschiedene Wörter hinweg')}{group('word','Wörter')}
{profile.targets.some(t=>t.kind==='omission')&&group('omission','Vollständigkeit – ausgelassene Wörter')}
{profile.targets.length>6&&<button type="button" onClick={()=>setAll(!all)}>{all?'Weniger anzeigen':'Alle Beobachtungen anzeigen'}</button>}
<p className="muted">Die Zustände sind Lernhilfen, keine Zertifizierung. Wortgenauigkeit und Lautwerte sind keine statistischen Wahrscheinlichkeiten.</p>
</section>;
import { useI18n, type MessageKey } from '../i18n/I18n';
const states: Record<string, MessageKey> = {
limited: 'profile.state.limited', observed: 'profile.state.observed', needs_practice: 'profile.state.needs_practice',
improved: 'profile.state.improved', stable: 'profile.state.stable'
};
const trends: Record<string, MessageKey> = {
insufficient: 'profile.trend.insufficient', improving: 'profile.trend.improving',
declining: 'profile.trend.declining', steady: 'profile.trend.steady'
};
export function PronunciationOverview() {
const { t, language } = useI18n();
const [profile, setProfile] = useState<PronunciationProfile | null>(null);
const [error, setError] = useState('');
const [all, setAll] = useState(false);
useEffect(() => {
let valid = true;
fetchPronunciationProfile().then((value) => { if (valid) setProfile(value); })
.catch((err) => { if (valid) setError(err instanceof Error ? err.message : t('profile.error')); });
return () => { valid = false; };
}, []);
if (error) return <section className="panel result-panel" aria-label={t('profile.title')}><h2>{t('profile.title')}</h2><p className="form-error" role="alert">{error}</p></section>;
if (!profile) return <section className="panel result-panel" aria-label={t('profile.title')}><p>{t('profile.loading')}</p></section>;
function count(noun: 'observations' | 'contexts' | 'tasks', value: number) {
const form = new Intl.PluralRules(language).select(value) === 'one' ? 'one' : 'other';
return t(`profile.${noun}.${form}`, { count: value.toLocaleString(language) });
}
function group(kind: PronunciationTarget['kind'], title: string) {
const targets = profile!.targets.filter((target) => target.kind === kind);
return <section className="panel result-panel"><h3>{title}</h3>{!targets.length ? <p className="muted">{t('profile.none')}</p> :
<div className="view-stack">{(all ? targets : targets.slice(0, 6)).map((target) => <article className="pronunciation-target" key={target.key}>
<strong>{kind === 'phoneme' ? `/${target.symbol}/` : target.symbol}</strong> <span>{states[target.state] ? t(states[target.state]) : target.state}</span>
<p>{kind === 'omission' ? t('profile.omission', { count: 100 - Math.round(target.mean) }) : `${Math.round(target.mean)} / 100`} · {count('observations', target.samples)} · {count('contexts', target.words)} · {count('tasks', target.tasks)}</p>
<p className="muted">{t('profile.last', { trend: trends[target.trend] ? t(trends[target.trend]) : target.trend, date: new Date(target.last_seen).toLocaleDateString(language) })}</p>
{kind === 'phoneme' && <p>{t('profile.examples', { words: target.examples.slice(0, 5).map((example) => `${example.word} (${Math.round(example.mean)} / 100)`).join(', ') })}</p>}
{target.next_review && <p>{t(target.review_due ? 'profile.due' : 'profile.next', { date: new Date(target.next_review).toLocaleDateString(language) })}</p>}
</article>)}</div>}</section>;
}
return <section className="view-stack" aria-label={t('profile.title')}>
<header><h2>{t('profile.yours', { language: profile.language })}</h2><p>{t('profile.intro')}</p><p>{t('profile.evidence', { recordings: profile.confirmed_recordings.toLocaleString(language), days: profile.window_days.toLocaleString(language) })}</p></header>
{profile.unverified_history > 0 && <p className="muted">{t('profile.history', { count: profile.unverified_history.toLocaleString(language) })}</p>}
{!profile.targets.length && <p>{t('profile.start')}</p>}
{group('phoneme', t('profile.sounds'))}{group('word', t('profile.words'))}
{profile.targets.some((target) => target.kind === 'omission') && group('omission', t('profile.completeness'))}
{profile.targets.length > 6 && <button type="button" onClick={() => setAll(!all)}>{t(all ? 'profile.less' : 'profile.all')}</button>}
<p className="muted">{t('profile.limits')}</p>
</section>;
}
@@ -2,16 +2,17 @@ import type { WordScore } from '../api/types';
type Props = {
targetText: string;
language?: string;
words?: WordScore[] | null;
};
export function PronunciationText({ targetText, words }: Props) {
export function PronunciationText({ targetText, words, language }: Props) {
if (!words || words.length === 0) {
return <p className="target-text">{targetText}</p>;
return <p className="target-text" lang={language} dir="auto">{targetText}</p>;
}
return (
<p className="target-text word-feedback">
<p className="target-text word-feedback" lang={language} dir="auto">
{words.map((word, index) => (
<span
className={`word word-${word.highlight}`}
+51
View File
@@ -0,0 +1,51 @@
import { createContext, useContext, useEffect, useMemo, useState, type ReactNode } from 'react';
import de from './de-DE.json';
import en from './en-US.json';
export const uiLanguages = ['de-DE', 'en-US'] as const;
export type UILanguage = typeof uiLanguages[number];
export type MessageKey = keyof typeof de;
type Parameters = Record<string, string | number>;
const messages: Record<UILanguage, Record<MessageKey, string>> = { 'de-DE': de, 'en-US': en };
const storageKey = 'speech_ui_language';
export function isUILanguage(value: string): value is UILanguage {
return uiLanguages.some((language) => language === value);
}
function initialLanguage(): UILanguage {
try {
const saved = localStorage.getItem(storageKey);
if (saved && isUILanguage(saved)) return saved;
} catch { /* Ignore an inaccessible optional language preference. */ }
return 'de-DE';
}
const I18nContext = createContext<{
language: UILanguage;
setLanguage: (language: UILanguage) => void;
t: (key: MessageKey, parameters?: Parameters) => string;
} | null>(null);
export function I18nProvider({ children }: { children: ReactNode }) {
const [language, setLanguage] = useState<UILanguage>(initialLanguage);
useEffect(() => {
document.documentElement.lang = language;
document.documentElement.dir = 'ltr';
try { localStorage.setItem(storageKey, language); } catch { /* Storage is optional. */ }
}, [language]);
const value = useMemo(() => ({
language,
setLanguage,
t: (key: MessageKey, parameters: Parameters = {}) => messages[language][key].replace(
/\{(\w+)\}/g, (placeholder, name: string) => String(parameters[name] ?? placeholder)
)
}), [language]);
return <I18nContext.Provider value={value}>{children}</I18nContext.Provider>;
}
export function useI18n() {
const value = useContext(I18nContext);
if (!value) throw new Error('I18nProvider is required');
return value;
}
+411 -2
View File
@@ -1,4 +1,413 @@
{
"appName": "Speech Learning",
"targetLevel": "A1 English"
"app.name": "Speech Learning",
"app.level": "A1 Sprachlernen",
"nav.today": "Heute",
"nav.practice": "Aussprache",
"nav.course": "A1-Kurs",
"nav.conversation": "Dialog",
"nav.progress": "Fortschritt",
"nav.admin": "Adminbereich",
"nav.debug": "Debug",
"nav.label": "Navigation",
"auth.email": "E-Mail",
"auth.password": "Passwort",
"auth.login": "Einloggen",
"auth.register": "Account erstellen",
"auth.register.submit": "Registrieren",
"auth.back": "Zurück zum Login",
"auth.logout": "Abmelden",
"auth.loading": "Konto wird geladen",
"auth.wait": "Bitte einen Moment warten.",
"auth.loadError": "Konto konnte nicht geladen werden.",
"auth.loginError": "Login fehlgeschlagen",
"auth.registerError": "Registrierung fehlgeschlagen",
"auth.busy": "Bitte warten…",
"auth.denied": "Kein Zugriff auf den Adminbereich.",
"common.retry": "Erneut versuchen",
"language.label": "Oberflächensprache",
"language.saveError": "Die Sprache konnte nicht gespeichert werden.",
"language.instructions": "Bevorzugte Erklärungssprache: {language}.",
"language.de-DE": "Deutsch",
"language.en-US": "Englisch",
"language.registerInfo": "Der Englischkurs verwendet derzeit deutsche Aufgabenanweisungen und Erklärungen.",
"dashboard.error": "Dashboard konnte nicht geladen werden",
"dashboard.loading": "Lade Dashboard…",
"dashboard.title": "A1 Aussprachetraining",
"dashboard.next": "Nächste Übung",
"dashboard.dailyGoal": "Tagesziel",
"dashboard.average": "Durchschnitt",
"dashboard.attempts": "Versuche",
"dashboard.minutes": "{count} min",
"progress.error": "Fortschritt konnte nicht geladen werden",
"progress.loading": "Lade Fortschritt…",
"progress.overview": "Lernübersicht",
"progress.average": "Historischer Durchschnitt",
"progress.recent": "Letzte Versuche",
"language.bank": "Die Erklärungssprache neuer Kursaufgaben wird im A1-Kurs gewählt.",
"profile.title": "Ausspracheprofil",
"profile.yours": "Dein Ausspracheprofil · {language}",
"profile.error": "Ausspracheprofil nicht verfügbar",
"profile.loading": "Lautprofil wird geladen…",
"profile.state.limited": "Wenige Nachweise – nachprüfen",
"profile.state.observed": "Noch uneinheitlich",
"profile.state.needs_practice": "Wiederholt schwierig",
"profile.state.improved": "Verbessert",
"profile.state.stable": "Stabil mit Wiederholung",
"profile.trend.insufficient": "Entwicklung noch nicht ausreichend belegt",
"profile.trend.improving": "Entwicklung verbessert",
"profile.trend.declining": "Zuletzt wieder schwieriger",
"profile.trend.steady": "Zuletzt ähnlich",
"profile.none": "Noch keine bestätigten Messungen in diesem Bereich.",
"profile.omission": "{count} % gewichteter Auslassungsanteil",
"profile.observations.one": "{count} unabhängige Beobachtung",
"profile.observations.other": "{count} unabhängige Beobachtungen",
"profile.contexts.one": "{count} Wortkontext",
"profile.contexts.other": "{count} Wortkontexte",
"profile.tasks.one": "{count} Aufgabe",
"profile.tasks.other": "{count} Aufgaben",
"profile.last": "{trend}. Zuletzt: {date}.",
"profile.examples": "Beispielwörter: {words}",
"profile.due": "Wiederholung fällig: {date}",
"profile.next": "Nächste Wiederholung: {date}",
"profile.intro": "Echte Azure-Nachsprechmessungen aus Aussprache und Kurs werden zusammen betrachtet. Neuere Ergebnisse zählen stärker; ein einzelner Ausreißer ergibt noch kein sicheres Lautproblem.",
"profile.evidence": "{recordings} berücksichtigte Aufnahmen im Zeitfenster von {days} Tagen. Wiederholungen derselben Aufgabe am selben Tag zählen je Wort oder Laut als eine Beobachtung.",
"profile.history": "{count} ältere Versuche bleiben im Verlauf erhalten. Ihre Messherkunft ist nicht belegt; sie bestimmen dieses Profil nicht.",
"profile.start": "Für dein neues Lautprofil fehlen noch bestätigte Messungen. Sprich einen Satz im Aussprachebereich nach, um zu beginnen.",
"profile.sounds": "Laute über verschiedene Wörter hinweg",
"profile.words": "Wörter",
"profile.completeness": "Vollständigkeit – ausgelassene Wörter",
"profile.less": "Weniger anzeigen",
"profile.all": "Alle Beobachtungen anzeigen",
"profile.limits": "Die Zustände sind Lernhilfen, keine Zertifizierung. Wortgenauigkeit und Lautwerte sind keine statistischen Wahrscheinlichkeiten.",
"ui.job_saved": "Auftrag gespeichert",
"ui.preparing": "Vorbereitung",
"ui.analysing_learning_progress": "Lernstand wird analysiert",
"ui.planning_an_exercise": "Lernauftrag wird erstellt",
"ui.creating_and_reviewing_an_exercise": "Aufgabe wird erstellt und fachlich geprüft",
"ui.evaluating_your_answer": "Antwort wird bewertet",
"ui.creating_and_reviewing_twelve_test_questions": "Zwölf Testaufgaben werden erstellt und geprüft",
"ui.unable_to_load_the_course": "Der Kurs konnte nicht geladen werden.",
"ui.unable_to_complete_the_job": "Der Auftrag konnte nicht abgeschlossen werden.",
"ui.back_to_the_adaptive_course": "Zurück zum adaptiven Kurs",
"ui.loading_a1_course": "Lade A1-Kurs…",
"ui.reload": "Erneut laden",
"ui.adaptive_language_course_a1": "Adaptiver Sprachkurs · A1",
"ui.your_a1_course": "Dein A1-Kurs",
"ui.seven_modules_six_learning_areas_and_new_exercises_suited_to": "Sieben Module, sechs Lernbereiche und neue Aufgaben passend zu deinem Lernstand.",
"ui.learning_language": "Kurssprache",
"ui.course_not_yet_available": " – Kurs noch nicht verfügbar",
"ui.a_reviewed_a1_course_pack_is_not_yet_available_for": "Für diese Zielsprache ist noch kein geprüftes A1-Sprachpaket freigeschaltet. Dein bisheriger Lernstand bleibt gespeichert.",
"ui.your_learning_progress": "Dein Lernstand",
"ui.exercises_are_selected_using_your_saved_evaluations_new_exercises_come": "Die Auswahl nutzt deine gespeicherten Bewertungen. Noch neue Aufgaben haben Vorrang; bei Lernbedarf folgen passende Übungen und Wiederholungen. Unbenotete Antworten zählen nicht als bewerteter Lernnachweis.",
"ui.no_ai_learning_analysis_yet_the_teacher_agent_creates_it": "Noch keine KI-Lernanalyse vorhanden. Der Lehrer-Agent erstellt sie aus deinen gespeicherten Antworten.",
"ui.the_learning_analysis_is_being_updated_after_your_latest_answer": "Die Lernanalyse wird nach deiner letzten Antwort aktualisiert.",
"ui.request_learning_analysis_again": "Lernanalyse erneut anfordern",
"ui.ai_assessment_based_on_saved_learning_evidence_all_modules_remain": "KI-Einschätzung auf Basis gespeicherter Lernnachweise. Alle Module bleiben frei zugänglich.",
"ui.module": "Modul",
"ui.recommended": " · Empfohlen",
"ui.learning_objective_achieved_according_to_ai_and_evidence_across_learning": "Lernziel laut KI und Bereichsnachweisen erreicht",
"ui.continue_learning": "Weiterlernen",
"ui.more_practice": "Noch üben:",
"ui.learning_area": "Lernbereich",
"ui.ai_recommendation": "KI-Empfehlung",
"ui.preparing_exercise": "Aufgabe wird vorbereitet…",
"ui.next_exercise": "Nächste Aufgabe",
"ui.start_a_new_a1_test_12_questions": "Neuen A1-Test starten · 12 Aufgaben",
"ui.you_can_keep_practising_the_number_of_generated_exercises_does": "Du kannst beliebig weiterüben. Die Anzahl erzeugter Aufgaben entscheidet nicht über den Modulabschluss.",
"ui.retry_job": "Auftrag erneut versuchen",
"ui.no_graded_learning_evidence_yet": "Noch kein bewerteter Lernnachweis",
"ui.a1_test": "A1-Test",
"ui.test_completed": "Test abgeschlossen",
"ui.submitted_evaluation_pending_an_overall_score_appears_once_all_open": "Abgegeben – Bewertung ausstehend. Eine Gesamtnote erscheint nach der Bewertung aller offenen Antworten.",
"ui.value_of_12_answers_saved_feedback_appears_at_the_end": "{value0} von 12 Antworten gespeichert. Feedback erscheint am Ende.",
"ui.evaluate_pending_answers": "Ausstehende Antworten bewerten",
"ui.ai_evaluation_is_currently_unavailable_all_answers_remain_saved": "KI-Bewertung derzeit nicht verfügbar. Alle Antworten bleiben gespeichert.",
"ui.overall_result": "Gesamtergebnis:",
"ui.request_ai_overall_assessment_again": "KI-Gesamteinschätzung erneut anfordern",
"ui.internal_a1_learning_assessment": "Interne A1-Lerneinschätzung.",
"ui.saved_exercises": "Gespeicherte Aufgaben",
"ui.your_exercises": "Deine Aufgaben",
"ui.your_selected_exercises_are_saved_here": "Deine ausgewählten Aufgaben werden hier gespeichert.",
"ui.load_more_exercises": "Weitere Aufgaben laden",
"ui.a1_test_2": "A1-Test ·",
"ui.result": "Ergebnis",
"ui.resume": "Fortsetzen",
"ui.current_course_exercise": "Aktuelle Kursaufgabe",
"ui.request_evaluation": "Bewertung anfordern",
"ui.request_evaluation_again": "Bewertung erneut anfordern",
"ui.ai_evaluation_is_currently_unavailable_you_can_compare_your_answer": "Die KI-Bewertung ist derzeit nicht verfügbar. Du kannst deine Antwort ohne Benotung mit dem Beispiel vergleichen.",
"ui.your_answer_remains_saved_even_if_you_leave_this_page": "Die Antwort bleibt gespeichert, auch wenn du die Seite verlässt.",
"ui.choose_a_module_and_request_your_next_exercise": "Wähle ein Modul und fordere deine nächste Aufgabe an.",
"ui.open_the_original_fixed_course": "Bisherigen festen Kurs öffnen",
"ui.unable_to_play_audio": "Audio konnte nicht abgespielt werden.",
"ui.audio_unavailable": "Audio nicht verfügbar.",
"ui.unable_to_save_your_answer": "Antwort konnte nicht gespeichert werden.",
"ui.from_the_reviewed_exercise_bank": "Aus geprüftem Aufgabenbestand",
"ui.created_with_ai": "Mit KI erstellt",
"ui.created_with_flowise": "Mit Flowise erstellt",
"ui.reviewed_fallback_exercise": "Geprüfte Ersatzaufgabe",
"ui.review": " · Wiederholung",
"ui.ai_evaluates_content_and_language_the_azure_pronunciation_score_is": "Inhalt und Sprache werden von der KI bewertet. Der Azure-Aussprachewert wird getrennt angezeigt.",
"ui.listen": "Anhören",
"ui.answer_options": "Antwortmöglichkeiten",
"ui.your_answer": "Deine Antwort",
"ui.up_to_30_seconds_you_can_listen_to_your_recording": "Bis zu 30 Sekunden. Du kannst die Aufnahme vor dem Absenden anhören.",
"ui.processing_answer": "Antwort wird verarbeitet…",
"ui.save_test_answer": "Testantwort speichern",
"ui.check_answer": "Antwort prüfen",
"ui.demo_measurement_does_not_count_as_learning_evidence": "Demo-Messung: zählt nicht als Lernnachweis.",
"ui.test_answer_saved_feedback_appears_once_all_twelve_answers_have": "Testantwort gespeichert. Das Feedback erscheint, sobald alle zwölf Antworten bewertet sind.",
"ui.answer_saved_the_teacher_agent_is_evaluating_it": "Antwort gespeichert. Der Lehrer-Agent bewertet sie.",
"ui.answer_saved_without_a_grade_you_can_request_an_ai": "Antwort gespeichert – ohne verbindliche Note. Eine KI-Bewertung kann später angefordert werden.",
"ui.evaluation_is_still_pending_you_can_request_it_again": "Die Bewertung steht noch aus. Du kannst sie erneut anfordern.",
"ui.content_and_language": "Inhalt und Sprache: ",
"ui.correct": "Richtig",
"ui.partially_correct": "Teilweise richtig",
"ui.keep_practising": "Noch üben",
"ui.recognised_text": "Erkannter Text:",
"ui.pronunciation": "Aussprache:",
"ui.for_self_comparison_without_grading": "Zum Selbstvergleich, ohne Benotung:",
"ui.example": "Beispiel:",
"ui.listening_transcript": "Hörtext:",
"ui.unable_to_play_the_sentence_please_try_again": "Satz konnte nicht abgespielt werden. Bitte erneut versuchen.",
"ui.the_agent_generated_the_same_sentence_again_please_try_once": "Der Agent hat denselben Satz erneut erzeugt. Bitte versuche es noch einmal.",
"ui.unable_to_load_exercise": "Uebung konnte nicht geladen werden",
"ui.evaluation_failed": "Bewertung fehlgeschlagen",
"ui.loading_exercise": "Lade Uebung...",
"ui.loading_new_exercise": "Lade neue Uebung...",
"ui.different_exercise": "Andere Uebung",
"ui.why_this_exercise": "Warum diese Übung:",
"ui.loading_sentence": "Satz wird geladen...",
"ui.listen_to_sentence": "Satz anhören",
"ui.listen_slowly": "Langsam anhören",
"ui.listen_to_these_practice_words": "Diese Wörter kannst du gezielt anhören:",
"ui.loading_word": "Wort wird geladen...",
"ui.practise_value_slowly": "{value0} langsam üben",
"ui.evaluating": "Bewertung läuft...",
"ui.record_again": "Erneut aufnehmen",
"ui.record": "Aufnehmen",
"ui.evaluate": "Bewerten",
"ui.recording_not_yet_submitted_listen_record_again_or_request_evaluation": "Aufnahme noch nicht gesendet. Anhören, erneut aufnehmen oder bewerten.",
"ui.listen_to_your_recording": "Eigene Aufnahme anhören",
"ui.evaluating_pronunciation": "Die Aussprache wird bewertet...",
"ui.evaluation": "Bewertung",
"ui.overall": "Gesamt",
"ui.accuracy": "Genauigkeit",
"ui.fluency": "Flüssigkeit",
"ui.completeness": "Vollständigkeit",
"ui.teacher_feedback": "Lehrerfeedback",
"ui.microphone_unavailable": "Mikrofon nicht verfuegbar",
"ui.no_recording_detected_please_try_again": "Keine Aufnahme erkannt. Bitte erneut versuchen.",
"ui.stop": "Stoppen",
"ui.starting_microphone": "Mikrofon wird gestartet...",
"ui.audio_monitoring": "Audio-Monitoring",
"ui.monitor_your_own_voice": "Eigene Stimme mithören",
"ui.monitoring_volume": "Mithörlautstärke:",
"ui.monitoring_volume_2": "Mithörlautstärke",
"ui.use_headphones_while_recording_you_may_hear_your_voice_with": "Während der Aufnahme mit Kopfhörern nutzen. Die eigene Stimme kann leicht verzögert sein.",
"ui.sound_analysis": "Lautanalyse",
"ui.no_sound_scores_are_available_for_this_recording": "Für diese Aufnahme sind keine Lautwerte verfügbar.",
"ui.azure_scores_each_sound_from_0_to_100_scores_below": "Azure bewertet jeden Laut von 0 bis 100. Werte unter 75 markieren hier Übungsbedarf.",
"ui.unable_to_start_conversation": "Dialog konnte nicht gestartet werden",
"ui.reply_failed": "Antwort fehlgeschlagen",
"ui.a1_role_play": "A1 Rollenspiel",
"ui.start": "Start",
"ui.start_a_short_a1_conversation": "Starte einen kurzen A1-Dialog.",
"ui.teacher": "Lehrer",
"ui.you": "Du",
"ui.send": "Senden",
"ui.play_audio": "Audio abspielen",
"ui.no_attempts_yet": "Noch kein Versuch",
"ui.unable_to_load_metrics": "Kennzahlen konnten nicht geladen werden.",
"ui.unable_to_load_users": "Nutzer konnten nicht geladen werden.",
"ui.administration": "Verwaltung",
"ui.an_overview_of_users_and_learning_activity": "Nutzer und Lernaktivität im Blick.",
"ui.product_metrics": "Produktkennzahlen",
"ui.total_users": "Nutzer gesamt",
"ui.active_in_7_days": "Aktiv in 7 Tagen",
"ui.speaking_attempts": "Sprechversuche",
"ui.ai_pronunciation_exercises": "KI-Ausspracheübungen",
"ui.average_score": "Ø Bewertung",
"ui.users": "Nutzer",
"ui.accounts_and_learning_activity_search_by_email_address": "Konten und Lernaktivität. Suche nach E-Mail-Adresse.",
"ui.search_email": "E-Mail suchen",
"ui.search": "Suchen",
"ui.role": "Rolle",
"ui.registered": "Registriert",
"ui.latest_attempt": "Letzter Versuch",
"ui.admin": "Admin",
"ui.learners": "Lernende",
"ui.no_matching_users_found": "Keine passenden Nutzer gefunden.",
"ui.loading_users": "Lade Nutzer...",
"ui.back": "Zurück",
"ui.next": "Weiter",
"ui.product_operations": "Produktbetrieb",
"ui.sales_and_access": "Verkauf und Zugänge",
"ui.plans_payments_and_access_to_purchased_content_are_not_connected": "Tarife, Zahlungen und Berechtigungen für gekaufte Inhalte sind noch nicht angeschlossen. Deshalb zeigt dieser Bereich keine erfundenen Umsatz- oder Abozahlen.",
"ui.next_product_catalogue": "Als Nächstes: Produktkatalog",
"ui.then_payment_provider_and_webhooks": "Dann: Zahlungsanbieter und Webhooks",
"ui.after_that_access_rights_per_purchase": "Danach: Zugangsrechte pro Kauf",
"ui.unable_to_load_call_details": "Aufrufdetails konnten nicht geladen werden.",
"ui.ai_administration_unavailable": "KI-Verwaltung nicht verfügbar",
"ui.ai_administration": "KI-Verwaltung",
"ui.ai_settings_and_usage": "KI-Einstellungen und Verbrauch",
"ui.direct_model_calls_from_go_amounts_are_usd_estimates_the": "Direkte Modellaufrufe aus Go. Beträge sind Schätzungen in USD; verbindlich ist die Anbieterrechnung. Tages- und Monatsgrenzen gelten in UTC.",
"ui.loading_ai_settings": "KI-Einstellungen werden geladen…",
"ui.budget": "Budget",
"ui.configured": "konfiguriert",
"ui.not_configured": "nicht konfiguriert",
"ui.at_least_80_of_a_budget_is_committed": "Mindestens 80 % eines Budgets sind belegt.",
"ui.ai_calls_are_blocked_until_a_positive_monthly_budget_is": "KI-Aufrufe sind gesperrt, bis ein positives Monatsbudget eingerichtet ist.",
"ui.monthly_limit_in_usd": "Monatslimit in USD",
"ui.daily_limit_in_usd_0_no_daily_limit": "Tageslimit in USD · 0 = kein Tageslimit",
"ui.budget_saved": "Budget gespeichert.",
"ui.save_budget": "Budget speichern",
"ui.a_conservative_upper_limit_is_reserved_before_each_call_unknown": "Vor jedem Aufruf wird eine konservative Obergrenze reserviert. Unbekannter Verbrauch bleibt gebunden, bis du ihn mit der Anbieterrechnung abgleichst. Eine neue Aufgabe kann mehrere Aufrufe benötigen.",
"ui.model_profiles": "Modellprofile",
"ui.action": "Arbeitsschritt",
"ui.provider": "Anbieter",
"ui.model_id": "Modell-ID",
"ui.maximum_output_tokens": "Maximale Ausgabetokens",
"ui.context_budget_input_and_output": "Kontextbudget · Ein- und Ausgabe",
"ui.temperature_empty_do_not_send": "Temperatur · leer = nicht senden",
"ui.reasoning_effort_only_when_supported": "Denkaufwand · nur bei Unterstützung",
"ui.do_not_send": "Nicht senden",
"ui.timeout_in_seconds": "Zeitlimit in Sekunden",
"ui.value_models_loaded_connection_successful_a_test_run_incurs_additional": "{value0} Modelle geladen. Verbindung erfolgreich. Ein Testlauf erzeugt zusätzliche, erfasste Kosten.",
"ui.load_model_list_check_connection": "Modellliste laden / Verbindung prüfen",
"ui.check_model_names_and_supported_parameters_with_the_provider_the": "Modellnamen und unterstützte Parameter beim Anbieter prüfen. Das Kontextbudget wird vor dem Versand konservativ begrenzt. Für zwölfteilige Tests ein ausreichend großes Profil konfigurieren.",
"ui.prices_in_usd_per_million_tokens": "Preise in USD pro Million Tokens",
"ui.input": "Eingabe",
"ui.cached_input": "Gecachte Eingabe",
"ui.output": "Ausgabe",
"ui.prices_checked_against_current_provider_pricing": "Preise mit aktuellen Anbieterpreisen abgeglichen",
"ui.json_schema_mode_only_for_supported_mistral_models": "JSON-Schemamodus · nur bei unterstütztem Mistral-Modell",
"ui.enable_profile_for_new_ai_jobs": "Profil für neue KI-Aufträge aktivieren",
"ui.new_profile_version_saved_test_with_correct_and_incorrect_answers": "Neue Profilversion gespeichert. Vor Freigabe mit richtigen und falschen Antworten testen.",
"ui.save_model_profile": "Modellprofil speichern",
"ui.system_prompt_and_output_schema": "Verwendeter Systemprompt und Ausgabeschema",
"ui.no_separate_schema_contract_validation_in_go": "Kein separates Schema; Vertragsprüfung in Go.",
"ui.check_evaluation_quality_2_paid_test_cases": "Bewertungsqualität prüfen · 2 kostenpflichtige Testfälle",
"ui.check_writing_evaluation_2_paid_test_cases": "Schreibbewertung prüfen · 2 kostenpflichtige Testfälle",
"ui.test_saved_profile_incurs_api_costs": "Gespeichertes Profil testen · erzeugt API-Kosten",
"ui.paste_only_the_content_of_input_here_this_call_does": "Hier nur den Inhalt von input einfügen. Der Aufruf verändert keinen Kursfortschritt und wird auch für ein deaktiviertes Profil erfasst. Änderungen am Profil zuerst speichern.",
"ui.ai_test_input": "KI-Testeingabe",
"ui.run_paid_test": "Kostenpflichtigen Test ausführen",
"ui.ai_usage": "KI-Verbrauch",
"ui.from": "Von",
"ui.to": "Bis",
"ui.model": "Modell",
"ui.user_id": "Nutzer-ID",
"ui.all": "Alle",
"ui.refresh_usage": "Verbrauch aktualisieren",
"ui.ai_call_details": "KI-Aufrufdetails",
"ui.call_details": "Aufrufdetails",
"ui.close": "Schließen",
"ui.loading_call_details": "Aufrufdetails werden geladen…",
"ui.reconcile_unknown_usage_with_the_provider_invoice_the_record_and": "Unbekannten Verbrauch anhand der Anbieterrechnung abgleichen. Der Eintrag und die Begründung bleiben erhalten.",
"ui.actual_cost_in_usd": "Tatsächliche Kosten in USD",
"ui.reason": "Begründung",
"ui.save_reconciliation": "Abgleich speichern",
"ui.time_user": "Zeit / Nutzer",
"ui.model_action": "Modell / Schritt",
"ui.status": "Status",
"ui.tokens_in_out": "Tokens Ein / Aus",
"ui.cost": "Kosten",
"ui.details": "Details",
"ui.unknown": "Unbekannt",
"ui.show": "Anzeigen",
"ui.test": " · Test",
"ui.system_diagnostics": "Systemdiagnose",
"ui.check_again": "Neu pruefen",
"ui.error": "Fehler",
"ui.no_http_status": "Kein HTTP-Status",
"ui.request_id_value": "Request-ID {value0}",
"ui.database": "Datenbank",
"ui.ai_connection": "KI-Anbindung",
"ui.azure_speech": "Azure Speech",
"ui.runtime": "Runtime",
"ui.configuration": "Konfiguration",
"ui.problem": "Problem",
"ui.not_checked_yet": "Noch nicht geprueft.",
"ui.no_data": "Keine Daten.",
"ui.unknown_error": "Unbekannter Fehler",
"ui.check_value": "{value0} pruefen",
"ui.vocabulary": "Wortschatz",
"ui.listening": "Hören",
"ui.reading": "Lesen",
"ui.grammar": "Grammatik",
"ui.writing": "Schreiben",
"ui.speaking": "Sprechen",
"ui.unable_to_load_course": "Kurs konnte nicht geladen werden.",
"ui.an_exercise_from_the_reviewed_bank_is_ready": "Eine Aufgabe aus dem geprüften Bestand ist bereit.",
"ui.an_additional_ai_exercise_is_ready": "Eine mit KI erstellte Zusatzaufgabe ist bereit.",
"ui.a_fixed_course_exercise_is_ready_for_review": "Du erhältst eine feste Kursaufgabe zur Wiederholung.",
"ui.unable_to_load_additional_exercise": "Zusatzaufgabe konnte nicht geladen werden.",
"ui.unable_to_play_audio_please_try_again": "Audio konnte nicht abgespielt werden. Bitte erneut versuchen.",
"ui.unable_to_evaluate_your_answer": "Antwort konnte nicht bewertet werden.",
"ui.unable_to_evaluate_pronunciation": "Aussprache konnte nicht bewertet werden.",
"ui.no_course_module_is_available_for_your_current_language_and": "Für deine aktuelle Sprache und Lernstufe ist noch kein Kursmodul verfügbar.",
"ui.loading_a1_course_2": "Lade A1-Kurs...",
"ui.guided_a1_course": "Geführter A1-Kurs",
"ui.module_progress": "Modulfortschritt",
"ui.additional_practice": "Zusätzlich üben",
"ui.review_vocabulary_and_grammar_your_progress_in_the_fixed_course": "Wortschatz und Grammatik wiederholen. Dein Fortschritt im festen Kurs bleibt davon getrennt.",
"ui.new_additional_exercise": "Neue Zusatzaufgabe",
"ui.loading_additional_exercises": "Zusatzaufgaben werden geladen…",
"ui.preparing_a_suitable_exercise_this_can_take_up_to_25": "Eine passende Aufgabe wird vorbereitet. Das kann bis zu 25 Sekunden dauern.",
"ui.unable_to_load_additional_exercise_2": "Zusatzaufgabe konnte nicht geladen werden:",
"ui.course_exercises": "Kursaufgaben",
"ui.your_additional_exercises": "Deine Zusatzaufgaben",
"ui.exercise": "Aufgabe",
"ui.from_the_reviewed_exercise_bank_2": "Aus geprüftem Aufgabenbestand · ",
"ui.created_with_ai_2": "Mit KI erstellt · ",
"ui.created_with_flowise_2": "Mit Flowise erstellt · ",
"ui.fixed_course_exercise_for_review": "Feste Kursaufgabe zur Wiederholung · ",
"ui.additional_practice_2": "Zusätzlich üben · ",
"ui.listen_first_the_spoken_text_appears_after_your_answer": "Höre zuerst zu. Der gesprochene Text erscheint nach deiner Antwort.",
"ui.checking": "Wird geprüft...",
"ui.you_can_listen_to_your_recording_or_record_again_before": "Du kannst die Aufnahme vor dem Bewerten anhören oder erneut aufnehmen.",
"ui.correct_2": "Richtig!",
"ui.not_correct_yet": "Noch nicht richtig.",
"ui.example_answer": "Musterantwort:",
"ui.listening_transcript_2": "Gehörter Text:",
"action.analyze_course_progress": "Lernanalyse",
"action.plan_course_task": "Aufgabenplanung",
"action.author_course_task": "Aufgabenautor",
"action.review_course_task": "Aufgabenprüfung",
"action.author_course_exam": "Testautor · 12 Aufgaben",
"action.review_course_exam": "Testprüfung · 12 Aufgaben",
"action.evaluate_course_attempt": "Antwortbewertung",
"action.summarize_course_exam": "Testzusammenfassung",
"action.next_exercise": "Aussprachegenerierung",
"course.modulesLabel": "A1-Module",
"course.inventory": "Geprüfter Aufgabenbestand: {total} Aufgaben · {unseen} noch neu. Danach stehen Wiederholungen bereit.",
"course.progress": "{tasks} Aufgaben · {attempts} Antworten · Ø {score}/100",
"admin.matches": "{count} Treffer",
"admin.page": "Seite {page} von {total}",
"ai.access": "API-Zugänge: DeepSeek {deepseek} · Mistral {mistral}",
"ai.committed": "Monat gebunden: {month} · Tag gebunden: {day} · Offene Reservierungen: {open}",
"ai.version": "Version {version}. Änderungen gelten für neue Aufträge; laufende Aufträge behalten ihre Einstellungen.",
"ai.tokens": "{calls} Aufrufe · Eingabe {input} · Ausgabe {output} Tokens",
"ai.costs": "Geschätzte Kosten {cost} · offene Reservierungen {reserved} · Verbrauch unbekannt bei {unknown} Aufrufen",
"ai.profileVersion": " · Profil v{version}",
"ai.attempt": "{ms} ms · Versuch {attempt}",
"ai.reserved": "Reserviert {cost}",
"ai.range": "{from}–{to} von {total}",
"legacy.completed": "{done} von {total} Aufgaben bearbeitet",
"legacy.correct": "{count} Aufgaben richtig gelöst. „Bearbeitet“ bedeutet nicht „A1 bestanden“.",
"legacy.areaProgress": "{done}/{total} bearbeitet · {correct} Ziel erreicht",
"recorder.percent": "{volume} Prozent",
"recorder.volume": "Mithörlautstärke: {volume} %",
"phoneme.tooltip": "{word}: Laut /{phoneme}/, {score} von 100 Punkten",
"language.content": "Lerninhalte und gespeicherte Rückmeldungen behalten ihre ursprüngliche Sprache.",
"conversation.answer": "Deine Dialogantwort",
"conversation.audioError": "Audio konnte nicht abgespielt werden.",
"course.instructionLanguage": "Erklärungssprache der Aufgaben",
"course.instructionScope": "Gilt für neue Aufgaben und KI-Erklärungen. Bereits zugewiesene Aufgaben, Lösungen und Bewertungen behalten ihre ursprüngliche Sprache.",
"course.englishPilot": "Englischer Pilot: zwölf Aufgaben in „Begrüßung & Vorstellung“, je zwei pro Lernbereich. Die übrigen Module und der A1-Test sind vorerst nur mit deutschen Erklärungen verfügbar.",
"course.noVariant": "Für diesen Bereich gibt es noch keine geprüften Aufgaben in der gewählten Erklärungssprache. Wähle das Vorstellungsmodul oder Deutsch als Erklärungssprache. Dein Verlauf bleibt zugänglich.",
"course.examUnavailable": "Für den A1-Test fehlt noch ein vollständiger Bestand in dieser Erklärungssprache. Bereits begonnene Tests behalten ihre Aufgaben.",
"course.taskLanguage": "Sprache dieser Aufgabe: {language}",
"api.courseVariantUnavailable": "Für diese Erklärungssprache ist hier noch kein geprüfter Aufgabenbestand verfügbar."
}
+411 -2
View File
@@ -1,4 +1,413 @@
{
"appName": "Speech Learning",
"targetLevel": "A1 English"
"app.name": "Speech Learning",
"app.level": "A1 language learning",
"nav.today": "Today",
"nav.practice": "Pronunciation",
"nav.course": "A1 course",
"nav.conversation": "Conversation",
"nav.progress": "Progress",
"nav.admin": "Administration",
"nav.debug": "Debug",
"nav.label": "Navigation",
"auth.email": "Email",
"auth.password": "Password",
"auth.login": "Log in",
"auth.register": "Create account",
"auth.register.submit": "Register",
"auth.back": "Back to login",
"auth.logout": "Log out",
"auth.loading": "Loading account",
"auth.wait": "Please wait a moment.",
"auth.loadError": "Unable to load account.",
"auth.loginError": "Login failed",
"auth.registerError": "Registration failed",
"auth.busy": "Please wait…",
"auth.denied": "No access to administration.",
"common.retry": "Try again",
"language.label": "Interface language",
"language.saveError": "Unable to save the language.",
"language.instructions": "Preferred explanation language: {language}.",
"language.de-DE": "German",
"language.en-US": "English",
"language.registerInfo": "The English course currently uses German task instructions and explanations.",
"dashboard.error": "Unable to load dashboard",
"dashboard.loading": "Loading dashboard…",
"dashboard.title": "A1 pronunciation practice",
"dashboard.next": "Next exercise",
"dashboard.dailyGoal": "Daily goal",
"dashboard.average": "Average",
"dashboard.attempts": "Attempts",
"dashboard.minutes": "{count} min",
"progress.error": "Unable to load progress",
"progress.loading": "Loading progress…",
"progress.overview": "Learning overview",
"progress.average": "Historical average",
"progress.recent": "Recent attempts",
"language.bank": "Choose the explanation language for new course exercises in the A1 course.",
"profile.title": "Pronunciation profile",
"profile.yours": "Your pronunciation profile · {language}",
"profile.error": "Pronunciation profile unavailable",
"profile.loading": "Loading pronunciation profile…",
"profile.state.limited": "Limited evidence – check again",
"profile.state.observed": "Results still vary",
"profile.state.needs_practice": "Repeated difficulty",
"profile.state.improved": "Improved",
"profile.state.stable": "Stable with review",
"profile.trend.insufficient": "Not enough evidence of a trend",
"profile.trend.improving": "Improving",
"profile.trend.declining": "More difficult recently",
"profile.trend.steady": "Similar recent results",
"profile.none": "No confirmed measurements in this area yet.",
"profile.omission": "{count}% weighted omission rate",
"profile.observations.one": "{count} independent observation",
"profile.observations.other": "{count} independent observations",
"profile.contexts.one": "{count} word context",
"profile.contexts.other": "{count} word contexts",
"profile.tasks.one": "{count} task",
"profile.tasks.other": "{count} tasks",
"profile.last": "{trend}. Last recorded: {date}.",
"profile.examples": "Example words: {words}",
"profile.due": "Review due: {date}",
"profile.next": "Next review: {date}",
"profile.intro": "Actual Azure measurements from sentence repetition in pronunciation practice and the course are considered together. Recent results carry more weight; a single outlier does not establish a pronunciation difficulty.",
"profile.evidence": "{recordings} recordings considered within {days} days. Repeating the same task on the same day counts as one observation per word or sound.",
"profile.history": "{count} older attempts remain in your history. Their measurement source is unverified, so they do not determine this profile.",
"profile.start": "Your new pronunciation profile needs confirmed measurements. Repeat a sentence in pronunciation practice to get started.",
"profile.sounds": "Sounds across different words",
"profile.words": "Words",
"profile.completeness": "Completeness – omitted words",
"profile.less": "Show less",
"profile.all": "Show all observations",
"profile.limits": "These states are learning aids, not certification. Word accuracy and sound scores are not statistical probabilities.",
"ui.job_saved": "Job saved",
"ui.preparing": "Preparing",
"ui.analysing_learning_progress": "Analysing learning progress",
"ui.planning_an_exercise": "Planning an exercise",
"ui.creating_and_reviewing_an_exercise": "Creating and reviewing an exercise",
"ui.evaluating_your_answer": "Evaluating your answer",
"ui.creating_and_reviewing_twelve_test_questions": "Creating and reviewing twelve test questions",
"ui.unable_to_load_the_course": "Unable to load the course.",
"ui.unable_to_complete_the_job": "Unable to complete the job.",
"ui.back_to_the_adaptive_course": "Back to the adaptive course",
"ui.loading_a1_course": "Loading A1 course…",
"ui.reload": "Reload",
"ui.adaptive_language_course_a1": "Adaptive language course · A1",
"ui.your_a1_course": "Your A1 course",
"ui.seven_modules_six_learning_areas_and_new_exercises_suited_to": "Seven modules, six learning areas and new exercises suited to your progress.",
"ui.learning_language": "Learning language",
"ui.course_not_yet_available": " – Course not yet available",
"ui.a_reviewed_a1_course_pack_is_not_yet_available_for": "A reviewed A1 course pack is not yet available for this learning language. Your previous progress remains saved.",
"ui.your_learning_progress": "Your learning progress",
"ui.exercises_are_selected_using_your_saved_evaluations_new_exercises_come": "Exercises are selected using your saved evaluations. New exercises come first, followed by practice and reviews where needed. Ungraded answers do not count as graded learning evidence.",
"ui.no_ai_learning_analysis_yet_the_teacher_agent_creates_it": "No AI learning analysis yet. The teacher agent creates it from your saved answers.",
"ui.the_learning_analysis_is_being_updated_after_your_latest_answer": "The learning analysis is being updated after your latest answer.",
"ui.request_learning_analysis_again": "Request learning analysis again",
"ui.ai_assessment_based_on_saved_learning_evidence_all_modules_remain": "AI assessment based on saved learning evidence. All modules remain accessible.",
"ui.module": "Module",
"ui.recommended": " · Recommended",
"ui.learning_objective_achieved_according_to_ai_and_evidence_across_learning": "Learning objective achieved according to AI and evidence across learning areas",
"ui.continue_learning": "Continue learning",
"ui.more_practice": "More practice:",
"ui.learning_area": "Learning area",
"ui.ai_recommendation": "AI recommendation",
"ui.preparing_exercise": "Preparing exercise…",
"ui.next_exercise": "Next exercise",
"ui.start_a_new_a1_test_12_questions": "Start a new A1 test · 12 questions",
"ui.you_can_keep_practising_the_number_of_generated_exercises_does": "You can keep practising. The number of generated exercises does not determine module completion.",
"ui.retry_job": "Retry job",
"ui.no_graded_learning_evidence_yet": "No graded learning evidence yet",
"ui.a1_test": "A1 test",
"ui.test_completed": "Test completed",
"ui.submitted_evaluation_pending_an_overall_score_appears_once_all_open": "Submitted – evaluation pending. An overall score appears once all open answers have been evaluated.",
"ui.value_of_12_answers_saved_feedback_appears_at_the_end": "{value0} of 12 answers saved. Feedback appears at the end.",
"ui.evaluate_pending_answers": "Evaluate pending answers",
"ui.ai_evaluation_is_currently_unavailable_all_answers_remain_saved": "AI evaluation is currently unavailable. All answers remain saved.",
"ui.overall_result": "Overall result:",
"ui.request_ai_overall_assessment_again": "Request AI overall assessment again",
"ui.internal_a1_learning_assessment": "Internal A1 learning assessment.",
"ui.saved_exercises": "Saved exercises",
"ui.your_exercises": "Your exercises",
"ui.your_selected_exercises_are_saved_here": "Your selected exercises are saved here.",
"ui.load_more_exercises": "Load more exercises",
"ui.a1_test_2": "A1 test ·",
"ui.result": "Result",
"ui.resume": "Resume",
"ui.current_course_exercise": "Current course exercise",
"ui.request_evaluation": "Request evaluation",
"ui.request_evaluation_again": "Request evaluation again",
"ui.ai_evaluation_is_currently_unavailable_you_can_compare_your_answer": "AI evaluation is currently unavailable. You can compare your answer with the example without a grade.",
"ui.your_answer_remains_saved_even_if_you_leave_this_page": "Your answer remains saved even if you leave this page.",
"ui.choose_a_module_and_request_your_next_exercise": "Choose a module and request your next exercise.",
"ui.open_the_original_fixed_course": "Open the original fixed course",
"ui.unable_to_play_audio": "Unable to play audio.",
"ui.audio_unavailable": "Audio unavailable.",
"ui.unable_to_save_your_answer": "Unable to save your answer.",
"ui.from_the_reviewed_exercise_bank": "From the reviewed exercise bank",
"ui.created_with_ai": "Created with AI",
"ui.created_with_flowise": "Created with Flowise",
"ui.reviewed_fallback_exercise": "Reviewed fallback exercise",
"ui.review": " · Review",
"ui.ai_evaluates_content_and_language_the_azure_pronunciation_score_is": "AI evaluates content and language. The Azure pronunciation score is shown separately.",
"ui.listen": "Listen",
"ui.answer_options": "Answer options",
"ui.your_answer": "Your answer",
"ui.up_to_30_seconds_you_can_listen_to_your_recording": "Up to 30 seconds. You can listen to your recording before submitting it.",
"ui.processing_answer": "Processing answer…",
"ui.save_test_answer": "Save test answer",
"ui.check_answer": "Check answer",
"ui.demo_measurement_does_not_count_as_learning_evidence": "Demo measurement: does not count as learning evidence.",
"ui.test_answer_saved_feedback_appears_once_all_twelve_answers_have": "Test answer saved. Feedback appears once all twelve answers have been evaluated.",
"ui.answer_saved_the_teacher_agent_is_evaluating_it": "Answer saved. The teacher agent is evaluating it.",
"ui.answer_saved_without_a_grade_you_can_request_an_ai": "Answer saved without a grade. You can request an AI evaluation later.",
"ui.evaluation_is_still_pending_you_can_request_it_again": "Evaluation is still pending. You can request it again.",
"ui.content_and_language": "Content and language: ",
"ui.correct": "Correct",
"ui.partially_correct": "Partially correct",
"ui.keep_practising": "Keep practising",
"ui.recognised_text": "Recognised text:",
"ui.pronunciation": "Pronunciation:",
"ui.for_self_comparison_without_grading": "For self-comparison, without grading:",
"ui.example": "Example:",
"ui.listening_transcript": "Listening transcript:",
"ui.unable_to_play_the_sentence_please_try_again": "Unable to play the sentence. Please try again.",
"ui.the_agent_generated_the_same_sentence_again_please_try_once": "The agent generated the same sentence again. Please try once more.",
"ui.unable_to_load_exercise": "Unable to load exercise",
"ui.evaluation_failed": "Evaluation failed",
"ui.loading_exercise": "Loading exercise…",
"ui.loading_new_exercise": "Loading new exercise…",
"ui.different_exercise": "Different exercise",
"ui.why_this_exercise": "Why this exercise:",
"ui.loading_sentence": "Loading sentence…",
"ui.listen_to_sentence": "Listen to sentence",
"ui.listen_slowly": "Listen slowly",
"ui.listen_to_these_practice_words": "Listen to these practice words:",
"ui.loading_word": "Loading word…",
"ui.practise_value_slowly": "Practise {value0} slowly",
"ui.evaluating": "Evaluating…",
"ui.record_again": "Record again",
"ui.record": "Record",
"ui.evaluate": "Evaluate",
"ui.recording_not_yet_submitted_listen_record_again_or_request_evaluation": "Recording not yet submitted. Listen, record again or request evaluation.",
"ui.listen_to_your_recording": "Listen to your recording",
"ui.evaluating_pronunciation": "Evaluating pronunciation…",
"ui.evaluation": "Evaluation",
"ui.overall": "Overall",
"ui.accuracy": "Accuracy",
"ui.fluency": "Fluency",
"ui.completeness": "Completeness",
"ui.teacher_feedback": "Teacher feedback",
"ui.microphone_unavailable": "Microphone unavailable",
"ui.no_recording_detected_please_try_again": "No recording detected. Please try again.",
"ui.stop": "Stop",
"ui.starting_microphone": "Starting microphone…",
"ui.audio_monitoring": "Audio monitoring",
"ui.monitor_your_own_voice": "Monitor your own voice",
"ui.monitoring_volume": "Monitoring volume:",
"ui.monitoring_volume_2": "Monitoring volume",
"ui.use_headphones_while_recording_you_may_hear_your_voice_with": "Use headphones while recording. You may hear your voice with a slight delay.",
"ui.sound_analysis": "Sound analysis",
"ui.no_sound_scores_are_available_for_this_recording": "No sound scores are available for this recording.",
"ui.azure_scores_each_sound_from_0_to_100_scores_below": "Azure scores each sound from 0 to 100. Scores below 75 indicate practice needs in this display.",
"ui.unable_to_start_conversation": "Unable to start conversation",
"ui.reply_failed": "Reply failed",
"ui.a1_role_play": "A1 role play",
"ui.start": "Start",
"ui.start_a_short_a1_conversation": "Start a short A1 conversation.",
"ui.teacher": "Teacher",
"ui.you": "You",
"ui.send": "Send",
"ui.play_audio": "Play audio",
"ui.no_attempts_yet": "No attempts yet",
"ui.unable_to_load_metrics": "Unable to load metrics.",
"ui.unable_to_load_users": "Unable to load users.",
"ui.administration": "Administration",
"ui.an_overview_of_users_and_learning_activity": "An overview of users and learning activity.",
"ui.product_metrics": "Product metrics",
"ui.total_users": "Total users",
"ui.active_in_7_days": "Active in 7 days",
"ui.speaking_attempts": "Speaking attempts",
"ui.ai_pronunciation_exercises": "AI pronunciation exercises",
"ui.average_score": "Average score",
"ui.users": "Users",
"ui.accounts_and_learning_activity_search_by_email_address": "Accounts and learning activity. Search by email address.",
"ui.search_email": "Search email",
"ui.search": "Search",
"ui.role": "Role",
"ui.registered": "Registered",
"ui.latest_attempt": "Latest attempt",
"ui.admin": "Admin",
"ui.learners": "Learners",
"ui.no_matching_users_found": "No matching users found.",
"ui.loading_users": "Loading users…",
"ui.back": "Back",
"ui.next": "Next",
"ui.product_operations": "Product operations",
"ui.sales_and_access": "Sales and access",
"ui.plans_payments_and_access_to_purchased_content_are_not_connected": "Plans, payments and access to purchased content are not connected yet. Revenue and subscription figures are therefore not shown.",
"ui.next_product_catalogue": "Next: product catalogue",
"ui.then_payment_provider_and_webhooks": "Then: payment provider and webhooks",
"ui.after_that_access_rights_per_purchase": "After that: access rights per purchase",
"ui.unable_to_load_call_details": "Unable to load call details.",
"ui.ai_administration_unavailable": "AI administration unavailable",
"ui.ai_administration": "AI administration",
"ui.ai_settings_and_usage": "AI settings and usage",
"ui.direct_model_calls_from_go_amounts_are_usd_estimates_the": "Direct model calls from Go. Amounts are USD estimates; the provider invoice is authoritative. Daily and monthly limits use UTC.",
"ui.loading_ai_settings": "Loading AI settings…",
"ui.budget": "Budget",
"ui.configured": "configured",
"ui.not_configured": "not configured",
"ui.at_least_80_of_a_budget_is_committed": "At least 80% of a budget is committed.",
"ui.ai_calls_are_blocked_until_a_positive_monthly_budget_is": "AI calls are blocked until a positive monthly budget is configured.",
"ui.monthly_limit_in_usd": "Monthly limit in USD",
"ui.daily_limit_in_usd_0_no_daily_limit": "Daily limit in USD · 0 = no daily limit",
"ui.budget_saved": "Budget saved.",
"ui.save_budget": "Save budget",
"ui.a_conservative_upper_limit_is_reserved_before_each_call_unknown": "A conservative upper limit is reserved before each call. Unknown usage stays committed until reconciled with the provider invoice. A new exercise may require several calls.",
"ui.model_profiles": "Model profiles",
"ui.action": "Action",
"ui.provider": "Provider",
"ui.model_id": "Model ID",
"ui.maximum_output_tokens": "Maximum output tokens",
"ui.context_budget_input_and_output": "Context budget · input and output",
"ui.temperature_empty_do_not_send": "Temperature · empty = do not send",
"ui.reasoning_effort_only_when_supported": "Reasoning effort · only when supported",
"ui.do_not_send": "Do not send",
"ui.timeout_in_seconds": "Timeout in seconds",
"ui.value_models_loaded_connection_successful_a_test_run_incurs_additional": "{value0} models loaded. Connection successful. A test run incurs additional recorded costs.",
"ui.load_model_list_check_connection": "Load model list / check connection",
"ui.check_model_names_and_supported_parameters_with_the_provider_the": "Check model names and supported parameters with the provider. The context budget is conservatively limited before sending. Configure a sufficiently large profile for twelve-question tests.",
"ui.prices_in_usd_per_million_tokens": "Prices in USD per million tokens",
"ui.input": "Input",
"ui.cached_input": "Cached input",
"ui.output": "Output",
"ui.prices_checked_against_current_provider_pricing": "Prices checked against current provider pricing",
"ui.json_schema_mode_only_for_supported_mistral_models": "JSON schema mode · only for supported Mistral models",
"ui.enable_profile_for_new_ai_jobs": "Enable profile for new AI jobs",
"ui.new_profile_version_saved_test_with_correct_and_incorrect_answers": "New profile version saved. Test with correct and incorrect answers before enabling it.",
"ui.save_model_profile": "Save model profile",
"ui.system_prompt_and_output_schema": "System prompt and output schema",
"ui.no_separate_schema_contract_validation_in_go": "No separate schema; contract validation in Go.",
"ui.check_evaluation_quality_2_paid_test_cases": "Check evaluation quality · 2 paid test cases",
"ui.check_writing_evaluation_2_paid_test_cases": "Check writing evaluation · 2 paid test cases",
"ui.test_saved_profile_incurs_api_costs": "Test saved profile · incurs API costs",
"ui.paste_only_the_content_of_input_here_this_call_does": "Paste only the content of input here. This call does not change course progress and is recorded even for a disabled profile. Save profile changes first.",
"ui.ai_test_input": "AI test input",
"ui.run_paid_test": "Run paid test",
"ui.ai_usage": "AI usage",
"ui.from": "From",
"ui.to": "To",
"ui.model": "Model",
"ui.user_id": "User ID",
"ui.all": "All",
"ui.refresh_usage": "Refresh usage",
"ui.ai_call_details": "AI call details",
"ui.call_details": "Call details",
"ui.close": "Close",
"ui.loading_call_details": "Loading call details…",
"ui.reconcile_unknown_usage_with_the_provider_invoice_the_record_and": "Reconcile unknown usage with the provider invoice. The record and reason are retained.",
"ui.actual_cost_in_usd": "Actual cost in USD",
"ui.reason": "Reason",
"ui.save_reconciliation": "Save reconciliation",
"ui.time_user": "Time / user",
"ui.model_action": "Model / action",
"ui.status": "Status",
"ui.tokens_in_out": "Tokens in / out",
"ui.cost": "Cost",
"ui.details": "Details",
"ui.unknown": "Unknown",
"ui.show": "Show",
"ui.test": " · Test",
"ui.system_diagnostics": "System diagnostics",
"ui.check_again": "Check again",
"ui.error": "Error",
"ui.no_http_status": "No HTTP status",
"ui.request_id_value": "Request ID {value0}",
"ui.database": "Database",
"ui.ai_connection": "AI connection",
"ui.azure_speech": "Azure Speech",
"ui.runtime": "Runtime",
"ui.configuration": "Configuration",
"ui.problem": "Problem",
"ui.not_checked_yet": "Not checked yet.",
"ui.no_data": "No data.",
"ui.unknown_error": "Unknown error",
"ui.check_value": "Check {value0}",
"ui.vocabulary": "Vocabulary",
"ui.listening": "Listening",
"ui.reading": "Reading",
"ui.grammar": "Grammar",
"ui.writing": "Writing",
"ui.speaking": "Speaking",
"ui.unable_to_load_course": "Unable to load course.",
"ui.an_exercise_from_the_reviewed_bank_is_ready": "An exercise from the reviewed bank is ready.",
"ui.an_additional_ai_exercise_is_ready": "An additional AI exercise is ready.",
"ui.a_fixed_course_exercise_is_ready_for_review": "A fixed course exercise is ready for review.",
"ui.unable_to_load_additional_exercise": "Unable to load additional exercise.",
"ui.unable_to_play_audio_please_try_again": "Unable to play audio. Please try again.",
"ui.unable_to_evaluate_your_answer": "Unable to evaluate your answer.",
"ui.unable_to_evaluate_pronunciation": "Unable to evaluate pronunciation.",
"ui.no_course_module_is_available_for_your_current_language_and": "No course module is available for your current language and level yet.",
"ui.loading_a1_course_2": "Loading A1 course…",
"ui.guided_a1_course": "Guided A1 course",
"ui.module_progress": "Module progress",
"ui.additional_practice": "Additional practice",
"ui.review_vocabulary_and_grammar_your_progress_in_the_fixed_course": "Review vocabulary and grammar. Your progress in the fixed course is tracked separately.",
"ui.new_additional_exercise": "New additional exercise",
"ui.loading_additional_exercises": "Loading additional exercises…",
"ui.preparing_a_suitable_exercise_this_can_take_up_to_25": "Preparing a suitable exercise. This can take up to 25 seconds.",
"ui.unable_to_load_additional_exercise_2": "Unable to load additional exercise:",
"ui.course_exercises": "Course exercises",
"ui.your_additional_exercises": "Your additional exercises",
"ui.exercise": "Exercise",
"ui.from_the_reviewed_exercise_bank_2": "From the reviewed exercise bank · ",
"ui.created_with_ai_2": "Created with AI · ",
"ui.created_with_flowise_2": "Created with Flowise · ",
"ui.fixed_course_exercise_for_review": "Fixed course exercise for review · ",
"ui.additional_practice_2": "Additional practice · ",
"ui.listen_first_the_spoken_text_appears_after_your_answer": "Listen first. The spoken text appears after your answer.",
"ui.checking": "Checking…",
"ui.you_can_listen_to_your_recording_or_record_again_before": "You can listen to your recording or record again before evaluation.",
"ui.correct_2": "Correct!",
"ui.not_correct_yet": "Not correct yet.",
"ui.example_answer": "Example answer:",
"ui.listening_transcript_2": "Listening transcript:",
"action.analyze_course_progress": "Learning analysis",
"action.plan_course_task": "Exercise planning",
"action.author_course_task": "Exercise author",
"action.review_course_task": "Exercise review",
"action.author_course_exam": "Test author · 12 questions",
"action.review_course_exam": "Test review · 12 questions",
"action.evaluate_course_attempt": "Answer evaluation",
"action.summarize_course_exam": "Test summary",
"action.next_exercise": "Pronunciation generation",
"course.modulesLabel": "A1 modules",
"course.inventory": "Reviewed exercise bank: {total} exercises · {unseen} still new. Reviews are available afterwards.",
"course.progress": "{tasks} exercises · {attempts} answers · average {score}/100",
"admin.matches": "{count} matches",
"admin.page": "Page {page} of {total}",
"ai.access": "API access: DeepSeek {deepseek} · Mistral {mistral}",
"ai.committed": "Monthly committed: {month} · daily committed: {day} · open reservations: {open}",
"ai.version": "Version {version}. Changes apply to new jobs; running jobs keep their settings.",
"ai.tokens": "{calls} calls · input {input} · output {output} tokens",
"ai.costs": "Estimated cost {cost} · open reservations {reserved} · unknown usage for {unknown} calls",
"ai.profileVersion": " · profile v{version}",
"ai.attempt": "{ms} ms · attempt {attempt}",
"ai.reserved": "Reserved {cost}",
"ai.range": "{from}–{to} of {total}",
"legacy.completed": "{done} of {total} exercises attempted",
"legacy.correct": "{count} exercises answered correctly. “Attempted” does not mean “A1 passed”.",
"legacy.areaProgress": "{done}/{total} attempted · {correct} objectives achieved",
"recorder.percent": "{volume} percent",
"recorder.volume": "Monitoring volume: {volume}%",
"phoneme.tooltip": "{word}: sound /{phoneme}/, {score} out of 100 points",
"language.content": "Learning content and saved feedback keep their original language.",
"conversation.answer": "Your conversation reply",
"conversation.audioError": "Unable to play audio.",
"course.instructionLanguage": "Exercise explanation language",
"course.instructionScope": "Applies to new exercises and AI explanations. Assigned exercises, solutions and evaluations retain their original language.",
"course.englishPilot": "English pilot: twelve exercises in “Greetings & introductions”, two per learning area. The other modules and the A1 test currently require German explanations.",
"course.noVariant": "This area has no reviewed exercises in the selected explanation language yet. Choose the introductions module or German explanations. Your history remains accessible.",
"course.examUnavailable": "A complete exercise bank for the A1 test is not available in this explanation language yet. Existing tests keep their assigned questions.",
"course.taskLanguage": "This exercise uses: {language}",
"api.courseVariantUnavailable": "No reviewed exercise bank is available here for this explanation language yet."
}
+22
View File
@@ -0,0 +1,22 @@
import { useI18n } from './I18n';
import type { CourseSkill } from '../api/adaptive';
export function useCourseSkillNames(): Record<CourseSkill, string> {
const { t } = useI18n();
return {grammar:t('ui.grammar'),vocabulary:t('ui.vocabulary'),listening:t('ui.listening'),reading:t('ui.reading'),speaking:t('ui.speaking'),writing:t('ui.writing')};
}
export function useAIActionNames(): Record<string, string> {
const { t } = useI18n();
return {
analyze_course_progress:t('action.analyze_course_progress'),
plan_course_task:t('action.plan_course_task'),
author_course_task:t('action.author_course_task'),
review_course_task:t('action.review_course_task'),
author_course_exam:t('action.author_course_exam'),
review_course_exam:t('action.review_course_exam'),
evaluate_course_attempt:t('action.evaluate_course_attempt'),
summarize_course_exam:t('action.summarize_course_exam'),
next_exercise:t('action.next_exercise'),
};
}
+20
View File
@@ -0,0 +1,20 @@
import { useState } from 'react';
import { ApiError } from '../api/client';
import { useI18n, type MessageKey } from './I18n';
type Message = string | { key: MessageKey; parameters?: Record<string, string | number> };
// Store local notices as keys so a language switch updates them immediately.
// API errors remain original strings; saved feedback is never translated here.
export function useLocalizedMessage() {
const { t } = useI18n();
const [message, setMessage] = useState<Message>('');
return [typeof message === 'string' ? message : t(message.key, message.parameters), setMessage] as const;
}
export function errorMessage(error: unknown, fallback: MessageKey): Message {
if (error instanceof ApiError && typeof error.payload === 'object' && error.payload !== null && 'code' in error.payload && error.payload.code === 'course_variant_unavailable') {
return { key: 'api.courseVariantUnavailable' };
}
return error instanceof Error ? error.message : { key: fallback };
}
+2 -1
View File
@@ -2,9 +2,10 @@ import React from 'react';
import ReactDOM from 'react-dom/client';
import { App } from './app/App';
import './app/styles.css';
import { I18nProvider } from './i18n/I18n';
ReactDOM.createRoot(document.getElementById('root')!).render(
<React.StrictMode>
<App />
<I18nProvider><App /></I18nProvider>
</React.StrictMode>
);
+37 -35
View File
@@ -1,26 +1,28 @@
import { useLocalizedMessage } from '../i18n/useLocalizedMessage';
import { useI18n } from '../i18n/I18n';
import { AIAdmin } from '../components/AIAdmin';
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 { t, language } = useI18n();
function formatDate(value?: string) {
return value ? new Date(value).toLocaleDateString(language) : t('ui.no_attempts_yet');
}
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('');
const [overviewError, setOverviewError] = useLocalizedMessage();
const [usersError, setUsersError] = useLocalizedMessage();
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.'); });
.catch((error) => { if (!cancelled) setOverviewError(error instanceof Error ? error.message : { key: 'ui.unable_to_load_metrics' }); });
return () => { cancelled = true; };
}, []);
@@ -28,7 +30,7 @@ export function AdminPage() {
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.'); });
.catch((error) => { if (!cancelled) setUsersError(error instanceof Error ? error.message : { key: 'ui.unable_to_load_users' }); });
return () => { cancelled = true; };
}, [search, page]);
@@ -42,46 +44,46 @@ export function AdminPage() {
<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>
<p className="eyebrow">{t('ui.administration')}</p>
<h1>{t('nav.admin')}</h1>
<p className="muted">{t('ui.an_overview_of_users_and_learning_activity')}</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>KI-Ausspracheü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 className="admin-metrics" aria-label={t('ui.product_metrics')}>
<div className="panel metric"><span>{t('ui.total_users')}</span><strong>{overview?.users_total ?? '–'}</strong></div>
<div className="panel metric"><span>{t('ui.active_in_7_days')}</span><strong>{overview?.users_active_7_days ?? '–'}</strong></div>
<div className="panel metric"><span>{t('ui.speaking_attempts')}</span><strong>{overview?.attempts_total ?? '–'}</strong></div>
<div className="panel metric"><span>{t('ui.ai_pronunciation_exercises')}</span><strong>{overview?.exercises_generated ?? '–'}</strong></div>
<div className="panel metric"><span>{t('ui.average_score')}</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>
<h2>{t('ui.users')}</h2>
<p className="muted">{t('ui.accounts_and_learning_activity_search_by_email_address')}</p>
</div>
<span className="admin-count">{users?.total ?? '–'} Treffer</span>
<span className="admin-count">{t('admin.matches', { count: users?.total.toLocaleString(language) ?? '–' })}</span>
</div>
<form className="admin-search" onSubmit={submitSearch}>
<label htmlFor="admin-user-search">E-Mail suchen</label>
<label htmlFor="admin-user-search">{t('ui.search_email')}</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>
<button className="primary-button" type="submit">{t('ui.search')}</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>
<thead><tr><th>{t('ui.users')}</th><th>{t('ui.role')}</th><th>{t('ui.registered')}</th><th>{t('dashboard.attempts')}</th><th>{t('ui.average_score')}</th><th>{t('ui.latest_attempt')}</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><span className={user.role === 'admin' ? 'admin-role admin-role-staff' : 'admin-role'}>{user.role === 'admin' ? t('ui.admin') : t('ui.learners')}</span></td>
<td>{formatDate(user.created_at)}</td>
<td>{user.attempts}</td>
<td>{user.attempts > 0 ? Math.round(user.average_score) : '–'}</td>
@@ -90,27 +92,27 @@ export function AdminPage() {
))}
</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>}
{users && users.users.length === 0 && <p className="muted admin-empty">{t('ui.no_matching_users_found')}</p>}
{!users && !usersError && <p className="muted admin-empty">{t('ui.loading_users')}</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>
<button className="ghost-button" disabled={page <= 1} onClick={() => setPage(page - 1)}>{t('ui.back')}</button>
<span>{t('admin.page', { page, total: Math.max(1, Math.ceil((users?.total ?? 0) / 25)) })}</span>
<button className="ghost-button" disabled={!users || page * 25 >= users.total} onClick={() => setPage(page + 1)}>{t('ui.next')}</button>
</div>
</section>
<AIAdmin />
<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>
<p className="eyebrow">{t('ui.product_operations')}</p>
<h2>{t('ui.sales_and_access')}</h2>
<p>{t('ui.plans_payments_and_access_to_purchased_content_are_not_connected')}</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>
<span>{t('ui.next_product_catalogue')}</span>
<span>{t('ui.then_payment_provider_and_webhooks')}</span>
<span>{t('ui.after_that_access_rights_per_purchase')}</span>
</div>
</section>
</div>
+17 -14
View File
@@ -1,13 +1,17 @@
import { useLocalizedMessage } from '../i18n/useLocalizedMessage';
import { useI18n } from '../i18n/I18n';
import { Play, Send } from 'lucide-react';
import { FormEvent, useState } from 'react';
import { sendConversationTurn, startConversation, type ConversationResponse } from '../api/conversation';
export function ConversationPage() {
const { t } = useI18n();
const [sessionId, setSessionId] = useState('');
const [targetLanguage, setTargetLanguage] = useState<string | undefined>();
const [input, setInput] = useState('');
const [turns, setTurns] = useState<Array<{ speaker: string; text: string }>>([]);
const [lastAudio, setLastAudio] = useState<ConversationResponse['audio']>(null);
const [error, setError] = useState('');
const [error, setError] = useLocalizedMessage();
const [loading, setLoading] = useState(false);
async function start() {
@@ -16,10 +20,11 @@ export function ConversationPage() {
try {
const response = await startConversation();
setSessionId(response.session?.id ?? '');
setTargetLanguage(response.session?.target_language);
setLastAudio(response.audio);
setTurns([{ speaker: 'teacher', text: response.teacher.tts_text || response.teacher.target_text }]);
} catch (err) {
setError(err instanceof Error ? err.message : 'Dialog konnte nicht gestartet werden');
setError(err instanceof Error ? err.message : { key: 'ui.unable_to_start_conversation' });
} finally {
setLoading(false);
}
@@ -37,7 +42,7 @@ export function ConversationPage() {
setLastAudio(response.audio);
setTurns((current) => [...current, { speaker: 'teacher', text: response.teacher.tts_text || response.teacher.target_text }]);
} catch (err) {
setError(err instanceof Error ? err.message : 'Antwort fehlgeschlagen');
setError(err instanceof Error ? err.message : { key: 'ui.reply_failed' });
} finally {
setLoading(false);
}
@@ -53,35 +58,33 @@ export function ConversationPage() {
<div className="view-stack">
<header className="view-header">
<div>
<p className="eyebrow">A1 Rollenspiel</p>
<h1>Dialog</h1>
<p className="eyebrow">{t('ui.a1_role_play')}</p>
<h1>{t('nav.conversation')}</h1>
</div>
<button className="primary-button" onClick={start} disabled={loading}>
<Play size={18} /> Start
</button>
<Play size={18} /> {t('ui.start')} </button>
</header>
{error && <p className="form-error">{error}</p>}
<section className="panel dialogue-panel">
{turns.length === 0 ? (
<p className="muted">Starte einen kurzen A1-Dialog.</p>
<p className="muted">{t('ui.start_a_short_a1_conversation')}</p>
) : (
turns.map((turn, index) => (
<div className={`bubble ${turn.speaker}`} key={`${turn.speaker}-${index}`}>
<span>{turn.speaker === 'teacher' ? 'Teacher' : 'You'}</span>
<p>{turn.text}</p>
<span>{turn.speaker === 'teacher' ? t('ui.teacher') : t('ui.you')}</span>
<p lang={targetLanguage} dir="auto">{turn.text}</p>
</div>
))
)}
</section>
<form className="chat-form" onSubmit={submit}>
<input value={input} onChange={(event) => setInput(event.target.value)} placeholder="My name is ..." disabled={!sessionId || loading} />
<input value={input} onChange={(event) => setInput(event.target.value)} aria-label={t('conversation.answer')} placeholder="My name is ..." lang={targetLanguage} dir="auto" disabled={!sessionId || loading} />
<button className="primary-button" disabled={!sessionId || loading || !input.trim()} type="submit">
<Send size={18} /> Senden
</button>
<button className="ghost-button icon-only" disabled={!lastAudio} onClick={playAudio} type="button" aria-label="Audio abspielen" title="Audio abspielen">
<Send size={18} /> {t('ui.send')} </button>
<button className="ghost-button icon-only" disabled={!lastAudio} onClick={playAudio} type="button" aria-label={t('ui.play_audio')} title={t('ui.play_audio')}>
<Play size={18} />
</button>
</form>
+60 -31
View File
@@ -1,16 +1,21 @@
import { errorMessage, useLocalizedMessage } from '../i18n/useLocalizedMessage';
import { useCourseSkillNames } from '../i18n/labels';
import { useI18n } from '../i18n/I18n';
import { useEffect, useRef, useState } from 'react';
import { request } from '../api/client';
import {
courseSkills, courseSkillNames, courseRequestID, getCourseCatalog, getCourseHistory, getAdaptiveTask,
courseSkills, courseRequestID, getCourseCatalog, getCourseHistory, getAdaptiveTask,
createCourseTask, getCourseJob, retryCourseJob, getCourseAttempt, retryCourseAttempt, createCourseExam, getCourseExam,
type CourseCatalog, type CourseJob, type AdaptiveTask, type AdaptiveAttempt, type AdaptiveExam
} from '../api/adaptive';
import { AdaptiveExercise } from '../components/AdaptiveExercise';
import { LegacyCoursePage } from './LegacyCoursePage';
const stageNames: Record<string, string> = { queued: 'Auftrag gespeichert', starting: 'Vorbereitung', analyzing: 'Lernstand wird analysiert', planning: 'Lernauftrag wird erstellt', generating_and_reviewing: 'Aufgabe wird erstellt und fachlich geprüft', evaluating: 'Antwort wird bewertet', generating_and_reviewing_exam: 'Zwölf Testaufgaben werden erstellt und geprüft' };
type SavedView = { module: string; task?: string; job?: string; exam?: string };
export function CoursePage() {
export function CoursePage({ onInstructionLanguageChange }: { onInstructionLanguageChange: (language: string) => Promise<void> }) {
const { t, language } = useI18n();
const courseSkillNames = useCourseSkillNames();
const stageNames: Record<string, string> = { queued: t('ui.job_saved'), starting: t('ui.preparing'), analyzing: t('ui.analysing_learning_progress'), planning: t('ui.planning_an_exercise'), generating_and_reviewing: t('ui.creating_and_reviewing_an_exercise'), evaluating: t('ui.evaluating_your_answer'), generating_and_reviewing_exam: t('ui.creating_and_reviewing_twelve_test_questions') };
const [catalog, setCatalog] = useState<CourseCatalog | null>(null);
const [moduleID, setModuleID] = useState('');
const [skill, setSkill] = useState('');
@@ -23,7 +28,7 @@ export function CoursePage() {
const [busy, setBusy] = useState(false);
const [recording, setRecording] = useState(false);
const [submitting, setSubmitting] = useState(false);
const [error, setError] = useState('');
const [error, setError] = useLocalizedMessage();
const [legacy, setLegacy] = useState(false);
const [restored, setRestored] = useState(false);
const [revision, setRevision] = useState(0);
@@ -34,7 +39,7 @@ export function CoursePage() {
const jobRunning = Boolean(job && (job.status === 'queued' || job.status === 'running'));
const locked = busy || recording || submitting || jobRunning;
const storeKey = catalog ? `speech_course_v2:${catalog.profile.id}` : '';
function showError(err: unknown) { if (active.current) setError(err instanceof Error ? err.message : 'Der Kurs konnte nicht geladen werden.'); }
function showError(err: unknown) { if (active.current) setError(errorMessage(err, 'ui.unable_to_load_the_course')); }
async function openTask(id: string) {
const result = await getAdaptiveTask(id);
if (!active.current) return;
@@ -87,7 +92,7 @@ export function CoursePage() {
if (current.kind === 'exam' && current.subject_id) { const result = await getCourseExam(current.subject_id); if (!valid) return; setExam(result); if (result.tasks[0]) { setTask(result.tasks[0]); setAttempt(null); } }
setJob(null); await refreshCatalog();
if (valid) requestAnimationFrame(() => exerciseRef.current?.scrollIntoView({ block: 'center', behavior: 'smooth' }));
} else if (current.status === 'failed') { setError(current.error ?? 'Der Auftrag konnte nicht abgeschlossen werden.'); }
} else if (current.status === 'failed') { setError(current.error ?? { key: 'ui.unable_to_complete_the_job' }); }
else { timer = window.setTimeout(poll, 1200); }
} catch (err) { if (valid) { showError(err); timer = window.setTimeout(poll, 4000); } }
}
@@ -138,6 +143,16 @@ export function CoursePage() {
try { await request('/me/preferences', { method: 'PATCH', body: JSON.stringify({ target_language: language, cefr_level: 'A1', daily_goal_minutes: catalog?.profile.daily_goal_minutes ?? 10 }) }); setTask(null); setAttempt(null); setJob(null); setExam(null); generationID.current = null; examRequestID.current = null; setRevision((n) => n + 1); }
catch (err) { showError(err); } finally { setBusy(false); }
}
async function changeInstructionLanguage(next: string) {
if (locked) return;
setBusy(true); setError('');
try {
await onInstructionLanguageChange(next);
generationID.current = null; examRequestID.current = null;
await refreshCatalog();
} catch (err) { showError(err); }
finally { setBusy(false); }
}
async function startExam() {
if (locked) return; setBusy(true); setError('');
try { examRequestID.current ??= courseRequestID(); const result = await createCourseExam(examRequestID.current); examRequestID.current = null; setExam(result.exam); setJob(result.job); setTask(null); setAttempt(null); }
@@ -154,44 +169,58 @@ export function CoursePage() {
try { if ((value.status === 'graded' || value.status === 'ungraded') && !value.exam_id) await openTask(value.task_id); await refreshCatalog(); if (exam) setExam(await getCourseExam(exam.id)); }
catch (err) { showError(err); }
}
if (legacy) return <><button type="button" className="ghost-button" onClick={() => setLegacy(false)}>Zurück zum adaptiven Kurs</button><LegacyCoursePage /></>;
if (!catalog) return <section className="panel"><p>{error || 'Lade A1-Kurs…'}</p>{error && <button type="button" onClick={() => setRevision((n) => n + 1)}>Erneut laden</button>}</section>;
if (legacy) return <><button type="button" className="ghost-button" onClick={() => setLegacy(false)}>{t('ui.back_to_the_adaptive_course')}</button><LegacyCoursePage /></>;
if (!catalog) return <section className="panel"><p>{error || t('ui.loading_a1_course')}</p>{error && <button type="button" onClick={() => setRevision((n) => n + 1)}>{t('ui.reload')}</button>}</section>;
const selected = catalog.modules.find((m) => m.id === moduleID);
const analysis = catalog.analysis?.modules.find((m) => m.module_id === moduleID);
const progress = catalog.progress.filter((p) => p.module_id === moduleID);
const inventory=(catalog.bank??[]).filter(p=>p.module_id===moduleID && (!skill||p.skill===skill));
const evaluating = attempt?.status === 'pending';
const noVariant = catalog.task_mode === 'bank' && inventory.reduce((sum, item) => sum + item.total, 0) === 0;
const instructionLanguage = catalog.instruction_language ?? 'de-DE';
const instructionName = (code: string) => code === 'de-DE' ? t('language.de-DE') : code === 'en-US' ? t('language.en-US') : code;
return <div className="view-stack">
<header className="view-header"><div><p className="eyebrow">Adaptiver Sprachkurs · A1</p><h1>Dein A1-Kurs</h1><p className="muted">Sieben Module, sechs Lernbereiche und neue Aufgaben passend zu deinem Lernstand.</p></div>
<label>Kurssprache<select disabled={locked} value={catalog.profile.target_language} onChange={(event) => void changeLanguage(event.target.value)}>{catalog.languages.map((l) => <option key={l.code} value={l.code}>{l.display_name}{catalog.enabled_languages.includes(l.code) ? '' : ' – Kurs noch nicht verfügbar'}</option>)}</select></label>
<header className="view-header"><div><p className="eyebrow">{t('ui.adaptive_language_course_a1')}</p><h1>{t('ui.your_a1_course')}</h1><p className="muted">{t('ui.seven_modules_six_learning_areas_and_new_exercises_suited_to')}</p></div>
<label>{t('ui.learning_language')}<select disabled={locked} value={catalog.profile.target_language} onChange={(event) => void changeLanguage(event.target.value)}>{catalog.languages.map((l) => <option key={l.code} value={l.code}>{l.display_name}{catalog.enabled_languages.includes(l.code) ? '' : t('ui.course_not_yet_available')}</option>)}</select></label>
</header>
{catalog.modules.length === 0 ? <section className="panel"><p>Für diese Zielsprache ist noch kein geprüftes A1-Sprachpaket freigeschaltet. Dein bisheriger Lernstand bleibt gespeichert.</p></section> : <>
<section className="panel course-analysis"><h2>Dein Lernstand</h2><p>{catalog.task_mode === 'bank' ? 'Die Auswahl nutzt deine gespeicherten Bewertungen. Noch neue Aufgaben haben Vorrang; bei Lernbedarf folgen passende Übungen und Wiederholungen. Unbenotete Antworten zählen nicht als bewerteter Lernnachweis.' : catalog.analysis?.summary ?? 'Noch keine KI-Lernanalyse vorhanden. Der Lehrer-Agent erstellt sie aus deinen gespeicherten Antworten.'}</p>
{catalog.analysis && catalog.analysis.facts_version < catalog.facts_version && <p className="muted" role="status">Die Lernanalyse wird nach deiner letzten Antwort aktualisiert.</p>}
{catalog.analysis_job?.status === 'failed' && <button type="button" onClick={() => void retryCourseJob(catalog.analysis_job!.id).then(refreshCatalog).catch(showError)}>Lernanalyse erneut anfordern</button>}
{catalog.analysis && <p className="muted">KI-Einschätzung auf Basis gespeicherter Lernnachweise. Alle Module bleiben frei zugänglich.</p>}
{catalog.task_mode === 'bank' && <section className="panel view-stack">
<label>{t('course.instructionLanguage')}<select disabled={locked} value={instructionLanguage} onChange={(event) => void changeInstructionLanguage(event.target.value)}>
{!(catalog.instruction_languages ?? ['de-DE']).includes(instructionLanguage) && <option value={instructionLanguage}>{instructionName(instructionLanguage)}</option>}
{(catalog.instruction_languages ?? ['de-DE']).map((code) => <option key={code} value={code}>{instructionName(code)}</option>)}
</select></label>
<p className="muted">{t('course.instructionScope')}</p>
{instructionLanguage === 'en-US' && <p>{t('course.englishPilot')}</p>}
{error && <p className="form-error" role="alert">{error}</p>}
</section>}
{catalog.modules.length === 0 ? <section className="panel"><p>{t('ui.a_reviewed_a1_course_pack_is_not_yet_available_for')}</p></section> : <>
<section className="panel course-analysis"><h2>{t('ui.your_learning_progress')}</h2><p>{catalog.task_mode === 'bank' ? t('ui.exercises_are_selected_using_your_saved_evaluations_new_exercises_come') : catalog.analysis?.summary ?? t('ui.no_ai_learning_analysis_yet_the_teacher_agent_creates_it')}</p>
{catalog.analysis && catalog.analysis.facts_version < catalog.facts_version && <p className="muted" role="status">{t('ui.the_learning_analysis_is_being_updated_after_your_latest_answer')}</p>}
{catalog.analysis_job?.status === 'failed' && <button type="button" onClick={() => void retryCourseJob(catalog.analysis_job!.id).then(refreshCatalog).catch(showError)}>{t('ui.request_learning_analysis_again')}</button>}
{catalog.analysis && <p className="muted">{t('ui.ai_assessment_based_on_saved_learning_evidence_all_modules_remain')}</p>}
</section>
<nav className="course-module-grid" aria-label="A1-Module">{catalog.modules.map((m) => <button type="button" key={m.id} disabled={locked} className={`panel course-module-card${moduleID === m.id ? ' selected' : ''}`} onClick={() => { setModuleID(m.id); setTask(null); setAttempt(null); setExam(null); setJob(null); setError(''); generationID.current = null; }}>
<span className="eyebrow">Modul {m.order}{catalog.analysis?.recommended_module_id === m.id ? ' · Empfohlen' : ''}</span><strong>{m.title}</strong><span className="muted">{catalog.analysis?.modules.some((a) => a.module_id === m.id && a.ready_for_completion) ? 'Lernziel laut KI und Bereichsnachweisen erreicht' : 'Weiterlernen'}</span>
<nav className="course-module-grid" aria-label={t('course.modulesLabel')}>{catalog.modules.map((m) => <button type="button" key={m.id} disabled={locked} className={`panel course-module-card${moduleID === m.id ? ' selected' : ''}`} onClick={() => { setModuleID(m.id); setTask(null); setAttempt(null); setExam(null); setJob(null); setError(''); generationID.current = null; }}>
<span className="eyebrow">{t('ui.module')} {m.order}{catalog.analysis?.recommended_module_id === m.id ? t('ui.recommended') : ''}</span><strong>{m.title}</strong><span className="muted">{catalog.analysis?.modules.some((a) => a.module_id === m.id && a.ready_for_completion) ? t('ui.learning_objective_achieved_according_to_ai_and_evidence_across_learning') : t('ui.continue_learning')}</span>
</button>)}</nav>
{selected && <section className="panel view-stack"><div><p className="eyebrow">Modul {selected.order}</p><h2>{selected.title}</h2><p className="muted">{selected.description}</p></div>
{analysis && <div><p>{analysis.recommendation}</p><p className="muted">{analysis.reason}</p>{analysis.weaknesses?.map((weakness, i) => <p key={i}>Noch üben: {weakness}</p>)}</div>}
<div className="course-area-grid" role="group" aria-label="Lernbereich"><button type="button" disabled={locked} className={skill === '' ? 'course-task active' : 'course-task'} onClick={() => setSkill('')}>KI-Empfehlung</button>{courseSkills.map((area) => <button type="button" disabled={locked} key={area} className={skill === area ? 'course-task active' : 'course-task'} onClick={() => { setSkill(area); generationID.current = null; }}>{courseSkillNames[area]}</button>)}</div>
<div className="action-row"><button type="button" className="primary-button" disabled={locked} onClick={() => void generate()}>{jobRunning ? 'Aufgabe wird vorbereitet…' : 'Nächste Aufgabe'}</button>{selected.key === 'review_test' && <button type="button" className="ghost-button" disabled={locked} onClick={() => void startExam()}>Neuen A1-Test starten · 12 Aufgaben</button>}</div>
<p className="muted">Du kannst beliebig weiterüben. Die Anzahl erzeugter Aufgaben entscheidet nicht über den Modulabschluss.</p>
{job && <div role="status"><p>{stageNames[job.stage] ?? job.stage}</p>{job.status === 'failed' && <button type="button" disabled={busy} onClick={() => { setError(''); void retryCourseJob(job.id).then(setJob).catch(showError); }}>Auftrag erneut versuchen</button>}</div>}
{selected && <section className="panel view-stack"><div><p className="eyebrow">{t('ui.module')} {selected.order}</p><h2>{selected.title}</h2><p className="muted">{selected.description}</p></div>
{analysis && <div><p>{analysis.recommendation}</p><p className="muted">{analysis.reason}</p>{analysis.weaknesses?.map((weakness, i) => <p key={i}>{t('ui.more_practice')} {weakness}</p>)}</div>}
<div className="course-area-grid" role="group" aria-label={t('ui.learning_area')}><button type="button" disabled={locked} className={skill === '' ? 'course-task active' : 'course-task'} onClick={() => setSkill('')}>{t('ui.ai_recommendation')}</button>{courseSkills.map((area) => <button type="button" disabled={locked} key={area} className={skill === area ? 'course-task active' : 'course-task'} onClick={() => { setSkill(area); generationID.current = null; }}>{courseSkillNames[area]}</button>)}</div>
<div className="action-row"><button type="button" className="primary-button" disabled={locked || noVariant} onClick={() => void generate()}>{jobRunning ? t('ui.preparing_exercise') : t('ui.next_exercise')}</button>{selected.key === 'review_test' && <button type="button" className="ghost-button" disabled={locked || catalog.exam_available === false} onClick={() => void startExam()}>{t('ui.start_a_new_a1_test_12_questions')}</button>}</div>
{noVariant && <p role="status">{t('course.noVariant')}</p>}
{selected.key === 'review_test' && catalog.exam_available === false && <p>{t('course.examUnavailable')}</p>}
<p className="muted">{t('ui.you_can_keep_practising_the_number_of_generated_exercises_does')}</p>
{job && <div role="status"><p>{stageNames[job.stage] ?? job.stage}</p>{job.status === 'failed' && <button type="button" disabled={busy} onClick={() => { setError(''); void retryCourseJob(job.id).then(setJob).catch(showError); }}>{t('ui.retry_job')}</button>}</div>}
{error && <p className="form-error" role="alert">{error}</p>}
{catalog.task_mode==='bank' && <p>Geprüfter Aufgabenbestand: {inventory.reduce((n,p)=>n+p.total,0)} Aufgaben · {inventory.reduce((n,p)=>n+p.unseen,0)} noch neu. Danach stehen Wiederholungen bereit.</p>}<div className="course-progress-grid">{courseSkills.map((area) => { const p = progress.find((x) => x.skill === area); return <div key={area}><strong>{courseSkillNames[area]}</strong><p>{p ? `${p.distinct_tasks} Aufgaben · ${p.attempts} Antworten · Ø ${Math.round(p.average_score)}/100` : 'Noch kein bewerteter Lernnachweis'}</p></div>; })}</div>
{catalog.task_mode==='bank' && <p>{t('course.inventory', { total: inventory.reduce((n,p)=>n+p.total,0).toLocaleString(language), unseen: inventory.reduce((n,p)=>n+p.unseen,0).toLocaleString(language) })}</p>}<div className="course-progress-grid">{courseSkills.map((area) => { const p = progress.find((x) => x.skill === area); return <div key={area}><strong>{courseSkillNames[area]}</strong><p>{p ? t('course.progress', { tasks: p.distinct_tasks.toLocaleString(language), attempts: p.attempts.toLocaleString(language), score: Math.round(p.average_score) }) : t('ui.no_graded_learning_evidence_yet')}</p></div>; })}</div>
</section>}
{exam && <section className="panel view-stack" aria-label="A1-Test"><h2>A1-Test</h2><p>{exam.status === 'completed' ? 'Test abgeschlossen' : exam.status === 'submitted' ? 'Abgegeben – Bewertung ausstehend. Eine Gesamtnote erscheint nach der Bewertung aller offenen Antworten.' : `${exam.attempts.length} von 12 Antworten gespeichert. Feedback erscheint am Ende.`}</p>
{exam.status === 'submitted' && <><button type="button" disabled={!catalog.grading_available || locked} onClick={() => { void (async()=>{try{ for(const a of exam.attempts.filter(a=>a.status==='ungraded'||a.status==='failed')) await retryCourseAttempt(a.id); }catch(err){showError(err);}finally{setExam(await getCourseExam(exam.id));}})().catch(showError); }}>Ausstehende Antworten bewerten</button>{!catalog.grading_available && <p>KI-Bewertung derzeit nicht verfügbar. Alle Antworten bleiben gespeichert.</p>}</>}
{exam.status === 'completed' && <><div className="course-progress-grid">{courseSkills.map((area) => <p key={area}>{courseSkillNames[area]}: {Math.round(exam.scores?.[area] ?? 0)} / 100</p>)}</div><strong>Gesamtergebnis: {Math.round(exam.score ?? 0)} / 100</strong><p>{exam.summary}</p>{exam.summary_status === 'failed' && exam.summary_job_id && <button type="button" onClick={() => void retryCourseJob(exam.summary_job_id!).then(() => setExam({ ...exam, summary_status: 'pending' })).catch(showError)}>KI-Gesamteinschätzung erneut anfordern</button>}<p className="muted">Interne A1-Lerneinschätzung.</p></>}
{exam && <section className="panel view-stack" aria-label={t('ui.a1_test')}><h2>{t('ui.a1_test')}</h2><p>{exam.status === 'completed' ? t('ui.test_completed') : exam.status === 'submitted' ? t('ui.submitted_evaluation_pending_an_overall_score_appears_once_all_open') : t('ui.value_of_12_answers_saved_feedback_appears_at_the_end', { value0: exam.attempts.length })}</p>
{exam.status === 'submitted' && <><button type="button" disabled={!catalog.grading_available || locked} onClick={() => { void (async()=>{try{ for(const a of exam.attempts.filter(a=>a.status==='ungraded'||a.status==='failed')) await retryCourseAttempt(a.id); }catch(err){showError(err);}finally{setExam(await getCourseExam(exam.id));}})().catch(showError); }}>{t('ui.evaluate_pending_answers')}</button>{!catalog.grading_available && <p>{t('ui.ai_evaluation_is_currently_unavailable_all_answers_remain_saved')}</p>}</>}
{exam.status === 'completed' && <><div className="course-progress-grid">{courseSkills.map((area) => <p key={area}>{courseSkillNames[area]}: {Math.round(exam.scores?.[area] ?? 0)} / 100</p>)}</div><strong>{t('ui.overall_result')} {Math.round(exam.score ?? 0)} / 100</strong><p>{exam.summary}</p>{exam.summary_status === 'failed' && exam.summary_job_id && <button type="button" onClick={() => void retryCourseJob(exam.summary_job_id!).then(() => setExam({ ...exam, summary_status: 'pending' })).catch(showError)}>{t('ui.request_ai_overall_assessment_again')}</button>}<p className="muted">{t('ui.internal_a1_learning_assessment')}</p></>}
<div className="course-area-grid">{exam.tasks.map((t, i) => <button type="button" key={t.id} disabled={recording || submitting || busy} className={task?.id === t.id ? 'course-task active' : 'course-task'} onClick={() => void openTask(t.id).catch(showError)}>{i + 1}. {courseSkillNames[t.skill]} {exam.attempts.some((a) => a.task_id === t.id) ? '✓' : ''}</button>)}</div>
</section>}
<div className="course-layout"><nav className="panel course-task-list" aria-label="Gespeicherte Aufgaben"><h2>Deine Aufgaben</h2>{history.length === 0 && <p className="muted">Deine ausgewählten Aufgaben werden hier gespeichert.</p>}{history.map((item) => <button type="button" className={task?.id === item.id ? 'course-task active' : 'course-task'} key={item.id} disabled={recording || submitting || busy} onClick={() => { setExam(null); void openTask(item.id).catch(showError); }}><span>{courseSkillNames[item.skill]} · {item.prompt.slice(0, 65)}</span></button>)}{hasMore && <button type="button" disabled={busy} onClick={() => void loadMore()}>Weitere Aufgaben laden</button>}
{catalog.exams.map((item) => <button type="button" key={item.id} disabled={locked} className="course-task" onClick={() => void getCourseExam(item.id).then((value) => { setExam(value); if (value.tasks[0]) void openTask(value.tasks[0].id).catch(showError); }).catch(showError)}>A1-Test · {item.status === 'completed' ? 'Ergebnis' : 'Fortsetzen'}</button>)}
</nav><section ref={exerciseRef} className="panel course-exercise" aria-label="Aktuelle Kursaufgabe" aria-live="polite">{task ? <><AdaptiveExercise key={task.id} task={task} attempt={attempt} locked={jobRunning} onAttempt={(a) => void receivedAttempt(a)} onRecording={setRecording} onBusy={setSubmitting} />{(attempt?.status === 'failed' || attempt?.status === 'ungraded') && <button type="button" disabled={catalog.task_mode === 'bank' && !catalog.grading_available} onClick={() => void retryCourseAttempt(attempt.id).then(() => setAttempt({ ...attempt, status: 'pending' })).catch(showError)}>{attempt.status === 'ungraded' ? 'Bewertung anfordern' : 'Bewertung erneut anfordern'}</button>}{attempt?.status === 'ungraded' && !catalog.grading_available && <p className="muted">Die KI-Bewertung ist derzeit nicht verfügbar. Du kannst deine Antwort ohne Benotung mit dem Beispiel vergleichen.</p>}{evaluating && <p className="muted">Die Antwort bleibt gespeichert, auch wenn du die Seite verlässt.</p>}</> : <p className="muted">Wähle ein Modul und fordere deine nächste Aufgabe an.</p>}</section></div>
<div className="course-layout"><nav className="panel course-task-list" aria-label={t('ui.saved_exercises')}><h2>{t('ui.your_exercises')}</h2>{history.length === 0 && <p className="muted">{t('ui.your_selected_exercises_are_saved_here')}</p>}{history.map((item) => <button type="button" className={task?.id === item.id ? 'course-task active' : 'course-task'} key={item.id} disabled={recording || submitting || busy} onClick={() => { setExam(null); void openTask(item.id).catch(showError); }}><span>{courseSkillNames[item.skill]} · {item.prompt.slice(0, 65)}</span></button>)}{hasMore && <button type="button" disabled={busy} onClick={() => void loadMore()}>{t('ui.load_more_exercises')}</button>}
{catalog.exams.map((item) => <button type="button" key={item.id} disabled={locked} className="course-task" onClick={() => void getCourseExam(item.id).then((value) => { setExam(value); if (value.tasks[0]) void openTask(value.tasks[0].id).catch(showError); }).catch(showError)}>{t('ui.a1_test_2')} {item.status === 'completed' ? t('ui.result') : t('ui.resume')}</button>)}
</nav><section ref={exerciseRef} className="panel course-exercise" aria-label={t('ui.current_course_exercise')} aria-live="polite">{task ? <><AdaptiveExercise key={task.id} task={task} attempt={attempt} locked={jobRunning} onAttempt={(a) => void receivedAttempt(a)} onRecording={setRecording} onBusy={setSubmitting} />{(attempt?.status === 'failed' || attempt?.status === 'ungraded') && <button type="button" disabled={catalog.task_mode === 'bank' && !catalog.grading_available} onClick={() => void retryCourseAttempt(attempt.id).then(() => setAttempt({ ...attempt, status: 'pending' })).catch(showError)}>{attempt.status === 'ungraded' ? t('ui.request_evaluation') : t('ui.request_evaluation_again')}</button>}{attempt?.status === 'ungraded' && !catalog.grading_available && <p className="muted">{t('ui.ai_evaluation_is_currently_unavailable_you_can_compare_your_answer')}</p>}{evaluating && <p className="muted">{t('ui.your_answer_remains_saved_even_if_you_leave_this_page')}</p>}</> : <p className="muted">{t('ui.choose_a_module_and_request_your_next_exercise')}</p>}</section></div>
</>}
<button type="button" className="link-button" disabled={locked} onClick={() => setLegacy(true)}>Bisherigen festen Kurs öffnen</button>
<button type="button" className="link-button" disabled={locked} onClick={() => setLegacy(true)}>{t('ui.open_the_original_fixed_course')}</button>
</div>;
}
+13 -11
View File
@@ -1,3 +1,4 @@
import { useI18n } from '../i18n/I18n';
import { ArrowRight, Clock, Gauge } from 'lucide-react';
import { useEffect, useState } from 'react';
import { fetchDashboard } from '../api/lessons';
@@ -9,6 +10,7 @@ type Props = {
};
export function DashboardPage({ onPractice, onLoaded }: Props) {
const { t } = useI18n();
const [dashboard, setDashboard] = useState<Dashboard | null>(null);
const [error, setError] = useState('');
@@ -21,40 +23,40 @@ export function DashboardPage({ onPractice, onLoaded }: Props) {
onLoaded(data.next_lesson, data.next_exercise);
})
.catch((err) => {
if (!cancelled) setError(err instanceof Error ? err.message : 'Dashboard konnte nicht geladen werden');
if (!cancelled) setError(err instanceof Error ? err.message : t('dashboard.error'));
});
return () => { cancelled = true; };
}, []);
if (error) return <p className="form-error">{error}</p>;
if (!dashboard) return <p className="muted">Lade Dashboard...</p>;
if (!dashboard) return <p className="muted">{t('dashboard.loading')}</p>;
return (
<div className="view-stack">
<header className="view-header">
<div>
<p className="eyebrow">Heute</p>
<h1>A1 Aussprachetraining</h1>
<p className="eyebrow">{t('nav.today')}</p>
<h1>{t('dashboard.title')}</h1>
</div>
<button className="primary-button" onClick={() => onPractice(dashboard.next_lesson, dashboard.next_exercise)}>
<ArrowRight size={18} /> Naechste Uebung
<ArrowRight size={18} /> {t('dashboard.next')}
</button>
</header>
<section className="metric-grid">
<div className="panel metric">
<Clock size={22} />
<span>Tagesziel</span>
<strong>{dashboard.profile.daily_goal_minutes} min</strong>
<span>{t('dashboard.dailyGoal')}</span>
<strong>{t('dashboard.minutes', { count: dashboard.profile.daily_goal_minutes })}</strong>
</div>
<div className="panel metric">
<Gauge size={22} />
<span>Durchschnitt</span>
<span>{t('dashboard.average')}</span>
<strong>{Math.round(dashboard.progress.average_score || 0)}</strong>
</div>
<div className="panel metric">
<ArrowRight size={22} />
<span>Versuche</span>
<span>{t('dashboard.attempts')}</span>
<strong>{dashboard.progress.total_attempts}</strong>
</div>
</section>
@@ -63,9 +65,9 @@ export function DashboardPage({ onPractice, onLoaded }: Props) {
<div>
<p className="eyebrow">{dashboard.next_lesson.topic}</p>
<h2>{dashboard.next_lesson.title}</h2>
<p className="target-text">{dashboard.next_exercise.target_text}</p>
<p className="target-text" lang={dashboard.next_exercise.target_language} dir="auto">{dashboard.next_exercise.target_text}</p>
</div>
<p className="muted">{dashboard.next_exercise.prompt_text}</p>
<p className="muted" lang={dashboard.user.instruction_language} dir="auto">{dashboard.next_exercise.prompt_text}</p>
</section>
</div>
);
+22 -19
View File
@@ -1,3 +1,4 @@
import { useI18n } from '../i18n/I18n';
import { Activity, Database, RefreshCw, Server, Settings, Waves } from 'lucide-react';
import type { ReactNode } from 'react';
import { useEffect, useState } from 'react';
@@ -20,6 +21,7 @@ type DebugError = {
};
export function DebugPage() {
const { t } = useI18n();
const [status, setStatus] = useState<DebugStatus | null>(null);
const [db, setDB] = useState<DebugDB | null>(null);
const [ai, setAI] = useState<DebugCheck | null>(null);
@@ -44,7 +46,7 @@ export function DebugPage() {
const runtimeResponse = await fetchDebugRuntime();
setRuntime(runtimeResponse.runtime);
} catch (err) {
setError(toDebugError(err));
setError(toDebugError(err, t('ui.unknown_error')));
} finally {
setLoading(false);
}
@@ -68,7 +70,7 @@ export function DebugPage() {
try {
await fn();
} catch (err) {
setError(toDebugError(err));
setError(toDebugError(err, t('ui.unknown_error')));
} finally {
setLoading(false);
}
@@ -78,35 +80,34 @@ export function DebugPage() {
<div className="view-stack">
<header className="view-header">
<div>
<p className="eyebrow">Systemdiagnose</p>
<h1>Debug</h1>
<p className="eyebrow">{t('ui.system_diagnostics')}</p>
<h1>{t('nav.debug')}</h1>
</div>
<button className="primary-button" onClick={refreshAll} disabled={loading}>
<RefreshCw size={18} /> Neu pruefen
</button>
<RefreshCw size={18} /> {t('ui.check_again')} </button>
</header>
{error && (
<section className="panel result-panel debug-error">
<h2>Fehler</h2>
<h2>{t('ui.error')}</h2>
<p>{error.message}</p>
<p className="muted">
{error.status ? `HTTP ${error.status}` : 'Kein HTTP-Status'} {error.requestId ? `Request-ID ${error.requestId}` : ''}
{error.status ? `HTTP ${error.status}` : t('ui.no_http_status')} {error.requestId ? t('ui.request_id_value', { value0: error.requestId }) : ''}
</p>
</section>
)}
<section className="debug-grid">
<DebugCheckCard icon={<Database size={21} />} title="Datenbank" check={dbToCheck(db)} onRefresh={runDB} />
<DebugCheckCard icon={<Waves size={21} />} title="Azure Speech" check={azure} onRefresh={runAzure} />
<DebugCheckCard icon={<Activity size={21} />} title="KI-Anbindung" check={ai} onRefresh={runAI} />
<DebugObjectCard icon={<Server size={21} />} title="Runtime" value={runtime} />
<DebugCheckCard icon={<Database size={21} />} title={t('ui.database')} check={dbToCheck(db)} onRefresh={runDB} />
<DebugCheckCard icon={<Waves size={21} />} title={t('ui.azure_speech')} check={azure} onRefresh={runAzure} />
<DebugCheckCard icon={<Activity size={21} />} title={t('ui.ai_connection')} check={ai} onRefresh={runAI} />
<DebugObjectCard icon={<Server size={21} />} title={t('ui.runtime')} value={runtime} />
</section>
<section className="panel result-panel">
<div className="debug-title">
<Settings size={21} />
<h2>Konfiguration</h2>
<h2>{t('ui.configuration')}</h2>
</div>
<DebugObject value={status?.config ?? null} />
</section>
@@ -115,6 +116,7 @@ export function DebugPage() {
}
function DebugCheckCard({ icon, title, check, onRefresh }: { icon: ReactNode; title: string; check: DebugCheck | null; onRefresh: () => void }) {
const { t } = useI18n();
const tone = check?.ok ? 'good' : 'weak';
return (
<section className={`panel debug-card debug-${tone}`}>
@@ -123,13 +125,13 @@ function DebugCheckCard({ icon, title, check, onRefresh }: { icon: ReactNode; ti
{icon}
<h2>{title}</h2>
</div>
<button className="ghost-button icon-only" onClick={onRefresh} aria-label={`${title} pruefen`} title={`${title} pruefen`}>
<button className="ghost-button icon-only" onClick={onRefresh} aria-label={t('ui.check_value', { value0: title })} title={t('ui.check_value', { value0: title })}>
<RefreshCw size={17} />
</button>
</div>
{check ? (
<>
<strong>{check.ok ? 'OK' : 'Problem'}</strong>
<strong>{check.ok ? 'OK' : t('ui.problem')}</strong>
<span>{check.status}</span>
{check.http_status ? <span>HTTP {check.http_status}</span> : null}
{check.duration_ms ? <span>{check.duration_ms} ms</span> : null}
@@ -137,7 +139,7 @@ function DebugCheckCard({ icon, title, check, onRefresh }: { icon: ReactNode; ti
<DebugObject value={check.details ?? null} />
</>
) : (
<p className="muted">Noch nicht geprueft.</p>
<p className="muted">{t('ui.not_checked_yet')}</p>
)}
</section>
);
@@ -156,7 +158,8 @@ function DebugObjectCard({ icon, title, value }: { icon: ReactNode; title: strin
}
function DebugObject({ value }: { value: Record<string, unknown> | null }) {
if (!value) return <p className="muted">Keine Daten.</p>;
const { t } = useI18n();
if (!value) return <p className="muted">{t('ui.no_data')}</p>;
return (
<dl className="debug-object">
{Object.entries(value).map(([key, val]) => (
@@ -190,12 +193,12 @@ function formatValue(value: unknown) {
return String(value ?? '');
}
function toDebugError(err: unknown): DebugError {
function toDebugError(err: unknown, fallback: string): DebugError {
if (err instanceof ApiError) {
return { message: err.message, status: err.status, requestId: err.requestId };
}
if (err instanceof Error) {
return { message: err.message };
}
return { message: 'Unbekannter Fehler' };
return { message: fallback };
}
+49 -48
View File
@@ -1,3 +1,5 @@
import { useLocalizedMessage } from '../i18n/useLocalizedMessage';
import { useI18n } from '../i18n/I18n';
import { useEffect, useRef, useState } from 'react';
import { fetchCourseAudio, fetchCourseModule, fetchCourseModules, fetchCoursePractice, nextCoursePractice, submitCourseAnswer } from '../api/course';
import { fetchExerciseAudio } from '../api/lessons';
@@ -5,17 +7,17 @@ import { submitAttempt } from '../api/practice';
import type { AttemptResponse, CourseAttemptResult, CourseModuleDetail, CourseTask } from '../api/types';
import { AudioRecorder } from '../components/AudioRecorder';
const skillNames: Record<CourseTask['skill'], string> = {
vocabulary: 'Wortschatz', listening: 'Hören', reading: 'Lesen', grammar: 'Grammatik',
writing: 'Schreiben', pronunciation: 'Aussprache'
};
export function LegacyCoursePage() {
const { t, language } = useI18n();
const skillNames: Record<CourseTask['skill'], string> = {
vocabulary: t('ui.vocabulary'), listening: t('ui.listening'), reading: t('ui.reading'), grammar: t('ui.grammar'),
writing: t('ui.writing'), pronunciation: t('nav.practice')
};
const [detail, setDetail] = useState<CourseModuleDetail | null>(null);
const [practiceTasks, setPracticeTasks] = useState<CourseTask[]>([]);
const [practiceTask, setPracticeTask] = useState<CourseTask | null>(null);
const [practiceNotice, setPracticeNotice] = useState('');
const [practiceError, setPracticeError] = useState('');
const [practiceNotice, setPracticeNotice] = useLocalizedMessage();
const [practiceError, setPracticeError] = useLocalizedMessage();
const exerciseRef = useRef<HTMLElement | null>(null);
const [practiceLoading, setPracticeLoading] = useState(true);
const [generating, setGenerating] = useState(false);
@@ -29,8 +31,8 @@ export function LegacyCoursePage() {
const [recordedUrl, setRecordedUrl] = useState('');
const [recording, setRecording] = useState(false);
const [busy, setBusy] = useState(false);
const [error, setError] = useState('');
const [audioError, setAudioError] = useState('');
const [error, setError] = useLocalizedMessage();
const [audioError, setAudioError] = useLocalizedMessage();
const playbackRef = useRef<{ player: HTMLAudioElement; url: string } | null>(null);
function stopPlayback() {
@@ -51,7 +53,7 @@ export function LegacyCoursePage() {
if (active) { setDetail(loaded); setSelectedId(loaded.tasks.find((task) => !task.attempted)?.id ?? loaded.tasks[0]?.id ?? ''); setLoaded(true); }
const practice = await fetchCoursePractice(loaded.module.id);
if (active) setPracticeTasks(practice.tasks);
}).catch((err) => { if (active) { setError(err instanceof Error ? err.message : 'Kurs konnte nicht geladen werden.'); setLoaded(true); } }).finally(() => { if (active) setPracticeLoading(false); });
}).catch((err) => { if (active) { setError(err instanceof Error ? err.message : { key: 'ui.unable_to_load_course' }); setLoaded(true); } }).finally(() => { if (active) setPracticeLoading(false); });
return () => { active = false; };
}, []);
@@ -103,16 +105,16 @@ export function LegacyCoursePage() {
setAnswer(''); setResult(null); setPronResult(null); setRecorded(null); setAudioError('');
if ((response.source === 'flowise' || response.source === 'ai' || response.source === 'curated')) {
setPracticeTasks((current) => [receivedTask, ...current.filter((item) => item.id !== response.task.id)].slice(0, 50));
setPracticeNotice(response.source === 'curated' ? 'Eine Aufgabe aus dem geprüften Bestand ist bereit.' : 'Eine mit KI erstellte Zusatzaufgabe ist bereit.');
setPracticeNotice(response.source === 'curated' ? { key: 'ui.an_exercise_from_the_reviewed_bank_is_ready' } : { key: 'ui.an_additional_ai_exercise_is_ready' });
} else {
setPracticeNotice('Du erhältst eine feste Kursaufgabe zur Wiederholung.');
setPracticeNotice({ key: 'ui.a_fixed_course_exercise_is_ready_for_review' });
}
requestAnimationFrame(() => {
exerciseRef.current?.focus({ preventScroll: true });
exerciseRef.current?.scrollIntoView({ block: 'start', behavior: 'smooth' });
});
} catch (err) {
setPracticeError(err instanceof Error ? err.message : 'Zusatzaufgabe konnte nicht geladen werden.');
setPracticeError(err instanceof Error ? err.message : { key: 'ui.unable_to_load_additional_exercise' });
} finally { setBusy(false); setGenerating(false); }
}
@@ -128,9 +130,9 @@ export function LegacyCoursePage() {
const player = new Audio(url);
playbackRef.current = { player, url };
player.onended = () => { if (playbackRef.current?.player === player) stopPlayback(); };
player.onerror = () => { if (playbackRef.current?.player === player) stopPlayback(); setAudioError('Audio konnte nicht abgespielt werden.'); };
player.onerror = () => { if (playbackRef.current?.player === player) stopPlayback(); setAudioError({ key: 'ui.unable_to_play_audio' }); };
await player.play();
} catch { stopPlayback(); setAudioError('Audio konnte nicht abgespielt werden. Bitte erneut versuchen.'); }
} catch { stopPlayback(); setAudioError({ key: 'ui.unable_to_play_audio_please_try_again' }); }
finally { setBusy(false); }
}
@@ -141,7 +143,7 @@ export function LegacyCoursePage() {
const response = await submitCourseAnswer(task.id, answer);
setResult(response);
await refresh();
} catch (err) { setError(err instanceof Error ? err.message : 'Antwort konnte nicht bewertet werden.'); }
} catch (err) { setError(err instanceof Error ? err.message : { key: 'ui.unable_to_evaluate_your_answer' }); }
finally { setBusy(false); }
}
@@ -153,40 +155,40 @@ export function LegacyCoursePage() {
setPronResult(response);
setRecorded(null);
await refresh();
} catch (err) { setError(err instanceof Error ? err.message : 'Aussprache konnte nicht bewertet werden.'); }
} catch (err) { setError(err instanceof Error ? err.message : { key: 'ui.unable_to_evaluate_pronunciation' }); }
finally { setBusy(false); }
}
if (error && !detail) return <p className="form-error">{error}</p>;
if (loaded && !detail) return <p className="muted">Für deine aktuelle Sprache und Lernstufe ist noch kein Kursmodul verfügbar.</p>;
if (!detail) return <p className="muted">Lade A1-Kurs...</p>;
if (loaded && !detail) return <p className="muted">{t('ui.no_course_module_is_available_for_your_current_language_and')}</p>;
if (!detail) return <p className="muted">{t('ui.loading_a1_course_2')}</p>;
const task = practiceTask ?? detail.tasks.find((item) => item.id === selectedId);
const skills = Object.entries(skillNames) as [CourseTask['skill'], string][];
return (
<div className="view-stack">
<header className="view-header">
<div><p className="eyebrow">Geführter A1-Kurs</p><h1>{detail.module.title}</h1><p className="muted">{detail.module.description}</p></div>
<div><p className="eyebrow">{t('ui.guided_a1_course')}</p><h1>{detail.module.title}</h1><p className="muted">{detail.module.description}</p></div>
</header>
<section className="panel course-progress" aria-label="Modulfortschritt">
<strong>{detail.module.attempted_count} von {detail.module.task_count} Aufgaben bearbeitet</strong>
<p className="muted">{detail.module.correct_count} Aufgaben richtig gelöst. „Bearbeitet“ bedeutet nicht „A1 bestanden“.</p>
<section className="panel course-progress" aria-label={t('ui.module_progress')}>
<strong>{t('legacy.completed', { done: detail.module.attempted_count.toLocaleString(language), total: detail.module.task_count.toLocaleString(language) })}</strong>
<p className="muted">{t('legacy.correct', { count: detail.module.correct_count.toLocaleString(language) })}</p>
<progress max={detail.module.task_count || 1} value={detail.module.attempted_count} />
</section>
<section className="panel course-additional" aria-label="Zusätzlich üben">
<div><h2>Zusätzlich üben</h2><p className="muted">Wortschatz und Grammatik wiederholen. Dein Fortschritt im festen Kurs bleibt davon getrennt.</p></div>
<section className="panel course-additional" aria-label={t('ui.additional_practice')}>
<div><h2>{t('ui.additional_practice')}</h2><p className="muted">{t('ui.review_vocabulary_and_grammar_your_progress_in_the_fixed_course')}</p></div>
<button type="button" className="primary-button" disabled={busy || recording || practiceLoading} onClick={() => void generatePractice()}>
{generating ? 'Aufgabe wird vorbereitet…' : 'Neue Zusatzaufgabe'}
{generating ? t('ui.preparing_exercise') : t('ui.new_additional_exercise')}
</button>
{practiceLoading && <p className="course-practice-status muted" role="status">Zusatzaufgaben werden geladen…</p>}
{generating && <p className="course-practice-status muted" role="status">Eine passende Aufgabe wird vorbereitet. Das kann bis zu 25 Sekunden dauern.</p>}
{practiceError && <p className="course-practice-status form-error" role="alert">Zusatzaufgabe konnte nicht geladen werden: {practiceError}</p>}
{practiceLoading && <p className="course-practice-status muted" role="status">{t('ui.loading_additional_exercises')}</p>}
{generating && <p className="course-practice-status muted" role="status">{t('ui.preparing_a_suitable_exercise_this_can_take_up_to_25')}</p>}
{practiceError && <p className="course-practice-status form-error" role="alert">{t('ui.unable_to_load_additional_exercise_2')} {practiceError}</p>}
{practiceNotice && <p className="course-practice-status muted" role="status">{practiceNotice}</p>}
</section>
<div className="course-layout">
<nav className="panel course-task-list" aria-label="Kursaufgaben">
<nav className="panel course-task-list" aria-label={t('ui.course_exercises')}>
{practiceTasks.length > 0 && <div className="course-skill-group">
<h2>Deine Zusatzaufgaben</h2>
<h2>{t('ui.your_additional_exercises')}</h2>
{practiceTasks.map((item, index) => <button key={item.id} type="button" disabled={busy || recording}
className={practiceTask?.id === item.id ? 'course-task active' : 'course-task'} onClick={() => selectTask(item, true)}>
<span>{skillNames[item.skill]} · {index + 1}</span><span>{item.correct ? '✓' : item.attempted ? '↻' : '○'}</span>
@@ -195,46 +197,45 @@ export function LegacyCoursePage() {
{skills.map(([skill, name]) => {
const tasks = detail.tasks.filter((item) => item.skill === skill);
return tasks.length > 0 && <div key={skill} className="course-skill-group">
<h2>{name} <small>{tasks.filter((item) => item.attempted).length}/{tasks.length} bearbeitet · {tasks.filter((item) => item.correct).length} Ziel erreicht</small></h2>
<h2>{name} <small>{t('legacy.areaProgress', { done: tasks.filter((item) => item.attempted).length, total: tasks.length, correct: tasks.filter((item) => item.correct).length })}</small></h2>
{tasks.map((item, index) => <button key={item.id} type="button" disabled={recording || busy}
className={!practiceTask && item.id === selectedId ? 'course-task active' : 'course-task'} onClick={() => selectTask(item)}>
<span>Aufgabe {index + 1}</span><span>{item.correct ? '✓' : item.attempted ? '↻' : '○'}</span>
<span>{t('ui.exercise')} {index + 1}</span><span>{item.correct ? '✓' : item.attempted ? '↻' : '○'}</span>
</button>)}
</div>;
})}
</nav>
<section ref={exerciseRef} tabIndex={-1} className="panel course-exercise" aria-live="polite" aria-label="Aktuelle Kursaufgabe">
<section ref={exerciseRef} tabIndex={-1} className="panel course-exercise" aria-live="polite" aria-label={t('ui.current_course_exercise')}>
{task && <>
<p className="eyebrow">{practiceTask ? (practiceTask.source === 'curated' ? 'Aus geprüftem Aufgabenbestand · ' : practiceTask.source === 'ai' ? 'Mit KI erstellt · ' : practiceTask.source === 'flowise' ? 'Mit Flowise erstellt · ' : practiceTask.source === 'seed' ? 'Feste Kursaufgabe zur Wiederholung · ' : 'Zusätzlich üben · ') : ''}{skillNames[task.skill]}</p>
<p className="eyebrow">{practiceTask ? (practiceTask.source === 'curated' ? t('ui.from_the_reviewed_exercise_bank_2') : practiceTask.source === 'ai' ? t('ui.created_with_ai_2') : practiceTask.source === 'flowise' ? t('ui.created_with_flowise_2') : practiceTask.source === 'seed' ? t('ui.fixed_course_exercise_for_review') : t('ui.additional_practice_2')) : ''}{skillNames[task.skill]}</p>
<h2>{task.prompt}</h2>
{task.passage && <p className="course-passage">{task.passage}</p>}
{task.skill === 'listening' && <p className="muted">Höre zuerst zu. Der gesprochene Text erscheint nach deiner Antwort.</p>}
{task.skill === 'listening' && <p className="muted">{t('ui.listen_first_the_spoken_text_appears_after_your_answer')}</p>}
{(task.skill === 'listening' || task.skill === 'pronunciation') && <button type="button" className="ghost-button" disabled={busy || recording}
onClick={() => void playAudio(task)}>Anhören</button>}
onClick={() => void playAudio(task)}>{t('ui.listen')}</button>}
{audioError && <p className="form-error">{audioError}</p>}
{task.kind === 'choice' && <div className="course-options" role="group" aria-label="Antwortmöglichkeiten">
{task.kind === 'choice' && <div className="course-options" role="group" aria-label={t('ui.answer_options')}>
{(task.options ?? []).map((option) => <label key={option} className="course-option">
<input type="radio" name={`answer-${task.id}`} value={option} checked={answer === option} onChange={() => setAnswer(option)} disabled={busy} /> {option}
</label>)}
</div>}
{task.kind === 'short_text' && <label>Deine Antwort
<input type="text" maxLength={200} value={answer} onChange={(event) => setAnswer(event.target.value)} disabled={busy} autoComplete="off" />
{task.kind === 'short_text' && <label>{t('ui.your_answer')} <input type="text" maxLength={200} value={answer} onChange={(event) => setAnswer(event.target.value)} disabled={busy} autoComplete="off" />
</label>}
{task.kind !== 'pronunciation' && <button type="button" className="primary-button" disabled={busy || !answer.trim()} onClick={() => void submit(task)}>
{busy ? 'Wird geprüft...' : 'Antwort prüfen'}
{busy ? t('ui.checking') : t('ui.check_answer')}
</button>}
{task.kind === 'pronunciation' && task.pronunciation_exercise && <div className="course-pronunciation">
<p className="target-text">{task.pronunciation_exercise.target_text}</p>
<div className="action-row"><AudioRecorder key={task.id} onRecorded={setRecorded} onRecordingChange={setRecording}
onRecordingStart={() => { setRecorded(null); setPronResult(null); }} disabled={busy} buttonLabel={recorded ? 'Erneut aufnehmen' : 'Aufnehmen'} secondary={Boolean(recorded)} />
{recorded && !recording && <button type="button" className="primary-button" disabled={busy} onClick={() => void assess(task)}>Bewerten</button>}</div>
{recordedUrl && !recording && <div className="recording-preview"><p className="muted">Du kannst die Aufnahme vor dem Bewerten anhören oder erneut aufnehmen.</p><audio controls src={recordedUrl} /></div>}
{pronResult && <div className="course-feedback"><strong>Aussprache: {Math.round(pronResult.attempt.overall_score)} / 100</strong><p>{pronResult.teacher.teacher_feedback}</p></div>}
onRecordingStart={() => { setRecorded(null); setPronResult(null); }} disabled={busy} buttonLabel={recorded ? t('ui.record_again') : t('ui.record')} secondary={Boolean(recorded)} />
{recorded && !recording && <button type="button" className="primary-button" disabled={busy} onClick={() => void assess(task)}>{t('ui.evaluate')}</button>}</div>
{recordedUrl && !recording && <div className="recording-preview"><p className="muted">{t('ui.you_can_listen_to_your_recording_or_record_again_before')}</p><audio controls src={recordedUrl} /></div>}
{pronResult && <div className="course-feedback"><strong>{t('ui.pronunciation')} {Math.round(pronResult.attempt.overall_score)} / 100</strong><p>{pronResult.teacher.teacher_feedback}</p></div>}
</div>}
{result?.task_id === task.id && <div className={result.correct ? 'course-feedback correct' : 'course-feedback'} role="status">
<strong>{result.correct ? 'Richtig!' : 'Noch nicht richtig.'}</strong>
<p>{result.explanation}</p><p>Musterantwort: {result.solution}</p>
{result.transcript && <p>Gehörter Text: {result.transcript}</p>}
<strong>{result.correct ? t('ui.correct_2') : t('ui.not_correct_yet')}</strong>
<p>{result.explanation}</p><p>{t('ui.example_answer')} {result.solution}</p>
{result.transcript && <p>{t('ui.listening_transcript_2')} {result.transcript}</p>}
</div>}
</>}
+8 -6
View File
@@ -1,3 +1,4 @@
import { useI18n } from '../i18n/I18n';
import { LogIn } from 'lucide-react';
import { FormEvent, useState } from 'react';
import { login } from '../api/auth';
@@ -8,6 +9,7 @@ type Props = {
};
export function LoginPage({ onDone, onRegister }: Props) {
const { t } = useI18n();
const [email, setEmail] = useState('');
const [password, setPassword] = useState('');
const [error, setError] = useState('');
@@ -21,7 +23,7 @@ export function LoginPage({ onDone, onRegister }: Props) {
await login(email, password);
onDone();
} catch (err) {
setError(err instanceof Error ? err.message : 'Login fehlgeschlagen');
setError(err instanceof Error ? err.message : t('auth.loginError'));
} finally {
setLoading(false);
}
@@ -31,24 +33,24 @@ export function LoginPage({ onDone, onRegister }: Props) {
<section className="auth-panel">
<div className="auth-heading">
<div className="brand-mark">SL</div>
<h1>Einloggen</h1>
<h1>{t('auth.login')}</h1>
</div>
<form onSubmit={submit} className="form-grid">
<label>
E-Mail
{t('auth.email')}
<input value={email} onChange={(event) => setEmail(event.target.value)} type="email" autoComplete="email" required />
</label>
<label>
Passwort
{t('auth.password')}
<input value={password} onChange={(event) => setPassword(event.target.value)} type="password" autoComplete="current-password" required />
</label>
{error && <p className="form-error">{error}</p>}
<button className="primary-button" disabled={loading} type="submit">
<LogIn size={18} /> Login
<LogIn size={18} /> {t(loading ? 'auth.busy' : 'auth.login')}
</button>
</form>
<button className="link-button" onClick={onRegister} type="button">
Account erstellen
{t('auth.register')}
</button>
</section>
);
+31 -29
View File
@@ -1,3 +1,5 @@
import { useLocalizedMessage } from '../i18n/useLocalizedMessage';
import { useI18n } from '../i18n/I18n';
import { RotateCcw, Send, Volume2 } from 'lucide-react';
import { useEffect, useRef, useState } from 'react';
import { fetchExerciseAudio, fetchNextLesson, type ExerciseAudioMode } from '../api/lessons';
@@ -13,6 +15,7 @@ type Props = {
};
export function PracticePage({ initialSelection }: Props) {
const { t } = useI18n();
const [lesson, setLesson] = useState<Lesson | null>(initialSelection?.lesson ?? null);
const [exercise, setExercise] = useState<Exercise | null>(initialSelection?.exercise ?? null);
const [audio, setAudio] = useState<Blob | null>(null);
@@ -22,9 +25,9 @@ export function PracticePage({ initialSelection }: Props) {
const [loadingNext, setLoadingNext] = useState(false);
const [recording, setRecording] = useState(false);
const [audioLoadingKey, setAudioLoadingKey] = useState<string | null>(null);
const [audioError, setAudioError] = useState('');
const [error, setError] = useState('');
const [notice, setNotice] = useState('');
const [audioError, setAudioError] = useLocalizedMessage();
const [error, setError] = useLocalizedMessage();
const [notice, setNotice] = useLocalizedMessage();
const submittingRef = useRef(false);
const referenceAudioRef = useRef<{ exerciseId: string; urls: Map<string, string>; player: HTMLAudioElement | null } | null>(null);
const audioRequestRef = useRef<AbortController | null>(null);
@@ -81,7 +84,7 @@ export function PracticePage({ initialSelection }: Props) {
await player.play();
} catch {
if (audioGenerationRef.current !== generation || controller?.signal.aborted) return;
setAudioError('Satz konnte nicht abgespielt werden. Bitte erneut versuchen.');
setAudioError({ key: 'ui.unable_to_play_the_sentence_please_try_again' });
} finally {
if (audioGenerationRef.current === generation) setAudioLoadingKey(null);
if (audioRequestRef.current === controller) audioRequestRef.current = null;
@@ -104,7 +107,7 @@ export function PracticePage({ initialSelection }: Props) {
try {
const next = await fetchNextLesson(fresh, fresh ? recentExerciseIds.current : []);
if (fresh && exercise?.target_text.trim().toLowerCase() === next.exercise.target_text.trim().toLowerCase()) {
setNotice('Der Agent hat denselben Satz erneut erzeugt. Bitte versuche es noch einmal.');
setNotice({ key: 'ui.the_agent_generated_the_same_sentence_again_please_try_once' });
}
setLesson(next.lesson);
setExercise(next.exercise);
@@ -112,7 +115,7 @@ export function PracticePage({ initialSelection }: Props) {
recentExerciseIds.current = [...recentExerciseIds.current, next.exercise.id].slice(-3);
}
} catch (err) {
setError(err instanceof Error ? err.message : 'Uebung konnte nicht geladen werden');
setError(err instanceof Error ? err.message : { key: 'ui.unable_to_load_exercise' });
} finally {
setLoadingNext(false);
}
@@ -127,7 +130,7 @@ export function PracticePage({ initialSelection }: Props) {
try {
setResult(await submitAttempt(exercise.id, audio));
} catch (err) {
setError(err instanceof Error ? err.message : 'Bewertung fehlgeschlagen');
setError(err instanceof Error ? err.message : { key: 'ui.evaluation_failed' });
} finally {
submittingRef.current = false;
setLoading(false);
@@ -137,8 +140,8 @@ export function PracticePage({ initialSelection }: Props) {
if (!lesson || !exercise) {
return (
<div className="view-stack">
<p className={error ? 'form-error' : 'muted'}>{error || 'Lade Uebung...'}</p>
{error && <button className="ghost-button" disabled={loadingNext} onClick={() => void loadNext(true)}>Erneut versuchen</button>}
<p className={error ? 'form-error' : 'muted'}>{error || t('ui.loading_exercise')}</p>
{error && <button className="ghost-button" disabled={loadingNext} onClick={() => void loadNext(true)}>{t('common.retry')}</button>}
</div>
);
}
@@ -150,10 +153,10 @@ export function PracticePage({ initialSelection }: Props) {
<header className="view-header">
<div>
<p className="eyebrow">{lesson.title}</p>
<h1>Aussprache</h1>
<h1>{t('nav.practice')}</h1>
</div>
<button className="ghost-button" disabled={loadingNext || loading || recording} onClick={() => void loadNext(true)}>
<RotateCcw size={18} /> {loadingNext ? 'Lade neue Uebung...' : 'Andere Uebung'}
<RotateCcw size={18} /> {loadingNext ? t('ui.loading_new_exercise') : t('ui.different_exercise')}
</button>
</header>
@@ -162,23 +165,23 @@ export function PracticePage({ initialSelection }: Props) {
<section className="panel practice-panel">
<p className="muted">{exercise.prompt_text}</p>
{exercise.training_reason&&<p className="muted" role="note">Warum diese Übung: {exercise.training_reason}</p>}
<PronunciationText targetText={exercise.target_text} words={result?.attempt.word_scores} />
{exercise.training_reason&&<p className="muted" role="note">{t('ui.why_this_exercise')} {exercise.training_reason}</p>}
<PronunciationText language={exercise.target_language} targetText={exercise.target_text} words={result?.attempt.word_scores} />
<div className="action-row">
<button className="ghost-button" type="button" disabled={loadingNext || audioLoadingKey !== null || recording} onClick={() => void playReference('normal')}>
<Volume2 size={18} /> {audioLoadingKey === 'normal:' ? 'Satz wird geladen...' : 'Satz anhören'}
<Volume2 size={18} /> {audioLoadingKey === 'normal:' ? t('ui.loading_sentence') : t('ui.listen_to_sentence')}
</button>
<button className="ghost-button" type="button" disabled={loadingNext || audioLoadingKey !== null || recording} onClick={() => void playReference('slow')}>
<Volume2 size={18} /> {audioLoadingKey === 'slow:' ? 'Satz wird geladen...' : 'Langsam anhören'}
<Volume2 size={18} /> {audioLoadingKey === 'slow:' ? t('ui.loading_sentence') : t('ui.listen_slowly')}
</button>
</div>
{focusWords.length > 0 && (
<div className="recording-preview">
<p className="muted">Diese Wörter kannst du gezielt anhören:</p>
<p className="muted">{t('ui.listen_to_these_practice_words')}</p>
<div className="action-row">
{focusWords.map((word) => (
<button className="ghost-button" type="button" key={word} disabled={loadingNext || audioLoadingKey !== null || recording} onClick={() => void playReference('focus', word)}>
<Volume2 size={18} /> {audioLoadingKey === `focus:${word.toLocaleLowerCase()}` ? 'Wort wird geladen...' : `${word} langsam üben`}
<Volume2 size={18} /> {audioLoadingKey === `focus:${word.toLocaleLowerCase()}` ? t('ui.loading_word') : t('ui.practise_value_slowly', { value0: word })}
</button>
))}
</div>
@@ -201,37 +204,36 @@ export function PracticePage({ initialSelection }: Props) {
}}
onRecordingChange={setRecording}
disabled={loading || loadingNext}
buttonLabel={loading ? 'Bewertung läuft...' : audio || result ? 'Erneut aufnehmen' : 'Aufnehmen'}
buttonLabel={loading ? t('ui.evaluating') : audio || result ? t('ui.record_again') : t('ui.record')}
secondary={Boolean(audio)}
/>
{audio && !recording && (
<button className="primary-button" disabled={loading || loadingNext} onClick={() => void evaluateRecording()} type="button">
<Send size={18} /> Bewerten
</button>
<Send size={18} /> {t('ui.evaluate')} </button>
)}
</div>
{audio && !recording && (
<div className="recording-preview">
<p className="muted">Aufnahme noch nicht gesendet. Anhören, erneut aufnehmen oder bewerten.</p>
{audioUrl && <audio controls src={audioUrl} aria-label="Eigene Aufnahme anhören" />}
<p className="muted">{t('ui.recording_not_yet_submitted_listen_record_again_or_request_evaluation')}</p>
{audioUrl && <audio controls src={audioUrl} aria-label={t('ui.listen_to_your_recording')} />}
</div>
)}
{loading && <p className="muted">Die Aussprache wird bewertet...</p>}
{loading && <p className="muted">{t('ui.evaluating_pronunciation')}</p>}
</section>
{result && (
<section className="result-grid">
<div className="panel result-panel">
<h2>Bewertung</h2>
<h2>{t('ui.evaluation')}</h2>
<div className="score-grid">
<ScoreBadge label="Gesamt" value={result.attempt.overall_score} />
<ScoreBadge label="Accuracy" value={result.attempt.accuracy_score} />
<ScoreBadge label="Fluency" value={result.attempt.fluency_score} />
<ScoreBadge label="Completeness" value={result.attempt.completeness_score} />
<ScoreBadge label={t('ui.overall')} value={result.attempt.overall_score} />
<ScoreBadge label={t('ui.accuracy')} value={result.attempt.accuracy_score} />
<ScoreBadge label={t('ui.fluency')} value={result.attempt.fluency_score} />
<ScoreBadge label={t('ui.completeness')} value={result.attempt.completeness_score} />
</div>
</div>
<div className="panel result-panel">
<h2>Lehrerfeedback</h2>
<h2>{t('ui.teacher_feedback')}</h2>
<p>{result.teacher.teacher_feedback}</p>
<p className="muted">{result.teacher.next_recommendation}</p>
</div>
+10 -8
View File
@@ -1,3 +1,4 @@
import { useI18n } from '../i18n/I18n';
import { useEffect, useState } from 'react';
import { fetchProgress } from '../api/lessons';
import type { ProgressSummary } from '../api/types';
@@ -5,31 +6,32 @@ import { PronunciationOverview } from '../components/PronunciationOverview';
import { ScoreBadge } from '../components/ScoreBadge';
export function ProgressPage() {
const { t, language } = useI18n();
const [progress, setProgress] = useState<ProgressSummary | null>(null);
const [error, setError] = useState('');
useEffect(() => {
fetchProgress().then(setProgress).catch((err) => setError(err instanceof Error ? err.message : 'Fortschritt konnte nicht geladen werden'));
fetchProgress().then(setProgress).catch((err) => setError(err instanceof Error ? err.message : t('progress.error')));
}, []);
if (error) return <p className="form-error">{error}</p>;
if (!progress) return <p className="muted">Lade Fortschritt...</p>;
if (!progress) return <p className="muted">{t('progress.loading')}</p>;
return (
<div className="view-stack">
<header className="view-header">
<div>
<p className="eyebrow">Lernübersicht</p>
<h1>Fortschritt</h1>
<p className="eyebrow">{t('progress.overview')}</p>
<h1>{t('nav.progress')}</h1>
</div>
</header>
<section className="metric-grid">
<div className="panel result-panel">
<ScoreBadge label="Historischer Durchschnitt" value={progress.average_score} />
<ScoreBadge label={t('progress.average')} value={progress.average_score} />
</div>
<div className="panel metric">
<span>Versuche</span>
<span>{t('dashboard.attempts')}</span>
<strong>{progress.total_attempts}</strong>
</div>
</section>
@@ -37,11 +39,11 @@ export function ProgressPage() {
<PronunciationOverview />
<section className="panel result-panel">
<h2>Letzte Versuche</h2>
<h2>{t('progress.recent')}</h2>
<div className="attempt-list">
{(progress.recent_attempts ?? []).map((attempt) => (
<div className="attempt-row" key={attempt.id}>
<span>{new Date(attempt.created_at).toLocaleString()}</span>
<span>{new Date(attempt.created_at).toLocaleString(language)}</span>
<strong>{Math.round(attempt.overall_score)}</strong>
</div>
))}
+10 -7
View File
@@ -1,3 +1,4 @@
import { useI18n } from '../i18n/I18n';
import { UserPlus } from 'lucide-react';
import { FormEvent, useState } from 'react';
import { register } from '../api/auth';
@@ -8,6 +9,7 @@ type Props = {
};
export function RegisterPage({ onDone, onLogin }: Props) {
const { t, language } = useI18n();
const [email, setEmail] = useState('');
const [password, setPassword] = useState('');
const [error, setError] = useState('');
@@ -18,10 +20,10 @@ export function RegisterPage({ onDone, onLogin }: Props) {
setLoading(true);
setError('');
try {
await register(email, password);
await register(email, password, language);
onDone();
} catch (err) {
setError(err instanceof Error ? err.message : 'Registrierung fehlgeschlagen');
setError(err instanceof Error ? err.message : t('auth.registerError'));
} finally {
setLoading(false);
}
@@ -31,24 +33,25 @@ export function RegisterPage({ onDone, onLogin }: Props) {
<section className="auth-panel">
<div className="auth-heading">
<div className="brand-mark">SL</div>
<h1>Account erstellen</h1>
<h1>{t('auth.register')}</h1>
</div>
<p className="muted">{t('language.registerInfo')}</p>
<form onSubmit={submit} className="form-grid">
<label>
E-Mail
{t('auth.email')}
<input value={email} onChange={(event) => setEmail(event.target.value)} type="email" autoComplete="email" required />
</label>
<label>
Passwort
{t('auth.password')}
<input value={password} onChange={(event) => setPassword(event.target.value)} type="password" autoComplete="new-password" minLength={8} required />
</label>
{error && <p className="form-error">{error}</p>}
<button className="primary-button" disabled={loading} type="submit">
<UserPlus size={18} /> Registrieren
<UserPlus size={18} /> {t(loading ? 'auth.busy' : 'auth.register.submit')}
</button>
</form>
<button className="link-button" onClick={onLogin} type="button">
Zurueck zum Login
{t('auth.back')}
</button>
</section>
);
+30 -2
View File
@@ -5,7 +5,10 @@ synthetischen Mikrofonsignal: standardmäßig keine Mithörbedienung und kein
Mithörpfad; nach expliziter Freigabe über `enableMonitoring` zunächst ausgeschaltetes Mithören, Schalter und
Lautstärke während der Aufnahme, tatsächliche Signalpegel, unveränderte
WAV-Aufnahme, Stoppen und Unmount, Mikrofonfehler mit erneutem Versuch sowie
automatisches Zeitlimit und schmale Ansicht. Benötigt Web-Abhängigkeiten und
automatisches Zeitlimit und schmale Ansicht. Ein Wechsel Deutsch → Englisch
→ Deutsch während einer Aufnahme darf keinen neuen Stream starten oder die
Aufnahme abbrechen; auch englische Aufnahme- und Monitoringbeschriftungen werden
geprüft. Benötigt Web-Abhängigkeiten und
Playwright mit Chromium, aber keine API oder Datenbank. Aus `apps/web`:
```bash
@@ -34,11 +37,36 @@ go test ./internal/httpapi -run TestPronunciationBrowserSmoke -v -count=1
Auch diese Fixture benötigt den freien Port 15175. Alle drei Browser-Smokes
nacheinander ausführen, nicht parallel.
`languages.e2e.cjs` läuft vor dem Kursbank-Smoke in derselben lokalen Fixture.
Es prüft vollständige Übersetzungsschlüssel/Platzhalter, Sprachwahl vor dem Login,
Registrierung, Wiederanmeldung mit Kontosprache, Speicherung nach Neuladen,
getrennte Erklärungssprache und fehlgeschlagene Speichervorgänge. Die Bedienung
von Aussprache, Dialog, Administration und festem Altkurs wird auf Englisch
geprüft. Eingegebene Dialogantworten und ungespeicherte Budgetfelder müssen einen
Sprachwechsel überstehen; die Sprachwahl darf diese Felder nicht speichern.
Lokale Statusmeldungen wechseln mit der Oberfläche ihre Sprache. Ein UI-only-PATCH
muss die aktive Lernsprache, A2-Niveau und ein abweichendes Tagesziel erhalten.
Die Kontoeinstellungen der Fixture werden vor dem anschließenden Bank-Smoke zurückgesetzt.
Alle Konten und Änderungen liegen ausschließlich in dessen zufälligem Testschema.
`course-variants.e2e.cjs` läuft zusätzlich mit einem neuen regulären Testkonto.
Es prüft die Erklärungssprachwahl unabhängig von der Oberfläche, alle zwölf
Pilotvarianten, die fünf Darstellungen, angepasste Bedeutungs-/Schreibaufgaben,
private Hörtexte und Lösungsschlüssel, unbenotete Antworten, Reload und die
unveränderte historische Ansicht nach einem Präferenzwechsel. Fehlende englische
Module erhalten keine deutschen Reserven; neue englische Tests werden abgelehnt,
während ein vorhandener deutscher Test über dieselbe Request-ID fortgesetzt
wird. Der Test löst keine Modellaufrufe aus. Der gesamte Bank-Smoke läuft danach
weiterhin vollständig auf Deutsch und Englisch als Oberflächensprache.
`course-bank.e2e.cjs` prüft den Kurs mit 840 Aufgaben, sieben Modulen, allen sechs
Lernbereichen und den fünf Darstellungsformen. Geprüft werden außerdem neue
Aufgabenzuweisungen, Neuladen, unbewertete offene Antworten mit Selbstvergleich
und ein vollständig abgegebener Test ohne vorzeitige Note oder Lösungsausgabe.
Die Prüfung bestätigt, dass dabei keine Modellaufrufe erfasst werden.
Die Prüfung läuft vollständig auf Deutsch und Englisch und bestätigt, dass dabei
keine Modellaufrufe erfasst werden. Sichtbare Aufgaben und Auswahloptionen müssen
den gespeicherten Originalen entsprechen; eine eingegebene Schreibantwort muss
beim Wechsel der Oberflächensprache erhalten bleiben.
Aus `apps/api` mit den unten beschriebenen Voraussetzungen:
+33 -2
View File
@@ -19,12 +19,18 @@ const { chromium } = require(process.env.PLAYWRIGHT_MODULE || 'playwright');
import React from '/node_modules/.vite/deps/react.js';
import ReactDOM from '/node_modules/.vite/deps/react-dom_client.js';
import { AudioRecorder } from '/src/components/AudioRecorder.tsx';
import { I18nProvider, useI18n } from '/src/i18n/I18n.tsx';
import '/src/app/styles.css';
const root = ReactDOM.createRoot(document.getElementById('root'));
function RecorderFixture(props) {
const { setLanguage } = useI18n();
window.setRecorderLanguage = setLanguage;
return React.createElement(AudioRecorder, props);
}
window.blobs = [];
window.renderRecorder = (maxSeconds, enableMonitoring = false) => root.render(React.createElement(AudioRecorder, {
window.renderRecorder = (maxSeconds, enableMonitoring = false) => root.render(React.createElement(I18nProvider, null, React.createElement(RecorderFixture, {
key: String(maxSeconds) + enableMonitoring, maxSeconds, enableMonitoring, onRecorded: blob => window.blobs.push(blob)
}));
})));
window.unmountRecorder = () => root.unmount();
window.renderRecorder();
</script></html>`);
@@ -39,10 +45,18 @@ const { chromium } = require(process.env.PLAYWRIGHT_MODULE || 'playwright');
await page.addInitScript(() => {
const RealContext = window.AudioContext;
window.contexts = [];
window.captures = [];
window.monitors = [];
window.streams = [];
window.AudioContext = class extends RealContext {
constructor(options) { super(options); window.contexts.push(this); }
createScriptProcessor(...args) {
const processor = super.createScriptProcessor(...args);
const capture = { samples: 0, rate: this.sampleRate };
window.captures.push(capture);
processor.addEventListener('audioprocess', event => { capture.samples += event.inputBuffer.length; });
return processor;
}
createGain() {
const gain = super.createGain();
const analyser = super.createAnalyser();
@@ -95,6 +109,8 @@ const { chromium } = require(process.env.PLAYWRIGHT_MODULE || 'playwright');
await page.waitForFunction(() => window.monitorRMS() > 0.1 && window.monitorRMS() < 0.2);
await toggle.uncheck();
await page.waitForFunction(() => window.monitorRMS() < 0.001);
// Collect enough real callback frames for the RMS windows checked below.
await page.waitForFunction(() => window.captures.at(-1).samples >= window.captures.at(-1).rate * 0.6);
await page.getByRole('button', { name: 'Stoppen' }).click();
await page.waitForFunction(() => window.contexts.every(c => c.state === 'closed'));
assert(await page.evaluate(() => window.streams.every(s => s.getTracks().every(t => t.readyState === 'ended'))));
@@ -129,6 +145,21 @@ const { chromium } = require(process.env.PLAYWRIGHT_MODULE || 'playwright');
await page.evaluate(() => { window.rejectMic = false; window.renderRecorder(1); });
await page.getByRole('button', { name: 'Aufnehmen', exact: true }).click();
await page.waitForFunction(() => window.blobs.length === 1 && window.contexts.every(c => c.state === 'closed'));
await page.evaluate(() => { window.renderRecorder(undefined, true); window.setRecorderLanguage('en-US'); });
await page.getByRole('button', { name: 'Record', exact: true }).click();
await page.getByRole('button', { name: 'Stop', exact: true }).waitFor();
const streamsBefore = await page.evaluate(() => window.streams.length);
const blobsBefore = await page.evaluate(() => window.blobs.length);
await page.evaluate(() => window.setRecorderLanguage('de-DE'));
await page.getByRole('button', { name: 'Stoppen', exact: true }).waitFor();
assert.equal(await page.evaluate(() => window.streams.length), streamsBefore);
assert.equal(await page.evaluate(() => window.contexts.at(-1).state), 'running');
await page.evaluate(() => window.setRecorderLanguage('en-US'));
await page.getByRole('switch', { name: 'Monitor your own voice' }).waitFor();
await page.getByRole('slider', { name: 'Monitoring volume', exact: true }).waitFor();
await page.waitForFunction(() => window.captures.at(-1).samples > 0);
await page.getByRole('button', { name: 'Stop', exact: true }).click();
await page.waitForFunction(count => window.blobs.length === count + 1, blobsBefore);
assert.deepEqual(errors, []);
await page.setViewportSize({ width: 320, height: 800 });
assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+17 -12
View File
@@ -3,27 +3,32 @@ const assert=require('node:assert/strict');
const crypto=require('node:crypto');
(async()=>{
const api=process.env.AI_E2E_API,token=process.env.AI_E2E_TOKEN,url=process.env.AI_E2E_URL;assert(api&&token&&url);
const english=process.env.UI_E2E_LANGUAGE==='en-US';
const translations={
'A1-Kurs':'A1 course','A1-Module':'A1 modules','Lernbereich':'Learning area','Aktuelle Kursaufgabe':'Current course exercise','Nächste Aufgabe':'Next exercise','Aus geprüftem Aufgabenbestand':'From the reviewed exercise bank','Grammatik':'Grammar','Antwort prüfen':'Check answer','100 / 100 · Richtig':'100 / 100 · Correct','Wortschatz':'Vocabulary','Lesen':'Reading','Hören':'Listening','Anhören':'Listen','Sprechen':'Speaking','Bis zu 30 Sekunden.':'Up to 30 seconds.','Schreiben':'Writing','Deine Antwort':'Your answer','Antwort gespeichert – ohne verbindliche Note.':'Answer saved without a grade.','Beispiel:':'Example:','Bewertung anfordern':'Request evaluation','Neuen A1-Test starten · 12 Aufgaben':'Start a new A1 test · 12 questions','A1-Test':'A1 test','Abgegeben – Bewertung ausstehend.':'Submitted – evaluation pending.','Ausstehende Antworten bewerten':'Evaluate pending answers'
};
const label=value=>english?(translations[value]??value):value;
const browser=await chromium.launch({headless:true,args:['--no-sandbox']});
try{
const page=await browser.newPage();page.setDefaultTimeout(15000);const errors=[];page.on('pageerror',e=>errors.push(e.message));const headers={Authorization:`Bearer ${token}`};
const get=async path=>{const r=await page.request.get(api+path,{headers});assert.equal(r.status(),200);return r.json()};
const post=async(path,data)=>{const r=await page.request.post(api+path,{headers,data});assert(r.status()<300,await r.text());return r.json()};
await page.goto(url);await page.evaluate(t=>localStorage.setItem('speech_token',t),token);await page.reload();await page.getByRole('button',{name:'A1-Kurs',exact:true}).click();
await page.goto(url);await page.evaluate(t=>localStorage.setItem('speech_token',t),token);await page.reload();if(english)await page.getByRole('combobox',{name:'Oberflächensprache'}).selectOption('en-US');await page.getByRole('button',{name:label('A1-Kurs'),exact:true}).click();
const cat=await get('/course/catalog');assert.equal(cat.task_mode,'bank');assert.equal(cat.grading_available,false);assert.equal(cat.bank.reduce((n,b)=>n+b.total,0),840);
const modules=page.getByRole('navigation',{name:'A1-Module'}).getByRole('button');await modules.nth(6).waitFor();assert.equal(await modules.count(),7);await modules.nth(1).click();
const areas=page.getByRole('group',{name:'Lernbereich'}),ex=page.getByRole('region',{name:'Aktuelle Kursaufgabe'});
async function next(area){await areas.getByRole('button',{name:area,exact:true}).click();const response=page.waitForResponse(r=>r.url().endsWith('/tasks/next')&&r.request().method()==='POST');await page.getByRole('button',{name:'Nächste Aufgabe',exact:true}).click();let j=await(await response).json();for(let n=0;n<40&&j.status!=='succeeded';n++){await page.waitForTimeout(150);j=await get('/course/jobs/'+j.id);if(j.status==='failed')throw new Error(j.error)}assert.equal(j.source,'curated');await ex.getByText('Aus geprüftem Aufgabenbestand',{exact:false}).waitFor();await page.getByRole('button',{name:'Nächste Aufgabe',exact:true}).waitFor({state:'visible'});return get('/course/tasks/'+j.task_id)}
let d=await next('Grammatik');const first=d.task.id;assert.equal(d.task.answer_key,undefined);await ex.getByRole('radio').first().check();await ex.getByRole('button',{name:'Antwort prüfen',exact:true}).click();await ex.getByRole('status').waitFor();d=await get('/course/tasks/'+first);await ex.locator('input[value="'+d.task.answer_key.correct_option_id+'"]').check();await ex.getByRole('button',{name:'Antwort prüfen',exact:true}).click();await ex.getByText('100 / 100 · Richtig',{exact:true}).waitFor();
await page.reload();await page.getByRole('button',{name:'A1-Kurs',exact:true}).click();await ex.getByText('100 / 100 · Richtig',{exact:true}).waitFor();d=await next('Grammatik');assert.notEqual(d.task.id,first);
await next('Wortschatz');await next('Lesen');await ex.locator('.course-passage').waitFor();d=await next('Hören');assert.equal(d.task.audio_text,undefined);await ex.getByRole('button',{name:'Anhören',exact:true}).waitFor();
await next('Sprechen');await ex.getByText('Bis zu 30 Sekunden.',{exact:false}).waitFor();d=await next('Schreiben');await ex.getByRole('textbox',{name:'Deine Antwort'}).fill('I have got a sister.');await ex.getByRole('button',{name:'Antwort prüfen',exact:true}).click();await ex.getByText('Antwort gespeichert – ohne verbindliche Note.',{exact:false}).waitFor();await ex.getByText('Beispiel:',{exact:false}).waitFor();
await page.reload();await page.getByRole('button',{name:'A1-Kurs',exact:true}).click();await ex.getByText('Antwort gespeichert – ohne verbindliche Note.',{exact:false}).waitFor();assert(await ex.getByRole('button',{name:'Bewertung anfordern',exact:true}).isDisabled());
await modules.nth(6).click();await page.getByRole('button',{name:'Neuen A1-Test starten · 12 Aufgaben',exact:true}).click();const examPanel=page.getByRole('region',{name:'A1-Test'});await examPanel.getByRole('button').nth(11).waitFor();let catalog=await get('/course/catalog'),exam=await get('/course/exams/'+catalog.exams[0].id);assert.equal(exam.tasks.length,12);
const modules=page.getByRole('navigation',{name:label('A1-Module')}).getByRole('button');await modules.nth(6).waitFor();assert.equal(await modules.count(),7);await modules.nth(1).click();
const areas=page.getByRole('group',{name:label('Lernbereich')}),ex=page.getByRole('region',{name:label('Aktuelle Kursaufgabe')});
async function next(area){await areas.getByRole('button',{name:label(area),exact:true}).click();const response=page.waitForResponse(r=>r.url().endsWith('/tasks/next')&&r.request().method()==='POST');await page.getByRole('button',{name:label('Nächste Aufgabe'),exact:true}).click();let j=await(await response).json();for(let n=0;n<40&&j.status!=='succeeded';n++){await page.waitForTimeout(150);j=await get('/course/jobs/'+j.id);if(j.status==='failed')throw new Error(j.error)}assert.equal(j.source,'curated');await ex.getByText(label('Aus geprüftem Aufgabenbestand'),{exact:false}).waitFor();await page.getByRole('button',{name:label('Nächste Aufgabe'),exact:true}).waitFor({state:'visible'});return get('/course/tasks/'+j.task_id)}
let d=await next('Grammatik');const first=d.task.id;assert.equal(d.task.answer_key,undefined);assert.equal(await ex.getByRole('heading',{level:2}).innerText(),d.task.prompt);assert.deepEqual(await ex.locator('.course-option').allTextContents(),d.task.options.map(o=>o.label));await ex.getByRole('radio').first().check();await ex.getByRole('button',{name:label('Antwort prüfen'),exact:true}).click();await ex.getByRole('status').waitFor();d=await get('/course/tasks/'+first);await ex.locator('input[value="'+d.task.answer_key.correct_option_id+'"]').check();await ex.getByRole('button',{name:label('Antwort prüfen'),exact:true}).click();await ex.getByText(label('100 / 100 · Richtig'),{exact:true}).waitFor();
await page.reload();await page.getByRole('button',{name:label('A1-Kurs'),exact:true}).click();await ex.getByText(label('100 / 100 · Richtig'),{exact:true}).waitFor();d=await next('Grammatik');assert.notEqual(d.task.id,first);
await next('Wortschatz');await next('Lesen');await ex.locator('.course-passage').waitFor();d=await next('Hören');assert.equal(d.task.audio_text,undefined);await ex.getByRole('button',{name:label('Anhören'),exact:true}).waitFor();
await next('Sprechen');await ex.getByText(label('Bis zu 30 Sekunden.'),{exact:false}).waitFor();d=await next('Schreiben');await ex.getByRole('textbox',{name:label('Deine Antwort')}).fill('I have got a sister.');if(english){await page.getByRole('combobox',{name:'Interface language'}).selectOption('de-DE');const germanExercise=page.getByRole('region',{name:'Aktuelle Kursaufgabe'});await germanExercise.getByRole('textbox',{name:'Deine Antwort'}).waitFor();assert.equal(await germanExercise.getByRole('textbox',{name:'Deine Antwort'}).inputValue(),'I have got a sister.');assert.equal(await germanExercise.getByRole('heading',{level:2}).innerText(),d.task.prompt);await page.getByRole('combobox',{name:'Oberflächensprache'}).selectOption('en-US');}await ex.getByRole('button',{name:label('Antwort prüfen'),exact:true}).click();await ex.getByText(label('Antwort gespeichert – ohne verbindliche Note.'),{exact:false}).waitFor();await ex.getByText(label('Beispiel:'),{exact:false}).waitFor();
await page.reload();await page.getByRole('button',{name:label('A1-Kurs'),exact:true}).click();await ex.getByText(label('Antwort gespeichert – ohne verbindliche Note.'),{exact:false}).waitFor();assert(await ex.getByRole('button',{name:label('Bewertung anfordern'),exact:true}).isDisabled());
await modules.nth(6).click();await page.getByRole('button',{name:label('Neuen A1-Test starten · 12 Aufgaben'),exact:true}).click();const examPanel=page.getByRole('region',{name:label('A1-Test')});await examPanel.getByRole('button').nth(11).waitFor();let catalog=await get('/course/catalog'),exam=await get('/course/exams/'+catalog.exams[0].id);assert.equal(exam.tasks.length,12);
const wav=Buffer.alloc(44+8000);wav.write('RIFF');wav.writeUInt32LE(wav.length-8,4);wav.write('WAVE',8);wav.write('fmt ',12);wav.writeUInt32LE(16,16);wav.writeUInt16LE(1,20);wav.writeUInt16LE(1,22);wav.writeUInt32LE(16000,24);wav.writeUInt32LE(32000,28);wav.writeUInt16LE(2,32);wav.writeUInt16LE(16,34);wav.write('data',36);wav.writeUInt32LE(8000,40);
for(const t of exam.tasks){assert.equal(t.answer_key,undefined);assert.equal(t.audio_text,undefined);const request_id=crypto.randomUUID().replaceAll('-','');if(['repeat_sentence','free_speech'].includes(t.kind)){const r=await page.request.post(api+'/course/tasks/'+t.id+'/audio-attempts',{headers,multipart:{request_id,audio:{name:'fixture.wav',mimeType:'audio/wav',buffer:wav}}});assert.equal(r.status(),202,await r.text())}else await post('/course/tasks/'+t.id+'/attempts',{request_id,answer:t.kind==='choice'?t.options[0].id:'I have got a sister.'})}
exam=await get('/course/exams/'+exam.id);assert.equal(exam.status,'submitted');assert.equal(exam.score,undefined);for(const t of exam.tasks){assert.equal(t.answer_key,undefined);assert.equal(t.audio_text,undefined);const detail=await get('/course/tasks/'+t.id);assert.equal(detail.task.answer_key,undefined)}for(const a of exam.attempts)assert.equal(a.evaluation,undefined);
await page.reload();await page.getByRole('button',{name:'A1-Kurs',exact:true}).click();await examPanel.getByText('Abgegeben – Bewertung ausstehend.',{exact:false}).waitFor();assert(await examPanel.getByRole('button',{name:'Ausstehende Antworten bewerten',exact:true}).isDisabled());
await page.reload();await page.getByRole('button',{name:label('A1-Kurs'),exact:true}).click();await examPanel.getByText(label('Abgegeben – Bewertung ausstehend.'),{exact:false}).waitFor();assert(await examPanel.getByRole('button',{name:label('Ausstehende Antworten bewerten'),exact:true}).isDisabled());
const usage=await get('/admin/ai/usage');assert.equal(usage.total,0);assert.deepEqual(errors,[]);
console.log('PASS: 840 bank tasks; six renderers; source/privacy; answer/reload; ungraded open answer; submitted frozen exam; no model calls or browser errors. Audio uses an explicit local fixture.');
console.log((english?'English: ':'German: ')+'PASS: 840 bank tasks; six renderers; source/privacy; answer/reload; ungraded open answer; submitted frozen exam; no model calls or browser errors. Audio uses an explicit local fixture.');
}finally{await browser.close()}
})().catch(e=>{console.error(e);process.exitCode=1});
+118
View File
@@ -0,0 +1,118 @@
// Local API/PostgreSQL fixture only. No paid provider calls or real microphone.
const { chromium } = require(process.env.PLAYWRIGHT_MODULE || 'playwright');
const assert = require('node:assert/strict');
const crypto = require('node:crypto');
(async () => {
const api = process.env.AI_E2E_API, url = process.env.AI_E2E_URL, adminToken = process.env.AI_E2E_TOKEN;
assert(api && url && adminToken);
const browser = await chromium.launch({ headless: true, args: ['--no-sandbox'] });
try {
const page = await browser.newPage(); page.setDefaultTimeout(15000);
const errors = []; page.on('pageerror', error => errors.push(error.message));
const registration = await page.request.post(api + '/auth/register', { data: { email: `variants-${Date.now()}@example.test`, password: 'local-variant-test-password', ui_language: 'en-US', target_language: 'en-US' } });
assert.equal(registration.status(), 201);
const account = await registration.json(), headers = { Authorization: `Bearer ${account.token}` };
const id = () => crypto.randomUUID().replaceAll('-', '');
const get = async path => { const response = await page.request.get(api + path, { headers }); assert.equal(response.status(), 200, await response.text()); return response.json(); };
const explanation = () => page.getByRole('combobox', { name: 'Exercise explanation language' });
const exercise = page.getByRole('region', { name: 'Current course exercise' });
async function waitJob(job) {
for (let count = 0; count < 80 && ['queued', 'running'].includes(job.status); count++) {
await page.waitForTimeout(100); job = await get('/course/jobs/' + job.id);
}
return job;
}
async function next(skill) {
await page.getByRole('group', { name: 'Learning area' }).getByRole('button', { name: skill, exact: true }).click();
const response = page.waitForResponse(r => r.url().endsWith('/tasks/next') && r.request().method() === 'POST');
await page.getByRole('button', { name: 'Next exercise', exact: true }).click();
const job = await waitJob(await (await response).json()); assert.equal(job.status, 'succeeded', job.error);
const detail = await get('/course/tasks/' + job.task_id);
await exercise.getByRole('heading', { level: 2, name: detail.task.instruction, exact: true }).waitFor();
await page.getByRole('button', { name: 'Next exercise', exact: true }).waitFor();
assert.equal(detail.task.instruction_language, 'en-US'); assert(detail.task.content_revision); assert(detail.task.variant_id);
assert.equal(detail.task.answer_key, undefined); assert.equal(detail.task.audio_text, undefined); assert.equal(detail.task.evidence_task_id, undefined);
return detail.task;
}
await page.goto(url); await page.evaluate(token => localStorage.setItem('speech_token', token), account.token); await page.reload();
await page.getByRole('button', { name: 'A1 course', exact: true }).click();
await explanation().selectOption('en-US');
await page.getByText('Preferred explanation language: English.', { exact: true }).waitFor();
let catalog = await get('/course/catalog');
assert.equal(catalog.modules[0].title, 'Greetings & introductions');
assert.equal(catalog.instruction_language, 'en-US'); assert.equal(catalog.exam_available, false);
assert.equal(catalog.bank.reduce((sum, item) => sum + item.total, 0), 12);
assert(catalog.bank.every(item => item.module_id === 'a1_introductions_v1' && item.total === 2));
const grammar = await next('Grammar');
await exercise.locator('.course-passage').getByText(grammar.stimulus.text, { exact: true }).waitFor();
assert.equal(grammar.stimulus.role, 'target'); assert.equal(grammar.stimulus.language, 'en-US');
for (let n = 0; n < 2; n++) {
const task = await next('Vocabulary');
assert.equal(task.canonical_task_id, task.variant_id, 'Adapted meanings require a separate canonical identity');
assert(task.options.every(option => option.language === 'en-US' && !['hello', 'name'].includes(option.label.toLowerCase())));
assert(!task.options.some(option => ['hallo', 'tschüss', 'Name', 'Alter', 'Wohnort'].includes(option.label)));
}
await next('Reading'); await exercise.locator('.course-passage').waitFor();
const listening = await next('Listening'); assert.equal(listening.stimulus, undefined);
await exercise.getByRole('button', { name: 'Listen', exact: true }).waitFor();
assert.equal(await exercise.getByText('Listening transcript:', { exact: false }).count(), 0);
for (let n = 0; n < 2; n++) {
const task = await next('Speaking');
assert(['repeat_sentence', 'free_speech'].includes(task.kind));
await exercise.getByRole('button', { name: 'Record', exact: true }).waitFor();
assert.equal(Boolean(task.reference_text), task.kind === 'repeat_sentence');
}
const writing = await next('Writing');
assert.equal(writing.kind, 'short_text'); assert.equal(writing.canonical_task_id, writing.variant_id);
assert(!writing.instruction.toLowerCase().includes('translate')); assert.equal(writing.stimulus.role, 'context');
await exercise.getByRole('textbox', { name: 'Your answer' }).fill('I am Anna.');
await exercise.getByRole('button', { name: 'Check answer', exact: true }).click();
await exercise.getByText('Answer saved without a grade.', { exact: false }).waitFor();
let saved = await get('/course/tasks/' + writing.id);
assert.equal(saved.attempt.status, 'ungraded'); assert.equal(saved.attempt.answer, 'I am Anna.'); assert.equal(saved.attempt.evaluation, undefined);
assert.equal(saved.task.answer_key.reference_answer_language, 'en-US');
const frozen = saved.task;
await explanation().selectOption('de-DE');
await page.getByText('Preferred explanation language: German.', { exact: true }).waitFor();
await exercise.getByText('This exercise uses: English', { exact: true }).waitFor();
saved = await get('/course/tasks/' + writing.id); assert.deepEqual(saved.task, frozen);
await page.reload(); await page.getByRole('button', { name: 'A1 course', exact: true }).click();
await exercise.getByRole('heading', { name: writing.instruction, exact: true }).waitFor();
saved = await get('/course/tasks/' + writing.id); assert.equal(saved.attempt.answer, 'I am Anna.'); assert.deepEqual(saved.task, frozen);
const currentUser = await get('/me'); assert.equal(currentUser.user.ui_language, 'en-US'); assert.deepEqual(currentUser.profile, account.profile);
await explanation().selectOption('en-US');
await page.getByText('Preferred explanation language: English.', { exact: true }).waitFor();
const freeWriting = await next('Writing'); assert.equal(freeWriting.kind, 'free_text');
const modules = page.getByRole('navigation', { name: 'A1 modules' }).getByRole('button');
await modules.nth(1).click();
await page.getByText('This area has no reviewed exercises', { exact: false }).waitFor();
assert(await page.getByRole('button', { name: 'Next exercise', exact: true }).isDisabled());
const missing = await page.request.post(api + '/course/modules/a1_family_v1/tasks/next', { headers, data: { request_id: id(), skill: 'grammar' } });
assert.equal(missing.status(), 202); const failed = await waitJob(await missing.json()); assert.equal(failed.status, 'failed'); assert.equal(failed.task_id, undefined);
assert.equal((await get('/course/modules/a1_family_v1/tasks')).tasks.length, 0);
await modules.nth(6).click();
assert(await page.getByRole('button', { name: 'Start a new A1 test · 12 questions', exact: true }).isDisabled());
const unsupportedExam = await page.request.post(api + '/course/exams', { headers, data: { request_id: id() } });
assert.equal(unsupportedExam.status(), 409); assert.equal((await unsupportedExam.json()).code, 'course_variant_unavailable');
catalog = await get('/course/catalog'); assert.equal(catalog.exams.length, 0);
// Reusing an existing German test request must keep that frozen session.
await page.request.put(api + '/course/instruction-language', { headers, data: { instruction_language: 'de-DE' } });
const examRequest = id();
const germanExamResponse = await page.request.post(api + '/course/exams', { headers, data: { request_id: examRequest } });
assert.equal(germanExamResponse.status(), 202);
const germanExam = await germanExamResponse.json();
assert.equal((await waitJob(germanExam.job)).status, 'succeeded');
await page.request.put(api + '/course/instruction-language', { headers, data: { instruction_language: 'en-US' } });
const replayResponse = await page.request.post(api + '/course/exams', { headers, data: { request_id: examRequest } });
assert.equal(replayResponse.status(), 202);
const replay = await replayResponse.json(); assert.equal(replay.exam.id, germanExam.exam.id); assert.equal(replay.job.id, germanExam.job.id); assert.equal(replay.job.instruction_language, 'de-DE');
const unsupported = await page.request.put(api + '/course/instruction-language', { headers, data: { instruction_language: 'fr-FR' } });
assert.equal(unsupported.status(), 409); assert.equal((await unsupported.json()).code, 'course_variant_unavailable');
assert.equal((await get('/me')).user.instruction_language, 'en-US');
const anonymous = await page.request.put(api + '/course/instruction-language', { data: { instruction_language: 'de-DE' } }); assert.equal(anonymous.status(), 401);
const usage = await page.request.get(api + '/admin/ai/usage', { headers: { Authorization: `Bearer ${adminToken}` } }); assert.equal((await usage.json()).total, 0);
assert.deepEqual(errors, []);
console.log('PASS: explanation choice; 12 structured pilot variants; five renderers/six skills; independent UI language; adapted vocabulary/writing; frozen answers/reload; no German fallback; unavailable English exam; auth; no model calls.');
} finally { await browser.close(); }
})().catch(error => { console.error(error); process.exitCode = 1; });
+141
View File
@@ -0,0 +1,141 @@
const { chromium } = require(process.env.PLAYWRIGHT_MODULE || 'playwright');
const assert = require('node:assert/strict');
const fs = require('node:fs');
(async () => {
const api = process.env.AI_E2E_API, token = process.env.AI_E2E_TOKEN, url = process.env.AI_E2E_URL;
assert(api && token && url);
const german = JSON.parse(fs.readFileSync('src/i18n/de-DE.json', 'utf8'));
const english = JSON.parse(fs.readFileSync('src/i18n/en-US.json', 'utf8'));
assert.deepEqual(Object.keys(german).sort(), Object.keys(english).sort());
for (const key of Object.keys(german)) {
assert(german[key] && english[key], `Empty translation: ${key}`);
assert.deepEqual(german[key].match(/\{\w+\}/g)?.sort() ?? [], english[key].match(/\{\w+\}/g)?.sort() ?? [], key);
}
const browser = await chromium.launch({ headless: true, args: ['--no-sandbox'] });
try {
const page = await browser.newPage();
page.setDefaultTimeout(15000);
const errors = [];
page.on('pageerror', (error) => errors.push(error.message));
const headers = { Authorization: `Bearer ${token}` };
const me = async () => {
const response = await page.request.get(api + '/me', { headers });
assert.equal(response.status(), 200);
return response.json();
};
const patch = async (data) => {
const response = await page.request.patch(api + '/me/preferences', { headers, data });
assert.equal(response.status(), 200, await response.text());
return response.json();
};
await page.goto(url);
await page.getByRole('heading', { name: 'Einloggen', exact: true }).waitFor();
await page.getByRole('combobox', { name: 'Oberflächensprache' }).selectOption('en-US');
await page.getByRole('heading', { name: 'Log in', exact: true }).waitFor();
assert.equal(await page.locator('html').getAttribute('lang'), 'en-US');
await page.reload();
await page.getByRole('heading', { name: 'Log in', exact: true }).waitFor();
await page.getByRole('button', { name: 'Create account', exact: true }).click();
await page.getByText('The English course currently uses German task instructions and explanations.').waitFor();
await page.setViewportSize({ width: 360, height: 780 });
assert(await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth), 'Registration overflows on a narrow screen');
await page.setViewportSize({ width: 1280, height: 800 });
const email = `languages-${Date.now()}@example.test`, password = 'local-language-test-password';
await page.getByRole('textbox', { name: 'Email', exact: true }).fill(email);
await page.getByLabel('Password', { exact: true }).fill(password);
const registration = page.waitForResponse((r) => r.url().endsWith('/auth/register') && r.request().method() === 'POST');
await page.getByRole('button', { name: 'Register', exact: true }).click();
const registered = await (await registration).json();
assert.equal(registered.user.ui_language, 'en-US');
assert.equal(registered.user.instruction_language, 'de-DE');
await page.getByRole('button', { name: 'Today', exact: true }).waitFor();
await page.getByText('Preferred explanation language: German.', { exact: true }).waitFor();
await page.getByRole('heading', { name: 'A1 pronunciation practice', exact: true }).waitFor();
await page.getByRole('button', { name: 'Log out', exact: true }).click();
await page.getByRole('combobox', { name: 'Interface language' }).selectOption('de-DE');
await page.getByRole('textbox', { name: 'E-Mail', exact: true }).fill(email);
await page.getByLabel('Passwort', { exact: true }).fill(password);
await page.getByRole('button', { name: 'Einloggen', exact: true }).click();
await page.getByRole('button', { name: 'Today', exact: true }).waitFor();
await page.getByRole('button', { name: 'Progress', exact: true }).click();
await page.getByRole('heading', { name: 'Progress', exact: true }).waitFor();
await page.getByRole('heading', { name: 'Your pronunciation profile · en-US', exact: true }).waitFor();
await page.getByText('Your new pronunciation profile needs confirmed measurements.', { exact: false }).waitFor();
await page.getByRole('button', { name: 'Log out', exact: true }).click();
const original = await me();
await page.evaluate((value) => localStorage.setItem('speech_token', value), token);
await page.reload();
await page.getByRole('combobox', { name: 'Oberflächensprache' }).selectOption('en-US');
await page.getByRole('button', { name: 'Pronunciation', exact: true }).click();
await page.getByRole('button', { name: 'Record', exact: true }).waitFor();
const sentence = await page.locator('.target-text').innerText();
await page.getByRole('combobox', { name: 'Interface language' }).selectOption('de-DE');
await page.getByRole('button', { name: 'Aufnehmen', exact: true }).waitFor();
assert.equal(await page.locator('.target-text').innerText(), sentence);
await page.getByRole('combobox', { name: 'Oberflächensprache' }).selectOption('en-US');
await page.getByRole('button', { name: 'Conversation', exact: true }).click();
await page.getByRole('button', { name: 'Start', exact: true }).click();
const reply = page.getByRole('textbox', { name: 'Your conversation reply', exact: true });
await reply.fill('My name is Mira.');
await page.getByRole('combobox', { name: 'Interface language' }).selectOption('de-DE');
assert.equal(await page.getByRole('textbox', { name: 'Deine Dialogantwort', exact: true }).inputValue(), 'My name is Mira.');
await page.getByRole('combobox', { name: 'Oberflächensprache' }).selectOption('en-US');
const turnResponse = page.waitForResponse(r => /\/conversation\/[^/]+\/turn$/.test(r.url()));
await page.getByRole('button', { name: 'Send', exact: true }).click();
assert.equal((await turnResponse).request().postDataJSON().text, 'My name is Mira.');
await page.locator('.bubble.learner').getByText('My name is Mira.', { exact: true }).waitFor();
await page.getByRole('button', { name: 'Administration', exact: true }).click();
await page.getByRole('heading', { name: 'AI settings and usage', exact: true }).waitFor();
const action = page.getByLabel('Action').first();
await action.selectOption('next_exercise');
await page.getByRole('option', { name: 'Pronunciation generation', exact: true }).first().waitFor({ state: 'attached' });
await page.getByLabel('Monthly limit in USD', { exact: true }).fill('0.12');
await page.getByRole('combobox', { name: 'Interface language' }).selectOption('de-DE');
assert.equal(await page.getByLabel('Monatslimit in USD', { exact: true }).inputValue(), '0.12');
await page.getByRole('combobox', { name: 'Oberflächensprache' }).selectOption('en-US');
assert.equal(await page.getByLabel('Monthly limit in USD', { exact: true }).inputValue(), '0.12');
const settings = await (await page.request.get(api + '/admin/ai/settings', { headers })).json();
assert.equal(settings.budget.monthly_limit_microusd, 0, 'Changing UI language must not save budget edits');
await page.getByLabel('Monthly limit in USD', { exact: true }).fill('0');
await page.getByRole('button', { name: 'Save budget', exact: true }).click();
await page.getByRole('status').filter({ hasText: 'Budget saved.' }).waitFor();
await page.getByRole('combobox', { name: 'Interface language' }).selectOption('de-DE');
await page.getByRole('status').filter({ hasText: 'Budget gespeichert.' }).waitFor();
await page.getByRole('combobox', { name: 'Oberflächensprache' }).selectOption('en-US');
await page.getByRole('status').filter({ hasText: 'Budget saved.' }).waitFor();
await page.getByRole('button', { name: 'A1 course', exact: true }).click();
await page.getByRole('button', { name: 'Open the original fixed course', exact: true }).click();
await page.getByText('Guided A1 course', { exact: true }).waitFor();
await page.getByRole('region', { name: 'Module progress', exact: true }).waitFor();
await patch({ ui_language: original.user.ui_language });
const learningProfile = await patch({ target_language: 'es-ES', cefr_level: 'A2', daily_goal_minutes: 23 });
await page.evaluate((value) => localStorage.setItem('speech_token', value), token);
await page.reload();
const picker = page.getByRole('combobox', { name: 'Oberflächensprache' });
await picker.waitFor();
await picker.selectOption('en-US');
await page.getByRole('button', { name: 'Today', exact: true }).waitFor();
let account = await me();
assert.equal(account.user.ui_language, 'en-US');
assert.equal(account.user.instruction_language, original.user.instruction_language);
assert.deepEqual(account.profile, learningProfile);
await page.reload();
await page.getByRole('combobox', { name: 'Interface language' }).waitFor();
assert.equal(await page.locator('html').getAttribute('lang'), 'en-US');
await page.route('**/me/preferences', (route) => route.fulfill({ status: 503, contentType: 'application/json', body: '{"error":"fixture unavailable"}' }));
await page.getByRole('combobox', { name: 'Interface language' }).selectOption('de-DE');
await page.getByRole('alert').filter({ hasText: 'Unable to save the language.' }).waitFor();
assert.equal(await page.getByRole('combobox', { name: 'Interface language' }).inputValue(), 'en-US');
account = await me();
assert.equal(account.user.ui_language, 'en-US');
assert.deepEqual(account.profile, learningProfile);
await page.unroute('**/me/preferences');
const rejected = await page.request.patch(api + '/me/preferences', { headers, data: { ui_language: 'xx-XX' } });
assert.equal(rejected.status(), 400);
await patch({ ui_language: original.user.ui_language, target_language: original.profile.target_language, cefr_level: original.profile.cefr_level, daily_goal_minutes: original.profile.daily_goal_minutes });
assert.deepEqual(errors, []);
console.log('PASS: catalog parity; language before login; registration/login; account persistence; independent instructions; pronunciation, conversation, admin and legacy controls; unsaved input survives language switches; partial PATCH preserves course/level/goal; rejected saves; no browser errors.');
} finally { await browser.close(); }
})().catch((error) => { console.error(error); process.exitCode = 1; });