[BE] feature/#251 최신 지도 조회 API 구현

backend/src/main/java/com/mapbefine/mapbefine/atlas/application/AtlasCommandService.java

@@ -0,0 +1,74 @@
+package com.mapbefine.mapbefine.atlas.application;
+
+import com.mapbefine.mapbefine.atlas.domain.Atlas;
+import com.mapbefine.mapbefine.atlas.domain.AtlasRepository;
+import com.mapbefine.mapbefine.auth.domain.AuthMember;
+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
+public class AtlasCommandService {
+
+    private final TopicRepository topicRepository;
+    private final MemberRepository memberRepository;
+    private final AtlasRepository atlasRepository;
+
+    public AtlasCommandService(
+            TopicRepository topicRepository,
+            MemberRepository memberRepository,
+            AtlasRepository atlasRepository
+    ) {
+        this.topicRepository = topicRepository;
+        this.memberRepository = memberRepository;
+        this.atlasRepository = atlasRepository;
+    }
+
+    public void addTopic(AuthMember authMember, Long topicId) {
+        Long memberId = authMember.getMemberId();
+
+        // TODO: 2023/08/10 memberId가 없는 경우 터짐 (Guest인 경우) (단, loginRequired로 일차적으로 막아놓긴 함)
+        if (isTopicAlreadyAdded(topicId, memberId)) {
+            return;
+        }
+
+        Topic topic = findTopicById(topicId);
+        validateReadPermission(authMember, topic);
+
+        Member member = findMemberById(memberId);
+
+        Atlas atlas = Atlas.from(topic, member);
+        atlasRepository.save(atlas);
+    }
+
+    private boolean isTopicAlreadyAdded(Long topicId, Long memberId) {
+        return atlasRepository.existsByMemberIdAndTopicId(memberId, topicId);
+    }
+
+    private Member findMemberById(Long memberId) {
+        return memberRepository.findById(memberId)
+                .orElseThrow(NoSuchElementException::new);
+    }
+
+    private Topic findTopicById(Long topicId) {
+        return topicRepository.findById(topicId)
+                .orElseThrow(NoSuchElementException::new);
+    }
+
+    private void validateReadPermission(AuthMember authMember, Topic topic) {
+        if (authMember.canRead(topic)) {
+            return;
+        }
+        throw new IllegalArgumentException("해당 지도에 접근권한이 없습니다.");
+    }
+
+    public void removeTopic(AuthMember authMember, Long topicId) {
+        atlasRepository.deleteByMemberIdAndTopicId(authMember.getMemberId(), topicId);
+    }
+
+}

backend/src/main/java/com/mapbefine/mapbefine/atlas/application/AtlasQueryService.java

@@ -0,0 +1,30 @@
+package com.mapbefine.mapbefine.atlas.application;
+
+import com.mapbefine.mapbefine.atlas.domain.Atlas;
+import com.mapbefine.mapbefine.atlas.domain.AtlasRepository;
+import com.mapbefine.mapbefine.auth.domain.AuthMember;
+import com.mapbefine.mapbefine.topic.dto.response.TopicResponse;
+import java.util.List;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@Transactional(readOnly = true)
+public class AtlasQueryService {
+
+    private final AtlasRepository atlasRepository;
+
+    public AtlasQueryService(AtlasRepository atlasRepository) {
+        this.atlasRepository = atlasRepository;
+    }
+
+    public List<TopicResponse> findTopicsByMember(AuthMember member) {
+        return atlasRepository.findAllByMemberId(member.getMemberId())
+                .stream()
+                .map(Atlas::getTopic)
+                .filter(member::canRead)
+                .map(TopicResponse::from)
+                .toList();
+    }
+
+}

backend/src/main/java/com/mapbefine/mapbefine/atlas/domain/Atlas.java

@@ -0,0 +1,50 @@
+package com.mapbefine.mapbefine.atlas.domain;
+
+import static lombok.AccessLevel.PROTECTED;
+
+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 java.util.Objects;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@NoArgsConstructor(access = PROTECTED)
+@Getter
+public class Atlas {
+
+    @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 Atlas(Topic topic, Member member) {
+        this.topic = topic;
+        this.member = member;
+    }
+
+    public static Atlas from(Topic topic, Member member) {
+        validateNotNull(topic, member);
+        return new Atlas(topic, member);
+    }
+
+    private static void validateNotNull(Topic topic, Member member) {
+        if (Objects.isNull(topic) || Objects.isNull(member)) {
+            throw new IllegalArgumentException("토픽과 멤버는 Null이어선 안됩니다.");
+        }
+    }
+
+}

