✨ [Feat] 유저의 입력 값 바탕 제일 높은 가중치의 개발자 3명 반환하는 API

src/main/java/ssuPlector/repository/developer/DeveloperRepositoryCustom.java

@@ -1,16 +1,20 @@
 package ssuPlector.repository.developer;
 
 import java.util.List;
+import java.util.Map;
 
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 
 import ssuPlector.domain.Developer;
 import ssuPlector.domain.category.Part;
+import ssuPlector.dto.request.DeveloperDTO.DeveloperMatchingDTO;
 
 public interface DeveloperRepositoryCustom {
 
     Page<Developer> findDevelopers(String sortType, Part part, Pageable pageable);
 
     List<Developer> searchDeveloper(String developerName);
+
+    Map<Long, Double> matchDeveloper(String developerInfo, DeveloperMatchingDTO requestDTO);
 }

src/main/java/ssuPlector/repository/developer/DeveloperRepositoryImpl.java

@@ -1,9 +1,12 @@
 package ssuPlector.repository.developer;
 
 import static ssuPlector.domain.QDeveloper.developer;
+import static ssuPlector.domain.QProjectDeveloper.projectDeveloper;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageImpl;
@@ -18,7 +21,10 @@
 
 import lombok.RequiredArgsConstructor;
 import ssuPlector.domain.Developer;
+import ssuPlector.domain.category.DevLanguage;
 import ssuPlector.domain.category.Part;
+import ssuPlector.domain.category.TechStack;
+import ssuPlector.dto.request.DeveloperDTO.DeveloperMatchingDTO;
 import ssuPlector.global.exception.GlobalException;
 import ssuPlector.global.response.code.GlobalErrorCode;
 
@@ -77,4 +83,62 @@ BooleanExpression part2Eq(Part part) {
     public List<Developer> searchDeveloper(String name) {
         return queryFactory.selectFrom(developer).where(developer.name.contains(name)).fetch();
     }
+
+    BooleanExpression searchDeveloperStudentNumber(String min, String max) {
+        if (min == null) min = "0";
+        if (max == null) max = "100";
+        return developer.studentNumber.between(min, max);
+    }
+
+    BooleanExpression searchDeveloperProjectExperience(Boolean experience) {
+        if (experience == null || !experience) {
+            return developer.isNotNull();
+        }
+        return queryFactory
+                .selectFrom(projectDeveloper)
+                .where(projectDeveloper.developer.eq(developer))
+                .exists();
+    }
+
+    @Override
+    public Map<Long, Double> matchDeveloper(String developerInfo, DeveloperMatchingDTO requestDTO) {
+        // part, 개발 경험, 학번
+        List<Developer> developers =
+                queryFactory
+                        .selectFrom(developer)
+                        .where(
+                                part1Eq(requestDTO.getPart())
+                                        .and(
+                                                searchDeveloperStudentNumber(
+                                                        requestDTO.getStudentNumberMin(),
+                                                        requestDTO.getStudentNumberMax()))
+                                        .and(
+                                                searchDeveloperProjectExperience(
+                                                        requestDTO.getProjectExperience())))
+                        .fetch();
+
+        Map<Long, Double> weight = new HashMap<>();
+
+        // 사용언어, 기술스택
+        for (Developer developer : developers) {
+            double tmpWeight = 0.0;
+
+            List<DevLanguage> devLanguageList = developer.getLanguageList();
+            List<DevLanguage> intersectionLang =
+                    devLanguageList.stream()
+                            .filter(requestDTO.getLanguageList()::contains)
+                            .toList();
+
+            tmpWeight += intersectionLang.size() * 0.5;
+
+            List<TechStack> techStackList = developer.getTechStackList();
+            List<TechStack> intersectionTech =
+                    techStackList.stream().filter(requestDTO.getTechStackList()::contains).toList();
+
+            tmpWeight += intersectionTech.size() * 0.3;
+
+            weight.put(developer.getId(), tmpWeight);
+        }
+        return weight;
+    }
 }

src/main/java/ssuPlector/service/developer/DeveloperService.java

@@ -28,4 +28,6 @@ public interface DeveloperService {
     Long createDummyDeveloper(DummyDeveloperRequestDTO requestDTO, MultipartFile image);
 
     List<DeveloperSearchDTO> searchDeveloper(String developerName);
+
+    List<DeveloperSearchDTO> matchDeveloper(String developerInfo, DeveloperMatchingDTO requestDTO);
 }

