📚 Educational Platform

@RestController
@RequestMapping("/api/courses")
@Validated
public class CourseController {
    
    private final CourseService courseService;
    private final ProgressService progressService;
    private final AnalyticsService analyticsService;
    
    public CourseController(CourseService courseService, 
                           ProgressService progressService,
                           AnalyticsService analyticsService) {
        this.courseService = courseService;
        this.progressService = progressService;
        this.analyticsService = analyticsService;
    }
    
    @GetMapping
    @PreAuthorize("hasRole('STUDENT') or hasRole('INSTRUCTOR')")
    public ResponseEntity<Page<CourseDto>> getCourses(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size,
            @RequestParam(required = false) String search,
            @RequestParam(required = false) String category,
            Authentication authentication) {
        
        Pageable pageable = PageRequest.of(page, size);
        Page<CourseDto> courses = courseService.findCourses(
            search, category, pageable, authentication.getName());
        
        return ResponseEntity.ok(courses);
    }
    
    @PostMapping("/{courseId}/enroll")
    @PreAuthorize("hasRole('STUDENT')")
    @Transactional
    public ResponseEntity<EnrollmentDto> enrollInCourse(
            @PathVariable Long courseId,
            Authentication authentication) {
        
        String studentId = authentication.getName();
        
        // Check prerequisites
        if (!courseService.checkPrerequisites(courseId, studentId)) {
            throw new PrerequisiteNotMetException("Prerequisites not satisfied");
        }
        
        // Create enrollment
        EnrollmentDto enrollment = courseService.enrollStudent(courseId, studentId);
        
        // Track analytics event
        analyticsService.trackEvent(AnalyticsEvent.builder()
            .eventType("COURSE_ENROLLMENT")
            .userId(studentId)
            .courseId(courseId)
            .timestamp(Instant.now())
            .build());
        
        // Send welcome notification
        notificationService.sendWelcomeNotification(enrollment);
        
        return ResponseEntity.ok(enrollment);
    }
}

@Service
@Transactional
public class CourseService {
    
    private final CourseRepository courseRepository;
    private final RedisTemplate<String, Object> redisTemplate;
    private final KafkaTemplate<String, Object> kafkaTemplate;
    
    @Cacheable(value = "courses", key = "#courseId")
    public CourseDto findById(Long courseId) {
        Course course = courseRepository.findById(courseId)
            .orElseThrow(() -> new CourseNotFoundException(courseId));
        
        return CourseMapper.toDto(course);
    }
    
    @CacheEvict(value = "courses", key = "#courseId")
    public CourseDto updateCourse(Long courseId, UpdateCourseRequest request) {
        Course course = courseRepository.findById(courseId)
            .orElseThrow(() -> new CourseNotFoundException(courseId));
        
        course.updateFromRequest(request);
        Course saved = courseRepository.save(course);
        
        // Publish course updated event
        kafkaTemplate.send("course-events", CourseUpdatedEvent.builder()
            .courseId(courseId)
            .timestamp(Instant.now())
            .changes(request.getChangedFields())
            .build());
        
        return CourseMapper.toDto(saved);
    }
}

@Component
@KafkaListener(topics = "learning-events")
public class LearningEventProcessor {
    
    private final ProgressService progressService;
    private final AnalyticsService analyticsService;
    private final RecommendationService recommendationService;
    
    @KafkaListener(topics = "learning-events", 
                   groupId = "progress-group")
    public void processLearningEvent(LearningEvent event) {
        try {
            switch (event.getEventType()) {
                case LESSON_COMPLETED:
                    handleLessonCompletion(event);
                    break;
                case QUIZ_SUBMITTED:
                    handleQuizSubmission(event);
                    break;
                case COURSE_COMPLETED:
                    handleCourseCompletion(event);
                    break;
            }
        } catch (Exception e) {
            log.error("Error processing learning event: {}", event, e);
            // Send to dead letter queue for retry
            kafkaTemplate.send("learning-events-dlq", event);
        }
    }
    
    private void handleLessonCompletion(LearningEvent event) {
        // Update progress
        progressService.updateLessonProgress(
            event.getUserId(), 
            event.getLessonId(), 
            ProgressStatus.COMPLETED);
        
        // Calculate course progress
        double courseProgress = progressService.calculateCourseProgress(
            event.getUserId(), event.getCourseId());
        
        // Update analytics
        analyticsService.recordLearningMetrics(LearningMetrics.builder()
            .userId(event.getUserId())
            .courseId(event.getCourseId())
            .lessonId(event.getLessonId())
            .timeSpent(event.getTimeSpent())
            .completionTimestamp(event.getTimestamp())
            .progress(courseProgress)
            .build());
        
        // Generate recommendations
        List<CourseRecommendation> recommendations = 
            recommendationService.generateRecommendations(
                event.getUserId(), event.getCourseId());
        
        // Send progress notification
        notificationService.sendProgressNotification(
            event.getUserId(), courseProgress);
    }
}