[merge]: friend API 구현 (#63)

src/main/java/com/splanet/splanet/core/exception/ErrorCode.java

@@ -36,6 +36,17 @@ public enum ErrorCode {
     INVITATION_ALREADY_PROCESSED("초대가 이미 처리되었습니다.", HttpStatus.BAD_REQUEST),
     USER_ALREADY_IN_TEAM("해당 유저는 이미 팀에 속해 있습니다.", HttpStatus.BAD_REQUEST),
 
+
+    // friend
+    FRIEND_NOT_FOUND("친구가 아닙니다.",HttpStatus.NOT_FOUND),
+    FRIEND_REQUEST_NOT_FOUND("해당 친구 요청을 찾을 수 없습니다.", HttpStatus.NOT_FOUND),
+    FRIEND_ALREADY_EXISTS("이미 친구 목록에 있습니다.", HttpStatus.BAD_REQUEST),
+    FRIEND_REQUEST_ALREADY_SENT("이미 요청을 보냈습니다.",HttpStatus.BAD_REQUEST),
+    FRIEND_REQUEST_NOT_FOUND_IN_RECEIVED_LIST("내가 받은 요청이 아닙니다.", HttpStatus.NOT_FOUND),
+    FRIEND_REQUEST_NOT_RECEIVER("본인이 보낸 요청은 수락하거나 거절할 수 없습니다.", HttpStatus.BAD_REQUEST),
+    FRIEND_REQUEST_ALREADY_ACCEPTED_OR_REJECTED("이미 수락하거나 거절한 사용자 입니다.", HttpStatus.BAD_REQUEST),
+    SELF_FRIEND_REQUEST_NOT_ALLOWED("본인에게 친구요청을 보낼 수 없습니다.", HttpStatus.BAD_REQUEST),
+
     // redis
     REDIS_SCAN_FAILED("Redis 키 스캔 중 오류가 발생했습니다.", HttpStatus.SERVICE_UNAVAILABLE);
 

src/main/java/com/splanet/splanet/friend/controller/FriendApi.java

@@ -0,0 +1,50 @@
+package com.splanet.splanet.friend.controller;
+
+import com.splanet.splanet.friend.dto.FriendResponse;
+import com.splanet.splanet.plan.dto.PlanResponseDto;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+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.RequestMapping;
+
+import java.util.List;
+import java.util.Map;
+
+@RequestMapping("/api/friends")
+@Tag(name = "Friend", description = "친구 관련 API")
+public interface FriendApi {
+
+    @GetMapping
+    @Operation(summary = "친구 목록 조회", description = "사용자의 친구 목록을 조회합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "친구 목록이 성공적으로 조회되었습니다."),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자입니다.")
+    })
+    ResponseEntity<List<FriendResponse>> getFriends(
+            @Parameter(description = "JWT 인증으로 전달된 사용자 ID", required = true) @AuthenticationPrincipal Long userId);
+
+    @GetMapping("/{friendId}/plans")
+    @Operation(summary = "친구 플랜 조회", description = "친구의 공개된 플랜 목록을 조회합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "친구의 공개된 계획이 성공적으로 조회되었습니다."),
+            @ApiResponse(responseCode = "400", description = "잘못된 요청입니다 (유효하지 않은 친구 ID)."),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자입니다."),
+            @ApiResponse(responseCode = "404", description = "친구를 찾을 수 없습니다.")
+    })
+    ResponseEntity<List<PlanResponseDto>> getFriendPlan(
+            @Parameter(description = "조회할 친구 ID", required = true) @PathVariable("friendId") Long friendId,
+            @Parameter(description = "JWT 인증으로 전달된 사용자 ID", required = true) @AuthenticationPrincipal Long userId);
+
+    @DeleteMapping("/{friendId}")
+    @Operation(summary = "친구 삭제하기", description = "친구 목록에서 삭제합니다.")
+    ResponseEntity<Map<String, String>> unfriend(
+            @Parameter(description = "삭제할 친구 ID", required = true) @PathVariable("friendId") Long friendId,
+            @Parameter(description = "JWT 인증으로 전달된 사용자 ID", required = true) @AuthenticationPrincipal Long userId);
+}

src/main/java/com/splanet/splanet/friend/controller/FriendController.java

@@ -0,0 +1,45 @@
+package com.splanet.splanet.friend.controller;
+
+import com.splanet.splanet.friend.dto.FriendResponse;
+import com.splanet.splanet.friend.service.FriendService;
+import com.splanet.splanet.plan.dto.PlanResponseDto;
+import com.splanet.splanet.plan.repository.PlanRepository;
+import com.splanet.splanet.user.repository.UserRepository;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+import java.util.Map;
+
+@RestController
+public class FriendController implements FriendApi {
+
+    private final FriendService friendService;
+
+    public FriendController(FriendService friendService) {
+        this.friendService = friendService;;
+    }
+
+    @Override
+    public ResponseEntity<List<FriendResponse>> getFriends(Long userId) {
+        List<FriendResponse> friends = friendService.getFriends(userId);
+        return ResponseEntity.ok(friends);
+    }
+
+    @Override
+    public ResponseEntity<List<PlanResponseDto>> getFriendPlan(
+            @PathVariable Long friendId,
+            @AuthenticationPrincipal Long userId) {
+        return friendService.getFriendPlan(friendId, userId);
+    }
+
+    @Override
+    public ResponseEntity<Map<String, String>> unfriend(
+            @PathVariable Long friendId,
+            @AuthenticationPrincipal Long userId) {
+        ResponseEntity<Map<String, String>> responseEntity = friendService.unfriend(friendId, userId);
+        return responseEntity;
+    }
+}

