[feat] 웨이블존 추천 시스템 구현 완료

src/main/java/com/wayble/server/common/config/ElasticsearchConfig.java

@@ -4,7 +4,6 @@
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.elasticsearch.client.ClientConfiguration;
 import org.springframework.data.elasticsearch.client.elc.ElasticsearchConfiguration;
-import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
 
 @Configuration
 public class ElasticsearchConfig extends ElasticsearchConfiguration {

src/main/java/com/wayble/server/explore/controller/WaybleZoneRecommendController.java

@@ -1,14 +1,15 @@
 package com.wayble.server.explore.controller;
 
 import com.wayble.server.common.response.CommonResponse;
+import com.wayble.server.explore.dto.recommend.WaybleZoneRecommendConditionDto;
 import com.wayble.server.explore.dto.recommend.WaybleZoneRecommendResponseDto;
 import com.wayble.server.explore.service.WaybleZoneRecommendService;
+import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.validation.annotation.Validated;
-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;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
 
 @RestController
 @RequiredArgsConstructor
@@ -18,10 +19,17 @@ public class WaybleZoneRecommendController {
 
     private final WaybleZoneRecommendService waybleZoneRecommendService;
 
-    @GetMapping("/{userId}")
-    public CommonResponse<WaybleZoneRecommendResponseDto> getWaybleZonePersonalRecommend(
-            @PathVariable("userId") Long userId) {
-        WaybleZoneRecommendResponseDto dto = waybleZoneRecommendService.getWaybleZonePersonalRecommend(userId);
-        return CommonResponse.success(dto);
+    @GetMapping()
+    public CommonResponse<List<WaybleZoneRecommendResponseDto>> getWaybleZonePersonalRecommend(
+            @Valid @ModelAttribute WaybleZoneRecommendConditionDto conditionDto,
+            @RequestParam(name = "size", defaultValue = "1") int size) {
+
+        List<WaybleZoneRecommendResponseDto> result = waybleZoneRecommendService.getWaybleZonePersonalRecommend(
+                conditionDto.userId(),
+                conditionDto.latitude(),
+                conditionDto.longitude(),
+                size
+        );
+        return CommonResponse.success(result);
     }
 }

src/main/java/com/wayble/server/explore/dto/recommend/WaybleZoneRecommendConditionDto.java

@@ -0,0 +1,23 @@
+package com.wayble.server.explore.dto.recommend;
+
+import jakarta.validation.constraints.DecimalMax;
+import jakarta.validation.constraints.DecimalMin;
+import jakarta.validation.constraints.NotNull;
+import lombok.Builder;
+
+@Builder
+public record WaybleZoneRecommendConditionDto(
+        @DecimalMin(value = "-90.0", message = "위도는 -90.0 이상이어야 합니다.")
+        @DecimalMax(value = "90.0", message = "위도는 90.0 이하여야 합니다.")
+        @NotNull(message = "위도 입력은 필수입니다.")
+        Double latitude,
+
+        @DecimalMin(value = "-180.0", message = "경도는 -180.0 이상이어야 합니다.")
+        @DecimalMax(value = "180.0", message = "경도는 180.0 이하여야 합니다.")
+        @NotNull(message = "경도 입력은 필수입니다.")
+        Double longitude,
+
+        @NotNull(message = "유저 ID는 필수입니다.")
+        Long userId
+) {
+}

src/main/java/com/wayble/server/explore/dto/recommend/WaybleZoneRecommendResponseDto.java

@@ -1,8 +1,47 @@
 package com.wayble.server.explore.dto.recommend;
 
+import com.wayble.server.explore.entity.WaybleZoneDocument;
+import com.wayble.server.wayblezone.entity.WaybleZoneType;
+import lombok.Builder;
+
+@Builder
 public record WaybleZoneRecommendResponseDto(
 
-        String username
+        Long zoneId,
+
+        String zoneName,
+
+        WaybleZoneType zoneType,
+
+        String thumbnailImageUrl,
+
+        Double latitude,
+
+        Double longitude,
+
+        Double averageRating,
+
+        Long reviewCount,
+
+        Double distanceScore,
+
+        Double similarityScore,
+
+        Double recencyScore,
+
+        Double totalScore
 
 ) {
+    public static WaybleZoneRecommendResponseDto from(WaybleZoneDocument waybleZoneDocument) {
+        return WaybleZoneRecommendResponseDto.builder()
+                .zoneId(waybleZoneDocument.getZoneId())
+                .zoneName(waybleZoneDocument.getZoneName())
+                .zoneType(waybleZoneDocument.getZoneType())
+                .thumbnailImageUrl(waybleZoneDocument.getThumbnailImageUrl())
+                .averageRating(waybleZoneDocument.getAverageRating())
+                .reviewCount(waybleZoneDocument.getReviewCount())
+                .latitude(waybleZoneDocument.getAddress().getLocation().getLat())
+                .longitude(waybleZoneDocument.getAddress().getLocation().getLon())
+                .build();
+    }
 }

src/main/java/com/wayble/server/explore/entity/RecommendLogDocument.java

@@ -0,0 +1,36 @@
+package com.wayble.server.explore.entity;
+import org.springframework.data.annotation.Id;
+import lombok.*;
+import org.springframework.data.elasticsearch.annotations.DateFormat;
+import org.springframework.data.elasticsearch.annotations.Document;
+import org.springframework.data.elasticsearch.annotations.Field;
+import org.springframework.data.elasticsearch.annotations.FieldType;
+
+import java.time.LocalDate;
+
+@ToString
+@Builder
+@Getter
+@AllArgsConstructor
+@NoArgsConstructor
+@Document(indexName = "recommend_log")
+public class RecommendLogDocument {
+
+    @Id
+    @Field(name = "id")
+    private String id;
+
+    private Long userId;
+
+    private Long zoneId;
+
+    @Field(type = FieldType.Date, format = DateFormat.date)
+    private LocalDate recommendationDate;
+
+    private Long recommendCount;
+
+    public void updateRecommendLog(LocalDate recommendationDate, Long recommendCount) {
+        this.recommendationDate = recommendationDate;
+        this.recommendCount = recommendCount;
+    }
+}

src/main/java/com/wayble/server/explore/entity/WaybleZoneVisitLogDocument.java

@@ -19,7 +19,7 @@ public class WaybleZoneVisitLogDocument {
 
     @Id
     @Field(name = "id")
-    private Long logId;
+    private String logId;
 
     private Long userId;
 
@@ -31,7 +31,7 @@ public class WaybleZoneVisitLogDocument {
 
     public static WaybleZoneVisitLogDocument fromEntity(User user, Long zoneId) {
         return WaybleZoneVisitLogDocument.builder()
-                .logId(UUID.randomUUID().getMostSignificantBits() & Long.MAX_VALUE)
+                .logId(UUID.randomUUID().toString())
                 .userId(user.getId())
                 .zoneId(zoneId)
                 .gender(user.getGender())

src/main/java/com/wayble/server/explore/exception/RecommendErrorCase.java

@@ -8,7 +8,11 @@
 @RequiredArgsConstructor
 public enum RecommendErrorCase implements ErrorCase {
 
-    INVALID_USER(400, 6001, "잘못된 유저 정보입니다.");
+    INVALID_USER(400, 6001, "잘못된 유저 정보입니다."),
+
+    RECOMMEND_LOG_NOT_EXIST(400, 6002, "해당하는 추천 기록이 존재하지 않습니다."),
+
+    WAYBLE_ZONE_NOT_EXIST(400, 6003, "추천 기록에 해당하는 웨이블존이 존재하지 않습니다.");
 
     private final Integer httpStatusCode;
     private final Integer errorCode;

src/main/java/com/wayble/server/explore/exception/VisitLogErrorCase.java

@@ -0,0 +1,17 @@
+package com.wayble.server.explore.exception;
+
+import com.wayble.server.common.exception.ErrorCase;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public enum VisitLogErrorCase implements ErrorCase {
+
+    USER_NOT_EXIST(400, 7001, "해당하는 유저가 존재하지 않습니다."),
+    ZONE_NOT_EXIST(400, 7002, "해당하는 웨이블존이 존재하지 않습니다.");
+
+    private final Integer httpStatusCode;
+    private final Integer errorCode;
+    private final String message;
+}

src/main/java/com/wayble/server/explore/repository/RecommendLogDocumentRepository.java

@@ -0,0 +1,15 @@
+package com.wayble.server.explore.repository;
+
+import com.wayble.server.explore.entity.RecommendLogDocument;
+import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
+
+import java.time.LocalDate;
+import java.util.Optional;
+
+public interface RecommendLogDocumentRepository extends ElasticsearchRepository<RecommendLogDocument, String> {
+    Optional<RecommendLogDocument> findByUserIdAndZoneId(Long userId, Long zoneId);
+
+    Boolean existsByUserIdAndZoneId(Long userId, Long zoneId);
+
+    Optional<RecommendLogDocument> findByUserIdAndRecommendationDate(Long userId, LocalDate recommendationDate);
+}

src/main/java/com/wayble/server/explore/repository/WaybleZoneVisitLogDocumentRepository.java

@@ -3,7 +3,10 @@
 import com.wayble.server.explore.entity.WaybleZoneVisitLogDocument;
 import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
 
+import java.util.List;
 
-public interface WaybleZoneVisitLogDocumentRepository extends ElasticsearchRepository<WaybleZoneVisitLogDocument, Long>{
+
+public interface WaybleZoneVisitLogDocumentRepository extends ElasticsearchRepository<WaybleZoneVisitLogDocument, String>{
+    List<WaybleZoneVisitLogDocument> findAll();
 }
 

src/main/java/com/wayble/server/explore/repository/recommend/WaybleZoneQueryRecommendRepository.java

@@ -1,18 +1,152 @@
 package com.wayble.server.explore.repository.recommend;
 
+import co.elastic.clients.elasticsearch._types.GeoLocation;
+import co.elastic.clients.elasticsearch._types.SortOrder;
+import co.elastic.clients.elasticsearch._types.query_dsl.Query;
 import com.wayble.server.explore.dto.recommend.WaybleZoneRecommendResponseDto;
+import com.wayble.server.explore.entity.RecommendLogDocument;
+import com.wayble.server.explore.entity.WaybleZoneDocument;
+import com.wayble.server.explore.entity.WaybleZoneVisitLogDocument;
 import com.wayble.server.user.entity.User;
+import com.wayble.server.user.entity.Gender;
+import com.wayble.server.explore.entity.AgeGroup;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.elasticsearch.client.elc.NativeQuery;
 import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
+import org.springframework.data.elasticsearch.core.SearchHits;
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.stereotype.Repository;
 
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+import java.util.*;
+import java.util.stream.Collectors;
+
 @Repository
 @RequiredArgsConstructor
 public class WaybleZoneQueryRecommendRepository {
 
     private final ElasticsearchOperations operations;
 
-    public WaybleZoneRecommendResponseDto searchPersonalWaybleZone(User user) {
-        return null;
+    private static final IndexCoordinates ZONE_INDEX = IndexCoordinates.of("wayble_zone");
+    private static final IndexCoordinates LOG_INDEX = IndexCoordinates.of("wayble_zone_visit_log");
+    private static final IndexCoordinates RECOMMEND_LOG_INDEX = IndexCoordinates.of("recommend_log");
+
+
+    // === [가중치 설정] === //
+    private static final double DISTANCE_WEIGHT = 0.55; // 거리 기반 점수 가중치
+    private static final double SIMILARITY_WEIGHT = 0.15;   // 유사 사용자 방문 이력 기반 점수 가중치
+    private static final double RECENCY_WEIGHT = 0.3;   // 최근 추천 내역 기반 감점 가중치
+
+    private static final int MAX_DAY_DIFF = 30; // 추천 감점 최대 기준일 (30일 전까지 고려)
+
+    public List<WaybleZoneRecommendResponseDto> searchPersonalWaybleZones(User user, double latitude, double longitude, int size) {
+
+        AgeGroup userAgeGroup = AgeGroup.fromBirthDate(user.getBirthDate());
+        Gender userGender = user.getGender();
+
+        // 사용자의 위치 기준으로 50km 반경 이내 장소들 조회
+        Query geoQuery = Query.of(q -> q
+                .bool(b -> b
+                        .filter(f -> f.geoDistance(gd -> gd
+                                .field("address.location")
+                                .location(loc -> loc.latlon(ll -> ll.lat(latitude).lon(longitude)))
+                                .distance("50km")))
+                )
+        );
+
+        // 거리 기준 정렬하여 최대 100개 결과 조회
+        NativeQuery nativeQuery = NativeQuery.builder()
+                .withQuery(geoQuery)
+                .withSort(s -> s.geoDistance(gds -> gds
+                        .field("address.location")
+                        .location(GeoLocation.of(gl -> gl.latlon(ll -> ll.lat(latitude).lon(longitude))))
+                        .order(SortOrder.Asc)))
+                .withMaxResults(100)
+                .build();
+
+        SearchHits<WaybleZoneDocument> zoneHits = operations.search(nativeQuery, WaybleZoneDocument.class, ZONE_INDEX);
+
+        // 전체 방문 로그를 최대 10,000건까지 조회
+        NativeQuery logQuery = NativeQuery.builder()
+                .withMaxResults(10000)
+                .build();
+
+        SearchHits<WaybleZoneVisitLogDocument> logHits = operations.search(logQuery, WaybleZoneVisitLogDocument.class, LOG_INDEX);
+
+        // zoneId 별로 유사 사용자 방문 횟수 가중치 계산
+        Map<Long, Double> zoneVisitScoreMap = new HashMap<>();
+
+        for (var hit : logHits) {
+            WaybleZoneVisitLogDocument log = hit.getContent();
+
+            double weight = 0.0;
+            boolean ageMatch = log.getAgeGroup() == userAgeGroup;
+            boolean genderMatch = log.getGender() == userGender;
+
+            if (ageMatch && genderMatch) {
+                weight = 1.0;   // 성별, 연령 둘 다 일치
+            } else if (ageMatch) {
+                weight = 0.7;   // 연령만 일치
+            } else if (genderMatch) {
+                weight = 0.2;   // 성별만 일치
+            }
+
+            zoneVisitScoreMap.merge(log.getZoneId(), weight, Double::sum);
+        }
+
+        // 최근 추천 날짜 조회 -> 가까울수록 감점
+        NativeQuery recommendLogQuery = NativeQuery.builder()
+                .withQuery(Query.of(q -> q.term(t -> t.field("userId").value(user.getId()))))
+                .withMaxResults(1000)
+                .build();
+
+        SearchHits<RecommendLogDocument> recommendHits = operations.search(recommendLogQuery, RecommendLogDocument.class, RECOMMEND_LOG_INDEX);
+        Map<Long, LocalDate> recentRecommendDateMap = recommendHits.stream()
+                .map(hit -> hit.getContent())
+                .collect(Collectors.toMap(RecommendLogDocument::getZoneId, RecommendLogDocument::getRecommendationDate));
+
+
+        // 각 장소마다 점수 계산 후 DTO로 변환
+        return zoneHits.stream()
+                .map(hit -> {
+                    WaybleZoneDocument zone = hit.getContent();
+
+                    // 거리 점수 계산 (가까울수록 높음)
+                    double distanceScore = (1.0 / (1.0 + ((Double) hit.getSortValues().get(0) / 1000.0))) * DISTANCE_WEIGHT;
+
+                    // 유사도 점수 (비슷한 사용자 방문수 반영)
+                    double similarityScore = (zoneVisitScoreMap.getOrDefault(zone.getZoneId(), 0.0) / 10.0) * SIMILARITY_WEIGHT;
+
+                    // 최근 추천일 기반 감점 계산
+                    double recencyScore = RECENCY_WEIGHT;
+                    LocalDate lastRecommendDate = recentRecommendDateMap.get(zone.getZoneId());
+
+                    if (lastRecommendDate != null) {
+                        long daysSince = ChronoUnit.DAYS.between(lastRecommendDate, LocalDate.now());
+                        double factor = 1.0 - Math.min(daysSince, MAX_DAY_DIFF) / (double) MAX_DAY_DIFF; // 0~1
+                        recencyScore = RECENCY_WEIGHT * (1.0 - factor); // days=0 -> 0점, days=30 -> full 점수
+                    }
+
+                    double totalScore = distanceScore + similarityScore + recencyScore;
+
+                    return WaybleZoneRecommendResponseDto.builder()
+                            .zoneId(zone.getZoneId())
+                            .zoneName(zone.getZoneName())
+                            .zoneType(zone.getZoneType())
+                            .thumbnailImageUrl(zone.getThumbnailImageUrl())
+                            .latitude(zone.getAddress().getLocation().getLat())
+                            .longitude(zone.getAddress().getLocation().getLon())
+                            .averageRating(zone.getAverageRating())
+                            .reviewCount(zone.getReviewCount())
+                            .distanceScore(distanceScore)
+                            .similarityScore(similarityScore)
+                            .recencyScore(recencyScore)
+                            .totalScore(totalScore)
+                            .build();
+                })
+                .sorted(Comparator.comparingDouble(WaybleZoneRecommendResponseDto::totalScore).reversed())  // 점수 내림차순 정렬
+                .limit(size)    // 상위 size 개수만 반환
+                .toList();
     }
-}
+}