Merge pull request #645 from peer-42seoul/hotfix-getFavorites-in-profile

[Hotfix] get favorites in profile
peer-42seoul · Jan 19, 2024 · 1308056 · 1308056
2 parents c5ed194 + 9541d62
commit 1308056
Show file tree

Hide file tree

Showing 9 changed files with 110 additions and 74 deletions.
diff --git a/src/main/java/peer/backend/controller/profile/FavoriteController.java b/src/main/java/peer/backend/controller/profile/FavoriteController.java
@@ -2,12 +2,16 @@
 
 import io.swagger.annotations.ApiOperation;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.core.Authentication;
 import org.springframework.web.bind.annotation.*;
 import peer.backend.dto.profile.FavoritePage;
+import peer.backend.dto.profile.response.RecruitFavoriteDto;
+import peer.backend.entity.board.recruit.RecruitFavorite;
 import peer.backend.exception.BadRequestException;
+import peer.backend.exception.OutOfRangeException;
 import peer.backend.service.profile.FavoriteService;
 
 @RestController
@@ -24,13 +28,14 @@ private void checkType(String type) {
 
     @ApiOperation(value = "C-MYPAGE-37, 38", notes = "관심 리스트를 가져옵니다.")
     @GetMapping("/recruit/favorite")
-    public ResponseEntity<Object> getFavorite(Authentication auth,
-                                              @RequestParam(value = "type") String type,
-                                              @RequestParam(value = "page") int page,
-                                              @RequestParam(value = "pagesize") int pageSize) {
+    public Page<RecruitFavoriteDto> getFavorite(Authentication auth,
+                                                @RequestParam(value = "type") String type,
+                                                @RequestParam(value = "page") int page,
+                                                @RequestParam(value = "pagesize") int pageSize) {
         checkType(type);
-        FavoritePage ret = favoriteService.getFavorite(auth, type, page, pageSize);
-        return new ResponseEntity<> (ret, HttpStatus.OK);
+        if (page < 1 || pageSize < 0)
+            throw new OutOfRangeException("유효하지 않은 페이지 요청입니다.");
+        return favoriteService.getFavorite(auth, type, page - 1, pageSize);
     }
 
     @ApiOperation(value = "C-MYPAGE-69", notes = "관심 리스트를 전부 삭제합니다.")

diff --git a/src/main/java/peer/backend/dto/profile/FavoritePage.java b/src/main/java/peer/backend/dto/profile/FavoritePage.java
@@ -1,16 +1,19 @@
 package peer.backend.dto.profile;
 
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
+import lombok.Value;
 import peer.backend.dto.board.recruit.RecruitListResponse;
 
 import java.util.List;
 
 @Getter
 @Setter
 @Builder
+@JsonIgnoreProperties(value = {"last"})
 public class FavoritePage {
     List<RecruitListResponse> postList;
     @JsonProperty("isLast")

diff --git a/src/main/java/peer/backend/dto/profile/SkillDTO.java b/src/main/java/peer/backend/dto/profile/SkillDTO.java
@@ -1,6 +1,7 @@
 package peer.backend.dto.profile;
 
 import lombok.*;
+import peer.backend.entity.tag.Tag;
 
 @Getter
 @Setter
@@ -11,4 +12,10 @@ public class SkillDTO {
     private Long tagId;
     private String name;
     private String color;
+
+    public SkillDTO(Tag tag) {
+        this.tagId = tag.getId();
+        this.name = tag.getName();
+        this.color = tag.getColor();
+    }
 }
diff --git a/src/main/java/peer/backend/dto/profile/response/RecruitFavoriteDto.java b/src/main/java/peer/backend/dto/profile/response/RecruitFavoriteDto.java
@@ -0,0 +1,51 @@
+package peer.backend.dto.profile.response;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import peer.backend.dto.profile.SkillDTO;
+import peer.backend.entity.board.recruit.Recruit;
+import peer.backend.entity.board.recruit.RecruitFavorite;
+import peer.backend.entity.tag.RecruitTag;
+import peer.backend.entity.tag.Tag;
+import peer.backend.entity.team.Team;
+import peer.backend.entity.user.User;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@JsonIgnoreProperties(value = {"favorite"})
+public class RecruitFavoriteDto {
+    private Long recruit_id;
+    private String title;
+    private String image;
+    private Long userId;
+    private String userNickname;
+    private String userImage;
+    private String status;
+    private List<SkillDTO> skillList;
+    @JsonProperty("isFavorite")
+    private boolean isFavorite;
+
+    public RecruitFavoriteDto(RecruitFavorite favorite, User user){
+        Recruit recruit = favorite.getRecruit();
+        Team team = recruit.getTeam();
+        this.recruit_id = recruit.getId();
+        this.title = recruit.getTitle();
+        this.image = recruit.getThumbnailUrl();
+        this.userId = user.getId();
+        this.userNickname = user.getNickname();
+        this.userImage = user.getImageUrl();
+        this.status = team.getStatus().getValue();
+        this.skillList = recruit.getRecruitTags().stream().map(RecruitTag::getSkillFromTag).collect(Collectors.toList());
+        this.isFavorite = true;
+    }
+}
diff --git a/src/main/java/peer/backend/entity/tag/RecruitTag.java b/src/main/java/peer/backend/entity/tag/RecruitTag.java
@@ -13,6 +13,7 @@
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
+import peer.backend.dto.profile.SkillDTO;
 import peer.backend.entity.board.recruit.Recruit;
 
 @Entity
@@ -45,4 +46,8 @@ public RecruitTag(Long recruitId, Long tagId) {
         this.recruitId = recruitId;
         this.tagId = tagId;
     }
+
+    public SkillDTO getSkillFromTag(){
+        return new SkillDTO(this.tag);
+    }
 }
diff --git a/src/main/java/peer/backend/repository/board/recruit/RecruitFavoriteRepository.java b/src/main/java/peer/backend/repository/board/recruit/RecruitFavoriteRepository.java
@@ -1,10 +1,19 @@
 package peer.backend.repository.board.recruit;
 
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 import peer.backend.entity.board.recruit.RecruitFavorite;
 import peer.backend.entity.board.recruit.enums.RecruitFavoriteEnum;
 import peer.backend.entity.composite.RecruitFavoritePK;
+import peer.backend.entity.team.enums.TeamType;
+
+import java.util.List;
 
 public interface RecruitFavoriteRepository extends JpaRepository<RecruitFavorite, RecruitFavoritePK> {
     boolean existsByUserIdAndRecruitIdAndType(Long userId, Long recruitId, RecruitFavoriteEnum type);
+
+    void deleteAllByUserIdAndTypeAndRecruitTeamType(Long userId, RecruitFavoriteEnum type, TeamType teamType);
+    List<RecruitFavorite> findByUserIdAndTypeAndRecruitTeamType(Long userId, RecruitFavoriteEnum type, TeamType teamType);
+    Page<RecruitFavorite> findByUserIdAndTypeAndRecruitTeamType(Long userId, RecruitFavoriteEnum type, TeamType teamType, Pageable pageable);
 }
diff --git a/src/main/java/peer/backend/service/board/recruit/HitchHikingService.java b/src/main/java/peer/backend/service/board/recruit/HitchHikingService.java
@@ -5,6 +5,7 @@
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 import peer.backend.dto.board.recruit.HitchListResponse;
 import peer.backend.dto.board.recruit.HitchResponse;
 import peer.backend.entity.board.recruit.Recruit;
@@ -25,6 +26,7 @@ public class HitchHikingService {
     private final TagService tagService;
 
 
+    @Transactional
     public Page<HitchListResponse> getHitchList(int page, int pageSize, String type){
             if (page < 1)
                 throw new OutOfRangeException("page 번호는 1부터 시작합니다.");
@@ -44,6 +46,7 @@ public Page<HitchListResponse> getHitchList(int page, int pageSize, String type)
             );
     }
 
+    @Transactional
     public HitchResponse getHitch(Long hitchId){
         Recruit recruit = recruitRepository.findById(hitchId)
                 .orElseThrow(() -> new NotFoundException("존재하지 않는 모집글입니다."));

diff --git a/src/main/java/peer/backend/service/board/team/ShowcaseService.java b/src/main/java/peer/backend/service/board/team/ShowcaseService.java
@@ -139,6 +139,7 @@ public ShowcaseResponse getShowcase(Long showcaseId, Authentication auth){
             throw new IllegalArgumentException("쇼케이스 게시물이 아닙니다.");
         User user = (auth != null ? User.authenticationToUser(auth) : null);
         Team team = showcase.getBoard().getTeam();
+        showcase.increaseHit();
         return ShowcaseResponse.builder()
                 .content(showcase.getContent())
                 .image(showcase.getFiles().get(0).getUrl())

diff --git a/src/main/java/peer/backend/service/profile/FavoriteService.java b/src/main/java/peer/backend/service/profile/FavoriteService.java
@@ -5,96 +5,48 @@
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.security.core.Authentication;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import peer.backend.dto.board.recruit.RecruitListResponse;
 import peer.backend.dto.profile.FavoritePage;
+import peer.backend.dto.profile.response.RecruitFavoriteDto;
 import peer.backend.entity.board.recruit.Recruit;
 import peer.backend.entity.board.recruit.RecruitFavorite;
+import peer.backend.entity.board.recruit.enums.RecruitFavoriteEnum;
 import peer.backend.entity.team.enums.TeamType;
 import peer.backend.entity.user.User;
+import peer.backend.repository.board.recruit.RecruitFavoriteRepository;
+import peer.backend.repository.board.recruit.RecruitRepository;
 import peer.backend.service.TagService;
 
 @Service
 @RequiredArgsConstructor
 public class FavoriteService {
 
-    private final TagService tagService;
-
-    @PersistenceContext
-    private EntityManager em;
-
-    private List<Recruit> findAllBy(Long userId, TeamType type) {
-        // SELECT * FROM user
-        // JOIN recruit_favorite ON user.id = recruit_favorite.user_id
-        // JOIN recruit ON recruit_favorite.recruit_id = recruit.recruit_id
-        // WHERE user.id = ? AND recruit.type = ?
-        return em.createQuery(
-                "SELECT r FROM User u " +
-                    "JOIN RecruitFavorite rf ON u.id = rf.user.id " +
-                    "JOIN Recruit r ON rf.recruit.id = r.id " +
-                        "JOIN Team k On r.id = k.id " +
-                    "WHERE u.id = :userId AND k.type = :teamType", Recruit.class)
-            .setParameter("userId", userId)
-            .setParameter("teamType", type)
-            .getResultList();
-    }
-
-    private List<Recruit> pagingBy(List<Recruit> retFind, int pageIndex, int pageSize) {
-        int first = (pageIndex - 1) * pageSize;
-        int last = pageIndex * pageSize;
-        if (retFind.size() < first) {
-            return new ArrayList<>();
-        }
-        if (retFind.size() < pageSize) {
-            return retFind;
-        }
-        return retFind.subList(first, last);
-    }
+    private final RecruitFavoriteRepository recruitFavoriteRepository;
 
     @Transactional(readOnly = true)
-    public FavoritePage getFavorite(Authentication auth, String type, int pageIndex, int pageSize) {
+    public Page<RecruitFavoriteDto> getFavorite(Authentication auth, String type, int pageIndex, int pageSize) {
         User user = User.authenticationToUser(auth);
-        List<Recruit> retFind = findAllBy(user.getId(), TeamType.valueOf(type));
-        List<Recruit> retPage = pagingBy(retFind, pageIndex, pageSize);
-        List<RecruitListResponse> ret = new ArrayList<>();
-        for (Recruit recruit : retPage) {
-            RecruitListResponse recruitListResponse = RecruitListResponse.builder()
-                .recruit_id(recruit.getId())
-                .title(recruit.getTitle())
-                .image(recruit.getThumbnailUrl())
-                .user_id(recruit.getWriter() != null ? recruit.getWriterId() : -1)
-                .user_nickname(recruit.getWriter() != null ? recruit.getWriter().getNickname() : "")
-                .user_thumbnail(
-                    recruit.getWriter() != null ? recruit.getWriter().getImageUrl() : null)
-                .status(recruit.getStatus().getStatus())
-//                .tagList(TagListManager.getRecruitTags(recruit.getRecruitTags()))
-                .tagList(this.tagService.recruitTagListToTagResponseList(recruit.getRecruitTags()))
-                .isFavorite(true)
-                .build();
-            ret.add(recruitListResponse);
-        }
-        return FavoritePage.builder()
-            .postList(ret)
-            .isLast(ret.isEmpty())
-            .build();
+        Page<RecruitFavorite> findRecruitFavorite =
+                recruitFavoriteRepository.findByUserIdAndTypeAndRecruitTeamType(
+                        user.getId(),
+                        RecruitFavoriteEnum.LIKE,
+                        TeamType.from(type),
+                        PageRequest.of(pageIndex, pageSize));
+        return findRecruitFavorite.map(favorite -> new RecruitFavoriteDto(favorite, user));
     }
 
     @Transactional
     public void deleteAll(Authentication auth, String type) {
         User user = User.authenticationToUser(auth);
-        List<RecruitFavorite> toDelete = em.createQuery(
-                "SELECT rf FROM User u " +
-                    "JOIN RecruitFavorite rf ON u.id = rf.user.id " +
-                    "JOIN Recruit r ON rf.recruit.id = r.id " +
-                        "JOIN Team k On r.id = k.id " +
-                    "WHERE u.id = :userId AND k.type = :teamType", RecruitFavorite.class)
-            .setParameter("userId", user.getId())
-            .setParameter("teamType", TeamType.valueOf(type))
-            .getResultList();
-        for (RecruitFavorite recruitFavorite : toDelete) {
-            em.remove(recruitFavorite);
-        }
+        recruitFavoriteRepository
+                .deleteAllByUserIdAndTypeAndRecruitTeamType(
+                        user.getId(),
+                        RecruitFavoriteEnum.LIKE,
+                        TeamType.from(type));
     }
 }