src/main/java/com/splanet/splanet/friend/dto/FriendResponse.java

@@ -0,0 +1,4 @@
+package com.splanet.splanet.friend.dto;
+
+public record FriendResponse(Long userId, String nickname, String profileImage) {
+}

src/main/java/com/splanet/splanet/friend/entity/Friend.java

@@ -1,6 +1,7 @@
 package com.splanet.splanet.friend.entity;
 
 import com.splanet.splanet.core.BaseEntity;
+import com.splanet.splanet.user.entity.User;
 import jakarta.persistence.*;
 import lombok.*;
 import lombok.experimental.SuperBuilder;
@@ -13,9 +14,11 @@
 @Entity
 public class Friend extends BaseEntity {
 
-    @Column(name = "user_id", nullable = false)
-    private Long userId;
+    @ManyToOne
+    @JoinColumn(name = "user_id", nullable = false)
+    private User user;
 
-    @Column(name = "friend_id", nullable = false)
-    private Long friendId;
+    @ManyToOne
+    @JoinColumn(name = "friend_id", nullable = false)
+    private User friend;
 }

src/main/java/com/splanet/splanet/friend/repository/FriendRepository.java

@@ -2,8 +2,20 @@
 
 import com.splanet.splanet.friend.entity.Friend;
 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 org.springframework.stereotype.Repository;
 
+import java.util.List;
+
+
 @Repository
 public interface FriendRepository extends JpaRepository<Friend, Long> {
+    List<Friend> findByUserId(Long userId);
+    boolean existsByUserIdAndFriendId(Long userId, Long friendId);
+
+    @Modifying
+    @Query("DELETE FROM Friend f WHERE f.user.id = :requesterId AND f.friend.id = :receiverId")
+    void deleteByRequesterIdAndReceiverId(@Param("requesterId") Long requesterId, @Param("receiverId") Long receiverId);
 }

src/main/java/com/splanet/splanet/friend/service/FriendService.java

@@ -0,0 +1,103 @@
+package com.splanet.splanet.friend.service;
+
+import com.splanet.splanet.core.exception.BusinessException;
+import com.splanet.splanet.core.exception.ErrorCode;
+import com.splanet.splanet.friend.dto.FriendResponse;
+import com.splanet.splanet.friend.entity.Friend;
+import com.splanet.splanet.friend.repository.FriendRepository;
+import com.splanet.splanet.friendRequest.entity.FriendRequest;
+import com.splanet.splanet.friendRequest.repository.FriendRequestRepository;
+import com.splanet.splanet.plan.dto.PlanResponseDto;
+import com.splanet.splanet.plan.entity.Plan;
+import com.splanet.splanet.plan.repository.PlanRepository;
+import com.splanet.splanet.user.entity.User;
+import com.splanet.splanet.user.repository.UserRepository;
+import jakarta.transaction.Transactional;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Service
+public class FriendService {
+
+    private final FriendRepository friendRepository;
+    private final PlanRepository planRepository;
+    private final FriendRequestRepository friendRequestRepository;
+
+    public FriendService(FriendRepository friendRepository, PlanRepository planRepository, FriendRequestRepository friendRequestRepository) {
+        this.friendRepository = friendRepository;
+        this.planRepository = planRepository;
+        this.friendRequestRepository = friendRequestRepository;
+    }
+
+    // 친구 목록 조회
+    public List<FriendResponse> getFriends(Long userId) {
+        List<Friend> friends = friendRepository.findByUserId(userId);
+
+        // Friend 엔티티를 FriendResponse DTO로 변환
+        return friends.stream()
+                .map(friend -> {
+                    User friendUser = friend.getFriend();
+                    return new FriendResponse(
+                            friendUser.getId(),
+                            friendUser.getNickname(),
+                            friendUser.getProfileImage()
+                    );
+                })
+                .collect(Collectors.toList());
+    }
+
+    // 친구의 공개 플랜 조회
+    public ResponseEntity<List<PlanResponseDto>> getFriendPlan(Long friendId, Long userId) {
+        // 친구 목록에 friendId가 있는지 확인
+        boolean isFriend = friendRepository.existsByUserIdAndFriendId(userId, friendId);
+
+        if (!isFriend) {
+            throw new BusinessException(ErrorCode.FRIEND_NOT_FOUND);
+        }
+
+        List<Plan> publicPlans = planRepository.findAllByUserIdAndAccessibility(friendId, true);
+
+        // 공개된 플랜이 없을 경우, 빈 목록 반환
+        if (publicPlans.isEmpty()) {
+            return ResponseEntity.ok(Collections.emptyList());
+        }
+
+        List<PlanResponseDto> planResponseDtos = publicPlans.stream()
+                .map(plan -> PlanResponseDto.builder()
+                        .id(plan.getId())
+                        .title(plan.getTitle())
+                        .description(plan.getDescription())
+                        .startDate(plan.getStartDate())
+                        .endDate(plan.getEndDate())
+                        .accessibility(plan.getAccessibility())
+                        .isCompleted(plan.getIsCompleted())
+                        .createdAt(plan.getCreatedAt())
+                        .updatedAt(plan.getUpdatedAt())
+                        .build())
+                .collect(Collectors.toList());
+
+        return ResponseEntity.ok(planResponseDtos);
+    }
+
+    // 친구 삭제(취소)하기
+    @Transactional
+    public ResponseEntity<Map<String, String>> unfriend(Long friendId, Long userId) {
+        if (!friendRepository.existsByUserIdAndFriendId(userId, friendId)) {
+            throw new BusinessException(ErrorCode.FRIEND_NOT_FOUND);
+        }
+
+        friendRepository.deleteByRequesterIdAndReceiverId(userId, friendId);
+
+        List<FriendRequest> pendingRequests = friendRequestRepository.findPendingRequestsByReceiverId(userId, friendId, FriendRequest.Status.PENDING);
+        for (FriendRequest request : pendingRequests) {
+            friendRequestRepository.delete(request);
+        }
+
+        return ResponseEntity.ok(Map.of("message", "친구 맺기 취소되었습니다!"));
+    }
+}

