[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,86 @@
+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) {
+        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 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 bookmarkId) {
+        validateBookmarkDeletingPermission(authMember, bookmarkId);
+
+        bookmarkRepository.deleteById(bookmarkId);
+    }
+
+    private void validateBookmarkDeletingPermission(AuthMember authMember, Long bookmarkId) {
+        boolean canDelete = bookmarkRepository.existsByIdAndMemberId(
+                bookmarkId,
+                authMember.getMemberId()
+        );
+
+        if (canDelete) {
+            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,36 @@
+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.bookmark.dto.response.BookmarkResponse;
+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<BookmarkResponse> findAllTopicsInBookmark(AuthMember authMember) {
+        validateNonExistsMember(authMember);
+        List<Bookmark> bookmark = bookmarkRepository.findAllByMemberId(authMember.getMemberId());
+
+        return bookmark.stream()
+                .map(BookmarkResponse::from)
+                .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,14 @@
+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 existsByIdAndMemberId(Long id, Long memberId);
+
+}

backend/src/main/java/com/mapbefine/mapbefine/bookmark/dto/response/BookmarkResponse.java

@@ -0,0 +1,31 @@
+package com.mapbefine.mapbefine.bookmark.dto.response;
+
+import com.mapbefine.mapbefine.bookmark.domain.Bookmark;
+import com.mapbefine.mapbefine.topic.domain.Topic;
+import com.mapbefine.mapbefine.topic.domain.TopicInfo;
+import java.time.LocalDateTime;
+
+public record BookmarkResponse(
+        Long id,
+        Long topicId,
+        String name,
+        String image,
+        Integer pinCount,
+        LocalDateTime updatedAt
+) {
+
+    public static BookmarkResponse from(Bookmark bookmark) {
+        Topic topic = bookmark.getTopic();
+        TopicInfo topicInfo = topic.getTopicInfo();
+
+        return new BookmarkResponse(
+                bookmark.getId(),
+                topic.getId(),
+                topicInfo.getName(),
+                topicInfo.getImageUrl(),
+                topic.countPins(),
+                topic.getUpdatedAt()
+        );
+    }
+
+}

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

@@ -0,0 +1,73 @@
+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.bookmark.dto.response.BookmarkResponse;
+import com.mapbefine.mapbefine.common.interceptor.LoginRequired;
+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.PathVariable;
+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("/members/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("/members/bookmarks/" + bookmarkId)).build();
+    }
+
+    @LoginRequired
+    @GetMapping
+    public ResponseEntity<List<BookmarkResponse>> findAllTopicsInBookmark(AuthMember authMember) {
+        List<BookmarkResponse> responses = bookmarkQueryService.findAllTopicsInBookmark(authMember);
+
+        return ResponseEntity.ok(responses);
+    }
+
+    @LoginRequired
+    @DeleteMapping("{bookmarkId}")
+    public ResponseEntity<Void> deleteTopicInBookmark(
+            AuthMember authMember,
+            @PathVariable Long bookmarkId
+    ) {
+        bookmarkCommandService.deleteTopicInBookmark(authMember, bookmarkId);
+
+        return ResponseEntity.noContent().build();
+    }
+
+    @LoginRequired
+    @DeleteMapping
+    public ResponseEntity<Void> deleteAllTopicsInBookmark(AuthMember authMember) {
+        bookmarkCommandService.deleteAllBookmarks(authMember);
+
+        return ResponseEntity.noContent().build();
+    }
+
+}

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());
 

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

@@ -57,7 +57,7 @@ public List<MemberResponse> findAll() {
     }
 
     public List<TopicResponse> findTopicsByMember(AuthMember authMember) {
-        validateNonExistsMember(authMember.getMemberId());
+        validateNonExistsMember(authMember);
         List<Topic> topicsByCreator = topicRepository.findByCreatorId(authMember.getMemberId());
 
         return topicsByCreator.stream()
@@ -66,16 +66,16 @@ public List<TopicResponse> findTopicsByMember(AuthMember authMember) {
     }
 
     public List<PinResponse> findPinsByMember(AuthMember authMember) {
-        validateNonExistsMember(authMember.getMemberId());
+        validateNonExistsMember(authMember);
         List<Pin> pinsByCreator = pinRepository.findByCreatorId(authMember.getMemberId());
 
         return pinsByCreator.stream()
                 .map(PinResponse::from)
                 .toList();
     }
-    
-    public void validateNonExistsMember(Long memberId) {
-        if (Objects.isNull(memberId)) {
+
+    public void validateNonExistsMember(AuthMember authMember) {
+        if (Objects.isNull(authMember.getMemberId())) {
             throw new IllegalArgumentException("존재하지 않는 유저입니다.");
         }
     }
@@ -91,7 +91,8 @@ public List<MemberTopicPermissionResponse> findAllWithPermission(Long topicId) {
     }
 
     public MemberTopicPermissionDetailResponse findMemberTopicPermissionById(Long permissionId) {
-        MemberTopicPermission memberTopicPermission = memberTopicPermissionRepository.findById(permissionId)
+        MemberTopicPermission memberTopicPermission = memberTopicPermissionRepository.findById(
+                        permissionId)
                 .orElseThrow(NoSuchElementException::new);
 
         return MemberTopicPermissionDetailResponse.from(memberTopicPermission);