Merge pull request #69 from AET-DevOps25/68-genai-enhance-course-generation-api-confirmation-chat-and-crawling

Features

* Background Scheduler

  * Crawls and embeds FreeCodeCamp blog articles every 12 hours
  * Uses cache to skip already embedded URLs
  * Provides REST endpoints to trigger and control the scheduler

* GenAI Course Generation Enhancements

  * Improved system prompt for more structured courses
  * Auto-detects content types (VIDEO, TEXT, HTML) in generated lessons

* API & Model Updates

  * Adds Pydantic models for scheduler control and status
  * Updates OpenAPI tags and documentation accordingly

Commit Summary

* feat(scheduler): implement blog embedder with async scheduling and cache
* feat(course-gen): improve GenAI prompts and content inference
* feat(api): add endpoints for scheduler control and manual execution
* chore: expose scheduler utils and update OpenAPI tags
* docs: document scheduler usage and configuration

Author: mahdibayouli

server/skillforge-course/src/main/java/com/gitittogether/skillForge/server/course/controller/courses/CourseController.java

@@ -12,13 +12,6 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.client.RestTemplate;
-import org.springframework.http.HttpHeaders;
-import com.fasterxml.jackson.core.type.TypeReference;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.springframework.http.HttpEntity;
-import org.springframework.http.HttpMethod;
 import jakarta.servlet.http.HttpServletRequest;
 import org.springframework.web.bind.annotation.*;
 
