feat: 매칭 필터 ID 기반 관리 추가

Author: Hooneybadger

src/main/java/com/example/rightbackend/matching/filter/controller/MatchingFilterController.java

@@ -5,7 +5,9 @@
 import com.example.rightbackend.global.response.SuccessResponse;
 import com.example.rightbackend.global.response.success.MatchingFilterSuccess;
 import com.example.rightbackend.matching.filter.controller.dto.request.MatchingFilterRequest;
+import com.example.rightbackend.matching.filter.controller.dto.request.MatchingFilterIdsRequest;
 import com.example.rightbackend.matching.filter.controller.dto.response.MatchingFilterResponse;
+import com.example.rightbackend.matching.filter.controller.dto.response.MatchingFilterIdsResponse;
 import com.example.rightbackend.matching.filter.domain.MatchingFilter;
 import com.example.rightbackend.matching.filter.service.MatchingFilterService;
 import lombok.RequiredArgsConstructor;
@@ -32,4 +34,18 @@ public ResponseEntity<SuccessResponse<MatchingFilterResponse>> createOrUpdateMat
         MatchingFilter matchingFilter = matchingFilterService.createOrUpdateMatchingFilter(loginMember, request);
         return SuccessResponse.of(MatchingFilterSuccess.UPDATE_MATCHING_FILTER_SUCCESS, MatchingFilterResponse.from(matchingFilter));
     }
+
+    @GetMapping("/v2")
+    public ResponseEntity<SuccessResponse<MatchingFilterIdsResponse>> getMatchingFilterWithIds(@Login LoginMember loginMember) {
+        MatchingFilter matchingFilter = matchingFilterService.getMatchingFilter(loginMember);
+        return SuccessResponse.of(MatchingFilterSuccess.GET_MATCHING_FILTER_SUCCESS, MatchingFilterIdsResponse.from(matchingFilter));
+    }
+
+    @PostMapping("/v2")
+    public ResponseEntity<SuccessResponse<MatchingFilterIdsResponse>> createOrUpdateMatchingFilterWithIds(
+            @Login LoginMember loginMember,
+            @RequestBody MatchingFilterIdsRequest request) {
+        MatchingFilter matchingFilter = matchingFilterService.createOrUpdateMatchingFilterWithIds(loginMember, request);
+        return SuccessResponse.of(MatchingFilterSuccess.UPDATE_MATCHING_FILTER_SUCCESS, MatchingFilterIdsResponse.from(matchingFilter));
+    }
 }

src/main/java/com/example/rightbackend/matching/filter/controller/dto/request/MatchingFilterIdsRequest.java

@@ -0,0 +1,12 @@
+package com.example.rightbackend.matching.filter.controller.dto.request;
+
+import java.util.List;
+import java.util.Map;
+
+public record MatchingFilterIdsRequest(
+        Integer minAge,
+        Integer maxAge,
+        Map<String, List<Integer>> idealFaceFeatureIds,
+        Long regionId
+) {
+}

src/main/java/com/example/rightbackend/matching/filter/controller/dto/response/MatchingFilterIdsResponse.java

