[Step3] 즐겨찾기 기능 구현 리뷰 요청드립니다.

src/main/java/nextstep/auth/authorization/AuthenticationPrincipalArgumentResolver.java

@@ -1,5 +1,6 @@
 package nextstep.auth.authorization;
 
+import nextstep.auth.authentication.AuthenticationException;
 import nextstep.auth.context.Authentication;
 import nextstep.auth.context.SecurityContextHolder;
 import org.springframework.core.MethodParameter;
@@ -20,6 +21,10 @@ public boolean supportsParameter(MethodParameter parameter) {
     @Override
     public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        if (authentication == null) {
+            throw new AuthenticationException();
+        }
+
         if (authentication.getPrincipal() instanceof Map) {
             return extractPrincipal(parameter, authentication);
         }

src/main/java/nextstep/subway/applicaion/FavoriteService.java

@@ -0,0 +1,50 @@
+package nextstep.subway.applicaion;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import nextstep.member.application.MemberService;
+import nextstep.member.domain.LoginMember;
+import nextstep.member.domain.MemberRepository;
+import nextstep.subway.applicaion.dto.FavoriteRequest;
+import nextstep.subway.applicaion.dto.FavoriteResponse;
+import nextstep.subway.domain.Favorite;
+import nextstep.subway.domain.FavoriteRepository;
+import nextstep.subway.domain.Station;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class FavoriteService {
+    private final StationService stationService;
+    private final PathService pathService;
+    private final MemberRepository memberRepository;
+    private final FavoriteRepository favoriteRepository;
+
+    public FavoriteService(StationService stationService, PathService pathService,
+        MemberRepository memberRepository, FavoriteRepository favoriteRepository) {
+        this.stationService = stationService;
+        this.pathService = pathService;
+        this.memberRepository = memberRepository;
+        this.favoriteRepository = favoriteRepository;
+    }
+
+    public FavoriteResponse createFavorite(FavoriteRequest favoriteRequest, Long memberId) {
+        Station source = stationService.findById(favoriteRequest.getSource());
+        Station target = stationService.findById(favoriteRequest.getTarget());
+        pathService.findPath(source, target);
+        Favorite favorite = favoriteRepository.save(Favorite.of(memberId, source, target));
+        return FavoriteResponse.from(favorite);
+    }
+
+    @Transactional(readOnly = true)
+    public List<FavoriteResponse> findFavorites(Long memberId) {
+        List<Favorite> favorites = favoriteRepository.findAllByMemberId(memberId);
+        return favorites.stream().map(FavoriteResponse::from).collect(Collectors.toList());
+    }
+
+    public void deleteFavorite(Long favoriteId, Long memberId) {
+        Favorite favorite = favoriteRepository.getById(favoriteId);
+        favorite.hasPermission(memberId);
+        favoriteRepository.delete(favorite);
+    }
+}

src/main/java/nextstep/subway/applicaion/PathService.java

@@ -22,10 +22,14 @@ public PathService(LineService lineService, StationService stationService) {
     public PathResponse findPath(Long source, Long target) {
         Station upStation = stationService.findById(source);
         Station downStation = stationService.findById(target);
-        List<Line> lines = lineService.findLines();
-        SubwayMap subwayMap = new SubwayMap(lines);
-        Path path = subwayMap.findPath(upStation, downStation);
+        Path path = findPath(upStation, downStation);
 
         return PathResponse.of(path);
     }
+
+    Path findPath(Station upStation, Station downStation) {
+        List<Line> lines = lineService.findLines();
+        SubwayMap subwayMap = new SubwayMap(lines);
+        return subwayMap.findPath(upStation, downStation);
+    }
 }

src/main/java/nextstep/subway/applicaion/dto/FavoriteRequest.java

@@ -0,0 +1,19 @@
+package nextstep.subway.applicaion.dto;
+
+public class FavoriteRequest {
+    private Long source;
+    private Long target;
+
+    public FavoriteRequest(Long source, Long target) {
+        this.source = source;
+        this.target = target;
+    }
+
+    public Long getSource() {
+        return source;
+    }
+
+    public Long getTarget() {
+        return target;
+    }
+}

src/main/java/nextstep/subway/applicaion/dto/FavoriteResponse.java

@@ -0,0 +1,39 @@
+package nextstep.subway.applicaion.dto;
+
+import nextstep.subway.domain.Favorite;
+
+public class FavoriteResponse {
+    private Long id;
+    private Long memberId;
+    private StationResponse source;
+    private StationResponse target;
+
+    private FavoriteResponse(Long id, Long memberId,
+        StationResponse source, StationResponse target) {
+        this.id = id;
+        this.memberId = memberId;
+        this.source = source;
+        this.target = target;
+    }
+
+    public static FavoriteResponse from(Favorite favorite) {
+        return new FavoriteResponse(favorite.getId(), favorite.getMemberId(),
+            StationResponse.of(favorite.getSource()), StationResponse.of(favorite.getTarget()));
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public Long getMemberId() {
+        return memberId;
+    }
+
+    public StationResponse getSource() {
+        return source;
+    }
+
+    public StationResponse getTarget() {
+        return target;
+    }
+}

src/main/java/nextstep/subway/domain/Favorite.java

@@ -0,0 +1,61 @@
+package nextstep.subway.domain;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.ManyToOne;
+
+@Entity
+public class Favorite {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "member_id")
+    private Long memberId;
+
+    @JoinColumn(name = "source_id")
+    @ManyToOne
+    private Station source;
+
+    @JoinColumn(name = "target_id")
+    @ManyToOne
+    private Station target;
+
+    private Favorite(Long memberId, Station source, Station target) {
+        this.memberId = memberId;
+        this.source = source;
+        this.target = target;
+    }
+
+    protected Favorite() {
+
+    }
+
+    public static Favorite of(Long memberId, Station source, Station target) {
+        return new Favorite(memberId, source, target);
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public Long getMemberId() {
+        return memberId;
+    }
+
+    public Station getSource() {
+        return source;
+    }
+
+    public Station getTarget() {
+        return target;
+    }
+
+    public boolean hasPermission(Long memberId) {
+        return this.memberId.equals(memberId);
+    }
+}

src/main/java/nextstep/subway/domain/FavoriteRepository.java

@@ -0,0 +1,8 @@
+package nextstep.subway.domain;
+
+import java.util.List;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface FavoriteRepository extends JpaRepository<Favorite, Long> {
+    List<Favorite> findAllByMemberId(Long memberId);
+}

src/main/java/nextstep/subway/domain/SubwayMap.java

@@ -1,5 +1,6 @@
 package nextstep.subway.domain;
 
+import java.util.Optional;
 import org.jgrapht.GraphPath;
 import org.jgrapht.alg.shortestpath.DijkstraShortestPath;
 import org.jgrapht.graph.SimpleDirectedWeightedGraph;
@@ -22,6 +23,11 @@ public Path findPath(Station source, Station target) {
         DijkstraShortestPath<Station, SectionEdge> dijkstraShortestPath = new DijkstraShortestPath<>(graph);
         GraphPath<Station, SectionEdge> result = dijkstraShortestPath.getPath(source, target);
 
+        Optional.ofNullable(result)
+            .orElseThrow(() -> {
+                throw new IllegalArgumentException("출발역과 도착역이 연결되어 있지 않습니다.");
+            });
+
         List<Section> sections = result.getEdgeList().stream()
                 .map(it -> it.getSection())
                 .collect(Collectors.toList());

src/main/java/nextstep/subway/ui/FavoriteController.java

@@ -0,0 +1,49 @@
+package nextstep.subway.ui;
+
+import java.net.URI;
+import java.util.List;
+import nextstep.auth.authorization.AuthenticationPrincipal;
+import nextstep.member.domain.LoginMember;
+import nextstep.subway.applicaion.FavoriteService;
+import nextstep.subway.applicaion.dto.FavoriteRequest;
+import nextstep.subway.applicaion.dto.FavoriteResponse;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/favorites")
+public class FavoriteController {
+
+    private final FavoriteService favoriteService;
+
+    public FavoriteController(FavoriteService favoriteService) {
+        this.favoriteService = favoriteService;
+    }
+
+    @PostMapping
+    public ResponseEntity<FavoriteResponse> createFavorite(
+        @AuthenticationPrincipal LoginMember loginMember,
+        @RequestBody FavoriteRequest favoriteRequest) {
+        FavoriteResponse favoriteResponse = favoriteService.createFavorite(favoriteRequest, loginMember.getId());
+        return ResponseEntity.created(URI.create("/favorites/" + favoriteResponse.getId())).body(favoriteResponse);
+    }
+
+    @GetMapping
+    public ResponseEntity<List<FavoriteResponse>> getFavorites(@AuthenticationPrincipal LoginMember loginMember) {
+        List<FavoriteResponse> favoriteResponses = favoriteService.findFavorites(loginMember.getId());
+        return ResponseEntity.ok(favoriteResponses);
+    }
+
+    @DeleteMapping("/{favoriteId}")
+    public ResponseEntity<Void> deleteFavorite(@AuthenticationPrincipal LoginMember loginMember, @PathVariable Long favoriteId) {
+        favoriteService.deleteFavorite(favoriteId, loginMember.getId());
+        return ResponseEntity.noContent().build();
+    }
+
+}