[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

@@ -7,13 +7,15 @@
 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.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 import roomescape.auth.AuthenticatedMember;
 import roomescape.domain.Member;
 import roomescape.service.auth.AuthService;
 import roomescape.service.dto.request.LoginRequest;
 import roomescape.service.dto.response.MemberIdAndNameResponse;
 
+@RequestMapping("/api")
 @RestController
 public class AuthApiController {
 
@@ -29,7 +31,9 @@ public ResponseEntity<MemberIdAndNameResponse> getMemberLoginInfo(@Authenticated
     }
 
     @PostMapping("/login")
-    public ResponseEntity<Void> login(@RequestBody @Valid LoginRequest request, HttpServletResponse response) {
+    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

@@ -9,39 +9,35 @@
 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.RequestMapping;
 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 roomescape.service.reservation.ReservationService;
 
 import java.net.URI;
 import java.util.List;
 
 @Validated
+@RequestMapping("/api")
 @RestController
 public class ReservationApiController {
 
-    private final ReservationCreateService reservationCreateService;
-    private final ReservationFindService reservationFindService;
-    private final ReservationDeleteService reservationDeleteService;
+    private final ReservationService reservationService;
 
-    public ReservationApiController(ReservationCreateService reservationCreateService,
-                                    ReservationFindService reservationFindService,
-                                    ReservationDeleteService reservationDeleteService) {
-        this.reservationCreateService = reservationCreateService;
-        this.reservationFindService = reservationFindService;
-        this.reservationDeleteService = reservationDeleteService;
+    public ReservationApiController(ReservationService reservationService) {
+        this.reservationService = reservationService;
     }
 
     @GetMapping("/reservations")
     public ResponseEntity<List<ReservationResponse>> getReservations() {
-        List<Reservation> reservations = reservationFindService.findReservations();
+        List<Reservation> reservations = reservationService.findReservations();
         return ResponseEntity.ok(
                 reservations.stream()
                         .map(ReservationResponse::new)
@@ -50,27 +46,34 @@ public ResponseEntity<List<ReservationResponse>> getReservations() {
     }
 
     @GetMapping("/reservations-mine")
-    public ResponseEntity<List<UserReservationResponse>> getUserReservations(@AuthenticatedMember Member member) {
-        List<Reservation> userReservations = reservationFindService.findUserReservations(member.getId());
+    public ResponseEntity<List<MemberReservationResponse>> getMemberReservations(@AuthenticatedMember Member member) {
+        List<ReservationWaitingWithRank> reservationWaitingWithRanks =
+                reservationService.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()))
+    public ResponseEntity<ReservationResponse> addReservationByMember(@RequestBody @Valid
+                                                                      ReservationSaveRequest request,
+                                                                      @AuthenticatedMember Member member) {
+        Reservation newReservation = reservationService.createReservation(
+                request,
+                member
+        );
+        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);
+    public ResponseEntity<Void> deleteWaiting(@AuthenticatedMember Member member,
+                                              @PathVariable
+                                              @Positive(message = "1 이상의 값만 입력해주세요.")
+                                              long id) {
+        reservationService.deleteReservation(id, member);
         return ResponseEntity.noContent().build();
     }
 }

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

@@ -1,84 +1,57 @@
 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.RequestMapping;
 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 roomescape.service.reservationtime.ReservationTimeService;
 
-import java.net.URI;
 import java.time.LocalDate;
 import java.util.List;
 
 @Validated
+@RequestMapping("/api/times")
 @RestController
 public class ReservationTimeApiController {
 
-    private final ReservationTimeCreateService reservationTimeCreateService;
-    private final ReservationTimeFindService reservationTimeFindService;
-    private final ReservationTimeDeleteService reservationTimeDeleteService;
+    private final ReservationTimeService reservationTimeService;
 
-    public ReservationTimeApiController(ReservationTimeCreateService reservationTimeCreateService,
-                                        ReservationTimeFindService reservationTimeFindService,
-                                        ReservationTimeDeleteService reservationTimeDeleteService) {
-        this.reservationTimeCreateService = reservationTimeCreateService;
-        this.reservationTimeFindService = reservationTimeFindService;
-        this.reservationTimeDeleteService = reservationTimeDeleteService;
+    public ReservationTimeApiController(ReservationTimeService reservationTimeService) {
+        this.reservationTimeService = reservationTimeService;
     }
 
-    @GetMapping("/times")
+    @GetMapping
     public ResponseEntity<List<ReservationTimeResponse>> getReservationTimes() {
-        List<ReservationTime> reservationTimes = reservationTimeFindService.findReservationTimes();
+        List<ReservationTime> reservationTimes = reservationTimeService.findReservationTimes();
         return ResponseEntity.ok(
                 reservationTimes.stream()
                         .map(ReservationTimeResponse::new)
                         .toList()
         );
     }
 
-    @GetMapping("/times/available")
-    public ResponseEntity<List<ReservationStatusResponse>> getReservationTimesIsBooked(
-            @RequestParam LocalDate date,
-            @RequestParam @Positive(message = "1 이상의 값만 입력해주세요.") long themeId) {
-        ReservationStatus reservationStatus = reservationTimeFindService.findIsBooked(date, themeId);
+    @GetMapping("/available")
+    public ResponseEntity<List<BookingStatusResponse>> getReservationTimesIsBooked(@RequestParam LocalDate date,
+                                                                                   @RequestParam
+                                                                                   @Positive(message = "1 이상의 값만 입력해주세요.")
+                                                                                   long themeId) {
+        BookingStatus bookingStatus = reservationTimeService.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,71 +1,44 @@
 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.RequestMapping;
 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 roomescape.service.theme.ThemeService;
+
+import java.util.List;
 
 @Validated
+@RequestMapping("/api/themes")
 @RestController
 public class ThemeApiController {
 
-    private final ThemeCreateService themeCreateService;
-    private final ThemeFindService themeFindService;
-    private final ThemeDeleteService themeDeleteService;
+    private final ThemeService themeService;
 
-    public ThemeApiController(ThemeCreateService themeCreateService,
-                              ThemeFindService themeFindService,
-                              ThemeDeleteService themeDeleteService) {
-        this.themeCreateService = themeCreateService;
-        this.themeFindService = themeFindService;
-        this.themeDeleteService = themeDeleteService;
+    public ThemeApiController(ThemeService themeService) {
+        this.themeService = themeService;
     }
 
-    @GetMapping("/themes")
+    @GetMapping
     public ResponseEntity<List<ThemeResponse>> getThemes() {
-        List<Theme> themes = themeFindService.findThemes();
+        List<Theme> themes = themeService.findThemes();
         return ResponseEntity.ok(
                 themes.stream()
                         .map(ThemeResponse::new)
                         .toList()
         );
     }
 
-    @GetMapping("/themes/ranks")
+    @GetMapping("/ranks")
     public ResponseEntity<List<ThemeResponse>> getThemeRanks() {
-        List<Theme> themes = themeFindService.findThemeRanks();
+        List<Theme> themes = themeService.findThemeRanks();
         return ResponseEntity.ok(
                 themes.stream()
                         .map(ThemeResponse::new)
                         .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/admin/AdminMemberApiController.java

@@ -18,7 +18,7 @@ public AdminMemberApiController(MemberService memberService) {
         this.memberService = memberService;
     }
 
-    @GetMapping("/admin/members")
+    @GetMapping("/api/admin/members")
     public ResponseEntity<List<MemberIdAndNameResponse>> getMembers() {
         List<Member> members = memberService.findMembers();
         return ResponseEntity.ok(