src/main/java/com/splanet/splanet/friendRequest/controller/FriendRequestApi.java

@@ -0,0 +1,72 @@
+package com.splanet.splanet.friendRequest.controller;
+
+import com.splanet.splanet.friendRequest.dto.FriendRequestCreateRequest;
+import com.splanet.splanet.friendRequest.dto.ReceivedFriendRequestResponse;
+import com.splanet.splanet.friendRequest.dto.SentFriendRequestResponse;
+import com.splanet.splanet.friendRequest.dto.SuccessResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RequestMapping("/api/friends/requests")
+@Tag(name = "FriendRequest", description = "친구 요청 관련 API")
+public interface FriendRequestApi {
+
+    @PostMapping
+    @Operation(summary = "친구 요청", description = "특정 사용자에게 친구 요청을 보냅니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "친구 요청이 성공적으로 전송되었습니다."),
+            @ApiResponse(responseCode = "400", description = "잘못된 요청입니다 (유효하지 않은 유저 ID)."),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자입니다.")
+    })
+    ResponseEntity<SuccessResponse> sendFriendRequest(
+            @Parameter(description = "친구 요청을 보낼 사용자 ID", required = true) @AuthenticationPrincipal Long userId,
+            @RequestBody FriendRequestCreateRequest request);
+
+    @PostMapping("/{requestId}/accept")
+    @Operation(summary = "친구 요청 수락", description = "친구 요청 수락")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "친구 요청 성공적으로 수락되었습니다."),
+            @ApiResponse(responseCode = "400", description = "잘못된 요청입니다 (유효하지 않은 유저 ID)."),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자입니다."),
+            @ApiResponse(responseCode = "404", description = "친구 요청을 찾을 수 없습니다.")
+    })
+    ResponseEntity<ReceivedFriendRequestResponse> acceptFriendRequest(@AuthenticationPrincipal Long userId,
+            @Parameter(description = "친구 요청 ID", required = true) @PathVariable Long requestId);
+
+    @PostMapping("/{requestId}/reject")
+    @Operation(summary = "친구 요청 거절", description = "친구 요청 거절")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "친구 요청이 성공적으로 거절되었습니다."),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자입니다."),
+            @ApiResponse(responseCode = "404", description = "친구 요청을 찾을 수 없습니다."),
+            @ApiResponse(responseCode = "404", description = "친구 요청을 찾을 수 없습니다.")
+    })
+    ResponseEntity<ReceivedFriendRequestResponse> rejectFriendRequest(
+            @Parameter(description = "친구 요청 ID", required = true) @PathVariable Long requestId, @AuthenticationPrincipal Long userId);
+
+    @GetMapping("/received")
+    @Operation(summary = "친구 요청 목록 조회 (받은 요청)", description = "사용자가 받은 친구 요청 목록을 조회합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "받은 친구 요청 목록이 성공적으로 조회되었습니다."),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자입니다.")
+    })
+    ResponseEntity<List<ReceivedFriendRequestResponse>> getReceivedRequests(
+            @Parameter(description = "JWT 인증으로 전달된 사용자 ID", required = true) @AuthenticationPrincipal Long userId);
+
+    @GetMapping("/sent")
+    @Operation(summary = "친구 요청 목록 조회 (보낸 요청)", description = "사용자가 보낸 친구 요청 목록을 조회합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "보낸 친구 요청 목록이 성공적으로 조회되었습니다."),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자입니다.")
+    })
+    ResponseEntity<List<SentFriendRequestResponse>> getSentRequests(
+            @Parameter(description = "JWT 인증으로 전달된 사용자 ID", required = true) @AuthenticationPrincipal Long userId);
+}