backend/src/main/java/com/mapbefine/mapbefine/atlas/domain/AtlasRepository.java

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

backend/src/main/java/com/mapbefine/mapbefine/atlas/presentation/AtlasController.java

@@ -0,0 +1,54 @@
+package com.mapbefine.mapbefine.atlas.presentation;
+
+import com.mapbefine.mapbefine.atlas.application.AtlasCommandService;
+import com.mapbefine.mapbefine.atlas.application.AtlasQueryService;
+import com.mapbefine.mapbefine.auth.domain.AuthMember;
+import com.mapbefine.mapbefine.common.interceptor.LoginRequired;
+import com.mapbefine.mapbefine.topic.dto.response.TopicResponse;
+import java.util.List;
+import org.springframework.http.HttpStatus;
+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.RestController;
+
+@RestController
+@RequestMapping("/atlas")
+public class AtlasController {
+
+    private final AtlasCommandService atlasCommandService;
+    private final AtlasQueryService atlasQueryService;
+
+    public AtlasController(AtlasCommandService atlasCommandService, AtlasQueryService atlasQueryService) {
+        this.atlasCommandService = atlasCommandService;
+        this.atlasQueryService = atlasQueryService;
+    }
+
+    @LoginRequired
+    @GetMapping
+    public ResponseEntity<List<TopicResponse>> findTopicsFromAtlas(AuthMember member) {
+        List<TopicResponse> topicResponses = atlasQueryService.findTopicsByMember(member);
+
+        return ResponseEntity.ok(topicResponses);
+    }
+
+    @LoginRequired
+    @PostMapping("/{topicId}")
+    public ResponseEntity<Void> addTopicToAtlas(AuthMember authMember, @PathVariable Long topicId) {
+        atlasCommandService.addTopic(authMember, topicId);
+
+        return ResponseEntity.status(HttpStatus.CREATED).build();
+    }
+
+    @LoginRequired
+    @DeleteMapping("/{topicId}")
+    public ResponseEntity<Void> removeTopicFromAtlas(AuthMember authMember, @PathVariable Long topicId) {
+        atlasCommandService.removeTopic(authMember, topicId);
+
+        return ResponseEntity.noContent().build();
+    }
+
+}

backend/src/main/java/com/mapbefine/mapbefine/pin/domain/PinRepository.java

@@ -22,4 +22,5 @@ public interface PinRepository extends JpaRepository<Pin, Long> {
 
     List<Pin> findByCreatorId(Long creatorId);
 
+    List<Pin> findAllByOrderByUpdatedAtDesc();
 }

backend/src/main/java/com/mapbefine/mapbefine/topic/application/TopicQueryService.java

@@ -1,6 +1,8 @@
 package com.mapbefine.mapbefine.topic.application;
 
 import com.mapbefine.mapbefine.auth.domain.AuthMember;
+import com.mapbefine.mapbefine.pin.domain.Pin;
+import com.mapbefine.mapbefine.pin.domain.PinRepository;
 import com.mapbefine.mapbefine.topic.domain.Topic;
 import com.mapbefine.mapbefine.topic.domain.TopicRepository;
 import com.mapbefine.mapbefine.topic.dto.response.TopicDetailResponse;
@@ -13,9 +15,11 @@
 @Transactional(readOnly = true)
 public class TopicQueryService {
 
+    private final PinRepository pinRepository;
     private final TopicRepository topicRepository;
 
-    public TopicQueryService(final TopicRepository topicRepository) {
+    public TopicQueryService(PinRepository pinRepository, TopicRepository topicRepository) {
+        this.pinRepository = pinRepository;
         this.topicRepository = topicRepository;
     }
 
@@ -75,4 +79,13 @@ private void validateReadableTopics(AuthMember member, List<Topic> topics) {
         }
     }
 
+    public List<TopicResponse> findAllByOrderByUpdatedAtDesc(AuthMember member) {
+        return pinRepository.findAllByOrderByUpdatedAtDesc()
+                .stream()
+                .map(Pin::getTopic)
+                .distinct()
+                .filter(member::canRead)
+                .map(TopicResponse::from)
+                .toList();
+    }
 }

