Merge pull request #20 from PSR-Co/feat/#19-login

[feat] 로그인 API & Token User 객체 반환

src/main/kotlin/com/psr/psr/global/exception/BaseResponseCode.kt

@@ -16,6 +16,8 @@ enum class BaseResponseCode(status: HttpStatus, message: String) {
     EXISTS_PHONE(HttpStatus.BAD_REQUEST, "이미 가입되어 있는 휴대폰 번호입니다."),
     EXISTS_EMAIL(HttpStatus.BAD_REQUEST, "이미 가입되어 있는 이메일입니다."),
     EXISTS_NICKNAME(HttpStatus.BAD_REQUEST, "이미 가입되어 있는 닉네임입니다."),
+    NOT_EXIST_EMAIL(HttpStatus.BAD_REQUEST, "해당 이메일로 가입한 사용자를 찾을 수 없습니다."),
+    INVALID_PASSWORD(HttpStatus.BAD_REQUEST, "사용자의 비밀번호가 일치하지 않습니다."),
     NOT_FOUND_USER(HttpStatus.NOT_FOUND, "사용자를 찾을 수 없습니다."),
 
     // User - type

src/main/kotlin/com/psr/psr/global/jwt/UserDetailsImpl.kt → src/main/kotlin/com/psr/psr/global/jwt/UserAccount.kt

@@ -5,14 +5,14 @@ import org.springframework.security.core.GrantedAuthority
 import org.springframework.security.core.authority.SimpleGrantedAuthority
 import org.springframework.security.core.userdetails.UserDetails
 
-class UserDetailsImpl(val user:User) :UserDetails {
+class UserAccount(private val user:User) :UserDetails {
 
     var enabled: Boolean = true
     override fun getAuthorities(): MutableCollection<out GrantedAuthority> {
         val grantedAuthority = SimpleGrantedAuthority(user.type.name)
         return mutableListOf(grantedAuthority)
     }
-    fun getUserId() : Long = user.id!!
+    fun getUser() : User = user
     override fun getPassword(): String = user.password
 
     override fun getUsername(): String = user.id.toString()

src/main/kotlin/com/psr/psr/global/jwt/UserDetailsServiceImpl.kt

@@ -13,12 +13,12 @@ import org.springframework.transaction.annotation.Transactional
 class UserDetailsServiceImpl(private val userRepository: UserRepository) :UserDetailsService {
     override fun loadUserByUsername(username: String?): UserDetails {
         val user:User = userRepository.findByIdOrNull(username?.toLong() ?: 0L) ?: throw UsernameNotFoundException("사용자 id를 찾을 수 없습니다.")
-        return UserDetailsImpl(user)
+        return UserAccount(user)
     }
 
     @Transactional
     fun loadUserById(id: Long): UserDetails {
         val user = userRepository.findById(id).orElseThrow { UsernameNotFoundException("User not found with id : $id") }
-        return UserDetailsImpl(user)
+        return UserAccount(user)
     }
 }

src/main/kotlin/com/psr/psr/user/controller/UserController.kt

@@ -2,6 +2,7 @@ package com.psr.psr.user.controller
 
 import com.psr.psr.global.dto.BaseResponse
 import com.psr.psr.global.jwt.dto.TokenRes
+import com.psr.psr.user.dto.LoginReq
 import com.psr.psr.user.dto.SignUpReq
 import com.psr.psr.user.service.UserService
 import org.springframework.validation.annotation.Validated
@@ -20,4 +21,13 @@ class UserController(
         fun signUp (@RequestBody @Validated signUpReq:  SignUpReq) : BaseResponse<TokenRes>{
                return BaseResponse(userService.signUp(signUpReq))
         }
+
+        /**
+         * 로그인
+         */
+        @PostMapping("/login")
+        @ResponseBody
+        fun login (@RequestBody @Validated loginReq: LoginReq) : BaseResponse<TokenRes>{
+                return BaseResponse(userService.login(loginReq))
+        }
 }

src/main/kotlin/com/psr/psr/user/dto/LoginReq.kt

@@ -0,0 +1,24 @@
+package com.psr.psr.user.dto
+
+import com.psr.psr.user.entity.*
+import jakarta.annotation.Nullable
+import jakarta.validation.constraints.Email
+import jakarta.validation.constraints.NotBlank
+import jakarta.validation.constraints.NotEmpty
+import jakarta.validation.constraints.Pattern
+import org.jetbrains.annotations.NotNull
+import java.util.stream.Collectors
+
+
+data class LoginReq (
+    @field:NotBlank
+    @field:Email(message = "올바르지 않은 이메일 형식입니다.")
+    val email: String,
+    @field:NotBlank
+    @field:Pattern(
+        regexp = "^.*(?=^.{8,15}\$)(?=.*\\d)(?=.*[a-zA-Z])(?=.*[!@#\$%^&+=]).*\$",
+        message = "비밀번호를 숫자, 문자, 특수문자 포함 8~15자리 이내로 입력해주세요"
+    )
+    var password: String
+    ) {
+}

src/main/kotlin/com/psr/psr/user/repository/UserRepository.kt

@@ -10,4 +10,5 @@ interface UserRepository: JpaRepository<User, Long> {
     fun existsByNickname(nickname: String): Boolean
     fun existsByPhone(phone: String): Boolean
     fun existsByEmail(nickname: String): Boolean
+    fun findByEmail(email:String): Optional<User>
 }

src/main/kotlin/com/psr/psr/user/service/UserService.kt

@@ -2,8 +2,11 @@ package com.psr.psr.user.service
 
 import com.psr.psr.global.exception.BaseException
 import com.psr.psr.global.exception.BaseResponseCode
+import com.psr.psr.global.exception.BaseResponseCode.INVALID_PASSWORD
+import com.psr.psr.global.exception.BaseResponseCode.NOT_EXIST_EMAIL
 import com.psr.psr.global.jwt.dto.TokenRes
 import com.psr.psr.global.jwt.utils.JwtUtils
+import com.psr.psr.user.dto.LoginReq
 import com.psr.psr.user.dto.SignUpReq
 import com.psr.psr.user.entity.User
 import com.psr.psr.user.repository.UserInterestRepository
@@ -54,6 +57,13 @@ class UserService(
         return createToken(user, password)
     }
 
+    // 로그인
+    fun login(loginReq: LoginReq) : TokenRes{
+        val user = userRepository.findByEmail(loginReq.email).orElseThrow{BaseException(NOT_EXIST_EMAIL)}
+        if(!passwordEncoder.matches(loginReq.password, user.password)) throw BaseException(INVALID_PASSWORD)
+        return createToken(user, loginReq.password)
+    }
+
     // 정규 표현식 확인 extract method
     private fun isValidRegularExpression(word: String, validation: String) : Boolean{
         val pattern = Pattern.compile(validation)