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.
168 lines
4.8 KiB
Go
168 lines
4.8 KiB
Go
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)
|
||
}
|