Files
Speech/apps/api/internal/store/adaptive_jobs.go
T
Eugenius Naumenko 16cceae28a Muttersprache koppeln und russischen A1-Kurs ergänzen
GUI und neue Erklärungen verwenden gemeinsam native_language. Deutsch und
Russisch sind die beiden Muttersprachen; Englisch bleibt die Lernsprache.
Kompatibilitätsfelder werden atomar gekoppelt, widersprüchliche Eingaben
abgewiesen und bestehende Profile sowie eingefrorene Inhalte erhalten.

Ergänzt vollständige russische GUI-Kataloge und 840 geprüfte Aufgabenansichten
in sieben Modulen einschließlich A1-Test, mit getrennten Sprachrollen für
Ausgangs- und Lernmaterial. Äquivalente Ansichten teilen ihre Nachweisidentität.
Stabile API-Fehlercodes, neue deterministische Hilfen und Trainingsbegründungen
berücksichtigen die Muttersprache. Dokumentiert das Sprachmodell in AGENTS.md.

Validierung: Go-Race-Suite mit eigener lokaler PostgreSQL-Testdatenbank, go vet,
Web-Build, Offline-Bank-/Variantenaudit, Diff-Prüfung sowie lokale Browser-Smokes
für Sprachen, Kurs, Administration, Aussprache und Aufnahme. Keine Live-Anbieter,
Produktionsprofile, Deployment-Schritte oder historischen Neubewertungen.
2026-11-07 17:02:17 +00:00

