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 = 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.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 } err = s.db.QueryRowContext(ctx, `SELECT COALESCE((SELECT facts_version FROM course_v2_versions WHERE user_id=$1 AND language=$2 AND version=$3),0)`, user, language, domain.CourseVersion).Scan(&out.FactsVersion) if err != nil { return out, err } rows, err := s.db.QueryContext(ctx, `SELECT t.module_id,t.skill,count(*),count(DISTINCT t.id),avg((a.evaluation->>'score')::float8),(array_agg(a.id ORDER BY a.created_at DESC,a.id DESC))[1] 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:"+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 }