Merge pull request #98 from JangYouJung/develop

[ Feature ] 이메일 인증 구현 및 사용자 프로필 이미지 추가/삭제 구현

.github/workflows/deploy.yml

@@ -34,7 +34,6 @@ jobs:
           port: 22
           uploads: |
             ./build/libs/ => /root/apache-tomcat-10.1.24/build-target/
-
       - name: Change old WAR to new WAR
         uses: appleboy/[email protected]
         with:

build.gradle

@@ -34,8 +34,11 @@ dependencies {
 	implementation 'jakarta.validation:jakarta.validation-api:3.0.2'
 	implementation 'org.springframework.security:spring-security-messaging'
 
+	// mail
+	implementation 'org.springframework.boot:spring-boot-starter-mail:3.0.5'
+	implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
+
 	// JWT
-	// implementation 'io.jsonwebtoken:jjwt:0.9.1'
 	implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
 	implementation 'io.jsonwebtoken:jjwt-impl:0.11.5'
 	implementation 'io.jsonwebtoken:jjwt-jackson:0.11.5'

src/main/java/meltingpot/server/auth/controller/AuthController.java

@@ -6,6 +6,8 @@
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotBlank;
 import meltingpot.server.auth.controller.dto.*;
+import meltingpot.server.exception.AuthException;
+import meltingpot.server.exception.DuplicateException;
 import meltingpot.server.exception.InvalidTokenException;
 import meltingpot.server.util.ResponseCode;
 import meltingpot.server.util.ResponseData;
@@ -23,7 +25,7 @@
 @Validated
 @RequiredArgsConstructor
 @RestController
-@RequestMapping("auth")
+@RequestMapping("/api/v1/auth")
 public class AuthController {
 
     private final AuthService authService;
@@ -39,10 +41,15 @@ public class AuthController {
     public ResponseEntity<ResponseData<AccountResponseDto>> signup(
             @RequestBody @Valid SignupRequestDto request
     ){
-        AccountResponseDto data = authService.signup(request);
-        logger.info("SIGNUP_SUCCESS (200 OK) :: userId = {}, userEmail = {}",
-                data.getId(), data.getEmail());
-        return ResponseData.toResponseEntity(ResponseCode.SIGNUP_SUCCESS, data);
+        try{
+            AccountResponseDto data = authService.signup(request);
+            logger.info("SIGNUP_SUCCESS (200 OK) :: userId = {}, userEmail = {}",
+                    data.getId(), data.getEmail());
+            return ResponseData.toResponseEntity(ResponseCode.SIGNUP_SUCCESS, data);
+
+        }catch ( AuthException e ){
+            return ResponseData.toResponseEntity( e.getResponseCode(), null);
+        }
     }
 
     // 프로필 이미지 URL 생성
@@ -100,9 +107,6 @@ public ResponseEntity<ResponseData<ReissueTokenResponseDto>> reissueToken(
     }
 
 
-
-    // 이메일 인증
-
     // 비밀번호 재설정
 
     // 탈퇴

src/main/java/meltingpot/server/auth/controller/MailController.java

@@ -0,0 +1,82 @@
+package meltingpot.server.auth.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import meltingpot.server.auth.controller.dto.MailVerificationRequestDto;
+import meltingpot.server.auth.controller.dto.VerificationCodeRequestDto;
+import meltingpot.server.auth.service.MailService;
+import meltingpot.server.exception.DuplicateException;
+import meltingpot.server.exception.MailVerificationException;
+import meltingpot.server.util.ResponseCode;
+import meltingpot.server.util.ResponseData;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/mail")
+public class MailController {
+    private final MailService mailService;
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
+
+    // 정회원 인증 메일 전송
+    @PostMapping("")
+    @Operation(summary="이메일 인증번호 전송 [임시]", description="[이메일 인증 임시 구현 SMTP]\n 입력 받은 이메일로 인증 번호를 전송합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "MAIL_VERIFICATION_SEND_SUCCESS", description = "이메일 인증번호 전송 성공"),
+            @ApiResponse(responseCode = "VERIFICATION_CODE_ALREADY_EXIST", description = "이미 생성한 인증 번호가 있습니다"),
+            @ApiResponse(responseCode = "MAIL_SEND_FAIL", description = "이메일 전송 실패")
+    })
+    public ResponseEntity<ResponseData> sendVerificationMail(
+            @RequestBody @Valid MailVerificationRequestDto request
+    ) {
+        try{
+            logger.info("MAIL_VERIFICATION_SEND_SUCCESS (200 OK)");
+            return ResponseData.toResponseEntity(mailService.sendVerificationMail(request));
+
+        }catch(MailVerificationException e){
+            return ResponseData.toResponseEntity(e.getResponseCode());
+        }
+    }
+
+    @PostMapping("verification")
+    @Operation(summary="이메일 인증번호 확인", description="이메일 인증 번호를 입력 받고 올바른 번호인지 확인합니다." )
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "MAIL_VERIFICATION_CHECK_SUCCESS", description = "인증번호가 일치합니다"),
+            @ApiResponse(responseCode = "AUTHENTICATION_NOT_FOUND", description = "메일 인증 정보를 찾을 수 없습니다"),
+            @ApiResponse(responseCode = "AUTH_TIME_OUT", description = "인증 시간을 초과했습니다"),
+            @ApiResponse(responseCode = "AUTH_NUMBER_INCORRECT", description = "인증 번호가 틀렸습니다"),
+    })
+    public ResponseEntity<ResponseData> checkVerification(
+            @RequestBody @Valid VerificationCodeRequestDto request
+    ) {
+        try{
+            logger.info("VERIFICATION_CHECK_SUCCESS (200 OK)");
+        return ResponseData.toResponseEntity( mailService.checkVerification(request));
+
+        }catch(MailVerificationException e){
+            return ResponseData.toResponseEntity(e.getResponseCode());
+        }
+    }
+
+    // 이메일 중복 확인
+    @PostMapping("duplication")
+    @Operation(summary="이메일 중복 체크", description="이미 가입한 이메일인지 확인하는 API 입니다.\n" )
+    public ResponseEntity<ResponseData> checkEmail(
+            @RequestBody @Valid MailVerificationRequestDto request) {
+        try{
+            mailService.checkUserName(request.email());
+            return ResponseData.toResponseEntity(ResponseCode.MAIL_AVAILABLE);
+        }catch (DuplicateException e){
+            return ResponseData.toResponseEntity(ResponseCode.EMAIL_DUPLICATION);
+        }
+    }
+}

