Files
Speech/apps/api/internal/store/store.go
T
Eugenius Naumenko bac840e091 Flowise-Übungen stabilisieren und Lernfortschritt korrigieren
Vermeide kürzlich angezeigte Sätze bei neuen Übungen und frage Flowise bei Wiederholungen einmal erneut. Validiere strukturierte Antworten, protokolliere die Übungsquelle und schütze nutzerspezifische Übungs-IDs.

Berechne schwierige Wörter anhand der neuesten Aussprache pro Wort. Passe das Lehrerfeedback an gute Bewertungen an und verbessere das Laden neuer Übungen im Web. Ergänze gezielte Go-Tests.
2026-10-07 20:52:02 +00:00

657 lines
24 KiB
Go

package store
import (
"context"
"crypto/rand"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"strings"
"speech-learning-api/internal/domain"
)
var ErrNotFound = errors.New("not found")
type PostgresStore struct {
db *sql.DB
}
func NewPostgresStore(db *sql.DB) *PostgresStore {
return &PostgresStore{db: db}
}
func NewID(prefix string) string {
var b [12]byte
if _, err := rand.Read(b[:]); err != nil {
panic(err)
}
return prefix + "_" + hex.EncodeToString(b[:])
}
func (s *PostgresStore) Init(ctx context.Context) error {
if _, err := s.db.ExecContext(ctx, schemaSQL); err != nil {
return err
}
for _, stmt := range seedSQL {
if _, err := s.db.ExecContext(ctx, stmt); err != nil {
return err
}
}
return nil
}
func (s *PostgresStore) EnsureGeneratedLesson(ctx context.Context, targetLanguage, cefrLevel string) (domain.Lesson, error) {
lesson := domain.Lesson{
ID: "les_generated_" + strings.ToLower(strings.ReplaceAll(targetLanguage, "-", "_")) + "_" + strings.ToLower(cefrLevel),
TargetLanguage: targetLanguage,
CEFRLevel: cefrLevel,
Topic: "agent_generated",
Title: "Agent generated practice",
}
row := s.db.QueryRowContext(ctx, `
INSERT INTO lessons (id, target_language, cefr_level, topic, title)
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (id) DO UPDATE SET
target_language = EXCLUDED.target_language,
cefr_level = EXCLUDED.cefr_level,
topic = EXCLUDED.topic,
title = EXCLUDED.title
RETURNING id, target_language, cefr_level, topic, title
`, lesson.ID, lesson.TargetLanguage, lesson.CEFRLevel, lesson.Topic, lesson.Title)
if err := row.Scan(&lesson.ID, &lesson.TargetLanguage, &lesson.CEFRLevel, &lesson.Topic, &lesson.Title); err != nil {
return domain.Lesson{}, err
}
return lesson, nil
}
func (s *PostgresStore) SaveGeneratedExercise(ctx context.Context, userID string, generated domain.GeneratedExercise) (domain.Lesson, domain.Exercise, error) {
targetLanguage := valueOr(generated.TargetLanguage, "en-US")
cefrLevel := valueOr(generated.CEFRLevel, "A1")
lesson, err := s.EnsureGeneratedLesson(ctx, targetLanguage, cefrLevel)
if err != nil {
return domain.Lesson{}, domain.Exercise{}, err
}
focusPoints, err := json.Marshal(generated.FocusPoints)
if err != nil {
return domain.Lesson{}, domain.Exercise{}, err
}
successCriteria, err := json.Marshal(generated.SuccessCriteria)
if err != nil {
return domain.Lesson{}, domain.Exercise{}, err
}
exercise := domain.Exercise{
ID: NewID("exg"),
LessonID: lesson.ID,
TargetLanguage: targetLanguage,
CEFRLevel: cefrLevel,
Type: valueOr(generated.ExerciseType, "repeat_sentence"),
PromptText: valueOr(generated.DisplayPrompt, "Sprich den Satz klar nach."),
TargetText: generated.ReferenceText,
Difficulty: 1,
Source: "flowise",
}
if strings.TrimSpace(exercise.TargetText) == "" {
return domain.Lesson{}, domain.Exercise{}, errors.New("generated exercise reference_text is required")
}
row := s.db.QueryRowContext(ctx, `
INSERT INTO exercises (
id, lesson_id, target_language, cefr_level, type, prompt_text, target_text,
difficulty, source, created_by_user_id, tts_text, focus_points_json,
success_criteria_json, reason_for_choice, agent_context_json
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'flowise', $9, $10, $11, $12, $13, $14)
RETURNING id, lesson_id, target_language, cefr_level, type, prompt_text, target_text, difficulty, source
`, exercise.ID, exercise.LessonID, exercise.TargetLanguage, exercise.CEFRLevel, exercise.Type,
exercise.PromptText, exercise.TargetText, exercise.Difficulty, userID, generated.TTSText,
string(focusPoints), string(successCriteria), generated.ReasonForChoice, mustJSON(generated))
if err := row.Scan(&exercise.ID, &exercise.LessonID, &exercise.TargetLanguage, &exercise.CEFRLevel, &exercise.Type, &exercise.PromptText, &exercise.TargetText, &exercise.Difficulty, &exercise.Source); err != nil {
return domain.Lesson{}, domain.Exercise{}, err
}
return lesson, exercise, nil
}
func (s *PostgresStore) DebugStatus(ctx context.Context) domain.DebugDBStatus {
status := domain.DebugDBStatus{
Counts: map[string]int{},
}
if err := s.db.PingContext(ctx); err != nil {
status.Error = err.Error()
return status
}
status.OK = true
for _, table := range []string{"users", "learner_profiles", "language_profiles", "lessons", "exercises", "attempts", "conversation_sessions"} {
var count int
if err := s.db.QueryRowContext(ctx, fmt.Sprintf("SELECT COUNT(*) FROM %s", table)).Scan(&count); err != nil {
status.OK = false
status.Error = err.Error()
return status
}
status.Counts[table] = count
}
_ = s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM language_profiles WHERE code = 'en-US'`).Scan(&status.SeedLanguageCount)
_ = s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM exercises WHERE target_language = 'en-US' AND cefr_level = 'A1'`).Scan(&status.SeedExerciseCount)
return status
}
func (s *PostgresStore) CreateUser(ctx context.Context, email, passwordHash, uiLanguage string) (domain.User, error) {
user := domain.User{ID: NewID("usr"), Email: strings.ToLower(strings.TrimSpace(email)), UILanguage: uiLanguage}
row := s.db.QueryRowContext(ctx, `
INSERT INTO users (id, email, password_hash, ui_language)
VALUES ($1, $2, $3, $4)
RETURNING id, email, ui_language, created_at
`, user.ID, user.Email, passwordHash, uiLanguage)
if err := row.Scan(&user.ID, &user.Email, &user.UILanguage, &user.CreatedAt); err != nil {
return domain.User{}, err
}
return user, nil
}
func (s *PostgresStore) GetPasswordHashByEmail(ctx context.Context, email string) (domain.User, string, error) {
var user domain.User
var hash string
row := s.db.QueryRowContext(ctx, `
SELECT id, email, password_hash, ui_language, created_at
FROM users
WHERE email = $1
`, strings.ToLower(strings.TrimSpace(email)))
if err := row.Scan(&user.ID, &user.Email, &hash, &user.UILanguage, &user.CreatedAt); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return domain.User{}, "", ErrNotFound
}
return domain.User{}, "", err
}
return user, hash, nil
}
func (s *PostgresStore) GetUser(ctx context.Context, id string) (domain.User, error) {
var user domain.User
row := s.db.QueryRowContext(ctx, `
SELECT id, email, ui_language, created_at
FROM users
WHERE id = $1
`, id)
if err := row.Scan(&user.ID, &user.Email, &user.UILanguage, &user.CreatedAt); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return domain.User{}, ErrNotFound
}
return domain.User{}, err
}
return user, nil
}
func (s *PostgresStore) CreateLearnerProfile(ctx context.Context, userID, targetLanguage, cefrLevel string, dailyGoalMinutes int) (domain.LearnerProfile, error) {
profile := domain.LearnerProfile{
ID: NewID("lrn"),
UserID: userID,
TargetLanguage: targetLanguage,
CEFRLevel: cefrLevel,
DailyGoalMinutes: dailyGoalMinutes,
}
row := s.db.QueryRowContext(ctx, `
INSERT INTO learner_profiles (id, user_id, target_language, cefr_level, daily_goal_minutes)
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (user_id, target_language) DO UPDATE SET
cefr_level = EXCLUDED.cefr_level,
daily_goal_minutes = EXCLUDED.daily_goal_minutes
RETURNING id, user_id, target_language, cefr_level, daily_goal_minutes, created_at
`, profile.ID, userID, targetLanguage, cefrLevel, dailyGoalMinutes)
if err := row.Scan(&profile.ID, &profile.UserID, &profile.TargetLanguage, &profile.CEFRLevel, &profile.DailyGoalMinutes, &profile.CreatedAt); err != nil {
return domain.LearnerProfile{}, err
}
return profile, nil
}
func (s *PostgresStore) GetPrimaryProfile(ctx context.Context, userID string) (domain.LearnerProfile, error) {
var p domain.LearnerProfile
row := s.db.QueryRowContext(ctx, `
SELECT id, user_id, target_language, cefr_level, daily_goal_minutes, created_at
FROM learner_profiles
WHERE user_id = $1
ORDER BY created_at
LIMIT 1
`, userID)
if err := row.Scan(&p.ID, &p.UserID, &p.TargetLanguage, &p.CEFRLevel, &p.DailyGoalMinutes, &p.CreatedAt); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return domain.LearnerProfile{}, ErrNotFound
}
return domain.LearnerProfile{}, err
}
return p, nil
}
func (s *PostgresStore) UpdatePreferences(ctx context.Context, userID, uiLanguage, targetLanguage, cefrLevel string, dailyGoalMinutes int) (domain.LearnerProfile, error) {
if uiLanguage != "" {
if _, err := s.db.ExecContext(ctx, `UPDATE users SET ui_language = $1 WHERE id = $2`, uiLanguage, userID); err != nil {
return domain.LearnerProfile{}, err
}
}
if dailyGoalMinutes <= 0 {
dailyGoalMinutes = 10
}
return s.CreateLearnerProfile(ctx, userID, valueOr(targetLanguage, "en-US"), valueOr(cefrLevel, "A1"), dailyGoalMinutes)
}
func (s *PostgresStore) ListLanguages(ctx context.Context) ([]domain.LanguageProfile, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT code, display_name, azure_locale, default_tts_voice, voices_json,
supports_pronunciation_assessment, supports_prosody
FROM language_profiles
ORDER BY code
`)
if err != nil {
return nil, err
}
defer rows.Close()
var out []domain.LanguageProfile
for rows.Next() {
item, err := scanLanguage(rows)
if err != nil {
return nil, err
}
out = append(out, item)
}
return out, rows.Err()
}
func (s *PostgresStore) GetLanguage(ctx context.Context, code string) (domain.LanguageProfile, error) {
row := s.db.QueryRowContext(ctx, `
SELECT code, display_name, azure_locale, default_tts_voice, voices_json,
supports_pronunciation_assessment, supports_prosody
FROM language_profiles
WHERE code = $1
`, code)
lang, err := scanLanguage(row)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return domain.LanguageProfile{}, ErrNotFound
}
return domain.LanguageProfile{}, err
}
return lang, nil
}
func (s *PostgresStore) NextLessonAndExercise(ctx context.Context, profile domain.LearnerProfile, avoidReferenceText ...string) (domain.Lesson, domain.Exercise, error) {
var lesson domain.Lesson
var exercise domain.Exercise
row := s.db.QueryRowContext(ctx, `
SELECT l.id, l.target_language, l.cefr_level, l.topic, l.title,
e.id, e.lesson_id, e.target_language, e.cefr_level, e.type,
e.prompt_text, e.target_text, e.difficulty, COALESCE(e.source, 'seed')
FROM exercises e
JOIN lessons l ON l.id = e.lesson_id
WHERE e.target_language = $1 AND e.cefr_level = $2
AND COALESCE(e.source, 'seed') = 'seed'
AND NOT EXISTS (
SELECT 1 FROM jsonb_array_elements_text($4::jsonb) AS avoided(sentence)
WHERE lower(trim(avoided.sentence)) = lower(trim(e.target_text))
)
ORDER BY (
SELECT COUNT(*)
FROM attempts a
WHERE a.exercise_id = e.id AND a.user_id = $3
), e.difficulty, e.id
LIMIT 1
`, profile.TargetLanguage, profile.CEFRLevel, profile.UserID, mustJSON(avoidReferenceText))
if err := row.Scan(
&lesson.ID, &lesson.TargetLanguage, &lesson.CEFRLevel, &lesson.Topic, &lesson.Title,
&exercise.ID, &exercise.LessonID, &exercise.TargetLanguage, &exercise.CEFRLevel, &exercise.Type,
&exercise.PromptText, &exercise.TargetText, &exercise.Difficulty, &exercise.Source,
); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return domain.Lesson{}, domain.Exercise{}, ErrNotFound
}
return domain.Lesson{}, domain.Exercise{}, err
}
return lesson, exercise, nil
}
func (s *PostgresStore) GetExercise(ctx context.Context, id, userID string) (domain.Exercise, error) {
var e domain.Exercise
row := s.db.QueryRowContext(ctx, `
SELECT id, lesson_id, target_language, cefr_level, type, prompt_text, target_text, difficulty, COALESCE(source, 'seed')
FROM exercises
WHERE id = $1 AND (COALESCE(source, 'seed') = 'seed' OR created_by_user_id = $2)
`, id, userID)
if err := row.Scan(&e.ID, &e.LessonID, &e.TargetLanguage, &e.CEFRLevel, &e.Type, &e.PromptText, &e.TargetText, &e.Difficulty, &e.Source); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return domain.Exercise{}, ErrNotFound
}
return domain.Exercise{}, err
}
return e, nil
}
func (s *PostgresStore) SaveAttempt(ctx context.Context, attempt domain.Attempt) (domain.Attempt, error) {
if attempt.ID == "" {
attempt.ID = NewID("att")
}
wordScores, err := json.Marshal(attempt.WordScores)
if err != nil {
return domain.Attempt{}, err
}
row := s.db.QueryRowContext(ctx, `
INSERT INTO attempts (
id, user_id, exercise_id, target_language, recognized_text,
overall_score, accuracy_score, fluency_score, completeness_score, prosody_score,
word_scores_json, teacher_feedback
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
RETURNING created_at
`, attempt.ID, attempt.UserID, attempt.ExerciseID, attempt.TargetLanguage, attempt.RecognizedText,
attempt.OverallScore, attempt.AccuracyScore, attempt.FluencyScore, attempt.CompletenessScore, attempt.ProsodyScore,
string(wordScores), attempt.TeacherFeedback)
if err := row.Scan(&attempt.CreatedAt); err != nil {
return domain.Attempt{}, err
}
return attempt, nil
}
func (s *PostgresStore) Progress(ctx context.Context, userID string, limit int) (domain.ProgressSummary, error) {
if limit <= 0 {
limit = 10
}
var summary domain.ProgressSummary
if err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*), COALESCE(AVG(overall_score), 0)
FROM attempts
WHERE user_id = $1
`, userID).Scan(&summary.TotalAttempts, &summary.AverageScore); err != nil {
return domain.ProgressSummary{}, err
}
profile, err := s.GetPrimaryProfile(ctx, userID)
if err == nil {
summary.DailyGoalMinutes = profile.DailyGoalMinutes
}
rows, err := s.db.QueryContext(ctx, `
SELECT id, user_id, exercise_id, target_language, recognized_text,
overall_score, accuracy_score, fluency_score, completeness_score, prosody_score,
word_scores_json, teacher_feedback, created_at
FROM attempts
WHERE user_id = $1
ORDER BY created_at DESC
LIMIT $2
`, userID, limit)
if err != nil {
return domain.ProgressSummary{}, err
}
defer rows.Close()
for rows.Next() {
attempt, err := scanAttempt(rows)
if err != nil {
return domain.ProgressSummary{}, err
}
summary.RecentAttempts = append(summary.RecentAttempts, attempt)
}
if err := rows.Err(); err != nil {
return domain.ProgressSummary{}, err
}
summary.WeakWords = latestWeakWords(summary.RecentAttempts)
return summary, nil
}
// RecentAttempts are ordered newest first. A newer successful score clears an
// older weak score for the same word within the progress window.
func latestWeakWords(attempts []domain.Attempt) []domain.WordScore {
seen := make(map[string]bool)
var weak []domain.WordScore
for _, attempt := range attempts {
for _, word := range attempt.WordScores {
key := strings.ToLower(strings.TrimSpace(word.Word))
if key == "" || seen[key] {
continue
}
seen[key] = true
if word.Accuracy < 75 {
weak = append(weak, word)
}
}
}
return weak
}
func (s *PostgresStore) CreateConversationSession(ctx context.Context, userID, targetLanguage, cefrLevel string) (domain.ConversationSession, error) {
session := domain.ConversationSession{
ID: NewID("con"),
UserID: userID,
TargetLanguage: targetLanguage,
CEFRLevel: cefrLevel,
Status: "active",
}
row := s.db.QueryRowContext(ctx, `
INSERT INTO conversation_sessions (id, user_id, target_language, cefr_level, status)
VALUES ($1, $2, $3, $4, $5)
RETURNING created_at
`, session.ID, session.UserID, session.TargetLanguage, session.CEFRLevel, session.Status)
if err := row.Scan(&session.CreatedAt); err != nil {
return domain.ConversationSession{}, err
}
return session, nil
}
func (s *PostgresStore) SaveConversationTurn(ctx context.Context, turn domain.ConversationTurn) (domain.ConversationTurn, error) {
if turn.ID == "" {
turn.ID = NewID("trn")
}
row := s.db.QueryRowContext(ctx, `
INSERT INTO conversation_turns (id, session_id, speaker, text, attempt_id)
VALUES ($1, $2, $3, $4, NULLIF($5, ''))
RETURNING created_at
`, turn.ID, turn.SessionID, turn.Speaker, turn.Text, turn.AttemptID)
if err := row.Scan(&turn.CreatedAt); err != nil {
return domain.ConversationTurn{}, err
}
return turn, nil
}
func scanLanguage(scanner interface{ Scan(dest ...any) error }) (domain.LanguageProfile, error) {
var lang domain.LanguageProfile
var voicesRaw []byte
if err := scanner.Scan(
&lang.Code, &lang.DisplayName, &lang.AzureLocale, &lang.DefaultTTSVoice, &voicesRaw,
&lang.SupportsPronunciationAssessment, &lang.SupportsProsody,
); err != nil {
return domain.LanguageProfile{}, err
}
if err := json.Unmarshal(voicesRaw, &lang.Voices); err != nil {
return domain.LanguageProfile{}, err
}
return lang, nil
}
func scanAttempt(scanner interface{ Scan(dest ...any) error }) (domain.Attempt, error) {
var attempt domain.Attempt
var wordsRaw []byte
if err := scanner.Scan(
&attempt.ID, &attempt.UserID, &attempt.ExerciseID, &attempt.TargetLanguage, &attempt.RecognizedText,
&attempt.OverallScore, &attempt.AccuracyScore, &attempt.FluencyScore, &attempt.CompletenessScore, &attempt.ProsodyScore,
&wordsRaw, &attempt.TeacherFeedback, &attempt.CreatedAt,
); err != nil {
return domain.Attempt{}, err
}
if len(wordsRaw) > 0 {
_ = json.Unmarshal(wordsRaw, &attempt.WordScores)
}
return attempt, nil
}
func valueOr(value, fallback string) string {
if strings.TrimSpace(value) == "" {
return fallback
}
return value
}
func mustJSON(value any) string {
body, err := json.Marshal(value)
if err != nil {
return "{}"
}
return string(body)
}
const schemaSQL = `
CREATE TABLE IF NOT EXISTS users (
id TEXT PRIMARY KEY,
email TEXT NOT NULL UNIQUE,
password_hash TEXT NOT NULL,
ui_language TEXT NOT NULL DEFAULT 'de-DE',
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE TABLE IF NOT EXISTS learner_profiles (
id TEXT PRIMARY KEY,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
target_language TEXT NOT NULL,
cefr_level TEXT NOT NULL DEFAULT 'A1',
daily_goal_minutes INT NOT NULL DEFAULT 10,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
UNIQUE (user_id, target_language)
);
CREATE TABLE IF NOT EXISTS language_profiles (
code TEXT PRIMARY KEY,
display_name TEXT NOT NULL,
azure_locale TEXT NOT NULL,
default_tts_voice TEXT NOT NULL,
voices_json JSONB NOT NULL DEFAULT '[]'::jsonb,
supports_pronunciation_assessment BOOLEAN NOT NULL DEFAULT true,
supports_prosody BOOLEAN NOT NULL DEFAULT true
);
CREATE TABLE IF NOT EXISTS lessons (
id TEXT PRIMARY KEY,
target_language TEXT NOT NULL,
cefr_level TEXT NOT NULL,
topic TEXT NOT NULL,
title TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS exercises (
id TEXT PRIMARY KEY,
lesson_id TEXT NOT NULL REFERENCES lessons(id) ON DELETE CASCADE,
target_language TEXT NOT NULL,
cefr_level TEXT NOT NULL,
type TEXT NOT NULL,
prompt_text TEXT NOT NULL,
target_text TEXT NOT NULL,
difficulty INT NOT NULL DEFAULT 1,
source TEXT NOT NULL DEFAULT 'seed',
created_by_user_id TEXT REFERENCES users(id) ON DELETE SET NULL,
tts_text TEXT NOT NULL DEFAULT '',
focus_points_json JSONB NOT NULL DEFAULT '[]'::jsonb,
success_criteria_json JSONB NOT NULL DEFAULT '[]'::jsonb,
reason_for_choice TEXT NOT NULL DEFAULT '',
agent_context_json JSONB NOT NULL DEFAULT '{}'::jsonb,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
ALTER TABLE exercises ADD COLUMN IF NOT EXISTS source TEXT NOT NULL DEFAULT 'seed';
ALTER TABLE exercises ADD COLUMN IF NOT EXISTS created_by_user_id TEXT REFERENCES users(id) ON DELETE SET NULL;
ALTER TABLE exercises ADD COLUMN IF NOT EXISTS tts_text TEXT NOT NULL DEFAULT '';
ALTER TABLE exercises ADD COLUMN IF NOT EXISTS focus_points_json JSONB NOT NULL DEFAULT '[]'::jsonb;
ALTER TABLE exercises ADD COLUMN IF NOT EXISTS success_criteria_json JSONB NOT NULL DEFAULT '[]'::jsonb;
ALTER TABLE exercises ADD COLUMN IF NOT EXISTS reason_for_choice TEXT NOT NULL DEFAULT '';
ALTER TABLE exercises ADD COLUMN IF NOT EXISTS agent_context_json JSONB NOT NULL DEFAULT '{}'::jsonb;
ALTER TABLE exercises ADD COLUMN IF NOT EXISTS created_at TIMESTAMPTZ NOT NULL DEFAULT now();
CREATE TABLE IF NOT EXISTS attempts (
id TEXT PRIMARY KEY,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
exercise_id TEXT NOT NULL REFERENCES exercises(id) ON DELETE CASCADE,
target_language TEXT NOT NULL,
recognized_text TEXT NOT NULL,
overall_score DOUBLE PRECISION NOT NULL,
accuracy_score DOUBLE PRECISION NOT NULL,
fluency_score DOUBLE PRECISION NOT NULL,
completeness_score DOUBLE PRECISION NOT NULL,
prosody_score DOUBLE PRECISION NOT NULL,
word_scores_json JSONB NOT NULL DEFAULT '[]'::jsonb,
teacher_feedback TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE TABLE IF NOT EXISTS progress_events (
id TEXT PRIMARY KEY,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
target_language TEXT NOT NULL,
event_type TEXT NOT NULL,
payload_json JSONB NOT NULL DEFAULT '{}'::jsonb,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE TABLE IF NOT EXISTS conversation_sessions (
id TEXT PRIMARY KEY,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
target_language TEXT NOT NULL,
cefr_level TEXT NOT NULL,
status TEXT NOT NULL DEFAULT 'active',
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE TABLE IF NOT EXISTS conversation_turns (
id TEXT PRIMARY KEY,
session_id TEXT NOT NULL REFERENCES conversation_sessions(id) ON DELETE CASCADE,
speaker TEXT NOT NULL,
text TEXT NOT NULL,
attempt_id TEXT REFERENCES attempts(id) ON DELETE SET NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS idx_attempts_user_created ON attempts(user_id, created_at DESC);
CREATE INDEX IF NOT EXISTS idx_exercises_language_level ON exercises(target_language, cefr_level);
`
var seedSQL = []string{
`INSERT INTO language_profiles (
code, display_name, azure_locale, default_tts_voice, voices_json,
supports_pronunciation_assessment, supports_prosody
) VALUES (
'en-US', 'English (United States)', 'en-US', 'en-US-JennyNeural',
'["en-US-JennyNeural", "en-US-GuyNeural", "en-US-AriaNeural"]'::jsonb,
true, true
) ON CONFLICT (code) DO UPDATE SET
display_name = EXCLUDED.display_name,
azure_locale = EXCLUDED.azure_locale,
default_tts_voice = EXCLUDED.default_tts_voice,
voices_json = EXCLUDED.voices_json`,
`INSERT INTO language_profiles (
code, display_name, azure_locale, default_tts_voice, voices_json,
supports_pronunciation_assessment, supports_prosody
) VALUES (
'es-ES', 'Spanish (Spain)', 'es-ES', 'es-ES-ElviraNeural',
'["es-ES-ElviraNeural", "es-ES-AlvaroNeural"]'::jsonb,
true, true
) ON CONFLICT (code) DO NOTHING`,
`INSERT INTO lessons (id, target_language, cefr_level, topic, title)
VALUES
('les_a1_intro', 'en-US', 'A1', 'introductions', 'Introduce yourself'),
('les_a1_cafe', 'en-US', 'A1', 'cafe', 'Order a coffee'),
('les_a1_numbers', 'en-US', 'A1', 'numbers', 'Numbers and names')
ON CONFLICT (id) DO UPDATE SET title = EXCLUDED.title`,
`INSERT INTO exercises (id, lesson_id, target_language, cefr_level, type, prompt_text, target_text, difficulty)
VALUES
('ex_a1_hello', 'les_a1_intro', 'en-US', 'A1', 'repeat_sentence', 'Sprich den Satz klar nach.', 'Hello, my name is Anna.', 1),
('ex_a1_from', 'les_a1_intro', 'en-US', 'A1', 'repeat_sentence', 'Achte auf den Rhythmus im Satz.', 'I am from Berlin.', 1),
('ex_a1_coffee', 'les_a1_cafe', 'en-US', 'A1', 'repeat_sentence', 'Sprich langsam und deutlich.', 'Can I have a coffee, please?', 2),
('ex_a1_water', 'les_a1_cafe', 'en-US', 'A1', 'repeat_sentence', 'Achte auf die Endlaute.', 'I would like some water.', 2),
('ex_a1_phone', 'les_a1_numbers', 'en-US', 'A1', 'repeat_sentence', 'Sprich jede Zahl einzeln sauber.', 'My phone number is five, two, nine.', 2)
ON CONFLICT (id) DO UPDATE SET
prompt_text = EXCLUDED.prompt_text,
target_text = EXCLUDED.target_text,
difficulty = EXCLUDED.difficulty`,
}
func DebugSQL(name string, err error) error {
if err == nil {
return nil
}
return fmt.Errorf("%s: %w", name, err)
}