[Project] 상영관 및 상영시간 테스트

testController

@GetMapping("/admin/test/showtime")
    public ResponseEntity<?> showtimetest() {
        Admin sessionAdmin = (Admin) session.getAttribute("sessionAdmin");
        int cinemaId = 1;
        LocalDate startDate = LocalDate.of(2024, 9, 25);
        // DTO 생성
        AdminShowtimeResponse.CinemaScheduleWithMoviesDTO cinemaSchedule = adminService.상영관별상영스케줄(sessionAdmin, startDate);
        // DTO 상태를 확인
        for (int i = 0; i < cinemaSchedule.getCinemaSchedule().getScreens().size(); i++) {
            System.out.println("Screen " + (i + 1) + " can add showtime: " + cinemaSchedule.getCinemaSchedule().getScreens().get(i).getCanAddShowtime());
        }

        // JSON 형식으로 DTO 반환
        return ResponseEntity.ok(cinemaSchedule);
    }

결과 json

{
  "cinemaSchedule": {
    "cinemaId": 1,
    "cinemaName": "서면롯데시네마",
    "screens": [
      {
        "screenId": 1,
        "screenName": "서면1상영관",
        "showtimes": [
          {
            "showtimeId": 7,
            "movieName": "Interstellar",
            "runtime": 169,
            "startedAt": "18:00"
          },
          {
            "showtimeId": 12,
            "movieName": "Parasite",
            "runtime": 132,
            "startedAt": "20:00"
          }
        ],
        "nextAvailableTime": "2024-09-25T22:42:00",
        "canAddShowtime": "true",
        "formattedNextAvailableTime": "2024-09-25 22:42"
      },
      {
        "screenId": 2,
        "screenName": "서면2상영관",
        "showtimes": [ ],
        "nextAvailableTime": "2024-09-25T00:00:00",
        "canAddShowtime": "true",
        "formattedNextAvailableTime": "2024-09-25 00:00"
      },
      {
        "screenId": 3,
        "screenName": "서면3상영관",
        "showtimes": [ ],
        "nextAvailableTime": "2024-09-25T00:00:00",
        "canAddShowtime": "true",
        "formattedNextAvailableTime": "2024-09-25 00:00"
      },
      {
        "screenId": 4,
        "screenName": "서면4상영관",
        "showtimes": [ ],
        "nextAvailableTime": "2024-09-25T00:00:00",
        "canAddShowtime": "true",
        "formattedNextAvailableTime": "2024-09-25 00:00"
      }
    ]
  },
  "movieList": [
    {
      "movieId": 1,
      "movieName": "Interstellar",
      "runtime": 169
    },
    {
      "movieId": 2,
      "movieName": "Parasite",
      "runtime": 132
    },
    {
      "movieId": 3,
      "movieName": "The Godfather",
      "runtime": 175
    },
    {
      "movieId": 4,
      "movieName": "Your Name",
      "runtime": 112
    },
    {
      "movieId": 5,
      "movieName": "Spirited Away",
      "runtime": 125
    }
  ]
}