src/main/java/meltingpot/server/auth/controller/dto/MailVerificationRequestDto.java

@@ -0,0 +1,12 @@
+package meltingpot.server.auth.controller.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import meltingpot.server.util.VerificationUtil;
+
+public record MailVerificationRequestDto(
+        @NotBlank(message = "email is required")
+        @Pattern(regexp = VerificationUtil.USERNAME_REGEXP)
+        String email
+) {
+}

src/main/java/meltingpot/server/auth/controller/dto/VerificationCodeRequestDto.java

@@ -0,0 +1,14 @@
+package meltingpot.server.auth.controller.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import meltingpot.server.util.VerificationUtil;
+
+public record VerificationCodeRequestDto(
+        @NotBlank(message = "email is required")
+        @Pattern(regexp = VerificationUtil.USERNAME_REGEXP)
+        String email,
+        @NotBlank
+        String code
+) {
+}

src/main/java/meltingpot/server/auth/service/AuthService.java

@@ -8,9 +8,8 @@
 import meltingpot.server.domain.entity.AccountLanguage;
 import meltingpot.server.domain.entity.AccountProfileImage;
 import meltingpot.server.domain.entity.enums.Gender;
-import meltingpot.server.exception.DuplicateException;
-import meltingpot.server.exception.InvalidTokenException;
-import meltingpot.server.exception.ResourceNotFoundException;
+import meltingpot.server.domain.repository.MailVerificationRepository;
+import meltingpot.server.exception.*;
 import meltingpot.server.config.TokenProvider;
 import meltingpot.server.domain.entity.RefreshToken;
 import meltingpot.server.domain.entity.Account;
