[feat] 피드 저장 상태 변경 api 개발

src/main/java/konkuk/thip/book/application/service/BookSavedService.java

@@ -61,7 +61,7 @@ public BookIsSavedResult changeSavedBook(String isbn, boolean isSave, Long userI
         }
 
         // 유저가 저장한 책 목록 조회
-        SavedBooks savedBooks = savedQueryPort.findByUserId(userId);
+        SavedBooks savedBooks = savedQueryPort.findSavedBooksByUserId(userId);
 
         if (isSave) {
             // 저장 요청 시 이미 저장되어 있으면 예외 발생

src/main/java/konkuk/thip/common/exception/code/ErrorCode.java

@@ -132,6 +132,9 @@ public enum ErrorCode implements ResponseCode {
     TAG_NOT_FOUND(HttpStatus.NOT_FOUND, 160002, "존재하지 않는 TAG 입니다."),
     INVALID_FEED_COMMAND(HttpStatus.BAD_REQUEST, 160003, "유효하지 않은 FEED 생성/수정 요청 입니다."),
     FEED_UPDATE_FORBIDDEN(HttpStatus.FORBIDDEN, 160004, "피드 수정 권한이 없습니다."),
+    DUPLICATED_FEEDS_IN_COLLECTION(HttpStatus.INTERNAL_SERVER_ERROR, 160005, "중복된 피드가 존재합니다."),
+    FEED_ALREADY_SAVED(HttpStatus.BAD_REQUEST, 160006, "사용자가 이미 저장한 피드입니다."),
+    FEED_NOT_SAVED_CANNOT_DELETE(HttpStatus.BAD_REQUEST, 160007, "사용자가 저장하지 않은 피드는 저장삭제 할 수 없습니다."),
 
     /**
      * 170000 : Image File error

src/main/java/konkuk/thip/feed/adapter/in/web/FeedCommandController.java

@@ -4,9 +4,12 @@
 import konkuk.thip.common.dto.BaseResponse;
 import konkuk.thip.common.security.annotation.UserId;
 import konkuk.thip.feed.adapter.in.web.request.FeedCreateRequest;
+import konkuk.thip.feed.adapter.in.web.request.FeedIsSavedRequest;
 import konkuk.thip.feed.adapter.in.web.request.FeedUpdateRequest;
 import konkuk.thip.feed.adapter.in.web.response.FeedIdResponse;
+import konkuk.thip.feed.adapter.in.web.response.FeedIsSavedResponse;
 import konkuk.thip.feed.application.port.in.FeedCreateUseCase;
+import konkuk.thip.feed.application.port.in.FeedSavedUseCase;
 import konkuk.thip.feed.application.port.in.FeedUpdateUseCase;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -22,6 +25,7 @@ public class FeedCommandController {
 
     private final FeedCreateUseCase feedCreateUseCase;
     private final FeedUpdateUseCase feedUpdateUseCase;
+    private final FeedSavedUseCase feedSavedUseCase;
 
     //피드 작성
     @PostMapping("/feeds")
@@ -40,4 +44,13 @@ public BaseResponse<FeedIdResponse> updateFeed(@RequestBody @Valid final FeedUpd
         return BaseResponse.ok(FeedIdResponse.of(feedUpdateUseCase.updateFeed(request.toCommand(userId,feedId))));
 
     }
+
+    //피드 저장상태 변경: true -> 저장, false -> 저장해제(삭제)
+    @PostMapping("/feeds/{feedId}/saved")
+    public BaseResponse<FeedIsSavedResponse> changeSavedFeed(@RequestBody final FeedIsSavedRequest request,
+                                                             @PathVariable("feedId") final Long feedId,
+                                                             @UserId final Long userId) {
+        return BaseResponse.ok(FeedIsSavedResponse.of(feedSavedUseCase.changeSavedFeed(FeedIsSavedRequest.toCommand(userId,feedId,request.type()))));
+    }
+
 }

src/main/java/konkuk/thip/feed/adapter/in/web/request/FeedIsSavedRequest.java

@@ -0,0 +1,13 @@
+package konkuk.thip.feed.adapter.in.web.request;
+
+import jakarta.validation.constraints.NotNull;
+import konkuk.thip.feed.application.port.in.dto.FeedIsSavedCommand;
+
+public record FeedIsSavedRequest(
+        @NotNull(message = "type은 필수입니다.")
+        boolean type
+) {
+    public static FeedIsSavedCommand toCommand(Long userId, Long feedId, Boolean type) {
+        return new FeedIsSavedCommand(userId, feedId, type);
+    }
+}

src/main/java/konkuk/thip/feed/adapter/in/web/response/FeedIsSavedResponse.java

@@ -0,0 +1,12 @@
+package konkuk.thip.feed.adapter.in.web.response;
+
+import konkuk.thip.feed.application.port.in.dto.FeedIsSavedResult;
+
+public record FeedIsSavedResponse(
+        Long feedId,
+        boolean isSaved
+) {
+        public static FeedIsSavedResponse of(FeedIsSavedResult feedIsSavedResult) {
+                return new FeedIsSavedResponse(feedIsSavedResult.feedId(), feedIsSavedResult.isSaved());
+        }
+}

src/main/java/konkuk/thip/feed/adapter/out/persistence/FeedCommandPersistenceAdapter.java

@@ -21,6 +21,7 @@
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
+import java.util.Optional;
 
 import static konkuk.thip.common.exception.code.ErrorCode.*;
 
@@ -36,16 +37,17 @@ public class FeedCommandPersistenceAdapter implements FeedCommandPort {
     private final FeedMapper feedMapper;
     private final ContentMapper contentMapper;
 
-    @Override
-    public Feed findById(Long id) {
-        FeedJpaEntity feedJpaEntity = feedJpaRepository.findById(id)
-                .orElseThrow(() -> new EntityNotFoundException(FEED_NOT_FOUND));
-
-        List<TagJpaEntity> tagJpaEntityList = tagJpaRepository.findAllByFeedId(feedJpaEntity.getPostId());
 
-        return feedMapper.toDomainEntity(feedJpaEntity, tagJpaEntityList);
+    @Override
+    public Optional<Feed> findById(Long id) {
+        return feedJpaRepository.findById(id)
+                .map(feedJpaEntity -> {
+                    List<TagJpaEntity> tagJpaEntityList = tagJpaRepository.findAllByFeedId(feedJpaEntity.getPostId());
+                    return feedMapper.toDomainEntity(feedJpaEntity, tagJpaEntityList);
+                });
     }
 
+
     @Override
     public Long save(Feed feed) {
 

src/main/java/konkuk/thip/feed/adapter/out/persistence/repository/FeedTag/FeedTagJpaRepository.java

@@ -2,15 +2,24 @@
 
 import konkuk.thip.feed.adapter.out.jpa.FeedJpaEntity;
 import konkuk.thip.feed.adapter.out.jpa.FeedTagJpaEntity;
+import konkuk.thip.saved.application.port.out.dto.FeedIdAndTagProjection;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 
+import java.util.List;
+
 public interface FeedTagJpaRepository extends JpaRepository<FeedTagJpaEntity, Long>{
 
     @Modifying
     @Query("DELETE FROM FeedTagJpaEntity ft WHERE ft.feedJpaEntity = :feedJpaEntity")
     void deleteAllByFeedJpaEntity(@Param("feedJpaEntity") FeedJpaEntity feedJpaEntity);
 
+    @Query("""
+    SELECT ft.feedJpaEntity.postId as feedId, ft.tagJpaEntity as tagJpaEntity
+    FROM FeedTagJpaEntity ft
+    WHERE ft.feedJpaEntity.postId IN :feedIds
+    """)
+    List<FeedIdAndTagProjection> findFeedIdAndTagsByFeedIds(@Param("feedIds") List<Long> feedIds);
 }

src/main/java/konkuk/thip/feed/application/port/in/FeedSavedUseCase.java

@@ -0,0 +1,8 @@
+package konkuk.thip.feed.application.port.in;
+
+import konkuk.thip.feed.application.port.in.dto.FeedIsSavedCommand;
+import konkuk.thip.feed.application.port.in.dto.FeedIsSavedResult;
+
+public interface FeedSavedUseCase {
+    FeedIsSavedResult changeSavedFeed(FeedIsSavedCommand feedIsSavedCommand);
+}

src/main/java/konkuk/thip/feed/application/port/in/dto/FeedIsSavedCommand.java

@@ -0,0 +1,12 @@
+package konkuk.thip.feed.application.port.in.dto;
+
+public record FeedIsSavedCommand(
+
+        Long userId,
+
+        Long feedId,
+
+        Boolean isSaved
+)
+{
+}

src/main/java/konkuk/thip/feed/application/port/in/dto/FeedIsSavedResult.java

@@ -0,0 +1,11 @@
+package konkuk.thip.feed.application.port.in.dto;
+
+public record FeedIsSavedResult(
+        Long feedId,
+        boolean isSaved
+)
+{
+    public static FeedIsSavedResult of(Long feedId, boolean isSaved) {
+        return new FeedIsSavedResult(feedId, isSaved);
+    }
+}

src/main/java/konkuk/thip/feed/application/port/out/FeedCommandPort.java

@@ -1,10 +1,19 @@
 package konkuk.thip.feed.application.port.out;
 
 
+import konkuk.thip.common.exception.EntityNotFoundException;
 import konkuk.thip.feed.domain.Feed;
 
+import java.util.Optional;
+
+import static konkuk.thip.common.exception.code.ErrorCode.FEED_NOT_FOUND;
+
 public interface FeedCommandPort {
     Long save(Feed feed);
     Long update(Feed feed);
-    Feed findById(Long id);
+    Optional<Feed> findById(Long id);
+    default Feed getByIdOrThrow(Long id) {
+        return findById(id)
+                .orElseThrow(() -> new EntityNotFoundException(FEED_NOT_FOUND));
+    }
 }

src/main/java/konkuk/thip/feed/application/service/FeedSavedService.java

@@ -0,0 +1,45 @@
+package konkuk.thip.feed.application.service;
+
+import jakarta.transaction.Transactional;
+import konkuk.thip.feed.application.port.in.FeedSavedUseCase;
+import konkuk.thip.feed.application.port.in.dto.FeedIsSavedCommand;
+import konkuk.thip.feed.application.port.in.dto.FeedIsSavedResult;
+import konkuk.thip.feed.application.port.out.FeedCommandPort;
+import konkuk.thip.feed.domain.Feed;
+import konkuk.thip.feed.domain.SavedFeeds;
+import konkuk.thip.saved.application.port.out.SavedCommandPort;
+import konkuk.thip.saved.application.port.out.SavedQueryPort;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class FeedSavedService implements FeedSavedUseCase {
+
+    private final FeedCommandPort feedCommandPort;
+    private final SavedCommandPort savedCommandPort;
+    private final SavedQueryPort savedQueryPort;
+
+    @Override
+    @Transactional
+    public FeedIsSavedResult changeSavedFeed(FeedIsSavedCommand feedIsSavedCommand) {
+
+        // 1. 피드 검증 및 조회
+        Feed feed = feedCommandPort.getByIdOrThrow(feedIsSavedCommand.feedId());
+
+        // 2. 유저가 저장한 피드 목록 조회
+        SavedFeeds savedFeeds = savedQueryPort.findSavedFeedsByUserId(feedIsSavedCommand.userId());
+
+        if (feedIsSavedCommand.isSaved()) {
+            // 저장 요청 시 이미 저장되어 있으면 예외 발생
+            savedFeeds.validateNotAlreadySaved(feed);
+            savedCommandPort.saveFeed(feedIsSavedCommand.userId(), feed.getId());
+        } else {
+            // 삭제 요청 시 저장되어 있지 않으면 예외 발생
+            savedFeeds.validateCanDelete(feed);
+            savedCommandPort.deleteFeed(feedIsSavedCommand.userId(), feed.getId());
+        }
+
+        return FeedIsSavedResult.of(feed.getId(), feedIsSavedCommand.isSaved());
+    }
+}

src/main/java/konkuk/thip/feed/application/service/FeedUpdateService.java

@@ -28,7 +28,7 @@ public Long updateFeed(FeedUpdateCommand command) {
         Feed.validateImageCount(command.remainImageUrls() != null ? command.remainImageUrls().size() : 0);
 
         // 2. 피드 조회
-        Feed feed = feedCommandPort.findById(command.feedId());
+        Feed feed = feedCommandPort.getByIdOrThrow(command.feedId());
 
         // 3. 도메인 내에서 내부 상태 변경 및 검증
         applyPartialFeedUpdate(feed, command);

src/main/java/konkuk/thip/feed/domain/Feed.java

@@ -8,6 +8,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
 
@@ -41,6 +42,19 @@ public class Feed extends BaseDomainEntity {
     @Builder.Default
     private List<Content> contentList = new ArrayList<>();
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Feed feed = (Feed) o;
+        return Objects.equals(id, feed.id);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id);
+    }
+
     public static Feed withoutId(String content, Long creatorId, Boolean isPublic, Long targetBookId,
                                  List<String> tagValues, List<String> imageUrls) {
 

src/main/java/konkuk/thip/feed/domain/SavedFeeds.java

@@ -0,0 +1,42 @@
+package konkuk.thip.feed.domain;
+
+import konkuk.thip.common.exception.InvalidStateException;
+import lombok.Getter;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static konkuk.thip.common.exception.code.ErrorCode.*;
+
+@Getter
+public class SavedFeeds {
+
+    private final Set<Feed> feeds;
+
+    public SavedFeeds(List<Feed> feeds) {
+        Set<Feed> feedSet = new HashSet<>(feeds);
+        if (feedSet.size() != feeds.size()) {
+            throw new InvalidStateException(DUPLICATED_FEEDS_IN_COLLECTION);
+        }
+        this.feeds = Collections.unmodifiableSet(feedSet);
+    }
+
+    // 중복 저장 검증
+    public void validateNotAlreadySaved(Feed feed) {
+        if (feeds.contains(feed)) {
+            throw new InvalidStateException(FEED_ALREADY_SAVED);
+        }
+    }
+
+    // 삭제 가능 여부 검증
+    public void validateCanDelete(Feed feed) {
+        if (!feeds.contains(feed)) {
+            throw new InvalidStateException(FEED_NOT_SAVED_CANNOT_DELETE);
+        }
+    }
+
+}
+
+

src/main/java/konkuk/thip/saved/adapter/out/persistence/SavedCommandPersistenceAdapter.java

@@ -3,7 +3,10 @@
 import konkuk.thip.book.adapter.out.jpa.BookJpaEntity;
 import konkuk.thip.book.adapter.out.persistence.repository.BookJpaRepository;
 import konkuk.thip.common.exception.EntityNotFoundException;
+import konkuk.thip.feed.adapter.out.jpa.FeedJpaEntity;
+import konkuk.thip.feed.adapter.out.persistence.repository.FeedJpaRepository;
 import konkuk.thip.saved.adapter.out.jpa.SavedBookJpaEntity;
+import konkuk.thip.saved.adapter.out.jpa.SavedFeedJpaEntity;
 import konkuk.thip.saved.adapter.out.mapper.SavedBookMapper;
 import konkuk.thip.saved.adapter.out.mapper.SavedFeedMapper;
 import konkuk.thip.saved.adapter.out.persistence.repository.SavedBookJpaRepository;
@@ -22,6 +25,7 @@ public class SavedCommandPersistenceAdapter implements SavedCommandPort {
 
     private final UserJpaRepository userJpaRepository;
     private final BookJpaRepository bookJpaRepository;
+    private final FeedJpaRepository feedJpaRepository;
     private final SavedBookJpaRepository savedBookJpaRepository;
     private final SavedFeedJpaRepository savedFeedJpaRepository;
     private final SavedBookMapper savedBookMapper;
@@ -40,10 +44,28 @@ public void saveBook(Long userId, Long bookId) {
         savedBookJpaRepository.save(entity);
     }
 
-
-    //삭제 전략 도입 전
     @Override
     public void deleteBook(Long userId, Long bookId) {
         savedBookJpaRepository.deleteByUserJpaEntity_UserIdAndBookJpaEntity_BookId(userId, bookId);
     }
+
+    @Override
+    public void saveFeed(Long userId, Long feedId) {
+        UserJpaEntity user = userJpaRepository.findById(userId)
+                .orElseThrow(() -> new EntityNotFoundException(USER_NOT_FOUND));
+        FeedJpaEntity feed = feedJpaRepository.findById(feedId)
+                .orElseThrow(() -> new EntityNotFoundException(FEED_NOT_FOUND));
+        SavedFeedJpaEntity entity = SavedFeedJpaEntity.builder()
+                .userJpaEntity(user)
+                .feedJpaEntity(feed)
+                .build();
+        savedFeedJpaRepository.save(entity);
+    }
+
+    @Override
+    public void deleteFeed(Long userId, Long feedId) {
+        savedFeedJpaRepository.deleteByUserIdAndFeedId(userId, feedId);
+    }
+
+
 }