Files
Eugenius Naumenko f3d42ee2b6 Mehrsprachige Bedienung und versionierte Aufgabenvarianten einführen
Übersetzungskataloge, getrennte Sprachpräferenzen und einen versionierten Aufgabenpilot ergänzen. Historische Aufgaben und Bewertungen bleiben erhalten; äquivalente Ansichten teilen Nachweise. Lokal mit Race-Tests und PostgreSQL, Vet, Web-Build, Bank-Audits und Browser-Fixtures geprüft. Dieser Stand dient als Ausgangspunkt für die anschließend beauftragte Zusammenführung zur Muttersprache.
2026-11-07 16:26:26 +00:00

167 lines
5.3 KiB
Go

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.ExplanationLanguage(), 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)
}