backend/src/main/java/com/mapbefine/mapbefine/topic/presentation/TopicController.java

@@ -85,6 +85,13 @@ public ResponseEntity<List<TopicDetailResponse>> findByIds(
         return ResponseEntity.ok(responses);
     }
 
+    @GetMapping("/newest")
+    public ResponseEntity<List<TopicResponse>> findAllByOrderByUpdatedAtDesc(AuthMember member) {
+        List<TopicResponse> responses = topicQueryService.findAllByOrderByUpdatedAtDesc(member);
+
+        return ResponseEntity.ok(responses);
+    }
+
     @LoginRequired
     @PutMapping("/{topicId}")
     public ResponseEntity<Void> update(

backend/src/test/java/com/mapbefine/mapbefine/atlas/AtlasIntegrationTest.java

@@ -0,0 +1,104 @@
+package com.mapbefine.mapbefine.atlas;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.http.HttpHeaders.AUTHORIZATION;
+
+import com.mapbefine.mapbefine.atlas.domain.Atlas;
+import com.mapbefine.mapbefine.atlas.domain.AtlasRepository;
+import com.mapbefine.mapbefine.common.IntegrationTest;
+import com.mapbefine.mapbefine.member.MemberFixture;
+import com.mapbefine.mapbefine.member.domain.Member;
+import com.mapbefine.mapbefine.member.domain.MemberRepository;
+import com.mapbefine.mapbefine.member.domain.Role;
+import com.mapbefine.mapbefine.topic.TopicFixture;
+import com.mapbefine.mapbefine.topic.domain.Topic;
+import com.mapbefine.mapbefine.topic.domain.TopicRepository;
+import io.restassured.RestAssured;
+import io.restassured.response.ExtractableResponse;
+import io.restassured.response.Response;
+import org.apache.tomcat.util.codec.binary.Base64;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+
+public class AtlasIntegrationTest extends IntegrationTest {
+
+    @Autowired
+    TopicRepository topicRepository;
+
+    @Autowired
+    MemberRepository memberRepository;
+
+    @Autowired
+    AtlasRepository atlasRepository;
+
+    private Member member;
+    private Topic topic;
+    private String authHeader;
+
+    @BeforeEach
+    void setMember() {
+        member = memberRepository.save(
+                MemberFixture.create("other", "[email protected]", Role.USER)
+        );
+        topic = topicRepository.save(TopicFixture.createPublicAndAllMembersTopic(member));
+        authHeader = Base64.encodeBase64String(
+                ("Basic " + member.getMemberInfo().getEmail()).getBytes()
+        );
+    }
+
+    @Test
+    @DisplayName("모아보기에 추가되어있는 지도 목록을 조회한다")
+    void findTopicsFromAtlas_Success() {
+        // when
+        ExtractableResponse<Response> response = RestAssured.given()
+                .log().all()
+                .header(AUTHORIZATION, authHeader)
+                .when().get("/atlas")
+                .then().log().all()
+                .extract();
+
+        // then
+        assertThat(response.statusCode()).isEqualTo(HttpStatus.OK.value());
+    }
+
+    @Test
+    @DisplayName("모아보기에 지도를 추가한다")
+    void addTopicToAtlas_Success() {
+        //given
+        Long topicId = topic.getId();
+
+        // when
+        ExtractableResponse<Response> response = RestAssured.given()
+                .log().all()
+                .header(AUTHORIZATION, authHeader)
+                .when().post("/atlas/{topicId}", topicId)
+                .then().log().all()
+                .extract();
+
+        // then
+        assertThat(response.statusCode()).isEqualTo(HttpStatus.CREATED.value());
+    }
+
+
+    @Test
+    @DisplayName("모아보기에 추가되어있는 지도를 삭제한다")
+    void removeTopicFromAtlas_Success() {
+        //given
+        Long topicId = topic.getId();
+        atlasRepository.save(Atlas.from(topic, member));
+
+        // when
+        ExtractableResponse<Response> response = RestAssured.given()
+                .log().all()
+                .header(AUTHORIZATION, authHeader)
+                .when().delete("/atlas/{topicId}", topicId)
+                .then().log().all()
+                .extract();
+
+        // then
+        assertThat(response.statusCode()).isEqualTo(HttpStatus.NO_CONTENT.value());
+    }
+}