Merge pull request #12 from DevKor-github/midpoint-subway

Feature/Midpoint-Subway 지하철역 기반 중간지점 계산 로직 구현 완료

Author: leesanghuu

src/main/java/com/ODG/ODG_back/domain/Midpoint.java

@@ -17,20 +17,16 @@
 public class Midpoint {
 
     @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     private String name;
 
-    private String line;
-
+    @Column(precision = 15, scale = 8)
     private BigDecimal latitude;
 
+    @Column(precision = 15, scale = 8)
     private BigDecimal longitude;
 
-    @OneToMany(mappedBy = "midpoint")
-    private List<RecommendedMidpoint> recommendedMidpoints;
-
     @ManyToMany(mappedBy = "midpoints")
     private List<Place> places;
 }

src/main/java/com/ODG/ODG_back/domain/SubwayDurationTime.java

@@ -0,0 +1,36 @@
+package com.ODG.ODG_back.domain;
+
+import jakarta.persistence.*;
+import lombok.*;
+
+@Entity
+@Getter
+@Builder
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(indexes = { @Index(name = "idx_start_end", columnList = "start,end") })
+public class SubwayDurationTime {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    Long start;
+
+    @Column(nullable = false)
+    Long end;
+
+    int shortestDurationTime; // 최소 소요 시간
+    int transferCountForShortestDuration; // 최소 소요 시간일 때 환승 횟수
+
+    @Column(nullable = false, length = 2000)
+    String shortestDurationTimePath; // 최소 소요 시간일 때 경로
+
+    int durationTimeForMinimumTransfer; // 최소 환승 횟수일 때 소요 시간
+    int minimumTransferCount; // 최소 환승 횟수
+
+    @Column(nullable = false, length = 2000)
+    String minimumTransferPath; // 최소 환승 횟수일 때 경로
+}

src/main/java/com/ODG/ODG_back/dto/external/OverpassStationInfoDTO.java

@@ -0,0 +1,4 @@
+package com.ODG.ODG_back.dto.external;
+
+public class OverpassStationInfoDTO {
+}

src/main/java/com/ODG/ODG_back/external/openStreetMap/OpenStreetMapApiClient.java

@@ -0,0 +1,4 @@
+package com.ODG.ODG_back.external.openStreetMap;
+
+public interface OpenStreetMapApiClient {
+}

src/main/java/com/ODG/ODG_back/external/openStreetMap/OpenStreetMapApiClientImpl.java

@@ -0,0 +1,4 @@
+package com.ODG.ODG_back.external.openStreetMap;
+
+public class OpenStreetMapApiClientImpl {
+}

src/main/java/com/ODG/ODG_back/external/overpass/OverpassApiClient.java

@@ -0,0 +1,4 @@
+package com.ODG.ODG_back.external.overpass;
+
+public interface OverpassApiClient {
+}

src/main/java/com/ODG/ODG_back/external/overpass/OverpassApiClientImpl.java

@@ -0,0 +1,4 @@
+package com.ODG.ODG_back.external.overpass;
+
+public class OverpassApiClientImpl {
+}

src/main/java/com/ODG/ODG_back/repository/SubwayDurationTimeRepository.java

@@ -0,0 +1,10 @@
+package com.ODG.ODG_back.repository;
+
+import com.ODG.ODG_back.domain.SubwayDurationTime;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface SubwayDurationTimeRepository extends JpaRepository<SubwayDurationTime, Long> {
+   Optional<SubwayDurationTime> findByStartAndEnd(Long start, Long end);
+}

src/main/java/com/ODG/ODG_back/strategy/SubwayMidpointStrategy.java

@@ -1,17 +1,147 @@
 package com.ODG.ODG_back.strategy;
 
+import com.ODG.ODG_back.domain.*;
+import com.ODG.ODG_back.dto.external.OverpassStationInfoDTO;
 import com.ODG.ODG_back.dto.midpoint.response.MidpointResponseDto;
+import com.ODG.ODG_back.exception.ErrorCode;
+import com.ODG.ODG_back.exception.custom.NotFoundException;
+import com.ODG.ODG_back.external.google.GoogleMatrixApiClient;
+import com.ODG.ODG_back.external.openStreetMap.OpenStreetMapApiClient;
+import com.ODG.ODG_back.external.overpass.OverpassApiClient;
+import com.ODG.ODG_back.mapper.MidpointMapper;
+import com.ODG.ODG_back.repository.MeetingRepository;
+import com.ODG.ODG_back.repository.MidpointRepository;
+import com.ODG.ODG_back.repository.RecommendedMidpointRepository;
+import com.ODG.ODG_back.repository.SubwayDurationTimeRepository;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 
 import java.math.BigDecimal;
