Adaptiven A1-Kurs und statistisches Aussprachetraining integrieren

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.
This commit is contained in:
Eugenius Naumenko
2026-11-01 23:23:20 +00:00
parent 83944f791e
commit e274eaab2b
186 changed files with 46676 additions and 257 deletions
+167
View File
@@ -0,0 +1,167 @@
package httpapi
import (
"errors"
"net/http"
"strings"
"unicode"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/store"
)
func (s *Server) courseProfile(r *http.Request) (domain.LearnerProfile, error) {
return s.store.GetPrimaryProfile(r.Context(), currentUserID(r))
}
func (s *Server) courseModules(w http.ResponseWriter, r *http.Request) {
profile, err := s.courseProfile(r)
if err != nil {
writeError(w, http.StatusNotFound, err)
return
}
modules, err := s.store.CourseModules(r.Context(), currentUserID(r), profile.TargetLanguage, profile.CEFRLevel)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
writeJSON(w, http.StatusOK, map[string]any{"modules": modules})
}
func (s *Server) courseModule(w http.ResponseWriter, r *http.Request) {
profile, err := s.courseProfile(r)
if err != nil {
writeError(w, http.StatusNotFound, err)
return
}
detail, err := s.store.CourseModule(r.Context(), currentUserID(r), profile.TargetLanguage, profile.CEFRLevel, r.PathValue("id"))
if errors.Is(err, store.ErrNotFound) {
writeError(w, http.StatusNotFound, err)
return
}
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
writeJSON(w, http.StatusOK, detail)
}
func (s *Server) courseTask(r *http.Request) (domain.CourseTaskKey, error) {
profile, err := s.courseProfile(r)
if err != nil {
return domain.CourseTaskKey{}, err
}
return s.store.CourseTaskKey(r.Context(), r.PathValue("id"), currentUserID(r), profile.TargetLanguage, profile.CEFRLevel)
}
func (s *Server) courseAttempt(w http.ResponseWriter, r *http.Request) {
if strings.HasPrefix(r.PathValue("id"), "a2_") {
s.adaptiveAttempt(w, r)
return
}
key, err := s.courseTask(r)
if errors.Is(err, store.ErrNotFound) {
writeError(w, http.StatusNotFound, err)
return
}
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
if key.Kind != "choice" && key.Kind != "short_text" {
writeError(w, http.StatusBadRequest, errors.New("this task uses pronunciation assessment"))
return
}
var input struct {
Answer string `json:"answer"`
}
if err := decodeJSON(r, &input); err != nil {
writeError(w, http.StatusBadRequest, err)
return
}
answer := strings.TrimSpace(input.Answer)
if answer == "" || len([]rune(answer)) > 200 {
writeError(w, http.StatusBadRequest, errors.New("answer must contain 1 to 200 characters"))
return
}
correct := answerMatches(answer, key.AcceptedAnswers)
id, err := s.store.SaveCourseAttempt(r.Context(), currentUserID(r), key.ID, answer, correct)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
transcript := ""
if key.Skill == "listening" {
transcript = key.AudioText
}
if s.course != nil {
if syncErr := s.course.Repo.SyncLegacy(r.Context()); syncErr != nil {
s.logger.Warn("legacy course evidence sync failed", "error", syncErr)
}
}
writeJSON(w, http.StatusCreated, domain.CourseAttemptResult{ID: id, TaskID: key.ID, Correct: correct, Solution: key.Solution, Explanation: key.Explanation, Transcript: transcript})
}
func answerMatches(answer string, accepted []string) bool {
normalized := normalizeCourseAnswer(answer)
for _, candidate := range accepted {
if normalized == normalizeCourseAnswer(candidate) {
return true
}
}
return false
}
func normalizeCourseAnswer(answer string) string {
answer = strings.Map(func(r rune) rune {
if r == '’' {
return '\''
}
return r
}, answer)
answer = strings.Join(strings.Fields(strings.ToLower(strings.TrimSpace(answer))), " ")
return strings.TrimSpace(strings.TrimRightFunc(answer, func(r rune) bool { return unicode.IsPunct(r) && r != '\'' }))
}
func (s *Server) courseAudio(w http.ResponseWriter, r *http.Request) {
if strings.HasPrefix(r.PathValue("id"), "a2_") {
s.adaptiveAudio(w, r)
return
}
key, err := s.courseTask(r)
if errors.Is(err, store.ErrNotFound) {
writeError(w, http.StatusNotFound, err)
return
}
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
if key.Skill != "listening" || key.AudioText == "" {
writeError(w, http.StatusNotFound, store.ErrNotFound)
return
}
profile, err := s.courseProfile(r)
if err != nil {
writeError(w, http.StatusNotFound, err)
return
}
language, err := s.store.GetLanguage(r.Context(), profile.TargetLanguage)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
audio, mime, err := s.speech.Synthesize(r.Context(), language.AzureLocale, language.DefaultTTSVoice, key.AudioText)
if err != nil {
writeError(w, http.StatusBadGateway, err)
return
}
if len(audio) == 0 {
writeError(w, http.StatusServiceUnavailable, errors.New("audio is unavailable"))
return
}
w.Header().Set("Content-Type", mime)
w.Header().Set("Cache-Control", "private, no-store")
w.WriteHeader(http.StatusOK)
_, _ = w.Write(audio)
}