Service

  public AdminShowtimeResponse.CinemaScheduleWithMoviesDTO 상영관별상영스케줄(Admin sessionAdmin, LocalDate selectedDate) {

        System.out.println(selectedDate);

        // 영화 목록을 가져옴
        List<Movie> movies = movieRepository.findAll();
        List<AdminShowtimeResponse.movieDTO> movieDTOList = new ArrayList<>();
        for (Movie movie : movies) {
            movieDTOList.add(new AdminShowtimeResponse.movieDTO(movie));
        }

        Long cinemaId = 1L;

        // 영화관 정보를 가져옴
        Cinema cinema = cinemaRepository.findById(cinemaId)
                .orElseThrow(() -> new IllegalArgumentException("Cinema not found"));

        // CinemaWithScreensDTO에 영화관 정보를 저장
        AdminShowtimeResponse.CinemaWithScreensDTO cinemaWithScreensDTO = new AdminShowtimeResponse.CinemaWithScreensDTO(cinema);

        // 상영관들의 ID 리스트를 추출
        List<Long> screenIds = new ArrayList<>();
        for (Screen screen : cinema.getScreens()) {
            screenIds.add(screen.getId());
        }

        // 각 상영관에 대한 ScreenDTO 생성
        for (Screen screen : cinema.getScreens()) {
            AdminShowtimeResponse.ScreenDTO screenDTO = new AdminShowtimeResponse.ScreenDTO(screen);
            cinemaWithScreensDTO.addScreen(screenDTO);  // 각 상영관 정보를 추가
        }

        // 상영시간을 조회 (주어진 날짜와 상영관 ID 리스트에 맞게)
        List<Showtime> showtimes = showtimeRepository.findByScreenIdsAndShowDate(screenIds, selectedDate);

        // 각 상영관에 대해 showtime 추가 및 검증
        for (AdminShowtimeResponse.ScreenDTO screenDTO : cinemaWithScreensDTO.getScreens()) {
            // 상영관에 해당하는 상영시간 필터링
            List<Showtime> screenShowtimes = new ArrayList<>();
            for (Showtime showtime : showtimes) {
                if (showtime.getScreen().getId().equals(screenDTO.getScreenId())) {
                    screenShowtimes.add(showtime);
                }
            }

            // 상영 시간이 있을 경우
            if (!screenShowtimes.isEmpty()) {
                for (Showtime showtime : screenShowtimes) {
                    AdminShowtimeResponse.ShowtimeDTO showtimeDTO = new AdminShowtimeResponse.ShowtimeDTO(showtime);
                    screenDTO.addShowtime(showtimeDTO);

                    // 마지막 상영 종료 시간을 계산 (상영 시작 시간 + 런타임 + 30분)
                    LocalDateTime showtimeEnd = showtime.getStartedAt().toLocalDateTime()
                            .plusMinutes(showtime.getMovie().getRuntime() + 30);

                    // selectedDate의 다음날 자정 기준으로 비교
                    LocalDateTime midnight = selectedDate.plusDays(1).atTime(0, 0);  // 다음날 자정

                    // 자정 기준 검증
                    if (showtimeEnd.isBefore(midnight)) {
                        screenDTO.setCanAddShowtime("true");
                        screenDTO.setNextAvailableTime(showtimeEnd);
                    } else {
                        screenDTO.setCanAddShowtime(null);
                    }
                }
            } else {
                // 상영 시간이 없을 경우
                LocalDate previousDate = selectedDate.minusDays(1);

                System.out.println("상영시간이 없을경우");
                List<Showtime> previousDayShowtimes = showtimeRepository.findByScreenIdsAndShowDate(Collections.singletonList(screenDTO.getScreenId()), previousDate);

                if (previousDayShowtimes.isEmpty()) {
                    // 전날에도 상영 시간이 없는 경우
                    screenDTO.setNextAvailableTime(selectedDate.atStartOfDay()); // 0시로 설정
                    screenDTO.setCanAddShowtime("true");
                } else {
                    // 전날 상영 시간이 있는 경우
                    Showtime lastShowtime = previousDayShowtimes.get(previousDayShowtimes.size() - 1);
                    LocalDateTime previousEndTime = lastShowtime.getStartedAt().toLocalDateTime()
                            .plusMinutes(lastShowtime.getMovie().getRuntime() + 30);

                    if (previousEndTime.isBefore(selectedDate.atStartOfDay())) {
                        screenDTO.setNextAvailableTime(selectedDate.atStartOfDay()); // 0시로 설정
                    } else {
                        screenDTO.setNextAvailableTime(previousEndTime);
                    }
                    screenDTO.setCanAddShowtime("true");
                }
            }
        }

        // 최종적으로 CinemaScheduleWithMoviesDTO 반환
        return new AdminShowtimeResponse.CinemaScheduleWithMoviesDTO(cinemaWithScreensDTO, movieDTOList);
    }

리포지토리 테스트

  @Test
    public void findScreensWithShowtimesByIdsAndDate_test(){
        Long cinemaId = 1L;
        Cinema cinemas = cinemaRepository.mFindByIdWithScreen(cinemaId);
        List<Long> screenIds = new ArrayList<>();;
        for (Screen screen : cinemas.getScreens()) {
            screenIds.add(screen.getId());
            System.out.println(screen.getId());

        }
        ;
        LocalDate date12 = LocalDate.of(2024, 9, 12); // 2024년 9월 12일
        LocalDate date13 = LocalDate.of(2024, 9, 13); // 2024년 9월 13일

        List<Screen> screens1 =screenRepository.findScreensWithShowtimesByIdsAndDate(screenIds,date12);
        System.out.println("--------------------");
        System.out.println("12일");
        for (Screen screen : screens1) {
            System.out.println(screen.getName());

            for (Showtime showtime : screen.getShowtimes()){
                System.out.println(showtime.getStartedAt());
            }
        }

        System.out.println("33333333333333333333");
        System.out.println("13일");
        List<Screen> screens2 =screenRepository.findScreensWithShowtimesByIdsAndDate(screenIds,date13);
        for (Screen screen : screens2) {
            System.out.println(screen.getName());
            for (Showtime showtime : screen.getShowtimes()){
                System.out.println(showtime.getStartedAt());
            }
        }

    }




    @Test
    public void admin_mFindAllwithScreenByIds(){
        Long cinemaId = 1L;
        Cinema cinemas = cinemaRepository.mFindByIdWithScreen(cinemaId);
        List<Long> screenIds = new ArrayList<>();;
        for (Screen screen : cinemas.getScreens()) {
            screenIds.add(screen.getId());

        }
        for (Long screenId : screenIds) {
            System.out.println("상영관id = " + screenId);
        }

        // 저장된 상영관 ID들을 통해 상영관과 그에 속한 showtime을 조회
        List<Screen> screensWithShowtimes = screenRepository.findScreensWithShowtimesByIds(screenIds);

        // 결과 출력 (테스트용)
        for (Screen screen : screensWithShowtimes) {
            System.out.println("상영관 id = " + screen.getId());
            for (Showtime showtime : screen.getShowtimes()) {
                System.out.println("상영시간 = " + showtime.getMovie().getRuntime());
            }
        }
    }