Thematische Lernwege im A1-Kurs standardmäßig empfehlen
Die bisherige Auswahl verbindet Lernbereiche nicht thematisch und kann freies Sprechen ohne passende Vorbereitung anbieten. Der Bankbetrieb empfiehlt nun 60 redaktionell verknüpfte Themen in sechs Lernmodulen: Hören, Wortschatz, Lesen, Nachsprechen, Grammatik, angeleitetes und freies Schreiben, freies Sprechen. Speichert die Lernwegposition getrennt von Leistungsnachweisen. Unbeantwortete Schritte bleiben empfohlen und sind explizit überspringbar; nach einer tatsächlich bewerteten schwachen Antwort gibt es höchstens eine Wiederholung ohne Notensperre. Bereichswahl, Muttersprache, historische Aufgaben und A1-Tests bleiben unabhängig. Deutsch und Russisch zeigen Thema und Schritt; vorhandene Aufgabeninhalte und Bewertungen werden nicht umgeschrieben. Keine zusätzlichen Modellaufrufe. Validierung: Go-Race-Suite mit eigener lokaler PostgreSQL-Testdatenbank, go vet, Web-Build, Bank-/Varianten-/Sequenzaudits und lokale Kurs-/Sprachen-/Admin-Smokes. Regressionsfall: passendes Schreiben vor freiem Sprechen über zwei Freunde. Keine Live-Anbieterprüfung oder Produktionsänderung.
This commit is contained in:
@@ -156,22 +156,23 @@ type CourseBrief struct {
|
||||
Reason string `json:"reason"`
|
||||
}
|
||||
type CourseJob struct {
|
||||
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:"-"`
|
||||
Recommendation *SequenceRecommendation `json:"recommendation,omitempty"`
|
||||
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"`
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
package domain
|
||||
|
||||
// Learning sequences link immutable tasks; they do not redefine their answers or
|
||||
// turn a submitted/ungraded answer into evidence of mastery.
|
||||
type LearningSequence struct {
|
||||
ID string `json:"id"`
|
||||
ModuleID string `json:"module_id"`
|
||||
Titles map[string]string `json:"titles"`
|
||||
Steps []LearningSequenceStep `json:"steps"`
|
||||
}
|
||||
type LearningSequenceStep struct {
|
||||
Phase string `json:"phase"`
|
||||
BankEntryID string `json:"bank_entry_id"`
|
||||
}
|
||||
type SequenceRecommendation struct {
|
||||
Review bool `json:"review"`
|
||||
NeedsAnswer bool `json:"needs_answer"`
|
||||
Revision string `json:"revision"`
|
||||
SequenceID string `json:"sequence_id,omitempty"`
|
||||
Title string `json:"title,omitempty"`
|
||||
Phase string `json:"phase,omitempty"`
|
||||
Step int `json:"step"`
|
||||
Steps int `json:"steps"`
|
||||
Topic int `json:"topic"`
|
||||
Topics int `json:"topics"`
|
||||
TaskID string `json:"task_id,omitempty"`
|
||||
Complete bool `json:"complete"`
|
||||
SkippedSteps int `json:"skipped_steps"`
|
||||
}
|
||||
@@ -124,7 +124,20 @@ func (s *Server) adaptiveCatalog(w http.ResponseWriter, r *http.Request) {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"native_language": user.ExplanationLanguage(), "native_languages": []string{"de-DE", "ru-RU"}, "instruction_language": user.ExplanationLanguage(), "instruction_languages": instructionLanguages, "exam_available": s.course.Mode != "bank" || bankExamInventoryAvailable(inventory), "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})
|
||||
recommendations := map[string]*domain.SequenceRecommendation{}
|
||||
if s.course.Mode == "bank" {
|
||||
for _, module := range snap.Modules {
|
||||
recommendation, err := s.course.Repo.SequenceRecommendation(r.Context(), user.ID, p.TargetLanguage, module.ID, user.ExplanationLanguage())
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
if recommendation != nil {
|
||||
recommendations[module.ID] = recommendation
|
||||
}
|
||||
}
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"sequence_recommendations": recommendations, "native_language": user.ExplanationLanguage(), "native_languages": []string{"de-DE", "ru-RU"}, "instruction_language": user.ExplanationLanguage(), "instruction_languages": instructionLanguages, "exam_available": s.course.Mode != "bank" || bankExamInventoryAvailable(inventory), "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)
|
||||
@@ -132,13 +145,14 @@ func (s *Server) adaptiveNext(w http.ResponseWriter, r *http.Request) {
|
||||
return
|
||||
}
|
||||
var input struct {
|
||||
RequestID string `json:"request_id"`
|
||||
Skill string `json:"skill"`
|
||||
RequestID string `json:"request_id"`
|
||||
SkipTaskID string `json:"skip_task_id"`
|
||||
Skill string `json:"skill"`
|
||||
}
|
||||
if !adaptiveJSON(w, r, &input) {
|
||||
return
|
||||
}
|
||||
if !courseRequestIDPattern.MatchString(input.RequestID) || !validCourseSkill(input.Skill) {
|
||||
if !courseRequestIDPattern.MatchString(input.RequestID) || !validCourseSkill(input.Skill) || (input.SkipTaskID != "" && (input.Skill != "" || len(input.SkipTaskID) > 120 || s.course.Mode != "bank")) {
|
||||
writeError(w, 400, errors.New("invalid request ID or skill"))
|
||||
return
|
||||
}
|
||||
@@ -146,7 +160,7 @@ func (s *Server) adaptiveNext(w http.ResponseWriter, r *http.Request) {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
j, err := s.course.Repo.Enqueue(r.Context(), currentUserID(r), p.TargetLanguage, "next", r.PathValue("id"), input.Skill, "", input.RequestID)
|
||||
j, err := s.course.Repo.Enqueue(r.Context(), currentUserID(r), p.TargetLanguage, "next", r.PathValue("id"), input.Skill, input.SkipTaskID, input.RequestID)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
|
||||
@@ -405,6 +405,7 @@ func TestBankBrowserSmoke(t *testing.T) {
|
||||
for _, check := range []struct{ script, language string }{
|
||||
{"tests/languages.e2e.cjs", "de-DE"},
|
||||
{"tests/course-variants.e2e.cjs", "ru-RU"},
|
||||
{"tests/course-sequences.e2e.cjs", "de-DE"},
|
||||
{"tests/course-bank.e2e.cjs", "de-DE"},
|
||||
{"tests/course-bank.e2e.cjs", "ru-RU"},
|
||||
} {
|
||||
|
||||
@@ -0,0 +1,195 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"speech-learning-api/internal/domain"
|
||||
"speech-learning-api/internal/store"
|
||||
)
|
||||
|
||||
func TestThematicLearningPathAndFrozenProgress(t *testing.T) {
|
||||
for _, native := range []string{"de-DE", "ru-RU"} {
|
||||
t.Run(native, func(t *testing.T) {
|
||||
db, profiles := adaptiveTestDB(t)
|
||||
ctx := context.Background()
|
||||
user, err := profiles.CreateUser(ctx, store.NewID("sequence")+"@example.test", "hash", native)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err = profiles.CreateLearnerProfile(ctx, user.ID, "en-US", "A1", 17); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
engine := NewCourseEngine(store.NewAdaptiveStore(db), profiles, nil, nil)
|
||||
engine.Mode = "bank"
|
||||
module := "a1_introductions_v1"
|
||||
requests := map[string]string{}
|
||||
run := func(skill, skip string) (domain.AdaptiveTask, domain.CourseJob) {
|
||||
t.Helper()
|
||||
request := store.NewID("sequence-request")
|
||||
job, err := engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", module, skill, skip, request)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
job, err = engine.Repo.Claim(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
task, err := engine.Process(ctx, job)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err = engine.Repo.Finish(ctx, job, task, ""); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
saved, err := engine.Repo.Job(ctx, user.ID, "en-US", job.ID)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
requests[saved.ID] = request
|
||||
return *task, saved
|
||||
}
|
||||
answer := func(task domain.AdaptiveTask, correct bool) domain.AdaptiveAttempt {
|
||||
t.Helper()
|
||||
text := task.AnswerKey.ReferenceAnswer
|
||||
if task.Kind == "choice" {
|
||||
text = task.AnswerKey.CorrectOptionID
|
||||
if !correct {
|
||||
for _, o := range task.Options {
|
||||
if o.ID != text {
|
||||
text = o.ID
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
var speech *domain.PronunciationResult
|
||||
if task.Skill == "speaking" {
|
||||
speech = &domain.PronunciationResult{Provider: "azure", RecognizedText: text, OverallScore: 90}
|
||||
}
|
||||
attempt, _, err := engine.Submit(ctx, user.ID, "en-US", task.ID, store.NewID("sequence-answer"), text, speech)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return attempt
|
||||
}
|
||||
first, job := run("", "")
|
||||
if first.Skill != "listening" || first.InstructionLanguage != native || job.Recommendation == nil || job.Recommendation.Step != 1 {
|
||||
t.Fatal(first, job)
|
||||
}
|
||||
var frozen []byte
|
||||
if err = db.QueryRowContext(ctx, `SELECT data FROM course_v2_tasks WHERE id=$1`, first.ID).Scan(&frozen); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
again, _ := run("", "")
|
||||
if again.ID != first.ID {
|
||||
t.Fatal("unanswered step silently bypassed")
|
||||
}
|
||||
// A graded mistake offers one bounded review, even with an unchanged task ID.
|
||||
answer(first, false)
|
||||
repeated, reviewJob := run("", "")
|
||||
if repeated.ID != first.ID || !reviewJob.Recommendation.Review {
|
||||
t.Fatal("missing bounded review", reviewJob)
|
||||
}
|
||||
blocked, _ := run("", "")
|
||||
if blocked.ID != first.ID {
|
||||
t.Fatal("old answer passed the new review")
|
||||
}
|
||||
answer(repeated, false)
|
||||
next, nextJob := run("", "")
|
||||
if next.ID == first.ID || nextJob.Recommendation.Step != 2 {
|
||||
t.Fatal("grade became a permanent gate", nextJob)
|
||||
}
|
||||
// Manual free speaking remains available and never moves the thematic cursor.
|
||||
before, _ := engine.Repo.SequenceRecommendation(ctx, user.ID, "en-US", module, native)
|
||||
manual, _ := run("speaking", "")
|
||||
if manual.Skill != "speaking" {
|
||||
t.Fatal(manual)
|
||||
}
|
||||
after, _ := engine.Repo.SequenceRecommendation(ctx, user.ID, "en-US", module, native)
|
||||
if before.Step != after.Step || before.SequenceID != after.SequenceID {
|
||||
t.Fatal("manual choice moved path")
|
||||
}
|
||||
// Explicit skipping is separate from evidence and replaying a request is stable.
|
||||
skipped, skipJob := run("", next.ID)
|
||||
if skipJob.Recommendation.SkippedSteps != 1 || skipJob.Recommendation.Step != 3 {
|
||||
t.Fatal(skipJob)
|
||||
}
|
||||
replayed, err := engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", module, "", next.ID, requests[skipJob.ID])
|
||||
if err != nil || replayed.TaskID != skipped.ID || replayed.Recommendation.Step != 3 {
|
||||
t.Fatal("request replay advanced path", err)
|
||||
}
|
||||
|
||||
wrong, err := engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", module, "", "another-users-task", store.NewID("skip-other"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
wrong, err = engine.Repo.Claim(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err = engine.Process(ctx, wrong); err == nil {
|
||||
t.Fatal("stale/foreign skip accepted")
|
||||
}
|
||||
if err = engine.Repo.Finish(ctx, wrong, nil, "expected conflict"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Changing native language preserves the thematic position and frozen content.
|
||||
other := "de-DE"
|
||||
if native == other {
|
||||
other = "ru-RU"
|
||||
}
|
||||
if _, err = profiles.UpdatePreferences(ctx, user.ID, other, "", "", 0); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
changed, err := engine.Repo.SequenceRecommendation(ctx, user.ID, "en-US", module, other)
|
||||
if err != nil || changed.Step != 3 || changed.SkippedSteps != 1 || changed.Title == before.Title {
|
||||
t.Fatal(changed, err)
|
||||
}
|
||||
if err = profiles.Init(ctx); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var current []byte
|
||||
if err = db.QueryRowContext(ctx, `SELECT data FROM course_v2_tasks WHERE id=$1`, first.ID).Scan(¤t); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !bytes.Equal(frozen, current) {
|
||||
t.Fatal("frozen task edited")
|
||||
}
|
||||
|
||||
// Finish the path through the reported two-friends speaking task. Every free
|
||||
// speech task follows a submitted, matching free-writing task, not a score gate.
|
||||
task := skipped
|
||||
seenCompose := map[string]bool{}
|
||||
foundFriends := false
|
||||
for n := 0; n < 110; n++ {
|
||||
if task.Kind == "free_speech" {
|
||||
key := task.AnswerKey.ReferenceAnswer
|
||||
if !seenCompose[key] {
|
||||
t.Fatal("speaking without related writing", task.CanonicalTaskID)
|
||||
}
|
||||
if task.CanonicalTaskID == "a1bank_en_v2_introductions_speaking_14" {
|
||||
foundFriends = true
|
||||
break
|
||||
}
|
||||
}
|
||||
attempt := answer(task, true)
|
||||
if task.Kind == "free_text" {
|
||||
if attempt.Status != "ungraded" {
|
||||
t.Fatal("missing model fabricated a writing grade", attempt)
|
||||
}
|
||||
seenCompose[task.AnswerKey.ReferenceAnswer] = true
|
||||
}
|
||||
task, _ = run("", "")
|
||||
}
|
||||
if !foundFriends {
|
||||
t.Fatal("two-friends sequence was not reached")
|
||||
}
|
||||
var calls int
|
||||
if err = db.QueryRowContext(ctx, `SELECT count(*) FROM ai_calls`).Scan(&calls); err != nil || calls != 0 {
|
||||
t.Fatal("sequence spent model budget", calls, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -37,14 +37,16 @@ func scanCourseJob(row interface{ Scan(...any) error }) (domain.CourseJob, error
|
||||
}
|
||||
if len(result) > 0 {
|
||||
var r struct {
|
||||
TaskID string `json:"task_id"`
|
||||
Source string `json:"source"`
|
||||
Review bool `json:"review"`
|
||||
TaskID string `json:"task_id"`
|
||||
Recommendation *domain.SequenceRecommendation `json:"recommendation"`
|
||||
Source string `json:"source"`
|
||||
Review bool `json:"review"`
|
||||
}
|
||||
if err = json.Unmarshal(result, &r); err != nil {
|
||||
return j, err
|
||||
}
|
||||
j.TaskID = r.TaskID
|
||||
j.Recommendation = r.Recommendation
|
||||
j.Source = r.Source
|
||||
j.Review = r.Review
|
||||
}
|
||||
@@ -91,7 +93,7 @@ func (s *AdaptiveStore) Finish(ctx context.Context, j domain.CourseJob, task *do
|
||||
if failure != "" {
|
||||
status = "failed"
|
||||
}
|
||||
_, err := s.db.ExecContext(ctx, `UPDATE course_v2_jobs SET status=$3,stage=$3,result=COALESCE($4,result),error=$5,lease_until=NULL WHERE id=$1 AND lease=$2 AND status='running'`, j.ID, j.Lease, status, result, failure)
|
||||
_, err := s.db.ExecContext(ctx, `UPDATE course_v2_jobs SET status=$3,stage=$3,result=COALESCE(result,'{}'::jsonb)||COALESCE($4,'{}'::jsonb),error=$5,lease_until=NULL WHERE id=$1 AND lease=$2 AND status='running'`, j.ID, j.Lease, status, result, failure)
|
||||
return err
|
||||
}
|
||||
func (s *AdaptiveStore) RetryEvaluation(ctx context.Context, user, language, attemptID string) (domain.CourseJob, error) {
|
||||
|
||||
@@ -171,7 +171,10 @@ func (s *AdaptiveStore) InstallBank(ctx context.Context) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err = s.db.ExecContext(ctx, bankSchema); err != nil {
|
||||
if _, err = bundledSequences(); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err = s.db.ExecContext(ctx, bankSchema+sequenceSchema); err != nil {
|
||||
return err
|
||||
}
|
||||
tx, err := s.db.BeginTx(ctx, nil)
|
||||
@@ -375,7 +378,11 @@ func (s *AdaptiveStore) AssignBankTask(ctx context.Context, j domain.CourseJob)
|
||||
hb := sha256.Sum256([]byte(j.UserID + b.entry.ID))
|
||||
return strings.Compare(hex.EncodeToString(ha[:]), hex.EncodeToString(hb[:])) < 0
|
||||
})
|
||||
chosen := candidates[0]
|
||||
selection, index, err := selectSequence(ctx, tx, j, candidates)
|
||||
if err != nil {
|
||||
return domain.AdaptiveTask{}, err
|
||||
}
|
||||
chosen := candidates[index]
|
||||
t := chosen.entry.Task
|
||||
t.Source = "curated"
|
||||
t.Review = chosen.seen
|
||||
@@ -403,7 +410,14 @@ func (s *AdaptiveStore) AssignBankTask(ctx context.Context, j domain.CourseJob)
|
||||
if err != nil {
|
||||
return domain.AdaptiveTask{}, err
|
||||
}
|
||||
data, _ := json.Marshal(map[string]any{"task_id": t.ID, "source": "curated", "review": chosen.seen})
|
||||
if err = saveSequenceSelection(ctx, tx, j, selection, t.ID); err != nil {
|
||||
return domain.AdaptiveTask{}, err
|
||||
}
|
||||
var recommendation *domain.SequenceRecommendation
|
||||
if selection != nil {
|
||||
recommendation = selection.Recommendation
|
||||
}
|
||||
data, _ := json.Marshal(map[string]any{"task_id": t.ID, "source": "curated", "review": chosen.seen, "recommendation": recommendation})
|
||||
if _, err = tx.ExecContext(ctx, `UPDATE course_v2_jobs SET result=$2 WHERE id=$1`, j.ID, data); err != nil {
|
||||
return domain.AdaptiveTask{}, err
|
||||
}
|
||||
|
||||
@@ -0,0 +1,288 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"database/sql"
|
||||
_ "embed"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"sync"
|
||||
|
||||
"speech-learning-api/internal/domain"
|
||||
)
|
||||
|
||||
//go:embed coursebank/sequences.json
|
||||
var sequenceData []byte
|
||||
|
||||
//go:embed coursebank/sequence_manifest.json
|
||||
var sequenceManifest []byte
|
||||
|
||||
const sequenceSchema = `
|
||||
CREATE TABLE IF NOT EXISTS course_v2_sequence_progress (
|
||||
user_id TEXT NOT NULL REFERENCES users(id),language TEXT NOT NULL,version TEXT NOT NULL,
|
||||
module_id TEXT NOT NULL,revision TEXT NOT NULL,cursor INT NOT NULL DEFAULT 0 CHECK(cursor>=0),
|
||||
active_task_id TEXT REFERENCES course_v2_tasks(id),presented_at TIMESTAMPTZ,
|
||||
skipped_steps INT NOT NULL DEFAULT 0 CHECK(skipped_steps>=0),
|
||||
reviewed BOOLEAN NOT NULL DEFAULT false,
|
||||
PRIMARY KEY(user_id,language,version,module_id,revision));
|
||||
ALTER TABLE course_v2_sequence_progress ADD COLUMN IF NOT EXISTS reviewed BOOLEAN NOT NULL DEFAULT false;
|
||||
`
|
||||
|
||||
type sequencePack struct {
|
||||
Revision string `json:"revision"`
|
||||
Review string `json:"editorial_review_sha256"`
|
||||
Sequences []domain.LearningSequence `json:"sequences"`
|
||||
}
|
||||
|
||||
var sequencesOnce sync.Once
|
||||
var sequencesPack sequencePack
|
||||
var sequencesError error
|
||||
|
||||
func bundledSequences() (sequencePack, error) {
|
||||
sequencesOnce.Do(func() {
|
||||
var manifest struct {
|
||||
SHA string `json:"sha256"`
|
||||
}
|
||||
if sequencesError = json.Unmarshal(sequenceManifest, &manifest); sequencesError != nil {
|
||||
return
|
||||
}
|
||||
sum := sha256.Sum256(sequenceData)
|
||||
if hex.EncodeToString(sum[:]) != manifest.SHA {
|
||||
sequencesError = errors.New("sequence checksum mismatch")
|
||||
return
|
||||
}
|
||||
if sequencesError = json.Unmarshal(sequenceData, &sequencesPack); sequencesError != nil {
|
||||
return
|
||||
}
|
||||
base, err := BundledBank()
|
||||
if err != nil {
|
||||
sequencesError = err
|
||||
return
|
||||
}
|
||||
sequencesError = validateSequences(sequencesPack, base)
|
||||
})
|
||||
return sequencesPack, sequencesError
|
||||
}
|
||||
func validateSequences(pack sequencePack, base []domain.BankEntry) error {
|
||||
if pack.Revision == "" || len(pack.Review) != 64 || len(pack.Sequences) == 0 {
|
||||
return errors.New("missing sequence review")
|
||||
}
|
||||
entries := map[string]domain.BankEntry{}
|
||||
for _, entry := range base {
|
||||
entries[entry.ID] = entry
|
||||
}
|
||||
seen := map[string]bool{}
|
||||
phases := []string{"listen", "vocabulary", "read", "repeat", "grammar", "write", "compose", "speak"}
|
||||
kinds := []string{"choice", "choice", "choice", "repeat_sentence", "choice", "short_text", "free_text", "free_speech"}
|
||||
skills := []string{"listening", "vocabulary", "reading", "speaking", "grammar", "writing", "writing", "speaking"}
|
||||
for _, seq := range pack.Sequences {
|
||||
if seq.ID == "" || seen[seq.ID] || seq.Titles["de-DE"] == "" || seq.Titles["ru-RU"] == "" {
|
||||
return fmt.Errorf("invalid sequence: %s", seq.ID)
|
||||
}
|
||||
seen[seq.ID] = true
|
||||
phase := -1
|
||||
for _, step := range seq.Steps {
|
||||
entry, ok := entries[step.BankEntryID]
|
||||
next := phase
|
||||
if next < 0 || step.Phase != phases[next] {
|
||||
next++
|
||||
}
|
||||
if next >= len(phases) || step.Phase != phases[next] || !ok || entry.Task.ModuleID != seq.ModuleID || entry.Task.Kind != kinds[next] || entry.Task.Skill != skills[next] {
|
||||
return fmt.Errorf("invalid sequence step: %s/%s", seq.ID, step.BankEntryID)
|
||||
}
|
||||
phase = next
|
||||
}
|
||||
if phase != len(phases)-1 {
|
||||
return fmt.Errorf("incomplete sequence: %s", seq.ID)
|
||||
}
|
||||
last := seq.Steps[len(seq.Steps)-1]
|
||||
previous := seq.Steps[len(seq.Steps)-2]
|
||||
if entries[last.BankEntryID].Task.AnswerKey.ReferenceAnswer != entries[previous.BankEntryID].Task.AnswerKey.ReferenceAnswer {
|
||||
return fmt.Errorf("unrelated final writing/speech: %s", seq.ID)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type sequencePosition struct {
|
||||
Sequence domain.LearningSequence
|
||||
Step domain.LearningSequenceStep
|
||||
StepIndex int
|
||||
TopicIndex int
|
||||
Topics int
|
||||
}
|
||||
|
||||
func sequencePositions(pack sequencePack, module string) []sequencePosition {
|
||||
out := []sequencePosition{}
|
||||
topics := 0
|
||||
for _, seq := range pack.Sequences {
|
||||
if seq.ModuleID == module {
|
||||
topics++
|
||||
}
|
||||
}
|
||||
topic := 0
|
||||
for _, seq := range pack.Sequences {
|
||||
if seq.ModuleID != module {
|
||||
continue
|
||||
}
|
||||
for n, step := range seq.Steps {
|
||||
out = append(out, sequencePosition{seq, step, n, topic, topics})
|
||||
}
|
||||
topic++
|
||||
}
|
||||
return out
|
||||
}
|
||||
func recommendationAt(pack sequencePack, positions []sequencePosition, cursor, skipped int, task, native string) *domain.SequenceRecommendation {
|
||||
r := &domain.SequenceRecommendation{Revision: pack.Revision, Complete: cursor >= len(positions), SkippedSteps: skipped}
|
||||
if r.Complete {
|
||||
return r
|
||||
}
|
||||
pos := positions[cursor]
|
||||
r.SequenceID = pos.Sequence.ID
|
||||
r.Title = pos.Sequence.Titles[native]
|
||||
r.Phase = pos.Step.Phase
|
||||
r.Step = pos.StepIndex + 1
|
||||
r.Steps = len(pos.Sequence.Steps)
|
||||
r.Topic = pos.TopicIndex + 1
|
||||
r.Topics = pos.Topics
|
||||
r.TaskID = task
|
||||
return r
|
||||
}
|
||||
|
||||
// This cursor records participation/explicit skipping, never success. It is
|
||||
// independent of native language, variant and grades. Exams never use it.
|
||||
func (s *AdaptiveStore) SequenceRecommendation(ctx context.Context, user, language, module, native string) (*domain.SequenceRecommendation, error) {
|
||||
if language != "en-US" {
|
||||
return nil, nil
|
||||
}
|
||||
pack, err := bundledSequences()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
positions := sequencePositions(pack, module)
|
||||
if len(positions) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
var cursor, skipped int
|
||||
var reviewed bool
|
||||
var task string
|
||||
err = s.db.QueryRowContext(ctx, `SELECT cursor,skipped_steps,COALESCE(active_task_id,''),reviewed FROM course_v2_sequence_progress WHERE user_id=$1 AND language=$2 AND version=$3 AND module_id=$4 AND revision=$5`, user, language, domain.CourseVersion, module, pack.Revision).Scan(&cursor, &skipped, &task, &reviewed)
|
||||
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
||||
return nil, err
|
||||
}
|
||||
r := recommendationAt(pack, positions, cursor, skipped, task, native)
|
||||
r.Review = reviewed
|
||||
if task != "" && !r.Complete {
|
||||
answered, err := sequenceAnswered(ctx, s.db, domain.CourseJob{UserID: user, Language: language, ModuleID: module}, pack.Revision)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
r.NeedsAnswer = !answered
|
||||
}
|
||||
return r, nil
|
||||
}
|
||||
|
||||
type sequenceSelection struct {
|
||||
Reset bool
|
||||
Reviewed bool
|
||||
Cursor int
|
||||
Skipped int
|
||||
Recommendation *domain.SequenceRecommendation
|
||||
}
|
||||
|
||||
func selectSequence(ctx context.Context, tx *sql.Tx, j domain.CourseJob, candidates []bankCandidate) (*sequenceSelection, int, error) {
|
||||
if j.Language != "en-US" || j.Skill != "" || j.Kind != "next" {
|
||||
return nil, 0, nil
|
||||
}
|
||||
pack, err := bundledSequences()
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
positions := sequencePositions(pack, j.ModuleID)
|
||||
if len(positions) == 0 {
|
||||
if j.SubjectID != "" {
|
||||
return nil, 0, ErrCourseConflict
|
||||
}
|
||||
return nil, 0, nil
|
||||
}
|
||||
_, err = tx.ExecContext(ctx, `INSERT INTO course_v2_sequence_progress(user_id,language,version,module_id,revision) VALUES($1,$2,$3,$4,$5) ON CONFLICT DO NOTHING`, j.UserID, j.Language, domain.CourseVersion, j.ModuleID, pack.Revision)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
var cursor, skipped int
|
||||
var reviewed bool
|
||||
reset := false
|
||||
var active string
|
||||
err = tx.QueryRowContext(ctx, `SELECT cursor,skipped_steps,COALESCE(active_task_id,''),reviewed FROM course_v2_sequence_progress WHERE user_id=$1 AND language=$2 AND version=$3 AND module_id=$4 AND revision=$5 FOR UPDATE`, j.UserID, j.Language, domain.CourseVersion, j.ModuleID, pack.Revision).Scan(&cursor, &skipped, &active, &reviewed)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
if j.SubjectID != "" && (j.SubjectID != active || cursor >= len(positions)) {
|
||||
return nil, 0, ErrCourseConflict
|
||||
}
|
||||
if cursor < len(positions) && active != "" {
|
||||
answered, err := sequenceAnswered(ctx, tx, j, pack.Revision)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
if answered && !reviewed && j.SubjectID == "" {
|
||||
// One optional review after an actually graded mistake. No pass mark
|
||||
// gates the path; a second answer or explicit skip continues it.
|
||||
var weak bool
|
||||
err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT a.status='graded' AND (a.evaluation->>'score')::float8<80 FROM course_v2_attempts a JOIN course_v2_sequence_progress p ON p.active_task_id=a.task_id WHERE p.user_id=$1 AND p.language=$2 AND p.version=$3 AND p.module_id=$4 AND p.revision=$5 AND a.user_id=$1 AND NOT a.demo AND a.exam_id IS NULL AND a.created_at>=p.presented_at ORDER BY a.created_at DESC,a.id DESC LIMIT 1),false)`, j.UserID, j.Language, domain.CourseVersion, j.ModuleID, pack.Revision).Scan(&weak)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
if weak {
|
||||
reviewed = true
|
||||
reset = true
|
||||
answered = false
|
||||
}
|
||||
}
|
||||
if answered || j.SubjectID != "" {
|
||||
cursor++
|
||||
reviewed = false
|
||||
reset = true
|
||||
if !answered {
|
||||
skipped++
|
||||
}
|
||||
active = ""
|
||||
}
|
||||
}
|
||||
r := recommendationAt(pack, positions, cursor, skipped, active, j.InstructionLanguage)
|
||||
r.Review = reviewed
|
||||
selection := &sequenceSelection{Cursor: cursor, Skipped: skipped, Recommendation: r, Reviewed: reviewed, Reset: reset}
|
||||
if r.Complete {
|
||||
return selection, 0, nil
|
||||
}
|
||||
for n, candidate := range candidates {
|
||||
if candidate.bankEntryID == positions[cursor].Step.BankEntryID {
|
||||
return selection, n, nil
|
||||
}
|
||||
}
|
||||
return nil, 0, ErrCourseVariantUnavailable
|
||||
}
|
||||
func saveSequenceSelection(ctx context.Context, tx *sql.Tx, j domain.CourseJob, selection *sequenceSelection, taskID string) error {
|
||||
if selection == nil {
|
||||
return nil
|
||||
}
|
||||
r := selection.Recommendation
|
||||
if r.Complete {
|
||||
taskID = ""
|
||||
}
|
||||
r.TaskID = taskID
|
||||
r.NeedsAnswer = taskID != ""
|
||||
_, err := tx.ExecContext(ctx, `UPDATE course_v2_sequence_progress SET cursor=$6,skipped_steps=$7,presented_at=CASE WHEN $9 OR active_task_id IS DISTINCT FROM NULLIF($8,'') THEN now() ELSE presented_at END,active_task_id=NULLIF($8,''),reviewed=$10 WHERE user_id=$1 AND language=$2 AND version=$3 AND module_id=$4 AND revision=$5`, j.UserID, j.Language, domain.CourseVersion, j.ModuleID, r.Revision, selection.Cursor, selection.Skipped, taskID, selection.Reset, selection.Reviewed)
|
||||
return err
|
||||
}
|
||||
|
||||
func sequenceAnswered(ctx context.Context, db interface {
|
||||
QueryRowContext(context.Context, string, ...any) *sql.Row
|
||||
}, j domain.CourseJob, revision string) (bool, error) {
|
||||
var answered bool
|
||||
err := db.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM course_v2_attempts a JOIN course_v2_sequence_progress p ON p.active_task_id=a.task_id WHERE p.user_id=$1 AND p.language=$2 AND p.version=$3 AND p.module_id=$4 AND p.revision=$5 AND a.user_id=$1 AND a.exam_id IS NULL AND NOT a.demo AND a.status IN ('graded','ungraded','pending') AND a.created_at>=p.presented_at)`, j.UserID, j.Language, domain.CourseVersion, j.ModuleID, revision).Scan(&answered)
|
||||
return answered, err
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestReviewedSequencesProtectPreparation(t *testing.T) {
|
||||
pack, err := bundledSequences()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
base, err := BundledBank()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(pack.Sequences) != 60 {
|
||||
t.Fatal(len(pack.Sequences))
|
||||
}
|
||||
copyPack := func() sequencePack {
|
||||
raw, _ := json.Marshal(pack)
|
||||
var copy sequencePack
|
||||
if err := json.Unmarshal(raw, ©); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return copy
|
||||
}
|
||||
t.Run("no free speech first", func(t *testing.T) {
|
||||
copy := copyPack()
|
||||
copy.Sequences[0].Steps[0] = copy.Sequences[0].Steps[len(copy.Sequences[0].Steps)-1]
|
||||
if validateSequences(copy, base) == nil {
|
||||
t.Fatal("unprepared speaking accepted")
|
||||
}
|
||||
})
|
||||
t.Run("no unrelated writing at the end", func(t *testing.T) {
|
||||
copy := copyPack()
|
||||
n := len(copy.Sequences[0].Steps)
|
||||
other := copy.Sequences[1]
|
||||
copy.Sequences[0].Steps[n-2] = other.Steps[len(other.Steps)-2]
|
||||
if validateSequences(copy, base) == nil {
|
||||
t.Fatal("unrelated writing accepted")
|
||||
}
|
||||
})
|
||||
t.Run("both native titles required", func(t *testing.T) {
|
||||
copy := copyPack()
|
||||
delete(copy.Sequences[0].Titles, "ru-RU")
|
||||
if validateSequences(copy, base) == nil {
|
||||
t.Fatal("missing Russian topic accepted")
|
||||
}
|
||||
})
|
||||
for _, module := range []string{"introductions", "family", "numbers_time", "daily_life", "food_shopping", "home_city"} {
|
||||
positions := sequencePositions(pack, "a1_"+module+"_v1")
|
||||
if len(positions) == 0 || positions[0].Step.Phase != "listen" {
|
||||
t.Fatal("no listening entry", module)
|
||||
}
|
||||
for _, native := range []string{"de-DE", "ru-RU"} {
|
||||
r := recommendationAt(pack, positions, 0, 0, "", native)
|
||||
if r.Topic != 1 || r.Topics != 10 || r.Title == "" || r.Complete {
|
||||
t.Fatal(r)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"revision": "en-A1-bank-v2",
|
||||
"total": 840,
|
||||
"editorial_review_sha256": "a64cc0b862192e996265420c7e6d8ac82c3543449c97fbdd99dc816a270e141a",
|
||||
"editorial_review_sha256": "6018e163c0e4a79dd12828c368db42c4382398be51f0c70c3343ba512278a42d",
|
||||
"files": {
|
||||
"introductions.grammar.json": "e166492fa3e9e13760620bda1af2c0bb6472d91216a4c46808360264450c5ebc",
|
||||
"introductions.vocabulary.json": "d72c534e3c7422d85b2aa03f2988b77da31163637c70ac511ca07f278d1fdd81",
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
{
|
||||
"sha256": "808b5b14d40eeee0d4cd47f584532e71c6bbb1a9c090d0166fd055861213efa8"
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -25,7 +25,9 @@ export type CourseAnalysis = {
|
||||
summary: string; facts_version: number; recommended_module_id: string;
|
||||
modules: { module_id: string; strengths: string[]; weaknesses: string[]; recommendation: string; reason: string; ready_for_completion: boolean }[];
|
||||
};
|
||||
export type SequenceRecommendation = { review: boolean; revision: string; sequence_id?: string; title?: string; phase?: string; step: number; steps: number; topic: number; topics: number; task_id?: string; complete: boolean; skipped_steps: number; needs_answer: boolean };
|
||||
export type CourseCatalog = {
|
||||
sequence_recommendations?: Record<string, SequenceRecommendation>;
|
||||
native_language?: string; native_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[];
|
||||
@@ -33,13 +35,13 @@ export type CourseCatalog = {
|
||||
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 = { 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 CourseJob = { recommendation?: SequenceRecommendation; 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');
|
||||
export const getCourseHistory = (module: string, offset = 0) => request<{ tasks: AdaptiveTask[]; has_more: boolean }>(`/course/modules/${encodeURIComponent(module)}/tasks?offset=${offset}`);
|
||||
export const getAdaptiveTask = (id: string) => request<{ task: AdaptiveTask; attempt: AdaptiveAttempt | null }>(`/course/tasks/${encodeURIComponent(id)}`);
|
||||
export const createCourseTask = (module: string, skill: string, requestId: string) => request<CourseJob>(`/course/modules/${encodeURIComponent(module)}/tasks/next`, { method: 'POST', body: JSON.stringify({ skill, request_id: requestId }) });
|
||||
export const createCourseTask = (module: string, skill: string, requestId: string, skipTaskID?: string) => request<CourseJob>(`/course/modules/${encodeURIComponent(module)}/tasks/next`, { method: 'POST', body: JSON.stringify({ skill, request_id: requestId, skip_task_id: skipTaskID }) });
|
||||
export const getCourseJob = (id: string) => request<CourseJob>(`/course/jobs/${encodeURIComponent(id)}`);
|
||||
export const retryCourseJob = (id: string) => request<CourseJob>(`/course/jobs/${encodeURIComponent(id)}/retry`, { method: 'POST' });
|
||||
export const getCourseAttempt = (id: string) => request<AdaptiveAttempt>(`/course/attempts/${encodeURIComponent(id)}`);
|
||||
|
||||
@@ -98,7 +98,7 @@
|
||||
"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.exercises_are_selected_using_your_saved_evaluations_new_exercises_come": "Der empfohlene Lernweg verbindet Hören, Wortschatz, Lesen, Nachsprechen, Grammatik und Schreiben bis zum freien Sprechen. Einzelne Lernbereiche bleiben direkt wählbar.",
|
||||
"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",
|
||||
@@ -443,5 +443,20 @@
|
||||
"seed.cafe.title": "Im Café",
|
||||
"seed.numbers.title": "Zahlen",
|
||||
"seed.generated.title": "Ausspracheübung",
|
||||
"seed.historical": "Historischer fester Kurs: Die gespeicherten Aufgaben und Erklärungen bleiben in ihrer ursprünglichen Sprache. Für neue Aufgaben in deiner Muttersprache nutze den aktuellen A1-Kurs."
|
||||
"seed.historical": "Historischer fester Kurs: Die gespeicherten Aufgaben und Erklärungen bleiben in ihrer ursprünglichen Sprache. Für neue Aufgaben in deiner Muttersprache nutze den aktuellen A1-Kurs.",
|
||||
"sequence.default": "Empfohlener Lernweg",
|
||||
"sequence.title": "Dein thematischer Lernweg",
|
||||
"sequence.intro": "Die Übungen bauen zum selben Thema aufeinander auf. Antworte und wähle dann „Nächste Aufgabe“. Du kannst einen Schritt überspringen oder einen Lernbereich direkt wählen. Bearbeitet bedeutet noch nicht beherrscht.",
|
||||
"sequence.position": "Thema {topic} von {topics} · Schritt {step} von {steps}",
|
||||
"sequence.skip": "Diesen Schritt überspringen",
|
||||
"sequence.complete": "Du hast diesen Lernweg durchgearbeitet oder Schritte übersprungen. Weitere Aufgaben richten sich nach deinen gespeicherten Bewertungen. Das ist noch kein Nachweis, dass du alles beherrschst.",
|
||||
"sequence.phase.listen": "Zuerst hören",
|
||||
"sequence.phase.vocabulary": "Wörter im Zusammenhang verstehen",
|
||||
"sequence.phase.read": "Ein passendes Beispiel lesen",
|
||||
"sequence.phase.repeat": "Mit Vorlage nachsprechen",
|
||||
"sequence.phase.grammar": "Das Satzmuster üben",
|
||||
"sequence.phase.write": "Mit Vorgabe schreiben",
|
||||
"sequence.phase.compose": "Selbstständig formulieren",
|
||||
"sequence.phase.speak": "Das Thema frei sprechen",
|
||||
"sequence.review": "Bei der letzten Antwort gab es einen Fehler. Übe diesen Schritt noch einmal oder überspringe ihn. Danach geht der Lernweg weiter, unabhängig von der Punktzahl."
|
||||
}
|
||||
|
||||
@@ -98,7 +98,7 @@
|
||||
"ui.course_not_yet_available": " — Курс пока недоступен",
|
||||
"ui.a_reviewed_a1_course_pack_is_not_yet_available_for": "Для этого изучаемого языка пока нет проверенного курса A1. Ваш прежний прогресс сохранён.",
|
||||
"ui.your_learning_progress": "Ваш прогресс в обучении",
|
||||
"ui.exercises_are_selected_using_your_saved_evaluations_new_exercises_come": "Задания подбираются по сохранённым оценкам. Сначала предлагаются новые задания, затем подходящие упражнения и повторения. Ответы без оценки не считаются оценёнными результатами обучения.",
|
||||
"ui.exercises_are_selected_using_your_saved_evaluations_new_exercises_come": "Рекомендуемый учебный путь связывает аудирование, лексику, чтение, повторение вслух, грамматику и письмо, подготавливая к самостоятельной речи. Любое направление можно выбрать напрямую.",
|
||||
"ui.no_ai_learning_analysis_yet_the_teacher_agent_creates_it": "Анализа ИИ пока нет. Учитель создаёт его на основе ваших сохранённых ответов.",
|
||||
"ui.the_learning_analysis_is_being_updated_after_your_latest_answer": "Анализ прогресса обновляется после последнего ответа.",
|
||||
"ui.request_learning_analysis_again": "Запросить анализ прогресса повторно",
|
||||
@@ -443,5 +443,20 @@
|
||||
"seed.cafe.title": "В кафе",
|
||||
"seed.numbers.title": "Числа",
|
||||
"seed.generated.title": "Упражнение на произношение",
|
||||
"seed.historical": "Исторический фиксированный курс: сохранённые задания и объяснения остаются на исходном языке. Новые задания на вашем родном языке доступны в текущем курсе A1."
|
||||
"seed.historical": "Исторический фиксированный курс: сохранённые задания и объяснения остаются на исходном языке. Новые задания на вашем родном языке доступны в текущем курсе A1.",
|
||||
"sequence.default": "Рекомендуемый учебный путь",
|
||||
"sequence.title": "Ваш тематический учебный путь",
|
||||
"sequence.intro": "Упражнения последовательно раскрывают одну тему. Ответьте и нажмите «Следующее задание». Можно пропустить шаг или выбрать направление обучения напрямую. Выполненное задание ещё не означает освоение материала.",
|
||||
"sequence.position": "Тема {topic} из {topics} · Шаг {step} из {steps}",
|
||||
"sequence.skip": "Пропустить этот шаг",
|
||||
"sequence.complete": "Вы прошли этот учебный путь или пропустили отдельные шаги. Дальнейшие задания подбираются по сохранённым оценкам. Это ещё не подтверждает освоение всего материала.",
|
||||
"sequence.phase.listen": "Сначала послушать",
|
||||
"sequence.phase.vocabulary": "Понять слова в контексте",
|
||||
"sequence.phase.read": "Прочитать пример по теме",
|
||||
"sequence.phase.repeat": "Повторить вслух по образцу",
|
||||
"sequence.phase.grammar": "Потренировать структуру предложения",
|
||||
"sequence.phase.write": "Написать по заданию",
|
||||
"sequence.phase.compose": "Самостоятельно составить текст",
|
||||
"sequence.phase.speak": "Самостоятельно рассказать по теме",
|
||||
"sequence.review": "В последнем ответе была ошибка. Повторите этот шаг ещё раз или пропустите его. После этого учебный путь продолжится независимо от балла."
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import { errorMessage, useLocalizedMessage } from '../i18n/useLocalizedMessage';
|
||||
import { useCourseSkillNames } from '../i18n/labels';
|
||||
import { useI18n } from '../i18n/I18n';
|
||||
import { useI18n, type MessageKey } from '../i18n/I18n';
|
||||
import { useEffect, useRef, useState } from 'react';
|
||||
import { request } from '../api/client';
|
||||
import {
|
||||
@@ -33,6 +33,7 @@ export function CoursePage() {
|
||||
const [restored, setRestored] = useState(false);
|
||||
const [revision, setRevision] = useState(0);
|
||||
const generationID = useRef<string | null>(null);
|
||||
const generationSkipID = useRef<string | undefined>(undefined);
|
||||
const examRequestID = useRef<string | null>(null);
|
||||
const exerciseRef = useRef<HTMLElement | null>(null);
|
||||
const active = useRef(true);
|
||||
@@ -137,9 +138,12 @@ export function CoursePage() {
|
||||
const timer = window.setTimeout(() => { void refreshCatalog().catch(showError); }, 3000);
|
||||
return () => window.clearTimeout(timer);
|
||||
}, [catalog]);
|
||||
async function generate() {
|
||||
async function generate(skip = false) {
|
||||
if (locked || !moduleID) return; setBusy(true); setError('');
|
||||
try { generationID.current ??= courseRequestID(); const next = await createCourseTask(moduleID, skill, generationID.current); generationID.current = null; setExam(null); setJob(next); }
|
||||
try { const skipID = skip ? task?.id : undefined;
|
||||
if (generationSkipID.current !== skipID) generationID.current = null;
|
||||
generationSkipID.current = skipID;
|
||||
generationID.current ??= courseRequestID(); const next = await createCourseTask(moduleID, skill, generationID.current, skipID); generationID.current = null; setExam(null); setJob(next); }
|
||||
catch (err) { showError(err); } finally { setBusy(false); }
|
||||
}
|
||||
async function changeLanguage(language: string) {
|
||||
@@ -166,6 +170,8 @@ export function CoursePage() {
|
||||
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 recommendation = catalog.sequence_recommendations?.[moduleID];
|
||||
const phases: Record<string, MessageKey> = { listen: 'sequence.phase.listen', vocabulary: 'sequence.phase.vocabulary', read: 'sequence.phase.read', repeat: 'sequence.phase.repeat', grammar: 'sequence.phase.grammar', write: 'sequence.phase.write', compose: 'sequence.phase.compose', speak: 'sequence.phase.speak' };
|
||||
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));
|
||||
@@ -187,7 +193,17 @@ export function CoursePage() {
|
||||
</button>)}</nav>
|
||||
{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="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(''); generationID.current = null; }}>{t(catalog.task_mode === 'bank' ? 'sequence.default' : '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>
|
||||
{skill === '' && recommendation && !exam && <div className="view-stack" role="region" aria-label={t('sequence.title')}>
|
||||
<h3>{t('sequence.title')}</h3>
|
||||
{recommendation.complete ? <p>{t('sequence.complete')}</p> : <>
|
||||
<strong>{recommendation.title}</strong>
|
||||
<p>{t('sequence.position', { topic: recommendation.topic, topics: recommendation.topics, step: recommendation.step, steps: recommendation.steps })} · {recommendation.phase && phases[recommendation.phase] ? t(phases[recommendation.phase]) : ''}</p>
|
||||
<p className="muted">{t('sequence.intro')}</p>
|
||||
{recommendation.review && <p role="status">{t('sequence.review')}</p>}
|
||||
{recommendation.task_id === task?.id && recommendation.needs_answer && <button type="button" className="ghost-button" disabled={locked} onClick={() => void generate(true)}>{t('sequence.skip')}</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>}
|
||||
|
||||
@@ -49,6 +49,16 @@ Sprachrollen, private Hörtexte/Lösungen, unbenotete Antworten sowie eingefrore
|
||||
Aufgaben nach Sprachwechsel und Reload. Ein russischer Test mit zwölf Aufgaben
|
||||
bleibt nach einem Wechsel über dieselbe Request-ID unverändert abrufbar.
|
||||
|
||||
`course-sequences.e2e.cjs` prüft auf Deutsch und Russisch den empfohlenen
|
||||
Lernweg mit Höreinstieg, Wiederaufnahme nach Reload, unveränderten Schritt bei
|
||||
bloßem Weiterklicken, explizites Überspringen, freie Bereichswahl, Fortsetzung
|
||||
nach einer Antwort und Erhalt beim Wechsel der Muttersprache. Die Kursbank-Fixture
|
||||
startet ihn sequenziell nach dem Varianten-Smoke. Keine Modellaufrufe.
|
||||
Die Go-Datenbanktests prüfen zusätzlich den Weg bis zur gemeldeten Aufgabe über
|
||||
zwei Freunde: passendes Schreiben vor freiem Sprechen, unbenotete Antworten ohne
|
||||
falschen Leistungsnachweis, einmaliges Wiederholungsangebot, Request-Replay,
|
||||
abgewiesene fremde/veraltete Skip-IDs und unveränderte historische Aufgaben.
|
||||
|
||||
`course-bank.e2e.cjs` läuft vollständig mit deutscher und russischer Muttersprache:
|
||||
Aufgabenzuweisung, Bedienung aller fünf Darstellungen, Antwort/Reload, Eingabeerhalt
|
||||
beim Sprachwechsel und vollständig abgegebener Test ohne vorzeitige Note oder
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
// Real local API and disposable database; no paid models or actual microphone.
|
||||
const {chromium}=require(process.env.PLAYWRIGHT_MODULE||'playwright');
|
||||
const assert=require('node:assert/strict'),crypto=require('node:crypto'),fs=require('node:fs');
|
||||
(async()=>{
|
||||
const api=process.env.AI_E2E_API,url=process.env.AI_E2E_URL;
|
||||
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));
|
||||
for(const native of ['de-DE','ru-RU']) {
|
||||
const labels=JSON.parse(fs.readFileSync(`src/i18n/${native}.json`));
|
||||
const response=await page.request.post(api+'/auth/register',{data:{email:`sequence-${native}-${Date.now()}@example.test`,password:'local-sequence-test-password',native_language:native,target_language:'en-US'}});assert.equal(response.status(),201);
|
||||
const account=await response.json(),headers={Authorization:`Bearer ${account.token}`};
|
||||
const get=async path=>{const r=await page.request.get(api+path,{headers});assert.equal(r.status(),200,await r.text());return r.json()};
|
||||
await page.goto(url);await page.evaluate(t=>localStorage.setItem('speech_token',t),account.token);await page.reload();await page.getByRole('button',{name:labels['nav.course'],exact:true}).click();
|
||||
const path=page.getByRole('region',{name:labels['sequence.title'],exact:true});await path.waitFor();await path.getByText(labels['sequence.phase.listen'],{exact:false}).waitFor();
|
||||
await page.getByRole('button',{name:labels['sequence.default'],exact:true}).waitFor();
|
||||
async function next(skip=false) {
|
||||
const ready=page.waitForResponse(r=>r.url().endsWith('/tasks/next')&&r.request().method()==='POST');
|
||||
await page.getByRole('button',{name:labels[skip?'sequence.skip':'ui.next_exercise'],exact:true}).click();
|
||||
let job=await(await ready).json();for(let n=0;n<100&&['queued','running'].includes(job.status);n++){await page.waitForTimeout(100);job=await get('/course/jobs/'+job.id)}
|
||||
assert.equal(job.status,'succeeded',job.error);
|
||||
await path.getByText(labels['sequence.phase.'+job.recommendation.phase],{exact:false}).waitFor();
|
||||
const current=await get('/course/tasks/'+job.task_id);
|
||||
const exercise=page.getByRole('region',{name:labels['ui.current_course_exercise']});await exercise.getByRole('heading',{name:current.task.instruction||current.task.prompt,exact:true}).waitFor();
|
||||
return {job,...current};
|
||||
}
|
||||
const first=await next();assert.equal(first.task.skill,'listening');assert.equal(first.job.recommendation.step,1);assert.equal(first.task.audio_text,undefined);assert.equal(first.task.answer_key,undefined);
|
||||
const same=await next();assert.equal(same.task.id,first.task.id,'Clicking Next alone must not count as practice');
|
||||
await page.reload();await page.getByRole('button',{name:labels['nav.course'],exact:true}).click();await path.getByRole('button',{name:labels['sequence.skip'],exact:true}).waitFor();
|
||||
const skipped=await next(true);assert.equal(skipped.job.recommendation.step,2);assert.equal(skipped.job.recommendation.skipped_steps,1);assert.equal(skipped.task.skill,'vocabulary');
|
||||
const areas=page.getByRole('group',{name:labels['ui.learning_area']});await areas.getByRole('button',{name:labels['ui.speaking'],exact:true}).click();assert.equal(await path.count(),0);
|
||||
await areas.getByRole('button',{name:labels['sequence.default'],exact:true}).click();await path.getByText(labels['sequence.phase.vocabulary'],{exact:false}).waitFor();
|
||||
// Submit a correct choice through the API, then let the browser continue the path.
|
||||
const baseline=JSON.parse(fs.readFileSync('../api/internal/store/coursebank/en-US/a1-v2/introductions.vocabulary.json'));
|
||||
const key=baseline.find(e=>e.id===skipped.task.canonical_task_id).task.answer_key.correct_option_id;
|
||||
const attempt=await page.request.post(api+'/course/tasks/'+skipped.task.id+'/attempts',{headers,data:{request_id:crypto.randomUUID().replaceAll('-',''),answer:key}});assert.equal(attempt.status(),201);
|
||||
const continued=await next();assert.equal(continued.job.recommendation.step,3);
|
||||
const me=await get('/me');assert.deepEqual(me.profile,account.profile);
|
||||
const other=native==='de-DE'?'ru-RU':'de-DE';await page.locator('.language-picker select').selectOption(other);
|
||||
const translated=JSON.parse(fs.readFileSync(`src/i18n/${other}.json`));await page.getByRole('region',{name:translated['sequence.title']}).getByText(translated['sequence.phase.vocabulary'],{exact:false}).waitFor();
|
||||
const catalog=await get('/course/catalog');assert.equal(catalog.sequence_recommendations.a1_introductions_v1.step,3);assert.equal(catalog.sequence_recommendations.a1_introductions_v1.skipped_steps,1);
|
||||
assert.equal((await get('/course/tasks/'+continued.task.id)).task.instruction_language,native);
|
||||
await page.getByRole('button',{name:translated['auth.logout'],exact:true}).click();
|
||||
}
|
||||
const usage=await page.request.get(api+'/admin/ai/usage',{headers:{Authorization:`Bearer ${process.env.AI_E2E_TOKEN}`}});assert.equal((await usage.json()).total,0);assert.deepEqual(errors,[]);
|
||||
console.log('PASS: German/Russian default thematic paths; listening entry; no silent skip; explicit skip and reload; manual areas remain available; submitted answers advance; native change retains path and frozen task; no model calls.');
|
||||
}finally{await browser.close()}
|
||||
})().catch(e=>{console.error(e);process.exitCode=1});
|
||||
Reference in New Issue
Block a user