feat: 이메일 인증 구현

src/main/java/com/example/solidconnection/auth/controller/AuthController.java

@@ -1,17 +1,25 @@
 package com.example.solidconnection.auth.controller;
 
+import com.example.solidconnection.auth.dto.EmailSignInRequest;
+import com.example.solidconnection.auth.dto.EmailSignUpTokenRequest;
+import com.example.solidconnection.auth.dto.EmailSignUpTokenResponse;
 import com.example.solidconnection.auth.dto.ReissueResponse;
 import com.example.solidconnection.auth.dto.SignInResponse;
 import com.example.solidconnection.auth.dto.SignUpRequest;
 import com.example.solidconnection.auth.dto.oauth.OAuthCodeRequest;
 import com.example.solidconnection.auth.dto.oauth.OAuthResponse;
 import com.example.solidconnection.auth.service.AuthService;
+import com.example.solidconnection.auth.service.CommonSignUpTokenProvider;
+import com.example.solidconnection.auth.service.EmailSignInService;
+import com.example.solidconnection.auth.service.EmailSignUpService;
+import com.example.solidconnection.auth.service.EmailSignUpTokenProvider;
 import com.example.solidconnection.auth.service.oauth.AppleOAuthService;
 import com.example.solidconnection.auth.service.oauth.KakaoOAuthService;
 import com.example.solidconnection.auth.service.oauth.OAuthSignUpService;
 import com.example.solidconnection.custom.resolver.AuthorizedUser;
 import com.example.solidconnection.custom.resolver.ExpiredToken;
 import com.example.solidconnection.custom.security.authentication.ExpiredTokenAuthentication;
+import com.example.solidconnection.siteuser.domain.AuthType;
 import com.example.solidconnection.siteuser.domain.SiteUser;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