@@ -31,10 +24,9 @@
 public class CourseController {
 
     private final CourseService courseService;
-private final RestTemplate restTemplate = new RestTemplate();
 
-@Value("${user.service.uri:http://user-service:8082}")
-private String userServiceUri;
+    @Value("${user.service.uri:http://user-service:8082}")
+    private String userServiceUri;
 
     @PostMapping
     public ResponseEntity<CourseResponse> createCourse(@RequestBody CourseRequest request) {
@@ -65,9 +57,9 @@ public ResponseEntity<List<CourseSummaryResponse>> getPublicCourses() {
     }
 
     @GetMapping("/public/published")
-    public ResponseEntity<List<CourseResponse>> getPublicPublishedCourses() {
+    public ResponseEntity<List<CourseSummaryResponse>> getPublishedCourses() {
         log.info("Fetching public and published courses for landing page");
-        List<CourseResponse> responses = courseService.getPublicPublishedCourses();
+        List<CourseSummaryResponse> responses = courseService.getPublishedCourses();
         return ResponseEntity.ok(responses);
     }
 
@@ -129,18 +121,23 @@ public ResponseEntity<Void> unbookmarkCourse(@PathVariable String courseId, @Pat
 
     @GetMapping("/search")
     public ResponseEntity<List<CourseResponse>> searchCourses(
-            @RequestParam(required = false) String instructor,
-            @RequestParam(required = false) Level level,
-            @RequestParam(required = false) Language language,
-            @RequestParam(required = false) String skill,
-            @RequestParam(required = false) String category,
-            @RequestParam(required = false) String title
+           @RequestParam(required = false) String instructor,
+           @RequestParam(required = false) Level level,
+           @RequestParam(required = false) Language language,
+           @RequestParam(required = false) String skill,
+           @RequestParam(required = false) String category,
+           @RequestParam(required = false) String title,
+           @RequestParam(required = false) boolean isPublished,
+           @RequestParam(required = false) boolean isPublic
     ) {
-        log.info("Advanced search: instructor={}, level={}, language={}, skill={}, category={}, title={}", instructor, level, language, skill, category, title);
-        List<CourseResponse> responses = courseService.advancedSearch(instructor, level, language, skill, category, title);
-        return ResponseEntity.ok(responses);
-    }
-
+       log.info("Advanced search: instructor={}, level={}, language={}, skill={}, category={}, title={}, isPublished={}, isPublic={}",
+               instructor, level, language, skill, category, title, isPublished, isPublic);
+       List<CourseResponse> responses = courseService.advancedSearch(instructor, level, language, skill, category, title, isPublished, isPublic);
+       return ResponseEntity.ok(responses);
+    }
+    
+    
+    
     @GetMapping("/search/instructor/{instructor}")
     public ResponseEntity<List<CourseResponse>> getCoursesByInstructor(@PathVariable String instructor) {
         log.info("Fetching courses by instructor: {}", instructor);
@@ -184,54 +181,32 @@ public ResponseEntity<List<CourseResponse>> searchCoursesByTitle(@PathVariable S
     }
 
     /**
-     * Generates a brand-new course via GenAI + RAG, then persists & returns it.
-     * Chosen as POST because we are **creating** a new server-side resource
-     * (the course) – even though the body only contains “input” data.
-     */
-    /*
-     * New variant that accepts userId in path.
-     * Example: POST /api/v1/courses/generate/learning_path/{userId}
-     */
+    * Generates a brand-new course via GenAI + RAG, then persists & returns it.
+    * Chosen as POST because we are **creating** a new server-side resource
+    */
     @PostMapping("/generate/learning_path/{userId}")
-    public ResponseEntity<CourseResponse> generateCourseForUser(@PathVariable String userId,
-                                                                @RequestBody LearningPathRequest req,
-                                                                HttpServletRequest servletRequest) {
-        
-
-        // Fetch user profile from user-service just for logging/demo
-        try {
-            String profileUrl = userServiceUri + "/api/v1/users/" + userId + "/profile";
-            String authHeader = servletRequest.getHeader("Authorization");
-            HttpHeaders headers = new HttpHeaders();
-            if (authHeader != null && !authHeader.isBlank()) {
-                headers.set("Authorization", authHeader);
-            }
-            HttpEntity<Void> entity = new HttpEntity<>(headers);
-            String profileJson = restTemplate.exchange(profileUrl, HttpMethod.GET, entity, String.class).getBody();
-            log.info("User profile fetched via user-service: {}", profileJson);
-            // extract skills field from JSON
-            List<String> extractedSkills = null;
-            try {
-                ObjectMapper mapper = new ObjectMapper();
-                JsonNode root = mapper.readTree(profileJson);
-                JsonNode skillsNode = root.get("skills");
-                if (skillsNode != null && skillsNode.isArray()) {
-                    extractedSkills = mapper.convertValue(skillsNode, new TypeReference<List<String>>() {});
-                }
-            } catch (Exception parseEx) {
-                log.warn("Could not parse skills from user profile: {}", parseEx.getMessage());
-            }
-            log.info("Generating course for user={} prompt='{}' skills={}", userId, req.prompt(), extractedSkills);
-            req = new LearningPathRequest(req.prompt(), extractedSkills);
-
-        } catch (Exception ex) {
-            log.warn("Failed to fetch user profile for {}: {}", userId, ex.getMessage());
-        }
-
-        // create the course after we logged the profile
-        CourseResponse generated = courseService.generateFromGenAi(req);
-        CourseResponse enrolled = courseService.enrollUserInCourse(generated.getId(), userId);
-        return ResponseEntity.ok(enrolled);
+    public ResponseEntity<CourseRequest> generateCourseForUser(@PathVariable String userId, @RequestBody LearningPathRequest req, HttpServletRequest servletRequest) {
+    log.info("Generating course for user: {}", userId);
+    CourseRequest generated = courseService.generateCourseFromGenAi(req, userId, servletRequest.getHeader("Authorization"));
+    return ResponseEntity.ok(generated);
     }
 
+
+    /**
+    * Confirms the generation of a course from a Learning Path request.
+    * This method is called after the course has been generated and the user has reviewed it.
+    * It retrieves the last generated course details, creates the course in the database, enrolls the user, and returns the course response.
+    *
+    * @param userId The ID of the user confirming the course generation.
+    * @return CourseResponse containing the confirmed course details.
+    */
+    @PostMapping("/generate/learning_path/{userId}/confirm")
+    public ResponseEntity<CourseResponse> confirmGeneratedCourse(@PathVariable String userId) {
+    log.info("Confirming course generation for user: {}", userId);
+    CourseResponse confirmed = courseService.confirmCourseGeneration(userId);
+    return ResponseEntity.ok(confirmed);
+    }
+
+
+
 } 

server/skillforge-course/src/main/java/com/gitittogether/skillForge/server/course/dto/response/utils/EmbedResult.java

@@ -0,0 +1,21 @@
+package com.gitittogether.skillForge.server.course.dto.response.utils;
+
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Builder
+public class EmbedResult {
+   private boolean success;
+   private String url;
+   private Integer chunksEmbedded;
+   private String message;
+   private String error;
+}
+

server/skillforge-course/src/main/java/com/gitittogether/skillForge/server/course/dto/response/utils/PromptResponse.java

@@ -0,0 +1,26 @@
+
+
+
+
+package com.gitittogether.skillForge.server.course.dto.response.utils;
+
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class PromptResponse {
+   private String prompt;
+   private String generated_text;
+   private String provider;
+
+
+}
+
+