@@ -0,0 +1,72 @@
+package com.example.rightbackend.matching.filter.controller.dto.response;
+
+import com.example.rightbackend.matching.filter.domain.MatchingFilter;
+import com.example.rightbackend.matching.filter.domain.Region;
+import com.example.rightbackend.matching.filter.service.IdealFaceFeatureUtil;
+
+import java.math.BigInteger;
+import java.util.List;
+import java.util.Map;
+
+public record MatchingFilterIdsResponse(
+        Long id,
+        Integer minAge,
+        Integer maxAge,
+        BigInteger idealFaceFeaturesBitmask,
+        Map<String, List<Integer>> idealFaceFeatureIds,
+        List<FeatureWithId> idealFaceFeatures,
+        RegionDto region
+) {
+    public static MatchingFilterIdsResponse from(MatchingFilter matchingFilter) {
+        RegionDto regionDto = null;
+        if (matchingFilter.getRegion() != null) {
+            regionDto = new RegionDto(
+                    matchingFilter.getRegion().getId(),
+                    matchingFilter.getRegion().getName()
+            );
+        }
+
+        Map<String, List<Integer>> featureIds = IdealFaceFeatureUtil.convertBitmaskToIds(matchingFilter.getIdealFaceFeaturesBitmask());
+
+        List<FeatureWithId> featuresWithIds = IdealFaceFeatureUtil.getFeatureInfosFromBitmask(matchingFilter.getIdealFaceFeaturesBitmask())
+                .stream()
+                .map(info -> new FeatureWithId(
+                        info.category(),
+                        info.code(),
+                        info.name(),
+                        info.index(),
+                        info.featureId()
+                ))
+                .toList();
+
+        return new MatchingFilterIdsResponse(
+                matchingFilter.getId(),
+                matchingFilter.getMinAge(),
+                matchingFilter.getMaxAge(),
+                matchingFilter.getIdealFaceFeaturesBitmask(),
+                featureIds,
+                featuresWithIds,
+                regionDto
+        );
+    }
+
+    public record RegionDto(
+            Long id,
+            String name
+    ) {
+        public static RegionDto from(Region region) {
+            return new RegionDto(
+                    region.getId(),
+                    region.getName()
+            );
+        }
+    }
+
+    public record FeatureWithId(
+            String category,
+            String code,
+            String name,
+            int index,
+            int featureId
+    ) {}
+}

src/main/java/com/example/rightbackend/matching/filter/service/IdealFaceFeatureUtil.java

