Muttersprache koppeln und russischen A1-Kurs ergänzen

GUI und neue Erklärungen verwenden gemeinsam native_language. Deutsch und
Russisch sind die beiden Muttersprachen; Englisch bleibt die Lernsprache.
Kompatibilitätsfelder werden atomar gekoppelt, widersprüchliche Eingaben
abgewiesen und bestehende Profile sowie eingefrorene Inhalte erhalten.

Ergänzt vollständige russische GUI-Kataloge und 840 geprüfte Aufgabenansichten
in sieben Modulen einschließlich A1-Test, mit getrennten Sprachrollen für
Ausgangs- und Lernmaterial. Äquivalente Ansichten teilen ihre Nachweisidentität.
Stabile API-Fehlercodes, neue deterministische Hilfen und Trainingsbegründungen
berücksichtigen die Muttersprache. Dokumentiert das Sprachmodell in AGENTS.md.

Validierung: Go-Race-Suite mit eigener lokaler PostgreSQL-Testdatenbank, go vet,
Web-Build, Offline-Bank-/Variantenaudit, Diff-Prüfung sowie lokale Browser-Smokes
für Sprachen, Kurs, Administration, Aussprache und Aufnahme. Keine Live-Anbieter,
Produktionsprofile, Deployment-Schritte oder historischen Neubewertungen.
This commit is contained in:
Eugenius Naumenko
2026-11-07 17:02:17 +00:00
parent f3d42ee2b6
commit 16cceae28a
77 changed files with 46646 additions and 1969 deletions
+30 -3
View File
@@ -141,17 +141,17 @@ func (e *CourseEngine) Process(ctx context.Context, j domain.CourseJob) (*domain
}
return &t, err
case "exam":
if j.InstructionLanguage != "" && j.InstructionLanguage != "de-DE" {
if j.InstructionLanguage != "" && !domain.SupportedNativeLanguage(j.InstructionLanguage) {
return nil, store.ErrCourseVariantUnavailable
}
tasks, err := e.Repo.BankExam(ctx, j.UserID, j.Language, j.ModuleID)
tasks, err := e.Repo.BankExam(ctx, j.UserID, j.Language, j.ModuleID, j.InstructionLanguage)
if errors.Is(err, store.ErrNotFound) {
tasks, err = e.Repo.ReserveExam(ctx, j.UserID, j.Language, j.ModuleID)
}
if err != nil {
return nil, err
}
if err = ValidateExamTasks(tasks, j.Language, j.ModuleID); err != nil {
if err = validateReviewedExamTasks(tasks, j.Language, j.ModuleID); err != nil {
return nil, err
}
return nil, e.Repo.SaveExamTasks(ctx, j.UserID, j.Language, j.SubjectID, tasks)
@@ -585,3 +585,30 @@ func (e *CourseEngine) completeBankExam(ctx context.Context, user, language, id
}
return e.Repo.EnsureBankExamSummary(ctx, user, id)
}
// Reviewed packages carry server-owned metadata that the model contract forbids.
// Validate their renderer/test coverage without treating trusted metadata as model output.
func validateReviewedExamTasks(tasks []domain.AdaptiveTask, language, module string) error {
plain := make([]domain.AdaptiveTask, len(tasks))
for i, task := range tasks {
task.InstructionLanguage = ""
task.Instruction = ""
task.Stimulus = nil
task.VariantID = ""
task.ContentRevision = ""
task.CanonicalTaskID = ""
task.EvidenceTaskID = ""
task.Options = append([]domain.TaskOption(nil), task.Options...)
for j := range task.Options {
task.Options[j].Language = ""
task.Options[j].Role = ""
}
if task.AnswerKey != nil {
key := *task.AnswerKey
key.ReferenceAnswerLanguage = ""
task.AnswerKey = &key
}
plain[i] = task
}
return ValidateExamTasks(plain, language, module)
}
+1 -1
View File
@@ -631,7 +631,7 @@ func (a *AIService) NextExercise(ctx context.Context, input domain.GeneratedExer
// Preserve the existing non-AI feedback and demo conversation behavior.
func (a *AIService) FeedbackForAttempt(ctx context.Context, text string, r domain.PronunciationResult, weak []domain.WordScore) (domain.TeacherResponse, error) {
return mockFeedback(text, r), nil
return localizedFeedback(ctx, text, r), nil
}
func (a *AIService) StartConversation(ctx context.Context, lang, level string) (domain.TeacherResponse, error) {
return (&FlowiseTeacher{}).StartConversation(ctx, lang, level)
+1 -1
View File
@@ -54,7 +54,7 @@ func (s *AuthService) Register(ctx context.Context, email, password, uiLanguage,
uiLanguage = "de-DE"
}
if !domain.SupportedUILanguage(uiLanguage) {
return AuthResult{}, errors.New("unsupported UI language")
return AuthResult{}, domain.ErrNativeLanguageUnsupported
}
if targetLanguage == "" {
targetLanguage = "en-US"
@@ -11,6 +11,7 @@ import (
"speech-learning-api/internal/config"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/store"
"strings"
"sync"
"testing"
)
@@ -163,9 +164,14 @@ func TestBankPostgresSelectionAndOptionalEvaluation(t *testing.T) {
}
func TestBankPostgresExamSubmissionAndLaterGrades(t *testing.T) {
for _, native := range []string{"de-DE", "ru-RU"} {
t.Run(native, func(t *testing.T) { testBankExamNative(t, native) })
}
}
func testBankExamNative(t *testing.T, native string) {
db, profiles := adaptiveTestDB(t)
ctx := context.Background()
user, err := profiles.CreateUser(ctx, store.NewID("exam-bank")+"@example.test", "hash", "de-DE")
user, err := profiles.CreateUser(ctx, store.NewID("exam-bank")+"@example.test", "hash", native)
if err != nil {
t.Fatal(err)
}
@@ -195,8 +201,15 @@ func TestBankPostgresExamSubmissionAndLaterGrades(t *testing.T) {
if err != nil || len(exam.Tasks) != 12 {
t.Fatal(err, exam)
}
if err = engine.Repo.SetInstructionLanguage(ctx, user.ID, "en-US", "de-DE"); err != nil {
t.Fatal(err)
}
// Task presentations and the final static summary retain the exam language.
ungraded := []domain.AdaptiveAttempt{}
for n, pub := range exam.Tasks {
if pub.InstructionLanguage != native {
t.Fatal("exam language not frozen", pub.InstructionLanguage, native)
}
if pub.AnswerKey != nil || pub.AudioText != "" {
t.Fatal("exam key leaked")
}
@@ -277,7 +290,7 @@ func TestBankPostgresExamSubmissionAndLaterGrades(t *testing.T) {
if message.Task != "evaluate_course_attempt" {
t.Error("unexpected model action", message.Task)
}
json.NewEncoder(w).Encode(aiCompletion(domain.CourseEvaluation{Score: 100, Verdict: "correct", Feedback: "Richtig.", Issues: []string{}}, true))
json.NewEncoder(w).Encode(aiCompletion(domain.CourseEvaluation{Score: 100, Verdict: "correct", Feedback: map[string]string{"de-DE": "Richtig.", "ru-RU": "Верно."}[native], Issues: []string{}}, true))
}))
defer server.Close()
agent.Keys["mistral"] = "fixture-secret"
@@ -311,6 +324,9 @@ func TestBankPostgresExamSubmissionAndLaterGrades(t *testing.T) {
if err != nil || exam.Status != "completed" || exam.Score == nil || *exam.Score != 100 || exam.SummaryStatus != "ready" {
t.Fatal("later grading failed", err, exam)
}
if native == "ru-RU" && !strings.HasPrefix(exam.Summary, "Внутренняя") {
t.Fatal("wrong summary language", exam.Summary)
}
// Repair a crash after score completion without invoking a summarizing model.
if _, err = db.Exec(`UPDATE course_v2_exams SET result=jsonb_set(result,'{summary_status}','"pending"') WHERE id=$1`, exam.ID); err != nil {
t.Fatal(err)
@@ -5,6 +5,7 @@ import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"log/slog"
"testing"
@@ -60,7 +61,7 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
if _, _, err = engine.Submit(ctx, user.ID, "en-US", old.ID, "old-answer", old.AnswerKey.CorrectOptionID, nil); err != nil {
t.Fatal(err)
}
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "en-US"); err != nil {
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "ru-RU"); err != nil {
t.Fatal(err)
}
run := func(skill, request string, changeAfterEnqueue bool) domain.AdaptiveTask {
@@ -69,7 +70,7 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if j.InstructionLanguage != "en-US" {
if j.InstructionLanguage != "ru-RU" {
t.Fatal("job did not freeze explanation language", j)
}
if changeAfterEnqueue {
@@ -88,24 +89,32 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
if err = repo.Finish(ctx, j, task, ""); err != nil {
t.Fatal(err)
}
if task.InstructionLanguage != "en-US" || task.VariantID == "" || task.ContentRevision == "" || task.Instruction == "" {
if task.InstructionLanguage != "ru-RU" || task.VariantID == "" || task.ContentRevision == "" || task.Instruction == "" {
t.Fatal("incomplete frozen variant", task)
}
return *task
}
first := run("grammar", "english-grammar-first", false)
if _, _, err = engine.Submit(ctx, user.ID, "en-US", first.ID, "english-first-answer", first.AnswerKey.CorrectOptionID, nil); err != nil {
// Limit this fixture to the historical grammar goal so evidence reuse is deterministic.
if _, err = db.ExecContext(ctx, `UPDATE course_v2_bank_variants v SET active=false FROM course_v2_bank b WHERE v.base_entry_id=b.id AND b.module_id='a1_introductions_v1' AND b.skill='grammar' AND b.id<>(SELECT bank_entry_id FROM course_v2_tasks WHERE id=$1)`, old.ID); err != nil {
t.Fatal(err)
}
translated := run("grammar", "english-grammar-second", true)
if !translated.Review || translated.EvidenceTaskID != old.ID {
t.Fatal("translation did not reuse existing evidence", translated, old)
var translated domain.AdaptiveTask
distinct := map[string]bool{old.ID: true}
for n := 0; n < 2; n++ {
translated = run("grammar", fmt.Sprintf("russian-grammar-%d", n), n == 1)
distinct[translated.EvidenceTaskID] = true
if _, _, err = engine.Submit(ctx, user.ID, "en-US", translated.ID, fmt.Sprintf("russian-answer-%d", n), translated.AnswerKey.CorrectOptionID, nil); err != nil {
t.Fatal(err)
}
}
if _, _, err = engine.Submit(ctx, user.ID, "en-US", translated.ID, "english-second-answer", translated.AnswerKey.CorrectOptionID, nil); err != nil {
t.Fatal(err)
// The translated historical task retains its canonical evidence identity.
var shared int
if err = db.QueryRowContext(ctx, `SELECT count(*) FROM course_v2_tasks WHERE owner_id=$1 AND data->>'evidence_task_id'=$2 AND variant_id IS NOT NULL`, user.ID, old.ID).Scan(&shared); err != nil || shared != 1 {
t.Fatal("translation did not share historical evidence", shared, err)
}
replay, err := repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_introductions_v1", "grammar", "", "english-grammar-second")
if err != nil || replay.TaskID != translated.ID || replay.InstructionLanguage != "en-US" {
replay, err := repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_introductions_v1", "grammar", "", "russian-grammar-1")
if err != nil || replay.TaskID != translated.ID || replay.InstructionLanguage != "ru-RU" {
t.Fatal("locale change altered idempotent replay", replay, err)
}
snapshot, err := repo.Snapshot(ctx, user.ID, "en-US", "de-DE")
@@ -116,7 +125,7 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
for _, p := range snapshot.Progress {
if p.Skill == "grammar" && p.ModuleID == old.ModuleID {
found = true
if p.Attempts != 3 || p.DistinctTasks != 2 {
if p.Attempts != 3 || p.DistinctTasks != len(distinct) {
t.Fatalf("translation inflated task evidence: %+v", p)
}
}
@@ -124,7 +133,10 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
if !found {
t.Fatal("missing graded evidence")
}
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "en-US"); err != nil {
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "ru-RU"); err != nil {
t.Fatal(err)
}
if _, err = db.ExecContext(ctx, `UPDATE course_v2_bank_variants SET active=true WHERE instruction_language='ru-RU'`); err != nil {
t.Fatal(err)
}
inventory, err := repo.BankInventory(ctx, user.ID, "en-US")
@@ -134,11 +146,9 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
total := 0
for _, item := range inventory {
total += item.Total
if item.ModuleID != "a1_introductions_v1" {
t.Fatal("German fallback advertised as English", item)
}
}
if total != 12 {
if total != 840 {
t.Fatal("incorrect locale inventory", inventory)
}
// Local speech fixtures exercise the real observation path; no Azure is called.
@@ -146,13 +156,16 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
if _, _, err = engine.Submit(ctx, user.ID, "en-US", oldSpeech.ID, "old-speech", oldSpeech.ReferenceText, &speech); err != nil {
t.Fatal(err)
}
localizedSpeech := run("speaking", "localized-speech", false)
if localizedSpeech.Kind != "free_speech" { // The existing repeat may be scheduled after the unseen free task.
if localizedSpeech.Kind != "repeat_sentence" {
t.Fatal(localizedSpeech.Kind)
if _, err = db.ExecContext(ctx, `UPDATE course_v2_bank_variants v SET active=false FROM course_v2_bank b WHERE v.base_entry_id=b.id AND b.module_id='a1_introductions_v1' AND b.skill='speaking' AND b.id<>(SELECT bank_entry_id FROM course_v2_tasks WHERE id=$1)`, oldSpeech.ID); err != nil {
t.Fatal(err)
}
var localizedSpeech domain.AdaptiveTask
for n := 0; n < 20; n++ {
localizedSpeech = run("speaking", fmt.Sprintf("localized-speech-%d", n), false)
if localizedSpeech.EvidenceTaskID == oldSpeech.ID {
break
}
} else {
localizedSpeech = run("speaking", "localized-repeat", false)
}
if localizedSpeech.EvidenceTaskID != oldSpeech.ID {
t.Fatal("translated repeat changed evidence identity", localizedSpeech)
@@ -182,10 +195,13 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
if !bytes.Equal(before, after) {
t.Fatal("historical snapshot was rewritten")
}
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "fr-FR"); !errors.Is(err, store.ErrCourseVariantUnavailable) {
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "fr-FR"); !errors.Is(err, domain.ErrNativeLanguageUnsupported) {
t.Fatal("unsupported locale accepted", err)
}
// Missing reviewed variants must not silently select a German reserve.
if _, err = db.ExecContext(ctx, `UPDATE course_v2_bank_variants v SET active=false FROM course_v2_bank b WHERE v.base_entry_id=b.id AND b.module_id='a1_family_v1'`); err != nil {
t.Fatal(err)
}
if _, err = repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_family_v1", "grammar", "", "missing-variants"); err != nil {
t.Fatal(err)
}
+21 -5
View File
@@ -54,6 +54,12 @@ func (f *FlowiseTeacher) NextExercise(ctx context.Context, input domain.Generate
ReasonForChoice: "Fallback exercise because Flowise did not return a valid exercise.",
Source: "fallback",
}
if input.UILanguage == "ru-RU" {
fallback.DisplayPrompt = "Чётко повторите предложение вслух."
fallback.FocusPoints = []string{"ритм", "конечные звуки"}
fallback.SuccessCriteria = []string{"точность выше 80"}
fallback.ReasonForChoice = "Резервное упражнение: новое упражнение сейчас недоступно."
}
progress := compactProgressForFlowise(input.Progress)
payload := map[string]any{
"task": "next_exercise",
@@ -96,20 +102,25 @@ func withoutPhonemeScores(words []domain.WordScore) []domain.WordScore {
func (f *FlowiseTeacher) FeedbackForAttempt(ctx context.Context, targetText string, result domain.PronunciationResult, weakWords []domain.WordScore) (domain.TeacherResponse, error) {
_ = ctx
_ = weakWords
return mockFeedback(targetText, result), nil
return localizedFeedback(ctx, targetText, result), nil
}
func (f *FlowiseTeacher) StartConversation(ctx context.Context, targetLanguage, cefrLevel string) (domain.TeacherResponse, error) {
_ = ctx
_ = targetLanguage
_ = cefrLevel
return domain.TeacherResponse{
response := domain.TeacherResponse{
ExerciseType: "conversation",
TargetText: "Hello. What is your name?",
TeacherFeedback: "Wir starten sehr einfach. Antworte mit: My name is ...",
TTSText: "Hello. What is your name?",
NextRecommendation: "Antworten: My name is ...",
}, nil
}
if nativeLanguage(ctx) == "ru-RU" {
response.TeacherFeedback = "Начнём с простого. Ответьте: My name is ..."
response.NextRecommendation = "Ответьте: My name is ..."
}
return response, nil
}
func (f *FlowiseTeacher) ContinueConversation(ctx context.Context, targetLanguage, cefrLevel, userText string) (domain.TeacherResponse, error) {
@@ -117,13 +128,18 @@ func (f *FlowiseTeacher) ContinueConversation(ctx context.Context, targetLanguag
_ = targetLanguage
_ = cefrLevel
_ = userText
return domain.TeacherResponse{
response := domain.TeacherResponse{
ExerciseType: "conversation",
TargetText: "Nice to meet you. Where are you from?",
TeacherFeedback: "Gut. Jetzt uebe einen kurzen Satz mit Herkunft.",
TTSText: "Nice to meet you. Where are you from?",
NextRecommendation: "Antworten: I am from ...",
}, nil
}
if nativeLanguage(ctx) == "ru-RU" {
response.TeacherFeedback = "Теперь потренируйте короткое предложение о том, откуда вы."
response.NextRecommendation = "Ответьте: I am from ..."
}
return response, nil
}
func (f *FlowiseTeacher) askExercise(ctx context.Context, payload map[string]any, input domain.GeneratedExerciseRequest, fallback domain.GeneratedExercise) (domain.GeneratedExercise, error) {
@@ -19,7 +19,7 @@ func TestLanguagePreferencesPreserveCourseAndExplanations(t *testing.T) {
if err != nil {
t.Fatal(err)
}
updated, err := profiles.UpdatePreferences(ctx, user.ID, "en-US", "", "", 0)
updated, err := profiles.UpdatePreferences(ctx, user.ID, "ru-RU", "", "", 0)
if err != nil {
t.Fatal(err)
}
@@ -30,7 +30,7 @@ func TestLanguagePreferencesPreserveCourseAndExplanations(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if loaded.UILanguage != "en-US" || loaded.InstructionLanguage != "de-DE" {
if loaded.NativeLanguage != "ru-RU" || loaded.UILanguage != "ru-RU" || loaded.InstructionLanguage != "ru-RU" {
t.Fatalf("language roles conflated: %+v", loaded)
}
_, _, err = profiles.GetPasswordHashByEmail(ctx, user.Email)
@@ -42,7 +42,7 @@ func TestLanguagePreferencesPreserveCourseAndExplanations(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if snapshot.UILanguage != "de-DE" {
if snapshot.UILanguage != "ru-RU" {
t.Fatalf("model instructions follow interface language: %q", snapshot.UILanguage)
}
if _, err = profiles.UpdatePreferences(ctx, user.ID, "unsupported", "en-US", "A1", 10); err == nil {
@@ -60,7 +60,7 @@ func TestLanguagePreferencesPreserveCourseAndExplanations(t *testing.T) {
t.Fatal("expected profile constraint failure")
}
loaded, err = profiles.GetUser(ctx, user.ID)
if err != nil || loaded.UILanguage != "en-US" {
if err != nil || loaded.UILanguage != "ru-RU" {
t.Fatalf("failed update changed interface: %+v %v", loaded, err)
}
active, err = profiles.GetPrimaryProfile(ctx, user.ID)
@@ -69,39 +69,48 @@ func TestLanguagePreferencesPreserveCourseAndExplanations(t *testing.T) {
}
}
func TestInstructionLanguageMigrationPreservesLegacyPreference(t *testing.T) {
func TestNativeLanguageMigrationAndCompatibility(t *testing.T) {
db, profiles := adaptiveTestDB(t)
ctx := context.Background()
user, err := profiles.CreateUser(ctx, "legacy-language@example.test", "hash", "fr-FR")
user, err := profiles.CreateUser(ctx, "legacy-language@example.test", "hash", "de-DE")
if err != nil {
t.Fatal(err)
}
// Simulate the previous schema in this disposable test schema only.
if _, err = db.ExecContext(ctx, `ALTER TABLE users DROP COLUMN instruction_language`); err != nil {
// Simulate the old independent settings in this disposable schema only.
if _, err = db.ExecContext(ctx, `ALTER TABLE users DROP CONSTRAINT users_native_language_coupled; ALTER TABLE users DROP COLUMN native_language; UPDATE users SET ui_language='ru-RU',instruction_language='de-DE'`); err != nil {
t.Fatal(err)
}
if err = profiles.Init(ctx); err != nil {
t.Fatal(err)
}
loaded, err := profiles.GetUser(ctx, user.ID)
if err != nil || loaded.InstructionLanguage != "fr-FR" {
t.Fatalf("legacy instruction preference lost: %+v %v", loaded, err)
if err != nil || loaded.NativeLanguage != "ru-RU" || loaded.UILanguage != "ru-RU" || loaded.InstructionLanguage != "ru-RU" {
t.Fatalf("migration did not couple native language: %+v %v", loaded, err)
}
if _, err = profiles.UpdatePreferences(ctx, user.ID, "en-US", "", "", 0); err != nil {
if _, err = profiles.UpdatePreferences(ctx, user.ID, "de-DE", "", "", 0); err != nil {
t.Fatal(err)
}
if err = profiles.Init(ctx); err != nil {
t.Fatal(err)
}
loaded, err = profiles.GetUser(ctx, user.ID)
if err != nil || loaded.UILanguage != "en-US" || loaded.InstructionLanguage != "fr-FR" {
t.Fatalf("repeated migration changed instruction preference: %+v %v", loaded, err)
if err != nil || loaded.NativeLanguage != "de-DE" || loaded.UILanguage != "de-DE" || loaded.InstructionLanguage != "de-DE" {
t.Fatalf("restart changed preference: %+v %v", loaded, err)
}
result, err := NewAuthService(profiles, "language-test-only").Register(ctx, "new-language@example.test", "test-password", "en-US", "en-US", 15)
if _, err = db.ExecContext(ctx, `UPDATE users SET instruction_language='ru-RU' WHERE id=$1`, user.ID); err == nil {
t.Fatal("database allowed divergent language roles")
}
result, err := NewAuthService(profiles, "language-test-only").Register(ctx, "new-language@example.test", "test-password", "ru-RU", "en-US", 15)
if err != nil {
t.Fatal(err)
}
if result.User.UILanguage != "en-US" || result.User.InstructionLanguage != "de-DE" {
t.Fatalf("new account did not keep German course explanations: %+v", result.User)
if result.User.NativeLanguage != "ru-RU" || result.User.UILanguage != "ru-RU" || result.User.InstructionLanguage != "ru-RU" {
t.Fatal(result.User)
}
if _, err = profiles.CreateUser(ctx, "unsupported@example.test", "hash", "en-US"); err == nil {
t.Fatal("English native language accepted")
}
if _, err = domain.ResolveNativeLanguage("de-DE", "ru-RU"); err != domain.ErrNativeLanguageConflict {
t.Fatal("conflicting aliases accepted", err)
}
}
@@ -0,0 +1,59 @@
package services
import (
"context"
"fmt"
"speech-learning-api/internal/domain"
"strings"
)
type nativeLanguageKey struct{}
// Request-scoped native language also applies to deterministic feedback; target
// texts and Azure measurements are never translated by this presentation step.
func WithNativeLanguage(ctx context.Context, language string) context.Context {
return context.WithValue(ctx, nativeLanguageKey{}, language)
}
func nativeLanguage(ctx context.Context) string {
language, _ := ctx.Value(nativeLanguageKey{}).(string)
return language
}
func localizedFeedback(ctx context.Context, text string, result domain.PronunciationResult) domain.TeacherResponse {
if nativeLanguage(ctx) != "ru-RU" {
return mockFeedback(text, result)
}
response := domain.TeacherResponse{ExerciseType: "repeat_sentence", TargetText: text, TTSText: text,
TeacherFeedback: "Предложение стоит ещё потренировать. Повторите его вслух.", NextRecommendation: "Повторите это упражнение."}
weakWord, phonemeWord := "", ""
var weak domain.PhonemeScore
for _, word := range result.WordScores {
if word.Highlight == "weak" && weakWord == "" {
weakWord = word.Word
}
if strings.EqualFold(word.ErrorType, "Omission") {
continue
}
for _, phoneme := range word.PhonemeScores {
if phoneme.Accuracy < 75 && (phonemeWord == "" || phoneme.Accuracy < weak.Accuracy) {
weak = phoneme
phonemeWord = word.Word
}
}
}
switch {
case result.OverallScore >= 95 && result.AccuracyScore >= 95 && result.FluencyScore >= 95 && result.CompletenessScore >= 95:
response.TeacherFeedback = "Отлично! Произношение этого предложения получило очень высокую оценку."
response.NextRecommendation = "Можно перейти к новому упражнению."
case phonemeWord != "":
response.TeacherFeedback = fmt.Sprintf("В слове %q звук /%s/ получил %.0f из 100 баллов.", phonemeWord, weak.Phoneme, weak.Accuracy)
response.NextRecommendation = fmt.Sprintf("Повторите предложение, уделяя внимание слову %q.", phonemeWord)
case weakWord != "":
response.TeacherFeedback = fmt.Sprintf("Слово %q получило невысокую оценку. Потренируйте его ещё раз в предложении.", weakWord)
response.NextRecommendation = fmt.Sprintf("Повторите предложение, уделяя внимание слову %q.", weakWord)
case result.OverallScore >= 85:
response.TeacherFeedback = "Хорошо! Произношение этого предложения получило высокую оценку."
response.NextRecommendation = "Можно перейти к новому упражнению."
}
return response
}
@@ -0,0 +1,30 @@
package services
import (
"context"
"speech-learning-api/internal/domain"
"strings"
"testing"
)
func TestRussianDeterministicFeedbackKeepsMeasurementsAndTarget(t *testing.T) {
ctx := WithNativeLanguage(context.Background(), "ru-RU")
result := domain.PronunciationResult{OverallScore: 86, WordScores: []domain.WordScore{{Word: "name", PhonemeScores: []domain.PhonemeScore{{Phoneme: "n", Accuracy: 62}}}}}
response := localizedFeedback(ctx, "My name is Anna.", result)
if response.TargetText != "My name is Anna." || response.TTSText != response.TargetText || !strings.Contains(response.TeacherFeedback, "/n/") || !strings.Contains(response.TeacherFeedback, "62 из 100") {
t.Fatal(response)
}
if result.WordScores[0].PhonemeScores[0].Accuracy != 62 {
t.Fatal("measurement changed")
}
result.WordScores[0].ErrorType = "Omission"
response = localizedFeedback(ctx, "My name is Anna.", result)
if strings.Contains(response.TeacherFeedback, "/n/") {
t.Fatal("omission treated as phoneme error")
}
teacher := &FlowiseTeacher{}
start, err := teacher.StartConversation(ctx, "en-US", "A1")
if err != nil || start.TargetText != "Hello. What is your name?" || !strings.Contains(start.TeacherFeedback, "Ответьте") {
t.Fatal(start, err)
}
}