[BE] Topic 패키지 관련 코드 리팩토링

backend/src/main/java/com/mapbefine/mapbefine/common/entity/Image.java

@@ -14,25 +14,28 @@
 @Getter
 public class Image {
 
-    private static final String VALID_IMAGE_URL_REGEX = "(http(s?):)([/|.|\\w|\\s|-])*\\.(?:jpg|gif|png)";
+    private static final String IMAGE_URL_REGEX = "(http(s?):)([/|.|\\w|\\s|-])*\\.(?:jpg|gif|png)";
 
-    @Pattern(regexp = VALID_IMAGE_URL_REGEX)
+    @Pattern(regexp = IMAGE_URL_REGEX)
     @Column(nullable = false, length = 2048)
     private String imageUrl;
 
     private Image(String imageUrl) {
         this.imageUrl = imageUrl;
     }
 
-    public static Image of(String imageUrl) {
+    public static Image from(String imageUrl) {
         validateUrl(imageUrl);
+
         return new Image(imageUrl);
     }
 
     private static void validateUrl(String imageUrl) {
-        if (!RegexUtil.matches(VALID_IMAGE_URL_REGEX, imageUrl)) {
-            throw new IllegalArgumentException("잘못된 형식의 URL입니다.");
+        if (RegexUtil.matches(IMAGE_URL_REGEX, imageUrl)) {
+            return;
         }
+
+        throw new IllegalArgumentException("잘못된 형식의 URL입니다.");
     }
 
 }

backend/src/main/java/com/mapbefine/mapbefine/pin/Domain/Pin.java

@@ -16,7 +16,6 @@
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.ManyToOne;
 import jakarta.persistence.OneToMany;
-import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.List;
 import lombok.Getter;
@@ -81,13 +80,19 @@ public void updatePinInfo(String name, String description) {
         pinInfo.update(name, description);
     }
 
-    public Pin copy(Topic topic) {
-        return Pin.createPinAssociatedWithLocationAndTopic(
-                pinInfo.getName(),
-                pinInfo.getDescription(),
-                location,
-                topic
-        );
+    /**
+     * createPinAssociatedWithLocationAndTopic을 재사용하지 않은 이유
+     * 내부적으로 copy를 처리하면, 반환값이 필요 없음 -> 외부에서 반환값을 무시함
+     * 반환값이 있을 경우, topic과의 연관관계를 맺어주지 않은 상태로 반환하고,
+     * 외부에서 해당 연관관계를 맺어주어도 됨 -> 이 방법은 객체가 불안정한 상태라고 판단 됨.
+     */
+
+    public void copyToTopic(Topic otherTopic) {
+        PinInfo copiedPinInfo = PinInfo.of(pinInfo.getName(), pinInfo.getDescription());
+        Pin copiedPin = new Pin(copiedPinInfo, location, otherTopic);
+        location.addPin(copiedPin);
+
+        otherTopic.addPin(copiedPin);
     }
 
     public void addPinImage(PinImage pinImage) {

backend/src/main/java/com/mapbefine/mapbefine/pin/Domain/PinImage.java

@@ -35,7 +35,7 @@ private PinImage(Image image, Pin pin) {
     }
 
     public static PinImage createPinImageAssociatedWithPin(String imageUrl, Pin pin) {
-        PinImage pinImage = new PinImage(Image.of(imageUrl), pin);
+        PinImage pinImage = new PinImage(Image.from(imageUrl), pin);
         pin.addPinImage(pinImage);
 
         return pinImage;

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

@@ -13,6 +13,7 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.NoSuchElementException;
+import java.util.Objects;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -34,112 +35,166 @@ public TopicCommandService(
         this.memberRepository = memberRepository;
     }
 
-    public long createNew(AuthMember member, TopicCreateRequest request) {
-        Topic topic = createNewTopic(member, request);
+    public Long saveEmptyTopic(AuthMember member, TopicCreateRequest request) {
+        Topic topic = convertToTopic(member, request);
 
-        List<Long> pinIds = request.pins();
-        List<Pin> original = pinRepository.findAllById(pinIds);
+        Topic savedTopic = topicRepository.save(topic);
 
-        validateExist(pinIds.size(), original.size());
-        pinRepository.saveAll(copyPins(original, topic));
-
-        return topic.getId();
+        return savedTopic.getId();
     }
 
-    public long createMerge(AuthMember member, TopicMergeRequest request) {
-        List<Long> topicIds = request.topics();
-        List<Topic> topics = findTopicsByIds(member, topicIds);
+    private Topic convertToTopic(AuthMember member, TopicCreateRequest request) {
+        Member creator = findCreatorByAuthMember(member);
 
-        validateExist(topicIds.size(), topics.size());
-        Topic topic = createMergeTopic(member, request);
+        return Topic.createTopicAssociatedWithCreator(
+                request.name(),
+                request.description(),
+                request.image(),
+                request.publicity(),
+                request.permission(),
+                creator
+        );
+    }
 
-        List<Pin> original = getPinFromTopics(topics);
-        pinRepository.saveAll(copyPins(original, topic));
+    private Member findCreatorByAuthMember(AuthMember member) {
+        if (Objects.isNull(member.getMemberId())) {
+            throw new IllegalArgumentException("Guest는 토픽을 생성할 수 없습니다.");
+        }
 
-        return topic.getId();
+        return memberRepository.findById(member.getMemberId())
+                .orElseThrow(NoSuchElementException::new);
     }
 
-    public void updateTopicInfo(
-            AuthMember member,
-            Long id,
-            TopicUpdateRequest request
-    ) {
-        Topic topic = topicRepository.findById(id)
-                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 Topic입니다."));
-        member.canTopicUpdate(topic);
+    public Long saveTopicWithPins(AuthMember member, TopicCreateRequest request) {
+        Topic topic = convertToTopic(member, request);
 
-        topic.updateTopicInfo(
-                request.name(),
-                request.description(),
-                request.image()
-        );
+        List<Pin> originalPins = findAllPins(request.pins());
+        validateCopyablePins(member, originalPins);
+        copyPinsToTopic(originalPins, topic);
+
+        Topic savedTopic = topicRepository.save(topic);
+
+        return savedTopic.getId();
     }
 
-    public void delete(AuthMember member, Long id) {
-        Topic topic = topicRepository.findById(id)
-                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 Topic입니다."));
-        member.canDelete(topic);
+    private List<Pin> findAllPins(List<Long> pinIds) {
+        List<Pin> findPins = pinRepository.findAllById(pinIds);
+
+        if (pinIds.size() != findPins.size()) {
+            throw new IllegalArgumentException("존재하지 않는 핀 Id가 존재합니다.");
+        }
 
-        pinRepository.deleteAllByTopicId(id);
-        topicRepository.deleteById(id);
+        return findPins;
     }
 
-    private List<Topic> findTopicsByIds(AuthMember member, List<Long> topicIds) {
-        return topicRepository.findAllById(topicIds)
-                .stream()
-                .filter(member::canRead)
-                .toList();
+    private void validateCopyablePins(AuthMember member, List<Pin> originalPins) {
+        int copyablePinCount = (int) originalPins.stream()
+                .filter(pin -> member.canRead(pin.getTopic()))
+                .count();
+
+        if (copyablePinCount != originalPins.size()) {
+            throw new IllegalArgumentException("복사할 수 없는 pin이 존재합니다.");
+        }
     }
 
-    private List<Pin> getPinFromTopics(List<Topic> topics) {
-        return topics.stream()
-                .map(Topic::getPins)
-                .flatMap(Collection::stream)
-                .toList();
+    private void copyPinsToTopic(List<Pin> pins, Topic topic) {
+        pins.forEach(pin -> pin.copyToTopic(topic));
     }
 
-    private Topic createMergeTopic(AuthMember member, TopicMergeRequest request) {
-        Member creator = findCreatorByAuthMember(member);
-        Topic topic = Topic.of(
-                request.name(),
-                request.description(),
-                request.image(),
-                request.publicity(),
-                request.permission(),
-                creator
-        );
-        return topicRepository.save(topic);
+    public Long merge(AuthMember member, TopicMergeRequest request) {
+        Topic topic = convertToTopic(member, request);
+
+        List<Topic> originalTopics = findAllTopics(request.topics());
+        validateCopyableTopics(member, originalTopics);
+        List<Pin> originalPins = getAllPinsFromTopics(originalTopics);
+
+        copyPinsToTopic(originalPins, topic);
+
+        Topic savedTopic = topicRepository.save(topic);
 
+        return savedTopic.getId();
     }
 
-    private Topic createNewTopic(AuthMember member, TopicCreateRequest request) {
+    private Topic convertToTopic(AuthMember member, TopicMergeRequest request) {
         Member creator = findCreatorByAuthMember(member);
-        Topic topic = Topic.of(
+
+        return Topic.createTopicAssociatedWithCreator(
                 request.name(),
                 request.description(),
                 request.image(),
                 request.publicity(),
                 request.permission(),
                 creator
         );
-        return topicRepository.save(topic);
     }
 
-    private Member findCreatorByAuthMember(AuthMember member) {
-        return memberRepository.findById(member.getMemberId())
-                .orElseThrow(NoSuchElementException::new);
+    private List<Topic> findAllTopics(List<Long> topicIds) {
+        List<Topic> findTopics = topicRepository.findAllById(topicIds);
+
+        if (topicIds.size() != findTopics.size()) {
+            throw new IllegalArgumentException("존재하지 않는 토픽 Id가 존재합니다.");
+        }
+
+        return findTopics;
     }
 
-    private void validateExist(int idCount, int existCount) {
-        if (idCount != existCount) {
-            throw new IllegalArgumentException("찾을 수 없는 ID가 포함되어 있습니다.");
+    private void validateCopyableTopics(AuthMember member, List<Topic> originalTopics) {
+        int copyablePinCount = (int) originalTopics.stream()
+                .filter(member::canRead)
+                .count();
+
+        if (copyablePinCount != originalTopics.size()) {
+            throw new IllegalArgumentException("복사할 수 없는 토픽이 존재합니다.");
         }
     }
 
-    private List<Pin> copyPins(List<Pin> pins, Topic topic) {
-        return pins.stream()
-                .map(original -> original.copy(topic))
+    private List<Pin> getAllPinsFromTopics(List<Topic> topics) {
+        return topics.stream()
+                .map(Topic::getPins)
+                .flatMap(Collection::stream)
                 .toList();
     }
 
+    public void updateTopicInfo(
+            AuthMember member,
+            Long topicId,
+            TopicUpdateRequest request
+    ) {
+        Topic topic = findTopic(topicId);
+
+        validateUpdateAuth(member, topic);
+
+        topic.updateTopicInfo(request.name(), request.description(), request.image());
+    }
+
+    private Topic findTopic(Long topicId) {
+        return topicRepository.findById(topicId)
+                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 Topic입니다."));
+    }
+
+    private void validateUpdateAuth(AuthMember member, Topic topic) {
+        if (member.canTopicUpdate(topic)) {
+            return;
+        }
+
+        throw new IllegalArgumentException("업데이트 권한이 없습니다.");
+    }
+
+    public void delete(AuthMember member, Long topicId) {
+        Topic topic = findTopic(topicId);
+
+        validateDeleteAuth(member, topic);
+
+        pinRepository.deleteAllByTopicId(topicId);
+        topicRepository.deleteById(topicId);
+    }
+
+    private void validateDeleteAuth(AuthMember member, Topic topic) {
+        if (member.canDelete(topic)) {
+            return;
+        }
+
+        throw new IllegalArgumentException("삭제 권한이 없습니다.");
+    }
+
 }

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

@@ -1,13 +1,11 @@
 package com.mapbefine.mapbefine.topic.application;
 
 import com.mapbefine.mapbefine.auth.domain.AuthMember;
-import com.mapbefine.mapbefine.location.domain.LocationRepository;
 import com.mapbefine.mapbefine.topic.domain.Topic;
 import com.mapbefine.mapbefine.topic.domain.TopicRepository;
 import com.mapbefine.mapbefine.topic.dto.response.TopicDetailResponse;
 import com.mapbefine.mapbefine.topic.dto.response.TopicResponse;
 import java.util.List;
-import java.util.stream.Collectors;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -17,28 +15,47 @@ public class TopicQueryService {
 
     private final TopicRepository topicRepository;
 
-    public TopicQueryService(final TopicRepository topicRepository, LocationRepository locationRepository) {
+    public TopicQueryService(final TopicRepository topicRepository) {
         this.topicRepository = topicRepository;
     }
 
-    public List<TopicResponse> findAll(AuthMember member) {
+    public List<TopicResponse> findAllReadable(AuthMember member) {
         return topicRepository.findAll().stream()
-                .filter(topic -> member.canRead(topic))
+                .filter(member::canRead)
                 .map(TopicResponse::from)
                 .toList();
     }
 
-    public List<TopicDetailResponse> findAllByIds(List<Long> ids) {
-        return topicRepository.findByIdIn(ids).stream()
+    public TopicDetailResponse findDetailById(AuthMember member, Long id) {
+        Topic topic = topicRepository.findById(id)
+                .orElseThrow(() -> new IllegalArgumentException("해당하는 Topic이 존재하지 않습니다."));
+
+        if (member.canRead(topic)) {
+            return TopicDetailResponse.from(topic);
+        }
+
+        throw new IllegalArgumentException("조회할 수 없는 Topic 입니다.");
+    }
+
+    // TODO: 2023/08/07 토픽의 id가 존재하지 않는 경우도 검증해야 하는가 ?
+    public List<TopicDetailResponse> findDetailsByIds(AuthMember member, List<Long> ids) {
+        List<Topic> topics = topicRepository.findByIdIn(ids);
+
+        validateReadableTopics(member, topics);
+
+        return topics.stream()
                 .map(TopicDetailResponse::from)
-                .collect(Collectors.toList());
+                .toList();
     }
 
-    public TopicDetailResponse findById(AuthMember member, Long id) {
-        Topic topic = topicRepository.findById(id)
+    private void validateReadableTopics(AuthMember member, List<Topic> topics) {
+        int readableCount = (int) topics.stream()
                 .filter(member::canRead)
-                .orElseThrow(() -> new IllegalArgumentException("해당하는 Topic이 존재하지 않습니다."));
+                .count();
 
-        return TopicDetailResponse.from(topic);
+        if (topics.size() != readableCount) {
+            throw new IllegalArgumentException("읽을 수 없는 토픽이 존재합니다.");
+        }
     }
+
 }