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"` 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 } 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=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 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 }