🚀 3단계 - 즐겨찾기 기능 구현

src/main/java/nextstep/auth/secured/SecuredAnnotationChecker.java

@@ -1,5 +1,7 @@
 package nextstep.auth.secured;
 
+import java.util.Optional;
+import nextstep.auth.authentication.execption.AuthenticationException;
 import nextstep.auth.context.Authentication;
 import nextstep.auth.context.SecurityContextHolder;
 import org.aspectj.lang.JoinPoint;
@@ -23,7 +25,9 @@ public void checkAuthorities(JoinPoint joinPoint) {
         Secured secured = method.getAnnotation(Secured.class);
         List<String> values = Arrays.stream(secured.value()).collect(Collectors.toList());
 
-        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        Authentication authentication = Optional.ofNullable(SecurityContextHolder.getContext().getAuthentication())
+                .orElseThrow(() -> new AuthenticationException("인증에 실패하였습니다."));
+
         authentication.getAuthorities().stream()
                 .filter(values::contains)
                 .findFirst()

src/main/java/nextstep/member/application/FavoriteService.java

@@ -0,0 +1,57 @@
+package nextstep.member.application;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import nextstep.member.application.dto.FavoriteRequest;
+import nextstep.member.application.dto.FavoriteResponse;
+import nextstep.member.domain.Favorite;
+import nextstep.member.domain.FavoriteRepository;
+import nextstep.member.domain.LoginMember;
+import nextstep.member.domain.Member;
+import nextstep.subway.applicaion.StationService;
+import nextstep.subway.domain.Station;
+import org.springframework.stereotype.Service;
+
+@Service
+public class FavoriteService {
+    private final MemberService memberService;
+    private final StationService stationService;
+    private final FavoriteRepository favoriteRepository;
+
+    public FavoriteService(MemberService memberService, StationService stationService,
+                           FavoriteRepository favoriteRepository) {
+        this.memberService = memberService;
+        this.stationService = stationService;
+        this.favoriteRepository = favoriteRepository;
+    }
+
+    public Long saveFavorite(LoginMember loginMember, FavoriteRequest favoriteRequest) {
+        Member member = memberService.findByEmail(loginMember.getEmail());
+
+        Station source = stationService.findById(favoriteRequest.getSource());
+        Station target = stationService.findById(favoriteRequest.getTarget());
+
+        Favorite favorite = member.addFavorite(source, target);
+
+        return favoriteRepository.save(favorite).getId();
+    }
+
+    public List<FavoriteResponse> findFavoriteResponses(LoginMember loginMember) {
+        Member member = memberService.findByEmail(loginMember.getEmail());
+        List<Favorite> favorites = member.getFavorites();
+
+        return favorites.stream()
+                .map(it -> FavoriteResponse.of(it, it.getSource(), it.getTarget()))
+                .collect(Collectors.toList());
+    }
+
+    public void deleteFavorite(LoginMember loginMember, Long favoriteId) {
+        Favorite favorite = favoriteRepository.findById(favoriteId)
+                .orElseThrow(IllegalArgumentException::new);
+
+        Member member = memberService.findByEmail(loginMember.getEmail());
+        member.removeFavorite(favorite);
+
+        favoriteRepository.delete(favorite);
+    }
+}

src/main/java/nextstep/member/application/MemberService.java

@@ -46,4 +46,8 @@ public void deleteMember(Long id) {
     public void deleteMember(String email) {
         memberRepository.deleteByEmail(email);
     }
+
+    public Member findByEmail(String email) {
+        return memberRepository.findByEmail(email).orElseThrow(IllegalArgumentException::new);
+    }
 }

src/main/java/nextstep/member/application/dto/FavoriteRequest.java

@@ -0,0 +1,22 @@
+package nextstep.member.application.dto;
+
+public class FavoriteRequest {
+    private Long source;
+    private Long target;
+
+    public FavoriteRequest() {
+    }
+
+    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/member/application/dto/FavoriteResponse.java

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

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

@@ -0,0 +1,50 @@
+package nextstep.member.domain;
+
+import nextstep.member.domain.exception.FavoriteException;
+import nextstep.subway.domain.Station;
+
+import javax.persistence.*;
+
+import static nextstep.member.domain.exception.FavoriteException.SAME_SOURCE_AND_TARGET;
+
+@Entity
+public class Favorite {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne
+    @JoinColumn(name = "source_id")
+    private Station source;
+
+    @ManyToOne
+    @JoinColumn(name = "target_id")
+    private Station target;
+
+    protected Favorite() {
+    }
+
+    public Favorite(Station source, Station target) {
+        if (source.isSame(target)) {
+            throw new FavoriteException(SAME_SOURCE_AND_TARGET);
+        }
+        this.source = source;
+        this.target = target;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public Station getSource() {
+        return source;
+    }
+
+    public Station getTarget() {
+        return target;
+    }
+
+    public boolean hasDuplicateFavorite(Station target, Station source) {
+        return this.target == target && this.source == source;
+    }
+}

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

@@ -0,0 +1,8 @@
+package nextstep.member.domain;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface FavoriteRepository extends JpaRepository<Favorite, Long> {
+}

src/main/java/nextstep/member/domain/Favorites.java

@@ -0,0 +1,43 @@
+package nextstep.member.domain;
+
+import nextstep.member.domain.exception.FavoriteException;
+import nextstep.subway.domain.Section;
+import nextstep.subway.domain.Station;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Embeddable;
+import javax.persistence.JoinColumn;
+import javax.persistence.OneToMany;
+import java.util.ArrayList;
+import java.util.List;
+
+import static nextstep.member.domain.exception.FavoriteException.DUPLICATION_FAVORITE;
+
+@Embeddable
+public class Favorites {
+    @OneToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE}, orphanRemoval = true)
+    @JoinColumn(name = "member_id")
+    private List<Favorite> favorites = new ArrayList<>();
+
+    public List<Favorite> getFavorites() {
+        return this.favorites;
+    }
+
+    public void add(Favorite favorite) {
+        checkDuplicationFavorite(favorite);
+        this.favorites.add(favorite);
+    }
+
+    public void delete(Favorite favorite) {
+        this.favorites.remove(favorite);
+    }
+
+    private void checkDuplicationFavorite(Favorite favorite) {
+        favorites.stream()
+                .filter(it -> it.hasDuplicateFavorite(favorite.getTarget(), favorite.getSource()))
+                .findFirst()
+                .ifPresent(it -> {
+                    throw new FavoriteException(DUPLICATION_FAVORITE);
+                });
+    }
+}

src/main/java/nextstep/member/domain/Member.java

@@ -1,7 +1,17 @@
 package nextstep.member.domain;
 
-import javax.persistence.*;
 import java.util.List;
+import javax.persistence.CollectionTable;
+import javax.persistence.Column;
+import javax.persistence.ElementCollection;
+import javax.persistence.Embedded;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import nextstep.subway.domain.Station;
 
 @Entity
 public class Member {
@@ -11,6 +21,8 @@ public class Member {
     private String email;
     private String password;
     private Integer age;
+    @Embedded
+    private Favorites favorites = new Favorites();
     @ElementCollection(fetch = FetchType.EAGER)
     @CollectionTable(
             name = "MEMBER_ROLE",
@@ -56,6 +68,22 @@ public List<String> getRoles() {
         return roles;
     }
 
+    public List<Favorite> getFavorites() {
+        return favorites.getFavorites();
+    }
+
+    public Favorite addFavorite(Station source, Station target) {
+        Favorite favorite = new Favorite(source, target);
+
+        favorites.add(favorite);
+
+        return favorite;
+    }
+
+    public void removeFavorite(Favorite favorite) {
+        favorites.delete(favorite);
+    }
+
     public void update(Member member) {
         this.email = member.email;
         this.password = member.password;

src/main/java/nextstep/member/domain/exception/FavoriteException.java

@@ -0,0 +1,10 @@
+package nextstep.member.domain.exception;
+
+public class FavoriteException extends IllegalArgumentException {
+    public static final String SAME_SOURCE_AND_TARGET = "즐겨찾기의 출발점과 도착역이 같을 수 없습니다.";
+    public static final String DUPLICATION_FAVORITE = "이미 등록되어있는 즐겨찾기입니다.";
+
+    public FavoriteException(String message) {
+        super(message);
+    }
+}

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

@@ -0,0 +1,51 @@
+package nextstep.member.ui;
+
+import java.net.URI;
+import java.util.List;
+import nextstep.auth.authorization.AuthenticationPrincipal;
+import nextstep.auth.secured.Secured;
+import nextstep.member.application.FavoriteService;
+import nextstep.member.application.dto.FavoriteRequest;
+import nextstep.member.application.dto.FavoriteResponse;
+import nextstep.member.domain.LoginMember;
+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
+    @Secured("ROLE_MEMBER")
+    public ResponseEntity<Void> createFavorite(@AuthenticationPrincipal LoginMember loginMember,
+                                               @RequestBody FavoriteRequest favoriteRequest) {
+        Long favoriteId = favoriteService.saveFavorite(loginMember, favoriteRequest);
+        return ResponseEntity.created(URI.create("/favorites/" + favoriteId)).build();
+    }
+
+    @GetMapping
+    @Secured("ROLE_MEMBER")
+    public ResponseEntity<List<FavoriteResponse>> showFavorites(@AuthenticationPrincipal LoginMember loginMember) {
+        List<FavoriteResponse> responses = favoriteService.findFavoriteResponses(loginMember);
+        return ResponseEntity.ok().body(responses);
+    }
+
+    @DeleteMapping("/{favoriteId}")
+    @Secured("ROLE_MEMBER")
+    public ResponseEntity<Void> deleteFavorite(@AuthenticationPrincipal LoginMember loginMember,
+                                               @PathVariable Long favoriteId) {
+        favoriteService.deleteFavorite(loginMember, favoriteId);
+        return ResponseEntity.noContent().build();
+    }
+}

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

@@ -4,6 +4,7 @@
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
+import java.util.Objects;
 
 @Entity
 public class Station {
@@ -26,4 +27,9 @@ public Long getId() {
     public String getName() {
         return name;
     }
+
+    public boolean isSame(Station target) {
+        return Objects.equals(this.id, target.getId()) &&
+                Objects.equals(this.name, target.getName());
+    }
 }