656 lines
24 KiB
Go
656 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: valueOr(generated.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)
|
|
ON CONFLICT (id) DO UPDATE SET
|
|
lesson_id = EXCLUDED.lesson_id,
|
|
target_language = EXCLUDED.target_language,
|
|
cefr_level = EXCLUDED.cefr_level,
|
|
type = EXCLUDED.type,
|
|
prompt_text = EXCLUDED.prompt_text,
|
|
target_text = EXCLUDED.target_text,
|
|
difficulty = EXCLUDED.difficulty,
|
|
source = EXCLUDED.source,
|
|
created_by_user_id = EXCLUDED.created_by_user_id,
|
|
tts_text = EXCLUDED.tts_text,
|
|
focus_points_json = EXCLUDED.focus_points_json,
|
|
success_criteria_json = EXCLUDED.success_criteria_json,
|
|
reason_for_choice = EXCLUDED.reason_for_choice,
|
|
agent_context_json = EXCLUDED.agent_context_json
|
|
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) (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' OR e.created_by_user_id = $3)
|
|
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)
|
|
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 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
|
|
`, id)
|
|
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()
|
|
|
|
weakByWord := map[string]domain.WordScore{}
|
|
for rows.Next() {
|
|
attempt, err := scanAttempt(rows)
|
|
if err != nil {
|
|
return domain.ProgressSummary{}, err
|
|
}
|
|
summary.RecentAttempts = append(summary.RecentAttempts, attempt)
|
|
for _, word := range attempt.WordScores {
|
|
if word.Accuracy < 75 {
|
|
existing, ok := weakByWord[strings.ToLower(word.Word)]
|
|
if !ok || word.Accuracy < existing.Accuracy {
|
|
weakByWord[strings.ToLower(word.Word)] = word
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for _, word := range weakByWord {
|
|
summary.WeakWords = append(summary.WeakWords, word)
|
|
}
|
|
return summary, rows.Err()
|
|
}
|
|
|
|
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)
|
|
}
|