pricelees/roomescape-refactored
1
0
Fork 0
generated from pricelees/issue-pr-template
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

[#7] API 응답 형식 재정의 및 Swagger-UI 관련 코드 패키지 분리 #8

Merged
pricelees merged 16 commits from refactor/#7 into main 2025-07-15 05:37:42 +00:00
Conversation 0 Commits 16 Files Changed 31 +513 -502
31 changed files with 513 additions and 502 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
src/main/java/roomescape/auth/docs/AuthAPI.kt Normal file
View File

@ -0,0 +1,45 @@
package roomescape.auth.docs
import io.swagger.v3.oas.annotations.Operation
import io.swagger.v3.oas.annotations.Parameter
import io.swagger.v3.oas.annotations.responses.ApiResponse
import io.swagger.v3.oas.annotations.responses.ApiResponses
import io.swagger.v3.oas.annotations.tags.Tag
import jakarta.validation.Valid
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.RequestBody
import roomescape.auth.web.LoginCheckResponse
import roomescape.auth.web.LoginRequest
import roomescape.auth.web.support.LoginRequired
import roomescape.auth.web.support.MemberId
import roomescape.common.dto.response.CommonApiResponse
@Tag(name = "1. 인증 / 인가 API", description = "로그인, 로그아웃 및 로그인 상태를 확인합니다")
interface AuthAPI {
@Operation(summary = "로그인")
@ApiResponses(
ApiResponse(responseCode = "200", description = "로그인 성공시 쿠키에 토큰 정보를 저장합니다."),
)
fun login(
@Valid @RequestBody loginRequest: LoginRequest
): ResponseEntity<CommonApiResponse<Unit>>
@Operation(summary = "로그인 상태 확인")
@ApiResponses(
ApiResponse(
responseCode = "200",
description = "로그인 상태이며, 로그인된 회원의 이름을 반환합니다.",
useReturnTypeSchema = true
),
)
fun checkLogin(
@MemberId @Parameter(hidden = true) memberId: Long
): ResponseEntity<CommonApiResponse<LoginCheckResponse>>
@LoginRequired
@Operation(summary = "로그아웃", tags = ["로그인이 필요한 API"])
@ApiResponses(
ApiResponse(responseCode = "200", description = "로그아웃 성공시 쿠키에 저장된 토큰 정보를 삭제합니다."),
)
fun logout(): ResponseEntity<CommonApiResponse<Unit>>
}

4
src/main/java/roomescape/auth/service/AuthService.kt
View File

@ -1,12 +1,12 @@
package roomescape.auth.service
import org.springframework.stereotype.Service
import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.Member
import roomescape.auth.infrastructure.jwt.JwtHandler
import roomescape.auth.web.LoginCheckResponse
import roomescape.auth.web.LoginRequest
import roomescape.auth.web.TokenResponse
import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.Member
@Service
class AuthService(

67
src/main/java/roomescape/auth/web/AuthAPI.kt
View File

@ -1,67 +0,0 @@
package roomescape.auth.web
import io.swagger.v3.oas.annotations.Operation
import io.swagger.v3.oas.annotations.Parameter
import io.swagger.v3.oas.annotations.media.Content
import io.swagger.v3.oas.annotations.media.Schema
import io.swagger.v3.oas.annotations.responses.ApiResponse
import io.swagger.v3.oas.annotations.responses.ApiResponses
import io.swagger.v3.oas.annotations.tags.Tag
import jakarta.servlet.http.HttpServletRequest
import jakarta.servlet.http.HttpServletResponse
import jakarta.validation.Valid
import org.springframework.http.HttpStatus
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.ResponseStatus
import roomescape.auth.web.support.LoginRequired
import roomescape.auth.web.support.MemberId
import roomescape.common.dto.response.ErrorResponse
import roomescape.common.dto.response.RoomEscapeApiResponse
@Tag(name = "1. 인증 / 인가 API", description = "로그인, 로그아웃 및 로그인 상태를 확인합니다")
interface AuthAPI {
@ResponseStatus(HttpStatus.OK)
@Operation(summary = "로그인")
@ApiResponses(
ApiResponse(
responseCode = "200",
description = "로그인 성공시 쿠키에 토큰 정보를 저장합니다."
),
ApiResponse(
responseCode = "400",
description = "존재하지 않는 회원이거나, 이메일 또는 비밀번호가 잘못 입력되었습니다.",
content = [Content(schema = Schema(implementation = ErrorResponse::class))]
)
)
fun login(
@Valid @RequestBody loginRequest: LoginRequest,
response: HttpServletResponse
): RoomEscapeApiResponse<Void>
@ResponseStatus(HttpStatus.OK)
@Operation(summary = "로그인 상태 확인")
@ApiResponses(
ApiResponse(
responseCode = "200",
description = "로그인 상태이며, 로그인된 회원의 이름을 반환합니다."
),
ApiResponse(
responseCode = "400",
description = "쿠키에 있는 토큰 정보로 회원을 조회할 수 없습니다.",
content = [Content(schema = Schema(implementation = ErrorResponse::class))]
),
ApiResponse(
responseCode = "401",
description = "토큰 정보가 없거나, 만료되었습니다.",
content = [Content(schema = Schema(implementation = ErrorResponse::class))]
)
)
fun checkLogin(@MemberId @Parameter(hidden = true) memberId: Long): RoomEscapeApiResponse<LoginCheckResponse>
@LoginRequired
@ResponseStatus(HttpStatus.OK)
@Operation(summary = "로그아웃", tags = ["로그인이 필요한 API"])
@ApiResponses(ApiResponse(responseCode = "200", description = "로그아웃 성공시 쿠키에 저장된 토큰 정보를 삭제합니다."))
fun logout(request: HttpServletRequest, response: HttpServletResponse): RoomEscapeApiResponse<Void>
}

45
src/main/java/roomescape/auth/web/AuthController.kt
View File

@ -1,21 +1,19 @@
package roomescape.auth.web
import io.swagger.v3.oas.annotations.Parameter
import jakarta.servlet.http.Cookie
import jakarta.servlet.http.HttpServletRequest
import jakarta.servlet.http.HttpServletResponse
import jakarta.validation.Valid
import org.springframework.http.HttpHeaders
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RestController
import roomescape.auth.docs.AuthAPI
import roomescape.auth.service.AuthService
import roomescape.auth.web.support.MemberId
import roomescape.auth.web.support.accessTokenCookie
import roomescape.auth.web.support.addAccessTokenCookie
import roomescape.auth.web.support.expire
import roomescape.auth.web.support.toCookie
import roomescape.common.dto.response.RoomEscapeApiResponse
import roomescape.auth.web.support.expiredAccessTokenCookie
import roomescape.auth.web.support.toResponseCookie
import roomescape.common.dto.response.CommonApiResponse
@RestController
class AuthController(
@ -25,34 +23,25 @@ class AuthController(
@PostMapping("/login")
override fun login(
@Valid @RequestBody loginRequest: LoginRequest,
response: HttpServletResponse
): RoomEscapeApiResponse<Void> {
val accessToken: TokenResponse = authService.login(loginRequest)
val cookie: Cookie = accessToken.toCookie()
): ResponseEntity<CommonApiResponse<Unit>> {
val response: TokenResponse = authService.login(loginRequest)
response.addAccessTokenCookie(cookie)
return RoomEscapeApiResponse.success()
return ResponseEntity.ok()
.header(HttpHeaders.SET_COOKIE, response.toResponseCookie())
.body(CommonApiResponse())
}
@GetMapping("/login/check")
override fun checkLogin(
@MemberId @Parameter(hidden = true) memberId: Long
): RoomEscapeApiResponse<LoginCheckResponse> {
val response = authService.checkLogin(memberId)
): ResponseEntity<CommonApiResponse<LoginCheckResponse>> {
val response: LoginCheckResponse = authService.checkLogin(memberId)
return RoomEscapeApiResponse.success(response)
return ResponseEntity.ok(CommonApiResponse(response))
}
@PostMapping("/logout")
override fun logout(
request: HttpServletRequest,
response: HttpServletResponse
): RoomEscapeApiResponse<Void> {
val cookie: Cookie = request.accessTokenCookie()
cookie.expire()
response.addAccessTokenCookie(cookie)
return RoomEscapeApiResponse.success()
}
override fun logout(): ResponseEntity<CommonApiResponse<Unit>> = ResponseEntity.ok()
.header(HttpHeaders.SET_COOKIE, expiredAccessTokenCookie())
.body(CommonApiResponse())
}

6
src/main/java/roomescape/auth/web/support/AuthInterceptors.kt
View File

@ -6,11 +6,11 @@ import org.springframework.http.HttpStatus
import org.springframework.stereotype.Component
import org.springframework.web.method.HandlerMethod
import org.springframework.web.servlet.HandlerInterceptor
import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.Member
import roomescape.auth.infrastructure.jwt.JwtHandler
import roomescape.common.exception.ErrorType
import roomescape.common.exception.RoomescapeException
import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.Member
private fun Any.isIrrelevantWith(annotationType: Class<out Annotation>): Boolean {
if (this !is HandlerMethod) {
@ -40,7 +40,7 @@ class LoginInterceptor(
val memberId: Long = jwtHandler.getMemberIdFromToken(token)
return memberService.existsById(memberId)
} catch (e: RoomescapeException) {
} catch (_: RoomescapeException) {
response.sendRedirect("/login")
throw RoomescapeException(ErrorType.LOGIN_REQUIRED, HttpStatus.FORBIDDEN)
}

29
src/main/java/roomescape/auth/web/support/CookieUtils.kt
View File

@ -2,26 +2,25 @@ package roomescape.auth.web.support
import jakarta.servlet.http.Cookie
import jakarta.servlet.http.HttpServletRequest
import jakarta.servlet.http.HttpServletResponse
import org.springframework.http.ResponseCookie
import roomescape.auth.web.TokenResponse
const val ACCESS_TOKEN_COOKIE_NAME = "accessToken"
fun Cookie.expire(): Unit {
this.value = ""
this.maxAge = 0
}
fun TokenResponse.toCookie(): Cookie = Cookie(ACCESS_TOKEN_COOKIE_NAME, this.accessToken)
.also { it.maxAge = 1800000 }
fun HttpServletRequest.accessTokenCookie(): Cookie = this.cookies
?.firstOrNull { it.name == ACCESS_TOKEN_COOKIE_NAME }
?: Cookie(ACCESS_TOKEN_COOKIE_NAME, "")
fun HttpServletResponse.addAccessTokenCookie(cookie: Cookie) {
cookie.isHttpOnly = true
cookie.secure = true
cookie.path = "/"
this.addCookie(cookie)
}
fun TokenResponse.toResponseCookie(): String = accessTokenCookie(this.accessToken, 1800)
.toString()
fun expiredAccessTokenCookie(): String = accessTokenCookie("", 0)
.toString()
private fun accessTokenCookie(token: String, maxAgeSecond: Long): ResponseCookie =
ResponseCookie.from(ACCESS_TOKEN_COOKIE_NAME, token)
.httpOnly(true)
.secure(true)
.path("/")
.maxAge(maxAgeSecond)
.build()

14
src/main/java/roomescape/common/dto/response/CommonApiResponse.kt Normal file
View File

@ -0,0 +1,14 @@
package roomescape.common.dto.response
import com.fasterxml.jackson.annotation.JsonInclude
import roomescape.common.exception.ErrorType
@JsonInclude(JsonInclude.Include.NON_NULL)
data class CommonApiResponse<T>(
val data: T? = null,
)
data class CommonErrorResponse(
val errorType: ErrorType,
val message: String? = errorType.description
)

21
src/main/java/roomescape/common/dto/response/ErrorResponse.kt
View File

@ -1,21 +0,0 @@
package roomescape.common.dto.response
import io.swagger.v3.oas.annotations.media.Schema
import roomescape.common.exception.ErrorType
@Schema(name = "예외 응답", description = "예외 발생 시 응답에 사용됩니다.")
@JvmRecord
data class ErrorResponse(
@field:Schema(description = "발생한 예외의 종류", example = "INVALID_REQUEST_DATA")
val errorType: ErrorType,
@field:Schema(description = "예외 메시지", example = "요청 데이터 값이 올바르지 않습니다.")
val message: String
) {
companion object {
@JvmStatic
fun of(errorType: ErrorType, message: String): ErrorResponse {
return ErrorResponse(errorType, message)
}
}
}

27
src/main/java/roomescape/common/dto/response/RoomEscapeApiResponse.kt
View File

@ -1,27 +0,0 @@
package roomescape.common.dto.response
import io.swagger.v3.oas.annotations.media.Schema
@Schema(description = "API 응답 시에 사용합니다.")
@JvmRecord
data class RoomEscapeApiResponse<T>(
@field:Schema(description = "응답 메시지", defaultValue = SUCCESS_MESSAGE)
val message: String,
@field:Schema(description = "응답 바디")
val data: T? = null
) {
companion object {
private const val SUCCESS_MESSAGE = "요청이 성공적으로 수행되었습니다."
@JvmStatic
fun <T> success(data: T): RoomEscapeApiResponse<T> {
return RoomEscapeApiResponse(SUCCESS_MESSAGE, data)
}
@JvmStatic
fun success(): RoomEscapeApiResponse<Void> {
return RoomEscapeApiResponse(SUCCESS_MESSAGE, null)
}
}
}

17
src/main/java/roomescape/common/dto/response/RoomescapeApiResponse.kt Normal file
View File

@ -0,0 +1,17 @@
package roomescape.common.dto.response
import io.swagger.v3.oas.annotations.media.Schema
@Schema(name = "API 성공 응답")
@JvmRecord
data class RoomescapeApiResponse<T>(
val data: T? = null
) {
companion object {
@JvmStatic
fun <T> success(data: T): RoomescapeApiResponse<T> = RoomescapeApiResponse(data)
@JvmStatic
fun success(): RoomescapeApiResponse<Void> = RoomescapeApiResponse(null)
}
}

33
src/main/java/roomescape/common/dto/response/RoomescapeApiResponseKT.kt
View File

@ -1,33 +0,0 @@
package roomescape.common.dto.response
import com.fasterxml.jackson.annotation.JsonInclude
import roomescape.common.exception.ErrorType
@JsonInclude(JsonInclude.Include.NON_NULL)
data class RoomescapeApiResponseKT<T>(
val success: Boolean,
val data: T? = null,
val errorType: ErrorType? = null,
val message: String? = null,
) {
companion object {
@JvmStatic
fun <T> success(data: T? = null): RoomescapeApiResponseKT<T> {
return RoomescapeApiResponseKT(
success = true,
data = data,
)
}
@JvmStatic
fun <T> fail(errorType: ErrorType, message: String? = null): RoomescapeApiResponseKT<T> {
return RoomescapeApiResponseKT(
success = false,
errorType = errorType,
message = message ?: errorType.description
)
}
}
}

18
src/main/java/roomescape/common/dto/response/RoomescapeErrorResponse.kt Normal file
View File

@ -0,0 +1,18 @@
package roomescape.common.dto.response
import io.swagger.v3.oas.annotations.media.Schema
import roomescape.common.exception.ErrorType
@Schema(name = "API 에러 응답")
@JvmRecord
data class RoomescapeErrorResponse(
val errorType: ErrorType,
val message: String
) {
companion object {
@JvmStatic
fun of(errorType: ErrorType, message: String? = null): RoomescapeErrorResponse =
RoomescapeErrorResponse(errorType, message ?: errorType.description)
}
}

51
src/main/java/roomescape/common/exception/ExceptionControllerAdvice.kt
View File

@ -2,16 +2,15 @@ package roomescape.common.exception
import io.github.oshai.kotlinlogging.KLogger
import io.github.oshai.kotlinlogging.KotlinLogging
import jakarta.servlet.http.HttpServletResponse
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.http.converter.HttpMessageNotReadableException
import org.springframework.web.HttpRequestMethodNotSupportedException
import org.springframework.web.bind.MethodArgumentNotValidException
import org.springframework.web.bind.annotation.ExceptionHandler
import org.springframework.web.bind.annotation.ResponseStatus
import org.springframework.web.bind.annotation.RestControllerAdvice
import org.springframework.web.client.ResourceAccessException
import roomescape.common.dto.response.ErrorResponse
import roomescape.common.dto.response.CommonErrorResponse
@RestControllerAdvice
class ExceptionControllerAdvice(
@ -19,57 +18,59 @@ class ExceptionControllerAdvice(
) {
@ExceptionHandler(value = [RoomescapeException::class])
fun handleRoomEscapeException(
e: RoomescapeException,
response: HttpServletResponse
): ErrorResponse {
fun handleRoomEscapeException(e: RoomescapeException): ResponseEntity<CommonErrorResponse> {
logger.error(e) { "message: ${e.message}, invalidValue: ${e.invalidValue}" }
response.status = e.httpStatus.value()
return ErrorResponse.of(e.errorType, e.message!!)
return ResponseEntity
.status(e.httpStatus)
.body(CommonErrorResponse(e.errorType))
}
@ExceptionHandler(ResourceAccessException::class)
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
fun handleResourceAccessException(e: ResourceAccessException): ErrorResponse {
fun handleResourceAccessException(e: ResourceAccessException): ResponseEntity<CommonErrorResponse> {
logger.error(e) { "message: ${e.message}" }
return ErrorResponse.of(ErrorType.PAYMENT_SERVER_ERROR, ErrorType.PAYMENT_SERVER_ERROR.description)
return ResponseEntity
.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(CommonErrorResponse(ErrorType.PAYMENT_SERVER_ERROR))
}
@ExceptionHandler(value = [HttpMessageNotReadableException::class])
@ResponseStatus(HttpStatus.BAD_REQUEST)
fun handleHttpMessageNotReadableException(e: HttpMessageNotReadableException): ErrorResponse {
fun handleHttpMessageNotReadableException(e: HttpMessageNotReadableException): ResponseEntity<CommonErrorResponse> {
logger.error(e) { "message: ${e.message}" }
return ErrorResponse.of(ErrorType.INVALID_REQUEST_DATA_TYPE,
ErrorType.INVALID_REQUEST_DATA_TYPE.description)
return ResponseEntity
.status(HttpStatus.BAD_REQUEST)
.body(CommonErrorResponse(ErrorType.INVALID_REQUEST_DATA_TYPE))
}
@ExceptionHandler(value = [MethodArgumentNotValidException::class])
@ResponseStatus(HttpStatus.BAD_REQUEST)
fun handleMethodArgumentNotValidException(e: MethodArgumentNotValidException): ErrorResponse {
fun handleMethodArgumentNotValidException(e: MethodArgumentNotValidException): ResponseEntity<CommonErrorResponse> {
val messages: String = e.bindingResult.allErrors
.mapNotNull { it.defaultMessage }
.joinToString(", ")
logger.error(e) { "message: $messages" }
return ErrorResponse.of(ErrorType.INVALID_REQUEST_DATA, messages)
return ResponseEntity
.status(HttpStatus.BAD_REQUEST)
.body(CommonErrorResponse(ErrorType.INVALID_REQUEST_DATA, messages))
}
@ExceptionHandler(value = [HttpRequestMethodNotSupportedException::class])
@ResponseStatus(HttpStatus.METHOD_NOT_ALLOWED)
fun handleHttpRequestMethodNotSupportedException(e: HttpRequestMethodNotSupportedException): ErrorResponse {
fun handleHttpRequestMethodNotSupportedException(e: HttpRequestMethodNotSupportedException): ResponseEntity<CommonErrorResponse> {
logger.error(e) { "message: ${e.message}" }
return ErrorResponse.of(ErrorType.METHOD_NOT_ALLOWED, ErrorType.METHOD_NOT_ALLOWED.description)
return ResponseEntity
.status(HttpStatus.METHOD_NOT_ALLOWED)
.body(CommonErrorResponse(ErrorType.METHOD_NOT_ALLOWED))
}
@ExceptionHandler(value = [Exception::class])
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
fun handleException(e: Exception): ErrorResponse {
fun handleException(e: Exception): ResponseEntity<CommonErrorResponse> {
logger.error(e) { "message: ${e.message}" }
return ErrorResponse.of(ErrorType.UNEXPECTED_ERROR, ErrorType.UNEXPECTED_ERROR.description)
return ResponseEntity
.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(CommonErrorResponse(ErrorType.UNEXPECTED_ERROR))
}
}

4
src/main/java/roomescape/member/business/MemberService.kt
View File

@ -4,12 +4,12 @@ import org.springframework.data.repository.findByIdOrNull
import org.springframework.http.HttpStatus
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import roomescape.common.exception.ErrorType
import roomescape.common.exception.RoomescapeException
import roomescape.member.infrastructure.persistence.Member
import roomescape.member.infrastructure.persistence.MemberRepository
import roomescape.member.web.MembersResponse
import roomescape.member.web.toResponse
import roomescape.common.exception.ErrorType
import roomescape.common.exception.RoomescapeException
@Service
@Transactional(readOnly = true)

21
src/main/java/roomescape/member/web/MemberAPI.kt → src/main/java/roomescape/member/docs/MemberAPI.kt
View File

@ -1,21 +1,24 @@
package roomescape.member.web
package roomescape.member.docs
import io.swagger.v3.oas.annotations.Operation
import io.swagger.v3.oas.annotations.responses.ApiResponse
import io.swagger.v3.oas.annotations.responses.ApiResponses
import io.swagger.v3.oas.annotations.tags.Tag
import org.springframework.http.HttpStatus
import org.springframework.web.bind.annotation.ResponseStatus
import org.springframework.http.ResponseEntity
import roomescape.auth.web.support.Admin
import roomescape.common.dto.response.RoomEscapeApiResponse
import roomescape.common.dto.response.CommonApiResponse
import roomescape.member.web.MembersResponse
@Tag(name = "2. 회원 API", description = "회원 정보를 관리할 때 사용합니다.")
interface MemberAPI {
@Admin
@Operation(summary = "모든 회원 조회", tags = ["관리자 로그인이 필요한 API"])
@ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
@ResponseStatus(HttpStatus.OK)
fun readAllMembers(): RoomEscapeApiResponse<MembersResponse>
@ApiResponses(
ApiResponse(
responseCode = "200",
description = "성공",
useReturnTypeSchema = true
)
)
fun readAllMembers(): ResponseEntity<CommonApiResponse<MembersResponse>>
}

39
src/main/java/roomescape/member/web/MemberController.kt
View File

@ -1,11 +1,11 @@
package roomescape.member.web
import io.swagger.v3.oas.annotations.media.Schema
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RestController
import roomescape.common.dto.response.CommonApiResponse
import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.Member
import roomescape.common.dto.response.RoomEscapeApiResponse
import roomescape.member.docs.MemberAPI
@RestController
class MemberController(
@ -13,36 +13,9 @@ class MemberController(
) : MemberAPI {
@GetMapping("/members")
override fun readAllMembers(): RoomEscapeApiResponse<MembersResponse> {
val result: MembersResponse = memberService.readAllMembers()
override fun readAllMembers(): ResponseEntity<CommonApiResponse<MembersResponse>> {
val response: MembersResponse = memberService.readAllMembers()
return RoomEscapeApiResponse.success(result)
return ResponseEntity.ok(CommonApiResponse(response))
}
}
@Schema(name = "회원 조회 응답", description = "회원 정보 조회 응답시 사용됩니다.")
data class MemberResponse(
@field:Schema(description = "회원의 고유 번호")
val id: Long,
@field:Schema(description = "회원의 이름")
val name: String
) {
companion object {
@JvmStatic
fun fromEntity(member: Member): MemberResponse {
return MemberResponse(member.id!!, member.name)
}
}
}
fun Member.toResponse(): MemberResponse = MemberResponse(
id = id!!,
name = name
)
@Schema(name = "회원 목록 조회 응답", description = "모든 회원의 정보 조회 응답시 사용됩니다.")
data class MembersResponse(
@field:Schema(description = "모든 회원의 ID 및 이름")
val members: List<MemberResponse>
)

31
src/main/java/roomescape/member/web/MemberDTO.kt Normal file
View File

@ -0,0 +1,31 @@
package roomescape.member.web
import io.swagger.v3.oas.annotations.media.Schema
import roomescape.member.infrastructure.persistence.Member
fun Member.toResponse(): MemberResponse = MemberResponse(
id = id!!,
name = name
)
@Schema(name = "회원 조회 응답", description = "회원 정보 조회 응답시 사용됩니다.")
data class MemberResponse(
@field:Schema(description = "회원의 고유 번호")
val id: Long,
@field:Schema(description = "회원의 이름")
val name: String
) {
companion object {
@JvmStatic
fun fromEntity(member: Member): MemberResponse {
return MemberResponse(member.id!!, member.name)
}
}
}
@Schema(name = "회원 목록 조회 응답", description = "모든 회원의 정보 조회 응답시 사용됩니다.")
data class MembersResponse(
@field:Schema(description = "모든 회원의 ID 및 이름")
val members: List<MemberResponse>
)

4
src/main/java/roomescape/payment/client/TossPaymentClient.java
View File

@ -14,13 +14,13 @@ import org.springframework.web.client.RestClient;
import com.fasterxml.jackson.databind.ObjectMapper;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.payment.dto.request.PaymentCancelRequest;
import roomescape.payment.dto.request.PaymentRequest;
import roomescape.payment.dto.response.PaymentCancelResponse;
import roomescape.payment.dto.response.PaymentResponse;
import roomescape.payment.dto.response.TossPaymentErrorResponse;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
@Component
public class TossPaymentClient {

2
src/main/java/roomescape/payment/domain/Payment.java
View File

@ -12,9 +12,9 @@ import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.OneToOne;
import roomescape.reservation.domain.Reservation;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.reservation.domain.Reservation;
@Entity
public class Payment {

4
src/main/java/roomescape/payment/service/PaymentService.java
View File

@ -7,6 +7,8 @@ import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.payment.domain.CanceledPayment;
import roomescape.payment.domain.Payment;
import roomescape.payment.domain.repository.CanceledPaymentRepository;
@ -16,8 +18,6 @@ import roomescape.payment.dto.response.PaymentCancelResponse;
import roomescape.payment.dto.response.PaymentResponse;
import roomescape.payment.dto.response.ReservationPaymentResponse;
import roomescape.reservation.domain.Reservation;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
@Service
@Transactional

70
src/main/java/roomescape/reservation/controller/ReservationController.java
View File

@ -24,6 +24,12 @@ import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotNull;
import roomescape.auth.web.support.Admin;
import roomescape.auth.web.support.LoginRequired;
import roomescape.auth.web.support.MemberId;
import roomescape.common.dto.response.RoomescapeApiResponse;
import roomescape.common.dto.response.RoomescapeErrorResponse;
import roomescape.common.exception.RoomescapeException;
import roomescape.payment.client.TossPaymentClient;
import roomescape.payment.dto.request.PaymentCancelRequest;
import roomescape.payment.dto.request.PaymentRequest;
@ -37,12 +43,6 @@ import roomescape.reservation.dto.response.ReservationResponse;
import roomescape.reservation.dto.response.ReservationsResponse;
import roomescape.reservation.service.ReservationService;
import roomescape.reservation.service.ReservationWithPaymentService;
import roomescape.auth.web.support.Admin;
import roomescape.auth.web.support.LoginRequired;
import roomescape.auth.web.support.MemberId;
import roomescape.common.dto.response.ErrorResponse;
import roomescape.common.dto.response.RoomEscapeApiResponse;
import roomescape.common.exception.RoomescapeException;
@RestController
@Tag(name = "3. 예약 API", description = "예약 및 대기 정보를 추가 / 조회 / 삭제할 때 사용합니다.")
@ -66,8 +66,8 @@ public class ReservationController {
@ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
})
public RoomEscapeApiResponse<ReservationsResponse> getAllReservations() {
return RoomEscapeApiResponse.success(reservationService.findAllReservations());
public RoomescapeApiResponse<ReservationsResponse> getAllReservations() {
return RoomescapeApiResponse.success(reservationService.findAllReservations());
}
@LoginRequired
@ -77,9 +77,9 @@ public class ReservationController {
@ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
})
public RoomEscapeApiResponse<MyReservationsResponse> getMemberReservations(
public RoomescapeApiResponse<MyReservationsResponse> getMemberReservations(
@MemberId @Parameter(hidden = true) Long memberId) {
return RoomEscapeApiResponse.success(reservationService.findMemberReservations(memberId));
return RoomescapeApiResponse.success(reservationService.findMemberReservations(memberId));
}
@Admin
@ -89,15 +89,15 @@ public class ReservationController {
@ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true),
@ApiResponse(responseCode = "400", description = "날짜 범위를 지정할 때, 종료 날짜는 시작 날짜 이전일 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class)))
content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
})
public RoomEscapeApiResponse<ReservationsResponse> getReservationBySearching(
public RoomescapeApiResponse<ReservationsResponse> getReservationBySearching(
@RequestParam(required = false) @Parameter(description = "테마 ID") Long themeId,
@RequestParam(required = false) @Parameter(description = "회원 ID") Long memberId,
@RequestParam(required = false) @Parameter(description = "yyyy-MM-dd 형식으로 입력해주세요", example = "2024-06-10") LocalDate dateFrom,
@RequestParam(required = false) @Parameter(description = "yyyy-MM-dd 형식으로 입력해주세요", example = "2024-06-10") LocalDate dateTo
) {
return RoomEscapeApiResponse.success(
return RoomescapeApiResponse.success(
reservationService.findFilteredReservations(themeId, memberId, dateFrom, dateTo));
}
@ -108,16 +108,16 @@ public class ReservationController {
@ApiResponses({
@ApiResponse(responseCode = "204", description = "성공"),
@ApiResponse(responseCode = "404", description = "예약 또는 결제 정보를 찾을 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class))),
content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class))),
})
public RoomEscapeApiResponse<Void> removeReservation(
public RoomescapeApiResponse<Void> removeReservation(
@MemberId @Parameter(hidden = true) Long memberId,
@NotNull(message = "reservationId는 null일 수 없습니다.") @PathVariable("id") @Parameter(description = "예약 ID") Long reservationId
) {
if (reservationWithPaymentService.isNotPaidReservation(reservationId)) {
reservationService.removeReservationById(reservationId, memberId);
return RoomEscapeApiResponse.success();
return RoomescapeApiResponse.success();
}
PaymentCancelRequest paymentCancelRequest = reservationWithPaymentService.removeReservationWithPayment(
@ -128,7 +128,7 @@ public class ReservationController {
reservationWithPaymentService.updateCanceledTime(paymentCancelRequest.paymentKey(),
paymentCancelResponse.canceledAt());
return RoomEscapeApiResponse.success();
return RoomescapeApiResponse.success();
}
@LoginRequired
@ -139,7 +139,7 @@ public class ReservationController {
@ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true,
headers = @Header(name = HttpHeaders.LOCATION, description = "생성된 예약 정보 URL", schema = @Schema(example = "/reservations/1")))
})
public RoomEscapeApiResponse<ReservationResponse> saveReservation(
public RoomescapeApiResponse<ReservationResponse> saveReservation(
@Valid @RequestBody ReservationRequest reservationRequest,
@MemberId @Parameter(hidden = true) Long memberId,
HttpServletResponse response
@ -170,9 +170,9 @@ public class ReservationController {
@ApiResponses({
@ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true,
headers = @Header(name = HttpHeaders.LOCATION, description = "생성된 예약 정보 URL", schema = @Schema(example = "/reservations/1"))),
@ApiResponse(responseCode = "409", description = "예약이 이미 존재합니다.", content = @Content(schema = @Schema(implementation = ErrorResponse.class)))
@ApiResponse(responseCode = "409", description = "예약이 이미 존재합니다.", content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
})
public RoomEscapeApiResponse<ReservationResponse> saveReservationByAdmin(
public RoomescapeApiResponse<ReservationResponse> saveReservationByAdmin(
@Valid @RequestBody AdminReservationRequest adminReservationRequest,
HttpServletResponse response
) {
@ -187,8 +187,8 @@ public class ReservationController {
@ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
})
public RoomEscapeApiResponse<ReservationsResponse> getAllWaiting() {
return RoomEscapeApiResponse.success(reservationService.findAllWaiting());
public RoomescapeApiResponse<ReservationsResponse> getAllWaiting() {
return RoomescapeApiResponse.success(reservationService.findAllWaiting());
}
@LoginRequired
@ -199,7 +199,7 @@ public class ReservationController {
@ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true,
headers = @Header(name = HttpHeaders.LOCATION, description = "생성된 예약 정보 URL", schema = @Schema(example = "/reservations/1")))
})
public RoomEscapeApiResponse<ReservationResponse> saveWaiting(
public RoomescapeApiResponse<ReservationResponse> saveWaiting(
@Valid @RequestBody WaitingRequest waitingRequest,
@MemberId @Parameter(hidden = true) Long memberId,
HttpServletResponse response
@ -215,14 +215,14 @@ public class ReservationController {
@ApiResponses({
@ApiResponse(responseCode = "204", description = "성공"),
@ApiResponse(responseCode = "404", description = "회원의 예약 대기 정보를 찾을 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class)))
content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
})
public RoomEscapeApiResponse<Void> deleteWaiting(
public RoomescapeApiResponse<Void> deleteWaiting(
@MemberId @Parameter(hidden = true) Long memberId,
@NotNull(message = "reservationId는 null 또는 공백일 수 없습니다.") @PathVariable("id") @Parameter(description = "예약 ID") Long reservationId
) {
reservationService.cancelWaiting(reservationId, memberId);
return RoomEscapeApiResponse.success();
return RoomescapeApiResponse.success();
}
@Admin
@ -232,17 +232,17 @@ public class ReservationController {
@ApiResponses({
@ApiResponse(responseCode = "200", description = "성공"),
@ApiResponse(responseCode = "404", description = "예약 대기 정보를 찾을 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class))),
content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class))),
@ApiResponse(responseCode = "409", description = "확정된 예약이 존재하여 대기 중인 예약을 승인할 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class)))
content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
})
public RoomEscapeApiResponse<Void> approveWaiting(
public RoomescapeApiResponse<Void> approveWaiting(
@MemberId @Parameter(hidden = true) Long memberId,
@NotNull(message = "reservationId는 null 또는 공백일 수 없습니다.") @PathVariable("id") @Parameter(description = "예약 ID") Long reservationId
) {
reservationService.approveWaiting(reservationId, memberId);
return RoomEscapeApiResponse.success();
return RoomescapeApiResponse.success();
}
@Admin
@ -252,22 +252,22 @@ public class ReservationController {
@ApiResponses({
@ApiResponse(responseCode = "204", description = "대기 중인 예약 거절 성공"),
@ApiResponse(responseCode = "404", description = "예약 대기 정보를 찾을 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class)))
content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
})
public RoomEscapeApiResponse<Void> denyWaiting(
public RoomescapeApiResponse<Void> denyWaiting(
@MemberId @Parameter(hidden = true) Long memberId,
@NotNull(message = "reservationId는 null 또는 공백일 수 없습니다.") @PathVariable("id") @Parameter(description = "예약 ID") Long reservationId
) {
reservationService.denyWaiting(reservationId, memberId);
return RoomEscapeApiResponse.success();
return RoomescapeApiResponse.success();
}
private RoomEscapeApiResponse<ReservationResponse> getCreatedReservationResponse(
private RoomescapeApiResponse<ReservationResponse> getCreatedReservationResponse(
ReservationResponse reservationResponse,
HttpServletResponse response
) {
response.setHeader(HttpHeaders.LOCATION, "/reservations/" + reservationResponse.id());
return RoomEscapeApiResponse.success(reservationResponse);
return RoomescapeApiResponse.success(reservationResponse);
}
}

28
src/main/java/roomescape/reservation/controller/ReservationTimeController.java
View File

@ -23,15 +23,15 @@ import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotNull;
import roomescape.auth.web.support.Admin;
import roomescape.auth.web.support.LoginRequired;
import roomescape.common.dto.response.RoomescapeApiResponse;
import roomescape.common.dto.response.RoomescapeErrorResponse;
import roomescape.reservation.dto.request.ReservationTimeRequest;
import roomescape.reservation.dto.response.ReservationTimeInfosResponse;
import roomescape.reservation.dto.response.ReservationTimeResponse;
import roomescape.reservation.dto.response.ReservationTimesResponse;
import roomescape.reservation.service.ReservationTimeService;
import roomescape.auth.web.support.Admin;
import roomescape.auth.web.support.LoginRequired;
import roomescape.common.dto.response.ErrorResponse;
import roomescape.common.dto.response.RoomEscapeApiResponse;
@RestController
@Tag(name = "4. 예약 시간 API", description = "예약 시간을 조회 / 추가 / 삭제할 때 사용합니다.")
@ -50,8 +50,8 @@ public class ReservationTimeController {
@ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
})
public RoomEscapeApiResponse<ReservationTimesResponse> getAllTimes() {
return RoomEscapeApiResponse.success(reservationTimeService.findAllTimes());
public RoomescapeApiResponse<ReservationTimesResponse> getAllTimes() {
return RoomescapeApiResponse.success(reservationTimeService.findAllTimes());
}
@Admin
@ -61,16 +61,16 @@ public class ReservationTimeController {
@ApiResponses({
@ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true),
@ApiResponse(responseCode = "409", description = "같은 시간을 추가할 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class)))
content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
})
public RoomEscapeApiResponse<ReservationTimeResponse> saveTime(
public RoomescapeApiResponse<ReservationTimeResponse> saveTime(
@Valid @RequestBody ReservationTimeRequest reservationTimeRequest,
HttpServletResponse response
) {
ReservationTimeResponse reservationTimeResponse = reservationTimeService.addTime(reservationTimeRequest);
response.setHeader(HttpHeaders.LOCATION, "/times/" + reservationTimeResponse.id());
return RoomEscapeApiResponse.success(reservationTimeResponse);
return RoomescapeApiResponse.success(reservationTimeResponse);
}
@Admin
@ -80,14 +80,14 @@ public class ReservationTimeController {
@ApiResponses({
@ApiResponse(responseCode = "204", description = "성공", useReturnTypeSchema = true),
@ApiResponse(responseCode = "409", description = "예약된 시간은 삭제할 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class)))
content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
})
public RoomEscapeApiResponse<Void> removeTime(
public RoomescapeApiResponse<Void> removeTime(
@NotNull(message = "timeId는 null 또는 공백일 수 없습니다.") @PathVariable @Parameter(description = "삭제하고자 하는 시간의 ID값") Long id
) {
reservationTimeService.removeTimeById(id);
return RoomEscapeApiResponse.success();
return RoomescapeApiResponse.success();
}
@LoginRequired
@ -97,7 +97,7 @@ public class ReservationTimeController {
@ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
})
public RoomEscapeApiResponse<ReservationTimeInfosResponse> findAllAvailableReservationTimes(
public RoomescapeApiResponse<ReservationTimeInfosResponse> findAllAvailableReservationTimes(
@NotNull(message = "날짜는 null일 수 없습니다.")
@RequestParam
@Parameter(description = "yyyy-MM-dd 형식으로 입력해주세요.", example = "2024-06-10")
@ -107,6 +107,6 @@ public class ReservationTimeController {
@Parameter(description = "조회할 테마의 ID를 입력해주세요.", example = "1")
Long themeId
) {
return RoomEscapeApiResponse.success(reservationTimeService.findAllAvailableTimesByDateAndTheme(date, themeId));
return RoomescapeApiResponse.success(reservationTimeService.findAllAvailableTimesByDateAndTheme(date, themeId));
}
}

2
src/main/java/roomescape/reservation/domain/Reservation.java
View File

@ -15,9 +15,9 @@ import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import roomescape.member.infrastructure.persistence.Member;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.member.infrastructure.persistence.Member;
import roomescape.theme.domain.Theme;
@Entity

2
src/main/java/roomescape/reservation/dto/request/ReservationTimeRequest.java
View File

@ -7,9 +7,9 @@ import org.springframework.http.HttpStatus;
import io.micrometer.common.util.StringUtils;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotNull;
import roomescape.reservation.domain.ReservationTime;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.reservation.domain.ReservationTime;
@Schema(name = "예약 시간 저장 요청", description = "예약 시간 저장 요청시 사용됩니다.")
public record ReservationTimeRequest(

4
src/main/java/roomescape/reservation/service/ReservationService.java
View File

@ -9,6 +9,8 @@ import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.member.business.MemberService;
import roomescape.member.infrastructure.persistence.Member;
import roomescape.reservation.domain.Reservation;
@ -22,8 +24,6 @@ import roomescape.reservation.dto.request.WaitingRequest;
import roomescape.reservation.dto.response.MyReservationsResponse;
import roomescape.reservation.dto.response.ReservationResponse;
import roomescape.reservation.dto.response.ReservationsResponse;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.theme.domain.Theme;
import roomescape.theme.service.ThemeService;

4
src/main/java/roomescape/reservation/service/ReservationTimeService.java
View File

@ -7,6 +7,8 @@ import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.reservation.domain.Reservation;
import roomescape.reservation.domain.ReservationTime;
import roomescape.reservation.domain.repository.ReservationRepository;
@ -16,8 +18,6 @@ import roomescape.reservation.dto.response.ReservationTimeInfoResponse;
import roomescape.reservation.dto.response.ReservationTimeInfosResponse;
import roomescape.reservation.dto.response.ReservationTimeResponse;
import roomescape.reservation.dto.response.ReservationTimesResponse;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
@Service
@Transactional

24
src/main/java/roomescape/theme/controller/ThemeController.java
View File

@ -23,8 +23,8 @@ import jakarta.validation.Valid;
import jakarta.validation.constraints.NotNull;
import roomescape.auth.web.support.Admin;
import roomescape.auth.web.support.LoginRequired;
import roomescape.common.dto.response.ErrorResponse;
import roomescape.common.dto.response.RoomEscapeApiResponse;
import roomescape.common.dto.response.RoomescapeApiResponse;
import roomescape.common.dto.response.RoomescapeErrorResponse;
import roomescape.theme.dto.ThemeRequest;
import roomescape.theme.dto.ThemeResponse;
import roomescape.theme.dto.ThemesResponse;
@ -47,8 +47,8 @@ public class ThemeController {
@ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
})
public RoomEscapeApiResponse<ThemesResponse> getAllThemes() {
return RoomEscapeApiResponse.success(themeService.findAllThemes());
public RoomescapeApiResponse<ThemesResponse> getAllThemes() {
return RoomescapeApiResponse.success(themeService.findAllThemes());
}
@GetMapping("/themes/most-reserved-last-week")
@ -57,10 +57,10 @@ public class ThemeController {
@ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
})
public RoomEscapeApiResponse<ThemesResponse> getMostReservedThemes(
public RoomescapeApiResponse<ThemesResponse> getMostReservedThemes(
@RequestParam(defaultValue = "10") @Parameter(description = "최대로 조회할 테마 갯수") int count
) {
return RoomEscapeApiResponse.success(themeService.getMostReservedThemesByCount(count));
return RoomescapeApiResponse.success(themeService.getMostReservedThemesByCount(count));
}
@Admin
@ -70,16 +70,16 @@ public class ThemeController {
@ApiResponses({
@ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true),
@ApiResponse(responseCode = "409", description = "같은 이름의 테마를 추가할 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class)))
content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
})
public RoomEscapeApiResponse<ThemeResponse> saveTheme(
public RoomescapeApiResponse<ThemeResponse> saveTheme(
@Valid @RequestBody ThemeRequest request,
HttpServletResponse response
) {
ThemeResponse themeResponse = themeService.addTheme(request);
response.setHeader(HttpHeaders.LOCATION, "/themes/" + themeResponse.id());
return RoomEscapeApiResponse.success(themeResponse);
return RoomescapeApiResponse.success(themeResponse);
}
@Admin
@ -89,13 +89,13 @@ public class ThemeController {
@ApiResponses({
@ApiResponse(responseCode = "204", description = "성공", useReturnTypeSchema = true),
@ApiResponse(responseCode = "409", description = "예약된 테마는 삭제할 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class)))
content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
})
public RoomEscapeApiResponse<Void> removeTheme(
public RoomescapeApiResponse<Void> removeTheme(
@NotNull(message = "themeId는 null일 수 없습니다.") @PathVariable Long id
) {
themeService.removeThemeById(id);
return RoomEscapeApiResponse.success();
return RoomescapeApiResponse.success();
}
}

6
src/main/java/roomescape/theme/service/ThemeService.java
View File

@ -7,9 +7,9 @@ import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import roomescape.reservation.domain.repository.ReservationRepository;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.reservation.domain.repository.ReservationRepository;
import roomescape.theme.domain.Theme;
import roomescape.theme.domain.repository.ThemeRepository;
import roomescape.theme.dto.ThemeRequest;
@ -21,11 +21,9 @@ import roomescape.theme.dto.ThemesResponse;
public class ThemeService {
private final ThemeRepository themeRepository;
private final ReservationRepository reservationRepository;
public ThemeService(ThemeRepository themeRepository, ReservationRepository reservationRepository) {
public ThemeService(ThemeRepository themeRepository) {
this.themeRepository = themeRepository;
this.reservationRepository = reservationRepository;
}
@Transactional(readOnly = true)

5
src/test/java/roomescape/auth/web/AuthControllerTest.kt
View File

@ -4,10 +4,9 @@ import io.mockk.every
import org.hamcrest.Matchers.containsString
import org.hamcrest.Matchers.`is`
import org.springframework.data.repository.findByIdOrNull
import roomescape.auth.web.LoginRequest
import roomescape.common.exception.ErrorType
import roomescape.util.MemberFixture
import roomescape.util.RoomescapeApiTest
import roomescape.common.exception.ErrorType
class AuthControllerTest : RoomescapeApiTest() {
@ -32,7 +31,7 @@ class AuthControllerTest : RoomescapeApiTest() {
runPostTest(endpoint, body = MemberFixture.userLoginRequest()) {
statusCode(200)
cookie("accessToken", expectedToken)
header("Set-Cookie", containsString("Max-Age=1800000"))
header("Set-Cookie", containsString("Max-Age=1800"))
header("Set-Cookie", containsString("HttpOnly"))
header("Set-Cookie", containsString("Secure"))
}

72
src/test/java/roomescape/auth/web/support/CookieUtilsTest.kt Normal file
View File

@ -0,0 +1,72 @@
package roomescape.auth.web.support
import io.kotest.assertions.assertSoftly
import io.kotest.core.spec.style.FunSpec
import io.kotest.matchers.collections.shouldContainAll
import io.kotest.matchers.shouldBe
import io.mockk.every
import io.mockk.mockk
import jakarta.servlet.http.Cookie
import jakarta.servlet.http.HttpServletRequest
import roomescape.auth.web.TokenResponse
class CookieUtilsTest : FunSpec({
context("HttpServletRequest에서 accessToken 쿠키를 가져온다.") {
val httpServletRequest: HttpServletRequest = mockk()
test("accessToken이 있으면 해당 쿠키를 반환한다.") {
val token = "test-token"
val cookie = Cookie(ACCESS_TOKEN_COOKIE_NAME, token)
every { httpServletRequest.cookies } returns arrayOf(cookie)
assertSoftly(httpServletRequest.accessTokenCookie()) {
this.name shouldBe ACCESS_TOKEN_COOKIE_NAME
this.value shouldBe token
}
}
test("accessToken이 없으면 accessToken에 빈 값을 담은 쿠키를 반환한다.") {
every { httpServletRequest.cookies } returns arrayOf()
assertSoftly(httpServletRequest.accessTokenCookie()) {
this.name shouldBe ACCESS_TOKEN_COOKIE_NAME
this.value shouldBe ""
}
}
test("httpServletRequest.cookies가 null이면 accessToken에 빈 값을 담은 쿠키를 반환한다.") {
every { httpServletRequest.cookies } returns null
assertSoftly(httpServletRequest.accessTokenCookie()) {
this.name shouldBe ACCESS_TOKEN_COOKIE_NAME
this.value shouldBe ""
}
}
}
context("TokenResponse를 쿠키로 반환한다.") {
val tokenResponse = TokenResponse("test-token")
val result: String = tokenResponse.toResponseCookie()
result.split("; ") shouldContainAll listOf(
"accessToken=test-token",
"HttpOnly",
"Secure",
"Path=/",
"Max-Age=1800"
)
}
context("만료된 accessToken 쿠키를 반환한다.") {
val result: String = expiredAccessTokenCookie()
result.split("; ") shouldContainAll listOf(
"accessToken=",
"HttpOnly",
"Secure",
"Path=/",
"Max-Age=0"
)
}
})

316
src/test/java/roomescape/common/dto/response/RoomescapeApiResponseKTTest.kt
View File

@ -1,158 +1,158 @@
package roomescape.common.dto.response
import com.fasterxml.jackson.databind.ObjectMapper
import com.ninjasquad.springmockk.MockkBean
import com.ninjasquad.springmockk.SpykBean
import io.kotest.core.spec.style.BehaviorSpec
import org.hamcrest.CoreMatchers.equalTo
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
import org.springframework.http.MediaType
import org.springframework.test.web.servlet.MockMvc
import org.springframework.test.web.servlet.get
import org.springframework.test.web.servlet.post
import org.springframework.web.bind.annotation.*
import roomescape.auth.infrastructure.jwt.JwtHandler
import roomescape.auth.web.support.AdminInterceptor
import roomescape.auth.web.support.LoginInterceptor
import roomescape.auth.web.support.MemberIdResolver
import roomescape.common.exception.ErrorType
import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.MemberRepository
@WebMvcTest(ApiResponseTestController::class)
class RoomescapeApiResponseKTTest(
@Autowired private val mockMvc: MockMvc
) : BehaviorSpec() {
@Autowired
private lateinit var AdminInterceptor: AdminInterceptor
@Autowired
private lateinit var loginInterceptor: LoginInterceptor
@Autowired
private lateinit var memberIdResolver: MemberIdResolver
@SpykBean
private lateinit var memberService: MemberService
@MockkBean
private lateinit var memberRepository: MemberRepository
@MockkBean
private lateinit var jwtHandler: JwtHandler
init {
Given("성공 응답에") {
val endpoint = "/success"
When("객체 데이터를 담으면") {
val id: Long = 1L
val name = "name"
Then("success=true, data={객체} 형태로 응답한다.") {
mockMvc.post("$endpoint/$id/$name") {
contentType = MediaType.APPLICATION_JSON
}.andDo {
print()
}.andExpect {
status { isOk() }
jsonPath("$.success", equalTo(true))
jsonPath("$.data.id", equalTo(id.toInt()))
jsonPath("$.data.name", equalTo(name))
}
}
}
When("문자열 데이터를 담으면") {
val message: String = "Hello, World!"
Then("success=true, data={문자열} 형태로 응답한다.") {
mockMvc.get("/success/$message") {
contentType = MediaType.APPLICATION_JSON
}.andDo {
print()
}.andExpect {
status { isOk() }
jsonPath("$.success", equalTo(true))
jsonPath("$.data", equalTo(message))
}
}
}
}
Given("실패 응답에") {
val endpoint = "/fail"
val objectMapper = ObjectMapper()
When("errorType만 담으면") {
Then("success=false, errorType={errorType}, message={errorType.description} 형태로 응답한다.") {
mockMvc.post(endpoint) {
contentType = MediaType.APPLICATION_JSON
content = objectMapper.writeValueAsString(FailRequest(errorType = ErrorType.INTERNAL_SERVER_ERROR))
}.andDo {
print()
}.andExpect {
status { isOk() }
jsonPath("$.success", equalTo(false))
jsonPath("$.errorType", equalTo(ErrorType.INTERNAL_SERVER_ERROR.name))
jsonPath("$.message", equalTo(ErrorType.INTERNAL_SERVER_ERROR.description))
}
}
}
When("errorType과 message를 담으면") {
val message: String = "An error occurred"
Then("success=false, errorType={errorType}, message={message} 형태로 응답한다.") {
mockMvc.post(endpoint) {
contentType = MediaType.APPLICATION_JSON
content = objectMapper.writeValueAsString(FailRequest(errorType = ErrorType.INTERNAL_SERVER_ERROR, message = message))
}.andDo {
print()
}.andExpect {
status { isOk() }
jsonPath("$.success", equalTo(false))
jsonPath("$.errorType", equalTo(ErrorType.INTERNAL_SERVER_ERROR.name))
jsonPath("$.message", equalTo(message))
}
}
}
}
}
}
data class SuccessResponse(
val id: Long,
val name: String
)
data class FailRequest(
val errorType: ErrorType,
val message: String? = null
)
@RestController
class ApiResponseTestController {
@GetMapping("/success/{message}")
fun succeedToGet(
@PathVariable message: String,
): RoomescapeApiResponseKT<String> =
RoomescapeApiResponseKT.success(message)
@PostMapping("/success/{id}/{name}")
fun succeedToPost(
@PathVariable id: Long,
@PathVariable name: String,
): RoomescapeApiResponseKT<SuccessResponse> =
RoomescapeApiResponseKT.success(SuccessResponse(id, name))
@PostMapping("/fail")
fun fail(
@RequestBody request: FailRequest
): RoomescapeApiResponseKT<Unit> =
request.message?.let {
RoomescapeApiResponseKT.fail(request.errorType, it)
} ?: RoomescapeApiResponseKT.fail(request.errorType)
}
//package roomescape.common.dto.response
//
//import com.fasterxml.jackson.databind.ObjectMapper
//import com.ninjasquad.springmockk.MockkBean
//import com.ninjasquad.springmockk.SpykBean
//import io.kotest.core.spec.style.BehaviorSpec
//import org.hamcrest.CoreMatchers.equalTo
//import org.springframework.beans.factory.annotation.Autowired
//import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
//import org.springframework.http.MediaType
//import org.springframework.test.web.servlet.MockMvc
//import org.springframework.test.web.servlet.get
//import org.springframework.test.web.servlet.post
//import org.springframework.web.bind.annotation.*
//import roomescape.auth.infrastructure.jwt.JwtHandler
//import roomescape.auth.web.support.AdminInterceptor
//import roomescape.auth.web.support.LoginInterceptor
//import roomescape.auth.web.support.MemberIdResolver
//import roomescape.common.exception.ErrorType
//import roomescape.member.business.MemberService
//import roomescape.member.infrastructure.persistence.MemberRepository
//
//@WebMvcTest(ApiResponseTestController::class)
//class RoomescapeApiResponseKTTest(
// @Autowired private val mockMvc: MockMvc
//) : BehaviorSpec() {
// @Autowired
// private lateinit var AdminInterceptor: AdminInterceptor
//
// @Autowired
// private lateinit var loginInterceptor: LoginInterceptor
//
// @Autowired
// private lateinit var memberIdResolver: MemberIdResolver
//
// @SpykBean
// private lateinit var memberService: MemberService
//
// @MockkBean
// private lateinit var memberRepository: MemberRepository
//
// @MockkBean
// private lateinit var jwtHandler: JwtHandler
//
// init {
// Given("성공 응답에") {
// val endpoint = "/success"
// When("객체 데이터를 담으면") {
// val id: Long = 1L
// val name = "name"
// Then("success=true, data={객체} 형태로 응답한다.") {
// mockMvc.post("$endpoint/$id/$name") {
// contentType = MediaType.APPLICATION_JSON
// }.andDo {
// print()
// }.andExpect {
// status { isOk() }
// jsonPath("$.success", equalTo(true))
// jsonPath("$.data.id", equalTo(id.toInt()))
// jsonPath("$.data.name", equalTo(name))
// }
// }
// }
//
// When("문자열 데이터를 담으면") {
// val message: String = "Hello, World!"
//
// Then("success=true, data={문자열} 형태로 응답한다.") {
// mockMvc.get("/success/$message") {
// contentType = MediaType.APPLICATION_JSON
// }.andDo {
// print()
// }.andExpect {
// status { isOk() }
// jsonPath("$.success", equalTo(true))
// jsonPath("$.data", equalTo(message))
// }
// }
// }
// }
//
// Given("실패 응답에") {
// val endpoint = "/fail"
// val objectMapper = ObjectMapper()
//
// When("errorType만 담으면") {
// Then("success=false, errorType={errorType}, message={errorType.description} 형태로 응답한다.") {
// mockMvc.post(endpoint) {
// contentType = MediaType.APPLICATION_JSON
// content = objectMapper.writeValueAsString(FailRequest(errorType = ErrorType.INTERNAL_SERVER_ERROR))
// }.andDo {
// print()
// }.andExpect {
// status { isOk() }
// jsonPath("$.success", equalTo(false))
// jsonPath("$.errorType", equalTo(ErrorType.INTERNAL_SERVER_ERROR.name))
// jsonPath("$.message", equalTo(ErrorType.INTERNAL_SERVER_ERROR.description))
// }
// }
// }
//
// When("errorType과 message를 담으면") {
// val message: String = "An error occurred"
//
// Then("success=false, errorType={errorType}, message={message} 형태로 응답한다.") {
// mockMvc.post(endpoint) {
// contentType = MediaType.APPLICATION_JSON
// content = objectMapper.writeValueAsString(FailRequest(errorType = ErrorType.INTERNAL_SERVER_ERROR, message = message))
// }.andDo {
// print()
// }.andExpect {
// status { isOk() }
// jsonPath("$.success", equalTo(false))
// jsonPath("$.errorType", equalTo(ErrorType.INTERNAL_SERVER_ERROR.name))
// jsonPath("$.message", equalTo(message))
// }
// }
// }
// }
// }
//}
//
//data class SuccessResponse(
// val id: Long,
// val name: String
//)
//
//data class FailRequest(
// val errorType: ErrorType,
// val message: String? = null
//)
//
//@RestController
//class ApiResponseTestController {
//
// @GetMapping("/success/{message}")
// fun succeedToGet(
// @PathVariable message: String,
// ): RoomescapeApiResponseKT<String> =
// RoomescapeApiResponseKT.success(message)
//
//
// @PostMapping("/success/{id}/{name}")
// fun succeedToPost(
// @PathVariable id: Long,
// @PathVariable name: String,
// ): RoomescapeApiResponseKT<SuccessResponse> =
// RoomescapeApiResponseKT.success(SuccessResponse(id, name))
//
//
// @PostMapping("/fail")
// fun fail(
// @RequestBody request: FailRequest
// ): RoomescapeApiResponseKT<Unit> =
// request.message?.let {
// RoomescapeApiResponseKT.fail(request.errorType, it)
// } ?: RoomescapeApiResponseKT.fail(request.errorType)
//}