Files
Speech/apps/api/internal/httpapi/course.go
T
Eugenius Naumenko e274eaab2b 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.
2026-11-01 23:23:20 +00:00

168 lines
4.8 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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)
}