feat : implement recommendation system with user skill analysis

Author: Rajat069

src/main/java/com/rajat_singh/leetcode_api/controller/RecommendationController.java

@@ -0,0 +1,34 @@
+package com.rajat_singh.leetcode_api.controller;
+
+import com.rajat_singh.leetcode_api.dto.RecommendationResponse;
+import com.rajat_singh.leetcode_api.dto.RecommendedQuestionDTO;
+import com.rajat_singh.leetcode_api.service.RecommendationService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController()
+@RequestMapping("/api/v1/recommendation")
+@RequiredArgsConstructor
+public class RecommendationController {
+
+    @Autowired
+    private final RecommendationService recommendationService;
+
+    @GetMapping("/{username}")
+    public ResponseEntity<RecommendationResponse> getAiPoweredRecommendations(@PathVariable String username){
+        RecommendationResponse response;
+        try{
+            response = recommendationService.getRecommendations(username);
+            return ResponseEntity.ok(response);
+        }
+        catch (Exception e){
+            return ResponseEntity.badRequest().build();
+        }
+    }
+
+}

src/main/java/com/rajat_singh/leetcode_api/controller/UserController.java

@@ -48,7 +48,7 @@ public ResponseEntity<UserSkillStatsResponse.MatchedUser> getUserSkillStats(@Pat
         Logger.info("getUserSkillStats() method called with username :: {}", username);
         return leetCodeService.getUserSkillStats(username)
                 .map(ResponseEntity::ok).orElse(ResponseEntity.notFound().build());
-    };
+    }
 
     @GetMapping("/recentUserSubmissions/{limit}")
     public ResponseEntity<UserRecentSubmissionsResponse.DataNode> getUserRecentSubmissions(@PathVariable String username,@PathVariable int limit) {

src/main/java/com/rajat_singh/leetcode_api/dto/RecommendationResponse.java

@@ -0,0 +1,18 @@
+package com.rajat_singh.leetcode_api.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Builder;
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+@Data
+@Builder
+public class RecommendationResponse {
+    @JsonProperty("weak-topics")
+    private Map<String, WeakTopicDTO> weakTopics;
+    
+    @JsonProperty("recommended-questions")
+    private List<RecommendedQuestionDTO> recommendedQuestions;
+}

src/main/java/com/rajat_singh/leetcode_api/dto/RecommendedQuestionDTO.java

@@ -0,0 +1,20 @@
+package com.rajat_singh.leetcode_api.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Builder;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+@Builder
+public class RecommendedQuestionDTO {
+    private String name;
+    
+    @JsonProperty("acceptance-rate")
+    private String acceptanceRate;
+    
+    private List<String> tags;
+    
+    private String link;
+}

src/main/java/com/rajat_singh/leetcode_api/dto/UserTagStatDTO.java

@@ -0,0 +1,13 @@
+package com.rajat_singh.leetcode_api.dto;
+
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class UserTagStatDTO {
+    private String tagName;
+    private int solved;
+    private long totalAvailable;
+    private double completionPercentage;
+}

src/main/java/com/rajat_singh/leetcode_api/dto/WeakTopicDTO.java

@@ -0,0 +1,18 @@
+package com.rajat_singh.leetcode_api.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class WeakTopicDTO {
+    @JsonProperty("completion-percentage")
+    private String completionPercentage;
+    
+    @JsonProperty("completed-questions")
+    private int completedQuestions;
+    
+    @JsonProperty("total-questions")
+    private long totalQuestions;
+}

src/main/java/com/rajat_singh/leetcode_api/repository/QuestionsRepository.java

@@ -4,15 +4,33 @@
 import jakarta.transaction.Transactional;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+import org.springframework.data.jpa.repository.Query;
 import org.springframework.stereotype.Repository;
 
+import java.util.List;
+
 
 @Repository
 public interface QuestionsRepository extends JpaRepository<QuestionEntity,Integer>, JpaSpecificationExecutor<QuestionEntity> {
 
     QuestionEntity findByTitleSlug(String title);
     QuestionEntity findByIsProblemOfTheDayTrue();
 
+    @Query("SELECT t.name as tagName, COUNT(q) as totalCount " +
+            "FROM QuestionEntity q JOIN q.topicTags t " +
+            "GROUP BY t.name")
+    List<TagCountProjection> countProblemsByTag();
+    @Query("SELECT DISTINCT q FROM QuestionEntity q JOIN q.topicTags t " +
+            "WHERE t.name IN :targetTags AND q.difficulty = 'MEDIUM' " +
+            "ORDER BY q.acRate DESC LIMIT 50")
+    List<QuestionEntity> findCandidateQuestions(List<String> targetTags);
+
+    @Query(value = "SELECT DISTINCT q.* FROM leetcode_questions q " +
+            "JOIN question_topic_tags t ON q.id = t.question_id " +
+            "WHERE t.name IN :tags AND q.difficulty IN :difficulties " +
+            "ORDER BY RANDOM() LIMIT :limit", nativeQuery = true)
+    List<QuestionEntity> findRandomQuestionsByTagsAndDifficulty(List<String> tags, List<String> difficulties, int limit);
     @Transactional
     void deleteByIsProblemOfTheDayTrue();
 }

src/main/java/com/rajat_singh/leetcode_api/repository/TagCountProjection.java

@@ -0,0 +1,7 @@
+package com.rajat_singh.leetcode_api.repository;
+
+public interface TagCountProjection {
+    String getTagSlug();
+    String getTagName();
+    Long getTotalCount();
+}

src/main/java/com/rajat_singh/leetcode_api/service/RecommendationService.java

@@ -0,0 +1,96 @@
+package com.rajat_singh.leetcode_api.service;
+
+import com.rajat_singh.leetcode_api.dto.*;
+import com.rajat_singh.leetcode_api.entity.QuestionEntity;
+import com.rajat_singh.leetcode_api.repository.QuestionsRepository;
+import com.rajat_singh.leetcode_api.repository.TagCountProjection;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import org.tinylog.Logger;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+public class RecommendationService {
+
+    private final LeetCodeService leetCodeService;
+    private final QuestionsRepository questionsRepository;
+
+
+    public RecommendationResponse getRecommendations(String username) {
+        Logger.info("Getting question recommendations for user : {}",username);
+        var userSolvedStats = leetCodeService.getUserSkillStats(username);
+        if (userSolvedStats.isEmpty()) return null;
+
+        UserSkillStatsResponse.TagProblemCounts userCounts = userSolvedStats.get().getTagProblemCounts();
+        Map<String, Long> dbTotalCounts = questionsRepository.countProblemsByTag()
+                .stream().collect(Collectors.toMap(TagCountProjection::getTagName, TagCountProjection::getTotalCount));
+
+        List<UserTagStatDTO> allStats = new ArrayList<>();
+        List<UserSkillStatsResponse.TagProblem> allUserTags = new ArrayList<>();
+        if (userCounts.getAdvanced() != null) allUserTags.addAll(userCounts.getAdvanced());
+        if (userCounts.getIntermediate() != null) allUserTags.addAll(userCounts.getIntermediate());
+        if (userCounts.getFundamental() != null) allUserTags.addAll(userCounts.getFundamental());
+
+        for (UserSkillStatsResponse.TagProblem t : allUserTags) {
+            long total = dbTotalCounts.getOrDefault(t.getTagName(), 0L);
+            if (total > 5) {
+                allStats.add(UserTagStatDTO.builder()
+                        .tagName(t.getTagName())
+                        .solved(t.getProblemsSolved())
+                        .totalAvailable(total)
+                        .completionPercentage((double) t.getProblemsSolved() / total)
+                        .build());
+            }
+        }
+
+        List<String> top5WeakTopics = allStats.stream()
+                .sorted((a, b) -> {
+                    double scoreA = (1 - a.getCompletionPercentage()) * Math.log(a.getTotalAvailable() + 1);
+                    double scoreB = (1 - b.getCompletionPercentage()) * Math.log(b.getTotalAvailable() + 1);
+                    return Double.compare(scoreB, scoreA);
+                })
+                .limit(5)
+                .map(UserTagStatDTO::getTagName)
+                .toList();
+
+        if (top5WeakTopics.isEmpty()){
+            Logger.warn("No weak topics found for user: {}", username);
+            return null;
+        }
+
+        List<QuestionEntity> questions = questionsRepository.findRandomQuestionsByTagsAndDifficulty(
+                top5WeakTopics, List.of("MEDIUM", "HARD"), 15);
+
+        Map<String, WeakTopicDTO> weakTopicsMap = new LinkedHashMap<>();
+        for (String topic : top5WeakTopics) {
+            UserTagStatDTO stat = allStats.stream()
+                    .filter(s -> s.getTagName().equals(topic))
+                    .findFirst().orElse(null);
+            
+            if (stat != null) {
+                weakTopicsMap.put(topic, WeakTopicDTO.builder()
+                        .completionPercentage(String.format("%.1f%%", stat.getCompletionPercentage() * 100))
+                        .completedQuestions(stat.getSolved())
+                        .totalQuestions(stat.getTotalAvailable())
+                        .build());
+            }
+        }
+
+        List<RecommendedQuestionDTO> recommendedQuestions = questions.stream()
+                .map(q -> RecommendedQuestionDTO.builder()
+                        .name(q.getTitle())
+                        .acceptanceRate(String.format("%.2f%%", q.getAcRate()))
+                        .tags(q.getTopicTags().stream().map(t -> t.getName()).collect(Collectors.toList()))
+                        .link(q.getProblemUrl())
+                        .build())
+                .collect(Collectors.toList());
+
+        return RecommendationResponse.builder()
+                .weakTopics(weakTopicsMap)
+                .recommendedQuestions(recommendedQuestions)
+                .build();
+    }
+}