@@ -7,97 +7,147 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 public class IdealFaceFeatureUtil {
 
     private static final Map<String, Integer> featureIndexMap = new HashMap<>();
     private static final List<FeatureInfo> featureInfoList = new ArrayList<>();
+    private static final Map<String, Map<Integer, FeatureInfo>> categoryIdMap = new HashMap<>();
 
     static {
         // 얼굴형
         int index = 0;
+        Map<Integer, FeatureInfo> faceShapeMap = new HashMap<>();
         for (FaceShape value : FaceShape.values()) {
             featureIndexMap.put(value.name(), index);
-            featureInfoList.add(new FeatureInfo("얼굴형", value.name(), value.getName(), index));
+            FeatureInfo info = new FeatureInfo("FACE_SHAPE", value.name(), value.getName(), index, value.getId());
+            featureInfoList.add(info);
+            faceShapeMap.put(value.getId(), info);
             index++;
         }
+        categoryIdMap.put("FACE_SHAPE", faceShapeMap);
 
         // 눈 타입
+        Map<Integer, FeatureInfo> eyeTypeMap = new HashMap<>();
         for (EyeType value : EyeType.values()) {
             featureIndexMap.put(value.name(), index);
-            featureInfoList.add(new FeatureInfo("눈 타입", value.name(), value.getName(), index));
+            FeatureInfo info = new FeatureInfo("EYE_TYPE", value.name(), value.getName(), index, value.getId());
+            featureInfoList.add(info);
+            eyeTypeMap.put(value.getId(), info);
             index++;
         }
+        categoryIdMap.put("EYE_TYPE", eyeTypeMap);
 
         // 눈 크기
+        Map<Integer, FeatureInfo> eyeSizeMap = new HashMap<>();
         for (EyeSize value : EyeSize.values()) {
             featureIndexMap.put(value.name(), index);
-            featureInfoList.add(new FeatureInfo("눈 크기", value.name(), value.getName(), index));
+            FeatureInfo info = new FeatureInfo("EYE_SIZE", value.name(), value.getName(), index, value.getId());
+            featureInfoList.add(info);
+            eyeSizeMap.put(value.getId(), info);
             index++;
         }
+        categoryIdMap.put("EYE_SIZE", eyeSizeMap);
 
         // 입술 모양
+        Map<Integer, FeatureInfo> lipShapeMap = new HashMap<>();
         for (LipShape value : LipShape.values()) {
             featureIndexMap.put(value.name(), index);
-            featureInfoList.add(new FeatureInfo("입술 모양", value.name(), value.getName(), index));
+            FeatureInfo info = new FeatureInfo("LIP_SHAPE", value.name(), value.getName(), index, value.getId());
+            featureInfoList.add(info);
+            lipShapeMap.put(value.getId(), info);
             index++;
         }
+        categoryIdMap.put("LIP_SHAPE", lipShapeMap);
 
         // 코 모양
+        Map<Integer, FeatureInfo> noseShapeMap = new HashMap<>();
         for (NoseShape value : NoseShape.values()) {
             featureIndexMap.put(value.name(), index);
-            featureInfoList.add(new FeatureInfo("코 모양", value.name(), value.getName(), index));
+            FeatureInfo info = new FeatureInfo("NOSE_SHAPE", value.name(), value.getName(), index, value.getId());
+            featureInfoList.add(info);
+            noseShapeMap.put(value.getId(), info);
             index++;
         }
+        categoryIdMap.put("NOSE_SHAPE", noseShapeMap);
 
         // 턱 모양
+        Map<Integer, FeatureInfo> jawShapeMap = new HashMap<>();
         for (JawShape value : JawShape.values()) {
             featureIndexMap.put(value.name(), index);
-            featureInfoList.add(new FeatureInfo("턱 모양", value.name(), value.getName(), index));
+            FeatureInfo info = new FeatureInfo("JAW_SHAPE", value.name(), value.getName(), index, value.getId());
+            featureInfoList.add(info);
+            jawShapeMap.put(value.getId(), info);
             index++;
         }
+        categoryIdMap.put("JAW_SHAPE", jawShapeMap);
 
         // 이마
+        Map<Integer, FeatureInfo> foreheadMap = new HashMap<>();
         for (ForeHead value : ForeHead.values()) {
             featureIndexMap.put(value.name(), index);
-            featureInfoList.add(new FeatureInfo("이마", value.name(), value.getName(), index));
+            FeatureInfo info = new FeatureInfo("FOREHEAD", value.name(), value.getName(), index, value.getId());
+            featureInfoList.add(info);
+            foreheadMap.put(value.getId(), info);
             index++;
         }
+        categoryIdMap.put("FOREHEAD", foreheadMap);
 
         // 피부 톤
+        Map<Integer, FeatureInfo> skinToneMap = new HashMap<>();
         for (SkinTone value : SkinTone.values()) {
             featureIndexMap.put(value.name(), index);
-            featureInfoList.add(new FeatureInfo("피부 톤", value.name(), value.getName(), index));
+            FeatureInfo info = new FeatureInfo("SKIN_TONE", value.name(), value.getName(), index, value.getId());
+            featureInfoList.add(info);
+            skinToneMap.put(value.getId(), info);
             index++;
         }
+        categoryIdMap.put("SKIN_TONE", skinToneMap);
 
         // 수염
+        Map<Integer, FeatureInfo> beardMap = new HashMap<>();
         for (Beard value : Beard.values()) {
             featureIndexMap.put(value.name(), index);
-            featureInfoList.add(new FeatureInfo("수염", value.name(), value.getName(), index));
+            FeatureInfo info = new FeatureInfo("BEARD", value.name(), value.getName(), index, value.getId());
+            featureInfoList.add(info);
+            beardMap.put(value.getId(), info);
             index++;
         }
+        categoryIdMap.put("BEARD", beardMap);
 
         // 안경
+        Map<Integer, FeatureInfo> glassMap = new HashMap<>();
         for (Glass value : Glass.values()) {
             featureIndexMap.put(value.name(), index);
-            featureInfoList.add(new FeatureInfo("안경", value.name(), value.getName(), index));
+            FeatureInfo info = new FeatureInfo("GLASS", value.name(), value.getName(), index, value.getId());
+            featureInfoList.add(info);
+            glassMap.put(value.getId(), info);
             index++;
         }
+        categoryIdMap.put("GLASS", glassMap);
 
         // 동물상
+        Map<Integer, FeatureInfo> animalLookMap = new HashMap<>();
         for (AnimalLook value : AnimalLook.values()) {
             featureIndexMap.put(value.name(), index);
-            featureInfoList.add(new FeatureInfo("동물상", value.name(), value.getName(), index));
+            FeatureInfo info = new FeatureInfo("ANIMAL_LOOK", value.name(), value.getName(), index, value.getId());
+            featureInfoList.add(info);
+            animalLookMap.put(value.getId(), info);
             index++;
         }
+        categoryIdMap.put("ANIMAL_LOOK", animalLookMap);
 
         // 나이
+        Map<Integer, FeatureInfo> ageMap = new HashMap<>();
         for (Age value : Age.values()) {
             featureIndexMap.put(value.name(), index);
-            featureInfoList.add(new FeatureInfo("나이", value.name(), value.getName(), index));
+            FeatureInfo info = new FeatureInfo("AGE", value.name(), value.getName(), index, value.getId());
+            featureInfoList.add(info);
+            ageMap.put(value.getId(), info);
             index++;
         }
+        categoryIdMap.put("AGE", ageMap);
     }
 
     public static Integer getFeatureIndex(String featureName) {
@@ -110,20 +160,88 @@ public static List<FeatureInfo> getAllFeatureInfos() {
 
     public static List<FeatureInfo> getFeatureInfosFromBitmask(BigInteger bitmask) {
         List<FeatureInfo> selectedFeatures = new ArrayList<>();
-        
+
         for (FeatureInfo featureInfo : featureInfoList) {
             if (bitmask.testBit(featureInfo.index())) {
                 selectedFeatures.add(featureInfo);
             }
         }
-        
+
         return selectedFeatures;
     }
-    
+
+    public static BigInteger convertIdsToBitmask(Map<String, List<Integer>> categoryIds) {
+        BigInteger bitmask = BigInteger.ZERO;
+
+        for (Map.Entry<String, List<Integer>> entry : categoryIds.entrySet()) {
+            String category = entry.getKey();
+            List<Integer> ids = entry.getValue();
+            Map<Integer, FeatureInfo> featureMap = categoryIdMap.get(category);
+
+            if (featureMap != null) {
+                for (Integer id : ids) {
+                    FeatureInfo info = featureMap.get(id);
+                    if (info != null) {
+                        bitmask = bitmask.setBit(info.index());
+                    }
+                }
+            }
+        }
+
+        return bitmask;
+    }
+
+    public static Map<String, List<Integer>> convertBitmaskToIds(BigInteger bitmask) {
+        Map<String, List<Integer>> result = new HashMap<>();
+
+        for (FeatureInfo info : featureInfoList) {
+            if (bitmask.testBit(info.index())) {
+                result.computeIfAbsent(info.category(), k -> new ArrayList<>())
+                      .add(info.featureId());
+            }
+        }
+
+        return result;
+    }
+
+    public static List<FeatureInfo> getFeatureInfosByIds(Map<String, List<Integer>> categoryIds) {
+        List<FeatureInfo> result = new ArrayList<>();
+
+        for (Map.Entry<String, List<Integer>> entry : categoryIds.entrySet()) {
+            String category = entry.getKey();
+            List<Integer> ids = entry.getValue();
+            Map<Integer, FeatureInfo> featureMap = categoryIdMap.get(category);
+
+            if (featureMap != null) {
+                for (Integer id : ids) {
+                    FeatureInfo info = featureMap.get(id);
+                    if (info != null) {
+                        result.add(info);
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
+    public static FeatureInfo getFeatureInfoByNameAndCategory(String name, String category) {
+        return featureInfoList.stream()
+                .filter(info -> info.name().equals(name) && info.category().equals(category))
+                .findFirst()
+                .orElse(null);
+    }
+
     public record FeatureInfo(
             String category,
             String code,
             String name,
-            int index
-    ) {}
+            int index,
+            int featureId
+    ) {
+        // 기존 코드와의 호환성을 위한 생성자
+        public FeatureInfo(String category, String code, String name, int index) {
+            this(category, code, name, index, 0);
+        }
+    }
 }