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:
@@ -0,0 +1,668 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/binary"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"speech-learning-api/internal/domain"
|
||||
"speech-learning-api/internal/services"
|
||||
"speech-learning-api/internal/store"
|
||||
)
|
||||
|
||||
func (s *Server) SetCourseEngine(engine *services.CourseEngine) { s.course = engine }
|
||||
func (s *Server) adaptiveProfile(w http.ResponseWriter, r *http.Request) (domain.LearnerProfile, bool) {
|
||||
if s.course == nil {
|
||||
writeError(w, http.StatusServiceUnavailable, errors.New("course engine unavailable"))
|
||||
return domain.LearnerProfile{}, false
|
||||
}
|
||||
p, err := s.courseProfile(r)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusNotFound, err)
|
||||
return p, false
|
||||
}
|
||||
if p.CEFRLevel != "A1" {
|
||||
writeError(w, http.StatusBadRequest, errors.New("the adaptive course is available at A1"))
|
||||
return p, false
|
||||
}
|
||||
return p, true
|
||||
}
|
||||
func adaptiveError(w http.ResponseWriter, err error) {
|
||||
status := http.StatusInternalServerError
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
status = http.StatusNotFound
|
||||
}
|
||||
if errors.Is(err, store.ErrCourseConflict) {
|
||||
status = http.StatusConflict
|
||||
}
|
||||
if status == 500 {
|
||||
writeError(w, status, errors.New("Der Kursvorgang konnte nicht gespeichert oder geladen werden."))
|
||||
} else {
|
||||
writeError(w, status, err)
|
||||
}
|
||||
}
|
||||
func adaptiveJSON(w http.ResponseWriter, r *http.Request, out any) bool {
|
||||
r.Body = http.MaxBytesReader(w, r.Body, 32768)
|
||||
defer r.Body.Close()
|
||||
decoder := json.NewDecoder(r.Body)
|
||||
decoder.DisallowUnknownFields()
|
||||
if err := decoder.Decode(out); err != nil {
|
||||
writeError(w, 400, errors.New("invalid course request"))
|
||||
return false
|
||||
}
|
||||
if decoder.Decode(new(any)) != io.EOF {
|
||||
writeError(w, 400, errors.New("trailing request content"))
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
func (s *Server) adaptiveCatalog(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
user, err := s.store.GetUser(r.Context(), currentUserID(r))
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
snap, err := s.course.Repo.Snapshot(r.Context(), user.ID, p.TargetLanguage, user.UILanguage)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
languages, err := s.store.ListLanguages(r.Context())
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
available := []string{}
|
||||
for _, l := range languages {
|
||||
modules, err := s.course.Repo.Modules(r.Context(), l.Code)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
if len(modules) == 7 {
|
||||
available = append(available, l.Code)
|
||||
}
|
||||
}
|
||||
exams, err := s.course.Repo.Exams(r.Context(), user.ID, p.TargetLanguage)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
analysisJob, err := s.course.Repo.LatestAnalysisJob(r.Context(), user.ID, p.TargetLanguage)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
if s.course.Mode == "bank" {
|
||||
snap.PreviousAnalysis = nil
|
||||
analysisJob = nil
|
||||
}
|
||||
inventory, err := s.course.Repo.BankInventory(r.Context(), user.ID, p.TargetLanguage)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"task_mode": s.course.Mode, "grading_available": s.course.EvaluationAvailable(r.Context()), "bank": inventory, "analysis_job": analysisJob, "profile": p, "modules": snap.Modules, "progress": snap.Progress, "analysis": snap.PreviousAnalysis, "facts_version": snap.FactsVersion, "enabled_languages": available, "languages": languages, "exams": exams})
|
||||
}
|
||||
func (s *Server) adaptiveNext(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var input struct {
|
||||
RequestID string `json:"request_id"`
|
||||
Skill string `json:"skill"`
|
||||
}
|
||||
if !adaptiveJSON(w, r, &input) {
|
||||
return
|
||||
}
|
||||
if !courseRequestIDPattern.MatchString(input.RequestID) || !validCourseSkill(input.Skill) {
|
||||
writeError(w, 400, errors.New("invalid request ID or skill"))
|
||||
return
|
||||
}
|
||||
if _, err := s.course.Repo.Module(r.Context(), p.TargetLanguage, r.PathValue("id")); err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
j, err := s.course.Repo.Enqueue(r.Context(), currentUserID(r), p.TargetLanguage, "next", r.PathValue("id"), input.Skill, "", input.RequestID)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 202, j)
|
||||
}
|
||||
func validCourseSkill(skill string) bool {
|
||||
if skill == "" {
|
||||
return true
|
||||
}
|
||||
for _, s := range domain.CourseSkills {
|
||||
if s == skill {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
func (s *Server) adaptiveHistory(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if _, err := s.course.Repo.Module(r.Context(), p.TargetLanguage, r.PathValue("id")); err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
offset := 0
|
||||
if value := r.URL.Query().Get("offset"); value != "" {
|
||||
n, err := strconv.Atoi(value)
|
||||
if err != nil || n < 0 {
|
||||
writeError(w, 400, errors.New("invalid history offset"))
|
||||
return
|
||||
}
|
||||
offset = n
|
||||
}
|
||||
tasks, err := s.course.Repo.History(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"), offset)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"tasks": tasks, "offset": offset, "has_more": len(tasks) == 25})
|
||||
}
|
||||
func (s *Server) adaptiveJob(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
j, err := s.course.Repo.Job(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, j)
|
||||
}
|
||||
func (s *Server) adaptiveRetryJob(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if s.course.Mode == "bank" {
|
||||
existing, err := s.course.Repo.Job(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
if existing.Kind == "evaluate" && !s.course.EvaluationAvailable(r.Context()) {
|
||||
writeError(w, 409, errors.New("KI-Bewertung derzeit nicht verfügbar. Die Antwort bleibt gespeichert."))
|
||||
return
|
||||
}
|
||||
}
|
||||
j, err := s.course.Repo.RetryJob(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 202, j)
|
||||
}
|
||||
func (s *Server) adaptiveTask(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
user := currentUserID(r)
|
||||
task, err := s.course.Repo.Task(r.Context(), user, p.TargetLanguage, r.PathValue("id"))
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
latest, err := s.course.Repo.LatestTaskAttempt(r.Context(), user, p.TargetLanguage, task.ID)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
reveal := latest != nil && (latest.Status == "graded" || latest.Status == "ungraded")
|
||||
if task.ExamID != "" {
|
||||
exam, err := s.course.Repo.Exam(r.Context(), user, p.TargetLanguage, task.ExamID)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
reveal = exam.Status == "completed"
|
||||
}
|
||||
if latest != nil {
|
||||
value, err := s.course.PublicAttempt(r.Context(), user, p.TargetLanguage, *latest)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
latest = &value
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"task": task.Public(reveal), "attempt": latest})
|
||||
}
|
||||
func (s *Server) adaptiveAttempt(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var input struct {
|
||||
RequestID string `json:"request_id"`
|
||||
Answer string `json:"answer"`
|
||||
}
|
||||
if !adaptiveJSON(w, r, &input) {
|
||||
return
|
||||
}
|
||||
legacyResponse := input.RequestID == ""
|
||||
answer := strings.TrimSpace(input.Answer)
|
||||
if input.RequestID == "" {
|
||||
input.RequestID = newRequestID()
|
||||
}
|
||||
if !courseRequestIDPattern.MatchString(input.RequestID) || answer == "" || len([]rune(answer)) > 10000 {
|
||||
writeError(w, 400, errors.New("answer and request ID are required; maximum 10000 characters"))
|
||||
return
|
||||
}
|
||||
task, err := s.course.Repo.Task(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
if task.Kind == "repeat_sentence" || task.Kind == "free_speech" {
|
||||
writeError(w, 400, errors.New("this task requires an audio recording"))
|
||||
return
|
||||
}
|
||||
if task.Kind == "choice" {
|
||||
valid := false
|
||||
for _, option := range task.Options {
|
||||
if answer == option.ID || answer == option.Label {
|
||||
valid = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !valid {
|
||||
writeError(w, 400, errors.New("Bitte eine der angebotenen Antworten wählen."))
|
||||
return
|
||||
}
|
||||
}
|
||||
attempt, job, err := s.course.Submit(r.Context(), currentUserID(r), p.TargetLanguage, task.ID, input.RequestID, answer, nil)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
public, err := s.course.PublicAttempt(r.Context(), currentUserID(r), p.TargetLanguage, attempt)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
status := 201
|
||||
if job != nil {
|
||||
status = 202
|
||||
}
|
||||
if legacyResponse && task.ExamID == "" && public.Evaluation != nil {
|
||||
solution := task.AnswerKey.ReferenceAnswer
|
||||
for _, option := range task.Options {
|
||||
if option.ID == task.AnswerKey.CorrectOptionID {
|
||||
solution = option.Label
|
||||
}
|
||||
}
|
||||
writeJSON(w, 201, domain.CourseAttemptResult{ID: public.ID, TaskID: task.ID, Correct: public.Evaluation.Verdict == "correct", Solution: solution, Explanation: public.Evaluation.Feedback, Transcript: task.AudioText})
|
||||
return
|
||||
}
|
||||
writeJSON(w, status, map[string]any{"attempt": public, "job": job})
|
||||
}
|
||||
func (s *Server) adaptiveGetAttempt(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
a, err := s.course.Repo.Attempt(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
a, err = s.course.PublicAttempt(r.Context(), currentUserID(r), p.TargetLanguage, a)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, a)
|
||||
}
|
||||
func (s *Server) adaptiveRetryAttempt(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if s.course.Mode == "bank" && !s.course.EvaluationAvailable(r.Context()) {
|
||||
writeError(w, 409, errors.New("KI-Bewertung derzeit nicht verfügbar. Die Antwort bleibt gespeichert."))
|
||||
return
|
||||
}
|
||||
j, err := s.course.Repo.RetryEvaluation(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 202, j)
|
||||
}
|
||||
func (s *Server) adaptiveAudio(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
t, err := s.course.Repo.Task(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
text := t.AudioText
|
||||
if t.Kind == "repeat_sentence" {
|
||||
text = t.ReferenceText
|
||||
}
|
||||
if text == "" {
|
||||
writeError(w, 404, store.ErrNotFound)
|
||||
return
|
||||
}
|
||||
lang, err := s.store.GetLanguage(r.Context(), p.TargetLanguage)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
if lang.AzureLocale == "" || lang.DefaultTTSVoice == "" {
|
||||
writeError(w, 503, errors.New("speech is not configured for this language"))
|
||||
return
|
||||
}
|
||||
audio, mime, err := s.speech.Synthesize(r.Context(), lang.AzureLocale, lang.DefaultTTSVoice, text)
|
||||
if err != nil || len(audio) == 0 {
|
||||
writeError(w, 503, errors.New("Audio ist momentan nicht verfügbar."))
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", mime)
|
||||
w.Header().Set("Cache-Control", "private, no-store")
|
||||
w.WriteHeader(200)
|
||||
_, _ = w.Write(audio)
|
||||
}
|
||||
|
||||
// Parse the actual PCM header and frame count. A file extension or claimed
|
||||
// MIME type alone cannot establish the sample rate or the 30-second limit.
|
||||
func validCourseWAV(audio []byte) bool {
|
||||
if len(audio) < 44 || string(audio[:4]) != "RIFF" || string(audio[8:12]) != "WAVE" {
|
||||
return false
|
||||
}
|
||||
validFormat := false
|
||||
dataSize := 0
|
||||
for pos := 12; pos+8 <= len(audio); {
|
||||
size := int(binary.LittleEndian.Uint32(audio[pos+4 : pos+8]))
|
||||
start := pos + 8
|
||||
if size < 0 || size > len(audio)-start {
|
||||
return false
|
||||
}
|
||||
switch string(audio[pos : pos+4]) {
|
||||
case "fmt ":
|
||||
if size < 16 {
|
||||
return false
|
||||
}
|
||||
validFormat = binary.LittleEndian.Uint16(audio[start:start+2]) == 1 && binary.LittleEndian.Uint16(audio[start+2:start+4]) == 1 && binary.LittleEndian.Uint32(audio[start+4:start+8]) == 16000 && binary.LittleEndian.Uint16(audio[start+14:start+16]) == 16 && binary.LittleEndian.Uint32(audio[start+8:start+12]) == 32000 && binary.LittleEndian.Uint16(audio[start+12:start+14]) == 2
|
||||
case "data":
|
||||
dataSize += size
|
||||
}
|
||||
pos = start + size + size%2
|
||||
}
|
||||
return validFormat && dataSize > 0 && dataSize <= 16000*2*30 && dataSize%2 == 0
|
||||
}
|
||||
func (s *Server) adaptiveAudioAttempt(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
t, err := s.course.Repo.Task(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
if t.Kind != "repeat_sentence" && t.Kind != "free_speech" {
|
||||
writeError(w, 400, errors.New("this task does not accept audio"))
|
||||
return
|
||||
}
|
||||
r.Body = http.MaxBytesReader(w, r.Body, 2<<20)
|
||||
if err = r.ParseMultipartForm(2 << 20); err != nil {
|
||||
writeError(w, 400, errors.New("invalid audio upload"))
|
||||
return
|
||||
}
|
||||
if r.MultipartForm != nil {
|
||||
defer r.MultipartForm.RemoveAll()
|
||||
}
|
||||
requestID := r.FormValue("request_id")
|
||||
if !courseRequestIDPattern.MatchString(requestID) {
|
||||
writeError(w, 400, errors.New("request_id is required"))
|
||||
return
|
||||
}
|
||||
if old, err := s.course.Repo.AttemptByRequest(r.Context(), currentUserID(r), p.TargetLanguage, requestID); err == nil {
|
||||
if old.TaskID != t.ID {
|
||||
writeError(w, 400, errors.New("request belongs to another task"))
|
||||
return
|
||||
}
|
||||
a, err := s.course.PublicAttempt(r.Context(), currentUserID(r), p.TargetLanguage, old)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"attempt": a})
|
||||
return
|
||||
} else if !errors.Is(err, store.ErrNotFound) {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
file, _, err := r.FormFile("audio")
|
||||
if err != nil {
|
||||
writeError(w, 400, errors.New("audio is required"))
|
||||
return
|
||||
}
|
||||
defer file.Close()
|
||||
audio, err := io.ReadAll(io.LimitReader(file, (1<<20)+1))
|
||||
if err != nil || !validCourseWAV(audio) {
|
||||
writeError(w, 400, errors.New("Bitte eine WAV-Aufnahme mit 16 kHz, mono, maximal 30 Sekunden senden."))
|
||||
return
|
||||
}
|
||||
lang, err := s.store.GetLanguage(r.Context(), p.TargetLanguage)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
if lang.AzureLocale == "" {
|
||||
writeError(w, 503, errors.New("speech locale unavailable"))
|
||||
return
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(r.Context(), 50*time.Second)
|
||||
defer cancel()
|
||||
transcript := t.ReferenceText
|
||||
if t.Kind == "free_speech" {
|
||||
transcriber, ok := s.speech.(interface {
|
||||
Transcribe(context.Context, []byte, string, string) (string, error)
|
||||
})
|
||||
if !ok {
|
||||
writeError(w, 503, errors.New("free speech is unavailable"))
|
||||
return
|
||||
}
|
||||
transcript, err = transcriber.Transcribe(ctx, audio, "audio/wav", lang.AzureLocale)
|
||||
if err != nil {
|
||||
writeError(w, 503, errors.New("Die Aufnahme konnte nicht transkribiert werden. Bitte erneut senden."))
|
||||
return
|
||||
}
|
||||
}
|
||||
var speech *domain.PronunciationResult
|
||||
if lang.SupportsPronunciationAssessment {
|
||||
result, err := s.speech.AssessPronunciation(ctx, services.PronunciationInput{Audio: audio, ContentType: "audio/wav", TargetText: transcript, Locale: lang.AzureLocale})
|
||||
if err != nil {
|
||||
writeError(w, 503, errors.New("Die Sprachmessung ist fehlgeschlagen. Die Aufnahme kann erneut gesendet werden."))
|
||||
return
|
||||
}
|
||||
if t.Kind == "free_speech" {
|
||||
result.Method = "unscripted"
|
||||
result.CompletenessScore = 0
|
||||
result.RecognizedText = transcript
|
||||
}
|
||||
if result.Provider != "azure" {
|
||||
writeError(w, 503, errors.New("Für Kursaufnahmen ist eine echte Azure-Sprachmessung erforderlich."))
|
||||
return
|
||||
}
|
||||
speech = &result
|
||||
} else if t.Kind == "repeat_sentence" {
|
||||
transcriber, ok := s.speech.(interface {
|
||||
Transcribe(context.Context, []byte, string, string) (string, error)
|
||||
})
|
||||
if !ok {
|
||||
writeError(w, 503, errors.New("speech is unavailable"))
|
||||
return
|
||||
}
|
||||
transcript, err = transcriber.Transcribe(ctx, audio, "audio/wav", lang.AzureLocale)
|
||||
if err != nil {
|
||||
writeError(w, 503, errors.New("Die Aufnahme konnte nicht transkribiert werden."))
|
||||
return
|
||||
}
|
||||
}
|
||||
answer := transcript
|
||||
if speech != nil && t.Kind == "repeat_sentence" {
|
||||
answer = speech.RecognizedText
|
||||
}
|
||||
if strings.TrimSpace(answer) == "" {
|
||||
writeError(w, 400, errors.New("no speech recognized"))
|
||||
return
|
||||
}
|
||||
a, job, err := s.course.Submit(r.Context(), currentUserID(r), p.TargetLanguage, t.ID, requestID, answer, speech)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
a, err = s.course.PublicAttempt(r.Context(), currentUserID(r), p.TargetLanguage, a)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 202, map[string]any{"attempt": a, "job": job})
|
||||
}
|
||||
func (s *Server) adaptiveNewExam(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var input struct {
|
||||
RequestID string `json:"request_id"`
|
||||
}
|
||||
if !adaptiveJSON(w, r, &input) {
|
||||
return
|
||||
}
|
||||
if !courseRequestIDPattern.MatchString(input.RequestID) {
|
||||
writeError(w, 400, errors.New("request_id is required"))
|
||||
return
|
||||
}
|
||||
mods, err := s.course.Repo.Modules(r.Context(), p.TargetLanguage)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
if len(mods) != 7 {
|
||||
writeError(w, 404, store.ErrNotFound)
|
||||
return
|
||||
}
|
||||
exam, err := s.course.Repo.NewExam(r.Context(), currentUserID(r), p.TargetLanguage, input.RequestID)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
job, err := s.course.Repo.Enqueue(r.Context(), currentUserID(r), p.TargetLanguage, "exam", mods[6].ID, "", exam.ID, "exam:"+exam.ID)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 202, map[string]any{"exam": exam, "job": job})
|
||||
}
|
||||
func (s *Server) adaptiveExam(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
exam, err := s.course.Repo.Exam(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, exam)
|
||||
}
|
||||
|
||||
// The compatibility endpoint retains its synchronous choice response. New
|
||||
// clients use jobs; old clients can still submit the displayed option label.
|
||||
func (s *Server) adaptiveLegacyNext(w http.ResponseWriter, r *http.Request) {
|
||||
p, ok := s.adaptiveProfile(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var input struct {
|
||||
RequestID string `json:"request_id"`
|
||||
}
|
||||
if !adaptiveJSON(w, r, &input) {
|
||||
return
|
||||
}
|
||||
if !courseRequestIDPattern.MatchString(input.RequestID) {
|
||||
writeError(w, 400, errors.New("invalid request_id"))
|
||||
return
|
||||
}
|
||||
module := r.PathValue("id")
|
||||
if _, err := s.course.Repo.Module(r.Context(), p.TargetLanguage, module); err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
j, err := s.course.Repo.Enqueue(r.Context(), currentUserID(r), p.TargetLanguage, "legacy_next", module, "vocabulary", "", input.RequestID)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
timer := time.NewTimer(25 * time.Second)
|
||||
defer timer.Stop()
|
||||
ticker := time.NewTicker(250 * time.Millisecond)
|
||||
defer ticker.Stop()
|
||||
for j.Status == "queued" || j.Status == "running" {
|
||||
select {
|
||||
case <-r.Context().Done():
|
||||
return
|
||||
case <-timer.C:
|
||||
goto fallback
|
||||
case <-ticker.C:
|
||||
j, err = s.course.Repo.Job(r.Context(), currentUserID(r), p.TargetLanguage, j.ID)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
if j.Status == "succeeded" && j.TaskID != "" {
|
||||
t, err := s.course.Repo.Task(r.Context(), currentUserID(r), p.TargetLanguage, j.TaskID)
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeLegacyAdaptiveTask(w, t)
|
||||
return
|
||||
}
|
||||
fallback:
|
||||
t, err := s.course.Repo.Reserve(r.Context(), currentUserID(r), p.TargetLanguage, module, "vocabulary")
|
||||
if err != nil {
|
||||
adaptiveError(w, err)
|
||||
return
|
||||
}
|
||||
writeLegacyAdaptiveTask(w, t)
|
||||
}
|
||||
func legacyAdaptiveTask(t domain.AdaptiveTask) domain.CourseTask {
|
||||
task := domain.CourseTask{ID: t.ID, ModuleID: t.ModuleID, Skill: t.Skill, Kind: t.Kind, Prompt: t.Prompt, Passage: t.Passage, Source: t.Source, Options: []string{}}
|
||||
for _, o := range t.Options {
|
||||
task.Options = append(task.Options, o.Label)
|
||||
}
|
||||
return task
|
||||
}
|
||||
func writeLegacyAdaptiveTask(w http.ResponseWriter, t domain.AdaptiveTask) {
|
||||
writeJSON(w, 200, domain.CoursePracticeResult{Task: legacyAdaptiveTask(t), Source: t.Source})
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestCourseWAVUsesActualFormatAndDuration(t *testing.T) {
|
||||
wav := func(seconds int) []byte {
|
||||
b := make([]byte, 44+seconds*32000)
|
||||
copy(b, "RIFF")
|
||||
binary.LittleEndian.PutUint32(b[4:8], uint32(len(b)-8))
|
||||
copy(b[8:12], "WAVE")
|
||||
copy(b[12:16], "fmt ")
|
||||
binary.LittleEndian.PutUint32(b[16:20], 16)
|
||||
binary.LittleEndian.PutUint16(b[20:22], 1)
|
||||
binary.LittleEndian.PutUint16(b[22:24], 1)
|
||||
binary.LittleEndian.PutUint32(b[24:28], 16000)
|
||||
binary.LittleEndian.PutUint32(b[28:32], 32000)
|
||||
binary.LittleEndian.PutUint16(b[32:34], 2)
|
||||
binary.LittleEndian.PutUint16(b[34:36], 16)
|
||||
copy(b[36:40], "data")
|
||||
binary.LittleEndian.PutUint32(b[40:44], uint32(len(b)-44))
|
||||
return b
|
||||
}
|
||||
if !validCourseWAV(wav(30)) {
|
||||
t.Fatal("valid recording rejected")
|
||||
}
|
||||
if validCourseWAV(wav(31)) || validCourseWAV(wav(0)) {
|
||||
t.Fatal("duration not enforced")
|
||||
}
|
||||
for _, offset := range []int{20, 22, 24, 28, 32, 34} {
|
||||
b := wav(1)
|
||||
b[offset] ^= 0xff
|
||||
if validCourseWAV(b) {
|
||||
t.Fatalf("invalid format accepted at %d", offset)
|
||||
}
|
||||
}
|
||||
b := wav(1)
|
||||
binary.LittleEndian.PutUint32(b[40:44], 9999999)
|
||||
if validCourseWAV(b) || validCourseWAV([]byte("not a WAV")) {
|
||||
t.Fatal("malformed payload accepted")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,290 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"speech-learning-api/internal/domain"
|
||||
"speech-learning-api/internal/services"
|
||||
"speech-learning-api/internal/store"
|
||||
)
|
||||
|
||||
func (s *Server) SetAIService(a *services.AIService) { s.ai = a }
|
||||
func (s *Server) aiAvailable(w http.ResponseWriter) bool {
|
||||
if s.ai == nil {
|
||||
writeError(w, 503, errors.New("Direkte KI-Anbindung nicht eingerichtet"))
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
func aiHTTPError(w http.ResponseWriter, err error) {
|
||||
status := 500
|
||||
if errors.Is(err, store.ErrAIBudget) || errors.Is(err, store.ErrAIDisabled) || errors.Is(err, store.ErrAIAttempts) {
|
||||
status = 409
|
||||
}
|
||||
if errors.Is(err, store.ErrAIConflict) {
|
||||
status = 409
|
||||
}
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
status = 404
|
||||
}
|
||||
if status == 500 {
|
||||
writeError(w, status, errors.New("KI-Verwaltung momentan nicht verfügbar"))
|
||||
return
|
||||
}
|
||||
writeError(w, status, err)
|
||||
}
|
||||
func (s *Server) aiSettings(w http.ResponseWriter, r *http.Request) {
|
||||
if !s.aiAvailable(w) {
|
||||
return
|
||||
}
|
||||
profiles, err := s.ai.Repo.Profiles(r.Context())
|
||||
if err != nil {
|
||||
aiHTTPError(w, err)
|
||||
return
|
||||
}
|
||||
budget, err := s.ai.Repo.Budget(r.Context())
|
||||
if err != nil {
|
||||
aiHTTPError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"profiles": profiles, "budget": budget, "providers": map[string]bool{"deepseek": s.ai.Configured("deepseek"), "mistral": s.ai.Configured("mistral")}, "prompt_version": s.ai.PromptVersion, "prompts": s.ai.Prompts, "schemas": s.ai.Schemas})
|
||||
}
|
||||
func (s *Server) aiSaveProfile(w http.ResponseWriter, r *http.Request) {
|
||||
if !s.aiAvailable(w) {
|
||||
return
|
||||
}
|
||||
var p domain.AIProfile
|
||||
if !adaptiveJSON(w, r, &p) {
|
||||
return
|
||||
}
|
||||
if p.Action != r.PathValue("action") {
|
||||
writeError(w, 400, errors.New("Arbeitsschritt stimmt nicht überein"))
|
||||
return
|
||||
}
|
||||
if err := services.ValidAIProfile(p); err != nil {
|
||||
writeError(w, 400, err)
|
||||
return
|
||||
}
|
||||
saved, err := s.ai.Repo.SaveProfile(r.Context(), currentUserID(r), p)
|
||||
if err != nil {
|
||||
aiHTTPError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, saved)
|
||||
}
|
||||
func (s *Server) aiSaveBudget(w http.ResponseWriter, r *http.Request) {
|
||||
if !s.aiAvailable(w) {
|
||||
return
|
||||
}
|
||||
var b struct {
|
||||
Month int64 `json:"monthly_limit_microusd"`
|
||||
Day int64 `json:"daily_limit_microusd"`
|
||||
}
|
||||
if !adaptiveJSON(w, r, &b) {
|
||||
return
|
||||
}
|
||||
if b.Month < 0 || b.Day < 0 || b.Month > 1000000000000 || b.Day > 1000000000000 {
|
||||
writeError(w, 400, errors.New("Ungültiges Budget"))
|
||||
return
|
||||
}
|
||||
if err := s.ai.Repo.SaveBudget(r.Context(), currentUserID(r), b.Month, b.Day); err != nil {
|
||||
aiHTTPError(w, err)
|
||||
return
|
||||
}
|
||||
value, err := s.ai.Repo.Budget(r.Context())
|
||||
if err != nil {
|
||||
aiHTTPError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, value)
|
||||
}
|
||||
func (s *Server) aiModels(w http.ResponseWriter, r *http.Request) {
|
||||
if !s.aiAvailable(w) {
|
||||
return
|
||||
}
|
||||
p := r.PathValue("provider")
|
||||
if p != "deepseek" && p != "mistral" {
|
||||
writeError(w, 400, errors.New("Unbekannter Anbieter"))
|
||||
return
|
||||
}
|
||||
models, err := s.ai.Models(r.Context(), p)
|
||||
if err != nil {
|
||||
writeError(w, 502, errors.New("Modellliste nicht verfügbar; API-Key und Anbieterzugang prüfen"))
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, models)
|
||||
}
|
||||
func (s *Server) aiUsage(w http.ResponseWriter, r *http.Request) {
|
||||
if !s.aiAvailable(w) {
|
||||
return
|
||||
}
|
||||
q := r.URL.Query()
|
||||
offset := 0
|
||||
if q.Get("offset") != "" {
|
||||
n, err := strconv.Atoi(q.Get("offset"))
|
||||
if err != nil || n < 0 || n > 1000000 {
|
||||
writeError(w, 400, errors.New("Ungültige Seite"))
|
||||
return
|
||||
}
|
||||
offset = n
|
||||
}
|
||||
for _, key := range []string{"from", "to"} {
|
||||
if q.Get(key) != "" {
|
||||
if _, err := time.Parse(time.RFC3339, q.Get(key)); err != nil {
|
||||
writeError(w, 400, errors.New("Zeitraum muss RFC3339 sein"))
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
result, err := s.ai.Repo.Usage(r.Context(), domain.AIUsageFilter{From: q.Get("from"), To: q.Get("to"), Provider: q.Get("provider"), Model: q.Get("model"), User: q.Get("user"), Action: q.Get("action"), Offset: offset})
|
||||
if err != nil {
|
||||
aiHTTPError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, result)
|
||||
}
|
||||
func (s *Server) aiCallDetail(w http.ResponseWriter, r *http.Request) {
|
||||
if !s.aiAvailable(w) {
|
||||
return
|
||||
}
|
||||
c, err := s.ai.Repo.Call(r.Context(), r.PathValue("id"))
|
||||
if err != nil {
|
||||
aiHTTPError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, c)
|
||||
}
|
||||
func (s *Server) aiResolve(w http.ResponseWriter, r *http.Request) {
|
||||
if !s.aiAvailable(w) {
|
||||
return
|
||||
}
|
||||
var b struct {
|
||||
Cost int64 `json:"cost_microusd"`
|
||||
Reason string `json:"reason"`
|
||||
}
|
||||
if !adaptiveJSON(w, r, &b) {
|
||||
return
|
||||
}
|
||||
if b.Cost < 0 || b.Cost > 1000000000000 || len(b.Reason) < 5 || len(b.Reason) > 1000 {
|
||||
writeError(w, 400, errors.New("Kosten und Begründung erforderlich"))
|
||||
return
|
||||
}
|
||||
if err := s.ai.Repo.Resolve(r.Context(), currentUserID(r), r.PathValue("id"), b.Cost, b.Reason); err != nil {
|
||||
aiHTTPError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]bool{"ok": true})
|
||||
}
|
||||
func (s *Server) aiTest(w http.ResponseWriter, r *http.Request) {
|
||||
if !s.aiAvailable(w) {
|
||||
return
|
||||
}
|
||||
var b struct {
|
||||
RequestID string `json:"request_id"`
|
||||
Action string `json:"action"`
|
||||
Input json.RawMessage `json:"input"`
|
||||
}
|
||||
if !aiTestJSON(w, r, &b) {
|
||||
return
|
||||
}
|
||||
if !courseRequestIDPattern.MatchString(b.RequestID) {
|
||||
writeError(w, 400, errors.New("request_id erforderlich"))
|
||||
return
|
||||
}
|
||||
if _, ok := s.ai.Prompts[b.Action]; !ok {
|
||||
writeError(w, 400, errors.New("Unbekannter Arbeitsschritt"))
|
||||
return
|
||||
}
|
||||
if len(b.Input) == 0 {
|
||||
writeError(w, 400, errors.New("Testeingabe fehlt"))
|
||||
return
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(r.Context(), 75*time.Second)
|
||||
defer cancel()
|
||||
ctx, operation, err := s.ai.Begin(ctx, currentUserID(r), "test_"+currentUserID(r)+"_"+b.RequestID, true)
|
||||
if err != nil {
|
||||
aiHTTPError(w, err)
|
||||
return
|
||||
}
|
||||
var result json.RawMessage
|
||||
// Typed contracts prevent a test from showing malformed JSON as successful.
|
||||
output := services.AIOutputForAction(b.Action)
|
||||
err = s.ai.Call(ctx, b.Action, b.Input, output)
|
||||
if err != nil {
|
||||
writeJSON(w, 200, map[string]any{"ok": false, "operation_id": operation.ID, "error": s.ai.AdminError(err), "profile": operation.Profiles[b.Action], "prompt_version": operation.PromptVersion})
|
||||
return
|
||||
}
|
||||
result, err = json.Marshal(output)
|
||||
if err != nil {
|
||||
aiHTTPError(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"ok": true, "operation_id": operation.ID, "output": result, "profile": operation.Profiles[b.Action], "prompt_version": operation.PromptVersion})
|
||||
}
|
||||
|
||||
func (s *Server) aiQuality(w http.ResponseWriter, r *http.Request) {
|
||||
if !s.aiAvailable(w) {
|
||||
return
|
||||
}
|
||||
var b struct {
|
||||
RequestID string `json:"request_id"`
|
||||
Suite string `json:"suite"`
|
||||
}
|
||||
if !adaptiveJSON(w, r, &b) {
|
||||
return
|
||||
}
|
||||
if !courseRequestIDPattern.MatchString(b.RequestID) {
|
||||
writeError(w, 400, errors.New("request_id erforderlich"))
|
||||
return
|
||||
}
|
||||
if b.Suite == "" {
|
||||
b.Suite = "grammar"
|
||||
}
|
||||
if b.Suite != "grammar" && b.Suite != "writing" {
|
||||
writeError(w, 400, errors.New("Unbekannte Qualitätsprüfung"))
|
||||
return
|
||||
}
|
||||
operationID := "quality_" + currentUserID(r) + "_" + b.RequestID
|
||||
if b.Suite != "grammar" {
|
||||
operationID = "quality_" + b.Suite + "_" + currentUserID(r) + "_" + b.RequestID
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(r.Context(), 80*time.Second)
|
||||
defer cancel()
|
||||
ctx, o, err := s.ai.Begin(ctx, currentUserID(r), operationID, true)
|
||||
if err != nil {
|
||||
aiHTTPError(w, err)
|
||||
return
|
||||
}
|
||||
results, err := s.ai.QualitySuite(ctx, b.Suite)
|
||||
if err != nil {
|
||||
aiHTTPError(w, err)
|
||||
return
|
||||
}
|
||||
passed := true
|
||||
for _, result := range results {
|
||||
passed = passed && result.Passed
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"suite": b.Suite, "passed": passed, "results": results, "operation_id": o.ID, "profile": o.Profiles["evaluate_course_attempt"]})
|
||||
}
|
||||
|
||||
func aiTestJSON(w http.ResponseWriter, r *http.Request, out any) bool {
|
||||
r.Body = http.MaxBytesReader(w, r.Body, 1<<20)
|
||||
defer r.Body.Close()
|
||||
decoder := json.NewDecoder(r.Body)
|
||||
decoder.DisallowUnknownFields()
|
||||
if err := decoder.Decode(out); err != nil {
|
||||
writeError(w, 400, errors.New("Ungültige Testeingabe; maximal 1 MiB"))
|
||||
return false
|
||||
}
|
||||
if decoder.Decode(new(any)) != io.EOF {
|
||||
writeError(w, 400, errors.New("Zusätzliche Daten hinter der Testeingabe"))
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
@@ -0,0 +1,468 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"syscall"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
_ "github.com/jackc/pgx/v5/stdlib"
|
||||
"speech-learning-api/internal/config"
|
||||
"speech-learning-api/internal/domain"
|
||||
"speech-learning-api/internal/services"
|
||||
"speech-learning-api/internal/store"
|
||||
)
|
||||
|
||||
func aiHTTPFixture(t *testing.T, bankMode ...bool) (*httptest.Server, string, *store.AIStore) {
|
||||
t.Helper()
|
||||
dsn := os.Getenv("COURSE_TEST_DATABASE_URL")
|
||||
if dsn == "" {
|
||||
t.Skip("COURSE_TEST_DATABASE_URL not set")
|
||||
}
|
||||
admin, err := sql.Open("pgx", dsn)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
schema := store.NewID("ai_http")
|
||||
if _, err = admin.Exec(`CREATE SCHEMA ` + schema); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
parsed, _ := url.Parse(dsn)
|
||||
q := parsed.Query()
|
||||
q.Set("search_path", schema)
|
||||
parsed.RawQuery = q.Encode()
|
||||
db, err := sql.Open("pgx", parsed.String())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { db.Close(); admin.Exec(`DROP SCHEMA ` + schema + ` CASCADE`); admin.Close() })
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
t.Cleanup(cancel)
|
||||
profiles := store.NewPostgresStore(db)
|
||||
if err = profiles.Init(ctx); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
user, err := profiles.CreateUser(ctx, "ai-http@example.test", "hash", "de-DE")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
profiles.CreateLearnerProfile(ctx, user.ID, "en-US", "A1", 10)
|
||||
db.Exec(`UPDATE users SET role='admin' WHERE id=$1`, user.ID)
|
||||
cfg := config.Config{JWTSecret: "ai-http-test-only", MistralAPIKey: "fixture-key", DeepSeekAPIKey: "fixture-key", AzureMock: true, CORSOrigins: []string{"http://localhost:15175"}}
|
||||
if len(bankMode) > 1 && bankMode[1] {
|
||||
cfg.PronunciationStrategy = "statistical"
|
||||
}
|
||||
var exerciseNumber atomic.Int32
|
||||
a := services.NewAIService(store.NewAIStore(db), cfg)
|
||||
provider := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path == "/models" {
|
||||
json.NewEncoder(w).Encode(map[string]any{"data": []any{map[string]any{"id": "fixture-model", "context_window": 131072, "max_output_tokens": 16384}}})
|
||||
return
|
||||
}
|
||||
var body struct {
|
||||
Messages []struct {
|
||||
Content string `json:"content"`
|
||||
} `json:"messages"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&body); err != nil || len(body.Messages) != 2 {
|
||||
t.Error("missing model messages")
|
||||
http.Error(w, "bad", 400)
|
||||
return
|
||||
}
|
||||
var request struct {
|
||||
Task string `json:"task"`
|
||||
Input json.RawMessage `json:"input"`
|
||||
}
|
||||
json.Unmarshal([]byte(body.Messages[1].Content), &request)
|
||||
var result any
|
||||
switch request.Task {
|
||||
case "next_exercise":
|
||||
var in struct {
|
||||
Mode string `json:"training_mode"`
|
||||
Required []string `json:"required_practice_words"`
|
||||
Plan *domain.PronunciationPlan `json:"training_plan"`
|
||||
}
|
||||
json.Unmarshal(request.Input, &in)
|
||||
word := "cat"
|
||||
candidate := ""
|
||||
if len(in.Required) > 0 {
|
||||
word = in.Required[0]
|
||||
}
|
||||
if in.Mode == "transfer" {
|
||||
word = "cup"
|
||||
if in.Plan != nil {
|
||||
for _, known := range in.Plan.KnownWords {
|
||||
if known == word {
|
||||
word = "school"
|
||||
}
|
||||
}
|
||||
}
|
||||
candidate = word
|
||||
}
|
||||
n := exerciseNumber.Add(1)
|
||||
ref := fmt.Sprintf("I see a %s near %s.", word, []string{"home", "the lake", "the pond", "the shop", "the house", "the garden"}[int(n-1)%6])
|
||||
result = domain.GeneratedExercise{ExerciseType: "repeat_sentence", TargetLanguage: "en-US", CEFRLevel: "A1", ReferenceText: ref, TTSText: ref, DisplayPrompt: "Sprich den Satz nach.", ReasonForChoice: "Kurze Übung anhand des gespeicherten Trainingsziels.", FocusPoints: []string{word}, SuccessCriteria: []string{"Sprich mit natürlichem Rhythmus."}, CandidateWord: candidate}
|
||||
|
||||
case "evaluate_course_attempt":
|
||||
var in struct {
|
||||
Answer string `json:"answer"`
|
||||
}
|
||||
json.Unmarshal(request.Input, &in)
|
||||
score, verdict, issues := 100, "correct", []string{}
|
||||
if in.Answer == "He have got a sister." {
|
||||
score, verdict, issues = 60, "partial", []string{"has nach he verwenden"}
|
||||
}
|
||||
feedback := "Bewertung aus Testanbieter"
|
||||
if in.Answer == "my name is Jack Hill. I live in city. My hobby is shwiming." {
|
||||
score, verdict, issues = 80, "partial", []string{"Am Satzanfang My schreiben.", "in city muss in a city heißen.", "shwiming muss swimming heißen."}
|
||||
feedback = "Inhalt erfüllt; My am Satzanfang, a city und swimming korrigieren."
|
||||
}
|
||||
result = map[string]any{"score": score, "verdict": verdict, "feedback": feedback, "issues": issues}
|
||||
case "analyze_course_progress":
|
||||
var in domain.CourseSnapshot
|
||||
json.Unmarshal(request.Input, &in)
|
||||
modules := []domain.ModuleAnalysis{}
|
||||
for _, m := range in.Modules {
|
||||
modules = append(modules, domain.ModuleAnalysis{ModuleID: m.ID, Strengths: []string{}, Weaknesses: []string{}, Recommendation: "Weiterlernen", Reason: "Aus gespeicherten Antworten", EvidenceIDs: []string{}})
|
||||
}
|
||||
result = domain.CourseAnalysis{SchemaVersion: 2, TargetLanguage: "en-US", CourseVersion: domain.CourseVersion, FactsVersion: in.FactsVersion, Summary: "Lernstand aus Testanbieter", RecommendedModuleID: "a1_family_v1", Modules: modules}
|
||||
case "plan_course_task":
|
||||
var in struct {
|
||||
Module string `json:"module_id"`
|
||||
Skill string `json:"requested_skill"`
|
||||
}
|
||||
json.Unmarshal(request.Input, &in)
|
||||
if in.Skill == "" {
|
||||
in.Skill = "grammar"
|
||||
}
|
||||
kind := "choice"
|
||||
if in.Skill == "writing" {
|
||||
kind = "free_text"
|
||||
}
|
||||
if in.Skill == "speaking" {
|
||||
kind = "free_speech"
|
||||
}
|
||||
if in.Skill == "reading" {
|
||||
kind = "short_text"
|
||||
}
|
||||
result = domain.CourseBrief{SchemaVersion: 2, ModuleID: in.Module, TargetLanguage: "en-US", CourseVersion: domain.CourseVersion, Skill: in.Skill, Kind: kind, Objective: "A1-Aufgabe", Difficulty: "A1", Reason: "Lernstand"}
|
||||
case "author_course_task":
|
||||
var in struct {
|
||||
Brief domain.CourseBrief `json:"brief"`
|
||||
}
|
||||
json.Unmarshal(request.Input, &in)
|
||||
task := domain.AdaptiveTask{SchemaVersion: 2, ModuleID: in.Brief.ModuleID, TargetLanguage: "en-US", CourseVersion: domain.CourseVersion, CEFRLevel: "A1", Skill: in.Brief.Skill, Kind: in.Brief.Kind, Prompt: "Aufgabe vom direkten Testanbieter", AnswerKey: &domain.TaskKey{Rubric: []string{"Verständliche A1-Antwort"}, Explanation: "Private Testlösung", ReferenceAnswer: "He has got a sister."}}
|
||||
if task.Kind == "choice" {
|
||||
task.Options = []domain.TaskOption{{ID: "o1", Label: "Anna"}, {ID: "o2", Label: "Bob"}, {ID: "o3", Label: "Tom"}}
|
||||
task.AnswerKey.CorrectOptionID = "o1"
|
||||
}
|
||||
if task.Skill == "reading" {
|
||||
task.Passage = "My name is Anna."
|
||||
}
|
||||
if task.Skill == "listening" {
|
||||
task.AudioText = "My name is Anna."
|
||||
}
|
||||
result = map[string]any{"schema_version": 2, "tasks": []domain.AdaptiveTask{task}}
|
||||
case "review_course_task":
|
||||
var in struct {
|
||||
Candidate struct {
|
||||
Tasks []domain.AdaptiveTask `json:"tasks"`
|
||||
} `json:"candidate"`
|
||||
}
|
||||
json.Unmarshal(request.Input, &in)
|
||||
checks := []services.AIChoiceCheck{}
|
||||
for i, task := range in.Candidate.Tasks {
|
||||
if task.Kind == "choice" {
|
||||
if task.AnswerKey != nil {
|
||||
t.Error("authored key leaked to reviewer")
|
||||
}
|
||||
check := services.AIChoiceCheck{TaskIndex: i}
|
||||
for n, option := range task.Options {
|
||||
check.Options = append(check.Options, services.AIOptionCheck{OptionID: option.ID, IsCorrect: n == 0, Reason: "Fixture solution"})
|
||||
}
|
||||
checks = append(checks, check)
|
||||
}
|
||||
}
|
||||
result = services.AIReview{SchemaVersion: 2, Approved: true, ChoiceChecks: checks, ReviewNotes: "Unabhängig gelöst"}
|
||||
case "author_course_exam":
|
||||
tasks, err := store.NewAdaptiveStore(db).ReserveExam(ctx, user.ID, "en-US", "a1_review_test_v1")
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
for i := range tasks {
|
||||
tasks[i].Source = ""
|
||||
}
|
||||
result = map[string]any{"schema_version": 2, "tasks": tasks}
|
||||
case "review_course_exam":
|
||||
var in struct {
|
||||
Candidate struct {
|
||||
Tasks []domain.AdaptiveTask `json:"tasks"`
|
||||
} `json:"candidate"`
|
||||
}
|
||||
json.Unmarshal(request.Input, &in)
|
||||
checks := []services.AIChoiceCheck{}
|
||||
for i, task := range in.Candidate.Tasks {
|
||||
if task.Kind == "choice" {
|
||||
if task.AnswerKey != nil {
|
||||
t.Error("authored key leaked to reviewer")
|
||||
}
|
||||
check := services.AIChoiceCheck{TaskIndex: i}
|
||||
for n, option := range task.Options {
|
||||
check.Options = append(check.Options, services.AIOptionCheck{OptionID: option.ID, IsCorrect: n == 0, Reason: "Fixture solution"})
|
||||
}
|
||||
checks = append(checks, check)
|
||||
}
|
||||
}
|
||||
result = services.AIReview{SchemaVersion: 2, Approved: true, ChoiceChecks: checks, ReviewNotes: "Unabhängig gelöst"}
|
||||
default:
|
||||
t.Error("unexpected task", request.Task)
|
||||
http.Error(w, "unsupported", 400)
|
||||
return
|
||||
}
|
||||
output, _ := json.Marshal(result)
|
||||
json.NewEncoder(w).Encode(map[string]any{"choices": []any{map[string]any{"finish_reason": "stop", "message": map[string]any{"content": string(output)}}}, "usage": map[string]any{"prompt_tokens": 100, "completion_tokens": 30}})
|
||||
}))
|
||||
t.Cleanup(provider.Close)
|
||||
a.URLs["mistral"] = provider.URL
|
||||
a.URLs["deepseek"] = provider.URL
|
||||
auth := services.NewAuthService(profiles, cfg.JWTSecret)
|
||||
logger := slog.New(slog.NewTextHandler(io.Discard, nil))
|
||||
server := NewServer(cfg, logger, profiles, auth, services.NewAzureSpeechService(cfg, logger), a)
|
||||
server.SetAIService(a)
|
||||
engine := services.NewCourseEngine(store.NewAdaptiveStore(db), profiles, a, logger)
|
||||
if len(bankMode) > 0 && bankMode[0] {
|
||||
engine.Mode = "bank"
|
||||
server.speech = bankFixtureSpeech{}
|
||||
}
|
||||
if len(bankMode) > 1 && bankMode[1] {
|
||||
server.speech = statisticalFixtureSpeech{}
|
||||
}
|
||||
server.SetCourseEngine(engine)
|
||||
go engine.Run(ctx)
|
||||
api := httptest.NewServer(server.Routes())
|
||||
t.Cleanup(api.Close)
|
||||
token, _ := auth.IssueToken(user.ID)
|
||||
return api, token, a.Repo
|
||||
}
|
||||
func aiHTTP(t *testing.T, api *httptest.Server, token, method, path string, body any) map[string]json.RawMessage {
|
||||
t.Helper()
|
||||
data, _ := json.Marshal(body)
|
||||
req, _ := http.NewRequest(method, api.URL+path, bytes.NewReader(data))
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
resp, err := api.Client().Do(req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
var result map[string]json.RawMessage
|
||||
json.NewDecoder(resp.Body).Decode(&result)
|
||||
if resp.StatusCode >= 300 {
|
||||
t.Fatalf("%s %s: %d: %s", method, path, resp.StatusCode, result["error"])
|
||||
}
|
||||
return result
|
||||
}
|
||||
func TestAIAdminPostgresAPI(t *testing.T) {
|
||||
api, token, repo := aiHTTPFixture(t)
|
||||
settings := aiHTTP(t, api, token, "GET", "/admin/ai/settings", nil)
|
||||
var profiles map[string]domain.AIProfile
|
||||
json.Unmarshal(settings["profiles"], &profiles)
|
||||
p := profiles["evaluate_course_attempt"]
|
||||
p.Model = "fixture-model"
|
||||
p.PricingSet = true
|
||||
p.InputPrice = 1000000
|
||||
p.OutputPrice = 2000000
|
||||
p.ContextTokens = 131072
|
||||
aiHTTP(t, api, token, "PUT", "/admin/ai/profiles/"+p.Action, p)
|
||||
aiHTTP(t, api, token, "PUT", "/admin/ai/budget", map[string]int64{"monthly_limit_microusd": 1000000})
|
||||
aiHTTP(t, api, token, "GET", "/admin/ai/providers/mistral/models", nil)
|
||||
result := aiHTTP(t, api, token, "POST", "/admin/ai/quality", map[string]string{"request_id": "quality-request"})
|
||||
var passed bool
|
||||
json.Unmarshal(result["passed"], &passed)
|
||||
if !passed {
|
||||
t.Fatal("quality fixture failed", result)
|
||||
}
|
||||
// Same request must reuse both paid completions.
|
||||
aiHTTP(t, api, token, "POST", "/admin/ai/quality", map[string]string{"request_id": "quality-request"})
|
||||
report, err := repo.Usage(context.Background(), domain.AIUsageFilter{})
|
||||
if err != nil || report.Total != 2 {
|
||||
t.Fatal("duplicate API test billing", report, err)
|
||||
}
|
||||
c := aiHTTP(t, api, token, "GET", "/admin/ai/calls/"+report.Calls[0].ID, nil)
|
||||
if bytes.Contains(c["input"], []byte("fixture-key")) {
|
||||
t.Fatal("key leaked")
|
||||
}
|
||||
}
|
||||
func TestAIBrowserSmoke(t *testing.T) {
|
||||
if os.Getenv("AI_BROWSER_SMOKE") != "1" {
|
||||
t.Skip("AI_BROWSER_SMOKE=1 enables Playwright against a disposable API")
|
||||
}
|
||||
api, token, _ := aiHTTPFixture(t)
|
||||
_, file, _, _ := runtime.Caller(0)
|
||||
web := filepath.Clean(filepath.Join(filepath.Dir(file), "../../../web"))
|
||||
dev := exec.Command("npm", "run", "dev", "--", "--host", "127.0.0.1", "--port", "15175", "--strictPort")
|
||||
dev.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
|
||||
dev.Dir = web
|
||||
dev.Env = append(os.Environ(), "VITE_API_BASE_URL="+api.URL)
|
||||
var devOutput bytes.Buffer
|
||||
dev.Stdout = &devOutput
|
||||
dev.Stderr = &devOutput
|
||||
if err := dev.Start(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var stopOnce sync.Once
|
||||
stopDev := func() {
|
||||
stopOnce.Do(func() {
|
||||
if dev.Process != nil {
|
||||
syscall.Kill(-dev.Process.Pid, syscall.SIGTERM)
|
||||
dev.Wait()
|
||||
}
|
||||
})
|
||||
}
|
||||
t.Cleanup(stopDev)
|
||||
ready := false
|
||||
for i := 0; i < 40; i++ {
|
||||
resp, err := http.Get("http://localhost:15175")
|
||||
if err == nil {
|
||||
resp.Body.Close()
|
||||
ready = true
|
||||
break
|
||||
}
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
if !ready {
|
||||
stopDev()
|
||||
t.Fatal("Vite did not start", devOutput.String())
|
||||
}
|
||||
node := exec.Command("node", "tests/ai-admin.e2e.cjs")
|
||||
node.Dir = web
|
||||
node.Env = append(os.Environ(), "AI_E2E_API="+api.URL, "AI_E2E_TOKEN="+token, "AI_E2E_URL=http://localhost:15175")
|
||||
output, err := node.CombinedOutput()
|
||||
stopDev()
|
||||
t.Log(string(output))
|
||||
t.Log("Vite:", devOutput.String())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBankBrowserSmoke(t *testing.T) {
|
||||
if os.Getenv("BANK_BROWSER_SMOKE") != "1" {
|
||||
t.Skip("BANK_BROWSER_SMOKE=1 enables Playwright against a disposable API")
|
||||
}
|
||||
api, token, _ := aiHTTPFixture(t, true)
|
||||
_, file, _, _ := runtime.Caller(0)
|
||||
web := filepath.Clean(filepath.Join(filepath.Dir(file), "../../../web"))
|
||||
dev := exec.Command("npm", "run", "dev", "--", "--host", "127.0.0.1", "--port", "15175", "--strictPort")
|
||||
dev.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
|
||||
dev.Dir = web
|
||||
dev.Env = append(os.Environ(), "VITE_API_BASE_URL="+api.URL)
|
||||
var devOutput bytes.Buffer
|
||||
dev.Stdout = &devOutput
|
||||
dev.Stderr = &devOutput
|
||||
if err := dev.Start(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var stopOnce sync.Once
|
||||
stopDev := func() {
|
||||
stopOnce.Do(func() {
|
||||
if dev.Process != nil {
|
||||
syscall.Kill(-dev.Process.Pid, syscall.SIGTERM)
|
||||
dev.Wait()
|
||||
}
|
||||
})
|
||||
}
|
||||
t.Cleanup(stopDev)
|
||||
ready := false
|
||||
for i := 0; i < 40; i++ {
|
||||
resp, err := http.Get("http://localhost:15175")
|
||||
if err == nil {
|
||||
resp.Body.Close()
|
||||
ready = true
|
||||
break
|
||||
}
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
if !ready {
|
||||
stopDev()
|
||||
t.Fatal("Vite did not start", devOutput.String())
|
||||
}
|
||||
node := exec.Command("node", "tests/course-bank.e2e.cjs")
|
||||
node.Dir = web
|
||||
node.Env = append(os.Environ(), "AI_E2E_API="+api.URL, "AI_E2E_TOKEN="+token, "AI_E2E_URL=http://localhost:15175")
|
||||
output, err := node.CombinedOutput()
|
||||
stopDev()
|
||||
t.Log(string(output))
|
||||
t.Log("Vite:", devOutput.String())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPronunciationBrowserSmoke(t *testing.T) {
|
||||
if os.Getenv("PRONUNCIATION_BROWSER_SMOKE") != "1" {
|
||||
t.Skip("PRONUNCIATION_BROWSER_SMOKE=1 enables Playwright against a disposable API")
|
||||
}
|
||||
api, token, _ := aiHTTPFixture(t, true, true)
|
||||
_, file, _, _ := runtime.Caller(0)
|
||||
web := filepath.Clean(filepath.Join(filepath.Dir(file), "../../../web"))
|
||||
dev := exec.Command("npm", "run", "dev", "--", "--host", "127.0.0.1", "--port", "15175", "--strictPort")
|
||||
dev.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
|
||||
dev.Dir = web
|
||||
dev.Env = append(os.Environ(), "VITE_API_BASE_URL="+api.URL)
|
||||
var devOutput bytes.Buffer
|
||||
dev.Stdout = &devOutput
|
||||
dev.Stderr = &devOutput
|
||||
if err := dev.Start(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var stopOnce sync.Once
|
||||
stopDev := func() {
|
||||
stopOnce.Do(func() {
|
||||
if dev.Process != nil {
|
||||
syscall.Kill(-dev.Process.Pid, syscall.SIGTERM)
|
||||
dev.Wait()
|
||||
}
|
||||
})
|
||||
}
|
||||
t.Cleanup(stopDev)
|
||||
ready := false
|
||||
for i := 0; i < 40; i++ {
|
||||
resp, err := http.Get("http://localhost:15175")
|
||||
if err == nil {
|
||||
resp.Body.Close()
|
||||
ready = true
|
||||
break
|
||||
}
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
if !ready {
|
||||
stopDev()
|
||||
t.Fatal("Vite did not start", devOutput.String())
|
||||
}
|
||||
node := exec.Command("node", "tests/pronunciation-profile.e2e.cjs")
|
||||
node.Dir = web
|
||||
node.Env = append(os.Environ(), "AI_E2E_API="+api.URL, "AI_E2E_TOKEN="+token, "AI_E2E_URL=http://localhost:15175")
|
||||
output, err := node.CombinedOutput()
|
||||
stopDev()
|
||||
t.Log(string(output))
|
||||
t.Log("Vite:", devOutput.String())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"io"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"speech-learning-api/internal/config"
|
||||
"speech-learning-api/internal/services"
|
||||
)
|
||||
|
||||
func TestAIAdminRoutesAreProtected(t *testing.T) {
|
||||
data := &adminTestStore{role: "learner"}
|
||||
auth := services.NewAuthService(nil, "ai-route-secret")
|
||||
token, _ := auth.IssueToken("admin-test")
|
||||
s := &Server{store: data, auth: auth, logger: slog.New(slog.NewTextHandler(io.Discard, nil))}
|
||||
handler := s.Routes()
|
||||
for _, route := range []struct{ method, path string }{{"GET", "settings"}, {"PUT", "profiles/evaluate_course_attempt"}, {"PUT", "budget"}, {"GET", "providers/mistral/models"}, {"GET", "usage"}, {"GET", "calls/test"}, {"POST", "calls/test/resolve"}, {"POST", "test"}, {"POST", "quality"}} {
|
||||
for _, role := range []string{"anonymous", "learner", "admin"} {
|
||||
data.role = role
|
||||
req := httptest.NewRequest(route.method, "/admin/ai/"+route.path, strings.NewReader("{}"))
|
||||
if role != "anonymous" {
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
}
|
||||
w := httptest.NewRecorder()
|
||||
handler.ServeHTTP(w, req)
|
||||
want := http.StatusForbidden
|
||||
if role == "anonymous" {
|
||||
want = 401
|
||||
}
|
||||
if role == "admin" {
|
||||
want = 503
|
||||
}
|
||||
if w.Code != want {
|
||||
t.Fatalf("%s %s %s: %d, expected %d", role, route.method, route.path, w.Code, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAISettingsCORSAllowsPUT(t *testing.T) {
|
||||
s := &Server{cfg: config.Config{CORSOrigins: []string{"http://localhost:15175"}}}
|
||||
req := httptest.NewRequest("OPTIONS", "/admin/ai/budget", nil)
|
||||
req.Header.Set("Origin", "http://localhost:15175")
|
||||
req.Header.Set("Access-Control-Request-Method", "PUT")
|
||||
w := httptest.NewRecorder()
|
||||
s.cors(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { t.Fatal("preflight should terminate in middleware") })).ServeHTTP(w, req)
|
||||
if !strings.Contains(w.Header().Get("Access-Control-Allow-Methods"), "PUT") {
|
||||
t.Fatal("PUT settings blocked by CORS")
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"speech-learning-api/internal/domain"
|
||||
"speech-learning-api/internal/services"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Explicit local fixture, not a claim of a real Azure measurement.
|
||||
type bankFixtureSpeech struct{}
|
||||
|
||||
func (bankFixtureSpeech) AssessPronunciation(_ context.Context, in services.PronunciationInput) (domain.PronunciationResult, error) {
|
||||
return domain.PronunciationResult{Provider: "azure", RecognizedText: in.TargetText, OverallScore: 90, AccuracyScore: 90}, nil
|
||||
}
|
||||
func (bankFixtureSpeech) Transcribe(context.Context, []byte, string, string) (string, error) {
|
||||
return "I have got a brother.", nil
|
||||
}
|
||||
func (bankFixtureSpeech) Synthesize(context.Context, string, string, string) ([]byte, string, error) {
|
||||
return []byte("fixture mp3"), "audio/mpeg", nil
|
||||
}
|
||||
func (bankFixtureSpeech) SynthesizeExercise(context.Context, string, string, string, string, string) ([]byte, string, error) {
|
||||
return []byte("fixture mp3"), "audio/mpeg", nil
|
||||
}
|
||||
|
||||
// Named fixtures intentionally simulate known measurements; they never call Azure.
|
||||
type statisticalFixtureSpeech struct{ bankFixtureSpeech }
|
||||
|
||||
func (statisticalFixtureSpeech) AssessPronunciation(_ context.Context, in services.PronunciationInput) (domain.PronunciationResult, error) {
|
||||
result := domain.PronunciationResult{Provider: "azure", Locale: in.Locale, Alphabet: "IPA", Method: "scripted", MeasurementVersion: "test-fixture", RecognizedText: in.TargetText, OverallScore: 80, AccuracyScore: 80}
|
||||
for _, token := range strings.Fields(in.TargetText) {
|
||||
word := strings.ToLower(strings.Trim(token, ".,!?"))
|
||||
w := domain.WordScore{Word: word, Accuracy: 90, Highlight: "good"}
|
||||
if word == "cat" || word == "cup" || word == "school" {
|
||||
w.Accuracy = 40
|
||||
w.Highlight = "weak"
|
||||
w.PhonemeScores = []domain.PhonemeScore{{Phoneme: "k", Accuracy: 30, Highlight: "weak"}}
|
||||
}
|
||||
result.WordScores = append(result.WordScores, w)
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"speech-learning-api/internal/domain"
|
||||
"speech-learning-api/internal/store"
|
||||
)
|
||||
|
||||
type practiceTestStore struct {
|
||||
*courseTestStore
|
||||
saved int
|
||||
fallback int
|
||||
existing bool
|
||||
saveError bool
|
||||
selectionError bool
|
||||
}
|
||||
|
||||
func (s *practiceTestStore) GetUser(context.Context, string) (domain.User, error) {
|
||||
return domain.User{UILanguage: "de-DE"}, nil
|
||||
}
|
||||
func (s *practiceTestStore) CourseModule(context.Context, string, string, string, string) (domain.CourseModuleDetail, error) {
|
||||
return domain.CourseModuleDetail{Module: domain.CourseModule{ID: "a1_introductions_v1", TargetLanguage: "en-US", CEFRLevel: "A1"}}, nil
|
||||
}
|
||||
func (s *practiceTestStore) CoursePracticeByRequest(context.Context, string, string, string) (domain.CoursePracticeResult, error) {
|
||||
if s.existing {
|
||||
return domain.CoursePracticeResult{Task: domain.CourseTask{ID: "existing"}, Source: "flowise"}, nil
|
||||
}
|
||||
return domain.CoursePracticeResult{}, store.ErrNotFound
|
||||
}
|
||||
func (s *practiceTestStore) SelectCoursePractice(context.Context, string, string) (domain.CoursePracticeSelection, error) {
|
||||
if s.selectionError {
|
||||
return domain.CoursePracticeSelection{}, errors.New("database unavailable")
|
||||
}
|
||||
return domain.CoursePracticeSelection{Goal: domain.IntroductionGoals()[2], State: domain.CourseLearningState{RecentResults: []bool{}}, AvoidPrompts: []string{}}, nil
|
||||
}
|
||||
func (s *practiceTestStore) SaveGeneratedCourseTask(_ context.Context, user, request string, out domain.GeneratedCourseTask) (domain.CoursePracticeResult, error) {
|
||||
if user != "usr_1" || request != "request_123" {
|
||||
return domain.CoursePracticeResult{}, errors.New("incorrect ownership")
|
||||
}
|
||||
s.saved++
|
||||
if s.saveError {
|
||||
return domain.CoursePracticeResult{}, errors.New("save failed")
|
||||
}
|
||||
return domain.CoursePracticeResult{Task: domain.CourseTask{ID: "generated", Prompt: out.Prompt, Options: out.Options, Kind: out.Kind, Skill: out.Skill}, Source: "flowise"}, nil
|
||||
}
|
||||
func (s *practiceTestStore) CoursePracticeFallback(_ context.Context, user, seed string) (domain.CoursePracticeResult, error) {
|
||||
s.fallback++
|
||||
if user != "usr_1" || seed != "a1i_v1_grammar_1" {
|
||||
return domain.CoursePracticeResult{}, errors.New("wrong fallback")
|
||||
}
|
||||
return domain.CoursePracticeResult{Task: domain.CourseTask{ID: seed}, Source: "seed"}, nil
|
||||
}
|
||||
|
||||
type practiceGenerator struct {
|
||||
err error
|
||||
invalid bool
|
||||
calls int
|
||||
}
|
||||
|
||||
func (g *practiceGenerator) GenerateCourseTask(_ context.Context, in domain.GenerateCourseTaskRequest) (domain.GeneratedCourseTask, error) {
|
||||
g.calls++
|
||||
out := domain.GeneratedCourseTask{SchemaVersion: 1, TargetLanguage: in.TargetLanguage, CEFRLevel: in.CEFRLevel, ModuleID: in.ModuleID, LearningGoalID: in.LearningGoal.ID, Skill: in.Skill, Kind: "choice", Prompt: "Ergänze: I ___ from Germany.", Options: []string{"am", "is", "are"}, Solution: "am", Explanation: "Nach I steht am."}
|
||||
if g.invalid {
|
||||
out.Solution = "unknown"
|
||||
}
|
||||
return out, g.err
|
||||
}
|
||||
func TestNextCoursePracticeGenerationAndFallback(t *testing.T) {
|
||||
for _, test := range []struct {
|
||||
name string
|
||||
generator *practiceGenerator
|
||||
saveError, existing, dbError bool
|
||||
status int
|
||||
source string
|
||||
}{
|
||||
{name: "generated", generator: &practiceGenerator{}, status: 200, source: "flowise"},
|
||||
{name: "disabled", status: 200, source: "seed"},
|
||||
{name: "timeout", generator: &practiceGenerator{err: context.DeadlineExceeded}, status: 200, source: "seed"},
|
||||
{name: "invalid", generator: &practiceGenerator{invalid: true}, status: 200, source: "seed"},
|
||||
{name: "save failure", generator: &practiceGenerator{}, saveError: true, status: 200, source: "seed"},
|
||||
{name: "idempotent retry", generator: &practiceGenerator{}, existing: true, status: 200, source: "flowise"},
|
||||
{name: "database unavailable", generator: &practiceGenerator{}, dbError: true, status: 500},
|
||||
} {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
data := &practiceTestStore{courseTestStore: &courseTestStore{}, saveError: test.saveError, existing: test.existing, selectionError: test.dbError}
|
||||
server := &Server{store: data, logger: slog.New(slog.NewTextHandler(io.Discard, nil))}
|
||||
if test.generator != nil {
|
||||
server.courseGenerator = test.generator
|
||||
}
|
||||
w := httptest.NewRecorder()
|
||||
server.nextCoursePractice(w, courseRequest("POST", "/", `{"request_id":"request_123"}`))
|
||||
if w.Code != test.status {
|
||||
t.Fatalf("status %d: %s", w.Code, w.Body.String())
|
||||
}
|
||||
if test.status != 200 {
|
||||
return
|
||||
}
|
||||
var result domain.CoursePracticeResult
|
||||
if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if result.Source != test.source {
|
||||
t.Fatalf("source %s", result.Source)
|
||||
}
|
||||
if strings.Contains(w.Body.String(), "solution") || strings.Contains(w.Body.String(), "explanation") {
|
||||
t.Fatal("leaked key")
|
||||
}
|
||||
if test.existing && test.generator.calls != 0 {
|
||||
t.Fatal("regenerated idempotent request")
|
||||
}
|
||||
if test.generator != nil && test.generator.invalid && data.saved != 0 {
|
||||
t.Fatal("stored invalid task")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
func TestCoursePracticeRejectsClientSelectedGoals(t *testing.T) {
|
||||
server := &Server{}
|
||||
for _, body := range []string{`{}`, `{"request_id":"short"}`, `{"request_id":"request_123","skill":"grammar"}`, `{"request_id":"request_123"} {}`, strings.Repeat(" ", 1100)} {
|
||||
w := httptest.NewRecorder()
|
||||
server.nextCoursePractice(w, courseRequest(http.MethodPost, "/", body))
|
||||
if w.Code != 400 {
|
||||
t.Fatalf("status %d", w.Code)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"speech-learning-api/internal/domain"
|
||||
"speech-learning-api/internal/services"
|
||||
)
|
||||
|
||||
type courseTestStore struct {
|
||||
DataStore
|
||||
savedAnswer string
|
||||
savedUser string
|
||||
savedOK bool
|
||||
key domain.CourseTaskKey
|
||||
}
|
||||
|
||||
func (s *courseTestStore) GetPrimaryProfile(context.Context, string) (domain.LearnerProfile, error) {
|
||||
return domain.LearnerProfile{TargetLanguage: "en-US", CEFRLevel: "A1"}, nil
|
||||
}
|
||||
func (s *courseTestStore) CourseTaskKey(_ context.Context, _, _, _, _ string) (domain.CourseTaskKey, error) {
|
||||
return s.key, nil
|
||||
}
|
||||
func (s *courseTestStore) SaveCourseAttempt(_ context.Context, userID, _, answer string, correct bool) (string, error) {
|
||||
s.savedUser, s.savedAnswer, s.savedOK = userID, answer, correct
|
||||
return "cat_1", nil
|
||||
}
|
||||
func (s *courseTestStore) CourseModule(context.Context, string, string, string, string) (domain.CourseModuleDetail, error) {
|
||||
return domain.CourseModuleDetail{Module: domain.CourseModule{ID: "a1_introductions_v1"}, Tasks: []domain.CourseTask{{ID: "task_1", Kind: "choice", Prompt: "Who?", Options: []string{"Anna", "Ben"}}}}, nil
|
||||
}
|
||||
func (s *courseTestStore) GetLanguage(context.Context, string) (domain.LanguageProfile, error) {
|
||||
return domain.LanguageProfile{AzureLocale: "en-US", DefaultTTSVoice: "en-US-JennyNeural"}, nil
|
||||
}
|
||||
|
||||
type courseTestSpeech struct {
|
||||
services.SpeechService
|
||||
text string
|
||||
}
|
||||
|
||||
func (s *courseTestSpeech) Synthesize(_ context.Context, _, _, text string) ([]byte, string, error) {
|
||||
s.text = text
|
||||
return []byte("mp3"), "audio/mpeg", nil
|
||||
}
|
||||
|
||||
func courseRequest(method, path, body string) *http.Request {
|
||||
req := httptest.NewRequest(method, path, strings.NewReader(body))
|
||||
req.SetPathValue("id", "task_1")
|
||||
return req.WithContext(context.WithValue(req.Context(), userIDKey, "usr_1"))
|
||||
}
|
||||
|
||||
func TestCourseModuleDoesNotExposeAnswerOrListeningTranscript(t *testing.T) {
|
||||
s := &Server{store: &courseTestStore{}}
|
||||
w := httptest.NewRecorder()
|
||||
s.courseModule(w, courseRequest(http.MethodGet, "/course/modules/a1_introductions_v1", ""))
|
||||
if w.Code != http.StatusOK {
|
||||
t.Fatalf("status %d: %s", w.Code, w.Body.String())
|
||||
}
|
||||
if bytes.Contains(w.Body.Bytes(), []byte("accepted_answers")) || bytes.Contains(w.Body.Bytes(), []byte("solution")) || bytes.Contains(w.Body.Bytes(), []byte("audio_text")) {
|
||||
t.Fatalf("course detail leaked hidden answers: %s", w.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestCourseAttemptStoresBothWrongAndNormalizedCorrectAnswer(t *testing.T) {
|
||||
data := &courseTestStore{key: domain.CourseTaskKey{ID: "task_1", Kind: "short_text", AcceptedAnswers: []string{"My name is Anna"}, Solution: "My name is Anna.", Explanation: "A1 sentence"}}
|
||||
s := &Server{store: data}
|
||||
for _, test := range []struct {
|
||||
answer string
|
||||
correct bool
|
||||
}{{"Wrong", false}, {" MY NAME IS ANNA. ", true}} {
|
||||
w := httptest.NewRecorder()
|
||||
s.courseAttempt(w, courseRequest(http.MethodPost, "/course/tasks/task_1/attempts", `{"answer":`+jsonString(test.answer)+`}`))
|
||||
if w.Code != http.StatusCreated {
|
||||
t.Fatalf("status %d: %s", w.Code, w.Body.String())
|
||||
}
|
||||
if data.savedUser != "usr_1" || data.savedOK != test.correct {
|
||||
t.Fatalf("saved wrong result: %#v", data)
|
||||
}
|
||||
var result domain.CourseAttemptResult
|
||||
if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if result.Correct != test.correct || result.Solution == "" {
|
||||
t.Fatalf("wrong response: %#v", result)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func jsonString(value string) string { encoded, _ := json.Marshal(value); return string(encoded) }
|
||||
|
||||
func TestCourseAudioOnlyUsesListeningText(t *testing.T) {
|
||||
data := &courseTestStore{key: domain.CourseTaskKey{ID: "task_1", Kind: "choice", Skill: "listening", AudioText: "My name is Anna."}}
|
||||
speech := &courseTestSpeech{}
|
||||
s := &Server{store: data, speech: speech}
|
||||
w := httptest.NewRecorder()
|
||||
s.courseAudio(w, courseRequest(http.MethodGet, "/course/tasks/task_1/audio", ""))
|
||||
if w.Code != http.StatusOK || speech.text != "My name is Anna." || w.Header().Get("Content-Type") != "audio/mpeg" {
|
||||
t.Fatalf("unexpected audio result: %d %q", w.Code, speech.text)
|
||||
}
|
||||
data.key.Skill = "reading"
|
||||
w = httptest.NewRecorder()
|
||||
s.courseAudio(w, courseRequest(http.MethodGet, "/course/tasks/task_1/audio", ""))
|
||||
if w.Code != http.StatusNotFound {
|
||||
t.Fatalf("non-listening audio status %d", w.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestListeningTranscriptIsReturnedAfterSubmission(t *testing.T) {
|
||||
data := &courseTestStore{key: domain.CourseTaskKey{ID: "task_1", Kind: "choice", Skill: "listening", AudioText: "My name is Anna.", AcceptedAnswers: []string{"Anna"}, Solution: "Anna"}}
|
||||
s := &Server{store: data}
|
||||
w := httptest.NewRecorder()
|
||||
s.courseAttempt(w, courseRequest(http.MethodPost, "/course/tasks/task_1/attempts", `{"answer":"Ben"}`))
|
||||
if w.Code != http.StatusCreated {
|
||||
t.Fatalf("status %d: %s", w.Code, w.Body.String())
|
||||
}
|
||||
var result domain.CourseAttemptResult
|
||||
if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if result.Transcript != "My name is Anna." || result.Correct {
|
||||
t.Fatalf("unexpected feedback: %#v", result)
|
||||
}
|
||||
}
|
||||
@@ -5,7 +5,6 @@ import (
|
||||
"net/http"
|
||||
"os"
|
||||
"runtime"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
@@ -30,7 +29,8 @@ func (s *Server) debugStatus(w http.ResponseWriter, r *http.Request) {
|
||||
"checks": map[string]any{
|
||||
"db": s.store.DebugStatus(r.Context()),
|
||||
"azure": s.azureStatus(),
|
||||
"flowise": s.flowiseStatus(r.Context()),
|
||||
"ai": s.aiStatus(r.Context()),
|
||||
"flowise": s.aiStatus(r.Context()),
|
||||
},
|
||||
})
|
||||
}
|
||||
@@ -79,9 +79,9 @@ func (s *Server) debugConfig() map[string]any {
|
||||
"azure_mock": s.cfg.AzureMock,
|
||||
"azure_region": valueOr(s.cfg.AzureRegion, "not-set"),
|
||||
"azure_speech_key_set": s.cfg.AzureSpeechKey != "",
|
||||
"flowise_base_url": valueOr(s.cfg.FlowiseBaseURL, "not-set"),
|
||||
"flowise_chatflow_set": s.cfg.FlowiseChatflow != "",
|
||||
"flowise_api_key_set": s.cfg.FlowiseAPIKey != "",
|
||||
"ai_provider": "direct",
|
||||
"deepseek_api_key_set": s.cfg.DeepSeekAPIKey != "",
|
||||
"mistral_api_key_set": s.cfg.MistralAPIKey != "",
|
||||
"jwt_secret_configured": s.cfg.JWTSecret != "" && s.cfg.JWTSecret != "dev-secret-change-me",
|
||||
}
|
||||
}
|
||||
@@ -104,40 +104,33 @@ func (s *Server) azureStatus() debugCheck {
|
||||
}
|
||||
|
||||
func (s *Server) flowiseStatus(ctx context.Context) debugCheck {
|
||||
baseURL := strings.TrimRight(s.cfg.FlowiseBaseURL, "/")
|
||||
details := map[string]any{
|
||||
"base_url": valueOr(baseURL, "not-set"),
|
||||
"chatflow_set": s.cfg.FlowiseChatflow != "",
|
||||
"api_key_set": s.cfg.FlowiseAPIKey != "",
|
||||
return s.aiStatus(ctx)
|
||||
}
|
||||
func (s *Server) aiStatus(ctx context.Context) debugCheck {
|
||||
if s.ai == nil {
|
||||
return debugCheck{Status: "not_configured"}
|
||||
}
|
||||
if baseURL == "" {
|
||||
return debugCheck{OK: false, Status: "not_configured", Details: details}
|
||||
}
|
||||
|
||||
start := time.Now()
|
||||
checkCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
|
||||
defer cancel()
|
||||
|
||||
req, err := http.NewRequestWithContext(checkCtx, http.MethodGet, baseURL, nil)
|
||||
b, err := s.ai.Repo.Budget(ctx)
|
||||
if err != nil {
|
||||
return debugCheck{OK: false, Status: "invalid_url", Error: err.Error(), Details: details}
|
||||
return debugCheck{Status: "database_unavailable"}
|
||||
}
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
profiles, err := s.ai.Repo.Profiles(ctx)
|
||||
if err != nil {
|
||||
return debugCheck{OK: false, Status: "unreachable", Error: err.Error(), DurationMS: time.Since(start).Milliseconds(), Details: details}
|
||||
return debugCheck{Status: "database_unavailable"}
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
ok := resp.StatusCode < 500
|
||||
status := "reachable"
|
||||
if !ok {
|
||||
status = "server_error"
|
||||
active := 0
|
||||
for _, p := range profiles {
|
||||
if p.Enabled && s.ai.Configured(p.Provider) {
|
||||
active++
|
||||
}
|
||||
}
|
||||
return debugCheck{
|
||||
OK: ok,
|
||||
Status: status,
|
||||
HTTPStatus: resp.StatusCode,
|
||||
DurationMS: time.Since(start).Milliseconds(),
|
||||
Details: details,
|
||||
ok := active > 0 && b.MonthlyLimit > 0 && b.MonthCommitted < b.MonthlyLimit && (b.DailyLimit == 0 || b.DayCommitted < b.DailyLimit)
|
||||
status := "setup_required"
|
||||
if ok {
|
||||
status = "configured"
|
||||
}
|
||||
return debugCheck{OK: ok, Status: status, Details: map[string]any{"active_profiles": active, "deepseek_configured": s.ai.Configured("deepseek"), "mistral_configured": s.ai.Configured("mistral"), "budget": b}}
|
||||
}
|
||||
func (s *Server) debugAI(w http.ResponseWriter, r *http.Request) {
|
||||
writeJSON(w, 200, map[string]any{"request_id": requestID(r), "ai": s.aiStatus(r.Context())})
|
||||
}
|
||||
|
||||
@@ -84,7 +84,7 @@ func (s *Server) cors(next http.Handler) http.Handler {
|
||||
w.Header().Set("Vary", "Origin")
|
||||
w.Header().Set("Access-Control-Allow-Credentials", "true")
|
||||
w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type")
|
||||
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PATCH, DELETE, OPTIONS")
|
||||
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS")
|
||||
w.Header().Set("Access-Control-Expose-Headers", "X-Request-ID")
|
||||
}
|
||||
if r.Method == http.MethodOptions {
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"net/http"
|
||||
"speech-learning-api/internal/domain"
|
||||
"time"
|
||||
)
|
||||
|
||||
type pronunciationStore interface {
|
||||
PronunciationProfile(context.Context, string, string, time.Time) (domain.PronunciationProfile, error)
|
||||
PlanPronunciation(context.Context, string, string, time.Time) (domain.PronunciationPlan, error)
|
||||
FailPronunciationPlan(context.Context, string, string) error
|
||||
}
|
||||
|
||||
func (s *Server) pronunciationProfile(w http.ResponseWriter, r *http.Request) {
|
||||
repo, ok := s.store.(pronunciationStore)
|
||||
if !ok {
|
||||
writeError(w, 503, errors.New("Ausspracheprofil nicht verfügbar"))
|
||||
return
|
||||
}
|
||||
user := currentUserID(r)
|
||||
profile, err := s.store.GetPrimaryProfile(r.Context(), user)
|
||||
if err != nil {
|
||||
writeError(w, 404, err)
|
||||
return
|
||||
}
|
||||
result, err := repo.PronunciationProfile(r.Context(), user, profile.TargetLanguage, time.Now().UTC())
|
||||
if err != nil {
|
||||
writeError(w, 500, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, result)
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
"log/slog"
|
||||
"testing"
|
||||
|
||||
"speech-learning-api/internal/domain"
|
||||
"speech-learning-api/internal/services"
|
||||
)
|
||||
|
||||
type pronunciationHistoryStore struct {
|
||||
DataStore
|
||||
user, language, level string
|
||||
fallbackAvoid []string
|
||||
}
|
||||
|
||||
func (s *pronunciationHistoryStore) RecentPronunciationTexts(_ context.Context, user, language, level string) ([]string, error) {
|
||||
s.user, s.language, s.level = user, language, level
|
||||
return []string{"Saved after reload."}, nil
|
||||
}
|
||||
func (s *pronunciationHistoryStore) NextLessonAndExercise(_ context.Context, _ domain.LearnerProfile, avoid ...string) (domain.Lesson, domain.Exercise, error) {
|
||||
s.fallbackAvoid = avoid
|
||||
return domain.Lesson{}, domain.Exercise{Source: "seed"}, nil
|
||||
}
|
||||
|
||||
type pronunciationHistoryTeacher struct {
|
||||
services.TeacherAgent
|
||||
request domain.GeneratedExerciseRequest
|
||||
}
|
||||
|
||||
func (t *pronunciationHistoryTeacher) NextExercise(_ context.Context, request domain.GeneratedExerciseRequest) (domain.GeneratedExercise, error) {
|
||||
t.request = request
|
||||
return domain.GeneratedExercise{}, nil
|
||||
}
|
||||
func TestPronunciationLoadsHistoryWithoutClientIDs(t *testing.T) {
|
||||
for _, client := range [][]string{nil, {"From browser."}} {
|
||||
repo, teacher := &pronunciationHistoryStore{}, &pronunciationHistoryTeacher{}
|
||||
s := &Server{store: repo, teacher: teacher, logger: slog.New(slog.NewTextHandler(io.Discard, nil))}
|
||||
_, _, err := s.nextAgentExercise(context.Background(), domain.User{ID: "learner"}, domain.LearnerProfile{TargetLanguage: "en-US", CEFRLevel: "A1"}, domain.ProgressSummary{}, client)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if repo.user != "learner" || repo.language != "en-US" || repo.level != "A1" {
|
||||
t.Fatal("wrong history scope")
|
||||
}
|
||||
avoid := teacher.request.AvoidReferenceTexts
|
||||
if len(avoid) != len(client)+1 || avoid[len(avoid)-1] != "Saved after reload." {
|
||||
t.Fatalf("history not passed to generator: %v", avoid)
|
||||
}
|
||||
if len(repo.fallbackAvoid) != len(client) {
|
||||
t.Fatal("history exhausted fixed fallback")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -25,6 +25,7 @@ type DataStore interface {
|
||||
NextLessonAndExercise(ctx context.Context, profile domain.LearnerProfile, avoidReferenceText ...string) (domain.Lesson, domain.Exercise, error)
|
||||
SaveGeneratedExercise(ctx context.Context, userID string, generated domain.GeneratedExercise) (domain.Lesson, domain.Exercise, error)
|
||||
GetExercise(ctx context.Context, id, userID string) (domain.Exercise, error)
|
||||
RecentPronunciationTexts(ctx context.Context, userID, language, level string) ([]string, error)
|
||||
SaveAttempt(ctx context.Context, attempt domain.Attempt) (domain.Attempt, error)
|
||||
Progress(ctx context.Context, userID string, limit int) (domain.ProgressSummary, error)
|
||||
AdminOverview(ctx context.Context) (domain.AdminOverview, error)
|
||||
@@ -32,20 +33,33 @@ type DataStore interface {
|
||||
CreateConversationSession(ctx context.Context, userID, targetLanguage, cefrLevel string) (domain.ConversationSession, error)
|
||||
SaveConversationTurn(ctx context.Context, turn domain.ConversationTurn) (domain.ConversationTurn, error)
|
||||
DebugStatus(ctx context.Context) domain.DebugDBStatus
|
||||
CourseModules(ctx context.Context, userID, language, level string) ([]domain.CourseModule, error)
|
||||
CourseModule(ctx context.Context, userID, language, level, id string) (domain.CourseModuleDetail, error)
|
||||
CourseTaskKey(ctx context.Context, taskID, userID, language, level string) (domain.CourseTaskKey, error)
|
||||
SaveCourseAttempt(ctx context.Context, userID, taskID, answer string, correct bool) (string, error)
|
||||
SelectCoursePractice(ctx context.Context, userID, moduleID string) (domain.CoursePracticeSelection, error)
|
||||
CoursePractice(ctx context.Context, userID, moduleID string) ([]domain.CourseTask, error)
|
||||
CoursePracticeByRequest(ctx context.Context, userID, moduleID, requestID string) (domain.CoursePracticeResult, error)
|
||||
CoursePracticeFallback(ctx context.Context, userID, seedID string) (domain.CoursePracticeResult, error)
|
||||
SaveGeneratedCourseTask(ctx context.Context, userID, requestID string, out domain.GeneratedCourseTask) (domain.CoursePracticeResult, error)
|
||||
}
|
||||
|
||||
type Server struct {
|
||||
cfg config.Config
|
||||
logger *slog.Logger
|
||||
store DataStore
|
||||
auth *services.AuthService
|
||||
speech services.SpeechService
|
||||
teacher services.TeacherAgent
|
||||
started time.Time
|
||||
ai *services.AIService
|
||||
course *services.CourseEngine
|
||||
cfg config.Config
|
||||
logger *slog.Logger
|
||||
store DataStore
|
||||
auth *services.AuthService
|
||||
speech services.SpeechService
|
||||
teacher services.TeacherAgent
|
||||
courseGenerator services.CourseTaskGenerator
|
||||
started time.Time
|
||||
}
|
||||
|
||||
func NewServer(cfg config.Config, logger *slog.Logger, store DataStore, auth *services.AuthService, speech services.SpeechService, teacher services.TeacherAgent) *Server {
|
||||
return &Server{cfg: cfg, logger: logger, store: store, auth: auth, speech: speech, teacher: teacher, started: time.Now()}
|
||||
generator, _ := teacher.(services.CourseTaskGenerator)
|
||||
return &Server{courseGenerator: generator, cfg: cfg, logger: logger, store: store, auth: auth, speech: speech, teacher: teacher, started: time.Now()}
|
||||
}
|
||||
|
||||
func (s *Server) Routes() http.Handler {
|
||||
@@ -60,17 +74,45 @@ func (s *Server) Routes() http.Handler {
|
||||
mux.Handle("GET /languages", s.requireAuth(http.HandlerFunc(s.languages)))
|
||||
mux.Handle("GET /languages/{code}/voices", s.requireAuth(http.HandlerFunc(s.languageVoices)))
|
||||
mux.Handle("GET /dashboard", s.requireAuth(http.HandlerFunc(s.dashboard)))
|
||||
mux.Handle("GET /pronunciation/profile", s.requireAuth(http.HandlerFunc(s.pronunciationProfile)))
|
||||
mux.Handle("GET /progress", s.requireAuth(http.HandlerFunc(s.progress)))
|
||||
mux.Handle("POST /lessons/next", s.requireAuth(http.HandlerFunc(s.nextLesson)))
|
||||
mux.Handle("GET /practice/exercises/{id}/audio", s.requireAuth(http.HandlerFunc(s.exerciseAudio)))
|
||||
mux.Handle("POST /practice/attempts", s.requireAuth(http.HandlerFunc(s.createAttempt)))
|
||||
mux.Handle("GET /course/catalog", s.requireAuth(http.HandlerFunc(s.adaptiveCatalog)))
|
||||
mux.Handle("POST /course/modules/{id}/tasks/next", s.requireAuth(http.HandlerFunc(s.adaptiveNext)))
|
||||
mux.Handle("GET /course/modules/{id}/tasks", s.requireAuth(http.HandlerFunc(s.adaptiveHistory)))
|
||||
mux.Handle("GET /course/jobs/{id}", s.requireAuth(http.HandlerFunc(s.adaptiveJob)))
|
||||
mux.Handle("POST /course/jobs/{id}/retry", s.requireAuth(http.HandlerFunc(s.adaptiveRetryJob)))
|
||||
mux.Handle("GET /course/tasks/{id}", s.requireAuth(http.HandlerFunc(s.adaptiveTask)))
|
||||
mux.Handle("POST /course/tasks/{id}/audio-attempts", s.requireAuth(http.HandlerFunc(s.adaptiveAudioAttempt)))
|
||||
mux.Handle("GET /course/attempts/{id}", s.requireAuth(http.HandlerFunc(s.adaptiveGetAttempt)))
|
||||
mux.Handle("POST /course/attempts/{id}/retry", s.requireAuth(http.HandlerFunc(s.adaptiveRetryAttempt)))
|
||||
mux.Handle("POST /course/exams", s.requireAuth(http.HandlerFunc(s.adaptiveNewExam)))
|
||||
mux.Handle("GET /course/exams/{id}", s.requireAuth(http.HandlerFunc(s.adaptiveExam)))
|
||||
mux.Handle("GET /course/modules", s.requireAuth(http.HandlerFunc(s.courseModules)))
|
||||
mux.Handle("POST /course/modules/{id}/practice/next", s.requireAuth(http.HandlerFunc(s.nextCoursePractice)))
|
||||
mux.Handle("GET /course/modules/{id}/practice", s.requireAuth(http.HandlerFunc(s.coursePractice)))
|
||||
mux.Handle("GET /course/modules/{id}", s.requireAuth(http.HandlerFunc(s.courseModule)))
|
||||
mux.Handle("POST /course/tasks/{id}/attempts", s.requireAuth(http.HandlerFunc(s.courseAttempt)))
|
||||
mux.Handle("GET /course/tasks/{id}/audio", s.requireAuth(http.HandlerFunc(s.courseAudio)))
|
||||
mux.Handle("POST /conversation/start", s.requireAuth(http.HandlerFunc(s.startConversation)))
|
||||
mux.Handle("POST /conversation/{id}/turn", s.requireAuth(http.HandlerFunc(s.conversationTurn)))
|
||||
mux.Handle("GET /admin/overview", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.adminOverview))))
|
||||
mux.Handle("GET /admin/users", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.adminUsers))))
|
||||
mux.Handle("GET /admin/ai/settings", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiSettings))))
|
||||
mux.Handle("PUT /admin/ai/profiles/{action}", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiSaveProfile))))
|
||||
mux.Handle("PUT /admin/ai/budget", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiSaveBudget))))
|
||||
mux.Handle("GET /admin/ai/providers/{provider}/models", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiModels))))
|
||||
mux.Handle("GET /admin/ai/usage", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiUsage))))
|
||||
mux.Handle("GET /admin/ai/calls/{id}", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiCallDetail))))
|
||||
mux.Handle("POST /admin/ai/calls/{id}/resolve", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiResolve))))
|
||||
mux.Handle("POST /admin/ai/quality", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiQuality))))
|
||||
mux.Handle("POST /admin/ai/test", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiTest))))
|
||||
if s.cfg.DebugEnabled {
|
||||
mux.Handle("GET /debug/status", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugStatus))))
|
||||
mux.Handle("GET /debug/db", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugDB))))
|
||||
mux.Handle("GET /debug/ai", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugAI))))
|
||||
mux.Handle("GET /debug/flowise", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugFlowise))))
|
||||
mux.Handle("GET /debug/azure", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugAzure))))
|
||||
mux.Handle("GET /debug/runtime", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugRuntime))))
|
||||
@@ -266,11 +308,32 @@ func (s *Server) nextLesson(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
|
||||
func (s *Server) nextAgentExercise(ctx context.Context, user domain.User, profile domain.LearnerProfile, progress domain.ProgressSummary, avoidReferenceTexts []string) (domain.Lesson, domain.Exercise, error) {
|
||||
// Keep fallback exercises available even when the learner has already used
|
||||
// every seed. The broader persisted history constrains generated sentences.
|
||||
fallbackAvoid := append([]string{}, avoidReferenceTexts...)
|
||||
recent, err := s.store.RecentPronunciationTexts(ctx, user.ID, profile.TargetLanguage, profile.CEFRLevel)
|
||||
if err != nil {
|
||||
return domain.Lesson{}, domain.Exercise{}, err
|
||||
}
|
||||
avoidReferenceTexts = append(append([]string{}, avoidReferenceTexts...), recent...)
|
||||
avoidReferenceText := ""
|
||||
if len(avoidReferenceTexts) > 0 {
|
||||
avoidReferenceText = avoidReferenceTexts[len(avoidReferenceTexts)-1]
|
||||
}
|
||||
var plan *domain.PronunciationPlan
|
||||
if s.cfg.PronunciationStrategy == "statistical" {
|
||||
repo, ok := s.store.(pronunciationStore)
|
||||
if !ok {
|
||||
return domain.Lesson{}, domain.Exercise{}, errors.New("pronunciation statistics unavailable")
|
||||
}
|
||||
selected, err := repo.PlanPronunciation(ctx, user.ID, profile.TargetLanguage, time.Now().UTC())
|
||||
if err != nil {
|
||||
return domain.Lesson{}, domain.Exercise{}, err
|
||||
}
|
||||
plan = &selected
|
||||
}
|
||||
generated, err := s.teacher.NextExercise(ctx, domain.GeneratedExerciseRequest{
|
||||
TrainingPlan: plan,
|
||||
UserID: user.ID,
|
||||
Profile: profile,
|
||||
Progress: progress,
|
||||
@@ -283,7 +346,11 @@ func (s *Server) nextAgentExercise(ctx context.Context, user domain.User, profil
|
||||
AvoidReferenceText: avoidReferenceText,
|
||||
AvoidReferenceTexts: avoidReferenceTexts,
|
||||
})
|
||||
if err == nil && generated.Source == "flowise" && strings.TrimSpace(generated.ReferenceText) != "" {
|
||||
if err == nil && (generated.Source == "flowise" || generated.Source == "ai") && strings.TrimSpace(generated.ReferenceText) != "" {
|
||||
generated.TrainingPlan = plan
|
||||
if plan != nil && plan.Mode == "transfer" {
|
||||
plan.CandidateWord = generated.CandidateWord
|
||||
}
|
||||
lesson, exercise, saveErr := s.store.SaveGeneratedExercise(ctx, user.ID, generated)
|
||||
if saveErr == nil {
|
||||
s.logger.Info("next exercise selected", "request_id", ctx.Value(requestIDKey), "source", exercise.Source, "exercise_id", exercise.ID)
|
||||
@@ -292,9 +359,16 @@ func (s *Server) nextAgentExercise(ctx context.Context, user domain.User, profil
|
||||
s.logger.Warn("saving generated exercise failed, using seed fallback", "error", saveErr)
|
||||
}
|
||||
if err != nil {
|
||||
s.logger.Warn("flowise next exercise failed, using seed fallback", "error", err)
|
||||
s.logger.Warn("AI next exercise failed, using seed fallback", "error", err)
|
||||
}
|
||||
lesson, exercise, err := s.store.NextLessonAndExercise(ctx, profile, avoidReferenceTexts...)
|
||||
if plan != nil {
|
||||
if repo, ok := s.store.(pronunciationStore); ok {
|
||||
if planErr := repo.FailPronunciationPlan(ctx, user.ID, plan.ID); planErr != nil {
|
||||
s.logger.Warn("pronunciation plan cleanup failed", "error", planErr)
|
||||
}
|
||||
}
|
||||
}
|
||||
lesson, exercise, err := s.store.NextLessonAndExercise(ctx, profile, fallbackAvoid...)
|
||||
if err == nil {
|
||||
s.logger.Info("next exercise selected", "request_id", ctx.Value(requestIDKey), "source", exercise.Source, "exercise_id", exercise.ID)
|
||||
}
|
||||
@@ -400,7 +474,8 @@ func (s *Server) createAttempt(w http.ResponseWriter, r *http.Request) {
|
||||
return
|
||||
}
|
||||
attempt, err := s.store.SaveAttempt(r.Context(), domain.Attempt{
|
||||
UserID: currentUserID(r),
|
||||
UserID: currentUserID(r),
|
||||
Provider: result.Provider, Measurement: &result,
|
||||
ExerciseID: exercise.ID,
|
||||
TargetLanguage: exercise.TargetLanguage,
|
||||
RecognizedText: result.RecognizedText,
|
||||
@@ -416,6 +491,11 @@ func (s *Server) createAttempt(w http.ResponseWriter, r *http.Request) {
|
||||
writeError(w, http.StatusInternalServerError, err)
|
||||
return
|
||||
}
|
||||
if s.course != nil {
|
||||
if err := s.course.Repo.SyncLegacyForExercise(r.Context(), exercise.ID); err != nil {
|
||||
s.logger.Warn("legacy speech evidence sync failed", "error", err)
|
||||
}
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, map[string]any{"attempt": attempt, "teacher": teacher, "provider": result.Provider})
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user