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