@@ -31,6 +39,10 @@ public class AuthController {
     private final OAuthSignUpService oAuthSignUpService;
     private final AppleOAuthService appleOAuthService;
     private final KakaoOAuthService kakaoOAuthService;
+    private final EmailSignInService emailSignInService;
+    private final EmailSignUpService emailSignUpService;
+    private final EmailSignUpTokenProvider emailSignUpTokenProvider;
+    private final CommonSignUpTokenProvider commonSignUpTokenProvider;
 
     @PostMapping("/apple")
     public ResponseEntity<OAuthResponse> processAppleOAuth(
@@ -48,10 +60,33 @@ public ResponseEntity<OAuthResponse> processKakaoOAuth(
         return ResponseEntity.ok(oAuthResponse);
     }
 
+    @PostMapping("/email/sign-in")
+    public ResponseEntity<SignInResponse> signInWithEmail(
+            @Valid @RequestBody EmailSignInRequest signInRequest
+    ) {
+        SignInResponse signInResponse = emailSignInService.signIn(signInRequest);
+        return ResponseEntity.ok(signInResponse);
+    }
+
+    /* 이메일 회원가입 시 signUpToken 을 발급받기 위한 api */
+    @PostMapping("/email/sign-up")
+    public ResponseEntity<EmailSignUpTokenResponse> signUpWithEmail(
+            @Valid @RequestBody EmailSignUpTokenRequest signUpRequest
+    ) {
+        emailSignUpService.validateUniqueEmail(signUpRequest.email());
+        String signUpToken = emailSignUpTokenProvider.generateAndSaveSignUpToken(signUpRequest);
+        return ResponseEntity.ok(new EmailSignUpTokenResponse(signUpToken));
+    }
+
     @PostMapping("/sign-up")
     public ResponseEntity<SignInResponse> signUp(
             @Valid @RequestBody SignUpRequest signUpRequest
     ) {
+        AuthType authType = commonSignUpTokenProvider.parseAuthType(signUpRequest.signUpToken());
+        if (AuthType.isEmail(authType)) {
+            SignInResponse signInResponse = emailSignUpService.signUp(signUpRequest);
+            return ResponseEntity.ok(signInResponse);
+        }
         SignInResponse signInResponse = oAuthSignUpService.signUp(signUpRequest);
         return ResponseEntity.ok(signInResponse);
     }

src/main/java/com/example/solidconnection/auth/dto/EmailSignInRequest.java

@@ -0,0 +1,13 @@
+package com.example.solidconnection.auth.dto;
+
+import jakarta.validation.constraints.NotBlank;
+
+public record EmailSignInRequest(
+
+        @NotBlank(message = "이메일을 입력해주세요.")
+        String email,
+
+        @NotBlank(message = "비밀번호를 입력해주세요.")
+        String password
+) {
+}

src/main/java/com/example/solidconnection/auth/dto/EmailSignUpTokenRequest.java

@@ -0,0 +1,14 @@
+package com.example.solidconnection.auth.dto;
+
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+
+public record EmailSignUpTokenRequest(
+
+        @Email(message = "이메일을 입력해주세요.")
+        String email,
+
+        @NotBlank(message = "비밀번호를 입력해주세요.")
+        String password
+) {
+}

src/main/java/com/example/solidconnection/auth/dto/EmailSignUpTokenResponse.java

@@ -0,0 +1,6 @@
+package com.example.solidconnection.auth.dto;
+
+public record EmailSignUpTokenResponse(
+        String signUpToken
+) {
+}

src/main/java/com/example/solidconnection/auth/dto/SignUpRequest.java

@@ -24,7 +24,7 @@ public record SignUpRequest(
         @JsonFormat(pattern = "yyyy-MM-dd")
         String birth) {
 
-    public SiteUser toSiteUser(String email, AuthType authType) {
+    public SiteUser toOAuthSiteUser(String email, AuthType authType) {
         return new SiteUser(
                 email,
                 this.nickname,
@@ -36,4 +36,18 @@ public SiteUser toSiteUser(String email, AuthType authType) {
                 authType
         );
     }
+
+    public SiteUser toEmailSiteUser(String email, String encodedPassword) {
+        return new SiteUser(
+                email,
+                this.nickname,
+                this.profileImageUrl,
+                this.birth,
+                this.preparationStatus,
+                Role.MENTEE,
+                this.gender,
+                AuthType.EMAIL,
+                encodedPassword
+        );
+    }
 }

src/main/java/com/example/solidconnection/auth/service/CommonSignUpTokenProvider.java

@@ -0,0 +1,27 @@
+package com.example.solidconnection.auth.service;
+
+import com.example.solidconnection.config.security.JwtProperties;
+import com.example.solidconnection.custom.exception.CustomException;
+import com.example.solidconnection.siteuser.domain.AuthType;
+import com.example.solidconnection.util.JwtUtils;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import static com.example.solidconnection.auth.service.EmailSignUpTokenProvider.AUTH_TYPE_CLAIM_KEY;
+import static com.example.solidconnection.custom.exception.ErrorCode.SIGN_UP_TOKEN_INVALID;
+
+@Component
+@RequiredArgsConstructor
+public class CommonSignUpTokenProvider {
+
+    private final JwtProperties jwtProperties;
+
+    public AuthType parseAuthType(String signUpToken) {
+        try {
+            String authTypeStr = JwtUtils.parseClaims(signUpToken, jwtProperties.secret()).get(AUTH_TYPE_CLAIM_KEY, String.class);
+            return AuthType.valueOf(authTypeStr);
+        } catch (Exception e) {
+            throw new CustomException(SIGN_UP_TOKEN_INVALID);
+        }
+    }
+}

src/main/java/com/example/solidconnection/auth/service/EmailSignInService.java

@@ -0,0 +1,43 @@
+package com.example.solidconnection.auth.service;
+
+import com.example.solidconnection.auth.dto.EmailSignInRequest;
+import com.example.solidconnection.auth.dto.SignInResponse;
+import com.example.solidconnection.custom.exception.CustomException;
+import com.example.solidconnection.siteuser.domain.AuthType;
+import com.example.solidconnection.siteuser.domain.SiteUser;
+import com.example.solidconnection.siteuser.repository.SiteUserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+import static com.example.solidconnection.custom.exception.ErrorCode.USER_NOT_FOUND;
+
+/*
+ * 보안을 위해 이메일과 비밀번호 중 무엇이 틀렸는지 구체적으로 응답하지 않는다.
+ * */
+@Service
+@RequiredArgsConstructor
+public class EmailSignInService {
+
+    private final SignInService signInService;
+    private final SiteUserRepository siteUserRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    public SignInResponse signIn(EmailSignInRequest signInRequest) {
+        Optional<SiteUser> optionalSiteUser = siteUserRepository.findByEmailAndAuthType(signInRequest.email(), AuthType.EMAIL);
+        if (optionalSiteUser.isPresent()) {
+            SiteUser siteUser = optionalSiteUser.get();
+            validatePassword(signInRequest.password(), siteUser.getPassword());
+            return signInService.signIn(siteUser);
+        }
+        throw new CustomException(USER_NOT_FOUND, "이메일과 비밀번호를 확인해주세요.");
+    }
+
+    private void validatePassword(String rawPassword, String encodedPassword) throws CustomException {
+        if (!passwordEncoder.matches(rawPassword, encodedPassword)) {
+            throw new CustomException(USER_NOT_FOUND, "이메일과 비밀번호를 확인해주세요.");
+        }
+    }
+}

src/main/java/com/example/solidconnection/auth/service/EmailSignUpService.java

@@ -0,0 +1,54 @@
+package com.example.solidconnection.auth.service;
+
+import com.example.solidconnection.auth.dto.SignUpRequest;
+import com.example.solidconnection.custom.exception.CustomException;
+import com.example.solidconnection.repositories.CountryRepository;
+import com.example.solidconnection.repositories.InterestedCountyRepository;
+import com.example.solidconnection.repositories.InterestedRegionRepository;
+import com.example.solidconnection.repositories.RegionRepository;
+import com.example.solidconnection.siteuser.domain.AuthType;
+import com.example.solidconnection.siteuser.domain.SiteUser;
+import com.example.solidconnection.siteuser.repository.SiteUserRepository;
+import org.springframework.stereotype.Service;
+
+import static com.example.solidconnection.custom.exception.ErrorCode.USER_ALREADY_EXISTED;
+
+@Service
+public class EmailSignUpService extends SignUpService {
+
+    private final EmailSignUpTokenProvider emailSignUpTokenProvider;
+
+    public EmailSignUpService(SignInService signInService, SiteUserRepository siteUserRepository,
+                              RegionRepository regionRepository, InterestedRegionRepository interestedRegionRepository,
+                              CountryRepository countryRepository, InterestedCountyRepository interestedCountyRepository,
+                              EmailSignUpTokenProvider emailSignUpTokenProvider) {
+        super(signInService, siteUserRepository, regionRepository, interestedRegionRepository, countryRepository, interestedCountyRepository);
+        this.emailSignUpTokenProvider = emailSignUpTokenProvider;
+    }
+
+    public void validateUniqueEmail(String email) {
+        if (siteUserRepository.existsByEmailAndAuthType(email, AuthType.EMAIL)) {
+            throw new CustomException(USER_ALREADY_EXISTED);
+        }
+    }
+
+    @Override
+    protected void validateSignUpToken(SignUpRequest signUpRequest) {
+        emailSignUpTokenProvider.validateSignUpToken(signUpRequest.signUpToken());
+    }
+
+    @Override
+    protected void validateUserNotDuplicated(SignUpRequest signUpRequest) {
+        String email = emailSignUpTokenProvider.parseEmail(signUpRequest.signUpToken());
+        if (siteUserRepository.existsByEmailAndAuthType(email, AuthType.EMAIL)) {
+            throw new CustomException(USER_ALREADY_EXISTED);
+        }
+    }
+
+    @Override
+    protected SiteUser createSiteUser(SignUpRequest signUpRequest) {
+        String email = emailSignUpTokenProvider.parseEmail(signUpRequest.signUpToken());
+        String encodedPassword = emailSignUpTokenProvider.parseEncodedPassword(signUpRequest.signUpToken());
+        return signUpRequest.toEmailSiteUser(email, encodedPassword);
+    }
+}

src/main/java/com/example/solidconnection/auth/service/EmailSignUpTokenProvider.java

@@ -0,0 +1,92 @@
+package com.example.solidconnection.auth.service;
+
+import com.example.solidconnection.auth.domain.TokenType;
+import com.example.solidconnection.auth.dto.EmailSignUpTokenRequest;
+import com.example.solidconnection.config.security.JwtProperties;
+import com.example.solidconnection.custom.exception.CustomException;
+import com.example.solidconnection.siteuser.domain.AuthType;
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import static com.example.solidconnection.custom.exception.ErrorCode.SIGN_UP_TOKEN_INVALID;
+import static com.example.solidconnection.custom.exception.ErrorCode.SIGN_UP_TOKEN_NOT_ISSUED_BY_SERVER;
+import static com.example.solidconnection.util.JwtUtils.parseClaims;
+import static com.example.solidconnection.util.JwtUtils.parseSubject;
+
+@Component
+public class EmailSignUpTokenProvider extends TokenProvider {
+
+    static final String PASSWORD_CLAIM_KEY = "password";
+    static final String AUTH_TYPE_CLAIM_KEY = "authType";
+
+    private final PasswordEncoder passwordEncoder;
+
+    public EmailSignUpTokenProvider(JwtProperties jwtProperties, RedisTemplate<String, String> redisTemplate,
+                                    PasswordEncoder passwordEncoder) {
+        super(jwtProperties, redisTemplate);
+        this.passwordEncoder = passwordEncoder;
+    }
+
+    public String generateAndSaveSignUpToken(EmailSignUpTokenRequest request) {
+        String email = request.email();
+        String password = request.password();
+        String encodedPassword = passwordEncoder.encode(password);
+        Map<String, Object> emailSignUpClaims = new HashMap<>(Map.of(
+                PASSWORD_CLAIM_KEY, encodedPassword,
+                AUTH_TYPE_CLAIM_KEY, AuthType.EMAIL
+        ));
+        Claims claims = Jwts.claims(emailSignUpClaims).setSubject(email);
+        Date now = new Date();
+        Date expiredDate = new Date(now.getTime() + TokenType.SIGN_UP.getExpireTime());
+
+        String signUpToken = Jwts.builder()
+                .setClaims(claims)
+                .setIssuedAt(now)
+                .setExpiration(expiredDate)
+                .signWith(SignatureAlgorithm.HS512, jwtProperties.secret())
+                .compact();
+        return saveToken(signUpToken, TokenType.SIGN_UP);
+    }
+
+    public void validateSignUpToken(String token) {
+        validateFormatAndExpiration(token);
+        String email = parseEmail(token);
+        validateIssuedByServer(email);
+    }
+
+    private void validateFormatAndExpiration(String token) {
+        try {
+            Claims claims = parseClaims(token, jwtProperties.secret());
+            Objects.requireNonNull(claims.getSubject());
+            String encodedPassword = claims.get(PASSWORD_CLAIM_KEY, String.class);
+            Objects.requireNonNull(encodedPassword);
+        } catch (Exception e) {
+            throw new CustomException(SIGN_UP_TOKEN_INVALID);
+        }
+    }
+
+    private void validateIssuedByServer(String email) {
+        String key = TokenType.SIGN_UP.addPrefix(email);
+        if (redisTemplate.opsForValue().get(key) == null) {
+            throw new CustomException(SIGN_UP_TOKEN_NOT_ISSUED_BY_SERVER);
+        }
+    }
+
+    public String parseEmail(String token) {
+        return parseSubject(token, jwtProperties.secret());
+    }
+
+    public String parseEncodedPassword(String token) {
+        Claims claims = parseClaims(token, jwtProperties.secret());
+        return claims.get(PASSWORD_CLAIM_KEY, String.class);
+    }
+}