[feat] 팔로잉 상태 변경 api 개발

src/main/java/konkuk/thip/common/entity/BaseDomainEntity.java

@@ -14,4 +14,12 @@ public class BaseDomainEntity {
     private LocalDateTime modifiedAt;
 
     private StatusType status;
+
+    protected void changeStatus() {
+        if (this.status == StatusType.ACTIVE) {
+            this.status = StatusType.INACTIVE;
+        } else {
+            this.status = StatusType.ACTIVE;
+        }
+    }
 }

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

@@ -37,6 +37,16 @@ public enum ErrorCode implements ResponseCode {
      * 70000 : user error
      */
     USER_NOT_FOUND(HttpStatus.NOT_FOUND, 70000, "존재하지 않는 USER 입니다."),
+    USER_ALREADY_FOLLOWED(HttpStatus.BAD_REQUEST, 70001, "이미 팔로우한 사용자입니다."),
+
+    /**
+     * 75000 : follow error
+     */
+    FOLLOW_NOT_FOUND(HttpStatus.NOT_FOUND, 75001, "존재하지 않는 FOLLOW 입니다."),
+    USER_ALREADY_UNFOLLOWED(HttpStatus.BAD_REQUEST, 75002, "이미 언팔로우한 사용자입니다."),
+    USER_CANNOT_FOLLOW_SELF(HttpStatus.BAD_REQUEST, 75003, "사용자는 자신을 팔로우할 수 없습니다."),
+
+
 
     /**
      * 80000 : book error

src/main/java/konkuk/thip/user/adapter/in/web/UserCommandController.java

@@ -4,14 +4,19 @@
 import jakarta.validation.Valid;
 import konkuk.thip.common.dto.BaseResponse;
 import konkuk.thip.common.security.annotation.Oauth2Id;
+import konkuk.thip.common.security.annotation.UserId;
 import konkuk.thip.common.security.util.JwtUtil;
+import konkuk.thip.user.adapter.in.web.request.UserFollowRequest;
 import konkuk.thip.user.adapter.in.web.request.UserSignupRequest;
 import konkuk.thip.user.adapter.in.web.request.UserVerifyNicknameRequest;
+import konkuk.thip.user.adapter.in.web.response.UserFollowResponse;
 import konkuk.thip.user.adapter.in.web.response.UserSignupResponse;
 import konkuk.thip.user.adapter.in.web.response.UserVerifyNicknameResponse;
+import konkuk.thip.user.application.port.in.UserFollowUsecase;
 import konkuk.thip.user.application.port.in.UserSignupUseCase;
 import konkuk.thip.user.application.port.in.UserVerifyNicknameUseCase;
 import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RestController;
@@ -25,11 +30,12 @@ public class UserCommandController {
 
     private final UserSignupUseCase userSignupUseCase;
     private final UserVerifyNicknameUseCase userVerifyNicknameUseCase;
+    private final UserFollowUsecase userFollowUsecase;
     private final JwtUtil jwtUtil;
 
     @PostMapping("/users/signup")
-    public BaseResponse<UserSignupResponse> signup(@Valid @RequestBody UserSignupRequest request,
-                                                   @Oauth2Id String oauth2Id,
+    public BaseResponse<UserSignupResponse> signup(@Valid @RequestBody final UserSignupRequest request,
+                                                   @Oauth2Id final String oauth2Id,
                                                    HttpServletResponse response) {
         Long userId = userSignupUseCase.signup(request.toCommand(oauth2Id));
         String accessToken = jwtUtil.createAccessToken(userId);
@@ -38,9 +44,19 @@ public BaseResponse<UserSignupResponse> signup(@Valid @RequestBody UserSignupReq
     }
 
     @PostMapping("/users/nickname")
-    public BaseResponse<UserVerifyNicknameResponse> verifyNickname(@Valid @RequestBody UserVerifyNicknameRequest request) {
+    public BaseResponse<UserVerifyNicknameResponse> verifyNickname(@Valid @RequestBody final UserVerifyNicknameRequest request) {
         return BaseResponse.ok(UserVerifyNicknameResponse.of(
                 userVerifyNicknameUseCase.isNicknameUnique(request.nickname()))
         );
     }
+
+    // 팔루우 상태 변경 : true -> 팔로우, false -> 언팔로우
+    @PostMapping("/users/following/{followingUserId}")
+    public BaseResponse<UserFollowResponse> followUser(@UserId final Long userId,
+                                            @PathVariable final Long followingUserId,
+                                            @RequestBody @Valid final UserFollowRequest request) {
+        return BaseResponse.ok(UserFollowResponse.of(userFollowUsecase.changeFollowingState(
+                UserFollowRequest.toCommand(userId, followingUserId, request.type())
+        )));
+    }
 }

src/main/java/konkuk/thip/user/adapter/in/web/request/UserFollowRequest.java

@@ -0,0 +1,13 @@
+package konkuk.thip.user.adapter.in.web.request;
+
+import jakarta.validation.constraints.NotNull;
+import konkuk.thip.user.application.port.in.dto.UserFollowCommand;
+
+public record UserFollowRequest(
+        @NotNull(message = "type은 필수 파라미터입니다.")
+        Boolean type // true -> 팔로우, false -> 언팔로우
+) {
+        public static UserFollowCommand toCommand(Long userId, Long targetUserId, Boolean type) {
+                return new UserFollowCommand(userId, targetUserId, type);
+        }
+}

src/main/java/konkuk/thip/user/adapter/in/web/response/UserFollowResponse.java

@@ -0,0 +1,9 @@
+package konkuk.thip.user.adapter.in.web.response;
+
+public record UserFollowResponse(
+        boolean isFollowing
+) {
+    public static UserFollowResponse of(boolean isFollowing) {
+        return new UserFollowResponse(isFollowing);
+    }
+}

src/main/java/konkuk/thip/user/adapter/out/jpa/FollowingJpaEntity.java

@@ -3,10 +3,12 @@
 import jakarta.persistence.*;
 import konkuk.thip.common.entity.BaseJpaEntity;
 import lombok.*;
+import org.hibernate.annotations.SQLDelete;
 
 @Entity
 @Table(name = "followings")
 @Getter
+@SQLDelete(sql = "UPDATE followings SET status = 'INACTIVE' WHERE following_id = ?")
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 @AllArgsConstructor
 @Builder

src/main/java/konkuk/thip/user/adapter/out/persistence/FollowingCommandPersistenceAdapter.java

@@ -0,0 +1,50 @@
+package konkuk.thip.user.adapter.out.persistence;
+
+import konkuk.thip.common.exception.EntityNotFoundException;
+import konkuk.thip.user.adapter.out.jpa.FollowingJpaEntity;
+import konkuk.thip.user.adapter.out.jpa.UserJpaEntity;
+import konkuk.thip.user.adapter.out.mapper.FollowingMapper;
+import konkuk.thip.user.application.port.out.FollowingCommandPort;
+import konkuk.thip.user.domain.Following;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+import static konkuk.thip.common.exception.code.ErrorCode.FOLLOW_NOT_FOUND;
+import static konkuk.thip.common.exception.code.ErrorCode.USER_NOT_FOUND;
+
+@Repository
+@RequiredArgsConstructor
+public class FollowingCommandPersistenceAdapter implements FollowingCommandPort {
+
+    private final FollowingJpaRepository followingJpaRepository;
+    private final UserJpaRepository userJpaRepository;
+
+    private final FollowingMapper followingMapper;
+
+    @Override
+    public Optional<Following> findByUserIdAndTargetUserId(Long userId, Long targetUserId) {
+        Optional<FollowingJpaEntity> followingJpaEntity = followingJpaRepository.findByUserAndTargetUser(userId, targetUserId);
+        return followingJpaEntity.map(followingMapper::toDomainEntity);
+    }
+
+    @Override
+    public void save(Following following) { // insert용
+        UserJpaEntity userJpaEntity = userJpaRepository.findById(following.getUserId()).orElseThrow(
+                () -> new EntityNotFoundException(USER_NOT_FOUND));
+
+        UserJpaEntity targetUser = userJpaRepository.findById(following.getFollowingUserId()).orElseThrow(
+                () -> new EntityNotFoundException(USER_NOT_FOUND));
+
+        followingJpaRepository.save(followingMapper.toJpaEntity(userJpaEntity, targetUser));
+    }
+
+    @Override
+    public void updateStatus(Following following) { // 상태변경 용
+        FollowingJpaEntity entity = followingJpaRepository.findByUserAndTargetUser(following.getUserId(), following.getFollowingUserId())
+                .orElseThrow(() -> new EntityNotFoundException(FOLLOW_NOT_FOUND));
+
+        entity.setStatus(following.getStatus());
+    }
+}

src/main/java/konkuk/thip/user/adapter/out/persistence/FollowingJpaRepository.java

@@ -2,6 +2,10 @@
 
 import konkuk.thip.user.adapter.out.jpa.FollowingJpaEntity;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface FollowingJpaRepository extends JpaRepository<FollowingJpaEntity, Long>, FollowingQueryRepository {
+
 
-public interface FollowingJpaRepository extends JpaRepository<FollowingJpaEntity, Long>,FollowingQueryRepository {
 }

src/main/java/konkuk/thip/user/adapter/out/persistence/FollowingQueryRepository.java

@@ -1,8 +1,12 @@
 package konkuk.thip.user.adapter.out.persistence;
 
+import konkuk.thip.user.adapter.out.jpa.FollowingJpaEntity;
+
+import java.util.Optional;
 import java.util.List;
 import java.util.Map;
 
 public interface FollowingQueryRepository {
     Map<Long, Integer> countByFollowingUserIds(List<Long> userIds);
+    Optional<FollowingJpaEntity> findByUserAndTargetUser(Long userId, Long targetUserId);
 }

src/main/java/konkuk/thip/user/adapter/out/persistence/FollowingQueryRepositoryImpl.java

@@ -2,10 +2,12 @@
 
 import com.querydsl.core.Tuple;
 import com.querydsl.jpa.impl.JPAQueryFactory;
+import konkuk.thip.user.adapter.out.jpa.FollowingJpaEntity;
 import konkuk.thip.user.adapter.out.jpa.QFollowingJpaEntity;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Repository;
 
+import java.util.Optional;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -35,4 +37,17 @@ public Map<Long, Integer> countByFollowingUserIds(List<Long> userIds) {
                         tuple -> tuple.get(following.count()).intValue()
                 ));
     }
+
+    @Override
+    public Optional<FollowingJpaEntity> findByUserAndTargetUser(Long userId, Long targetUserId) {
+        QFollowingJpaEntity following = QFollowingJpaEntity.followingJpaEntity;
+
+        FollowingJpaEntity followingJpaEntity = jpaQueryFactory
+                .selectFrom(following)
+                .where(following.userJpaEntity.userId.eq(userId)
+                        .and(following.followingUserJpaEntity.userId.eq(targetUserId)))
+                .fetchOne();
+
+        return Optional.ofNullable(followingJpaEntity);
+    }
 }

src/main/java/konkuk/thip/user/application/port/in/UserFollowUsecase.java

@@ -0,0 +1,8 @@
+package konkuk.thip.user.application.port.in;
+
+
+import konkuk.thip.user.application.port.in.dto.UserFollowCommand;
+
+public interface UserFollowUsecase {
+    Boolean changeFollowingState(UserFollowCommand followCommand);
+}

src/main/java/konkuk/thip/user/application/port/in/dto/UserFollowCommand.java

@@ -0,0 +1,8 @@
+package konkuk.thip.user.application.port.in.dto;
+
+public record UserFollowCommand(
+        Long userId,
+        Long targetUserId,
+        Boolean type // true -> 팔로우, false -> 언팔로우
+) {
+}

src/main/java/konkuk/thip/user/application/port/out/FollowingCommandPort.java

@@ -0,0 +1,14 @@
+package konkuk.thip.user.application.port.out;
+
+import konkuk.thip.user.domain.Following;
+
+import java.util.Optional;
+
+public interface FollowingCommandPort {
+
+    Optional<Following> findByUserIdAndTargetUserId(Long userId, Long targetUserId);
+
+    void save(Following following);
+
+    void updateStatus(Following following);
+}

src/main/java/konkuk/thip/user/application/service/UserFollowService.java

@@ -0,0 +1,54 @@
+package konkuk.thip.user.application.service;
+
+import konkuk.thip.common.exception.InvalidStateException;
+import konkuk.thip.user.application.port.in.UserFollowUsecase;
+import konkuk.thip.user.application.port.in.dto.UserFollowCommand;
+import konkuk.thip.user.application.port.out.FollowingCommandPort;
+import konkuk.thip.user.domain.Following;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Objects;
+import java.util.Optional;
+
+import static konkuk.thip.common.exception.code.ErrorCode.USER_ALREADY_UNFOLLOWED;
+import static konkuk.thip.common.exception.code.ErrorCode.USER_CANNOT_FOLLOW_SELF;
+
+@Service
+@RequiredArgsConstructor
+public class UserFollowService implements UserFollowUsecase {
+
+    private final FollowingCommandPort followingCommandPort;
+
+    @Override
+    @Transactional
+    public Boolean changeFollowingState(UserFollowCommand followCommand) {
+        Long userId = followCommand.userId();
+        Long targetUserId = followCommand.targetUserId();
+        Boolean type = followCommand.type();
+
+        validateParams(userId, targetUserId);
+
+        Optional<Following> optionalFollowing = followingCommandPort.findByUserIdAndTargetUserId(userId, targetUserId);
+
+        if (optionalFollowing.isPresent()) { // 이미 팔로우 관계가 존재하는 경우
+            Following following = optionalFollowing.get();
+            boolean isFollowing = following.changeFollowingState(type);
+            followingCommandPort.updateStatus(following);
+            return isFollowing;
+        } else { // 팔로우 관계가 존재하지 않는 경우
+            if (!type) {
+                throw new InvalidStateException(USER_ALREADY_UNFOLLOWED); // 언팔로우 요청인데 팔로우 관계가 존재하지 않으므로 이미 언팔로우 상태
+            }
+            followingCommandPort.save(Following.withoutId(userId, targetUserId));
+            return true; // 새로 팔로우한 경우
+        }
+    }
+
+    private void validateParams(Long userId, Long targetUserId) {
+        if(Objects.equals(userId, targetUserId)) {
+            throw new InvalidStateException(USER_CANNOT_FOLLOW_SELF);
+        }
+    }
+}

src/main/java/konkuk/thip/user/domain/Following.java

@@ -1,9 +1,14 @@
 package konkuk.thip.user.domain;
 
 import konkuk.thip.common.entity.BaseDomainEntity;
+import konkuk.thip.common.entity.StatusType;
+import konkuk.thip.common.exception.InvalidStateException;
 import lombok.Getter;
 import lombok.experimental.SuperBuilder;
 
+import static konkuk.thip.common.exception.code.ErrorCode.USER_ALREADY_FOLLOWED;
+import static konkuk.thip.common.exception.code.ErrorCode.USER_ALREADY_UNFOLLOWED;
+
 @Getter
 @SuperBuilder
 public class Following extends BaseDomainEntity {
@@ -13,4 +18,30 @@ public class Following extends BaseDomainEntity {
     private Long userId;
 
     private Long followingUserId;
+
+    public static Following withoutId(Long userId, Long followingUserId) {
+        return Following.builder()
+                .userId(userId)
+                .followingUserId(followingUserId)
+                .status(StatusType.ACTIVE)
+                .build();
+    }
+
+    public boolean changeFollowingState(boolean isFollowRequest) {
+        StatusType currentStatus = getStatus();
+        validateFollowingState(isFollowRequest, currentStatus);
+
+        super.changeStatus();
+        return isFollowRequest;
+    }
+
+    private void validateFollowingState(boolean isFollowRequest, StatusType currentStatus) {
+        if (isFollowRequest && currentStatus == StatusType.ACTIVE) { // 팔로우 요청일 때 이미 팔로우 중인 경우
+            throw new InvalidStateException(USER_ALREADY_FOLLOWED);
+        }
+
+        if (!isFollowRequest && currentStatus == StatusType.INACTIVE) { // 언팔로우 요청일 때 이미 언팔로우 중인 경우
+            throw new InvalidStateException(USER_ALREADY_UNFOLLOWED);
+        }
+    }
 }

src/test/java/konkuk/thip/room/adapter/in/web/RoomGetMemberListApiTest.java

@@ -99,7 +99,7 @@ void setUp() {
 
     @AfterEach
     void tearDown() {
-        followingJpaRepository.deleteAll();
+        followingJpaRepository.deleteAllInBatch();
         userRoomJpaRepository.deleteAll();
         roomJpaRepository.deleteAll();
         bookJpaRepository.deleteAll();