Feat/#158 get poke to me single

src/main/java/org/sopt/app/application/auth/PlaygroundAuthInfo.java

@@ -6,6 +6,9 @@
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+import lombok.AccessLevel;
 import org.sopt.app.domain.enums.UserStatus;
 
 public class PlaygroundAuthInfo {
@@ -51,15 +54,6 @@ public static class PlaygroundProfile {
         private List<PlaygroundActivity> activities;
     }
 
-    @Getter
-    @Setter
-    // TODO 임시
-    @Builder
-    @ToString
-    public static class PlaygroundProfileWithId extends PlaygroundProfile {
-        private Long id;
-    }
-
     @Getter
     @Setter
     @ToString
@@ -135,9 +129,9 @@ public static class UserActiveInfo {
     }
 
     @Getter
-    @Setter
-    @Builder
     @ToString
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
+    @AllArgsConstructor(access = AccessLevel.PRIVATE)
     public static class MemberProfile {
         private Long id;
         private String profileImage;
@@ -150,9 +144,9 @@ public ActivityCardinalInfo getLatestActivity() {
     }
 
     @Getter
-    @Setter
     @Builder
-    @ToString
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
+    @AllArgsConstructor(access = AccessLevel.PRIVATE)
     public static class ActivityCardinalInfo {
         private String cardinalInfo;
 

src/main/java/org/sopt/app/application/auth/PlaygroundAuthService.java

@@ -1,22 +1,19 @@
 package org.sopt.app.application.auth;
 
 import io.jsonwebtoken.ExpiredJwtException;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
 import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import lombok.val;
-import org.sopt.app.application.auth.PlaygroundAuthInfo.PlaygroundActivity;
-import org.sopt.app.application.auth.PlaygroundAuthInfo.PlaygroundProfileWithId;
 import org.sopt.app.common.exception.BadRequestException;
 import org.sopt.app.common.exception.UnauthorizedException;
 import org.sopt.app.common.response.ErrorCode;
 import org.sopt.app.domain.enums.UserStatus;
 import org.sopt.app.interfaces.external.PlaygroundClient;
 import org.sopt.app.presentation.auth.AppAuthRequest;
-import org.sopt.app.presentation.user.UserRequest;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.springframework.web.client.HttpClientErrorException.BadRequest;
@@ -139,38 +136,16 @@ public PlaygroundAuthInfo.ActiveUserIds getPlayGroundUserIds(String accessToken)
     public List<PlaygroundAuthInfo.MemberProfile> getPlaygroundMemberProfiles(String accessToken, List<Long> memberIds) {
         Map<String, String> defaultHeader = createDefaultHeader();
         defaultHeader.put("Authorization", accessToken);
-        UserRequest.MemberProfilesRequest request = new UserRequest.MemberProfilesRequest();
-        request.setMemberIds(memberIds);
+        String stringifyIds = memberIds.stream()
+                .map(String::valueOf)
+                .collect(Collectors.joining(","));
         try {
-            return playgroundClient.getMemberProfiles(defaultHeader, request);
-            // TODO : 임시 Mock Data
-            //return List.of(new PlaygroundAuthInfo.MemberProfile(122L, null, "구건모", List.of(new PlaygroundAuthInfo.ActivityCardinalInfo("32,웹"))));
+            return playgroundClient.getMemberProfiles(defaultHeader, URLEncoder.encode(stringifyIds, StandardCharsets.UTF_8));
         } catch (BadRequest e) {
             throw new BadRequestException(ErrorCode.PLAYGROUND_PROFILE_NOT_EXISTS.getMessage());
         } catch (ExpiredJwtException e) {
-        throw new UnauthorizedException(ErrorCode.INVALID_PLAYGROUND_TOKEN.getMessage());
-    }
+            throw new UnauthorizedException(ErrorCode.INVALID_PLAYGROUND_TOKEN.getMessage());
+        }
     }
 
-    public List<PlaygroundAuthInfo.PlaygroundProfileWithId> getPlaygroundProfiles(List<Long> recommendUserIds) {
-        val result = recommendUserIds.stream().map(
-                userId -> {
-                    val dummyActivity = new PlaygroundActivity();
-                    val dummyCardinalActivity = new PlaygroundAuthInfo.PlaygroundCardinalActivity();
-                    dummyCardinalActivity.setGeneration(currentGeneration);
-                    dummyCardinalActivity.setId(1L);
-                    dummyCardinalActivity.setIsProject(false);
-                    dummyCardinalActivity.setPart("서버");
-                    dummyCardinalActivity.setTeam("없음");
-                    dummyActivity.setCardinalActivities(List.of(dummyCardinalActivity));
-
-                    val playgroundProfile = new PlaygroundProfileWithId(userId);
-                    playgroundProfile.setProfileImage("");
-                    playgroundProfile.setName("test");
-                    playgroundProfile.setActivities(List.of(dummyActivity));
-                    return playgroundProfile;
-                }
-        ).toList();
-        return result;
-    }
 }

src/main/java/org/sopt/app/application/poke/FriendService.java

@@ -8,26 +8,34 @@
 import org.sopt.app.domain.entity.Friend;
 import org.sopt.app.domain.enums.Friendship;
 import org.sopt.app.interfaces.postgres.FriendRepository;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
 
 import java.util.Optional;
 
 @Service
 @RequiredArgsConstructor
 public class FriendService {
-    private static final int LIMIT_NEW_FRIEND = 2;
-    private static final int LIMIT_BEST_FRIEND = 5;
-    private static final int LIMIT_SOULMATE = 11;
 
     private final FriendRepository friendRepository;
 
     public List<Long> findAllFriendIdsByUserIdRandomly(Long userId, int limitNum) {
         return friendRepository.getFriendRandom(userId, limitNum);
     }
 
+    public List<Long> findAllFriendsByFriendship(Long userId, Integer lowerLimit, Integer upperLimit) {
+        return friendRepository.findAllByUserIdAndPokeCountBetweenOrderByPokeCountDesc(
+                userId, lowerLimit, upperLimit).stream()
+                .map(Friend::getFriendUserId)
+                .toList();
+    }
+    public Page<Friend> findAllFriendsByFriendship(Long userId, Integer lowerLimit, Integer upperLimit, Pageable pageable) {
+        return friendRepository.findAllByUserIdAndPokeCountBetweenOrderByPokeCountDesc(
+                userId, lowerLimit, upperLimit, pageable);
+    }
+
 
-    @Transactional
     public void createRelation(Long pokerId, Long pokedId) {
         Friend createdRelationUserToFriend = Friend.builder()
                 .userId(pokerId)
@@ -43,21 +51,18 @@ public void createRelation(Long pokerId, Long pokedId) {
         friendRepository.save(createdRelationFriendToUser);
     }
 
-    @Transactional
     public void applyPokeCount(Long pokerId, Long pokedId) {
         Friend friendship = friendRepository.findByUserIdAndFriendUserId(pokerId, pokedId)
                 .orElseThrow(() -> new NotFoundException(ErrorCode.FRIENDSHIP_NOT_FOUND.getMessage()));
         friendship.addPokeCount();
     }
 
-    @Transactional(readOnly = true)
     public boolean isFriendEachOther(Long pokerId, Long pokedId) {
         Optional<Friend> pokerToPokedRelation = friendRepository.findByUserIdAndFriendUserId(pokerId, pokedId);
         Optional<Friend> pokedToPokerRelation = friendRepository.findByUserIdAndFriendUserId(pokedId, pokerId);
         return pokerToPokedRelation.isPresent() && pokedToPokerRelation.isPresent();
     }
 
-    @Transactional(readOnly = true)
     public PokeInfo.Relationship getRelationInfo(Long pokerId, Long pokedId) {
         Friend friendship = friendRepository.findByUserIdAndFriendUserId(pokerId, pokedId)
                 .orElseThrow(() -> new NotFoundException(ErrorCode.FRIENDSHIP_NOT_FOUND.getMessage()));
@@ -68,19 +73,18 @@ public PokeInfo.Relationship getRelationInfo(Long pokerId, Long pokedId) {
     }
 
     private String decideRelationName(Integer pokeCount) {
-        if (pokeCount >= LIMIT_SOULMATE) {
-            return Friendship.SOULMATE.getValue();
+        if (pokeCount >= Friendship.SOULMATE.getLowerLimit()) {
+            return Friendship.SOULMATE.getFriendshipName();
         }
-        if (pokeCount >= LIMIT_BEST_FRIEND) {
-            return Friendship.BEST_FRIEND.getValue();
+        if (pokeCount >= Friendship.BEST_FRIEND.getLowerLimit()) {
+            return Friendship.BEST_FRIEND.getFriendshipName();
         }
-        if (pokeCount >= LIMIT_NEW_FRIEND) {
-            return Friendship.NEW_FRIEND.getValue();
+        if (pokeCount >= Friendship.NEW_FRIEND.getLowerLimit()) {
+            return Friendship.NEW_FRIEND.getFriendshipName();
         }
-        return Friendship.NON_FRIEND.getValue();
+        return Friendship.NON_FRIEND.getFriendshipName();
     }
 
-    @Transactional(readOnly = true)
     public List<Long> getMutualFriendIds(Long pokerId, Long pokedId) {
         List<Long> pokerFriendIds = friendRepository.findAllOfFriendIdsByUserId(pokerId);
         List<Long> pokedFriendIds = friendRepository.findAllOfFriendIdsByUserId(pokedId);

src/main/java/org/sopt/app/application/poke/PokeHistoryService.java

@@ -7,6 +7,8 @@
 import org.sopt.app.common.response.ErrorCode;
 import org.sopt.app.common.exception.BadRequestException;
 import org.sopt.app.interfaces.postgres.PokeHistoryRepository;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 
 import java.time.LocalDateTime;
@@ -39,6 +41,13 @@ public List<Long> getPokeFriendIds(Long userId) {
                 .toList();
     }
 
+    public List<PokeHistory> getPokeFriendIdsInOrderByMostRecent(Long userId) {
+        return pokeHistoryRepository.findAllByPokedId(userId);
+    }
+    public Page<PokeHistory> getPokeFriendIdsInOrderByMostRecent(Long userId, Pageable pageable) {
+        return pokeHistoryRepository.findAllByPokedId(userId, pageable);
+    }
+
     public void checkUserOverDailyPokeLimit(Long userId) {
         LocalDateTime today = LocalDateTime.now();
         List<PokeHistory> allByPokerIdAndCreatedAtDate = pokeHistoryRepository.findAllByPokerIdAndCreatedAt(userId, today);

src/main/java/org/sopt/app/application/poke/PokeService.java

@@ -32,7 +32,10 @@ public Boolean isReplyPoke(Long pokerId, Long pokedId) {
 
     @Transactional(readOnly = true)
     public PokeInfo.PokeDetail getPokeDetail(Long pokerId, Long pokedId) {
-        PokeHistory latestPokeHistory = historyRepository.findAllByPokerIdAndPokedIdOrderByCreatedAtDesc(pokerId, pokedId).get(0);
+        PokeHistory latestPokeHistory = historyRepository.findAllByPokerIdAndPokedIdOrderByCreatedAtDesc(pokerId, pokedId).stream()
+                .distinct()
+                .findFirst()
+                .orElseThrow(() -> new NotFoundException(ErrorCode.POKE_HISTORY_NOT_FOUND.getMessage()));
         return PokeInfo.PokeDetail.builder()
                 .id(latestPokeHistory.getId())
                 .message(latestPokeHistory.getMessage())

src/main/java/org/sopt/app/application/user/UserService.java

@@ -5,7 +5,6 @@
 import lombok.RequiredArgsConstructor;
 import lombok.val;
 import org.sopt.app.application.auth.PlaygroundAuthInfo;
-import org.sopt.app.application.auth.PlaygroundAuthInfo.PlaygroundProfileWithId;
 import org.sopt.app.application.user.UserInfo.PokeProfile;
 import org.sopt.app.application.user.UserInfo.UserProfile;
 import org.sopt.app.common.exception.UnauthorizedException;
@@ -94,19 +93,19 @@ public void updatePlaygroundToken(UserInfo.Id userId, String playgroundToken) {
     }
 
     @Transactional(readOnly = true)
-    public UserInfo.UserProfile getUserProfile(Long userId) {
+    public UserProfile getUserProfile(Long userId) {
         val user = userRepository.findUserById(userId)
                 .orElseThrow(() -> new UnauthorizedException(ErrorCode.USER_NOT_FOUND.getMessage()));
-        return UserInfo.UserProfile.builder()
+        return UserProfile.builder()
                         .userId(user.getId())
                         .name(user.getUsername())
                         .playgroundId(user.getPlaygroundId())
                         .build();
     }
 
-    public List<UserInfo.UserProfile> getUserProfilesByPlaygroundIds(List<Long> playgroundIds) {
+    public List<UserProfile> getUserProfilesByPlaygroundIds(List<Long> playgroundIds) {
         return userRepository.findAllByPlaygroundIdIn(playgroundIds).stream().map(
-            u -> UserInfo.UserProfile.builder()
+            u -> UserProfile.builder()
                 .userId(u.getId())
                 .name(u.getUsername())
                 .playgroundId(u.getPlaygroundId())
@@ -125,28 +124,26 @@ public List<UserProfile> getUserProfileByUserId(List<Long> userId) {
     }
 
     public List<PokeProfile> combinePokeProfileList(
-        List<UserProfile> userProfiles, List<PlaygroundProfileWithId> playgroundProfiles
+        List<UserProfile> userProfiles, List<PlaygroundAuthInfo.MemberProfile> playgroundProfiles
     ) {
         return userProfiles.stream().map(userProfile -> {
             val playgroundProfile = playgroundProfiles.stream()
                 .filter(profile -> profile.getId().equals(userProfile.getPlaygroundId()))
                 .findFirst()
                 .orElseThrow(() -> new RuntimeException("플레이그라운드 프로필이 없습니다."));
-            val generation = playgroundProfile.getActivities().get(0).getCardinalActivities().get(0)
-                .getGeneration();
-            val part = playgroundProfile.getActivities().get(0).getCardinalActivities().get(0)
-                .getPart();
+            val generation = playgroundProfile.getActivities().get(0).getGeneration();
+            val part = playgroundProfile.getActivities().get(0).getPart();
             return PokeProfile.builder()
                 .userId(userProfile.getUserId())
                 .profileImage(playgroundProfile.getProfileImage())
                 .name(userProfile.getName())
-                .generation(generation)
+                .generation(Long.parseLong(generation))
                 .part(part)
                 .isAlreadyPoked(false)
                 .build();
         }).toList();
     }
-    public List<UserInfo.UserProfile> findRandomFriendsOfFriends(Long userId, Long friendIds, int limitNum) {
+    public List<UserProfile> findRandomFriendsOfFriends(Long userId, Long friendIds, int limitNum) {
         val users = userRepository.findRandomFriendsOfFriends(userId, friendIds, limitNum);
         return users.stream().map(
             u -> UserProfile.builder()

src/main/java/org/sopt/app/common/response/ErrorCode.java

@@ -52,6 +52,7 @@ public enum ErrorCode {
     POKE_MESSAGE_NOT_FOUND("해당 찌르기 메시지는 존재하지 않습니다."),
     OVER_DAILY_POKE_LIMIT("일일 최대 찌르기 가능 횟수를 초과했습니다."),
 
+
     // FRIEND
     FRIENDSHIP_NOT_FOUND("해당 친구관계는 존재하지 않습니다."),
 

src/main/java/org/sopt/app/domain/enums/Friendship.java

@@ -1,13 +1,29 @@
 package org.sopt.app.domain.enums;
 
 import lombok.*;
+import org.sopt.app.common.exception.BadRequestException;
+import org.sopt.app.common.response.ErrorCode;
+
+import java.util.Arrays;
 
 @Getter
 @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
 public enum Friendship {
-    NON_FRIEND(""), NEW_FRIEND("친한친구"), BEST_FRIEND("단짝친구"), SOULMATE("천생연분")
+    NON_FRIEND("","", 0,1),
+    NEW_FRIEND("NF","친한친구",2, 4),
+    BEST_FRIEND("BF","단짝친구",5,10),
+    SOULMATE("SM","천생연분",11,99)
     ;
 
-    private final String value;
+    private final String typeFlag;
+    private final String friendshipName;
+    private final Integer lowerLimit;
+    private final Integer upperLimit;
 
+    public static Friendship getFriendshipByValue(String type) {
+        return Arrays.stream(values())
+                .filter(friendship -> friendship.getTypeFlag().equals(type))
+                .findFirst()
+                .orElseThrow(() -> new BadRequestException(ErrorCode.FRIENDSHIP_NOT_FOUND.getMessage()));
+    }
 }