feat(be):User도메인 1차 구현

Author: 정동하

src/main/kotlin/com/back/koreaTravelGuide/domain/user/controller/GuideController.kt

@@ -0,0 +1,51 @@
+package com.back.koreaTravelGuide.domain.guide.controller
+
+import com.back.koreaTravelGuide.common.ApiResponse
+import com.back.koreaTravelGuide.domain.guide.service.GuideService
+import com.back.koreaTravelGuide.domain.user.dto.request.GuideUpdateRequest
+import com.back.koreaTravelGuide.domain.user.dto.response.GuideResponse
+import io.swagger.v3.oas.annotations.Operation
+import io.swagger.v3.oas.annotations.tags.Tag
+import org.springframework.http.ResponseEntity
+import org.springframework.security.access.prepost.PreAuthorize
+import org.springframework.security.core.annotation.AuthenticationPrincipal
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PatchMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+
+@Tag(name = "가이드 API", description = "가이드 조회 및 프로필 관리에 대한 API")
+@RestController
+@RequestMapping("/api/guides")
+class GuideController(
+    private val guideService: GuideService,
+) {
+    @Operation(summary = "가이드 목록 조회")
+    @GetMapping
+    fun getAllGuides(): ResponseEntity<ApiResponse<List<GuideResponse>>> {
+        val guides = guideService.getAllGuides()
+        return ResponseEntity.ok(ApiResponse("전체 가이드 목록을 조회했습니다.", guides))
+    }
+
+    @Operation(summary = "가이드 단건 조회")
+    @GetMapping("/{guideId}")
+    fun getGuideById(
+        @PathVariable guideId: Long,
+    ): ResponseEntity<ApiResponse<GuideResponse>> {
+        val guide = guideService.getGuideById(guideId)
+        return ResponseEntity.ok(ApiResponse("가이드 정보를 성공적으로 조회했습니다.", guide))
+    }
+
+    @Operation(summary = "가이드 프로필 수정")
+    @PreAuthorize("hasRole('GUIDE')")
+    @PatchMapping("/me")
+    fun updateMyGuideProfile(
+        @AuthenticationPrincipal guideId: Long,
+        @RequestBody request: GuideUpdateRequest,
+    ): ResponseEntity<ApiResponse<GuideResponse>> {
+        val updatedGuideProfile = guideService.updateGuideProfile(guideId, request)
+        return ResponseEntity.ok(ApiResponse("가이드 정보가 성공적으로 수정되었습니다.", updatedGuideProfile))
+    }
+}

src/main/kotlin/com/back/koreaTravelGuide/domain/user/controller/UserController.kt

@@ -4,61 +4,46 @@ import com.back.koreaTravelGuide.common.ApiResponse
 import com.back.koreaTravelGuide.domain.user.dto.request.UserUpdateRequest
 import com.back.koreaTravelGuide.domain.user.dto.response.UserResponse
 import com.back.koreaTravelGuide.domain.user.service.UserService
+import io.swagger.v3.oas.annotations.Operation
 import org.springframework.http.ResponseEntity
 import org.springframework.security.core.annotation.AuthenticationPrincipal
-import org.springframework.security.core.userdetails.UserDetails
 import org.springframework.web.bind.annotation.DeleteMapping
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PatchMapping
-import org.springframework.web.bind.annotation.PathVariable
 import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RestController
 
 @RestController
