Files
Speech/apps/api/internal/store/adaptive.go
T
Eugenius Naumenko f3d42ee2b6 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.
2026-11-07 16:26:26 +00:00

585 lines
23 KiB
Go

package store
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"strings"
"time"
"speech-learning-api/internal/domain"
)
var ErrCourseConflict = errors.New("course operation conflicts with saved state")
type AdaptiveStore struct{ db *sql.DB }
func NewAdaptiveStore(db *sql.DB) *AdaptiveStore { return &AdaptiveStore{db: db} }
func (s *AdaptiveStore) Init(ctx context.Context) error {
if _, err := s.db.ExecContext(ctx, adaptiveSchema); err != nil {
return err
}
if err := initPronunciation(ctx, s.db); err != nil {
return err
}
if err := s.InstallPack(ctx, EnglishCoursePack()); err != nil {
return err
}
if err := s.InstallBank(ctx); err != nil {
return err
}
return s.importLegacy(ctx)
}
func (s *AdaptiveStore) Modules(ctx context.Context, language string) ([]domain.AdaptiveModule, error) {
rows, err := s.db.QueryContext(ctx, `SELECT data FROM course_v2_modules WHERE language=$1 AND version=$2 ORDER BY sort_order`, language, domain.CourseVersion)
if err != nil {
return nil, err
}
defer rows.Close()
out := []domain.AdaptiveModule{}
for rows.Next() {
var data []byte
var m domain.AdaptiveModule
if err := rows.Scan(&data); err != nil {
return nil, err
}
if err := json.Unmarshal(data, &m); err != nil {
return nil, err
}
out = append(out, m)
}
return out, rows.Err()
}
func (s *AdaptiveStore) Module(ctx context.Context, language, id string) (domain.AdaptiveModule, error) {
var data []byte
var out domain.AdaptiveModule
err := s.db.QueryRowContext(ctx, `SELECT data FROM course_v2_modules WHERE id=$1 AND language=$2 AND version=$3`, id, language, domain.CourseVersion).Scan(&data)
if errors.Is(err, sql.ErrNoRows) {
return out, ErrNotFound
}
if err != nil {
return out, err
}
err = json.Unmarshal(data, &out)
return out, err
}
func (s *AdaptiveStore) Task(ctx context.Context, user, language, id string) (domain.AdaptiveTask, error) {
var t domain.AdaptiveTask
var data []byte
var brief, exam sql.NullString
var presentations int
err := s.db.QueryRowContext(ctx, `SELECT id,data,source,brief_id,exam_id,created_at,presentation_count FROM course_v2_tasks WHERE id=$1 AND language=$2 AND version=$3 AND (owner_id=$4 OR owner_id IS NULL)`, id, language, domain.CourseVersion, user).Scan(&t.ID, &data, &t.Source, &brief, &exam, &t.CreatedAt, &presentations)
if errors.Is(err, sql.ErrNoRows) {
return t, ErrNotFound
}
if err != nil {
return t, err
}
idCopy, source, created := t.ID, t.Source, t.CreatedAt
if err = json.Unmarshal(data, &t); err != nil {
return t, err
}
t.ID = idCopy
t.Source = source
t.CreatedAt = created
t.BriefID = brief.String
t.ExamID = exam.String
if t.Source == "curated" && t.ExamID == "" {
t.Review = t.Review || presentations > 1
}
return t, nil
}
func (s *AdaptiveStore) History(ctx context.Context, user, language, module string, offset int) ([]domain.AdaptiveTask, error) {
rows, err := s.db.QueryContext(ctx, `SELECT id FROM course_v2_tasks WHERE owner_id=$1 AND language=$2 AND version=$3 AND module_id=$4 AND exam_id IS NULL ORDER BY created_at DESC,id DESC LIMIT 25 OFFSET $5`, user, language, domain.CourseVersion, module, offset)
if err != nil {
return nil, err
}
ids := []string{}
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
rows.Close()
return nil, err
}
ids = append(ids, id)
}
err = rows.Err()
rows.Close()
if err != nil {
return nil, err
}
tasks := []domain.AdaptiveTask{}
for _, id := range ids {
t, err := s.Task(ctx, user, language, id)
if err != nil {
return nil, err
}
tasks = append(tasks, t.Public(false))
}
return tasks, nil
}
func (s *AdaptiveStore) Reserve(ctx context.Context, user, language, module, skill string) (domain.AdaptiveTask, error) {
var id string
err := s.db.QueryRowContext(ctx, `SELECT t.id FROM course_v2_tasks t WHERE t.source='seed' AND t.owner_id IS NULL AND t.language=$1 AND t.version=$2 AND t.module_id=$3 AND ($4='' OR t.skill=$4) ORDER BY (SELECT count(*) FROM course_v2_attempts a WHERE a.task_id=t.id AND a.user_id=$5),t.created_at,t.id LIMIT 1`, language, domain.CourseVersion, module, skill, user).Scan(&id)
if errors.Is(err, sql.ErrNoRows) {
return domain.AdaptiveTask{}, ErrNotFound
}
if err != nil {
return domain.AdaptiveTask{}, err
}
return s.Task(ctx, user, language, id)
}
func fingerprint(t domain.AdaptiveTask) string {
// Include task kind, context and options: similar wording with different
// reading passages or answer choices is not the same exercise.
data, _ := json.Marshal([]any{t.Skill, t.Kind, strings.ToLower(strings.Join(strings.Fields(t.Prompt), " ")), t.Passage, t.ReferenceText, t.AudioText, t.Options})
h := sha256.Sum256(data)
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"
}
t.SchemaVersion = 2
t.CourseVersion = domain.CourseVersion
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return t, err
}
defer tx.Rollback()
var previous []byte
err = tx.QueryRowContext(ctx, `SELECT result FROM course_v2_jobs WHERE id=$1 AND user_id=$2 AND lease=$3 AND status='running' FOR UPDATE`, j.ID, j.UserID, j.Lease).Scan(&previous)
if errors.Is(err, sql.ErrNoRows) {
return t, errors.New("job lease lost")
}
if err != nil {
return t, err
}
if len(previous) > 0 {
var result struct {
TaskID string `json:"task_id"`
Review bool `json:"review"`
}
if err = json.Unmarshal(previous, &result); err != nil {
return t, err
}
if result.TaskID != "" {
if err = tx.Commit(); err != nil {
return t, err
}
old, err := s.Task(ctx, j.UserID, j.Language, result.TaskID)
old.Review = result.Review
return old, err
}
}
data, err := json.Marshal(t)
if err != nil {
return t, err
}
result, err := tx.ExecContext(ctx, `INSERT INTO course_v2_tasks(id,module_id,language,version,owner_id,source,skill,kind,data,fingerprint,brief_id,generation_job) VALUES($1,$2,$3,$4,$5,$12,$6,$7,$8,$9,NULLIF($10,''),$11) ON CONFLICT DO NOTHING`, t.ID, t.ModuleID, t.TargetLanguage, t.CourseVersion, j.UserID, t.Skill, t.Kind, data, fingerprint(t), t.BriefID, j.ID, t.Source)
if err != nil {
return t, err
}
count, err := result.RowsAffected()
if err != nil {
return t, err
}
if count == 0 {
err = tx.QueryRowContext(ctx, `SELECT id FROM course_v2_tasks WHERE owner_id=$1 AND language=$2 AND version=$3 AND module_id=$4 AND fingerprint=$5 AND exam_id IS NULL`, j.UserID, t.TargetLanguage, t.CourseVersion, t.ModuleID, fingerprint(t)).Scan(&t.ID)
if err != nil {
return t, err
}
t.Review = true
}
saved, err := json.Marshal(map[string]any{"task_id": t.ID, "source": t.Source, "review": t.Review})
if err != nil {
return t, err
}
if _, err = tx.ExecContext(ctx, `UPDATE course_v2_jobs SET result=$2 WHERE id=$1`, j.ID, saved); err != nil {
return t, err
}
if err = tx.Commit(); err != nil {
return t, err
}
review := t.Review
t, err = s.Task(ctx, j.UserID, j.Language, t.ID)
t.Review = review
return t, err
}
func (s *AdaptiveStore) LatestAnalysis(ctx context.Context, user, language string) (*domain.CourseAnalysis, error) {
var data []byte
var version int64
var created time.Time
err := s.db.QueryRowContext(ctx, `SELECT data,facts_version,created_at FROM course_v2_analyses WHERE user_id=$1 AND language=$2 AND version=$3 ORDER BY facts_version DESC LIMIT 1`, user, language, domain.CourseVersion).Scan(&data, &version, &created)
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
if err != nil {
return nil, err
}
var out domain.CourseAnalysis
err = json.Unmarshal(data, &out)
out.FactsVersion = version
out.CreatedAt = created
return &out, err
}
func (s *AdaptiveStore) SaveAnalysis(ctx context.Context, user string, a domain.CourseAnalysis) error {
data, err := json.Marshal(a)
if err != nil {
return err
}
_, err = s.db.ExecContext(ctx, `INSERT INTO course_v2_analyses(id,user_id,language,version,facts_version,data) VALUES($1,$2,$3,$4,$5,$6) ON CONFLICT(user_id,language,version,facts_version) DO NOTHING`, NewID("analysis"), user, a.TargetLanguage, domain.CourseVersion, a.FactsVersion, data)
return err
}
func (s *AdaptiveStore) SaveBrief(ctx context.Context, user string, version int64, b domain.CourseBrief) (domain.CourseBrief, error) {
b.ID = NewID("brief")
data, err := json.Marshal(b)
if err != nil {
return b, err
}
_, err = s.db.ExecContext(ctx, `INSERT INTO course_v2_briefs(id,user_id,language,version,facts_version,data) VALUES($1,$2,$3,$4,$5,$6)`, b.ID, user, b.TargetLanguage, domain.CourseVersion, version, data)
return b, err
}
func (s *AdaptiveStore) Brief(ctx context.Context, user, id string) (domain.CourseBrief, error) {
var data []byte
var b domain.CourseBrief
err := s.db.QueryRowContext(ctx, `SELECT data FROM course_v2_briefs WHERE id=$1 AND user_id=$2`, id, user).Scan(&data)
if errors.Is(err, sql.ErrNoRows) {
return b, ErrNotFound
}
if err != nil {
return b, err
}
err = json.Unmarshal(data, &b)
return b, err
}
func (s *AdaptiveStore) Snapshot(ctx context.Context, user, language, uiLanguage string) (domain.CourseSnapshot, error) {
out := domain.CourseSnapshot{TargetLanguage: language, CourseVersion: domain.CourseVersion, CEFRLevel: "A1", UILanguage: uiLanguage, Progress: []domain.SkillProgress{}, RecentTasks: []domain.AdaptiveTask{}, RecentAttempts: []domain.AdaptiveAttempt{}, RecentPrompts: []string{}}
var err error
out.Modules, err = s.Modules(ctx, language)
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 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
}
for rows.Next() {
var p domain.SkillProgress
if err := rows.Scan(&p.ModuleID, &p.Skill, &p.Attempts, &p.DistinctTasks, &p.AverageScore, &p.EvidenceID); err != nil {
rows.Close()
return out, err
}
out.Progress = append(out.Progress, p)
}
err = rows.Err()
rows.Close()
if err != nil {
return out, err
}
rows, err = s.db.QueryContext(ctx, `SELECT a.id 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')) ORDER BY a.created_at DESC,a.id DESC LIMIT 20`, user, language, domain.CourseVersion)
if err != nil {
return out, err
}
ids := []string{}
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
rows.Close()
return out, err
}
ids = append(ids, id)
}
err = rows.Err()
rows.Close()
if err != nil {
return out, err
}
recentTaskIDs := map[string]bool{}
for _, id := range ids {
a, err := s.Attempt(ctx, user, language, id)
if err != nil {
return out, err
}
out.RecentAttempts = append(out.RecentAttempts, a)
if !recentTaskIDs[a.TaskID] {
t, err := s.Task(ctx, user, language, a.TaskID)
if err != nil {
return out, err
}
out.RecentTasks = append(out.RecentTasks, t)
recentTaskIDs[a.TaskID] = true
}
}
rows, err = s.db.QueryContext(ctx, `SELECT data->>'prompt' FROM course_v2_tasks WHERE owner_id=$1 AND language=$2 AND version=$3 ORDER BY created_at DESC LIMIT 10`, user, language, domain.CourseVersion)
if err != nil {
return out, err
}
for rows.Next() {
var p string
if err := rows.Scan(&p); err != nil {
rows.Close()
return out, err
}
out.RecentPrompts = append(out.RecentPrompts, p)
}
err = rows.Err()
rows.Close()
if err != nil {
return out, err
}
out.PreviousAnalysis, err = s.LatestAnalysis(ctx, user, language)
return out, err
}
const adaptiveAttemptSelect = `SELECT a.id,a.task_id,t.module_id,t.language,t.skill,a.answer,a.status,a.evaluation,a.speech,a.exam_id,a.demo,a.created_at FROM course_v2_attempts a JOIN course_v2_tasks t ON t.id=a.task_id `
func scanAdaptiveAttempt(row interface{ Scan(...any) error }) (domain.AdaptiveAttempt, error) {
var a domain.AdaptiveAttempt
var evaluation, speech []byte
var exam sql.NullString
err := row.Scan(&a.ID, &a.TaskID, &a.ModuleID, &a.TargetLanguage, &a.Skill, &a.Answer, &a.Status, &evaluation, &speech, &exam, &a.Demo, &a.CreatedAt)
if errors.Is(err, sql.ErrNoRows) {
return a, ErrNotFound
}
if err != nil {
return a, err
}
a.ExamID = exam.String
if len(evaluation) > 0 {
if err := json.Unmarshal(evaluation, &a.Evaluation); err != nil {
return a, err
}
}
if len(speech) > 0 {
if err := json.Unmarshal(speech, &a.Speech); err != nil {
return a, err
}
}
return a, nil
}
func (s *AdaptiveStore) Attempt(ctx context.Context, user, language, id string) (domain.AdaptiveAttempt, error) {
return scanAdaptiveAttempt(s.db.QueryRowContext(ctx, adaptiveAttemptSelect+`WHERE a.id=$1 AND a.user_id=$2 AND t.language=$3 AND t.version=$4`, id, user, language, domain.CourseVersion))
}
func (s *AdaptiveStore) AttemptByRequest(ctx context.Context, user, language, request string) (domain.AdaptiveAttempt, error) {
return scanAdaptiveAttempt(s.db.QueryRowContext(ctx, adaptiveAttemptSelect+`WHERE a.request_id=$1 AND a.user_id=$2 AND t.language=$3 AND t.version=$4`, request, user, language, domain.CourseVersion))
}
func (s *AdaptiveStore) Submit(ctx context.Context, user, request string, t domain.AdaptiveTask, answer string, speech *domain.PronunciationResult) (domain.AdaptiveAttempt, error) {
if a, err := s.AttemptByRequest(ctx, user, t.TargetLanguage, request); err == nil {
if a.TaskID != t.ID {
return a, fmt.Errorf("%w: request ID belongs to another task", ErrCourseConflict)
}
return a, nil
} else if !errors.Is(err, ErrNotFound) {
return a, err
}
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return domain.AdaptiveAttempt{}, err
}
defer tx.Rollback()
if t.ExamID != "" {
var status string
err = tx.QueryRowContext(ctx, `SELECT status FROM course_v2_exams WHERE id=$1 AND user_id=$2 FOR UPDATE`, t.ExamID, user).Scan(&status)
if err != nil {
return domain.AdaptiveAttempt{}, err
}
if status != "in_progress" {
return domain.AdaptiveAttempt{}, fmt.Errorf("%w: exam is not accepting answers", ErrCourseConflict)
}
}
id := NewID("a2a")
var speechData any
demo := false
if speech != nil {
b, err := json.Marshal(speech)
if err != nil {
return domain.AdaptiveAttempt{}, err
}
speechData = b
demo = speech.Provider != "azure"
}
_, err = tx.ExecContext(ctx, `INSERT INTO course_v2_attempts(id,user_id,task_id,request_id,answer,status,speech,demo,exam_id) VALUES($1,$2,$3,$4,$5,'pending',$6,$7,NULLIF($8,'')) ON CONFLICT DO NOTHING`, id, user, t.ID, request, answer, speechData, demo, t.ExamID)
if err != nil {
return domain.AdaptiveAttempt{}, err
}
if speech != nil && speech.Provider == "azure" && t.Kind == "repeat_sentence" {
var actualID string
var actualTime time.Time
// The persisted row, not a competing request's candidate ID, is authoritative.
if err = tx.QueryRowContext(ctx, `SELECT id,created_at FROM course_v2_attempts WHERE user_id=$1 AND task_id=$2 AND (request_id=$3 OR (exam_id IS NOT NULL AND exam_id=$4))`, user, t.ID, request, t.ExamID).Scan(&actualID, &actualTime); err != nil {
return domain.AdaptiveAttempt{}, err
}
if actualID == id {
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
}
}
}
if err = tx.Commit(); err != nil {
return domain.AdaptiveAttempt{}, err
}
a, err := s.AttemptByRequest(ctx, user, t.TargetLanguage, request)
if errors.Is(err, ErrNotFound) && t.ExamID != "" {
a, err = scanAdaptiveAttempt(s.db.QueryRowContext(ctx, adaptiveAttemptSelect+`WHERE a.user_id=$1 AND a.task_id=$2 AND a.exam_id=$3`, user, t.ID, t.ExamID))
}
if err == nil && a.TaskID != t.ID {
return domain.AdaptiveAttempt{}, fmt.Errorf("%w: request ID belongs to another task", ErrCourseConflict)
}
return a, err
}
func (s *AdaptiveStore) Grade(ctx context.Context, user, language, id string, e domain.CourseEvaluation) error {
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
data, err := json.Marshal(e)
if err != nil {
return err
}
var demo bool
err = tx.QueryRowContext(ctx, `UPDATE course_v2_attempts a SET status='graded',evaluation=$3 FROM course_v2_tasks t WHERE a.id=$1 AND a.user_id=$2 AND t.id=a.task_id AND t.language=$4 AND t.version=$5 AND a.status<>'graded' RETURNING a.demo`, id, user, data, language, domain.CourseVersion).Scan(&demo)
if errors.Is(err, sql.ErrNoRows) {
return nil
}
if err != nil {
return err
}
if !demo {
_, err = tx.ExecContext(ctx, `INSERT INTO course_v2_versions(user_id,language,version,facts_version) VALUES($1,$2,$3,1) ON CONFLICT(user_id,language,version) DO UPDATE SET facts_version=course_v2_versions.facts_version+1`, user, language, domain.CourseVersion)
if err != nil {
return err
}
}
return tx.Commit()
}
func (s *AdaptiveStore) FailAttempt(ctx context.Context, user, id string) error {
_, err := s.db.ExecContext(ctx, `UPDATE course_v2_attempts SET status='failed' WHERE id=$1 AND user_id=$2 AND status<>'graded'`, id, user)
return err
}
func (s *AdaptiveStore) importLegacy(ctx context.Context) error {
// One-way, idempotent copies preserve the original tables and IDs. The new
// course receives evidence from both old course attempts and speech attempts.
rows, err := s.db.QueryContext(ctx, `SELECT t.id,t.module_id,t.skill,t.kind,t.prompt,t.passage,t.audio_text,t.options_json,t.solution,t.explanation,t.source,t.owner_user_id,t.pronunciation_exercise_id FROM course_tasks t WHERE t.module_id='a1_introductions_v1'`)
if err != nil {
return err
}
type legacy struct {
id, exercise string
t domain.AdaptiveTask
owner sql.NullString
}
items := []legacy{}
for rows.Next() {
var x legacy
var options []byte
var exercise sql.NullString
x.t = domain.AdaptiveTask{SchemaVersion: 2, ModuleID: "a1_introductions_v1", TargetLanguage: "en-US", CourseVersion: domain.CourseVersion, CEFRLevel: "A1", OriginModuleKey: "introductions"}
var solution, explanation string
if err := rows.Scan(&x.id, &x.t.ModuleID, &x.t.Skill, &x.t.Kind, &x.t.Prompt, &x.t.Passage, &x.t.AudioText, &options, &solution, &explanation, &x.t.Source, &x.owner, &exercise); err != nil {
rows.Close()
return err
}
labels := []string{}
if err := json.Unmarshal(options, &labels); err != nil {
rows.Close()
return err
}
x.t.AnswerKey = &domain.TaskKey{ReferenceAnswer: solution, Rubric: []string{"Evaluate the intended A1 meaning; accept valid alternative answers."}, Explanation: explanation}
for i, label := range labels {
option := domain.TaskOption{ID: fmt.Sprintf("o%d", i+1), Label: label}
x.t.Options = append(x.t.Options, option)
if label == solution {
x.t.AnswerKey.CorrectOptionID = option.ID
}
}
if x.t.Skill == "pronunciation" {
x.t.Skill = "speaking"
x.t.Kind = "repeat_sentence"
}
x.t.ID = "a2_legacy_" + x.id
x.exercise = exercise.String
items = append(items, x)
}
err = rows.Err()
rows.Close()
if err != nil {
return err
}
for _, x := range items {
if x.exercise != "" {
var ref string
if err := s.db.QueryRowContext(ctx, `SELECT target_text FROM exercises WHERE id=$1`, x.exercise).Scan(&ref); err != nil {
return err
}
x.t.ReferenceText = ref
}
data, err := json.Marshal(x.t)
if err != nil {
return err
}
_, err = s.db.ExecContext(ctx, `INSERT INTO course_v2_tasks(id,module_id,language,version,owner_id,source,skill,kind,data,fingerprint,legacy_id) VALUES($1,$2,'en-US',$3,$4,$5,$6,$7,$8,$9,$10) ON CONFLICT DO NOTHING`, x.t.ID, x.t.ModuleID, domain.CourseVersion, x.owner, x.t.Source, x.t.Skill, x.t.Kind, data, "legacy:"+x.id, x.id)
if err != nil {
return err
}
}
// Preserve historic boolean grading without pretending it was agent analysis.
_, err = s.db.ExecContext(ctx, `INSERT INTO course_v2_attempts(id,user_id,task_id,request_id,answer,status,evaluation,legacy_id,created_at)
SELECT 'a2a_legacy_'||a.id,a.user_id,t.id,'legacy:'||a.id,a.answer,'graded',jsonb_build_object('score',CASE WHEN a.correct THEN 100 ELSE 0 END,'verdict',CASE WHEN a.correct THEN 'correct' ELSE 'incorrect' END,'feedback','Aus bisherigem Kurs übernommen.','issues','[]'::jsonb),a.id,a.created_at
FROM course_attempts a JOIN course_v2_tasks t ON t.legacy_id=a.task_id ON CONFLICT DO NOTHING`)
if err != nil {
return err
}
_, err = s.db.ExecContext(ctx, `INSERT INTO course_v2_attempts(id,user_id,task_id,request_id,answer,status,evaluation,speech,demo,legacy_id,created_at)
SELECT 'a2a_speech_'||a.id,a.user_id,t.id,'speech:'||a.id,a.recognized_text,'graded',jsonb_build_object('score',a.overall_score,'verdict',CASE WHEN a.overall_score>=75 THEN 'correct' ELSE 'partial' END,'feedback',a.teacher_feedback,'issues','[]'::jsonb),jsonb_build_object('recognized_text',a.recognized_text,'overall_score',a.overall_score,'accuracy_score',a.accuracy_score,'fluency_score',a.fluency_score,'completeness_score',a.completeness_score,'word_scores',a.word_scores_json,'provider','legacy'),true,'speech:'||a.id,a.created_at
FROM attempts a JOIN course_tasks old ON old.pronunciation_exercise_id=a.exercise_id JOIN course_v2_tasks t ON t.legacy_id=old.id ON CONFLICT DO NOTHING`)
// Older speech attempts did not record provider provenance. Keep them visible
// but do not claim that potentially mocked measurements certify completion.
if err != nil {
return err
}
_, err = s.db.ExecContext(ctx, `INSERT INTO course_v2_versions(user_id,language,version,facts_version)
SELECT a.user_id,t.language,t.version,count(*) FROM course_v2_attempts a JOIN course_v2_tasks t ON t.id=a.task_id WHERE a.status='graded' AND NOT a.demo GROUP BY a.user_id,t.language,t.version
ON CONFLICT(user_id,language,version) DO UPDATE SET facts_version=GREATEST(course_v2_versions.facts_version,EXCLUDED.facts_version)`)
return err
}
func (s *AdaptiveStore) LatestTaskAttempt(ctx context.Context, user, language, task string) (*domain.AdaptiveAttempt, error) {
a, err := scanAdaptiveAttempt(s.db.QueryRowContext(ctx, adaptiveAttemptSelect+`WHERE a.user_id=$1 AND t.language=$2 AND a.task_id=$3 ORDER BY a.created_at DESC,a.id DESC LIMIT 1`, user, language, task))
if errors.Is(err, ErrNotFound) {
return nil, nil
}
return &a, err
}
func (s *AdaptiveStore) SyncLegacy(ctx context.Context) error { return s.importLegacy(ctx) }
func (s *AdaptiveStore) SyncLegacyForExercise(ctx context.Context, exercise string) error {
var linked bool
if err := s.db.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM course_tasks WHERE pronunciation_exercise_id=$1)`, exercise).Scan(&linked); err != nil {
return err
}
if linked {
return s.importLegacy(ctx)
}
return nil
}