[BE] feature/#264 토픽에 대한 즐겨찾기 API

backend/src/docs/asciidoc/bookmark.adoc

@@ -0,0 +1,15 @@
+== 즐겨찾기
+
+=== 토픽을 유저의 즐겨찾기에 추가
+
+operation::bookmark-controller-test/add-topic-in-bookmark[snippets='http-request,http-response']
+
+=== 유저의 토픽 즐겨찾기 목록 조회
+
+operation::bookmark-controller-test/find-topics-in-bookmark[snippets='http-request,http-response']
+
+=== 유저의 토픽 즐겨찾기 단일 삭제
+operation::bookmark-controller-test/delete-topic-in-bookmark[snippets='http-request,http-response']
+
+=== 유저의 토픽 즐겨찾기 전체 삭제
+operation::bookmark-controller-test/delete-all-topics-in-bookmark[snippets='http-request,http-response']

backend/src/docs/asciidoc/index.adoc

@@ -11,3 +11,4 @@ toc::[]
 include::topic.adoc[]
 include::pin.adoc[]
 include::member.adoc[]
+include::bookmark.adoc[]

backend/src/docs/asciidoc/member.adoc

@@ -34,4 +34,4 @@ operation::member-controller-test/find-pins-by-member[snippets='http-request,htt
 
 === 유저가 만든 토픽 조회
 
-operation::member-controller-test/find-topics-by-member[snippets='http-request,http-response']
+operation::member-controller-test/find-topics-by-member[snippets='http-request,http-response']

backend/src/main/java/com/mapbefine/mapbefine/bookmark/application/BookmarkCommandService.java

@@ -0,0 +1,92 @@
+package com.mapbefine.mapbefine.bookmark.application;
+
+import com.mapbefine.mapbefine.auth.domain.AuthMember;
+import com.mapbefine.mapbefine.bookmark.domain.Bookmark;
+import com.mapbefine.mapbefine.bookmark.domain.BookmarkRepository;
+import com.mapbefine.mapbefine.member.domain.Member;
+import com.mapbefine.mapbefine.member.domain.MemberRepository;
+import com.mapbefine.mapbefine.topic.domain.Topic;
+import com.mapbefine.mapbefine.topic.domain.TopicRepository;
+import java.util.NoSuchElementException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@Transactional(readOnly = true)
+public class BookmarkCommandService {
+
+    private final BookmarkRepository bookmarkRepository;
+
+    private final MemberRepository memberRepository;
+
+    private final TopicRepository topicRepository;
+
+    public BookmarkCommandService(
+            BookmarkRepository bookmarkRepository,
+            MemberRepository memberRepository,
+            TopicRepository topicRepository
+    ) {
+        this.bookmarkRepository = bookmarkRepository;
+        this.memberRepository = memberRepository;
+        this.topicRepository = topicRepository;
+    }
+
+    public Long addTopicInBookmark(AuthMember authMember, Long topicId) {
+        validateBookmarkDuplication(authMember, topicId);
+        Topic topic = getTopicById(topicId);
+        validateBookmarkingPermission(authMember, topic);
+        Member member = getMemberById(authMember);
+
+        Bookmark bookmark = Bookmark.createWithAssociatedTopicAndMember(topic, member);
+        bookmarkRepository.save(bookmark);
+
+        return bookmark.getId();
+    }
+
+    private Topic getTopicById(Long topicId) {
+        return topicRepository.findById(topicId)
+                .orElseThrow(() -> new NoSuchElementException("존재하지 않는 토픽입니다."));
+    }
+
+    private void validateBookmarkDuplication(AuthMember authMember, Long topicId) {
+        if (isExistBookmark(authMember, topicId)) {
+            throw new IllegalArgumentException("이미 즐겨찾기로 등록된 토픽입니다.");
+        }
+    }
+
+    private boolean isExistBookmark(AuthMember authMember, Long topicId) {
+        return bookmarkRepository.existsByMemberIdAndTopicId(authMember.getMemberId(), topicId);
+    }
+
+    private void validateBookmarkingPermission(AuthMember authMember, Topic topic) {
+        if (authMember.canRead(topic)) {
+            return;
+        }
+
+        throw new IllegalArgumentException("토픽에 대한 권한이 없어서 즐겨찾기에 추가할 수 없습니다.");
+    }
+
+    private Member getMemberById(AuthMember authMember) {
+        return memberRepository.findById(authMember.getMemberId())
+                .orElseThrow(() -> new NoSuchElementException("존재하지 않는 멤버입니다."));
+    }
+
+    public void deleteTopicInBookmark(AuthMember authMember, Long topicId) {
+        validateBookmarkDeletingPermission(authMember, topicId);
+
+        bookmarkRepository.deleteByMemberIdAndTopicId(authMember.getMemberId(), topicId);
+    }
+
+    private void validateBookmarkDeletingPermission(AuthMember authMember, Long topicId) {
+        if (isExistBookmark(authMember, topicId)) {
+            return;
+        }
+
+        throw new IllegalArgumentException("즐겨찾기 삭제에 대한 권한이 없습니다.");
+    }
+
+    public void deleteAllBookmarks(AuthMember authMember) {
+        bookmarkRepository.deleteAllByMemberId(authMember.getMemberId());
+    }
+
+}

backend/src/main/java/com/mapbefine/mapbefine/bookmark/application/BookmarkQueryService.java

@@ -0,0 +1,37 @@
+package com.mapbefine.mapbefine.bookmark.application;
+
+import com.mapbefine.mapbefine.auth.domain.AuthMember;
+import com.mapbefine.mapbefine.bookmark.domain.Bookmark;
+import com.mapbefine.mapbefine.bookmark.domain.BookmarkRepository;
+import com.mapbefine.mapbefine.topic.dto.response.TopicResponse;
+import java.util.List;
+import java.util.Objects;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@Transactional(readOnly = true)
+public class BookmarkQueryService {
+
+    private final BookmarkRepository bookmarkRepository;
+
+    public BookmarkQueryService(BookmarkRepository bookmarkRepository) {
+        this.bookmarkRepository = bookmarkRepository;
+    }
+
+    public List<TopicResponse> findAllTopicsInBookmark(AuthMember authMember) {
+        validateNonExistsMember(authMember);
+        List<Bookmark> bookmarks = bookmarkRepository.findAllByMemberId(authMember.getMemberId());
+
+        return bookmarks.stream()
+                .map(bookmark -> TopicResponse.from(bookmark.getTopic(), Boolean.TRUE))
+                .toList();
+    }
+
+    public void validateNonExistsMember(AuthMember authMember) {
+        if (Objects.isNull(authMember.getMemberId())) {
+            throw new IllegalArgumentException("존재하지 않는 유저입니다.");
+        }
+    }
+
+}

backend/src/main/java/com/mapbefine/mapbefine/bookmark/domain/Bookmark.java

@@ -0,0 +1,47 @@
+package com.mapbefine.mapbefine.bookmark.domain;
+
+import com.mapbefine.mapbefine.member.domain.Member;
+import com.mapbefine.mapbefine.topic.domain.Topic;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Getter
+public class Bookmark {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne
+    @JoinColumn(name = "topic_id", nullable = false)
+    private Topic topic;
+
+    @ManyToOne
+    @JoinColumn(name = "member_id", nullable = false)
+    private Member member;
+
+    private Bookmark(Topic topic, Member member) {
+        this.topic = topic;
+        this.member = member;
+    }
+
+    // TODO: 2023/08/11 필요한 검증이 무엇이 있을까.. 현재로썬 외부에서 검증하는 방법 밖에 ?
+    public static Bookmark createWithAssociatedTopicAndMember(Topic topic, Member member) {
+        Bookmark bookmark = new Bookmark(topic, member);
+
+        topic.addBookmark(bookmark);
+        member.addBookmark(bookmark);
+
+        return bookmark;
+    }
+
+}

backend/src/main/java/com/mapbefine/mapbefine/bookmark/domain/BookmarkRepository.java

@@ -0,0 +1,15 @@
+package com.mapbefine.mapbefine.bookmark.domain;
+
+import java.util.List;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface BookmarkRepository extends JpaRepository<Bookmark, Long> {
+
+    List<Bookmark> findAllByMemberId(Long memberId);
+
+    void deleteAllByMemberId(Long memberId);
+
+    boolean existsByMemberIdAndTopicId(Long memberId, Long topicId);
+
+    void deleteByMemberIdAndTopicId(Long memberId, Long topicId);
+}

backend/src/main/java/com/mapbefine/mapbefine/bookmark/presentation/BookmarkController.java

@@ -0,0 +1,64 @@
+package com.mapbefine.mapbefine.bookmark.presentation;
+
+import com.mapbefine.mapbefine.auth.domain.AuthMember;
+import com.mapbefine.mapbefine.bookmark.application.BookmarkCommandService;
+import com.mapbefine.mapbefine.bookmark.application.BookmarkQueryService;
+import com.mapbefine.mapbefine.common.interceptor.LoginRequired;
+import com.mapbefine.mapbefine.topic.dto.response.TopicResponse;
+import java.net.URI;
+import java.util.List;
+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.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/bookmarks")
+public class BookmarkController {
+
+    private final BookmarkCommandService bookmarkCommandService;
+
+    private final BookmarkQueryService bookmarkQueryService;
+
+    public BookmarkController(
+            BookmarkCommandService bookmarkCommandService,
+            BookmarkQueryService bookmarkQueryService
+    ) {
+        this.bookmarkCommandService = bookmarkCommandService;
+        this.bookmarkQueryService = bookmarkQueryService;
+    }
+
+    @LoginRequired
+    @PostMapping
+    public ResponseEntity<Void> addTopicInBookmark(
+            AuthMember authMember,
+            @RequestParam Long topicId
+    ) {
+        Long bookmarkId = bookmarkCommandService.addTopicInBookmark(authMember, topicId);
+
+        return ResponseEntity.created(URI.create("/bookmarks/" + bookmarkId)).build();
+    }
+
+    @LoginRequired
+    @GetMapping
+    public ResponseEntity<List<TopicResponse>> findAllTopicsInBookmark(AuthMember authMember) {
+        List<TopicResponse> responses = bookmarkQueryService.findAllTopicsInBookmark(authMember);
+
+        return ResponseEntity.ok(responses);
+    }
+
+    @LoginRequired
+    @DeleteMapping
+    public ResponseEntity<Void> deleteTopicInBookmark(
+            AuthMember authMember,
+            @RequestParam Long topicId
+    ) {
+        bookmarkCommandService.deleteTopicInBookmark(authMember, topicId);
+
+        return ResponseEntity.noContent().build();
+    }
+
+}

backend/src/main/java/com/mapbefine/mapbefine/location/application/LocationQueryService.java

@@ -4,6 +4,8 @@
 import static java.util.stream.Collectors.groupingBy;
 
 import com.mapbefine.mapbefine.auth.domain.AuthMember;
+import com.mapbefine.mapbefine.bookmark.domain.Bookmark;
+import com.mapbefine.mapbefine.bookmark.domain.BookmarkRepository;
 import com.mapbefine.mapbefine.location.domain.Coordinate;
 import com.mapbefine.mapbefine.location.domain.Location;
 import com.mapbefine.mapbefine.location.domain.LocationRepository;
@@ -24,9 +26,14 @@ public class LocationQueryService {
     private static final double NEAR_DISTANCE_METERS = 3000;
 
     private final LocationRepository locationRepository;
+    private final BookmarkRepository bookmarkRepository;
 
-    public LocationQueryService(LocationRepository locationRepository) {
+    public LocationQueryService(
+            LocationRepository locationRepository,
+            BookmarkRepository bookmarkRepository
+    ) {
         this.locationRepository = locationRepository;
+        this.bookmarkRepository = bookmarkRepository;
     }
 
     public List<TopicResponse> findNearbyTopicsSortedByPinCount(
@@ -52,12 +59,31 @@ private Map<Topic, Long> countPinsByTopicInLocations(List<Location> locations) {
                 .collect(groupingBy(Pin::getTopic, counting()));
     }
 
-    private List<TopicResponse> sortTopicsByPinCounts(Map<Topic, Long> topicCounts, AuthMember member) {
+    private List<TopicResponse> sortTopicsByPinCounts(
+            Map<Topic, Long> topicCounts,
+            AuthMember member
+    ) {
+        List<Topic> bookmarkedTopics = getBookmarkedTopics(member);
+
         return topicCounts.entrySet().stream()
                 .filter(entry -> member.canRead(entry.getKey()))
                 .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
-                .map(entry -> TopicResponse.from(entry.getKey()))
+                .map(entry -> {
+                    Topic topic = entry.getKey();
+
+                    return TopicResponse.from(topic, isInBookmark(bookmarkedTopics, topic));
+                })
                 .toList();
     }
 
+    private List<Topic> getBookmarkedTopics(AuthMember member) {
+        return bookmarkRepository.findAllByMemberId(member.getMemberId())
+                .stream()
+                .map(Bookmark::getTopic)
+                .toList();
+    }
+
+    private boolean isInBookmark(List<Topic> bookmarkedTopics, Topic topic) {
+        return bookmarkedTopics.contains(topic);
+    }
 }

backend/src/main/java/com/mapbefine/mapbefine/member/application/MemberCommandService.java

@@ -58,7 +58,10 @@ private void validateUniqueEmail(String email) {
         }
     }
 
-    public Long saveMemberTopicPermission(AuthMember authMember, MemberTopicPermissionCreateRequest request) {
+    public Long saveMemberTopicPermission(
+            AuthMember authMember,
+            MemberTopicPermissionCreateRequest request
+    ) {
         Member member = memberRepository.findById(request.memberId())
                 .orElseThrow(NoSuchElementException::new);
         Topic topic = topicRepository.findById(request.topicId())
@@ -107,8 +110,9 @@ private void validateDuplicatePermission(Long topicId, Long memberId) {
     }
 
     public void deleteMemberTopicPermission(AuthMember authMember, Long permissionId) {
-        MemberTopicPermission memberTopicPermission = memberTopicPermissionRepository.findById(permissionId)
-                .orElseThrow(NoSuchElementException::new);
+        MemberTopicPermission memberTopicPermission =
+                memberTopicPermissionRepository.findById(permissionId)
+                        .orElseThrow(NoSuchElementException::new);
 
         validateMemberCanTopicUpdate(authMember, memberTopicPermission.getTopic());