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
@@ -0,0 +1,166 @@
package httpapi
import (
"context"
"encoding/json"
"errors"
"io"
"net/http"
"regexp"
"strings"
"time"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/services"
"speech-learning-api/internal/store"
)
func (s *Server) practiceModule(w http.ResponseWriter, r *http.Request) (domain.CourseModuleDetail, bool) {
profile, err := s.courseProfile(r)
if err != nil {
writeError(w, http.StatusNotFound, err)
return domain.CourseModuleDetail{}, false
}
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 detail, false
}
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return detail, false
}
if detail.Module.ID != "a1_introductions_v1" || profile.TargetLanguage != "en-US" || profile.CEFRLevel != "A1" {
writeError(w, http.StatusBadRequest, errors.New("additional practice is not available for this module"))
return detail, false
}
return detail, true
}
func (s *Server) coursePractice(w http.ResponseWriter, r *http.Request) {
detail, ok := s.practiceModule(w, r)
if !ok {
return
}
tasks, err := s.store.CoursePractice(r.Context(), currentUserID(r), detail.Module.ID)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
if s.course != nil {
profile, err := s.courseProfile(r)
if err != nil {
adaptiveError(w, err)
return
}
newer, err := s.course.Repo.History(r.Context(), currentUserID(r), profile.TargetLanguage, detail.Module.ID, 0)
if err != nil {
adaptiveError(w, err)
return
}
for _, item := range newer {
if item.Kind != "choice" || strings.HasPrefix(item.ID, "a2_legacy_") {
continue
}
converted := legacyAdaptiveTask(item)
latest, err := s.course.Repo.LatestTaskAttempt(r.Context(), currentUserID(r), profile.TargetLanguage, item.ID)
if err != nil {
adaptiveError(w, err)
return
}
if latest != nil {
converted.Attempted = true
converted.Correct = latest.Evaluation != nil && latest.Evaluation.Verdict == "correct"
}
tasks = append(tasks, converted)
}
}
writeJSON(w, http.StatusOK, map[string]any{"tasks": tasks})
}
var courseRequestIDPattern = regexp.MustCompile(`^[A-Za-z0-9_-]{8,80}$`)
func (s *Server) nextCoursePractice(w http.ResponseWriter, r *http.Request) {
if s.course != nil {
s.adaptiveLegacyNext(w, r)
return
}
var input struct {
RequestID string `json:"request_id"`
}
r.Body = http.MaxBytesReader(w, r.Body, 1024)
defer r.Body.Close()
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(&input); err != nil {
writeError(w, http.StatusBadRequest, errors.New("invalid practice request"))
return
}
if decoder.Decode(new(any)) != io.EOF || !courseRequestIDPattern.MatchString(input.RequestID) {
writeError(w, http.StatusBadRequest, errors.New("invalid request_id"))
return
}
detail, ok := s.practiceModule(w, r)
if !ok {
return
}
userID := currentUserID(r)
existing, err := s.store.CoursePracticeByRequest(r.Context(), userID, detail.Module.ID, input.RequestID)
if err == nil {
writeJSON(w, http.StatusOK, existing)
return
}
if !errors.Is(err, store.ErrNotFound) {
writeError(w, http.StatusInternalServerError, err)
return
}
selection, err := s.store.SelectCoursePractice(r.Context(), userID, detail.Module.ID)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
user, err := s.store.GetUser(r.Context(), userID)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
request := domain.GenerateCourseTaskRequest{
Task: "generate_course_task", SchemaVersion: 1, TargetLanguage: detail.Module.TargetLanguage,
CEFRLevel: detail.Module.CEFRLevel, UILanguage: user.UILanguage, ModuleID: detail.Module.ID,
Skill: selection.Goal.Skill, Kind: "choice", LearningGoal: selection.Goal,
LearningState: selection.State, AvoidPrompts: selection.AvoidPrompts,
}
reason := "course generator unavailable"
if s.courseGenerator != nil {
ctx, cancel := context.WithTimeout(r.Context(), 25*time.Second)
generated, generateErr := s.courseGenerator.GenerateCourseTask(ctx, request)
cancel()
// Validate here as well so another generator implementation cannot bypass it.
if generateErr == nil {
generateErr = services.ValidateGeneratedCourseTask(generated, request)
}
if generateErr == nil {
result, saveErr := s.store.SaveGeneratedCourseTask(r.Context(), userID, input.RequestID, generated)
if saveErr == nil {
s.logger.Info("course practice selected", "source", result.Source, "task_id", result.Task.ID, "learning_goal_id", selection.Goal.ID)
writeJSON(w, http.StatusOK, result)
return
}
reason = "saving generated course task failed"
s.logger.Warn(reason, "error", saveErr)
} else {
reason = generateErr.Error()
}
}
if r.Context().Err() != nil {
return
}
s.logger.Warn("course generation fallback", "reason", reason, "learning_goal_id", selection.Goal.ID)
result, err := s.store.CoursePracticeFallback(r.Context(), userID, selection.Goal.SeedTaskID)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
s.logger.Info("course practice selected", "source", result.Source, "task_id", result.Task.ID, "learning_goal_id", selection.Goal.ID)
writeJSON(w, http.StatusOK, result)
}