[3 - 4단계 방탈출 예약 대기] 카피(김상혁) 미션 제출합니다.

src/main/java/roomescape/RoomescapeApplication.java

@@ -2,8 +2,10 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
 
 @SpringBootApplication
+@EnableJpaAuditing
 public class RoomescapeApplication {
     public static void main(String[] args) {
         SpringApplication.run(RoomescapeApplication.class, args);

src/main/java/roomescape/auth/AdminAuthHandlerInterceptor.java

@@ -17,7 +17,8 @@ public class AdminAuthHandlerInterceptor implements HandlerInterceptor {
     private final AuthService authService;
     private final TokenProvider tokenProvider;
 
-    public AdminAuthHandlerInterceptor(AuthService authService, TokenProvider tokenProvider) {
+    public AdminAuthHandlerInterceptor(AuthService authService,
+                                       TokenProvider tokenProvider) {
         this.authService = authService;
         this.tokenProvider = tokenProvider;
     }

src/main/java/roomescape/auth/AuthenticatedMemberArgumentResolver.java

@@ -19,15 +19,16 @@ public class AuthenticatedMemberArgumentResolver implements HandlerMethodArgumen
     private final AuthService authService;
     private final TokenProvider tokenProvider;
 
-    public AuthenticatedMemberArgumentResolver(AuthService authService, TokenProvider tokenProvider) {
+    public AuthenticatedMemberArgumentResolver(AuthService authService,
+                                               TokenProvider tokenProvider) {
         this.authService = authService;
         this.tokenProvider = tokenProvider;
     }
 
     @Override
     public boolean supportsParameter(MethodParameter parameter) {
         return parameter.hasParameterAnnotation(AuthenticatedMember.class)
-                && Member.class.isAssignableFrom(parameter.getParameterType());
+               && Member.class.isAssignableFrom(parameter.getParameterType());
     }
 
     @Override

src/main/java/roomescape/config/AuthWebConfig.java

@@ -27,6 +27,6 @@ public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers)
 
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
-        registry.addInterceptor(adminAuthHandlerInterceptor).addPathPatterns("/admin/**");
+        registry.addInterceptor(adminAuthHandlerInterceptor).addPathPatterns("/admin/**", "/api/admin/**");
     }
 }

src/main/java/roomescape/controller/api/AuthApiController.java

@@ -23,13 +23,15 @@ public AuthApiController(AuthService authService) {
         this.authService = authService;
     }
 
-    @GetMapping("/login/check")
+    @GetMapping("/api/login/check")
     public ResponseEntity<MemberIdAndNameResponse> getMemberLoginInfo(@AuthenticatedMember Member member) {
         return ResponseEntity.ok(new MemberIdAndNameResponse(member.getId(), member.getName()));
     }
 
-    @PostMapping("/login")
-    public ResponseEntity<Void> login(@RequestBody @Valid LoginRequest request, HttpServletResponse response) {
+    @PostMapping("/api/login")
+    public ResponseEntity<Void> login(@RequestBody @Valid
+                                      LoginRequest request,
+                                      HttpServletResponse response) {
         String accessToken = authService.login(request);
         Cookie cookie = new Cookie("token", accessToken);
         cookie.setHttpOnly(true);

src/main/java/roomescape/controller/api/MemberApiController.java

@@ -21,10 +21,11 @@ public MemberApiController(MemberService memberService) {
         this.memberService = memberService;
     }
 
-    @PostMapping("/members")
-    public ResponseEntity<MemberIdAndNameResponse> signup(@RequestBody @Valid SignupRequest request) {
+    @PostMapping("/api/members")
+    public ResponseEntity<MemberIdAndNameResponse> signup(@RequestBody @Valid
+                                                          SignupRequest request) {
         Member member = memberService.signUp(request);
-        return ResponseEntity.created(URI.create("/members/" + member.getId()))
+        return ResponseEntity.created(URI.create("/api/members/" + member.getId()))
                 .body(new MemberIdAndNameResponse(member.getId(), member.getName()));
     }
 }

src/main/java/roomescape/controller/api/ReservationApiController.java

@@ -1,23 +1,21 @@
 package roomescape.controller.api;
 
 import jakarta.validation.Valid;
-import jakarta.validation.constraints.Positive;
 import org.springframework.http.ResponseEntity;
 import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RestController;
 import roomescape.auth.AuthenticatedMember;
 import roomescape.domain.Member;
 import roomescape.domain.Reservation;
+import roomescape.domain.ReservationStatus;
+import roomescape.domain.ReservationWaitingWithRank;
 import roomescape.service.dto.request.ReservationSaveRequest;
+import roomescape.service.dto.response.MemberReservationResponse;
 import roomescape.service.dto.response.ReservationResponse;
-import roomescape.service.dto.response.UserReservationResponse;
 import roomescape.service.reservation.ReservationCreateService;
-import roomescape.service.reservation.ReservationDeleteService;
 import roomescape.service.reservation.ReservationFindService;
 
 import java.net.URI;
@@ -29,17 +27,14 @@ public class ReservationApiController {
 
     private final ReservationCreateService reservationCreateService;
     private final ReservationFindService reservationFindService;
-    private final ReservationDeleteService reservationDeleteService;
 
     public ReservationApiController(ReservationCreateService reservationCreateService,
-                                    ReservationFindService reservationFindService,
-                                    ReservationDeleteService reservationDeleteService) {
+                                    ReservationFindService reservationFindService) {
         this.reservationCreateService = reservationCreateService;
         this.reservationFindService = reservationFindService;
-        this.reservationDeleteService = reservationDeleteService;
     }
 
-    @GetMapping("/reservations")
+    @GetMapping("/api/reservations")
     public ResponseEntity<List<ReservationResponse>> getReservations() {
         List<Reservation> reservations = reservationFindService.findReservations();
         return ResponseEntity.ok(
@@ -49,28 +44,27 @@ public ResponseEntity<List<ReservationResponse>> getReservations() {
         );
     }
 
-    @GetMapping("/reservations-mine")
-    public ResponseEntity<List<UserReservationResponse>> getUserReservations(@AuthenticatedMember Member member) {
-        List<Reservation> userReservations = reservationFindService.findUserReservations(member.getId());
+    @GetMapping("/api/reservations-mine")
+    public ResponseEntity<List<MemberReservationResponse>> getMemberReservations(@AuthenticatedMember Member member) {
+        List<ReservationWaitingWithRank> reservationWaitingWithRanks =
+                reservationFindService.findMemberReservations(member.getId());
         return ResponseEntity.ok(
-                userReservations.stream()
-                        .map(UserReservationResponse::new)
+                reservationWaitingWithRanks.stream()
+                        .map(MemberReservationResponse::new)
                         .toList()
         );
     }
 
-    @PostMapping("/reservations")
-    public ResponseEntity<ReservationResponse> addReservationByUser(@RequestBody @Valid ReservationSaveRequest request,
-                                                                    @AuthenticatedMember Member member) {
-        Reservation newReservation = reservationCreateService.createReservation(request, member);
-        return ResponseEntity.created(URI.create("/reservations/" + newReservation.getId()))
+    @PostMapping("/api/reservations")
+    public ResponseEntity<ReservationResponse> addReservationByMember(@RequestBody @Valid
+                                                                      ReservationSaveRequest request,
+                                                                      @AuthenticatedMember Member member) {
+        Reservation newReservation = reservationCreateService.createReservation(
+                request,
+                member,
+                ReservationStatus.RESERVED
+        );
+        return ResponseEntity.created(URI.create("/api/reservations/" + newReservation.getId()))
                 .body(new ReservationResponse(newReservation));
     }
-
-    @DeleteMapping("/reservations/{id}")
-    public ResponseEntity<Void> deleteReservation(@PathVariable
-                                                  @Positive(message = "1 이상의 값만 입력해주세요.") long id) {
-        reservationDeleteService.deleteReservation(id);
-        return ResponseEntity.noContent().build();
-    }
 }

src/main/java/roomescape/controller/api/ReservationTimeApiController.java

@@ -1,46 +1,31 @@
 package roomescape.controller.api;
 
-import jakarta.validation.Valid;
 import jakarta.validation.constraints.Positive;
 import org.springframework.http.ResponseEntity;
 import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
-import roomescape.domain.ReservationStatus;
+import roomescape.domain.BookingStatus;
 import roomescape.domain.ReservationTime;
-import roomescape.service.dto.request.ReservationTimeSaveRequest;
-import roomescape.service.dto.response.ReservationStatusResponse;
+import roomescape.service.dto.response.BookingStatusResponse;
 import roomescape.service.dto.response.ReservationTimeResponse;
-import roomescape.service.reservationtime.ReservationTimeCreateService;
-import roomescape.service.reservationtime.ReservationTimeDeleteService;
 import roomescape.service.reservationtime.ReservationTimeFindService;
 
-import java.net.URI;
 import java.time.LocalDate;
 import java.util.List;
 
 @Validated
 @RestController
 public class ReservationTimeApiController {
 
-    private final ReservationTimeCreateService reservationTimeCreateService;
     private final ReservationTimeFindService reservationTimeFindService;
-    private final ReservationTimeDeleteService reservationTimeDeleteService;
 
-    public ReservationTimeApiController(ReservationTimeCreateService reservationTimeCreateService,
-                                        ReservationTimeFindService reservationTimeFindService,
-                                        ReservationTimeDeleteService reservationTimeDeleteService) {
-        this.reservationTimeCreateService = reservationTimeCreateService;
+    public ReservationTimeApiController(ReservationTimeFindService reservationTimeFindService) {
         this.reservationTimeFindService = reservationTimeFindService;
-        this.reservationTimeDeleteService = reservationTimeDeleteService;
     }
 
-    @GetMapping("/times")
+    @GetMapping("/api/times")
     public ResponseEntity<List<ReservationTimeResponse>> getReservationTimes() {
         List<ReservationTime> reservationTimes = reservationTimeFindService.findReservationTimes();
         return ResponseEntity.ok(
@@ -50,35 +35,21 @@ public ResponseEntity<List<ReservationTimeResponse>> getReservationTimes() {
         );
     }
 
-    @GetMapping("/times/available")
-    public ResponseEntity<List<ReservationStatusResponse>> getReservationTimesIsBooked(
-            @RequestParam LocalDate date,
-            @RequestParam @Positive(message = "1 이상의 값만 입력해주세요.") long themeId) {
-        ReservationStatus reservationStatus = reservationTimeFindService.findIsBooked(date, themeId);
+    @GetMapping("/api/times/available")
+    public ResponseEntity<List<BookingStatusResponse>> getReservationTimesIsBooked(@RequestParam LocalDate date,
+                                                                                   @RequestParam
+                                                                                   @Positive(message = "1 이상의 값만 입력해주세요.")
+                                                                                   long themeId) {
+        BookingStatus bookingStatus = reservationTimeFindService.findTimeSlotsBookingStatus(date, themeId);
         return ResponseEntity.ok(
-                reservationStatus.getReservationStatus()
+                bookingStatus.getReservationStatus()
                         .entrySet()
                         .stream()
-                        .map(status -> new ReservationStatusResponse(
+                        .map(status -> new BookingStatusResponse(
                                         status.getKey(),
                                         status.getValue()
                                 )
                         ).toList()
         );
     }
-
-    @PostMapping("/times")
-    public ResponseEntity<ReservationTimeResponse> addReservationTime(
-            @RequestBody @Valid ReservationTimeSaveRequest request) {
-        ReservationTime reservationTime = reservationTimeCreateService.createReservationTime(request);
-        return ResponseEntity.created(URI.create("times/" + reservationTime.getId()))
-                .body(new ReservationTimeResponse(reservationTime));
-    }
-
-    @DeleteMapping("/times/{id}")
-    public ResponseEntity<Void> deleteReservationTime(@PathVariable
-                                                      @Positive(message = "1 이상의 값만 입력해주세요.") long id) {
-        reservationTimeDeleteService.deleteReservationTime(id);
-        return ResponseEntity.noContent().build();
-    }
 }

src/main/java/roomescape/controller/api/ThemeApiController.java

@@ -1,41 +1,26 @@
 package roomescape.controller.api;
 
-import jakarta.validation.Valid;
-import jakarta.validation.constraints.Positive;
-import java.net.URI;
-import java.util.List;
 import org.springframework.http.ResponseEntity;
 import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RestController;
 import roomescape.domain.Theme;
-import roomescape.service.dto.request.ThemeSaveRequest;
 import roomescape.service.dto.response.ThemeResponse;
-import roomescape.service.theme.ThemeCreateService;
-import roomescape.service.theme.ThemeDeleteService;
 import roomescape.service.theme.ThemeFindService;
 
+import java.util.List;
+
 @Validated
 @RestController
 public class ThemeApiController {
 
-    private final ThemeCreateService themeCreateService;
     private final ThemeFindService themeFindService;
-    private final ThemeDeleteService themeDeleteService;
 
-    public ThemeApiController(ThemeCreateService themeCreateService,
-                              ThemeFindService themeFindService,
-                              ThemeDeleteService themeDeleteService) {
-        this.themeCreateService = themeCreateService;
+    public ThemeApiController(ThemeFindService themeFindService) {
         this.themeFindService = themeFindService;
-        this.themeDeleteService = themeDeleteService;
     }
 
-    @GetMapping("/themes")
+    @GetMapping("/api/themes")
     public ResponseEntity<List<ThemeResponse>> getThemes() {
         List<Theme> themes = themeFindService.findThemes();
         return ResponseEntity.ok(
@@ -45,7 +30,7 @@ public ResponseEntity<List<ThemeResponse>> getThemes() {
         );
     }
 
-    @GetMapping("/themes/ranks")
+    @GetMapping("/api/themes/ranks")
     public ResponseEntity<List<ThemeResponse>> getThemeRanks() {
         List<Theme> themes = themeFindService.findThemeRanks();
         return ResponseEntity.ok(
@@ -54,18 +39,4 @@ public ResponseEntity<List<ThemeResponse>> getThemeRanks() {
                         .toList()
         );
     }
-
-    @PostMapping("/themes")
-    public ResponseEntity<ThemeResponse> addTheme(@RequestBody @Valid ThemeSaveRequest request) {
-        Theme theme = themeCreateService.createTheme(request);
-        return ResponseEntity.created(URI.create("/themes/" + theme.getId()))
-                .body(new ThemeResponse(theme));
-    }
-
-    @DeleteMapping("/themes/{id}")
-    public ResponseEntity<Void> deleteTheme(@PathVariable
-                                            @Positive(message = "1 이상의 값만 입력해주세요.") long id) {
-        themeDeleteService.deleteTheme(id);
-        return ResponseEntity.noContent().build();
-    }
 }

src/main/java/roomescape/controller/api/WaitingApiController.java

@@ -0,0 +1,55 @@
+package roomescape.controller.api;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.Positive;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RestController;
+import roomescape.auth.AuthenticatedMember;
+import roomescape.domain.Member;
+import roomescape.domain.Reservation;
+import roomescape.domain.ReservationStatus;
+import roomescape.service.dto.request.ReservationSaveRequest;
+import roomescape.service.dto.response.ReservationResponse;
+import roomescape.service.reservation.ReservationCreateService;
+import roomescape.service.reservation.ReservationDeleteService;
+
+import java.net.URI;
+
+@RestController
+public class WaitingApiController {
+
+    private final ReservationCreateService reservationCreateService;
+    private final ReservationDeleteService reservationDeleteService;
+
+    public WaitingApiController(ReservationCreateService reservationCreateService,
+                                ReservationDeleteService reservationDeleteService) {
+        this.reservationCreateService = reservationCreateService;
+        this.reservationDeleteService = reservationDeleteService;
+    }
+
+    @PostMapping("/api/waitings")
+    public ResponseEntity<ReservationResponse> addWaiting(@AuthenticatedMember Member member,
+                                                          @RequestBody @Valid
+                                                          ReservationSaveRequest request) {
+        Reservation newReservation = reservationCreateService.createReservation(
+                request,
+                member,
+                ReservationStatus.WAITING
+        );
+        return ResponseEntity.created(URI.create("/api/waitings/" + newReservation.getId()))
+                .body(new ReservationResponse(newReservation));
+    }
+
+    @DeleteMapping("/api/waitings/{id}")
+    public ResponseEntity<Void> deleteWaiting(@AuthenticatedMember Member member,
+                                              @PathVariable
+                                              @Positive(message = "1 이상의 값만 입력해주세요.")
+                                              long id) {
+        reservationDeleteService.deleteReservation(id, member);
+        return ResponseEntity.noContent().build();
+    }
+}