From 2bcdb1a80b5f20bde7a74f03e41b68f6ab43288b Mon Sep 17 00:00:00 2001 From: songfox00 Date: Thu, 12 Nov 2026 17:30:23 +0900 Subject: [PATCH 1/4] feat(ticketing): add authenticated performance seat query --- .../auth/infrastructure/SecurityConfig.java | 1 - .../application/ConcertQueryService.java | 37 ++++ .../infrastructure/LayoutSeatRepository.java | 9 +- .../infrastructure/PerformanceRepository.java | 8 +- .../ticketing/api/TicketSeatController.java | 20 ++ .../ticketing/application/TicketSeatInfo.java | 10 + .../application/TicketSeatQueryService.java | 39 ++++ .../infrastructure/TicketSeatRepository.java | 8 +- .../entity/ConcertPerformanceMappingTest.java | 14 +- .../entity/VenueLayoutMappingTest.java | 8 +- .../ticketing/TicketSeatQueryApiTest.java | 200 ++++++++++++++++++ .../entity/TicketSeatMappingTest.java | 8 +- docs/contracts/api/ticketing.md | 42 +++- docs/domains/ticketing/design.md | 8 +- docs/domains/ticketing/venue-consistency.md | 2 +- 15 files changed, 391 insertions(+), 23 deletions(-) create mode 100644 backend/src/main/java/com/restless/ticketing/application/TicketSeatInfo.java create mode 100644 backend/src/test/java/com/restless/ticketing/TicketSeatQueryApiTest.java diff --git a/backend/src/main/java/com/restless/auth/infrastructure/SecurityConfig.java b/backend/src/main/java/com/restless/auth/infrastructure/SecurityConfig.java index 4d92c88f..6b4d7d29 100644 --- a/backend/src/main/java/com/restless/auth/infrastructure/SecurityConfig.java +++ b/backend/src/main/java/com/restless/auth/infrastructure/SecurityConfig.java @@ -39,7 +39,6 @@ public class SecurityConfig implements WebMvcConfigurer { /** 로그인 없이 GET으로 볼 수 있는 경로. 팀 API 계약(docs/contracts/api) 기준. */ static final String[] PUBLIC_GET_PATHS = { "/api/concerts", "/api/concerts/**", - "/api/concert-sessions/*/seats", "/api/drops", "/api/drops/*", "/api/auctions", "/api/auctions/*", "/api/auctions/*/bids", "/api/auctions/*/result", "/api/fan-meetings/*", diff --git a/backend/src/main/java/com/restless/concert/application/ConcertQueryService.java b/backend/src/main/java/com/restless/concert/application/ConcertQueryService.java index ad2994ce..65c00fca 100644 --- a/backend/src/main/java/com/restless/concert/application/ConcertQueryService.java +++ b/backend/src/main/java/com/restless/concert/application/ConcertQueryService.java @@ -1,4 +1,41 @@ package com.restless.concert.application; +import com.restless.common.error.BusinessException; +import com.restless.common.error.ErrorCode; +import com.restless.concert.domain.Performance; +import com.restless.concert.infrastructure.LayoutSeatRepository; +import com.restless.concert.infrastructure.PerformanceRepository; +import java.math.BigDecimal; +import java.util.List; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +@Service +@RequiredArgsConstructor public class ConcertQueryService { + + private final PerformanceRepository performanceRepository; + private final LayoutSeatRepository layoutSeatRepository; + + @Transactional(readOnly = true) + public PerformanceLayout getPerformanceLayout(Long performanceId) { + Performance performance = performanceRepository.findById(performanceId) + .orElseThrow(() -> new BusinessException(ErrorCode.NOT_FOUND, "공연 회차를 찾을 수 없습니다.")); + List seats = layoutSeatRepository.findAllById_LayoutId(performance.getLayoutId()).stream() + .map(seat -> new SeatPosition(seat.getId().getVenueSeatId(), seat.getSectionLabel(), + seat.getRowLabel(), seat.getSeatNumber(), seat.getPosX(), seat.getPosY())) + .toList(); + return new PerformanceLayout(performance.getLayoutId(), seats); + } + + public record PerformanceLayout(Long layoutId, List seats) { + public PerformanceLayout { + seats = List.copyOf(seats); + } + } + + public record SeatPosition(Long venueSeatId, String sectionLabel, String rowLabel, + String seatNumber, BigDecimal posX, BigDecimal posY) { + } } diff --git a/backend/src/main/java/com/restless/concert/infrastructure/LayoutSeatRepository.java b/backend/src/main/java/com/restless/concert/infrastructure/LayoutSeatRepository.java index a34e7721..b95c6cb5 100644 --- a/backend/src/main/java/com/restless/concert/infrastructure/LayoutSeatRepository.java +++ b/backend/src/main/java/com/restless/concert/infrastructure/LayoutSeatRepository.java @@ -1,4 +1,11 @@ package com.restless.concert.infrastructure; -public interface LayoutSeatRepository { +import com.restless.concert.domain.LayoutSeat; +import com.restless.concert.domain.LayoutSeatId; +import java.util.List; +import org.springframework.data.jpa.repository.JpaRepository; + +public interface LayoutSeatRepository extends JpaRepository { + + List findAllById_LayoutId(Long layoutId); } diff --git a/backend/src/main/java/com/restless/concert/infrastructure/PerformanceRepository.java b/backend/src/main/java/com/restless/concert/infrastructure/PerformanceRepository.java index e42916f3..b6361d03 100644 --- a/backend/src/main/java/com/restless/concert/infrastructure/PerformanceRepository.java +++ b/backend/src/main/java/com/restless/concert/infrastructure/PerformanceRepository.java @@ -1,4 +1,10 @@ package com.restless.concert.infrastructure; -public interface PerformanceRepository { +import com.restless.concert.domain.Performance; +import java.util.List; +import org.springframework.data.jpa.repository.JpaRepository; + +public interface PerformanceRepository extends JpaRepository { + + List findAllByConcertIdOrderByStartsAtAsc(Long concertId); } diff --git a/backend/src/main/java/com/restless/ticketing/api/TicketSeatController.java b/backend/src/main/java/com/restless/ticketing/api/TicketSeatController.java index f4919107..30e2dcdf 100644 --- a/backend/src/main/java/com/restless/ticketing/api/TicketSeatController.java +++ b/backend/src/main/java/com/restless/ticketing/api/TicketSeatController.java @@ -1,4 +1,24 @@ package com.restless.ticketing.api; +import com.restless.ticketing.application.TicketSeatInfo; +import com.restless.ticketing.application.TicketSeatQueryService; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +@RestController +@RequestMapping("/api/performances") +@RequiredArgsConstructor public class TicketSeatController { + + private final TicketSeatQueryService ticketSeatQueryService; + + @GetMapping("/{performanceId}/seats") + public List getSeats(@PathVariable("performanceId") Long performanceId) { + return ticketSeatQueryService.getSeats(performanceId); + } } diff --git a/backend/src/main/java/com/restless/ticketing/application/TicketSeatInfo.java b/backend/src/main/java/com/restless/ticketing/application/TicketSeatInfo.java new file mode 100644 index 00000000..9140bc6f --- /dev/null +++ b/backend/src/main/java/com/restless/ticketing/application/TicketSeatInfo.java @@ -0,0 +1,10 @@ +package com.restless.ticketing.application; + +import com.restless.ticketing.domain.TicketSeatStatus; +import java.math.BigDecimal; + +/** 지정 회차의 판매 좌석과 배치 위치를 결합한 조회 결과. */ +public record TicketSeatInfo(Long seatId, Long venueSeatId, String sectionLabel, String rowLabel, + String seatNumber, BigDecimal posX, BigDecimal posY, + String grade, long price, TicketSeatStatus status) { +} diff --git a/backend/src/main/java/com/restless/ticketing/application/TicketSeatQueryService.java b/backend/src/main/java/com/restless/ticketing/application/TicketSeatQueryService.java index 0e121adf..9beae910 100644 --- a/backend/src/main/java/com/restless/ticketing/application/TicketSeatQueryService.java +++ b/backend/src/main/java/com/restless/ticketing/application/TicketSeatQueryService.java @@ -1,4 +1,43 @@ package com.restless.ticketing.application; +import com.restless.concert.application.ConcertQueryService; +import com.restless.concert.application.ConcertQueryService.PerformanceLayout; +import com.restless.concert.application.ConcertQueryService.SeatPosition; +import com.restless.ticketing.domain.TicketSeat; +import com.restless.ticketing.infrastructure.TicketSeatRepository; +import java.util.Comparator; +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +@Service +@RequiredArgsConstructor public class TicketSeatQueryService { + + private final TicketSeatRepository ticketSeatRepository; + private final ConcertQueryService concertQueryService; + + @Transactional(readOnly = true) + public List getSeats(Long performanceId) { + PerformanceLayout layout = concertQueryService.getPerformanceLayout(performanceId); + Map positions = layout.seats().stream() + .collect(Collectors.toMap(SeatPosition::venueSeatId, Function.identity())); + + return ticketSeatRepository.findAllByPerformanceId(performanceId).stream() + .sorted(Comparator.comparing(TicketSeat::getId)) + .map(seat -> { + SeatPosition position = positions.get(seat.getVenueSeatId()); + if (!layout.layoutId().equals(seat.getLayoutId()) || position == null) { + throw new IllegalStateException("회차의 판매 좌석과 배치가 일치하지 않습니다: " + seat.getId()); + } + return new TicketSeatInfo(seat.getId(), seat.getVenueSeatId(), position.sectionLabel(), + position.rowLabel(), position.seatNumber(), position.posX(), position.posY(), + seat.getGrade(), seat.getPrice(), seat.getStatus()); + }) + .toList(); + } } diff --git a/backend/src/main/java/com/restless/ticketing/infrastructure/TicketSeatRepository.java b/backend/src/main/java/com/restless/ticketing/infrastructure/TicketSeatRepository.java index 626fab0c..02f5e884 100644 --- a/backend/src/main/java/com/restless/ticketing/infrastructure/TicketSeatRepository.java +++ b/backend/src/main/java/com/restless/ticketing/infrastructure/TicketSeatRepository.java @@ -1,4 +1,10 @@ package com.restless.ticketing.infrastructure; -public interface TicketSeatRepository { +import com.restless.ticketing.domain.TicketSeat; +import java.util.List; +import org.springframework.data.jpa.repository.JpaRepository; + +public interface TicketSeatRepository extends JpaRepository { + + List findAllByPerformanceId(Long performanceId); } diff --git a/backend/src/test/java/com/restless/concert/entity/ConcertPerformanceMappingTest.java b/backend/src/test/java/com/restless/concert/entity/ConcertPerformanceMappingTest.java index c7c32ff3..94479e5c 100644 --- a/backend/src/test/java/com/restless/concert/entity/ConcertPerformanceMappingTest.java +++ b/backend/src/test/java/com/restless/concert/entity/ConcertPerformanceMappingTest.java @@ -1,6 +1,7 @@ package com.restless.concert.entity; import com.restless.TestcontainersConfiguration; +import com.restless.concert.infrastructure.PerformanceRepository; import com.restless.concert.domain.Concert; import com.restless.concert.domain.Performance; import com.restless.concert.domain.Venue; @@ -42,6 +43,9 @@ class ConcertPerformanceMappingTest { @Autowired private EntityManager entityManager; + @Autowired + private PerformanceRepository performanceRepository; + @DisplayName("같은 공연장·배치를 사용하는 공연의 여러 회차와 UTC 시각을 저장하고 조회한다") @Test void reloadsConcertAndSeparatePerformancesSharingVenueAndLayout() { @@ -52,8 +56,12 @@ void reloadsConcertAndSeparatePerformancesSharingVenueAndLayout() { STARTS_AT, OPENS_AT, CLOSES_AT, 4, "SCHEDULED"); Performance second = Performance.create(concert.getId(), venue.getId(), layout.getId(), STARTS_AT.plusSeconds(86400), OPENS_AT, CLOSES_AT.plusSeconds(86400), 2, "SCHEDULED"); - entityManager.persist(first); entityManager.persist(second); + entityManager.persist(first); + Concert otherConcert = Concert.create(venue.getId(), concert.getSellerId(), "Other", "SCHEDULED", CREATED_AT); + entityManager.persist(otherConcert); + entityManager.persist(Performance.create(otherConcert.getId(), venue.getId(), layout.getId(), + STARTS_AT, OPENS_AT, CLOSES_AT, 4, "SCHEDULED")); entityManager.flush(); entityManager.clear(); @@ -76,9 +84,7 @@ void reloadsConcertAndSeparatePerformancesSharingVenueAndLayout() { assertThat(performance.getMaxTicketsPerUser()).isEqualTo(4); assertThat(performance.getStatus()).isEqualTo("SCHEDULED"); - var performances = entityManager.createQuery(""" - select s from Performance s where s.concertId = :concertId order by s.startsAt - """, Performance.class).setParameter("concertId", concert.getId()).getResultList(); + var performances = performanceRepository.findAllByConcertIdOrderByStartsAtAsc(concert.getId()); assertThat(performances).extracting(Performance::getId).containsExactly(first.getId(), second.getId()); assertThat(performances.get(1).getStartsAt()).isEqualTo(STARTS_AT.plusSeconds(86400)); assertThat(performances.get(1).getMaxTicketsPerUser()).isEqualTo(2); diff --git a/backend/src/test/java/com/restless/concert/entity/VenueLayoutMappingTest.java b/backend/src/test/java/com/restless/concert/entity/VenueLayoutMappingTest.java index 8af567a2..976da9b5 100644 --- a/backend/src/test/java/com/restless/concert/entity/VenueLayoutMappingTest.java +++ b/backend/src/test/java/com/restless/concert/entity/VenueLayoutMappingTest.java @@ -1,6 +1,7 @@ package com.restless.concert.entity; import com.restless.TestcontainersConfiguration; +import com.restless.concert.infrastructure.LayoutSeatRepository; import com.restless.concert.domain.*; import jakarta.persistence.EntityManager; import jakarta.persistence.PersistenceException; @@ -33,6 +34,9 @@ class VenueLayoutMappingTest { @Autowired private EntityManager entityManager; + @Autowired + private LayoutSeatRepository layoutSeatRepository; + @DisplayName("배치 버전별로 같은 실제 좌석을 재사용하고 복합 키·좌표·판매 여부를 조회한다") @Test void reloadsLayoutAndCompositeSeatKeysAcrossVersions() { @@ -74,9 +78,7 @@ void reloadsLayoutAndCompositeSeatKeysAcrossVersions() { assertThat(other.getId()).isNotEqualTo(firstId); assertThat(other.getSectionLabel()).isEqualTo("Blocked A"); assertThat(other.isSellable()).isFalse(); - var seats = entityManager.createQuery(""" - select s from LayoutSeat s where s.id.layoutId = :layoutId - """, LayoutSeat.class).setParameter("layoutId", first.getId()).getResultList(); + var seats = layoutSeatRepository.findAllById_LayoutId(first.getId()); assertThat(seats).extracting(LayoutSeat::getId).containsExactly(firstId); } diff --git a/backend/src/test/java/com/restless/ticketing/TicketSeatQueryApiTest.java b/backend/src/test/java/com/restless/ticketing/TicketSeatQueryApiTest.java new file mode 100644 index 00000000..0e1444bb --- /dev/null +++ b/backend/src/test/java/com/restless/ticketing/TicketSeatQueryApiTest.java @@ -0,0 +1,200 @@ +package com.restless.ticketing; + +import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.jwt; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +import com.restless.TestcontainersConfiguration; +import com.restless.concert.domain.Concert; +import com.restless.concert.domain.LayoutSeat; +import com.restless.concert.domain.LayoutSeatId; +import com.restless.concert.domain.Performance; +import com.restless.concert.domain.Venue; +import com.restless.concert.domain.VenueLayout; +import com.restless.concert.domain.VenueSeat; +import com.restless.concert.domain.VenueSection; +import com.restless.member.domain.Member; +import com.restless.ticketing.domain.SeatHold; +import com.restless.ticketing.domain.TicketReservation; +import com.restless.ticketing.domain.TicketSeat; +import jakarta.persistence.EntityManager; +import java.math.BigDecimal; +import java.time.Instant; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc; +import org.springframework.context.annotation.Import; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.transaction.annotation.Transactional; + +@DisplayName("회차별 좌석 조회 API") +@SpringBootTest(properties = { + "spring.jpa.hibernate.ddl-auto=validate", + "spring.docker.compose.enabled=false" +}) +@AutoConfigureMockMvc +@Import(TestcontainersConfiguration.class) +@Transactional +class TicketSeatQueryApiTest { + + private static final Instant NOW = Instant.parse("2026-11-12T01:00:00Z"); + private static final String PATH = "/api/performances/{performanceId}/seats"; + + @Autowired + private MockMvc mockMvc; + + @Autowired + private EntityManager entityManager; + + private Long userId; + private Long venueId; + private Long sectionId; + private Long concertId; + private Long layoutId; + private Long performanceId; + + @BeforeEach + void setUp() { + Member host = Member.register("seat-query@example.com", "test-hash", "Host", NOW); + entityManager.persist(host); + userId = host.getId(); + Venue venue = Venue.create("Hall", "Seoul", "Asia/Seoul", "ACTIVE", NOW); + entityManager.persist(venue); + venueId = venue.getId(); + VenueSection section = VenueSection.create(venueId, "A", "Section A", "1F", "ACTIVE"); + entityManager.persist(section); + sectionId = section.getId(); + VenueLayout layout = VenueLayout.create(venueId, "BASIC", 1, "Basic", "PUBLISHED", NOW); + entityManager.persist(layout); + layoutId = layout.getId(); + Concert concert = Concert.create(venueId, userId, "Concert", "SCHEDULED", NOW); + entityManager.persist(concert); + concertId = concert.getId(); + performanceId = persistPerformance(layoutId); + } + + @Test + @DisplayName("로그인한 사용자는 지정 회차의 배치 위치·가격·현재 상태만 좌석 ID 순으로 조회한다") + void returnsOnlyRequestedPerformanceSeatsWithTheirLayoutAndCurrentState() throws Exception { + Long firstPhysicalId = persistPhysicalSeat("1"); + Long secondPhysicalId = persistPhysicalSeat("2"); + Long unsoldPhysicalId = persistPhysicalSeat("3"); + includeInLayout(layoutId, firstPhysicalId, "A", "10.25"); + includeInLayout(layoutId, secondPhysicalId, "B", "20.50"); + includeInLayout(layoutId, unsoldPhysicalId, "C", "30.00"); + + // 같은 물리 좌석도 배치에 따라 표시명과 위치가 다를 수 있다. + VenueLayout otherLayout = VenueLayout.create(venueId, "BASIC", 2, "Other", "PUBLISHED", NOW); + entityManager.persist(otherLayout); + includeInLayout(otherLayout.getId(), firstPhysicalId, "OTHER", "999.00"); + Long otherPerformanceId = persistPerformance(otherLayout.getId()); + persistTicketSeat(otherPerformanceId, otherLayout.getId(), firstPhysicalId, "OTHER", 1); + Long sharedLayoutPerformanceId = persistPerformance(layoutId); + persistTicketSeat(sharedLayoutPerformanceId, layoutId, firstPhysicalId, "OTHER", 2); + + // 물리 좌석 순서와 판매 좌석 ID 순서를 다르게 하여 위치 결합 키를 검증한다. + TicketSeat first = persistTicketSeat(performanceId, layoutId, secondPhysicalId, "R", 0); + TicketSeat second = persistTicketSeat(performanceId, layoutId, firstPhysicalId, "VIP", 3_000_000_000L); + TicketReservation reservation = TicketReservation.createHeld(userId, performanceId, "seat-query", + new byte[32], NOW.plusSeconds(300), NOW); + entityManager.persist(reservation); + SeatHold hold = SeatHold.createHeld(reservation.getId(), performanceId, second.getId(), + second.getPrice(), NOW.plusSeconds(300), NOW); + entityManager.persist(hold); + entityManager.flush(); + // 실제 선점 기능 대신 기존 소유권 제약을 만족하는 조회용 상태를 준비한다. + entityManager.createNativeQuery(""" + UPDATE performance_seats SET status = 'HELD', current_hold_id = :holdId WHERE id = :seatId + """).setParameter("holdId", hold.getId()).setParameter("seatId", second.getId()).executeUpdate(); + entityManager.clear(); + + mockMvc.perform(get(PATH, performanceId).with(jwt())) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.length()").value(2)) + .andExpect(jsonPath("$[0].seatId").value(first.getId())) + .andExpect(jsonPath("$[0].venueSeatId").value(secondPhysicalId)) + .andExpect(jsonPath("$[0].sectionLabel").value("B")) + .andExpect(jsonPath("$[0].rowLabel").value("1")) + .andExpect(jsonPath("$[0].seatNumber").value("2")) + .andExpect(jsonPath("$[0].posX").value(20.50)) + .andExpect(jsonPath("$[0].posY").value(-5.25)) + .andExpect(jsonPath("$[0].grade").value("R")) + .andExpect(jsonPath("$[0].price").value(0)) + .andExpect(jsonPath("$[0].status").value("AVAILABLE")) + .andExpect(jsonPath("$[1].seatId").value(second.getId())) + .andExpect(jsonPath("$[1].venueSeatId").value(firstPhysicalId)) + .andExpect(jsonPath("$[1].sectionLabel").value("A")) + .andExpect(jsonPath("$[1].posX").value(10.25)) + .andExpect(jsonPath("$[1].grade").value("VIP")) + .andExpect(jsonPath("$[1].price").value(3_000_000_000L)) + .andExpect(jsonPath("$[1].status").value("HELD")) + .andExpect(jsonPath("$[1].currentHoldId").doesNotExist()) + .andExpect(jsonPath("$[1].userId").doesNotExist()); + } + + @Test + @DisplayName("회차가 존재하지만 판매 좌석이 없으면 빈 배열을 반환한다") + void returnsEmptyArrayForPerformanceWithoutSaleSeats() throws Exception { + includeInLayout(layoutId, persistPhysicalSeat("1"), "A", "10.25"); + entityManager.flush(); + entityManager.clear(); + + mockMvc.perform(get(PATH, performanceId).with(jwt())) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.length()").value(0)); + } + + @Test + @DisplayName("없는 회차는 빈 배열 대신 404 NOT_FOUND를 반환한다") + void rejectsMissingPerformance() throws Exception { + mockMvc.perform(get(PATH, -1).with(jwt())) + .andExpect(status().isNotFound()) + .andExpect(jsonPath("$.code").value("NOT_FOUND")); + } + + @Test + @DisplayName("숫자로 변환할 수 없는 회차 ID는 400 INVALID_REQUEST를 반환한다") + void rejectsNonNumericPerformanceId() throws Exception { + mockMvc.perform(get(PATH, "invalid").with(jwt())) + .andExpect(status().isBadRequest()) + .andExpect(jsonPath("$.code").value("INVALID_REQUEST")); + } + + @Test + @DisplayName("로그인하지 않으면 좌석 조회는 401 UNAUTHORIZED를 반환한다") + void rejectsUnauthenticatedSeatQuery() throws Exception { + mockMvc.perform(get(PATH, performanceId)) + .andExpect(status().isUnauthorized()) + .andExpect(jsonPath("$.code").value("UNAUTHORIZED")); + } + + private Long persistPerformance(Long targetLayoutId) { + Performance performance = Performance.create(concertId, venueId, targetLayoutId, + NOW.plusSeconds(14400), NOW.plusSeconds(3600), NOW.plusSeconds(10800), 4, "SCHEDULED"); + entityManager.persist(performance); + return performance.getId(); + } + + private Long persistPhysicalSeat(String number) { + VenueSeat seat = VenueSeat.create(venueId, sectionId, "1", number, false, "ACTIVE"); + entityManager.persist(seat); + return seat.getId(); + } + + private void includeInLayout(Long targetLayoutId, Long physicalId, String label, String x) { + VenueSeat physical = entityManager.find(VenueSeat.class, physicalId); + entityManager.persist(LayoutSeat.create(new LayoutSeatId(targetLayoutId, physicalId), venueId, + label, "1", physical.getSeatNumber(), new BigDecimal(x), new BigDecimal("-5.25"), true)); + } + + private TicketSeat persistTicketSeat(Long targetPerformanceId, Long targetLayoutId, Long physicalId, + String grade, long price) { + TicketSeat seat = TicketSeat.createAvailable(targetPerformanceId, targetLayoutId, physicalId, grade, price); + entityManager.persist(seat); + return seat; + } +} diff --git a/backend/src/test/java/com/restless/ticketing/entity/TicketSeatMappingTest.java b/backend/src/test/java/com/restless/ticketing/entity/TicketSeatMappingTest.java index b718b694..460468a0 100644 --- a/backend/src/test/java/com/restless/ticketing/entity/TicketSeatMappingTest.java +++ b/backend/src/test/java/com/restless/ticketing/entity/TicketSeatMappingTest.java @@ -1,6 +1,7 @@ package com.restless.ticketing.entity; import com.restless.TestcontainersConfiguration; +import com.restless.ticketing.infrastructure.TicketSeatRepository; import com.restless.concert.domain.*; import com.restless.member.domain.Member; import com.restless.ticketing.domain.SeatHold; @@ -39,6 +40,9 @@ class TicketSeatMappingTest { @Autowired private EntityManager entityManager; + @Autowired + private TicketSeatRepository ticketSeatRepository; + private Long userId; private Long venueId; private Long sectionId; @@ -92,9 +96,7 @@ void reloadsPerformancePricesAndCurrentOwnerStates() { assertThat(other.getGrade()).isEqualTo("R"); assertThat(other.getPrice()).isZero(); assertThat(other.getStatus()).isEqualTo(TicketSeatStatus.AVAILABLE); - var seats = entityManager.createQuery(""" - select s from TicketSeat s where s.performanceId = :performanceId - """, TicketSeat.class).setParameter("performanceId", performanceId).getResultList(); + var seats = ticketSeatRepository.findAllByPerformanceId(performanceId); assertThat(seats).extracting(TicketSeat::getId).containsExactly(first.getId()); Long holdId = createHoldFixture(first.getId()); diff --git a/docs/contracts/api/ticketing.md b/docs/contracts/api/ticketing.md index 342877d6..28e22895 100644 --- a/docs/contracts/api/ticketing.md +++ b/docs/contracts/api/ticketing.md @@ -8,7 +8,7 @@ | Method | Endpoint | 기능 | |---|---|---| | GET | `/api/concerts/{concertId}/sessions` | 공연 회차 목록 | -| GET | `/api/concert-sessions/{sessionId}/seats` | 회차별 좌석 상태 (3초 폴링) | +| GET | `/api/performances/{performanceId}/seats` | 회차별 좌석 상태 (3초 폴링) | | POST | `/api/ticket-reservations` | 좌석 선점 (`Idempotency-Key`) | | GET | `/api/ticket-reservations/{reservationId}` | 예약 상세 | | GET | `/api/ticket-reservations/active` | 활성 예약 조회, 복구 | @@ -17,6 +17,38 @@ | POST | `/api/ticket-reservations/{reservationId}/cancellations` | 환불 요청 | | GET | `/api/ticket-reservations/{reservationId}/cancellations` | 환불 상태 조회 | +## 회차별 좌석 조회 + +`GET /api/performances/{performanceId}/seats`는 로그인이 필수이며, +`Authorization: Bearer ` 헤더로 인증한다. 비로그인 요청은 `401 UNAUTHORIZED`로 응답한다. +공연 상세·회차 목록은 비로그인 조회를 허용하고, 회차를 클릭해 좌석 선택에 진입할 때부터 로그인을 요구한다. +프론트엔드는 로그인 완료 후 선택한 회차의 좌석 화면으로 복귀하도록 연결한다 (프론트엔드 구현은 별도). +`performanceId`를 내부 Performance ID로 전달하며, 해당 회차의 판매 좌석만 좌석 ID 오름차순으로 반환한다. + +성공 (`200 OK`): + +```json +[ + { + "seatId": 10, + "venueSeatId": 101, + "sectionLabel": "A", + "rowLabel": "1", + "seatNumber": "1", + "posX": 10.00, + "posY": 20.00, + "grade": "VIP", + "price": 150000, + "status": "AVAILABLE" + } +] +``` + +`seatId`는 회차별 판매 좌석 ID이며 `venueSeatId`는 물리 좌석 ID다. +상태는 `AVAILABLE`, `HELD`, `SOLD` 중 하나다. 현재 상태를 조회하며 만료 처리나 선점은 수행하지 않는다. +회차에 판매 좌석이 없으면 빈 배열을 반환한다. 없는 회차는 `404 NOT_FOUND`, +Long으로 변환할 수 없는 performanceId는 `400 INVALID_REQUEST`로 응답한다. + ## 좌석 선점 요청: @@ -26,7 +58,7 @@ POST /api/ticket-reservations Idempotency-Key: 7f83a2b1-... Content-Type: application/json -{ "sessionId": 100, "seatIds": [10, 11] } +{ "performanceId": 100, "seatIds": [10, 11] } ``` 성공: @@ -94,5 +126,7 @@ checkout은 예약 잠금·기존 주문 참조로 중복 생성과 기한 연 ## 내부 회차 명칭 Java 엔티티·Repository는 Performance/PerformanceRepository, DB 테이블은 performances로 통일한다. -API 호환성을 위해 /api/concert-sessions 경로와 기존 sessionId 요청 필드는 그대로 유지한다. -API의 sessionId는 내부 Performance의 ID로 해석한다. +좌석 조회 API는 /api/performances/{performanceId}/seats로 통일하며 performanceId는 Performance의 ID다. +좌석 선점 요청 본문도 performanceId를 사용하며, 내부 Performance의 ID로 해석한다. +기존 concert-sessions 조회 경로와 선점 요청의 sessionId 필드는 제공하지 않는다. +선점 요청 DTO와 API 처리는 아직 구현 전이며, 구현 시 위 계약을 따른다. diff --git a/docs/domains/ticketing/design.md b/docs/domains/ticketing/design.md index 67382d60..25724c25 100644 --- a/docs/domains/ticketing/design.md +++ b/docs/domains/ticketing/design.md @@ -261,7 +261,7 @@ DB에서는 회차별 좌석 행을 잠근 뒤 현재 소유권을 검사·변 | API | 기능 | | -------------------------------------------------- | ----- | -| `GET /api/concert-sessions/{id}/seats` | 좌석 조회 | +| `GET /api/performances/{performanceId}/seats` | 좌석 조회 (로그인 필수) | | `POST /api/ticket-reservations` | 좌석 선점 | | `GET /api/ticket-reservations/active` | 예약 복구 | | `DELETE /api/ticket-reservations/{id}` | 선점 취소 | @@ -493,7 +493,7 @@ flowchart LR | Method | Endpoint | 설명 | | ------ | --------------------------------------------- | --------- | | GET | `/api/concerts/{id}/sessions` | 공연 회차 목록 | - | GET | `/api/concert-sessions/{id}/seats` | 회차별 좌석 상태 | + | GET | `/api/performances/{performanceId}/seats` | 회차별 좌석 상태 (로그인 필수) | | POST | `/api/ticket-reservations` | 좌석 선점 | | GET | `/api/ticket-reservations/{id}` | 예약 상세 조회 | | GET | `/api/ticket-reservations/active` | 활성 예약 조회 | @@ -512,7 +512,7 @@ flowchart LR ``` ``` { - "sessionId": 100, + "performanceId": 100, "seatIds": [10, 11] } @@ -580,4 +580,4 @@ flowchart LR - 이벤트 중복 수신 시에도 동일한 결과를 보장한다(멱등성). - 예약·좌석·구매 수량은 동일 트랜잭션에서 변경한다. - 핵심 결과 반영은 Coordinator의 직접 호출로 처리하고, 후속 이벤트는 ADR-0001을 따른다. - - 결제 결과 처리는 P0, 티켓팅 발행 이벤트는 실제 구독 기능에 따라 P1 또는 선택 사항으로 구현한다. \ No newline at end of file + - 결제 결과 처리는 P0, 티켓팅 발행 이벤트는 실제 구독 기능에 따라 P1 또는 선택 사항으로 구현한다. diff --git a/docs/domains/ticketing/venue-consistency.md b/docs/domains/ticketing/venue-consistency.md index ea8248d4..4437a496 100644 --- a/docs/domains/ticketing/venue-consistency.md +++ b/docs/domains/ticketing/venue-consistency.md @@ -134,4 +134,4 @@ WHERE c.layout_id <> p.layout_id; - ./gradlew clean test --tests 'com.restless.concert.*' 실행으로 공연 도메인 테스트 총 17개가 통과했다. 최초 실행의 클래스 로딩 오류는 빌드 산출물 초기화 후 재실행에서 해소됐다. - 주최자 권한, 회차 등록 API, 오픈 후 배치 변경 제한의 서비스 처리, 판매 좌석·예매 로직은 이번 매핑 구현 범위가 아니다. -회차 내부 명칭은 Performance/PerformanceRepository로 통일하고 테스트도 ConcertPerformanceMappingTest로 변경했다. DB performances 및 API /api/concert-sessions와 sessionId는 유지한다. 이름 변경 후 ./gradlew build 실행으로 전체 테스트 161개가 통과했다. +회차 내부 명칭은 Performance/PerformanceRepository로 통일하고 테스트도 ConcertPerformanceMappingTest로 변경했다. DB performances는 유지한다. 좌석 조회 API는 후속 결정에 따라 /api/performances/{performanceId}/seats로 통일했다. 선점 요청 본문의 회차 식별자도 performanceId로 통일한다. 선점 요청 DTO와 API 처리는 아직 구현 전이다. 내부 이름 변경 당시 ./gradlew build 실행으로 전체 테스트 161개가 통과했으며, 후속 API 명명 변경에 대한 테스트는 아직 실행하지 않았다. From db62b2f9822517346e54a62ccfe092cf6f2907da Mon Sep 17 00:00:00 2001 From: songfox00 Date: Thu, 12 Nov 2026 22:45:32 +0900 Subject: [PATCH 2/4] feat(ticketing): implement seat holds and expiration --- .../com/restless/common/error/ErrorCode.java | 13 +- .../application/ConcertQueryService.java | 23 ++ .../api/TicketReservationController.java | 27 ++ .../api/dto/TicketReservationRequest.java | 12 + .../SeatHoldExpirationScheduler.java | 30 ++ .../application/TicketReservationInfo.java | 12 + .../application/TicketReservationService.java | 308 +++++++++++++++ .../restless/ticketing/domain/SeatHold.java | 8 + .../ticketing/domain/TicketPurchaseLimit.java | 14 + .../ticketing/domain/TicketReservation.java | 11 + .../restless/ticketing/domain/TicketSeat.java | 16 + .../infrastructure/SeatHoldRepository.java | 8 +- .../TicketPurchaseLimitRepository.java | 11 +- .../TicketReservationRepository.java | 46 ++- .../infrastructure/TicketSeatRepository.java | 12 +- .../TicketReservationServiceTest.java | 358 ++++++++++++++++++ docs/contracts/api/ticketing.md | 36 +- docs/domains/ticketing/expiration.md | 6 +- docs/domains/ticketing/idempotency.md | 13 +- docs/domains/ticketing/purchase-limit.md | 2 +- docs/domains/ticketing/seat-ownership.md | 7 + docs/domains/ticketing/venue-consistency.md | 2 +- 22 files changed, 959 insertions(+), 16 deletions(-) create mode 100644 backend/src/main/java/com/restless/ticketing/api/dto/TicketReservationRequest.java create mode 100644 backend/src/main/java/com/restless/ticketing/application/TicketReservationInfo.java create mode 100644 backend/src/test/java/com/restless/ticketing/application/TicketReservationServiceTest.java diff --git a/backend/src/main/java/com/restless/common/error/ErrorCode.java b/backend/src/main/java/com/restless/common/error/ErrorCode.java index d58e916e..ffd6db23 100644 --- a/backend/src/main/java/com/restless/common/error/ErrorCode.java +++ b/backend/src/main/java/com/restless/common/error/ErrorCode.java @@ -5,7 +5,7 @@ /** * 오류 코드. 응답의 {@code code}는 상수 이름이다. - * 지금은 공통 코드와 인증에 필요한 코드만 있다. 도메인 코드는 `도메인_상황` 이름으로 추가한다. + * 공통·인증·회원·티켓팅에서 사용하는 오류를 정의한다. */ @Getter public enum ErrorCode { @@ -26,7 +26,16 @@ public enum ErrorCode { DUPLICATE_EMAIL(HttpStatus.CONFLICT, "이미 가입된 이메일입니다."), MEMBER_NOT_FOUND(HttpStatus.NOT_FOUND, "회원을 찾을 수 없습니다."), MEMBER_PASSWORD_MISMATCH(HttpStatus.BAD_REQUEST, "비밀번호가 올바르지 않습니다."), - MEMBER_HAS_ACTIVE_PARTICIPATION(HttpStatus.CONFLICT, "진행 중인 주문이나 참여가 있어 탈퇴할 수 없습니다."); + MEMBER_HAS_ACTIVE_PARTICIPATION(HttpStatus.CONFLICT, "진행 중인 주문이나 참여가 있어 탈퇴할 수 없습니다."), + + // 티켓팅 + SEAT_UNAVAILABLE(HttpStatus.CONFLICT, "선점할 수 없는 좌석이 포함되어 있습니다."), + ACTIVE_RESERVATION_EXISTS(HttpStatus.CONFLICT, "진행 중인 예약이 있습니다."), + TICKET_LIMIT_EXCEEDED(HttpStatus.CONFLICT, "회차별 구매 한도를 초과했습니다."), + BOOKING_NOT_OPEN(HttpStatus.CONFLICT, "예매 시작 전입니다."), + BOOKING_CLOSED(HttpStatus.CONFLICT, "예매가 마감되었습니다."), + IDEMPOTENCY_KEY_CONFLICT(HttpStatus.CONFLICT, "같은 요청 키를 다른 요청에 사용할 수 없습니다."), + SEAT_LOCK_TIMEOUT(HttpStatus.CONFLICT, "좌석 처리 경합이 발생했습니다. 같은 요청 키로 재시도해 주세요."); private final HttpStatus httpStatus; private final String message; diff --git a/backend/src/main/java/com/restless/concert/application/ConcertQueryService.java b/backend/src/main/java/com/restless/concert/application/ConcertQueryService.java index 65c00fca..7edb8205 100644 --- a/backend/src/main/java/com/restless/concert/application/ConcertQueryService.java +++ b/backend/src/main/java/com/restless/concert/application/ConcertQueryService.java @@ -6,7 +6,10 @@ import com.restless.concert.infrastructure.LayoutSeatRepository; import com.restless.concert.infrastructure.PerformanceRepository; import java.math.BigDecimal; +import java.time.Instant; import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; import lombok.RequiredArgsConstructor; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @@ -38,4 +41,24 @@ public record PerformanceLayout(Long layoutId, List seats) { public record SeatPosition(Long venueSeatId, String sectionLabel, String rowLabel, String seatNumber, BigDecimal posX, BigDecimal posY) { } + + /** 선점에 필요한 회차 정책과 판매 가능한 배치 좌석만 제공한다. */ + @Transactional(readOnly = true) + public BookingPerformance getBookingPerformance(Long performanceId) { + Performance performance = performanceRepository.findById(performanceId) + .orElseThrow(() -> new BusinessException(ErrorCode.NOT_FOUND, "공연 회차를 찾을 수 없습니다.")); + Set sellableSeatIds = layoutSeatRepository.findAllById_LayoutId(performance.getLayoutId()).stream() + .filter(seat -> seat.isSellable()) + .map(seat -> seat.getId().getVenueSeatId()) + .collect(Collectors.toUnmodifiableSet()); + return new BookingPerformance(performance.getLayoutId(), performance.getBookingOpensAt(), + performance.getBookingClosesAt(), performance.getMaxTicketsPerUser(), sellableSeatIds); + } + + public record BookingPerformance(Long layoutId, Instant bookingOpensAt, Instant bookingClosesAt, + int maxTicketsPerUser, Set sellableSeatIds) { + public BookingPerformance { + sellableSeatIds = Set.copyOf(sellableSeatIds); + } + } } diff --git a/backend/src/main/java/com/restless/ticketing/api/TicketReservationController.java b/backend/src/main/java/com/restless/ticketing/api/TicketReservationController.java index 673b2616..b6839a51 100644 --- a/backend/src/main/java/com/restless/ticketing/api/TicketReservationController.java +++ b/backend/src/main/java/com/restless/ticketing/api/TicketReservationController.java @@ -1,4 +1,31 @@ package com.restless.ticketing.api; +import com.restless.auth.LoginMember; +import com.restless.ticketing.api.dto.TicketReservationRequest; +import com.restless.ticketing.application.TicketReservationInfo; +import com.restless.ticketing.application.TicketReservationService; +import jakarta.validation.Valid; +import lombok.RequiredArgsConstructor; +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestHeader; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.ResponseStatus; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequestMapping("/api/ticket-reservations") +@RequiredArgsConstructor public class TicketReservationController { + + private final TicketReservationService ticketReservationService; + + @PostMapping + @ResponseStatus(HttpStatus.CREATED) + public TicketReservationInfo reserve(@LoginMember Long userId, + @RequestHeader("Idempotency-Key") String requestKey, + @Valid @RequestBody TicketReservationRequest request) { + return ticketReservationService.reserve(userId, requestKey, request.performanceId(), request.seatIds()); + } } diff --git a/backend/src/main/java/com/restless/ticketing/api/dto/TicketReservationRequest.java b/backend/src/main/java/com/restless/ticketing/api/dto/TicketReservationRequest.java new file mode 100644 index 00000000..932577aa --- /dev/null +++ b/backend/src/main/java/com/restless/ticketing/api/dto/TicketReservationRequest.java @@ -0,0 +1,12 @@ +package com.restless.ticketing.api.dto; + +import jakarta.validation.constraints.NotEmpty; +import jakarta.validation.constraints.NotNull; +import jakarta.validation.constraints.Positive; + +import java.util.List; + +public record TicketReservationRequest( + @NotNull @Positive Long performanceId, + @NotEmpty List<@NotNull @Positive Long> seatIds) { +} diff --git a/backend/src/main/java/com/restless/ticketing/application/SeatHoldExpirationScheduler.java b/backend/src/main/java/com/restless/ticketing/application/SeatHoldExpirationScheduler.java index 7c52ab5e..64172036 100644 --- a/backend/src/main/java/com/restless/ticketing/application/SeatHoldExpirationScheduler.java +++ b/backend/src/main/java/com/restless/ticketing/application/SeatHoldExpirationScheduler.java @@ -1,4 +1,34 @@ package com.restless.ticketing.application; +import com.restless.ticketing.infrastructure.TicketReservationRepository; +import io.micrometer.core.instrument.MeterRegistry; +import lombok.RequiredArgsConstructor; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.scheduling.annotation.EnableScheduling; +import org.springframework.scheduling.annotation.Scheduled; +import org.springframework.stereotype.Component; + +@Component +@EnableScheduling +@RequiredArgsConstructor public class SeatHoldExpirationScheduler { + + private static final Logger log = LoggerFactory.getLogger(SeatHoldExpirationScheduler.class); + + private final TicketReservationRepository reservations; + private final TicketReservationService reservationService; + private final MeterRegistry metrics; + + @Scheduled(fixedDelayString = "${restless.ticketing.hold-expiration-delay-ms:5000}") + public void expireHolds() { + for (Long reservationId : reservations.findExpiredHoldIds()) { + try { + reservationService.expireHold(reservationId); + } catch (RuntimeException failure) { + log.error("선점 예약 만료 처리 실패: reservationId={}", reservationId, failure); + metrics.counter("ticketing.hold.expiration.failures").increment(); + } + } + } } diff --git a/backend/src/main/java/com/restless/ticketing/application/TicketReservationInfo.java b/backend/src/main/java/com/restless/ticketing/application/TicketReservationInfo.java new file mode 100644 index 00000000..19d33306 --- /dev/null +++ b/backend/src/main/java/com/restless/ticketing/application/TicketReservationInfo.java @@ -0,0 +1,12 @@ +package com.restless.ticketing.application; + +import com.restless.ticketing.domain.TicketReservationStatus; +import java.time.Instant; +import java.util.List; + +public record TicketReservationInfo(Long reservationId, TicketReservationStatus status, + List seatIds, Instant holdExpiresAt) { + public TicketReservationInfo { + seatIds = List.copyOf(seatIds); + } +} diff --git a/backend/src/main/java/com/restless/ticketing/application/TicketReservationService.java b/backend/src/main/java/com/restless/ticketing/application/TicketReservationService.java index b197528a..6ffea259 100644 --- a/backend/src/main/java/com/restless/ticketing/application/TicketReservationService.java +++ b/backend/src/main/java/com/restless/ticketing/application/TicketReservationService.java @@ -1,4 +1,312 @@ package com.restless.ticketing.application; +import com.restless.common.error.BusinessException; +import com.restless.common.error.ErrorCode; +import com.restless.concert.application.ConcertQueryService; +import com.restless.concert.application.ConcertQueryService.BookingPerformance; +import com.restless.ticketing.domain.*; +import com.restless.ticketing.infrastructure.SeatHoldRepository; +import com.restless.ticketing.infrastructure.TicketPurchaseLimitRepository; +import com.restless.ticketing.infrastructure.TicketReservationRepository; +import com.restless.ticketing.infrastructure.TicketSeatRepository; +import org.hibernate.exception.ConstraintViolationException; +import org.springframework.dao.DataIntegrityViolationException; +import org.springframework.dao.PessimisticLockingFailureException; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; +import org.springframework.transaction.PlatformTransactionManager; +import org.springframework.transaction.TransactionDefinition; +import org.springframework.transaction.support.TransactionTemplate; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.ZoneOffset; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; + +@Service public class TicketReservationService { + + private static final int MAX_ATTEMPTS = 3; + private static final long HOLD_SECONDS = 300; + private static final Set ACTIVE_STATUSES = Set.of( + TicketReservationStatus.HELD, TicketReservationStatus.PAYMENT_PENDING, TicketReservationStatus.RECONCILING); + + private final TicketSeatRepository ticketSeatRepository; + private final TicketReservationRepository ticketReservationRepository; + private final SeatHoldRepository seatHoldRepository; + private final TicketPurchaseLimitRepository ticketPurchaseLimitRepository; + private final ConcertQueryService concertQueryService; + private final JdbcTemplate jdbc; + private final TransactionTemplate transaction; + + public TicketReservationService(TicketSeatRepository ticketSeatRepository, TicketReservationRepository ticketReservationRepository, + SeatHoldRepository seatHoldRepository, TicketPurchaseLimitRepository ticketPurchaseLimitRepository, + ConcertQueryService concertQueryService, JdbcTemplate jdbc, + PlatformTransactionManager transactionManager) { + this.ticketSeatRepository = ticketSeatRepository; + this.ticketReservationRepository = ticketReservationRepository; + this.seatHoldRepository = seatHoldRepository; + this.ticketPurchaseLimitRepository = ticketPurchaseLimitRepository; + this.concertQueryService = concertQueryService; + this.jdbc = jdbc; + this.transaction = new TransactionTemplate(transactionManager); + transaction.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); + // 잠금 후 조회가 이전 일반 SELECT의 스냅샷을 재사용하지 않도록 한다. + transaction.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED); + } + + /** 재시도와 만료 정리는 원래 선점 트랜잭션이 종료된 뒤 수행한다. */ + public TicketReservationInfo reserve(Long userId, String requestKey, Long performanceId, List seatIds) { + List orderedIds = validateAndSort(userId, requestKey, performanceId, seatIds); + byte[] hash = requestHash(performanceId, orderedIds); + + for (int attempt = 0; attempt < MAX_ATTEMPTS; attempt++) { + try { + return transaction.execute(status -> reserveInTransaction(userId, requestKey, performanceId, + orderedIds, hash)); + } catch (ExpiredReservations encountered) { + // 다른 사용자의 구매 관리 행을 기존 좌석 잠금 아래에서 획득하지 않는다. + for (Long reservationId : encountered.reservationIds) { + expireHold(reservationId); + } + } catch (DataIntegrityViolationException conflict) { + if (!isCreationRace(conflict)) { + throw conflict; + } + // 실패한 트랜잭션을 롤백한 뒤 다음 시도에서 기존 행과 요청 해시를 비교한다. + } catch (PessimisticLockingFailureException conflict) { + // 교착·잠금 시간 초과는 전체 트랜잭션을 종료한 뒤 같은 입력으로만 재시도한다. + } + } + throw new BusinessException(ErrorCode.SEAT_LOCK_TIMEOUT); + } + + private TicketReservationInfo reserveInTransaction(Long userId, String requestKey, Long performanceId, + List orderedIds, byte[] hash) { + // 기존 키는 새 요청의 회차 유효성·예매 시간에 앞서 원래 예약 기준으로 비교한다. + var originalOwner = ticketReservationRepository.findOwnerByUserIdAndRequestKey(userId, requestKey); + if (originalOwner.isPresent()) { + ticketPurchaseLimitRepository.findByUserIdAndPerformanceId(userId, originalOwner.get().getPerformanceId()) + .orElseThrow(() -> new IllegalStateException("예약의 구매 관리 행이 없습니다.")); + TicketReservation original = ticketReservationRepository.findByUserIdAndRequestKey(userId, requestKey).orElseThrow(); + return replay(original, performanceId, orderedIds, hash); + } + + BookingPerformance performance = concertQueryService.getBookingPerformance(performanceId); + TicketPurchaseLimit limit = ticketPurchaseLimitRepository.findByUserIdAndPerformanceId(userId, performanceId) + .orElseGet(() -> ticketPurchaseLimitRepository.saveAndFlush(TicketPurchaseLimit.create(userId, performanceId))); + + TicketReservation existing = ticketReservationRepository.findByUserIdAndRequestKey(userId, requestKey).orElse(null); + if (existing != null) { + return replay(existing, performanceId, orderedIds, hash); + } + + List active = ticketReservationRepository.findByUserIdAndPerformanceIdAndStatusIn( + userId, performanceId, ACTIVE_STATUSES); + Instant checkedAt = databaseNow(); + Set expired = active.stream().filter(reservation -> reservation.isHoldExpired(checkedAt)) + .map(TicketReservation::getId).collect(Collectors.toSet()); + if (!expired.isEmpty()) { + throw new ExpiredReservations(expired); + } + if (!active.isEmpty()) { + throw new BusinessException(ErrorCode.ACTIVE_RESERVATION_EXISTS); + } + validateBookingTime(performance, checkedAt); + if ((long) limit.getConfirmedCount() + limit.getReservedCount() + orderedIds.size() + > performance.maxTicketsPerUser()) { + throw new BusinessException(ErrorCode.TICKET_LIMIT_EXCEEDED); + } + + List lockedSeats = lockSeats(orderedIds); + Set expiredOwners = new HashSet<>(); + + for (TicketSeat seat : lockedSeats) { + if (!performanceId.equals(seat.getPerformanceId()) + || !performance.layoutId().equals(seat.getLayoutId()) + || !performance.sellableSeatIds().contains(seat.getVenueSeatId())) { + throw new BusinessException(ErrorCode.SEAT_UNAVAILABLE); + } + + if (seat.getStatus() == TicketSeatStatus.HELD && seat.getCurrentHoldId() != null) { + SeatHold owner = seatHoldRepository.findById(seat.getCurrentHoldId()) + .orElseThrow(() -> new IllegalStateException("좌석의 현재 선점 이력이 없습니다.")); + TicketReservation ownerReservation = ticketReservationRepository.findById(owner.getReservationId()) + .orElseThrow(() -> new IllegalStateException("선점 예약이 없습니다.")); + + if (ownerReservation.isHoldExpired(databaseNow())) { + expiredOwners.add(ownerReservation.getId()); + continue; + } + } + + if (seat.getStatus() != TicketSeatStatus.AVAILABLE || seat.getCurrentHoldId() != null) { + throw new BusinessException(ErrorCode.SEAT_UNAVAILABLE); + } + } + + if (!expiredOwners.isEmpty()) { + throw new ExpiredReservations(expiredOwners); + } + + // 좌석 잠금을 기다리는 동안 예매가 마감될 수 있으므로 DB 시각을 다시 읽는다. + Instant now = databaseNow(); + validateBookingTime(performance, now); + Instant expiresAt = now.plusSeconds(HOLD_SECONDS); + TicketReservation reservation = ticketReservationRepository.saveAndFlush(TicketReservation.createHeld( + userId, performanceId, requestKey, hash, expiresAt, now)); + for (TicketSeat seat : lockedSeats) { + SeatHold hold = seatHoldRepository.saveAndFlush(SeatHold.createHeld(reservation.getId(), performanceId, + seat.getId(), seat.getPrice(), expiresAt, now)); + seat.hold(hold.getId()); + } + limit.reserve(lockedSeats.size(), performance.maxTicketsPerUser()); + return new TicketReservationInfo(reservation.getId(), reservation.getStatus(), orderedIds, expiresAt); + } + + private TicketReservationInfo replay(TicketReservation reservation, Long performanceId, + List orderedIds, byte[] hash) { + List originalHolds = seatHoldRepository.findAllByReservationIdOrderByPerformanceSeatIdAsc(reservation.getId()); + List originalIds = originalHolds.stream().map(SeatHold::getPerformanceSeatId).toList(); + byte[] storedHash = reservation.getHoldRequestHash(); + + if (storedHash == null) { + if (originalHolds.isEmpty() || originalHolds.stream() + .anyMatch(hold -> !hold.getPerformanceId().equals(reservation.getPerformanceId())) + || new HashSet<>(originalIds).size() != originalIds.size()) { + throw new IllegalStateException("과거 예약의 최초 선점 요청을 재구성할 수 없습니다."); + } + storedHash = requestHash(reservation.getPerformanceId(), originalIds); + } + + if (!performanceId.equals(reservation.getPerformanceId()) || !MessageDigest.isEqual(storedHash, hash)) { + throw new BusinessException(ErrorCode.IDEMPOTENCY_KEY_CONFLICT); + } + if (!originalIds.equals(orderedIds)) { + throw new IllegalStateException("예약의 선점 이력과 최초 요청이 일치하지 않습니다."); + } + if (reservation.isHoldExpired(databaseNow())) { + throw new ExpiredReservations(Set.of(reservation.getId())); + } + return new TicketReservationInfo(reservation.getId(), reservation.getStatus(), originalIds, + reservation.getHoldExpiresAt()); + } + + /** 결제 전 HELD만 반환한다. PAYMENT_PENDING/RECONCILING은 기한만으로 해제하지 않는다. */ + public void expireHold(Long reservationId) { + for (int attempt = 0; attempt < MAX_ATTEMPTS; attempt++) { + try { + transaction.executeWithoutResult(status -> expireInTransaction(reservationId)); + return; + } catch (PessimisticLockingFailureException conflict) { + // 새 트랜잭션에서 소유권과 기한을 다시 확인한다. + } + } + throw new BusinessException(ErrorCode.SEAT_LOCK_TIMEOUT); + } + + private void expireInTransaction(Long reservationId) { + var owner = ticketReservationRepository.findOwnerById(reservationId) + .orElseThrow(() -> new IllegalStateException("만료 대상 예약이 없습니다.")); + TicketPurchaseLimit limit = ticketPurchaseLimitRepository.findByUserIdAndPerformanceId(owner.getUserId(), owner.getPerformanceId()) + .orElseThrow(() -> new IllegalStateException("예약의 구매 관리 행이 없습니다.")); + TicketReservation reservation = ticketReservationRepository.findLockedById(reservationId).orElseThrow(); + if (!reservation.isHoldExpired(databaseNow())) { + return; + } + List originalHolds = seatHoldRepository.findAllByReservationIdOrderByPerformanceSeatIdAsc(reservationId); + if (originalHolds.isEmpty()) { + throw new IllegalStateException("반환할 선점 이력이 없습니다."); + } + List lockedSeats = lockSeats(originalHolds.stream().map(SeatHold::getPerformanceSeatId).toList()); + Instant now = databaseNow(); + for (int index = 0; index < originalHolds.size(); index++) { + SeatHold hold = originalHolds.get(index); + TicketSeat seat = lockedSeats.get(index); + if (hold.getStatus() != SeatHoldStatus.HELD + || !hold.getPerformanceId().equals(reservation.getPerformanceId()) + || !seat.getPerformanceId().equals(reservation.getPerformanceId())) { + throw new IllegalStateException("만료 예약의 선점·좌석 관계가 일치하지 않습니다."); + } + seat.release(hold.getId()); + hold.release(now); + } + limit.release(originalHolds.size()); + reservation.releaseExpiredHold(now); + } + + private List lockSeats(List orderedIds) { + List locked = new ArrayList<>(orderedIds.size()); + // ORDER BY에만 의존하지 않고 단건 잠금을 순서대로 획득한다. + for (Long id : orderedIds) { + locked.add(ticketSeatRepository.findLockedById(id).orElseThrow(() -> new BusinessException(ErrorCode.SEAT_UNAVAILABLE))); + } + return locked; + } + + private Instant databaseNow() { + return jdbc.queryForObject("SELECT UTC_TIMESTAMP(6)", LocalDateTime.class).toInstant(ZoneOffset.UTC); + } + + private void validateBookingTime(BookingPerformance performance, Instant now) { + if (now.isBefore(performance.bookingOpensAt())) { + throw new BusinessException(ErrorCode.BOOKING_NOT_OPEN); + } + if (!now.isBefore(performance.bookingClosesAt())) { + throw new BusinessException(ErrorCode.BOOKING_CLOSED); + } + } + + private List validateAndSort(Long userId, String requestKey, Long performanceId, List seatIds) { + if (userId == null || userId <= 0) { + throw new BusinessException(ErrorCode.UNAUTHORIZED); + } + if (requestKey == null || requestKey.isBlank() || requestKey.length() > 100 + || performanceId == null || performanceId <= 0 || seatIds == null || seatIds.isEmpty() + || seatIds.stream().anyMatch(id -> id == null || id <= 0) + || new HashSet<>(seatIds).size() != seatIds.size()) { + throw new BusinessException(ErrorCode.INVALID_REQUEST); + } + return seatIds.stream().sorted().toList(); + } + + private byte[] requestHash(Long performanceId, List orderedIds) { + String canonical = "v1\n" + performanceId + "\n" + orderedIds.stream() + .map(String::valueOf).collect(Collectors.joining(",")); + try { + return MessageDigest.getInstance("SHA-256").digest(canonical.getBytes(StandardCharsets.UTF_8)); + } catch (NoSuchAlgorithmException impossible) { + throw new IllegalStateException("SHA-256을 사용할 수 없습니다.", impossible); + } + } + + private boolean isCreationRace(DataIntegrityViolationException conflict) { + for (Throwable cause = conflict; cause != null; cause = cause.getCause()) { + if (cause instanceof ConstraintViolationException violation) { + String constraint = violation.getConstraintName(); + if (constraint == null) { + return false; + } + constraint = constraint.replace("`", "").replace("'", "").replace("\"", ""); + return constraint.endsWith("uk_ticket_purchase_limits_user_performance") + || constraint.endsWith("uk_ticket_reservations_user_request_key"); + } + } + return false; + } + + private static class ExpiredReservations extends RuntimeException { + private final Set reservationIds; + + private ExpiredReservations(Set reservationIds) { + this.reservationIds = Set.copyOf(reservationIds); + } + } } diff --git a/backend/src/main/java/com/restless/ticketing/domain/SeatHold.java b/backend/src/main/java/com/restless/ticketing/domain/SeatHold.java index 7d342647..75f30f14 100644 --- a/backend/src/main/java/com/restless/ticketing/domain/SeatHold.java +++ b/backend/src/main/java/com/restless/ticketing/domain/SeatHold.java @@ -71,4 +71,12 @@ public static SeatHold createHeld(Long reservationId, Long performanceId, Long p long priceAmount, Instant expiresAt, Instant now) { return new SeatHold(reservationId, performanceId, performanceSeatId, priceAmount, expiresAt, now); } + + public void release(Instant now) { + if (status != SeatHoldStatus.HELD) { + throw new IllegalStateException("반환 가능한 선점이 아닙니다."); + } + status = SeatHoldStatus.RELEASED; + releasedAt = Objects.requireNonNull(now); + } } diff --git a/backend/src/main/java/com/restless/ticketing/domain/TicketPurchaseLimit.java b/backend/src/main/java/com/restless/ticketing/domain/TicketPurchaseLimit.java index 1728d421..6d3e34ed 100644 --- a/backend/src/main/java/com/restless/ticketing/domain/TicketPurchaseLimit.java +++ b/backend/src/main/java/com/restless/ticketing/domain/TicketPurchaseLimit.java @@ -42,4 +42,18 @@ private TicketPurchaseLimit(Long userId, Long performanceId) { public static TicketPurchaseLimit create(Long userId, Long performanceId) { return new TicketPurchaseLimit(userId, performanceId); } + + public void reserve(int quantity, int maximum) { + if (quantity <= 0 || (long) confirmedCount + reservedCount + quantity > maximum) { + throw new IllegalStateException("구매 가능 수량을 초과했습니다."); + } + reservedCount = Math.addExact(reservedCount, quantity); + } + + public void release(int quantity) { + if (quantity <= 0 || reservedCount < quantity) { + throw new IllegalStateException("반환할 선점 수량이 일치하지 않습니다."); + } + reservedCount -= quantity; + } } diff --git a/backend/src/main/java/com/restless/ticketing/domain/TicketReservation.java b/backend/src/main/java/com/restless/ticketing/domain/TicketReservation.java index 0db9ab5b..da04457a 100644 --- a/backend/src/main/java/com/restless/ticketing/domain/TicketReservation.java +++ b/backend/src/main/java/com/restless/ticketing/domain/TicketReservation.java @@ -86,4 +86,15 @@ public static TicketReservation createHeld(Long userId, Long performanceId, Stri public byte[] getHoldRequestHash() { return holdRequestHash == null ? null : holdRequestHash.clone(); } + + public boolean isHoldExpired(Instant now) { + return status == TicketReservationStatus.HELD && !now.isBefore(holdExpiresAt); + } + + public void releaseExpiredHold(Instant now) { + if (!isHoldExpired(now) || orderId != null || checkoutStartedAt != null || paymentExpiresAt != null) { + throw new IllegalStateException("결제 전 만료된 선점 예약만 반환할 수 있습니다."); + } + status = TicketReservationStatus.RELEASED; + } } diff --git a/backend/src/main/java/com/restless/ticketing/domain/TicketSeat.java b/backend/src/main/java/com/restless/ticketing/domain/TicketSeat.java index 325ece2f..466e1bb9 100644 --- a/backend/src/main/java/com/restless/ticketing/domain/TicketSeat.java +++ b/backend/src/main/java/com/restless/ticketing/domain/TicketSeat.java @@ -62,4 +62,20 @@ public static TicketSeat createAvailable(Long performanceId, Long layoutId, Long String grade, long price) { return new TicketSeat(performanceId, layoutId, venueSeatId, grade, price); } + + public void hold(Long holdId) { + if (status != TicketSeatStatus.AVAILABLE || currentHoldId != null) { + throw new IllegalStateException("선점 가능한 좌석이 아닙니다."); + } + currentHoldId = Objects.requireNonNull(holdId); + status = TicketSeatStatus.HELD; + } + + public void release(Long holdId) { + if (status != TicketSeatStatus.HELD || !Objects.equals(currentHoldId, holdId)) { + throw new IllegalStateException("좌석의 현재 선점 소유자가 일치하지 않습니다."); + } + status = TicketSeatStatus.AVAILABLE; + currentHoldId = null; + } } diff --git a/backend/src/main/java/com/restless/ticketing/infrastructure/SeatHoldRepository.java b/backend/src/main/java/com/restless/ticketing/infrastructure/SeatHoldRepository.java index 1e856755..609c3163 100644 --- a/backend/src/main/java/com/restless/ticketing/infrastructure/SeatHoldRepository.java +++ b/backend/src/main/java/com/restless/ticketing/infrastructure/SeatHoldRepository.java @@ -1,4 +1,10 @@ package com.restless.ticketing.infrastructure; -public interface SeatHoldRepository { +import com.restless.ticketing.domain.SeatHold; +import java.util.List; +import org.springframework.data.jpa.repository.JpaRepository; + +public interface SeatHoldRepository extends JpaRepository { + + List findAllByReservationIdOrderByPerformanceSeatIdAsc(Long reservationId); } diff --git a/backend/src/main/java/com/restless/ticketing/infrastructure/TicketPurchaseLimitRepository.java b/backend/src/main/java/com/restless/ticketing/infrastructure/TicketPurchaseLimitRepository.java index 7edd60ba..3933f263 100644 --- a/backend/src/main/java/com/restless/ticketing/infrastructure/TicketPurchaseLimitRepository.java +++ b/backend/src/main/java/com/restless/ticketing/infrastructure/TicketPurchaseLimitRepository.java @@ -1,4 +1,13 @@ package com.restless.ticketing.infrastructure; -public interface TicketPurchaseLimitRepository { +import com.restless.ticketing.domain.TicketPurchaseLimit; +import jakarta.persistence.LockModeType; +import java.util.Optional; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Lock; + +public interface TicketPurchaseLimitRepository extends JpaRepository { + + @Lock(LockModeType.PESSIMISTIC_WRITE) + Optional findByUserIdAndPerformanceId(Long userId, Long performanceId); } diff --git a/backend/src/main/java/com/restless/ticketing/infrastructure/TicketReservationRepository.java b/backend/src/main/java/com/restless/ticketing/infrastructure/TicketReservationRepository.java index 3be2f561..e4e35a5b 100644 --- a/backend/src/main/java/com/restless/ticketing/infrastructure/TicketReservationRepository.java +++ b/backend/src/main/java/com/restless/ticketing/infrastructure/TicketReservationRepository.java @@ -1,4 +1,48 @@ package com.restless.ticketing.infrastructure; -public interface TicketReservationRepository { +import com.restless.ticketing.domain.TicketReservation; +import com.restless.ticketing.domain.TicketReservationStatus; +import jakarta.persistence.LockModeType; +import java.util.Collection; +import java.util.List; +import java.util.Optional; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Lock; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; + +public interface TicketReservationRepository extends JpaRepository { + + @Lock(LockModeType.PESSIMISTIC_WRITE) + Optional findByUserIdAndRequestKey(Long userId, String requestKey); + + @Lock(LockModeType.PESSIMISTIC_WRITE) + List findByUserIdAndPerformanceIdAndStatusIn( + Long userId, Long performanceId, Collection statuses); + + @Lock(LockModeType.PESSIMISTIC_WRITE) + @Query("select r from TicketReservation r where r.id = :id") + Optional findLockedById(@Param("id") Long id); + + @Query("select r.userId as userId, r.performanceId as performanceId from TicketReservation r where r.id = :id") + Optional findOwnerById(@Param("id") Long id); + + @Query(""" + select r.userId as userId, r.performanceId as performanceId from TicketReservation r + where r.userId = :userId and r.requestKey = :requestKey + """) + Optional findOwnerByUserIdAndRequestKey(@Param("userId") Long userId, + @Param("requestKey") String requestKey); + + @Query(value = """ + SELECT id FROM ticket_reservations + WHERE status = 'HELD' AND hold_expires_at <= UTC_TIMESTAMP(6) + ORDER BY hold_expires_at, id LIMIT 100 + """, nativeQuery = true) + List findExpiredHoldIds(); + + interface ReservationOwner { + Long getUserId(); + Long getPerformanceId(); + } } diff --git a/backend/src/main/java/com/restless/ticketing/infrastructure/TicketSeatRepository.java b/backend/src/main/java/com/restless/ticketing/infrastructure/TicketSeatRepository.java index 02f5e884..6dc587e5 100644 --- a/backend/src/main/java/com/restless/ticketing/infrastructure/TicketSeatRepository.java +++ b/backend/src/main/java/com/restless/ticketing/infrastructure/TicketSeatRepository.java @@ -1,10 +1,20 @@ package com.restless.ticketing.infrastructure; import com.restless.ticketing.domain.TicketSeat; -import java.util.List; +import jakarta.persistence.LockModeType; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Lock; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; + +import java.util.List; +import java.util.Optional; public interface TicketSeatRepository extends JpaRepository { List findAllByPerformanceId(Long performanceId); + + @Lock(LockModeType.PESSIMISTIC_WRITE) + @Query("select s from TicketSeat s where s.id = :id") + Optional findLockedById(@Param("id") Long id); } diff --git a/backend/src/test/java/com/restless/ticketing/application/TicketReservationServiceTest.java b/backend/src/test/java/com/restless/ticketing/application/TicketReservationServiceTest.java new file mode 100644 index 00000000..b1869745 --- /dev/null +++ b/backend/src/test/java/com/restless/ticketing/application/TicketReservationServiceTest.java @@ -0,0 +1,358 @@ +package com.restless.ticketing.application; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import com.restless.TestcontainersConfiguration; +import com.restless.common.error.BusinessException; +import com.restless.common.error.ErrorCode; +import com.restless.concert.domain.Concert; +import com.restless.concert.domain.LayoutSeat; +import com.restless.concert.domain.LayoutSeatId; +import com.restless.concert.domain.Performance; +import com.restless.concert.domain.Venue; +import com.restless.concert.domain.VenueLayout; +import com.restless.concert.domain.VenueSeat; +import com.restless.concert.domain.VenueSection; +import com.restless.member.domain.Member; +import com.restless.ticketing.domain.TicketReservationStatus; +import com.restless.ticketing.domain.TicketSeat; +import jakarta.persistence.EntityManager; +import java.math.BigDecimal; +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.ZoneOffset; +import java.util.List; +import java.util.UUID; +import java.util.concurrent.Callable; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import org.junit.jupiter.params.provider.ValueSource; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.context.annotation.Import; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.test.context.bean.override.mockito.MockitoBean; +import org.springframework.transaction.PlatformTransactionManager; +import org.springframework.transaction.support.TransactionTemplate; + +@DisplayName("좌석 선점 서비스 통합 테스트") +@SpringBootTest(properties = { + "spring.jpa.hibernate.ddl-auto=validate", + "spring.docker.compose.enabled=false" +}) +@Import(TestcontainersConfiguration.class) +class TicketReservationServiceTest { + + @Autowired + private TicketReservationService service; + @Autowired + private EntityManager entityManager; + @Autowired + private JdbcTemplate jdbc; + @Autowired + private PlatformTransactionManager transactionManager; + + // 만료 시점은 DB fixture로 제어하고 실제 만료 서비스를 직접 호출한다. + @MockitoBean + private SeatHoldExpirationScheduler scheduler; + + private Fixture fixture; + + @BeforeEach + void setUp() { + // 서비스가 REQUIRES_NEW를 사용하므로 준비 데이터도 먼저 커밋한다. + fixture = new TransactionTemplate(transactionManager).execute(status -> { + Instant now = jdbc.queryForObject("SELECT UTC_TIMESTAMP(6)", LocalDateTime.class) + .toInstant(ZoneOffset.UTC); + String suffix = UUID.randomUUID().toString(); + Member first = Member.register("hold-first-" + suffix + "@example.com", "hash", "First", now); + Member second = Member.register("hold-second-" + suffix + "@example.com", "hash", "Second", now); + entityManager.persist(first); + entityManager.persist(second); + Venue venue = Venue.create("Hall", "Seoul", "Asia/Seoul", "ACTIVE", now); + entityManager.persist(venue); + VenueSection section = VenueSection.create(venue.getId(), "A", "Section A", "1F", "ACTIVE"); + entityManager.persist(section); + VenueLayout layout = VenueLayout.create(venue.getId(), "BASIC", 1, "Basic", "PUBLISHED", now); + entityManager.persist(layout); + Concert concert = Concert.create(venue.getId(), first.getId(), "Concert", "SCHEDULED", now); + entityManager.persist(concert); + Performance performance = performance(concert.getId(), venue.getId(), layout.getId(), now); + Performance other = performance(concert.getId(), venue.getId(), layout.getId(), now.plusSeconds(60)); + List seatIds = java.util.stream.IntStream.rangeClosed(1, 3).mapToObj(number -> { + VenueSeat physical = VenueSeat.create(venue.getId(), section.getId(), "1", String.valueOf(number), + false, "ACTIVE"); + entityManager.persist(physical); + entityManager.persist(LayoutSeat.create(new LayoutSeatId(layout.getId(), physical.getId()), + venue.getId(), "A", "1", String.valueOf(number), BigDecimal.valueOf(number), + BigDecimal.ZERO, true)); + TicketSeat seat = TicketSeat.createAvailable(performance.getId(), layout.getId(), physical.getId(), + "VIP", 100_000L); + entityManager.persist(seat); + return seat.getId(); + }).toList(); + return new Fixture(first.getId(), second.getId(), venue.getId(), performance.getId(), other.getId(), seatIds); + }); + } + + @AfterEach + void cleanUp() { + if (fixture == null) { + return; + } + new TransactionTemplate(transactionManager).executeWithoutResult(status -> { + jdbc.update("UPDATE performance_seats SET status = 'AVAILABLE', current_hold_id = NULL WHERE performance_id = ?", + fixture.performanceId()); + jdbc.update("DELETE FROM seat_holds WHERE performance_id = ?", fixture.performanceId()); + jdbc.update("DELETE FROM ticket_reservations WHERE performance_id IN (?, ?)", + fixture.performanceId(), fixture.otherPerformanceId()); + jdbc.update("DELETE FROM ticket_purchase_limits WHERE performance_id IN (?, ?)", + fixture.performanceId(), fixture.otherPerformanceId()); + jdbc.update("DELETE FROM performance_seats WHERE performance_id = ?", fixture.performanceId()); + jdbc.update("DELETE FROM performances WHERE venue_id = ?", fixture.venueId()); + jdbc.update("DELETE FROM concerts WHERE venue_id = ?", fixture.venueId()); + jdbc.update("DELETE FROM layout_seats WHERE venue_id = ?", fixture.venueId()); + jdbc.update("DELETE FROM venue_layouts WHERE venue_id = ?", fixture.venueId()); + jdbc.update("DELETE FROM venue_seats WHERE venue_id = ?", fixture.venueId()); + jdbc.update("DELETE FROM venue_sections WHERE venue_id = ?", fixture.venueId()); + jdbc.update("DELETE FROM venues WHERE id = ?", fixture.venueId()); + jdbc.update("DELETE FROM users WHERE id IN (?, ?)", fixture.firstUserId(), fixture.secondUserId()); + }); + } + + @Test + @DisplayName("서로 다른 사용자가 같은 좌석을 동시에 선점하면 한 명만 소유하고 패자는 전체 롤백된다") + void concurrentUsersCannotOwnTheSameSeat() throws Exception { + List results = race( + () -> reserve(fixture.firstUserId(), "first", List.of(seat(0), seat(1))), + () -> reserve(fixture.secondUserId(), "second", List.of(seat(1), seat(2)))); + + assertThat(results.stream().filter(result -> result.info() != null)).hasSize(1); + assertThat(results.stream().map(Outcome::error).filter(java.util.Objects::nonNull)) + .containsExactly(ErrorCode.SEAT_UNAVAILABLE); + TicketReservationInfo winner = results.stream().map(Outcome::info).filter(java.util.Objects::nonNull) + .findFirst().orElseThrow(); + assertStoredReservation(winner, 2); + assertThat(count("ticket_reservations")).isEqualTo(1); + assertThat(count("seat_holds")).isEqualTo(2); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM performance_seats WHERE performance_id = ? AND status = 'AVAILABLE' AND current_hold_id IS NULL", + Integer.class, fixture.performanceId())).isEqualTo(1); + assertThat(jdbc.queryForObject("SELECT SUM(reserved_count) FROM ticket_purchase_limits WHERE performance_id = ?", + Integer.class, fixture.performanceId())).isEqualTo(2); + } + + @Test + @DisplayName("같은 사용자가 다른 키와 다른 좌석으로 동시에 요청해도 활성 예약은 하나만 생성된다") + void concurrentRequestsForSameUserCreateOneActiveReservation() throws Exception { + List results = race( + () -> reserve(fixture.firstUserId(), "first", List.of(seat(0))), + () -> reserve(fixture.firstUserId(), "second", List.of(seat(1)))); + + assertThat(results.stream().filter(result -> result.info() != null)).hasSize(1); + assertThat(results.stream().map(Outcome::error).filter(java.util.Objects::nonNull)) + .containsExactly(ErrorCode.ACTIVE_RESERVATION_EXISTS); + assertThat(count("ticket_reservations")).isEqualTo(1); + assertThat(count("ticket_purchase_limits")).isEqualTo(1); + assertThat(reservedCount(fixture.firstUserId())).isEqualTo(1); + } + + @Test + @DisplayName("동일 키의 동시 요청은 구매 관리 행 생성 경쟁에도 같은 예약으로 연결된다") + void concurrentSameKeyRequestsReturnOneReservation() throws Exception { + List results = race( + () -> reserve(fixture.firstUserId(), "same", List.of(seat(0), seat(1))), + () -> reserve(fixture.firstUserId(), "same", List.of(seat(1), seat(0)))); + + assertThat(results).allSatisfy(result -> assertThat(result.error()).isNull()); + assertThat(results.get(0).info()).isEqualTo(results.get(1).info()); + assertStoredReservation(results.get(0).info(), 2); + assertThat(count("ticket_reservations")).isEqualTo(1); + assertThat(count("seat_holds")).isEqualTo(2); + assertThat(count("ticket_purchase_limits")).isEqualTo(1); + } + + @Test + @DisplayName("같은 키 재요청은 좌석 순서와 무관하게 최초 기한을 유지하고 다른 좌석·회차는 거절한다") + void replayPreservesOriginalReservationAndRejectsDifferentContent() { + TicketReservationInfo original = reserve(fixture.firstUserId(), "same", List.of(seat(1), seat(0))); + TicketReservationInfo replay = reserve(fixture.firstUserId(), "same", List.of(seat(0), seat(1))); + + assertThat(replay).isEqualTo(original); + assertThat(replay.seatIds()).containsExactly(seat(0), seat(1)); + assertThat(jdbc.queryForObject("SELECT TIMESTAMPDIFF(SECOND, created_at, hold_expires_at) FROM ticket_reservations WHERE id = ?", + Long.class, original.reservationId())).isEqualTo(300L); + assertError(() -> reserve(fixture.firstUserId(), "same", List.of(seat(0), seat(2))), + ErrorCode.IDEMPOTENCY_KEY_CONFLICT); + assertError(() -> service.reserve(fixture.firstUserId(), "same", fixture.otherPerformanceId(), + List.of(seat(0), seat(1))), ErrorCode.IDEMPOTENCY_KEY_CONFLICT); + assertStoredReservation(original, 2); + assertThat(count("ticket_reservations")).isEqualTo(1); + assertThat(count("seat_holds")).isEqualTo(2); + } + + @ParameterizedTest(name = "{displayName} [요청 좌석 수={0}]") + @ValueSource(ints = {1, 2}) + @DisplayName("확정 수량을 포함한 회차 한도는 정확히 채울 수 있고 초과 요청은 좌석·수량을 변경하지 않는다") + void enforcesPurchaseLimitIncludingConfirmedQuantity(int quantity) { + // 결제 확정은 이번 구현 범위 밖이므로 기존 확정 수량만 fixture로 준비한다. + jdbc.update("INSERT INTO ticket_purchase_limits (user_id, performance_id, reserved_count, confirmed_count) VALUES (?, ?, 0, 2)", + fixture.firstUserId(), fixture.performanceId()); + List requested = fixture.seatIds().subList(0, quantity); + + if (quantity == 1) { + TicketReservationInfo result = reserve(fixture.firstUserId(), "limit", requested); + assertStoredReservation(result, 1); + } else { + assertError(() -> reserve(fixture.firstUserId(), "limit", requested), ErrorCode.TICKET_LIMIT_EXCEEDED); + assertThat(count("ticket_reservations")).isZero(); + assertThat(count("seat_holds")).isZero(); + assertThat(reservedCount(fixture.firstUserId())).isZero(); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM performance_seats WHERE performance_id = ? AND status = 'AVAILABLE' AND current_hold_id IS NULL", + Integer.class, fixture.performanceId())).isEqualTo(3); + } + assertThat(jdbc.queryForObject("SELECT confirmed_count FROM ticket_purchase_limits WHERE user_id = ? AND performance_id = ?", + Integer.class, fixture.firstUserId(), fixture.performanceId())).isEqualTo(2); + } + + @Test + @DisplayName("만료 요청 정리는 예약의 모든 좌석을 반환하고 같은 키 재생성·중복 반환·새 소유자 해제를 막는다") + void expiredReservationReleasesAllSeatsWithoutRecreationOrReleasingNewOwner() { + TicketReservationInfo old = reserve(fixture.firstUserId(), "old", List.of(seat(0), seat(1))); + markExpired(old.reservationId()); + Instant expiredAt = jdbc.queryForObject("SELECT hold_expires_at FROM ticket_reservations WHERE id = ?", + LocalDateTime.class, old.reservationId()).toInstant(ZoneOffset.UTC); + + // 선택한 한 좌석에서 만료를 발견해도 기존 예약의 모든 좌석을 반환해야 한다. + TicketReservationInfo next = reserve(fixture.secondUserId(), "new", List.of(seat(0))); + assertThat(reservationStatus(old.reservationId())).isEqualTo("RELEASED"); + assertThat(reservedCount(fixture.firstUserId())).isZero(); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM seat_holds WHERE reservation_id = ? AND status = 'RELEASED' AND released_at IS NOT NULL", + Integer.class, old.reservationId())).isEqualTo(2); + assertThat(jdbc.queryForObject("SELECT status FROM performance_seats WHERE id = ?", String.class, seat(1))) + .isEqualTo("AVAILABLE"); + assertThat(jdbc.queryForObject("SELECT current_hold_id FROM performance_seats WHERE id = ?", Long.class, seat(1))) + .isNull(); + + service.expireHold(old.reservationId()); + TicketReservationInfo replay = reserve(fixture.firstUserId(), "old", List.of(seat(1), seat(0))); + assertThat(replay.reservationId()).isEqualTo(old.reservationId()); + assertThat(replay.status()).isEqualTo(TicketReservationStatus.RELEASED); + assertThat(replay.holdExpiresAt()).isEqualTo(expiredAt); + assertThat(count("ticket_reservations")).isEqualTo(2); + assertThat(reservedCount(fixture.firstUserId())).isZero(); + assertStoredReservation(next, 1); + } + + @ParameterizedTest(name = "{displayName} [{0}]") + @EnumSource(value = TicketReservationStatus.class, names = {"HELD", "PAYMENT_PENDING", "RECONCILING"}) + @DisplayName("기한 전 HELD와 결제 진행·결과 확인 중 예약은 최초 선점 기한만으로 반환하지 않는다") + void doesNotReleaseUnexpiredOrPaymentProtectedReservations(TicketReservationStatus state) { + TicketReservationInfo original = reserve(fixture.firstUserId(), "protected", List.of(seat(0), seat(1))); + if (state != TicketReservationStatus.HELD) { + markExpired(original.reservationId()); + jdbc.update("UPDATE ticket_reservations SET status = ?, checkout_started_at = UTC_TIMESTAMP(6), payment_expires_at = DATE_ADD(UTC_TIMESTAMP(6), INTERVAL 5 MINUTE) WHERE id = ?", + state.name(), original.reservationId()); + } + + service.expireHold(original.reservationId()); + + assertThat(reservationStatus(original.reservationId())).isEqualTo(state.name()); + assertStoredReservation(original, 2); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM seat_holds WHERE reservation_id = ? AND released_at IS NOT NULL", + Integer.class, original.reservationId())).isZero(); + } + + private Performance performance(Long concertId, Long venueId, Long layoutId, Instant now) { + Performance result = Performance.create(concertId, venueId, layoutId, now.plusSeconds(86400), + now.minusSeconds(3600), now.plusSeconds(3600), 3, "SCHEDULED"); + entityManager.persist(result); + return result; + } + + private TicketReservationInfo reserve(Long userId, String key, List seatIds) { + return service.reserve(userId, key, fixture.performanceId(), seatIds); + } + + private Long seat(int index) { + return fixture.seatIds().get(index); + } + + private int count(String table) { + return jdbc.queryForObject("SELECT COUNT(*) FROM " + table + " WHERE performance_id = ?", + Integer.class, fixture.performanceId()); + } + + private int reservedCount(Long userId) { + return jdbc.queryForObject("SELECT reserved_count FROM ticket_purchase_limits WHERE user_id = ? AND performance_id = ?", + Integer.class, userId, fixture.performanceId()); + } + + private String reservationStatus(Long reservationId) { + return jdbc.queryForObject("SELECT status FROM ticket_reservations WHERE id = ?", String.class, reservationId); + } + + private void markExpired(Long reservationId) { + jdbc.update("UPDATE ticket_reservations SET hold_expires_at = DATE_SUB(UTC_TIMESTAMP(6), INTERVAL 1 SECOND) WHERE id = ?", + reservationId); + } + + private void assertStoredReservation(TicketReservationInfo info, int quantity) { + assertThat(jdbc.queryForObject(""" + SELECT COUNT(*) FROM performance_seats s + JOIN seat_holds h ON h.id = s.current_hold_id AND h.performance_seat_id = s.id + WHERE h.reservation_id = ? AND s.performance_id = ? AND s.status = 'HELD' AND h.status = 'HELD' + """, Integer.class, info.reservationId(), fixture.performanceId())).isEqualTo(quantity); + Long userId = jdbc.queryForObject("SELECT user_id FROM ticket_reservations WHERE id = ?", Long.class, + info.reservationId()); + assertThat(reservedCount(userId)).isEqualTo(quantity); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM seat_holds WHERE reservation_id = ? AND price_amount = 100000", + Integer.class, info.reservationId())).isEqualTo(quantity); + } + + private void assertError(Runnable action, ErrorCode expected) { + assertThatThrownBy(action::run).isInstanceOfSatisfying(BusinessException.class, + failure -> assertThat(failure.getErrorCode()).isEqualTo(expected)); + } + + private List race(Callable first, Callable second) + throws Exception { + var executor = Executors.newFixedThreadPool(2); + CountDownLatch ready = new CountDownLatch(2); + CountDownLatch start = new CountDownLatch(1); + try { + var futures = List.of(first, second).stream().map(action -> executor.submit(() -> { + ready.countDown(); + if (!start.await(10, TimeUnit.SECONDS)) { + throw new IllegalStateException("동시 요청 시작 신호를 받지 못했습니다."); + } + try { + return new Outcome(action.call(), null); + } catch (BusinessException failure) { + return new Outcome(null, failure.getErrorCode()); + } + })).toList(); + assertThat(ready.await(10, TimeUnit.SECONDS)).isTrue(); + start.countDown(); + return List.of(futures.get(0).get(30, TimeUnit.SECONDS), futures.get(1).get(30, TimeUnit.SECONDS)); + } finally { + start.countDown(); + executor.shutdownNow(); + assertThat(executor.awaitTermination(10, TimeUnit.SECONDS)).isTrue(); + } + } + + private record Outcome(TicketReservationInfo info, ErrorCode error) { + } + + private record Fixture(Long firstUserId, Long secondUserId, Long venueId, Long performanceId, + Long otherPerformanceId, List seatIds) { + } +} diff --git a/docs/contracts/api/ticketing.md b/docs/contracts/api/ticketing.md index 28e22895..fc124301 100644 --- a/docs/contracts/api/ticketing.md +++ b/docs/contracts/api/ticketing.md @@ -51,27 +51,55 @@ Long으로 변환할 수 없는 performanceId는 `400 INVALID_REQUEST`로 응답 ## 좌석 선점 +로그인 필수다. 회원 ID는 본문에서 받지 않고 `@LoginMember`로 인증된 토큰에서 추출한다. +`performanceId`와 `seatIds`는 양수여야 하며 좌석 목록은 비어 있거나 중복될 수 없다. +`seatIds`는 물리 좌석 ID가 아닌 조회 응답의 판매 좌석 `seatId`다. +`Idempotency-Key`는 필수이며 공백만 있는 값은 거절하고 최대 100자로 제한한다. +키의 대소문자·후행 공백은 구분하며, 좌석 ID의 순서 차이는 같은 요청으로 취급한다. + 요청: ```http POST /api/ticket-reservations +Authorization: Bearer Idempotency-Key: 7f83a2b1-... Content-Type: application/json { "performanceId": 100, "seatIds": [10, 11] } ``` -성공: +성공 (`201 Created`): ```json { "reservationId": 5001, "status": "HELD", "seatIds": [10, 11], - "holdExpiresAt": "2026-11-06T11:30:00+09:00" + "holdExpiresAt": "2026-11-12T02:30:00Z" } ``` +좌석 ID는 오름차순으로 반환하며, 잠금 획득 후 DB UTC 시각 기준으로 5분간 선점한다. +예매 시간은 시작 정각부터 마감 직전까지 허용한다. 좌석 하나라도 선점 불가하면 전체 요청을 롤백한다. +같은 사용자·키·회차·좌석 집합으로 재요청하면 기존 예약의 현재 상태와 최초 기한을 `201`로 반환한다. +만료·취소된 예약도 재생성하지 않는다. 만료된 결제 전 HELD 예약은 전체 반환 후 RELEASED 상태로 연결한다. +다른 회차나 좌석으로 같은 키를 재사용하면 `409 IDEMPOTENCY_KEY_CONFLICT`다. +최초 요청의 5분 기한은 새로고침·재요청으로 연장되지 않는다. + +선점 API의 오류 HTTP 상태: + +| HTTP | 코드 | 조건 | +|---|---|---| +| 400 | `INVALID_REQUEST` | 필수 헤더 누락, 유효하지 않은 본문·키, 중복 좌석 | +| 401 | `UNAUTHORIZED` | 인증 정보 없음 또는 유효하지 않은 토큰 | +| 404 | `NOT_FOUND` | 없는 공연 회차 | +| 409 | `SEAT_UNAVAILABLE` | 없는 판매 좌석, 다른 회차·배치, 판매 제외, 이미 선점·판매된 좌석 | +| 409 | `ACTIVE_RESERVATION_EXISTS` | 해당 사용자·회차의 활성 예약 존재 | +| 409 | `TICKET_LIMIT_EXCEEDED` | 확정+선점+신규 수량이 회차 한도 초과 | +| 409 | `BOOKING_NOT_OPEN`, `BOOKING_CLOSED` | 예매 시간 범위 밖 | +| 409 | `IDEMPOTENCY_KEY_CONFLICT` | 같은 키로 다른 회차·좌석 요청 | +| 409 | `SEAT_LOCK_TIMEOUT` | 잠금·생성 경합 등의 최대 3회 시도 소진. 같은 키로 재요청 가능 | + ## 오류 코드 | 코드 | 의미 | @@ -85,7 +113,7 @@ Content-Type: application/json | `IDEMPOTENCY_KEY_CONFLICT` | 같은 키로 다른 요청 | | `SEAT_LOCK_TIMEOUT` | 잠금 대기 초과 | -아래 멱등성 계약의 202·409 외 오류의 HTTP 상태 코드는 후속 API 설계에서 정한다. +위 선점 API 외 후속 API의 오류 HTTP 상태 코드는 해당 API 구현 시 정한다. ## 결제 기한 정책 (DECIDED) @@ -129,4 +157,4 @@ Java 엔티티·Repository는 Performance/PerformanceRepository, DB 테이블은 좌석 조회 API는 /api/performances/{performanceId}/seats로 통일하며 performanceId는 Performance의 ID다. 좌석 선점 요청 본문도 performanceId를 사용하며, 내부 Performance의 ID로 해석한다. 기존 concert-sessions 조회 경로와 선점 요청의 sessionId 필드는 제공하지 않는다. -선점 요청 DTO와 API 처리는 아직 구현 전이며, 구현 시 위 계약을 따른다. +선점 요청 DTO와 POST API는 위 명칭으로 구현했다. 테스트·동시성 실행 검증은 아직 하지 않았다. diff --git a/docs/domains/ticketing/expiration.md b/docs/domains/ticketing/expiration.md index e3675606..f1eb3f14 100644 --- a/docs/domains/ticketing/expiration.md +++ b/docs/domains/ticketing/expiration.md @@ -1,7 +1,7 @@ # 예약 만료와 좌석 반환 - 상태: DECIDED (2026-11-12, 담당자 합의). -- 구현 상태: 문서 설계. 애플리케이션·승인 시도 스키마는 후속 구현 대상이다. +- 구현 상태: 결제 전 HELD 예약의 전체 좌석 반환과 요청 시 만료 정리, 5초 주기 만료 스케줄러를 구현했다. PAYMENT_PENDING 이후 만료·승인 시도 연동은 후속 구현 대상이며, 이번 동작·동시성 테스트는 아직 실행하지 않았다. ## 1. 판단 기준 @@ -47,6 +47,10 @@ PG 조회 미존재만으로 최종 실패라고 단정하지 않는다. 4. 다중 좌석은 모두 함께 반환한다. 중복 만료 실행은 상태를 재검증하여 카운터를 한 번만 감소시킨다. 5초 스케줄러와 요청 시 만료 검증은 같은 반환 규칙을 사용한다. +현재 스케줄러는 DB UTC 시각으로 만료된 HELD 예약을 만료 시각·ID 순으로 최대 100건 조회하고 예약별 별도 트랜잭션으로 처리한다. +기본 실행 간격은 처리 종료 후 5초이며 restless.ticketing.hold-expiration-delay-ms로 조정할 수 있다. +예약별 실패는 로그와 ticketing.hold.expiration.failures 메트릭을 남기고 다른 예약 처리를 계속한다. +PAYMENT_PENDING/RECONCILING과 결제 관련 필드가 있는 비정상 HELD는 자동 반환하지 않는다. 기한 도달은 반환 가능한 시점이며 스케줄러 실행 지연으로 실제 정리가 늦을 수 있다. 불명확 상태 5분 후 운영 전환은 반환 조건이 아니다. 자동 조회와 좌석 보호를 계속한다. 복구 정책은 [결제 트랜잭션 설계](transactions.md)를 따른다. diff --git a/docs/domains/ticketing/idempotency.md b/docs/domains/ticketing/idempotency.md index c9a57d86..87e5a311 100644 --- a/docs/domains/ticketing/idempotency.md +++ b/docs/domains/ticketing/idempotency.md @@ -302,7 +302,10 @@ GROUP BY user_id, request_key COLLATE utf8mb4_0900_bin HAVING COUNT(*) > 1; ``` -현재 버전은 고정 정규화 형식을 사용한다. 구체적인 직렬화 형식은 선점 구현에서 문서·테스트로 고정하고 이후 변경 시 기존 해시 호환을 유지한다. +현재 MVP의 정규화 형식은 UTF-8 문자열 `v1\n\n<오름차순 판매 좌석 ID를 쉼표로 연결>`이며 마지막 줄 끝에는 개행이 없다. +예를 들어 회차 100의 좌석 [11, 10]은 `v1\n100\n10,11`의 SHA-256으로 저장한다. +빈 목록·중복·NULL·0 이하 ID는 정규화 전에 거절한다. 키는 공백만 있는 값과 100자 초과를 거절하며 trim/소문자 변환을 하지 않는다. +향후 형식을 바꾸더라도 기존 해시의 재요청 호환성을 유지해야 한다. TicketReservationServiceTest에 동일 키의 동시·순차 재요청, 좌석 순서 정규화, 다른 회차·좌석 충돌 검증을 작성했으며 아직 실행하지 않았다. ### checkout @@ -315,7 +318,11 @@ HAVING COUNT(*) > 1; ### 구현 시작 조건 핵심 선점 정책·DB 제약·구매 제한·재요청 처리 방향은 확정되어 좌석 선점 구현을 시작할 수 있다. -현재 엔티티·서비스·Controller는 골격 상태이므로 데이터 매핑부터 구현한다. +엔티티 매핑과 좌석 조회, 최초 선점 POST·결제 전 HELD 만료 처리를 구현했다. checkout·결제·취소·환불 API는 후속 범위다. 회차 조회는 concert 모듈의 application 계약으로 제공하여 ticketing이 concert Repository를 직접 참조하지 않게 한다. -좌석 배열 검증·정규화 형식·HTTP 오류 매핑·잠금 대기 설정은 선점 구현 계획에서 구체화한다. +좌석 배열 검증·정규화는 위 MVP 계약, HTTP 오류 매핑은 [API 계약](../../contracts/api/ticketing.md)을 따른다. +선점·만료는 각각 READ_COMMITTED의 새 트랜잭션으로 실행하며, 구매 관리 행 생성과 사용자별 키 UNIQUE 충돌·교착·잠금 대기 실패는 전체 롤백 후 최대 3회 시도한다. +재시도 가능한 UNIQUE는 uk_ticket_purchase_limits_user_performance와 uk_ticket_reservations_user_request_key로 제한한다. 그 외 무결성 오류는 키 충돌로 오인하지 않는다. +잠금 대기 시간은 환경의 MySQL innodb_lock_wait_timeout을 사용하며 이번 구현에서 DB·세션 값을 변경하지 않는다. 시도 소진은 SEAT_LOCK_TIMEOUT이다. +만료 예약 발견 시 기존 선점 트랜잭션을 롤백한 뒤 해당 예약의 전체 반환을 별도 트랜잭션에서 수행하고 최초 입력으로 재시도한다. 첫 범위는 지정석 선점과 기존 예약 반환까지로 두고, 결제 Handler 변경·전용 멱등성 테이블은 포함하지 않는다. diff --git a/docs/domains/ticketing/purchase-limit.md b/docs/domains/ticketing/purchase-limit.md index 5ae378c5..17ed04d8 100644 --- a/docs/domains/ticketing/purchase-limit.md +++ b/docs/domains/ticketing/purchase-limit.md @@ -3,7 +3,7 @@ # 구매 제한과 사용자·회차별 활성 예약 - 상태: DECIDED (2026-11-12, 담당자 합의). -- 구현 상태: TicketPurchaseLimit 엔티티 매핑 구현. 비관적 락·한도 검증·수량 변경 애플리케이션은 후속 구현 대상이다. +- 구현 상태: 엔티티 매핑과 최초 선점·결제 전 선점 만료의 구매 관리 행 잠금, 활성 예약·한도 검증, 수량 변경을 구현했다. 결제·취소·환불 경로는 후속 구현 대상이며 이번 동시성 검증은 아직 실행하지 않았다. ## 범위와 불변식 diff --git a/docs/domains/ticketing/seat-ownership.md b/docs/domains/ticketing/seat-ownership.md index cc711586..08062b34 100644 --- a/docs/domains/ticketing/seat-ownership.md +++ b/docs/domains/ticketing/seat-ownership.md @@ -7,6 +7,13 @@ - 기준: MySQL 8 / InnoDB, ADR-0002. - 구현 상태: 설계 합의. 아래 추가 제약과 처리 절차가 현재 코드에 구현됐다는 의미는 아니다. +현재 선점 구현: POST /api/ticket-reservations에서 사용자·회차 구매 관리 행과 예약을 잠근 뒤 판매 좌석을 ID 오름차순으로 단건 잠근다. +예매 기간·배치의 판매 가능 여부·AVAILABLE/NULL 소유권·활성 예약·구매 한도를 검사하고, +예약·선점 이력·HELD/현재 선점 포인터·reserved_count를 한 트랜잭션에 반영한다. +DB UTC 시각 기준 선점 기한은 5분이며 재요청으로 연장하지 않는다. 결제 전 HELD 만료 반환도 같은 잠금 순서를 따른다. +공연·회차의 관리 status 값 집합은 데이터 사전상 미확정이므로 새 허용 상태를 임의로 정의하지 않으며, 관리 상태별 예매 차단은 후속 정책 대상이다. +결제 확정·취소·환불의 소유권 전이는 후속 구현이다. TicketReservationServiceTest에 선점 경쟁·동일 키·구매 한도·결제 전 만료와 결제 상태 보호 검증을 작성했으며 아직 실행하지 않았다. + ## 1. 소유권의 기준 회차별 좌석 행 `performance_seats`가 현재 소유권의 기준이다. `seat_holds`는 이력이다. diff --git a/docs/domains/ticketing/venue-consistency.md b/docs/domains/ticketing/venue-consistency.md index 4437a496..680dc428 100644 --- a/docs/domains/ticketing/venue-consistency.md +++ b/docs/domains/ticketing/venue-consistency.md @@ -134,4 +134,4 @@ WHERE c.layout_id <> p.layout_id; - ./gradlew clean test --tests 'com.restless.concert.*' 실행으로 공연 도메인 테스트 총 17개가 통과했다. 최초 실행의 클래스 로딩 오류는 빌드 산출물 초기화 후 재실행에서 해소됐다. - 주최자 권한, 회차 등록 API, 오픈 후 배치 변경 제한의 서비스 처리, 판매 좌석·예매 로직은 이번 매핑 구현 범위가 아니다. -회차 내부 명칭은 Performance/PerformanceRepository로 통일하고 테스트도 ConcertPerformanceMappingTest로 변경했다. DB performances는 유지한다. 좌석 조회 API는 후속 결정에 따라 /api/performances/{performanceId}/seats로 통일했다. 선점 요청 본문의 회차 식별자도 performanceId로 통일한다. 선점 요청 DTO와 API 처리는 아직 구현 전이다. 내부 이름 변경 당시 ./gradlew build 실행으로 전체 테스트 161개가 통과했으며, 후속 API 명명 변경에 대한 테스트는 아직 실행하지 않았다. +회차 내부 명칭은 Performance/PerformanceRepository로 통일하고 테스트도 ConcertPerformanceMappingTest로 변경했다. DB performances는 유지한다. 좌석 조회 API는 후속 결정에 따라 /api/performances/{performanceId}/seats로 통일했다. 선점 요청 본문의 회차 식별자도 performanceId로 통일하고 요청 DTO·POST API를 구현했다. 내부 이름 변경 당시 ./gradlew build 실행으로 전체 테스트 161개가 통과했으며, 후속 API 명명 변경·선점 구현에 대한 테스트는 아직 실행하지 않았다. From cda280220417a6fe44727b1641b81891a1113a7b Mon Sep 17 00:00:00 2001 From: songfox00 Date: Thu, 12 Nov 2026 23:29:22 +0900 Subject: [PATCH 3/4] feat(ticketing): add seat hold cancellation --- .../com/restless/common/error/ErrorCode.java | 1 + .../api/TicketReservationController.java | 8 ++ .../application/TicketReservationService.java | 51 +++++++++++- .../ticketing/domain/TicketReservation.java | 14 +++- .../TicketReservationServiceTest.java | 81 +++++++++++++++++++ docs/contracts/api/ticketing.md | 30 +++++++ docs/domains/ticketing/idempotency.md | 2 +- docs/domains/ticketing/purchase-limit.md | 2 +- docs/domains/ticketing/seat-ownership.md | 4 +- 9 files changed, 186 insertions(+), 7 deletions(-) diff --git a/backend/src/main/java/com/restless/common/error/ErrorCode.java b/backend/src/main/java/com/restless/common/error/ErrorCode.java index ffd6db23..d9c127e7 100644 --- a/backend/src/main/java/com/restless/common/error/ErrorCode.java +++ b/backend/src/main/java/com/restless/common/error/ErrorCode.java @@ -34,6 +34,7 @@ public enum ErrorCode { TICKET_LIMIT_EXCEEDED(HttpStatus.CONFLICT, "회차별 구매 한도를 초과했습니다."), BOOKING_NOT_OPEN(HttpStatus.CONFLICT, "예매 시작 전입니다."), BOOKING_CLOSED(HttpStatus.CONFLICT, "예매가 마감되었습니다."), + RESERVATION_CANNOT_CANCEL(HttpStatus.CONFLICT, "결제 전 선점 예약만 취소할 수 있습니다."), IDEMPOTENCY_KEY_CONFLICT(HttpStatus.CONFLICT, "같은 요청 키를 다른 요청에 사용할 수 없습니다."), SEAT_LOCK_TIMEOUT(HttpStatus.CONFLICT, "좌석 처리 경합이 발생했습니다. 같은 요청 키로 재시도해 주세요."); diff --git a/backend/src/main/java/com/restless/ticketing/api/TicketReservationController.java b/backend/src/main/java/com/restless/ticketing/api/TicketReservationController.java index b6839a51..60e0dccb 100644 --- a/backend/src/main/java/com/restless/ticketing/api/TicketReservationController.java +++ b/backend/src/main/java/com/restless/ticketing/api/TicketReservationController.java @@ -7,6 +7,8 @@ import jakarta.validation.Valid; import lombok.RequiredArgsConstructor; import org.springframework.http.HttpStatus; +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.RequestHeader; @@ -28,4 +30,10 @@ public TicketReservationInfo reserve(@LoginMember Long userId, @Valid @RequestBody TicketReservationRequest request) { return ticketReservationService.reserve(userId, requestKey, request.performanceId(), request.seatIds()); } + + @DeleteMapping("/{reservationId}") + @ResponseStatus(HttpStatus.NO_CONTENT) + public void cancel(@LoginMember Long userId, @PathVariable("reservationId") Long reservationId) { + ticketReservationService.cancel(userId, reservationId); + } } diff --git a/backend/src/main/java/com/restless/ticketing/application/TicketReservationService.java b/backend/src/main/java/com/restless/ticketing/application/TicketReservationService.java index 6ffea259..cd1dd934 100644 --- a/backend/src/main/java/com/restless/ticketing/application/TicketReservationService.java +++ b/backend/src/main/java/com/restless/ticketing/application/TicketReservationService.java @@ -199,6 +199,45 @@ private TicketReservationInfo replay(TicketReservation reservation, Long perform reservation.getHoldExpiresAt()); } + /** 본인 예약만 취소한다. 반환 완료된 예약은 수량·좌석을 다시 변경하지 않는다. */ + public void cancel(Long userId, Long reservationId) { + if (userId == null || userId <= 0) { + throw new BusinessException(ErrorCode.UNAUTHORIZED); + } + if (reservationId == null || reservationId <= 0) { + throw new BusinessException(ErrorCode.INVALID_REQUEST); + } + for (int attempt = 0; attempt < MAX_ATTEMPTS; attempt++) { + try { + transaction.executeWithoutResult(status -> cancelInTransaction(userId, reservationId)); + return; + } catch (PessimisticLockingFailureException conflict) { + // 전체 롤백 후 소유자·예약 상태를 다시 검사한다. + } + } + throw new BusinessException(ErrorCode.SEAT_LOCK_TIMEOUT); + } + + private void cancelInTransaction(Long userId, Long reservationId) { + var owner = ticketReservationRepository.findOwnerById(reservationId) + .filter(candidate -> userId.equals(candidate.getUserId())) + .orElseThrow(() -> new BusinessException(ErrorCode.NOT_FOUND)); + TicketPurchaseLimit limit = ticketPurchaseLimitRepository + .findByUserIdAndPerformanceId(userId, owner.getPerformanceId()) + .orElseThrow(() -> new IllegalStateException("예약의 구매 관리 행이 없습니다.")); + TicketReservation reservation = ticketReservationRepository.findLockedById(reservationId) + .filter(candidate -> userId.equals(candidate.getUserId())) + .orElseThrow(() -> new BusinessException(ErrorCode.NOT_FOUND)); + if (reservation.getStatus() == TicketReservationStatus.RELEASED) { + return; + } + if (!reservation.canReleaseHold()) { + throw new BusinessException(ErrorCode.RESERVATION_CANNOT_CANCEL); + } + releaseHeldSeats(reservation, limit); + reservation.cancelHold(); + } + /** 결제 전 HELD만 반환한다. PAYMENT_PENDING/RECONCILING은 기한만으로 해제하지 않는다. */ public void expireHold(Long reservationId) { for (int attempt = 0; attempt < MAX_ATTEMPTS; attempt++) { @@ -221,7 +260,14 @@ private void expireInTransaction(Long reservationId) { if (!reservation.isHoldExpired(databaseNow())) { return; } - List originalHolds = seatHoldRepository.findAllByReservationIdOrderByPerformanceSeatIdAsc(reservationId); + releaseHeldSeats(reservation, limit); + reservation.releaseExpiredHold(databaseNow()); + } + + /** 호출자는 구매 관리 행과 예약 잠금을 보유해야 한다. 좌석·이력·수량을 함께 반환한다. */ + private void releaseHeldSeats(TicketReservation reservation, TicketPurchaseLimit limit) { + List originalHolds = seatHoldRepository + .findAllByReservationIdOrderByPerformanceSeatIdAsc(reservation.getId()); if (originalHolds.isEmpty()) { throw new IllegalStateException("반환할 선점 이력이 없습니다."); } @@ -233,13 +279,12 @@ private void expireInTransaction(Long reservationId) { if (hold.getStatus() != SeatHoldStatus.HELD || !hold.getPerformanceId().equals(reservation.getPerformanceId()) || !seat.getPerformanceId().equals(reservation.getPerformanceId())) { - throw new IllegalStateException("만료 예약의 선점·좌석 관계가 일치하지 않습니다."); + throw new IllegalStateException("반환 예약의 선점·좌석 관계가 일치하지 않습니다."); } seat.release(hold.getId()); hold.release(now); } limit.release(originalHolds.size()); - reservation.releaseExpiredHold(now); } private List lockSeats(List orderedIds) { diff --git a/backend/src/main/java/com/restless/ticketing/domain/TicketReservation.java b/backend/src/main/java/com/restless/ticketing/domain/TicketReservation.java index da04457a..0513d5ac 100644 --- a/backend/src/main/java/com/restless/ticketing/domain/TicketReservation.java +++ b/backend/src/main/java/com/restless/ticketing/domain/TicketReservation.java @@ -92,9 +92,21 @@ public boolean isHoldExpired(Instant now) { } public void releaseExpiredHold(Instant now) { - if (!isHoldExpired(now) || orderId != null || checkoutStartedAt != null || paymentExpiresAt != null) { + if (!isHoldExpired(now) || !canReleaseHold()) { throw new IllegalStateException("결제 전 만료된 선점 예약만 반환할 수 있습니다."); } status = TicketReservationStatus.RELEASED; } + + public boolean canReleaseHold() { + return status == TicketReservationStatus.HELD + && orderId == null && checkoutStartedAt == null && paymentExpiresAt == null; + } + + public void cancelHold() { + if (!canReleaseHold()) { + throw new IllegalStateException("결제 전 선점 예약만 취소할 수 있습니다."); + } + status = TicketReservationStatus.RELEASED; + } } diff --git a/backend/src/test/java/com/restless/ticketing/application/TicketReservationServiceTest.java b/backend/src/test/java/com/restless/ticketing/application/TicketReservationServiceTest.java index b1869745..e610c8d7 100644 --- a/backend/src/test/java/com/restless/ticketing/application/TicketReservationServiceTest.java +++ b/backend/src/test/java/com/restless/ticketing/application/TicketReservationServiceTest.java @@ -2,6 +2,10 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.jwt; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; import com.restless.TestcontainersConfiguration; import com.restless.common.error.BusinessException; @@ -37,9 +41,11 @@ import org.junit.jupiter.params.provider.ValueSource; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc; import org.springframework.context.annotation.Import; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.test.context.bean.override.mockito.MockitoBean; +import org.springframework.test.web.servlet.MockMvc; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.support.TransactionTemplate; @@ -49,6 +55,7 @@ "spring.docker.compose.enabled=false" }) @Import(TestcontainersConfiguration.class) +@AutoConfigureMockMvc class TicketReservationServiceTest { @Autowired @@ -59,6 +66,8 @@ class TicketReservationServiceTest { private JdbcTemplate jdbc; @Autowired private PlatformTransactionManager transactionManager; + @Autowired + private MockMvc mockMvc; // 만료 시점은 DB fixture로 제어하고 실제 만료 서비스를 직접 호출한다. @MockitoBean @@ -270,6 +279,78 @@ void doesNotReleaseUnexpiredOrPaymentProtectedReservations(TicketReservationStat Integer.class, original.reservationId())).isZero(); } + @Test + @DisplayName("본인 선점 취소는 전체 좌석·수량을 반환하고 반복 취소는 새 예약과 확정 수량에 영향을 주지 않는다") + void ownerCancellationReleasesAllSeatsOnlyOnce() throws Exception { + jdbc.update("INSERT INTO ticket_purchase_limits (user_id, performance_id, reserved_count, confirmed_count) VALUES (?, ?, 0, 1)", + fixture.firstUserId(), fixture.performanceId()); + TicketReservationInfo original = reserve(fixture.firstUserId(), "cancel", List.of(seat(0), seat(1))); + + mockMvc.perform(delete("/api/ticket-reservations/{reservationId}", original.reservationId()) + .with(jwt().jwt(token -> token.subject(fixture.firstUserId().toString())))) + .andExpect(status().isNoContent()); + + assertThat(reservationStatus(original.reservationId())).isEqualTo("RELEASED"); + assertThat(reservedCount(fixture.firstUserId())).isZero(); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM performance_seats WHERE performance_id = ? AND status = 'AVAILABLE' AND current_hold_id IS NULL", + Integer.class, fixture.performanceId())).isEqualTo(3); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM seat_holds WHERE reservation_id = ? AND status = 'RELEASED' AND released_at IS NOT NULL", + Integer.class, original.reservationId())).isEqualTo(2); + var releasedAt = jdbc.queryForList("SELECT released_at FROM seat_holds WHERE reservation_id = ? ORDER BY performance_seat_id", + LocalDateTime.class, original.reservationId()); + + // 새 예약의 수량이 있는 상태에서 이전 취소를 반복해 이중 차감을 검출한다. + TicketReservationInfo next = reserve(fixture.firstUserId(), "after-cancel", List.of(seat(0))); + mockMvc.perform(delete("/api/ticket-reservations/{reservationId}", original.reservationId()) + .with(jwt().jwt(token -> token.subject(fixture.firstUserId().toString())))) + .andExpect(status().isNoContent()); + + assertStoredReservation(next, 1); + assertThat(reservationStatus(original.reservationId())).isEqualTo("RELEASED"); + assertThat(jdbc.queryForList("SELECT released_at FROM seat_holds WHERE reservation_id = ? ORDER BY performance_seat_id", + LocalDateTime.class, original.reservationId())).isEqualTo(releasedAt); + assertThat(jdbc.queryForObject("SELECT confirmed_count FROM ticket_purchase_limits WHERE user_id = ? AND performance_id = ?", + Integer.class, fixture.firstUserId(), fixture.performanceId())).isEqualTo(1); + assertThat(reserve(fixture.firstUserId(), "cancel", original.seatIds()).status()) + .isEqualTo(TicketReservationStatus.RELEASED); + assertThat(count("ticket_reservations")).isEqualTo(2); + } + + @Test + @DisplayName("다른 회원의 JWT로 선점 취소를 요청하면 404이고 예약·좌석·수량을 유지한다") + void rejectsCancellationByAnotherMember() throws Exception { + TicketReservationInfo original = reserve(fixture.firstUserId(), "owner", List.of(seat(0), seat(1))); + + mockMvc.perform(delete("/api/ticket-reservations/{reservationId}", original.reservationId()) + .with(jwt().jwt(token -> token.subject(fixture.secondUserId().toString())))) + .andExpect(status().isNotFound()) + .andExpect(jsonPath("$.code").value("NOT_FOUND")); + + assertThat(reservationStatus(original.reservationId())).isEqualTo("HELD"); + assertStoredReservation(original, 2); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM seat_holds WHERE reservation_id = ? AND released_at IS NOT NULL", + Integer.class, original.reservationId())).isZero(); + } + + @ParameterizedTest(name = "{displayName} [{0}]") + @EnumSource(value = TicketReservationStatus.class, names = {"PAYMENT_PENDING", "RECONCILING"}) + @DisplayName("본인 예약이어도 결제 진행·결과 확인 중이면 취소를 거절하고 좌석·수량을 유지한다") + void rejectsCancellationDuringPayment(TicketReservationStatus state) throws Exception { + TicketReservationInfo original = reserve(fixture.firstUserId(), "payment", List.of(seat(0), seat(1))); + jdbc.update("UPDATE ticket_reservations SET status = ?, checkout_started_at = UTC_TIMESTAMP(6), payment_expires_at = DATE_ADD(UTC_TIMESTAMP(6), INTERVAL 5 MINUTE) WHERE id = ?", + state.name(), original.reservationId()); + + mockMvc.perform(delete("/api/ticket-reservations/{reservationId}", original.reservationId()) + .with(jwt().jwt(token -> token.subject(fixture.firstUserId().toString())))) + .andExpect(status().isConflict()) + .andExpect(jsonPath("$.code").value("RESERVATION_CANNOT_CANCEL")); + + assertThat(reservationStatus(original.reservationId())).isEqualTo(state.name()); + assertStoredReservation(original, 2); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM seat_holds WHERE reservation_id = ? AND released_at IS NOT NULL", + Integer.class, original.reservationId())).isZero(); + } + private Performance performance(Long concertId, Long venueId, Long layoutId, Instant now) { Performance result = Performance.create(concertId, venueId, layoutId, now.plusSeconds(86400), now.minusSeconds(3600), now.plusSeconds(3600), 3, "SCHEDULED"); diff --git a/docs/contracts/api/ticketing.md b/docs/contracts/api/ticketing.md index fc124301..df1c03df 100644 --- a/docs/contracts/api/ticketing.md +++ b/docs/contracts/api/ticketing.md @@ -100,6 +100,35 @@ Content-Type: application/json | 409 | `IDEMPOTENCY_KEY_CONFLICT` | 같은 키로 다른 회차·좌석 요청 | | 409 | `SEAT_LOCK_TIMEOUT` | 잠금·생성 경합 등의 최대 3회 시도 소진. 같은 키로 재요청 가능 | +## 선점 취소 + +`DELETE /api/ticket-reservations/{reservationId}`는 로그인 필수이며 회원 ID는 `@LoginMember`로 받는다. +요청 본문과 Idempotency-Key는 필요하지 않다. 본인의 결제 전 HELD 예약 전체를 반환하며 일부 좌석만 취소하지 않는다. +성공은 본문 없는 `204 No Content`다. + +```http +DELETE /api/ticket-reservations/5001 +Authorization: Bearer +``` + +- 구매 관리 행 → 예약 → 판매 좌석 ID 오름차순으로 잠그고 소유자·상태·현재 선점 포인터를 재검증한다. +- 예약과 선점 이력은 RELEASED, 좌석은 AVAILABLE/current_hold_id=NULL로 변경하고 reserved_count를 반환 좌석 수만큼 줄인다. confirmed_count는 변경하지 않는다. +- 변경은 모두 같은 트랜잭션에서 커밋하거나 롤백하며 이력·최초 기한·요청 키는 보존한다. +- 본인의 이미 RELEASED인 예약에 반복 요청하면 204로 응답하며 좌석·수량을 다시 변경하지 않는다. 만료 처리와 경합해도 반환은 한 번만 반영한다. +- 만료 시각이 지난 결제 전 HELD도 취소 가능하다. PAYMENT_PENDING/RECONCILING/CONFIRMED 및 환불 상태는 이 API로 반환하지 않는다. +- HELD라도 주문 ID·결제 진입 시각·결제 기한이 있으면 취소하지 않는다. 결제·환불 취소 흐름은 별도 구현 대상이다. + +| HTTP | 코드 | 조건 | +|---|---|---| +| 400 | `INVALID_REQUEST` | 유효하지 않은 예약 ID | +| 401 | `UNAUTHORIZED` | 인증 실패 | +| 404 | `NOT_FOUND` | 없는 예약 또는 타인의 예약 | +| 409 | `RESERVATION_CANNOT_CANCEL` | 결제 전 HELD/반환 완료 RELEASED 이외 상태 또는 결제 관련 필드 존재 | +| 409 | `SEAT_LOCK_TIMEOUT` | 잠금 경합으로 최대 3회 시도 소진 | + +좌석 소유 포인터·이력·카운터가 불일치하면 전체 롤백하며 서버 오류로 남긴다. 다른 소유자의 좌석을 강제로 반환하거나 수량을 임의 보정하지 않는다. +TicketReservationServiceTest에 본인·타인 취소, 중복 취소의 수량 보존, 결제 진행·결과 확인 중 취소 거절 테스트를 작성했으며 아직 실행하지 않았다. + ## 오류 코드 | 코드 | 의미 | @@ -112,6 +141,7 @@ Content-Type: application/json | `BOOKING_CLOSED` | 예매 마감 | | `IDEMPOTENCY_KEY_CONFLICT` | 같은 키로 다른 요청 | | `SEAT_LOCK_TIMEOUT` | 잠금 대기 초과 | +| `RESERVATION_CANNOT_CANCEL` | 결제 전 선점 취소 불가 | 위 선점 API 외 후속 API의 오류 HTTP 상태 코드는 해당 API 구현 시 정한다. diff --git a/docs/domains/ticketing/idempotency.md b/docs/domains/ticketing/idempotency.md index 87e5a311..459afc21 100644 --- a/docs/domains/ticketing/idempotency.md +++ b/docs/domains/ticketing/idempotency.md @@ -318,7 +318,7 @@ HAVING COUNT(*) > 1; ### 구현 시작 조건 핵심 선점 정책·DB 제약·구매 제한·재요청 처리 방향은 확정되어 좌석 선점 구현을 시작할 수 있다. -엔티티 매핑과 좌석 조회, 최초 선점 POST·결제 전 HELD 만료 처리를 구현했다. checkout·결제·취소·환불 API는 후속 범위다. +엔티티 매핑과 좌석 조회, 최초 선점 POST·결제 전 HELD 만료·본인 선점 취소 DELETE를 구현했다. 취소는 별도 요청 키 없이 예약 잠금과 RELEASED 상태로 중복 반환을 막는다. checkout·결제·결제 이후 취소·환불 API는 후속 범위다. 회차 조회는 concert 모듈의 application 계약으로 제공하여 ticketing이 concert Repository를 직접 참조하지 않게 한다. 좌석 배열 검증·정규화는 위 MVP 계약, HTTP 오류 매핑은 [API 계약](../../contracts/api/ticketing.md)을 따른다. 선점·만료는 각각 READ_COMMITTED의 새 트랜잭션으로 실행하며, 구매 관리 행 생성과 사용자별 키 UNIQUE 충돌·교착·잠금 대기 실패는 전체 롤백 후 최대 3회 시도한다. diff --git a/docs/domains/ticketing/purchase-limit.md b/docs/domains/ticketing/purchase-limit.md index 17ed04d8..ae29322e 100644 --- a/docs/domains/ticketing/purchase-limit.md +++ b/docs/domains/ticketing/purchase-limit.md @@ -3,7 +3,7 @@ # 구매 제한과 사용자·회차별 활성 예약 - 상태: DECIDED (2026-11-12, 담당자 합의). -- 구현 상태: 엔티티 매핑과 최초 선점·결제 전 선점 만료의 구매 관리 행 잠금, 활성 예약·한도 검증, 수량 변경을 구현했다. 결제·취소·환불 경로는 후속 구현 대상이며 이번 동시성 검증은 아직 실행하지 않았다. +- 구현 상태: 엔티티 매핑과 최초 선점·결제 전 선점 만료·본인 선점 취소의 구매 관리 행 잠금, 활성 예약·한도 검증, 수량 변경을 구현했다. 선점 취소도 예약 전체의 reserved_count를 한 번만 감소시키며 confirmed_count는 유지한다. 결제·결제 이후 취소·환불 경로는 후속 구현 대상이며 이번 동시성 검증은 아직 실행하지 않았다. ## 범위와 불변식 diff --git a/docs/domains/ticketing/seat-ownership.md b/docs/domains/ticketing/seat-ownership.md index 08062b34..9e1d154c 100644 --- a/docs/domains/ticketing/seat-ownership.md +++ b/docs/domains/ticketing/seat-ownership.md @@ -12,7 +12,9 @@ 예약·선점 이력·HELD/현재 선점 포인터·reserved_count를 한 트랜잭션에 반영한다. DB UTC 시각 기준 선점 기한은 5분이며 재요청으로 연장하지 않는다. 결제 전 HELD 만료 반환도 같은 잠금 순서를 따른다. 공연·회차의 관리 status 값 집합은 데이터 사전상 미확정이므로 새 허용 상태를 임의로 정의하지 않으며, 관리 상태별 예매 차단은 후속 정책 대상이다. -결제 확정·취소·환불의 소유권 전이는 후속 구현이다. TicketReservationServiceTest에 선점 경쟁·동일 키·구매 한도·결제 전 만료와 결제 상태 보호 검증을 작성했으며 아직 실행하지 않았다. +결제 전 선점 취소 DELETE를 구현했다. @LoginMember의 회원 ID로 본인 예약인지 확인하고 구매 관리 행 → 예약 → 좌석 ID 오름차순 잠금 아래 전체 반환한다. +취소와 만료는 같은 좌석·이력·수량 반환 코드를 사용한다. 취소는 만료 전에도 HELD → RELEASED로 전이하며, 이미 RELEASED이면 다시 변경하지 않는다. +결제 확정·결제 이후 취소·환불의 소유권 전이는 후속 구현이다. TicketReservationServiceTest에 선점 경쟁·동일 키·구매 한도·결제 전 만료와 결제 상태 보호 검증을 작성했으며 아직 실행하지 않았다. TicketReservationServiceTest에 본인·타인 취소, 중복 취소의 수량 보존, 결제 진행·결과 확인 중 취소 거절 테스트를 작성했으며 아직 실행하지 않았다. ## 1. 소유권의 기준 From 821328e2dbfe01f96718c24a8cd4937b74970819 Mon Sep 17 00:00:00 2001 From: songfox00 Date: Wed, 18 Nov 2026 14:09:52 +0900 Subject: [PATCH 4/4] =?UTF-8?q?feat:=20=EC=84=A0=EC=A0=90=20=EA=B0=80?= =?UTF-8?q?=EB=8A=A5=20=EC=A2=8C=EC=84=9D=20=ED=91=9C=EC=8B=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ticketing/api/TicketSeatController.java | 9 +++++++ .../TicketReservationQueryService.java | 17 +++++++++++++ .../dto/TicketBookingAvailability.java | 5 ++++ .../TicketPurchaseLimitRepository.java | 2 ++ .../TicketReservationServiceTest.java | 24 +++++++++++++++++++ docs/contracts/api/ticketing.md | 6 +++++ 6 files changed, 63 insertions(+) create mode 100644 backend/src/main/java/com/restless/ticketing/application/dto/TicketBookingAvailability.java diff --git a/backend/src/main/java/com/restless/ticketing/api/TicketSeatController.java b/backend/src/main/java/com/restless/ticketing/api/TicketSeatController.java index 51697736..5dee908d 100644 --- a/backend/src/main/java/com/restless/ticketing/api/TicketSeatController.java +++ b/backend/src/main/java/com/restless/ticketing/api/TicketSeatController.java @@ -2,6 +2,9 @@ import com.restless.ticketing.application.dto.TicketSeatInfo; import com.restless.ticketing.application.TicketSeatQueryService; +import com.restless.ticketing.application.TicketReservationQueryService; +import com.restless.ticketing.application.dto.TicketBookingAvailability; +import com.restless.auth.LoginMember; import lombok.RequiredArgsConstructor; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; @@ -16,6 +19,12 @@ public class TicketSeatController { private final TicketSeatQueryService ticketSeatQueryService; + private final TicketReservationQueryService reservationQueries; + + @GetMapping("/{performanceId}/booking-availability") + public TicketBookingAvailability availability(@LoginMember Long userId, @PathVariable Long performanceId) { + return reservationQueries.getAvailability(userId, performanceId); + } @GetMapping("/{performanceId}/seats") public List getSeats(@PathVariable("performanceId") Long performanceId) { diff --git a/backend/src/main/java/com/restless/ticketing/application/TicketReservationQueryService.java b/backend/src/main/java/com/restless/ticketing/application/TicketReservationQueryService.java index 9958ba8d..53afd60c 100644 --- a/backend/src/main/java/com/restless/ticketing/application/TicketReservationQueryService.java +++ b/backend/src/main/java/com/restless/ticketing/application/TicketReservationQueryService.java @@ -8,6 +8,9 @@ import com.restless.ticketing.domain.TicketReservationStatus; import com.restless.ticketing.infrastructure.SeatHoldRepository; import com.restless.ticketing.infrastructure.TicketReservationRepository; +import com.restless.ticketing.infrastructure.TicketPurchaseLimitRepository; +import com.restless.concert.application.ConcertQueryService; +import com.restless.ticketing.application.dto.TicketBookingAvailability; import java.time.Instant; import java.time.LocalDateTime; import java.time.ZoneOffset; @@ -32,6 +35,20 @@ public class TicketReservationQueryService { private final TicketReservationRepository ticketReservationRepository; private final SeatHoldRepository seatHoldRepository; private final JdbcTemplate jdbc; + private final TicketPurchaseLimitRepository purchaseLimits; + private final ConcertQueryService concerts; + + public TicketBookingAvailability getAvailability(Long userId, Long performanceId) { + validateUser(userId); + if (performanceId == null || performanceId <= 0) throw new BusinessException(ErrorCode.INVALID_REQUEST); + int maximum = concerts.getBookingPerformance(performanceId).maxTicketsPerUser(); + var limit = purchaseLimits.findFirstByUserIdAndPerformanceId(userId, performanceId); + int confirmed = limit.map(com.restless.ticketing.domain.TicketPurchaseLimit::getConfirmedCount).orElse(0); + int reserved = limit.map(com.restless.ticketing.domain.TicketPurchaseLimit::getReservedCount).orElse(0); + var active = getActive(userId).stream().filter(r -> r.performanceId().equals(performanceId)).findFirst().orElse(null); + return new TicketBookingAvailability(maximum, confirmed, reserved, + Math.max(0, maximum - confirmed - reserved), active); + } public TicketReservationDetail getDetail(Long userId, Long reservationId) { validateUser(userId); diff --git a/backend/src/main/java/com/restless/ticketing/application/dto/TicketBookingAvailability.java b/backend/src/main/java/com/restless/ticketing/application/dto/TicketBookingAvailability.java new file mode 100644 index 00000000..4f09b493 --- /dev/null +++ b/backend/src/main/java/com/restless/ticketing/application/dto/TicketBookingAvailability.java @@ -0,0 +1,5 @@ +package com.restless.ticketing.application.dto; + +/** 조회 시점의 한도와 활성 예약. 선점 시에는 서버가 다시 검증한다. */ +public record TicketBookingAvailability(int maximum, int confirmed, int reserved, int remaining, + TicketReservationDetail activeReservation) { } diff --git a/backend/src/main/java/com/restless/ticketing/infrastructure/TicketPurchaseLimitRepository.java b/backend/src/main/java/com/restless/ticketing/infrastructure/TicketPurchaseLimitRepository.java index 3933f263..bcd72490 100644 --- a/backend/src/main/java/com/restless/ticketing/infrastructure/TicketPurchaseLimitRepository.java +++ b/backend/src/main/java/com/restless/ticketing/infrastructure/TicketPurchaseLimitRepository.java @@ -10,4 +10,6 @@ public interface TicketPurchaseLimitRepository extends JpaRepository findByUserIdAndPerformanceId(Long userId, Long performanceId); + + Optional findFirstByUserIdAndPerformanceId(Long userId, Long performanceId); } diff --git a/backend/src/test/java/com/restless/ticketing/application/TicketReservationServiceTest.java b/backend/src/test/java/com/restless/ticketing/application/TicketReservationServiceTest.java index 7784c799..e5107338 100644 --- a/backend/src/test/java/com/restless/ticketing/application/TicketReservationServiceTest.java +++ b/backend/src/test/java/com/restless/ticketing/application/TicketReservationServiceTest.java @@ -262,6 +262,30 @@ void expiredReservationReleasesAllSeatsWithoutRecreationOrReleasingNewOwner() { assertStoredReservation(next, 1); } + @Test + @DisplayName("회차별 구매 한도는 본인 확정·선점 수량과 활성 예약을 조회한다") + void bookingAvailabilityShowsOwnCountsAndActiveReservation() throws Exception { + String path = "/api/performances/{id}/booking-availability"; + mockMvc.perform(get(path, fixture.performanceId())).andExpect(status().isUnauthorized()); + mockMvc.perform(get(path, fixture.performanceId()).with(jwt().jwt(t -> t.subject(fixture.firstUserId().toString())))) + .andExpect(status().isOk()).andExpect(jsonPath("$.maximum").value(3)) + .andExpect(jsonPath("$.remaining").value(3)).andExpect(jsonPath("$.activeReservation").doesNotExist()); + jdbc.update("INSERT INTO ticket_purchase_limits (user_id, performance_id, reserved_count, confirmed_count) VALUES (?, ?, 0, 2)", fixture.firstUserId(), fixture.performanceId()); + mockMvc.perform(get(path, fixture.performanceId()).with(jwt().jwt(t -> t.subject(fixture.firstUserId().toString())))) + .andExpect(status().isOk()).andExpect(jsonPath("$.confirmed").value(2)) + .andExpect(jsonPath("$.remaining").value(1)).andExpect(jsonPath("$.activeReservation").doesNotExist()); + TicketReservationInfo own = reserve(fixture.firstUserId(), "availability", List.of(seat(0))); + mockMvc.perform(get(path, fixture.performanceId()).with(jwt().jwt(t -> t.subject(fixture.firstUserId().toString())))) + .andExpect(status().isOk()).andExpect(jsonPath("$.confirmed").value(2)) + .andExpect(jsonPath("$.reserved").value(1)).andExpect(jsonPath("$.remaining").value(0)) + .andExpect(jsonPath("$.activeReservation.reservationId").value(own.reservationId())); + mockMvc.perform(get(path, fixture.performanceId()).with(jwt().jwt(t -> t.subject(fixture.secondUserId().toString())))) + .andExpect(status().isOk()).andExpect(jsonPath("$.remaining").value(3)) + .andExpect(jsonPath("$.activeReservation").doesNotExist()); + mockMvc.perform(get(path, Long.MAX_VALUE).with(jwt().jwt(t -> t.subject(fixture.firstUserId().toString())))) + .andExpect(status().isNotFound()); + } + @ParameterizedTest(name = "{displayName} [{0}]") @EnumSource(value = TicketReservationStatus.class, names = {"HELD", "PAYMENT_PENDING", "RECONCILING"}) @DisplayName("기한 전 HELD와 결제 진행·결과 확인 중 예약은 최초 선점 기한만으로 반환하지 않는다") diff --git a/docs/contracts/api/ticketing.md b/docs/contracts/api/ticketing.md index a7c14382..19687cf1 100644 --- a/docs/contracts/api/ticketing.md +++ b/docs/contracts/api/ticketing.md @@ -171,6 +171,12 @@ Long으로 변환할 수 없는 performanceId는 `400 INVALID_REQUEST`로 응답 ## 좌석 선점 +### 본인 회차별 구매 한도 조회 + +`GET /api/performances/{performanceId}/booking-availability`는 로그인 회원의 해당 회차 구매 현황을 반환한다. `maximum`은 회차당 한도, `confirmed`는 확정 수량, `reserved`는 선점 수량, `remaining`은 `max(0, maximum - confirmed - reserved)`이다. `activeReservation`은 해당 회차의 HELD·PAYMENT_PENDING·RECONCILING 본인 예약 상세 또는 null이다. 예약이 없는 최초 사용자도 수량 0으로 조회하며, 타인의 수량은 공개하지 않는다. 회차가 없으면 404, 비로그인은 401이다. + +조회 결과는 조회 시점의 안내이며 좌석을 확보하지 않는다. 다른 요청이 수량을 변경할 수 있으므로 실제 선점 시 서버는 기존 구매 관리 행 잠금 아래 한도와 활성 예약을 다시 확인한다. HELD는 기존 checkout 또는 취소로 이어가며, PAYMENT_PENDING·RECONCILING은 결제 확인으로 안내한다. 결제 진행 후에는 선점 취소 API를 사용할 수 없다. + 로그인 필수다. 회원 ID는 본문에서 받지 않고 `@LoginMember`로 인증된 토큰에서 추출한다. `performanceId`와 `seatIds`는 양수여야 하며 좌석 목록은 비어 있거나 중복될 수 없다. `seatIds`는 물리 좌석 ID가 아닌 조회 응답의 판매 좌석 `seatId`다.