+@RequestMapping("/api/users")
 class UserController(
     private val userService: UserService,
 ) {
-    @GetMapping("/api/users/me")
+    @Operation(summary = "내 정보 조회")
+    @GetMapping("/me")
     fun getMyProfile(
-        @AuthenticationPrincipal userDetails: UserDetails,
+        @AuthenticationPrincipal userId: Long,
     ): ResponseEntity<ApiResponse<UserResponse>> {
-        // username 이메일로 설정할것임
-        val userProfile = userService.getUserProfileByEmail(userDetails.username)
-        val response = ApiResponse("내 정보를 성공적으로 조회했습니다.", userProfile)
-        return ResponseEntity.ok(response)
+        val userProfile = userService.getUserProfileById(userId)
+        return ResponseEntity.ok(ApiResponse("내 정보를 성공적으로 조회했습니다.", userProfile))
     }
 
-    @PatchMapping("/api/users/me")
+    @Operation(summary = "내 프로필 수정")
+    @PatchMapping("/me")
     fun updateMyProfile(
-        @AuthenticationPrincipal userDetails: UserDetails,
+        @AuthenticationPrincipal userId: Long,
         @RequestBody request: UserUpdateRequest,
     ): ResponseEntity<ApiResponse<UserResponse>> {
-        val updatedProfile = userService.updateProfile(userDetails.username, request)
-        val response = ApiResponse("정보가 성공적으로 수정되었습니다.", updatedProfile)
-        return ResponseEntity.ok(response)
+        val updatedProfile = userService.updateUserProfile(userId, request)
+        return ResponseEntity.ok(ApiResponse("정보가 성공적으로 수정되었습니다.", updatedProfile))
     }
 
-    @DeleteMapping("/api/users/me")
-    fun deleteUser(
-        @AuthenticationPrincipal userDetails: UserDetails,
+    @Operation(summary = "회원 탈퇴")
+    @DeleteMapping("/me")
+    fun deleteMe(
+        @AuthenticationPrincipal userId: Long,
     ): ResponseEntity<ApiResponse<Unit>> {
-        userService.deleteUser(userDetails.username)
+        userService.deleteUser(userId)
         return ResponseEntity.ok(ApiResponse("회원 탈퇴가 완료되었습니다."))
     }
-
-    @GetMapping("/api/guides")
-    fun getAllGuides(): ResponseEntity<ApiResponse<List<UserResponse>>> {
-        val guides = userService.getAllGuides()
-        val response = ApiResponse("전체 가이드 목록을 조회했습니다.", guides)
-        return ResponseEntity.ok(response)
-    }
-
-    @GetMapping("/api/guides/{guideId}")
-    fun getGuideById(
-        @PathVariable guideId: Long,
-    ): ResponseEntity<ApiResponse<UserResponse>> {
-        val guide = userService.getGuideById(guideId)
-        val response = ApiResponse("가이드 정보를 성공적으로 조회했습니다.", guide)
-        return ResponseEntity.ok(response)
-    }
 }

src/main/kotlin/com/back/koreaTravelGuide/domain/user/dto/request/GuideUpdateRequest.kt

@@ -0,0 +1,8 @@
+package com.back.koreaTravelGuide.domain.user.dto.request
+
+data class GuideUpdateRequest(
+    val nickname: String?,
+    val profileImageUrl: String?,
+    val location: String?,
+    val description: String?,
+)

src/main/kotlin/com/back/koreaTravelGuide/domain/user/dto/request/UserUpdateRequest.kt

@@ -3,6 +3,4 @@ package com.back.koreaTravelGuide.domain.user.dto.request
 data class UserUpdateRequest(
     val nickname: String?,
     val profileImageUrl: String?,
-    val location: String?,
-    val description: String?,
 )

src/main/kotlin/com/back/koreaTravelGuide/domain/user/dto/response/GuideResponse.kt

@@ -0,0 +1,28 @@
+package com.back.koreaTravelGuide.domain.user.dto.response
+
+import com.back.koreaTravelGuide.domain.user.entity.User
+import com.back.koreaTravelGuide.domain.user.enums.UserRole
+
+data class GuideResponse(
+    val id: Long,
+    val email: String,
+    val nickname: String,
+    val profileImageUrl: String?,
+    val role: UserRole,
+    val location: String?,
+    val description: String?,
+) {
+    companion object {
+        fun from(user: User): GuideResponse {
+            return GuideResponse(
+                id = user.id!!,
+                email = user.email,
+                nickname = user.nickname,
+                profileImageUrl = user.profileImageUrl,
+                role = user.role,
+                location = user.location,
+                description = user.description,
+            )
+        }
+    }
+}

src/main/kotlin/com/back/koreaTravelGuide/domain/user/dto/response/UserResponse.kt

@@ -9,10 +9,6 @@ data class UserResponse(
     val nickname: String,
     val profileImageUrl: String?,
     val role: UserRole,
-    // Guide
-    val location: String?,
-    // Guide
-    val description: String?,
 ) {
     companion object {
         fun from(user: User): UserResponse {
@@ -22,8 +18,6 @@ data class UserResponse(
                 nickname = user.nickname,
                 profileImageUrl = user.profileImageUrl,
                 role = user.role,
-                location = user.location,
-                description = user.description,
             )
         }
     }

src/main/kotlin/com/back/koreaTravelGuide/domain/user/entity/User.kt

@@ -35,10 +35,8 @@ class User(
     @Enumerated(EnumType.STRING)
     @Column(nullable = false)
     var role: UserRole = UserRole.USER,
-    // GUIDE
     @Column
     var location: String? = null,
-    // GUIDE
     @Column(columnDefinition = "TEXT")
     var description: String? = null,
     @CreatedDate

src/main/kotlin/com/back/koreaTravelGuide/domain/user/repository/UserRepository.kt

@@ -7,12 +7,5 @@ import org.springframework.stereotype.Repository
 
 @Repository
 interface UserRepository : JpaRepository<User, Long> {
-    fun findByOauthProviderAndOauthId(
-        oauthProvider: String,
-        oauthId: String,
-    ): User?
-
-    fun findByEmail(email: String): User?
-
     fun findByRole(role: UserRole): List<User>
 }

src/main/kotlin/com/back/koreaTravelGuide/domain/user/service/GuideService.kt

@@ -0,0 +1,51 @@
+package com.back.koreaTravelGuide.domain.guide.service
+
+import com.back.koreaTravelGuide.domain.user.dto.request.GuideUpdateRequest
+import com.back.koreaTravelGuide.domain.user.dto.response.GuideResponse
+import com.back.koreaTravelGuide.domain.user.enums.UserRole
+import com.back.koreaTravelGuide.domain.user.repository.UserRepository
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Service
+class GuideService(
+    private val userRepository: UserRepository,
+) {
+    @Transactional(readOnly = true)
+    fun getAllGuides(): List<GuideResponse> {
+        return userRepository.findByRole(UserRole.GUIDE)
+            .map { GuideResponse.from(it) }
+    }
+
+    @Transactional(readOnly = true)
+    fun getGuideById(guideId: Long): GuideResponse {
+        val user =
+            userRepository.findById(guideId)
+                .orElseThrow { NoSuchElementException() }
+
+        if (user.role != UserRole.GUIDE) {
+            throw IllegalArgumentException()
+        }
+        return GuideResponse.from(user)
+    }
+
+    fun updateGuideProfile(
+        guideId: Long,
+        request: GuideUpdateRequest,
+    ): GuideResponse {
+        val user =
+            userRepository.findById(guideId)
+                .orElseThrow { NoSuchElementException() }
+
+        if (user.role != UserRole.GUIDE) {
+            throw IllegalAccessException()
+        }
+
+        user.nickname = request.nickname ?: user.nickname
+        user.profileImageUrl = request.profileImageUrl ?: user.profileImageUrl
+        user.location = request.location ?: user.location
+        user.description = request.description ?: user.description
+
+        return GuideResponse.from(userRepository.save(user))
+    }
+}

src/main/kotlin/com/back/koreaTravelGuide/domain/user/service/UserService.kt

@@ -2,65 +2,40 @@ package com.back.koreaTravelGuide.domain.user.service
 
 import com.back.koreaTravelGuide.domain.user.dto.request.UserUpdateRequest
 import com.back.koreaTravelGuide.domain.user.dto.response.UserResponse
-import com.back.koreaTravelGuide.domain.user.enums.UserRole
 import com.back.koreaTravelGuide.domain.user.repository.UserRepository
-import jakarta.persistence.EntityNotFoundException
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
 
 @Service
-@Transactional
 class UserService(
     private val userRepository: UserRepository,
 ) {
-    // 회원 이메일 단건 조회
     @Transactional(readOnly = true)
-    fun getUserProfileByEmail(email: String): UserResponse {
+    fun getUserProfileById(id: Long): UserResponse {
         val user =
-            userRepository.findByEmail(email)
-                ?: throw EntityNotFoundException("해당 이메일을 가진 사용자를 찾을 수 없습니다")
+            userRepository.findById(id)
+                .orElseThrow { NoSuchElementException() }
         return UserResponse.from(user)
     }
 
-    // 회원 업데이트
-    fun updateProfile(
-        email: String,
+    fun updateUserProfile(
+        id: Long,
         request: UserUpdateRequest,
     ): UserResponse {
         val user =
-            userRepository.findByEmail(email)
-                ?: throw EntityNotFoundException("해당 이메일을 가진 사용자를 찾을 수 없습니다")
+            userRepository.findById(id)
+                .orElseThrow { NoSuchElementException() }
 
         user.nickname = request.nickname ?: user.nickname
         user.profileImageUrl = request.profileImageUrl ?: user.profileImageUrl
-        user.location = request.location ?: user.location
-        user.description = request.description ?: user.description
 
-        val updatedUser = userRepository.save(user)
-        return UserResponse.from(updatedUser)
+        return UserResponse.from(userRepository.save(user))
     }
 
-    // 회원 삭제
-    fun deleteUser(email: String) {
-        val user =
-            userRepository.findByEmail(email)
-                ?: throw EntityNotFoundException("해당 이메일을 가진 사용자를 찾을 수 없습니다")
-        userRepository.delete(user)
-    }
-
-    // 전체 가이드 목록 조회
-    @Transactional(readOnly = true)
-    fun getAllGuides(): List<UserResponse> {
-        return userRepository.findByRole(UserRole.GUIDE)
-            .map { UserResponse.from(it) }
-    }
-
-    // 가이드 정보 단건 조회
-    @Transactional(readOnly = true)
-    fun getGuideById(guideId: Long): UserResponse {
-        val user =
-            userRepository.findById(guideId)
-                .orElseThrow { EntityNotFoundException("해당 ID의 사용자를 찾을 수 없습니다") }
-        return UserResponse.from(user)
+    fun deleteUser(id: Long) {
+        if (!userRepository.existsById(id)) {
+            throw NoSuchElementException()
+        }
+        userRepository.deleteById(id)
     }
 }