+import java.util.*;
+
+import static java.util.stream.Collectors.groupingBy;
 
 @Component("subwayStrategy")
 @RequiredArgsConstructor
 public class SubwayMidpointStrategy implements MidpointStrategy{
+    private final int MAX_DISTANCE = 2000; // 최대 검색 거리 (미터 단위)
+    private final MeetingRepository meetingRepository;
+    private final RecommendedMidpointRepository recommendedMidpointRepository;
+    private final MidpointRepository midpointRepository;
+    private final MidpointMapper midpointMapper;
+    private final SubwayDurationTimeRepository timeRepository; // 지하철역간 이동 시간 저장소
 
     @Override
     public MidpointResponseDto calculateMidpoints(String inviteCode) {
-        return new MidpointResponseDto(1L, "dummy", BigDecimal.ZERO, BigDecimal.ZERO);
+
+        Meeting meeting = meetingRepository.findByInviteCode(inviteCode).orElseThrow(
+                () -> new NotFoundException(ErrorCode.MEETING_NOT_FOUND)
+        );
+        // 출발지 = 참가자 위치
+        List<Participant> participants = meeting.getParticipants();
+        // 목적지 = 모든 지하철역
+        List<Midpoint> allMidpoints = midpointRepository.findAll();
+
+        // 각 participant별로 allMidpoints에서 가장 가까운 지하철역을 찾아 리스트에 추가
+
+        List<Midpoint> nearestMidpoints = new ArrayList<>();
+        for (Participant participant : participants) {
+            Midpoint nearest = allMidpoints.stream()
+                    .min(Comparator.comparing(midpoint ->
+                            participant.getLatitude().subtract(midpoint.getLatitude()).abs()
+                                    .add(participant.getLongitude().subtract(midpoint.getLongitude()).abs())
+                    ))
+                    .orElseThrow(RuntimeException::new);
+            nearestMidpoints.add(nearest);
+        }
+
+        List<MidpointScore> midpointScores = calculateMidpointScores(nearestMidpoints, allMidpoints, participants.size());
+
+        MidpointScore best = midpointScores.stream()
+                .min(Comparator.comparingDouble(MidpointScore::totalDeviation))
+                .orElseThrow(RuntimeException::new);
+
+        saveRecommendedMidpoint(best, meeting);
+        return midpointMapper.toDto(best.midpoint());
+    }
+
+    // 각 참가자별 가장 가까운 역(nearbyStationsForEachParticipant)과 모든 Midpoint의 역 정보를 기반으로
+    // 각 Midpoint까지의 소요 시간 합(midPointScore)을 계산하여 반환하는 메서드
+    public List<MidpointScore> calculateMidpointScores(
+            List<Midpoint> nearbyStationsForEachParticipant,
+            List<Midpoint> allMidpoints,
+            int numberOfParticipants) {
+
+        List<MidpointScore> scores = new ArrayList<>();
+
+        for (Midpoint midpoint : allMidpoints) {
+            var score = calculateMidpointScore(nearbyStationsForEachParticipant, numberOfParticipants, midpoint);
+
+            if(score != null) {
+                scores.add(score);
+            }
+        }
+
+        return scores;
+    }
+
+    public MidpointScore calculateMidpointScore(List<Midpoint> nearbyStationsForEachParticipant, int numberOfParticipants, Midpoint midpoint) {
+        int totalDuration = 0;
+
+        try{
+
+            for (Midpoint startStation : nearbyStationsForEachParticipant) {
+                // 시작역과 목적지역 이름이 모두 존재해야 함
+
+                // SubwayDurationTimeRepository에서 소요 시간 조회
+                SubwayDurationTime durationOpt = getDurationInfo(startStation, midpoint);
+                totalDuration += durationOpt.getShortestDurationTime();
+
+                return new MidpointScore(midpoint, (double) totalDuration / numberOfParticipants, totalDuration);
+            }
+        }
+        catch (NotFoundException e) {
+            // 해당 midpoint에 대한 정보가 없으면 유효하지 않은 것으로 간주
+        }
+
+        return null;
+    }
+
+    public SubwayDurationTime getDurationInfo(
+            Midpoint start,
+            Midpoint end) {
+        // 시작역과 목적지역 이름이 모두 존재해야 함
+
+        if(Objects.equals(start.getId(), end.getId())){
+            new SubwayDurationTime();
+            return SubwayDurationTime.builder()
+                    .start(start.getId())
+                    .end(end.getId())
+                    .shortestDurationTime(0)
+                    .transferCountForShortestDuration(0)
+                    .build();
+        }
+        Optional<SubwayDurationTime> durationTime = timeRepository.findByStartAndEnd(
+                start.getId(), end.getId());
+
+        if (durationTime.isEmpty()) {
+            throw new NotFoundException(ErrorCode.INTERNAL_SERVER_ERROR);
+        }
+
+        return durationTime.get();
     }
+
+    private void saveRecommendedMidpoint(MidpointScore best, Meeting meeting) {
+        RecommendedMidpoint recommended = new RecommendedMidpoint(
+                null,
+                best.avg(),
+                1,
+                java.time.LocalDateTime.now(),
+                meeting,
+                best.midpoint()
+        );
+        recommendedMidpointRepository.save(recommended);
+    }
+
+    public record MidpointScore(Midpoint midpoint, double avg, double totalDeviation) {}
 }