src/main/java/ssuPlector/service/developer/DeveloperServiceImpl.java

@@ -1,16 +1,31 @@
 package ssuPlector.service.developer;
 
 import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.UUID;
 
+import org.apache.commons.lang3.tuple.Pair;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.client.RestTemplate;
 import org.springframework.web.multipart.MultipartFile;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
 import lombok.RequiredArgsConstructor;
 import ssuPlector.aws.s3.AmazonS3Manager;
 import ssuPlector.converter.DeveloperConverter;
@@ -23,6 +38,7 @@
 import ssuPlector.domain.category.TechStack;
 import ssuPlector.dto.request.DeveloperDTO;
 import ssuPlector.dto.request.DeveloperDTO.DeveloperListRequestDTO;
+import ssuPlector.dto.request.DeveloperDTO.DeveloperMatchingDTO;
 import ssuPlector.dto.request.DeveloperDTO.DeveloperRequestDTO;
 import ssuPlector.dto.request.DeveloperDTO.DeveloperUpdateRequestDTO;
 import ssuPlector.dto.response.DeveloperDTO.DeveloperSearchDTO;
@@ -42,6 +58,9 @@ public class DeveloperServiceImpl implements DeveloperService {
     private final AmazonS3Manager s3Manager;
     private final UuidRepository uuidRepository;
 
+    @Value("${sp.ai.url}")
+    private String aiUrl;
+
     @Override
     @Transactional
     public Long createDeveloper(String email, DeveloperRequestDTO requestDTO) {
@@ -137,4 +156,73 @@ public List<DeveloperSearchDTO> searchDeveloper(String developerName) {
         List<Developer> developers = developerRepository.searchDeveloper(developerName);
         return developers.stream().map(DeveloperConverter::toDeveloperSearchDTO).toList();
     }
+
+    @Override
+    public List<DeveloperSearchDTO> matchDeveloper(
+            String developerInfo, DeveloperMatchingDTO requestDTO) {
+        // request
+        RestTemplate restTemplate = new RestTemplate();
+        HttpHeaders headers = new HttpHeaders();
+
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        String requestBody =
+                String.format(
+                        "{\"part\":\"%s\", \"request\":\"%s\"}",
+                        requestDTO.getPart(), developerInfo);
+
+        HttpEntity<String> requestEntity = new HttpEntity<>(requestBody, headers);
+
+        ResponseEntity<String> response =
+                restTemplate.exchange(aiUrl, HttpMethod.POST, requestEntity, String.class);
+
+        // response
+        ObjectMapper objectMapper = new ObjectMapper();
+        List<Long> developerIds = new ArrayList<>();
+        try {
+            JsonNode developersNode = objectMapper.readTree(response.getBody()).path("developers");
+            Iterator<JsonNode> elements = developersNode.elements();
+            while (elements.hasNext()) {
+                Long developerId = elements.next().path("developer_id").asLong();
+                developerIds.add(developerId);
+            }
+        } catch (JsonProcessingException e) {
+            throw new GlobalException(GlobalErrorCode.INVALID_REQUEST_INFO);
+        }
+
+        Map<Long, Double> weight = developerRepository.matchDeveloper(developerInfo, requestDTO);
+
+        double w = 0.0;
+        for (Long developerId : developerIds) {
+            Developer developer =
+                    developerRepository
+                            .findById(developerId)
+                            .orElseThrow(
+                                    () -> new GlobalException(GlobalErrorCode.DEVELOPER_NOT_FOUND));
+
+            weight.put(developer.getId(), weight.get(developer.getId()) + w);
+            w -= 0.3;
+        }
+
+        // sort
+        List<Pair<Long, Double>> sortedDeveloper =
+                weight.entrySet().stream()
+                        .map(entry -> Pair.of(entry.getKey(), entry.getValue()))
+                        .sorted((p1, p2) -> p2.getValue().compareTo(p1.getValue()))
+                        .toList();
+
+        List<Developer> developerList =
+                sortedDeveloper.stream()
+                        .limit(3)
+                        .map(
+                                m -> {
+                                    Optional<Developer> optionalDeveloper =
+                                            developerRepository.findById(m.getLeft());
+                                    return optionalDeveloper.orElseThrow(
+                                            () ->
+                                                    new GlobalException(
+                                                            GlobalErrorCode.DEVELOPER_NOT_FOUND));
+                                })
+                        .toList();
+        return developerList.stream().map(DeveloperConverter::toDeveloperSearchDTO).toList();
+    }
 }