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

Author: 정동하

setup-git-hooks.sh

@@ -1,4 +1,64 @@
 package com.back.koreaTravelGuide.domain.user.controller
 
-// TODO: 사용자 컨트롤러 - 사용자 관련 API 엔드포인트 (향후 구현)
-class UserController
+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 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.RestController
+
+@RestController
+class UserController(
+    private val userService: UserService,
+) {
+    @GetMapping("/api/users/me")
+    fun getMyProfile(
+        @AuthenticationPrincipal userDetails: UserDetails,
+    ): ResponseEntity<ApiResponse<UserResponse>> {
+        // username 이메일로 설정할것임
+        val userProfile = userService.getUserProfileByEmail(userDetails.username)
+        val response = ApiResponse("내 정보를 성공적으로 조회했습니다.", userProfile)
+        return ResponseEntity.ok(response)
+    }
+
+    @PatchMapping("/api/users/me")
+    fun updateMyProfile(
+        @AuthenticationPrincipal userDetails: UserDetails,
+        @RequestBody request: UserUpdateRequest,
+    ): ResponseEntity<ApiResponse<UserResponse>> {
+        val updatedProfile = userService.updateProfile(userDetails.username, request)
+        val response = ApiResponse("정보가 성공적으로 수정되었습니다.", updatedProfile)
+        return ResponseEntity.ok(response)
+    }
+
+    @DeleteMapping("/api/users/me")
+    fun deleteUser(
+        @AuthenticationPrincipal userDetails: UserDetails,
+    ): ResponseEntity<ApiResponse<Unit>> {
+        userService.deleteUser(userDetails.username)
+        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/controller/UserController.kt

@@ -0,0 +1,8 @@
+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/UserRequest.kt

@@ -0,0 +1,30 @@
+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 UserResponse(
+    val id: Long,
+    val email: String,
+    val nickname: String,
+    val profileImageUrl: String?,
+    val role: UserRole,
+    // Guide
+    val location: String?,
+    // Guide
+    val description: String?,
+) {
+    companion object {
+        fun from(user: User): UserResponse {
+            return UserResponse(
+                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/UserResponse.kt

@@ -1,4 +1,50 @@
 package com.back.koreaTravelGuide.domain.user.entity
 
-// TODO: 사용자 엔티티 - 사용자 정보 저장 (향후 구현)
-class User
+import com.back.koreaTravelGuide.domain.user.enums.UserRole
+import jakarta.persistence.Column
+import jakarta.persistence.Entity
+import jakarta.persistence.EntityListeners
+import jakarta.persistence.EnumType
+import jakarta.persistence.Enumerated
+import jakarta.persistence.GeneratedValue
+import jakarta.persistence.GenerationType
+import jakarta.persistence.Id
+import jakarta.persistence.Table
+import org.springframework.data.annotation.CreatedDate
+import org.springframework.data.annotation.LastModifiedDate
+import org.springframework.data.jpa.domain.support.AuditingEntityListener
+import java.time.LocalDateTime
+
+@Entity
+@Table(name = "users")
+@EntityListeners(AuditingEntityListener::class)
+class User(
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    val id: Long? = null,
+    @Column(name = "oauth_provider", nullable = false)
+    val oauthProvider: String,
+    @Column(name = "oauth_id", nullable = false)
+    val oauthId: String,
+    @Column(unique = true, nullable = false)
+    val email: String,
+    @Column(nullable = false)
+    var nickname: String,
+    @Column(name = "profile_image_url")
+    var profileImageUrl: String? = null,
+    @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
+    @Column(name = "created_at", nullable = false, updatable = false)
+    val createdAt: LocalDateTime = LocalDateTime.now(),
+    @LastModifiedDate
+    @Column(name = "last_login_at")
+    var lastLoginAt: LocalDateTime = LocalDateTime.now(),
+)

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

@@ -0,0 +1,7 @@
+package com.back.koreaTravelGuide.domain.user.enums
+
+enum class UserRole {
+    USER,
+    ADMIN,
+    GUIDE,
+}

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

@@ -1,4 +1,18 @@
 package com.back.koreaTravelGuide.domain.user.repository
 
-// TODO: 사용자 리포지토리 - 사용자 데이터 저장/조회 (향후 구현)
-interface UserRepository
+import com.back.koreaTravelGuide.domain.user.entity.User
+import com.back.koreaTravelGuide.domain.user.enums.UserRole
+import org.springframework.data.jpa.repository.JpaRepository
+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/entity/User.kt

@@ -1,4 +1,66 @@
 package com.back.koreaTravelGuide.domain.user.service
 
-// TODO: 사용자 서비스 - 사용자 관리 비즈니스 로직 (향후 구현)
-class UserService
+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 {
+        val user =
+            userRepository.findByEmail(email)
+                ?: throw EntityNotFoundException("해당 이메일을 가진 사용자를 찾을 수 없습니다")
+        return UserResponse.from(user)
+    }
+
+    // 회원 업데이트
+    fun updateProfile(
+        email: String,
+        request: UserUpdateRequest,
+    ): UserResponse {
+        val user =
+            userRepository.findByEmail(email)
+                ?: throw EntityNotFoundException("해당 이메일을 가진 사용자를 찾을 수 없습니다")
+
+        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)
+    }
+
+    // 회원 삭제
+    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)
+    }
+}