@@ -47,13 +46,22 @@ public class AuthService implements UserDetailsService {
     private final RefreshTokenRepository refreshTokenRepository;
     private final PasswordEncoder passwordEncoder;
     private final FileService fileService;
+    private final MailVerificationRepository mailVerificationRepository;
 
     // 회원가입
     @Transactional
     public AccountResponseDto signup(SignupRequestDto signupRequest) {
 
-        // 이메일(아이디) 중복 검사
-        checkUserName(signupRequest.email());
+        // TODO 개발 완료 후 이메일 인증 확인 주석 풀기
+//        // 이메일 인증을 거친 유효한 이메일인지 확인
+//        if(!mailVerificationRepository.existsByEmailAndVerifiedTrue(signupRequest.email())){
+//            throw new AuthException(ResponseCode.MAIL_NOT_AUTHORIZED);
+//        };
+
+        // 이미 가입한 이메일인지 확인
+        if(accountRepository.existsByUsername(signupRequest.email())){
+            throw new AuthException(ResponseCode.EMAIL_DUPLICATION);
+        }
 
         Account account = Account.builder()
                 .username(signupRequest.email())
@@ -160,14 +168,6 @@ public UserDetails loadUserByUsername(String username) throws UsernameNotFoundEx
         return new AccountUser(account);
     }
 
-    // 회원가입시 이메일 유효성 확인
-    @Transactional(readOnly = true)
-    public void checkUserName(String username) {
-        if(accountRepository.existsByUsername(username)){
-            throw new DuplicateException(ResponseCode.EMAIL_DUPLICATION);
-        }
-    }
-
     @Transactional(rollbackFor = Exception.class)
     public ReissueTokenResponseDto reissueToken( String oldAccessToken, String refreshToken ) {
         TokenDto reissuedTokenDto;

src/main/java/meltingpot/server/auth/service/MailService.java

@@ -0,0 +1,121 @@
+package meltingpot.server.auth.service;
+
+import lombok.RequiredArgsConstructor;
+import meltingpot.server.auth.controller.dto.MailVerificationRequestDto;
+import meltingpot.server.auth.controller.dto.VerificationCodeRequestDto;
+import meltingpot.server.domain.entity.Constants;
+import meltingpot.server.domain.entity.MailVerification;
+import meltingpot.server.domain.repository.AccountRepository;
+import meltingpot.server.domain.repository.MailVerificationRepository;
+import meltingpot.server.exception.DuplicateException;
+import meltingpot.server.exception.MailVerificationException;
+import meltingpot.server.util.MailUtil;
+import meltingpot.server.util.ResponseCode;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.time.LocalDateTime;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Random;
+
+@RequiredArgsConstructor
+@Service
+public class MailService {
+    private final MailVerificationRepository mailVerificationRepository;
+    private final MailUtil mailUtil;
+    private final AccountRepository accountRepository;
+
+    // 인증 코드 생성
+    private String createCode() {
+        try {
+            Random rand = SecureRandom.getInstanceStrong();
+            StringBuilder code = new StringBuilder();
+
+            for (int i = 0; i < 6; i++) {
+                // 0~9까지 난수 생성
+                String num = Integer.toString(rand.nextInt(10));
+                code.append(num);
+            }
+
+            return code.toString();
+
+        } catch (NoSuchAlgorithmException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    // 인증 메일 발송
+    @Transactional
+    public ResponseCode sendVerificationMail(MailVerificationRequestDto request) {
+        String email = request.email();
+
+        // 이미 유효한 인증 정보가 있는 경우
+        Optional<MailVerification> oldMailVerification = mailVerificationRepository.findByEmailAndExpiredAtIsAfterNowAndVerifiedFalse(email,LocalDateTime.now());
+        if(oldMailVerification.isPresent()){
+            throw new MailVerificationException(ResponseCode.VERIFICATION_CODE_ALREADY_EXIST);
+        }
+
+        String code = createCode();
+        Map<String,String> mailValues = Map.of("code", code);
+
+        String title = "[멜팅팟] 이메일 인증을 위한 인증 번호 안내";
+
+        // 메일 전송
+        mailUtil.sendMimeMessageMailWithValues(title, email, "EmailAuthenticationForm.html", mailValues);
+
+        LocalDateTime expiredAt = LocalDateTime.now().plusMinutes(Constants.AUTH_TIME_LIMIT);
+
+        MailVerification mailVerification = MailVerification.builder()
+                .email(email)
+                .expiredAt(expiredAt)
+                .authenticationNumber(code)
+                .build();
+
+        mailVerificationRepository.save(mailVerification);
+
+        return ResponseCode.MAIL_VERIFICATION_SEND_SUCCESS;
+
+    }
+
+
+    // 인증 번호 확인
+    @Transactional
+    public ResponseCode checkVerification(VerificationCodeRequestDto request) {
+
+        // 현재 유효한 인증 정보 가져오기
+        MailVerification mailVerification = mailVerificationRepository.findByEmailAndExpiredAtIsAfterNowAndVerifiedFalse(request.email(), LocalDateTime.now())
+                .orElseThrow( // 인증 정보가 없는 경우
+                        ()->new MailVerificationException(ResponseCode.AUTHENTICATION_NOT_FOUND)
+                );
+
+        // 인증 번호 유효 기간을 초과한 경우
+        if(LocalDateTime.now().isAfter(mailVerification.getExpiredAt())){
+            throw new MailVerificationException(ResponseCode.AUTH_TIME_OUT);
+        }
+
+        // 인증 번호가 틀린 경우
+        if(!mailVerification.getAuthenticationNumber().equals(request.code())){
+            throw new MailVerificationException(ResponseCode.AUTH_NUMBER_INCORRECT);
+        }
+
+        // 인증에 성공한 경우: 제한 시간 내에 인증 번호를 올바르게 입력한 경우
+        mailVerification.setVerified(true);
+        mailVerificationRepository.save(mailVerification);
+
+        return ResponseCode.MAIL_VERIFICATION_CHECK_SUCCESS;
+
+    }
+
+    // 회원가입시 이메일 유효성 확인
+    @Transactional(readOnly = true)
+    public void checkUserName(String username) {
+        if(accountRepository.existsByUsername(username)){
+            throw new DuplicateException(ResponseCode.EMAIL_DUPLICATION);
+        }
+    }
+
+}

src/main/java/meltingpot/server/config/JwtFilter.java

@@ -44,7 +44,7 @@ protected void doFilterInternal(HttpServletRequest request, HttpServletResponse
         // 정상 토큰이면 해당 토큰으로 Authentication 을 가져와서 SecurityContext 에 저장
         // 권한이 필요하지 않은 요청은 custom jwt filter를 거치지 않도록 설정
         if (request.getRequestURI().contains("/contract") || request.getRequestURI()
-                .contains("/auth") || request.getRequestURI().contains("/mail/reset-password")
+                .contains("/api/v1/auth") || request.getRequestURI().contains("/api/v1/mail")
                 || request.getRequestURI().contains("/docs") || request.getRequestURI()
                 .contains("/favicon.ico") || request.getRequestURI().contains("/h2-console") ||
                 request.getRequestURI().contains("/swagger-ui") ||

src/main/java/meltingpot/server/config/SecurityConfig.java

@@ -35,7 +35,7 @@ protected SecurityFilterChain filterChain(HttpSecurity http, TokenProvider token
                 //TODO 개발 완료 후 permitAll 삭제
                 .authorizeHttpRequests((authorizeRequests) ->
                         authorizeRequests.requestMatchers("/swagger", "/swagger-ui.html", "/swagger-ui/**", "/api-docs", "/api-docs/**", "/v3/api-docs/**", "/chat/**").permitAll()
-                                .requestMatchers("/auth/**", "/api/v1/**").permitAll()
+                                .requestMatchers("/ws/**","/api/v1/**").permitAll()
                                 .anyRequest().authenticated()
                 );
 

src/main/java/meltingpot/server/domain/entity/Constants.java

@@ -0,0 +1,14 @@
+package meltingpot.server.domain.entity;
+
+public final class Constants {
+
+    // 이메일 인증 시도 제한 횟수
+    public static final Integer LIMIT_ATTEMPT_COUNT = 5;
+
+    // 이메일 인증 제한 쿨타임 시간(분)
+    public static final Integer COOL_TIME_MINUTE = 5;
+
+    // 이메일 인증 번호 확인 제한 시간(분)
+    public static final Integer AUTH_TIME_LIMIT = 10;
+
+}