454 lines
19 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"speech-learning-api/internal/domain"
)
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,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
}
var existing string
err = s.db.QueryRowContext(ctx, `SELECT id FROM course_v2_jobs WHERE user_id=$1 AND kind=$2 AND request_id=$3 AND language=$4 AND version=$5 AND module_id=$6 AND skill=$7 AND subject_id=$8`, user, kind, request, language, domain.CourseVersion, module, skill, subject).Scan(&existing)
if errors.Is(err, sql.ErrNoRows) {
return domain.CourseJob{}, fmt.Errorf("%w: request ID already belongs to a different operation", ErrCourseConflict)
}
if err != nil {
return domain.CourseJob{}, err
}
return s.Job(ctx, user, language, existing)
}
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, &j.InstructionLanguage)
if errors.Is(err, sql.ErrNoRows) {
return j, ErrNotFound
}
if err != nil {
return j, err
}
if len(result) > 0 {
var r struct {
TaskID string `json:"task_id"`
Source string `json:"source"`
Review bool `json:"review"`
}
if err = json.Unmarshal(result, &r); err != nil {
return j, err
}
j.TaskID = r.TaskID
j.Source = r.Source
j.Review = r.Review
}
return j, nil
}
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))
}
func (s *AdaptiveStore) Claim(ctx context.Context) (domain.CourseJob, error) {
// Leases exceed the operation deadline; a crashed process can be recovered
// without two workers writing a result for the same live operation.
_, err := s.db.ExecContext(ctx, `UPDATE course_v2_jobs SET status='failed',error='Der Vorgang wurde wiederholt unterbrochen. Bitte erneut anfordern.' WHERE status='running' AND lease_until<now() AND deliveries>=3`)
if err != nil {
return domain.CourseJob{}, err
}
return scanCourseJob(s.db.QueryRowContext(ctx, `UPDATE course_v2_jobs SET status='running',stage='starting',deliveries=deliveries+1,lease=$1,
lease_until=now()+ CASE WHEN kind='exam' THEN interval '6 minutes' ELSE interval '4 minutes' END
WHERE id=(SELECT id FROM course_v2_jobs WHERE status='queued' OR (status='running' AND lease_until<now() AND deliveries<3) ORDER BY created_at FOR UPDATE SKIP LOCKED LIMIT 1) RETURNING `+jobColumns, NewID("lease")))
}
func (s *AdaptiveStore) Stage(ctx context.Context, j domain.CourseJob, stage string) error {
result, err := s.db.ExecContext(ctx, `UPDATE course_v2_jobs SET stage=$3 WHERE id=$1 AND lease=$2 AND status='running'`, j.ID, j.Lease, stage)
if err != nil {
return err
}
n, err := result.RowsAffected()
if err == nil && n == 0 {
return errors.New("job lease lost")
}
return err
}
func (s *AdaptiveStore) Finish(ctx context.Context, j domain.CourseJob, task *domain.AdaptiveTask, failure string) error {
var result any
if task != nil {
data, err := json.Marshal(map[string]any{"task_id": task.ID, "source": task.Source, "review": task.Review})
if err != nil {
return err
}
result = data
}
status := "succeeded"
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)
return err
}
func (s *AdaptiveStore) RetryEvaluation(ctx context.Context, user, language, attemptID string) (domain.CourseJob, error) {
a, err := s.Attempt(ctx, user, language, attemptID)
if err != nil {
return domain.CourseJob{}, err
}
if a.Status == "graded" {
return domain.CourseJob{}, fmt.Errorf("%w: answer already graded", ErrCourseConflict)
}
j, err := s.Enqueue(ctx, user, language, "evaluate", a.ModuleID, a.Skill, a.ID, "evaluation:"+a.ID)
if err != nil {
return j, err
}
_, err = s.db.ExecContext(ctx, `UPDATE course_v2_jobs SET status='queued',stage='queued',error='',deliveries=0,ai_revision=ai_revision+1 WHERE id=$1 AND user_id=$2 AND status IN ('failed','succeeded')`, j.ID, user)
if err != nil {
return j, err
}
_, err = s.db.ExecContext(ctx, `UPDATE course_v2_attempts SET status='pending' WHERE id=$1 AND user_id=$2 AND status IN ('failed','ungraded')`, a.ID, user)
if err != nil {
return j, err
}
return s.Job(ctx, user, language, j.ID)
}
func (s *AdaptiveStore) NewExam(ctx context.Context, user, language, request string) (domain.AdaptiveExam, error) {
id := NewID("exam")
_, err := s.db.ExecContext(ctx, `INSERT INTO course_v2_exams(id,user_id,language,version,request_id) VALUES($1,$2,$3,$4,$5) ON CONFLICT(user_id,request_id) DO NOTHING`, id, user, language, domain.CourseVersion, request)
if err != nil {
return domain.AdaptiveExam{}, err
}
err = s.db.QueryRowContext(ctx, `SELECT id FROM course_v2_exams WHERE user_id=$1 AND request_id=$2 AND language=$3 AND version=$4`, user, request, language, domain.CourseVersion).Scan(&id)
if errors.Is(err, sql.ErrNoRows) {
return domain.AdaptiveExam{}, fmt.Errorf("%w: request ID belongs to another language", ErrCourseConflict)
}
if err != nil {
return domain.AdaptiveExam{}, err
}
return s.Exam(ctx, user, language, id)
}
func (s *AdaptiveStore) Exams(ctx context.Context, user, language string) ([]domain.AdaptiveExam, error) {
rows, err := s.db.QueryContext(ctx, `SELECT id,status FROM course_v2_exams WHERE user_id=$1 AND language=$2 AND version=$3 ORDER BY created_at DESC LIMIT 25`, user, language, domain.CourseVersion)
if err != nil {
return nil, err
}
defer rows.Close()
exams := []domain.AdaptiveExam{}
for rows.Next() {
var e domain.AdaptiveExam
e.TargetLanguage = language
if err := rows.Scan(&e.ID, &e.Status); err != nil {
return nil, err
}
exams = append(exams, e)
}
return exams, rows.Err()
}
func (s *AdaptiveStore) Exam(ctx context.Context, user, language, id string) (domain.AdaptiveExam, error) {
e := domain.AdaptiveExam{ID: id, TargetLanguage: language, Tasks: []domain.AdaptiveTask{}, Attempts: []domain.AdaptiveAttempt{}}
var result []byte
err := s.db.QueryRowContext(ctx, `SELECT status,result FROM course_v2_exams WHERE id=$1 AND user_id=$2 AND language=$3 AND version=$4`, id, user, language, domain.CourseVersion).Scan(&e.Status, &result)
if errors.Is(err, sql.ErrNoRows) {
return e, ErrNotFound
}
if err != nil {
return e, err
}
if len(result) > 0 {
var r struct {
Scores map[string]float64 `json:"scores"`
Score *float64 `json:"score"`
Summary string `json:"summary"`
SummaryStatus string `json:"summary_status"`
}
if err = json.Unmarshal(result, &r); err != nil {
return e, err
}
e.Scores = r.Scores
e.Score = r.Score
e.Summary = r.Summary
e.SummaryStatus = r.SummaryStatus
}
if e.Status == "completed" && e.SummaryStatus != "ready" {
var status string
err = s.db.QueryRowContext(ctx, `SELECT id,status FROM course_v2_jobs WHERE user_id=$1 AND subject_id=$2 AND kind='exam_finalize' ORDER BY created_at DESC LIMIT 1`, user, id).Scan(&e.SummaryJobID, &status)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return e, err
}
if status == "failed" {
e.SummaryStatus = "failed"
}
}
if e.Status == "preparing" {
err = s.db.QueryRowContext(ctx, `SELECT id FROM course_v2_jobs WHERE user_id=$1 AND subject_id=$2 AND kind='exam' ORDER BY created_at DESC LIMIT 1`, user, id).Scan(&e.PreparationJobID)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return e, err
}
}
rows, err := s.db.QueryContext(ctx, `SELECT id FROM course_v2_tasks WHERE exam_id=$1 AND owner_id=$2 ORDER BY created_at,id`, id, user)
if err != nil {
return e, err
}
ids := []string{}
for rows.Next() {
var tid string
if err := rows.Scan(&tid); err != nil {
rows.Close()
return e, err
}
ids = append(ids, tid)
}
err = rows.Err()
rows.Close()
if err != nil {
return e, err
}
for _, tid := range ids {
t, err := s.Task(ctx, user, language, tid)
if err != nil {
return e, err
}
e.Tasks = append(e.Tasks, t.Public(e.Status == "completed"))
}
rows, err = s.db.QueryContext(ctx, adaptiveAttemptSelect+`WHERE a.exam_id=$1 AND a.user_id=$2 ORDER BY a.created_at`, id, user)
if err != nil {
return e, err
}
for rows.Next() {
a, err := scanAdaptiveAttempt(rows)
if err != nil {
rows.Close()
return e, err
}
if e.Status != "completed" {
a.Evaluation = nil
a.Speech = nil
}
e.Attempts = append(e.Attempts, a)
}
err = rows.Err()
rows.Close()
return e, err
}
func (s *AdaptiveStore) SaveExamTasks(ctx context.Context, user, language, exam string, tasks []domain.AdaptiveTask) error {
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
// Serialize equivalent assignments with ordinary bank selection, so a
// concurrent exam and exercise share the same first evidence identity.
if _, err = tx.ExecContext(ctx, `SELECT pg_advisory_xact_lock(hashtextextended($1,0))`, user+":"+language+":"+domain.CourseVersion); err != nil {
return err
}
var status string
err = tx.QueryRowContext(ctx, `SELECT status FROM course_v2_exams WHERE id=$1 AND user_id=$2 AND language=$3 FOR UPDATE`, exam, user, language).Scan(&status)
if err != nil {
return err
}
if status != "preparing" {
return nil
}
for i, t := range tasks {
t.ID = fmt.Sprintf("a2_%s_%02d", exam, i)
t.ExamID = exam
t.TargetLanguage = language
t.CourseVersion = domain.CourseVersion
fp := fingerprint(t)
if t.Source == "curated" {
fp = "bank-exam:" + t.BriefID
t.BriefID = ""
}
bankID := ""
if t.Source == "curated" {
bankID = t.CanonicalTaskID
if t.VariantID != "" {
if err = tx.QueryRowContext(ctx, `SELECT base_entry_id FROM course_v2_bank_variants WHERE id=$1`, t.VariantID).Scan(&bankID); err != nil {
return err
}
}
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 COALESCE(NULLIF(data->>'canonical_task_id',''),bank_entry_id)=$4 ORDER BY created_at,id LIMIT 1`, user, language, domain.CourseVersion, t.CanonicalTaskID).Scan(&t.EvidenceTaskID)
if errors.Is(err, sql.ErrNoRows) {
t.EvidenceTaskID = t.ID
} else if err != nil {
return err
}
}
data, err := json.Marshal(t)
if err != nil {
return err
}
_, err = tx.ExecContext(ctx, `INSERT INTO course_v2_tasks(id,module_id,language,version,owner_id,source,skill,kind,data,fingerprint,exam_id,bank_entry_id,variant_id) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,NULLIF($12,''),NULLIF($13,''))`, t.ID, t.ModuleID, language, domain.CourseVersion, user, t.Source, t.Skill, t.Kind, data, fp, exam, bankID, t.VariantID)
if err != nil {
return err
}
}
_, err = tx.ExecContext(ctx, `UPDATE course_v2_exams SET status='in_progress' WHERE id=$1`, exam)
if err != nil {
return err
}
return tx.Commit()
}
func (s *AdaptiveStore) ReserveExam(ctx context.Context, user, language, module string) ([]domain.AdaptiveTask, error) {
mods, err := s.Modules(ctx, language)
if err != nil {
return nil, err
}
if len(mods) != 7 {
return nil, ErrNotFound
}
out := []domain.AdaptiveTask{}
for i, skill := range domain.CourseSkills {
for n := 0; n < 2; n++ {
origin := mods[(i+n+1)%6]
t, err := s.Reserve(ctx, user, language, origin.ID, skill)
if err != nil {
return nil, err
}
t.ID = ""
t.ModuleID = module
t.OriginModuleKey = origin.Key
out = append(out, t)
}
}
return out, nil
}
func (s *AdaptiveStore) CompleteExam(ctx context.Context, user, language, id string) (bool, error) {
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return false, err
}
defer tx.Rollback()
var status string
err = tx.QueryRowContext(ctx, `SELECT status FROM course_v2_exams WHERE id=$1 AND user_id=$2 AND language=$3 FOR UPDATE`, id, user, language).Scan(&status)
if err != nil {
return false, err
}
if status == "completed" {
return false, nil
}
var total, graded, submitted int
err = tx.QueryRowContext(ctx, `SELECT count(*),count(*) FILTER(WHERE a.status='graded'),count(a.id) FROM course_v2_tasks t LEFT JOIN course_v2_attempts a ON a.task_id=t.id AND a.user_id=$2 WHERE t.exam_id=$1`, id, user).Scan(&total, &graded, &submitted)
if err != nil {
return false, err
}
if total != 12 || graded != 12 {
if total == 12 && submitted == 12 {
if _, err = tx.ExecContext(ctx, `UPDATE course_v2_exams SET status='submitted' WHERE id=$1 AND status='in_progress'`, id); err != nil {
return false, err
}
return false, tx.Commit()
}
return false, nil
}
rows, err := tx.QueryContext(ctx, `SELECT t.skill,avg((a.evaluation->>'score')::float8) FROM course_v2_tasks t JOIN course_v2_attempts a ON a.task_id=t.id WHERE t.exam_id=$1 AND a.user_id=$2 GROUP BY t.skill`, id, user)
if err != nil {
return false, err
}
scores := map[string]float64{}
sum := 0.0
for rows.Next() {
var skill string
var score float64
if err := rows.Scan(&skill, &score); err != nil {
rows.Close()
return false, err
}
scores[skill] = score
sum += score
}
err = rows.Err()
rows.Close()
if err != nil {
return false, err
}
if len(scores) != 6 {
return false, errors.New("incomplete exam skill coverage")
}
data, err := json.Marshal(map[string]any{"scores": scores, "score": sum / 6, "summary": "Die KI-Gesamteinschätzung wird vorbereitet.", "summary_status": "pending"})
if err != nil {
return false, err
}
_, err = tx.ExecContext(ctx, `UPDATE course_v2_exams SET status='completed',result=$2 WHERE id=$1`, id, data)
if err != nil {
return false, err
}
return true, tx.Commit()
}
func (s *AdaptiveStore) ExamSummary(ctx context.Context, user, id, summary string) error {
_, err := s.db.ExecContext(ctx, `UPDATE course_v2_exams SET result=result||jsonb_build_object('summary',$3::text,'summary_status','ready') WHERE id=$1 AND user_id=$2 AND status='completed'`, id, user, summary)
return err
}
func (s *AdaptiveStore) Release(ctx context.Context, j domain.CourseJob) error {
_, err := s.db.ExecContext(ctx, `UPDATE course_v2_jobs SET status='queued',stage='queued',lease_until=NULL WHERE id=$1 AND lease=$2 AND status='running'`, j.ID, j.Lease)
return err
}
func (s *AdaptiveStore) Reconcile(ctx context.Context, bankMode ...bool) error {
_, failureErr := s.db.ExecContext(ctx, `UPDATE course_v2_attempts a SET status='failed' WHERE a.status='pending' AND EXISTS(SELECT 1 FROM course_v2_jobs j WHERE j.kind='evaluate' AND j.subject_id=a.id AND j.user_id=a.user_id AND j.status='failed')`)
if failureErr != nil {
return failureErr
}
// Repair the gap if the process stops between storing an answer and enqueueing
// its assessment, or between final grading and scheduling the learning update.
_, err := s.db.ExecContext(ctx, `INSERT INTO course_v2_jobs(id,user_id,language,version,kind,module_id,skill,subject_id,request_id)
SELECT 'job_eval_'||a.id,a.user_id,t.language,t.version,'evaluate',t.module_id,t.skill,a.id,'evaluation:'||a.id
FROM course_v2_attempts a JOIN course_v2_tasks t ON t.id=a.task_id WHERE a.status='pending' ON CONFLICT DO NOTHING`)
if err != nil {
return err
}
if len(bankMode) == 0 || !bankMode[0] {
_, err = s.db.ExecContext(ctx, `INSERT INTO course_v2_jobs(id,user_id,language,version,kind,request_id)
SELECT 'job_analysis_'||v.user_id||'_'||v.language||'_'||v.facts_version,v.user_id,v.language,v.version,'analyze','analysis:'||v.language||':'||v.facts_version
FROM course_v2_versions v WHERE NOT EXISTS(SELECT 1 FROM course_v2_analyses a WHERE a.user_id=v.user_id AND a.language=v.language AND a.version=v.version AND a.facts_version>=v.facts_version)
ON CONFLICT DO NOTHING`)
if err != nil {
return err
}
}
_, err = s.db.ExecContext(ctx, `UPDATE course_v2_jobs j SET status='queued',stage='queued',deliveries=0 WHERE kind='exam_finalize' AND status IN ('succeeded','failed') AND EXISTS(SELECT 1 FROM course_v2_exams e WHERE e.id=j.subject_id AND e.status IN ('in_progress','submitted') AND (SELECT count(*) FROM course_v2_attempts a WHERE a.exam_id=e.id AND a.status='graded')=12)`)
if err != nil {
return err
}
_, err = s.db.ExecContext(ctx, `INSERT INTO course_v2_jobs(id,user_id,language,version,kind,module_id,subject_id,request_id)
SELECT 'job_finalize_'||e.id,e.user_id,e.language,e.version,'exam_finalize','a1_review_test_v1',e.id,'finalize:'||e.id FROM course_v2_exams e
WHERE e.status IN ('in_progress','submitted') AND (SELECT count(*) FROM course_v2_attempts a WHERE a.exam_id=e.id)=12 ON CONFLICT DO NOTHING`)
return err
}
func (s *AdaptiveStore) ResetFinalizer(ctx context.Context, user, exam string) error {
_, err := s.db.ExecContext(ctx, `UPDATE course_v2_jobs SET status='queued',stage='queued',deliveries=0 WHERE user_id=$1 AND kind='exam_finalize' AND subject_id=$2 AND status IN ('succeeded','failed') AND EXISTS(SELECT 1 FROM course_v2_exams e WHERE e.id=$2 AND e.status IN ('in_progress','submitted') AND (SELECT count(*) FROM course_v2_attempts a WHERE a.exam_id=e.id AND a.status='graded')=12)`, user, exam)
return err
}
func (s *AdaptiveStore) RetryJob(ctx context.Context, user, language, id string) (domain.CourseJob, error) {
j, err := s.Job(ctx, user, language, id)
if err != nil {
return j, err
}
if j.Kind == "evaluate" {
return s.RetryEvaluation(ctx, user, language, j.SubjectID)
}
_, err = s.db.ExecContext(ctx, `UPDATE course_v2_jobs SET status='queued',stage='queued',error='',deliveries=0,ai_revision=ai_revision+1 WHERE id=$1 AND user_id=$2 AND status='failed'`, id, user)
if err != nil {
return j, err
}
return s.Job(ctx, user, language, id)
}
func (s *AdaptiveStore) LatestAnalysisJob(ctx context.Context, user, language string) (*domain.CourseJob, error) {
j, err := scanCourseJob(s.db.QueryRowContext(ctx, `SELECT `+jobColumns+` FROM course_v2_jobs WHERE user_id=$1 AND language=$2 AND version=$3 AND kind='analyze' ORDER BY created_at DESC LIMIT 1`, user, language, domain.CourseVersion))
if errors.Is(err, ErrNotFound) {
return nil, nil
}
if err != nil {
return nil, err
}
return &j, nil
}