chore: conflicts are fixed

.github/workflows/open-api-code-review.yml

@@ -0,0 +1,19 @@
+name: Code Review
+
+permissions:
+  contents: read
+  pull-requests: write
+
+on:
+  pull_request:
+    types: [ opened ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: anc95/ChatGPT-CodeReview@main
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          OPENAI_API_KEY: ${{ secrets.OPEN_API_KEY }}
+          LANGUAGE: Korean

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/storage/service/StorageService.java

@@ -0,0 +1,19 @@
+package kr.co.pennyway.api.apis.storage.service;
+
+import kr.co.pennyway.infra.client.aws.s3.AwsS3Provider;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.net.URI;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class StorageService {
+    private final AwsS3Provider awsS3Provider;
+
+    public URI getPresignedUrl(String type, String ext, String userId, String chatroomId) {
+        return awsS3Provider.generatedPresignedUrl(type, ext, userId, chatroomId);
+    }
+}

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/users/service/DeviceTokenRegisterService.java

@@ -0,0 +1,47 @@
+package kr.co.pennyway.api.apis.users.service;
+
+import kr.co.pennyway.domain.domains.device.domain.DeviceToken;
+import kr.co.pennyway.domain.domains.device.service.DeviceTokenService;
+import kr.co.pennyway.domain.domains.user.domain.User;
+import kr.co.pennyway.domain.domains.user.exception.UserErrorCode;
+import kr.co.pennyway.domain.domains.user.exception.UserErrorException;
+import kr.co.pennyway.domain.domains.user.service.UserService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Optional;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class DeviceTokenRegisterService {
+    private final UserService userService;
+    private final DeviceTokenService deviceTokenService;
+
+    @Transactional
+    public DeviceToken execute(Long userId, String token) {
+        User user = userService.readUser(userId).orElseThrow(() -> new UserErrorException(UserErrorCode.NOT_FOUND));
+
+        return getOrCreateDevice(user, token);
+    }
+
+    /**
+     * 사용자의 디바이스 토큰을 가져오거나 생성한다.
+     * <p>
+     * 이미 등록된 디바이스 토큰인 경우 마지막 로그인 시간을 갱신한다.
+     */
+    private DeviceToken getOrCreateDevice(User user, String token) {
+        Optional<DeviceToken> deviceToken = deviceTokenService.readDeviceByUserIdAndToken(user.getId(), token);
+
+        if (deviceToken.isPresent()) {
+            DeviceToken device = deviceToken.get();
+            device.activate();
+            device.updateLastSignedInAt();
+            return device;
+        } else {
+            return deviceTokenService.createDevice(DeviceToken.of(token, user));
+        }
+    }
+}

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/common/security/jwt/JwtClaimsParserUtil.java

@@ -0,0 +1,35 @@
+package kr.co.pennyway.api.common.security.jwt;
+
+import kr.co.pennyway.infra.common.jwt.JwtClaims;
+
+import java.util.function.Function;
+
+public class JwtClaimsParserUtil {
+    /**
+     * JwtClaims에서 key에 해당하는 값을 반환하는 메서드
+     *
+     * @return key에 해당하는 값이 없거나, 타입이 일치하지 않을 경우 null을 반환한다.
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> T getClaimsValue(JwtClaims claims, String key, Class<T> type) {
+        Object value = claims.getClaims().get(key);
+        if (value != null && type.isAssignableFrom(value.getClass())) {
+            return (T) value;
+        }
+        return null;
+    }
+
+    /**
+     * JwtClaims에서 valueConverter를 이용하여 key에 해당하는 값을 반환하는 메서드
+     *
+     * @param valueConverter : String 타입의 값을 T 타입으로 변환하는 함수
+     * @return key에 해당하는 값이 없을 경우 null을 반환한다.
+     */
+    public static <T> T getClaimsValue(JwtClaims claims, String key, Function<String, T> valueConverter) {
+        Object value = claims.getClaims().get(key);
+        if (value != null) {
+            return valueConverter.apply((String) value);
+        }
+        return null;
+    }
+}

pennyway-app-external-api/src/test/java/kr/co/pennyway/api/apis/users/service/NameUpdateServiceTest.java

@@ -0,0 +1,82 @@
+package kr.co.pennyway.api.apis.users.service;
+
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import kr.co.pennyway.api.apis.auth.service.PhoneVerificationService;
+import kr.co.pennyway.api.config.ExternalApiDBTestConfig;
+import kr.co.pennyway.api.config.fixture.UserFixture;
+import kr.co.pennyway.domain.common.redis.phone.PhoneCodeService;
+import kr.co.pennyway.domain.config.JpaConfig;
+import kr.co.pennyway.domain.domains.user.domain.User;
+import kr.co.pennyway.domain.domains.user.exception.UserErrorCode;
+import kr.co.pennyway.domain.domains.user.exception.UserErrorException;
+import kr.co.pennyway.domain.domains.user.service.UserService;
+import kr.co.pennyway.infra.client.aws.s3.AwsS3Provider;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.transaction.annotation.Transactional;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.springframework.test.util.AssertionErrors.assertEquals;
+
+@ExtendWith(MockitoExtension.class)
+@DataJpaTest(properties = "spring.jpa.hibernate.ddl-auto=create")
+@ContextConfiguration(classes = {JpaConfig.class, UserProfileUpdateService.class, UserService.class})
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+public class NameUpdateServiceTest extends ExternalApiDBTestConfig {
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private UserProfileUpdateService userProfileUpdateService;
+
+    @MockBean
+    private AwsS3Provider awsS3Provider;
+
+    @MockBean
+    private PhoneVerificationService phoneVerificationService;
+
+    @MockBean
+    private PhoneCodeService phoneCodeService;
+
+    @MockBean
+    private JPAQueryFactory queryFactory;
+
+    @Test
+    @Transactional
+    @DisplayName("사용자가 삭제된 유저인 경우 NOT_FOUND 에러를 반환한다.")
+    void updateNameWhenUserIsDeleted() {
+        // given
+        String newName = "양재서";
+        User originUser = UserFixture.GENERAL_USER.toUser();
+        userService.createUser(originUser);
+        userService.deleteUser(originUser);
+
+        // when - then
+        UserErrorException ex = assertThrows(UserErrorException.class, () -> userProfileUpdateService.updateName(originUser.getId(), newName));
+        assertEquals("삭제된 사용자인 경우 Not Found를 반환한다.", UserErrorCode.NOT_FOUND, ex.getBaseErrorCode());
+    }
+
+    @Test
+    @Transactional
+    @DisplayName("사용자의 이름이 성공적으로 변경된다.")
+    void updateName() {
+        // given
+        User originUser = UserFixture.GENERAL_USER.toUser();
+        userService.createUser(originUser);
+        String newName = "양재서";
+
+        // when
+        userProfileUpdateService.updateName(originUser.getId(), newName);
+
+        // then
+        User updatedUser = userService.readUser(originUser.getId()).orElseThrow();
+        assertEquals("사용자 이름이 변경되어 있어야 한다.", newName, updatedUser.getName());
+    }
+}

pennyway-app-external-api/src/test/java/kr/co/pennyway/api/apis/users/usecase/DeviceTokenRegisterServiceTest.java

@@ -0,0 +1,115 @@
+package kr.co.pennyway.api.apis.users.usecase;
+
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import kr.co.pennyway.api.apis.users.dto.DeviceTokenDto;
+import kr.co.pennyway.api.apis.users.service.DeviceTokenRegisterService;
+import kr.co.pennyway.api.config.ExternalApiDBTestConfig;
+import kr.co.pennyway.api.config.fixture.DeviceTokenFixture;
+import kr.co.pennyway.api.config.fixture.UserFixture;
+import kr.co.pennyway.domain.config.JpaConfig;
+import kr.co.pennyway.domain.domains.device.domain.DeviceToken;
+import kr.co.pennyway.domain.domains.device.service.DeviceTokenService;
+import kr.co.pennyway.domain.domains.user.domain.User;
+import kr.co.pennyway.domain.domains.user.service.UserService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.transaction.annotation.Transactional;
+
+import static org.springframework.test.util.AssertionErrors.*;
+
+@ExtendWith(MockitoExtension.class)
+@DataJpaTest(properties = "spring.jpa.hibernate.ddl-auto=create")
+@ContextConfiguration(classes = {JpaConfig.class, DeviceTokenRegisterService.class, UserService.class, DeviceTokenService.class})
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+public class DeviceTokenRegisterServiceTest extends ExternalApiDBTestConfig {
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private DeviceTokenService deviceTokenService;
+
+    @Autowired
+    private DeviceTokenRegisterService deviceTokenRegisterService;
+
+    @MockBean
+    private JPAQueryFactory queryFactory;
+
+    private User requestUser;
+
+    @BeforeEach
+    void setUp() {
+        requestUser = userService.createUser(UserFixture.GENERAL_USER.toUser());
+    }
+
+    @Test
+    @Transactional
+    @DisplayName("[1] token 등록 요청이 들어왔을 때, 새로운 디바이스 토큰을 등록한다.")
+    void registerNewDevice() {
+        // given
+        DeviceTokenDto.RegisterReq request = DeviceTokenFixture.INIT.toRegisterReq();
+
+        // when
+        DeviceToken response = deviceTokenRegisterService.execute(requestUser.getId(), request.token());
+
+        // then
+        deviceTokenService.readDeviceByUserIdAndToken(requestUser.getId(), request.token()).ifPresentOrElse(
+                device -> {
+                    assertEquals("요청한 디바이스 토큰과 동일해야 한다.", response.getToken(), device.getToken());
+                    assertEquals("디바이스 ID가 일치해야 한다.", response.getId(), device.getId());
+                    assertTrue("디바이스가 사용자 ID와 연결되어 있어야 한다.", device.getUser().getId().equals(requestUser.getId()));
+                    System.out.println("device = " + device);
+                },
+                () -> fail("신규 디바이스가 등록되어 있어야 한다.")
+        );
+    }
+
+    @Test
+    @Transactional
+    @DisplayName("[2] token에 대한 활성화 디바이스 토큰이 이미 존재하는 경우 기존 데이터를 반환한다.")
+    void registerNewDeviceWhenDeviceIsAlreadyExists() {
+        // given
+        DeviceToken originDeviceToken = DeviceTokenFixture.INIT.toDevice(requestUser);
+        deviceTokenService.createDevice(originDeviceToken);
+        DeviceTokenDto.RegisterReq request = DeviceTokenFixture.INIT.toRegisterReq();
+
+        // when
+        DeviceToken response = deviceTokenRegisterService.execute(requestUser.getId(), request.token());
+
+        // then
+        deviceTokenService.readDeviceByUserIdAndToken(requestUser.getId(), request.token()).ifPresentOrElse(
+                device -> {
+                    assertEquals("요청한 디바이스 토큰과 동일해야 한다.", response.getToken(), device.getToken());
+                    assertEquals("디바이스 ID가 일치해야 한다.", originDeviceToken.getId(), device.getId());
+                    assertTrue("디바이스가 사용자 ID와 연결되어 있어야 한다.", device.getUser().getId().equals(requestUser.getId()));
+                    assertTrue("디바이스가 활성화 상태여야 한다.", device.getActivated());
+                    System.out.println("device = " + device);
+                },
+                () -> fail("신규 디바이스가 등록되어 있어야 한다.")
+        );
+    }
+
+    @Test
+    @Transactional
+    @DisplayName("[3] token 등록 요청이 들어왔을 때, 활성화되지 않은 디바이스 토큰이 존재하는 경우 토큰을 활성화 상태로 변경한다.")
+    void registerNewDeviceWhenDeviceIsNotActivated() {
+        // given
+        DeviceToken originDeviceToken = DeviceTokenFixture.INIT.toDevice(requestUser);
+        originDeviceToken.deactivate();
+        deviceTokenService.createDevice(originDeviceToken);
+        DeviceTokenDto.RegisterReq request = DeviceTokenFixture.INIT.toRegisterReq();
+
+        // when
+        DeviceToken response = deviceTokenRegisterService.execute(requestUser.getId(), request.token());
+
+        // then
+        assertTrue("디바이스가 활성화 상태여야 한다.", response.getActivated());
+    }
+}