Direkte DeepSeek- und Mistral-Anbindung mit versionierten Aktionsprofilen, Budgetreservierung, Tokenabrechnung und administrativen Qualitätsprüfungen ersetzen die Flowise-Abhängigkeit im regulären Betrieb. 840 geprüfte A1-Aufgaben mit geschützter Testauswertung und konkreten offenen Arbeitsaufträgen ergänzen den Kurs. Inhalts- und Sprachbewertung bleiben von Azure-Aussprachewerten getrennt; historische Aufgaben und Antworten bleiben erhalten. Echte Wort- und Phonemmessungen werden mit Herkunft, Aktualität und Nachweisdichte gebündelt. Go bestimmt Trainingsziele und Wiederholungen, das Modell formuliert dazu passende Nachsprechübungen. Profilansicht und Auswahlgründe werden angezeigt. Validierung: Go-Race-Tests mit lokaler PostgreSQL-Integration, go vet, Web-Build, Audit aller 840 Aufgaben und drei Browser-Smokes mit lokalen Modell-/Speech-Fixtures bestanden. Keine Produktionsänderungen oder Live-Aufrufe.
580 lines
23 KiB
Go
580 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 = 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
|
|
}
|