🎭 라이브 연극 티켓 통합 예매 플랫폼 - 다중 극장 & 공연 실시간 좌석 예약

mkdir theater-multi-venue-booking-platform && cd theater-multi-venue-booking-platform

이 폴더에서 프로젝트를 시작합니다.

Laravel 13.x 프로젝트를 생성하고 기본 설정을 완료하세요.

```bash
composer create-project laravel/laravel .
php artisan key:generate
```

.env 파일 설정:
- DB_CONNECTION=mysql (또는 pgsql)
- DB_DATABASE=theater_booking
- CACHE_DRIVER=redis
- QUEUE_CONNECTION=database
- MAIL_MAILER=smtp (개발 중에는 log로 설정 가능)

Tailwind CSS 4.x 설치:
```bash
npm install -D tailwindcss@latest postcss autoprefixer
npx tailwindcss init -p
```

tailwind.config.js 설정:
```javascript
module.exports = {
  content: [
    './resources/**/*.blade.php',
    './resources/**/*.js',
  ],
  theme: { extend: {} },
  plugins: [],
}
```

resources/css/app.css:
```css
@tailwind base;
@tailwind components;
@tailwind utilities;
```

Alpine.js CDN 추가 (resources/views/layouts/app.blade.php):
```html
<script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3.x.x/dist/cdn.min.js"></script>
```

마이그레이션 실행:
```bash
php artisan migrate
php artisan queue:table
php artisan migrate
```

Redis 설치 확인 (로컬 환경):
```bash
redis-cli ping  # PONG 응답 확인
```

데이터베이스 스키마를 설계하고 마이그레이션 파일을 생성하세요.

필요한 테이블:

1. venues (극장)
   - id, name, address, city, seat_map_image, created_at, updated_at

2. shows (공연)
   - id, title, description, genre, runtime_minutes, age_rating, poster_image, created_at, updated_at

3. showtimes (회차)
   - id, show_id (FK), venue_id (FK), show_date, show_time, total_seats, available_seats, created_at, updated_at
   - 인덱스: show_id, venue_id, show_date

4. seats (좌석)
   - id, showtime_id (FK), section (VIP/R/S/A), row, number, price, status (available/pending/booked), locked_at (타임아웃 체크용), locked_by_session, created_at, updated_at
   - 인덱스: showtime_id, status
   - 유니크 제약: showtime_id + section + row + number

5. bookings (예약)
   - id, user_id (FK, nullable), showtime_id (FK), seat_ids (JSON), booker_name, booker_email, booker_phone, total_price, status (pending/confirmed/cancelled), payment_method, booking_number (unique), qr_code, created_at, updated_at
   - 인덱스: booking_number, user_id, showtime_id

6. actors (배우) - 보너스
   - id, name, bio, photo, created_at, updated_at

7. actor_show (피벗 테이블) - 보너스
   - id, show_id, actor_id

마이그레이션 생성 명령:
```bash
php artisan make:migration create_venues_table
php artisan make:migration create_shows_table
php artisan make:migration create_showtimes_table
php artisan make:migration create_seats_table
php artisan make:migration create_bookings_table
php artisan make:migration create_actors_table
php artisan make:migration create_actor_show_table
```

각 마이그레이션 파일에 스키마 정의 후 실행:
```bash
php artisan migrate
```

Eloquent 모델을 생성하고 관계를 정의하세요.

```bash
php artisan make:model Venue
php artisan make:model Show
php artisan make:model Showtime
php artisan make:model Seat
php artisan make:model Booking
php artisan make:model Actor
```

각 모델에 관계 정의:

**Venue 모델**:
- hasMany(Showtime::class)

**Show 모델**:
- hasMany(Showtime::class)
- belongsToMany(Actor::class) (보너스)

**Showtime 모델**:
- belongsTo(Show::class)
- belongsTo(Venue::class)
- hasMany(Seat::class)
- hasMany(Booking::class)

**Seat 모델**:
- belongsTo(Showtime::class)
- $casts = ['locked_at' => 'datetime'];
- 스코프 추가:
  - scopeAvailable($query): status가 'available'인 좌석
  - scopeExpiredLocks($query): locked_at이 5분 이상 지난 pending 좌석

**Booking 모델**:
- belongsTo(User::class, 'user_id')->nullable()
- belongsTo(Showtime::class)
- $casts = ['seat_ids' => 'array'];

**Actor 모델** (보너스):
- belongsToMany(Show::class)

$fillable 속성을 각 모델에 추가하여 대량 할당 허용.

Seeder와 Factory를 생성하여 더미 데이터를 만드세요.

```bash
php artisan make:factory VenueFactory
php artisan make:factory ShowFactory
php artisan make:factory ShowtimeFactory
php artisan make:factory SeatFactory
php artisan make:seeder DatabaseSeeder
```

**VenueFactory**: 극장 5개 생성 (name, address, city)
**ShowFactory**: 공연 20개 생성 (title, description, genre, runtime_minutes, age_rating)
**ShowtimeFactory**: 각 공연당 3~5개 회차 생성 (show_date는 향후 30일 내 랜덤)
**SeatFactory**: 각 회차당 좌석 100석 생성
  - section: VIP(10석), R(30석), S(30석), A(30석)
  - row: A~J (랜덤)
  - number: 1~10 (랜덤)
  - price: VIP(100000), R(80000), S(60000), A(40000)
  - status: 'available'

**DatabaseSeeder**:
```php
Venue::factory(5)->create()->each(function ($venue) {
    Show::factory(4)->create()->each(function ($show) use ($venue) {
        Showtime::factory(3)->create([
            'show_id' => $show->id,
            'venue_id' => $venue->id,
        ])->each(function ($showtime) {
            Seat::factory(100)->create(['showtime_id' => $showtime->id]);
        });
    });
});
```

실행:
```bash
php artisan db:seed
```

사용자 공연 목록 페이지를 구현하세요.

**라우트 (routes/web.php)**:
```php
Route::get('/', [ShowController::class, 'index'])->name('home');
Route::get('/shows', [ShowController::class, 'index'])->name('shows.index');
Route::get('/shows/{show}', [ShowController::class, 'show'])->name('shows.show');
```

**ShowController**:
```bash
php artisan make:controller ShowController
```

index() 메서드:
- 공연 목록 조회 (페이지네이션 12개씩)
- 필터링: 장르(genre), 날짜 범위(date_from, date_to), 극장(venue_id)
- 캐싱: Redis에 5분간 캐시
```php
$shows = Cache::remember('shows_list', 300, function () {
    return Show::with('showtimes.venue')->paginate(12);
});
```

show() 메서드:
- 특정 공연 상세 정보
- 회차 목록 (향후 날짜만, 날짜순 정렬)
- Eager Loading으로 N+1 쿼리 방지
```php
$show = Show::with(['showtimes' => function ($query) {
    $query->where('show_date', '>=', now())
          ->orderBy('show_date')
          ->orderBy('show_time')
          ->with('venue');
}])->findOrFail($id);
```

**Blade 뷰 (resources/views/shows/index.blade.php)**:
- Tailwind CSS 그리드 레이아웃 (grid grid-cols-1 md:grid-cols-3 lg:grid-cols-4 gap-6)
- 공연 카드: 포스터 이미지, 제목, 장르, 러닝타임
- 필터 폼: 장르 셀렉트, 날짜 범위 input, 극장 셀렉트
- 페이지네이션 ({{ $shows->links() }})

**Blade 뷰 (resources/views/shows/show.blade.php)**:
- 공연 상세 정보: 포스터, 제목, 설명, 장르, 러닝타임, 연령제한
- 회차 목록: 날짜, 시간, 극장명, 잔여석, [예약하기] 버튼
- [예약하기] 버튼 클릭 시 좌석 선택 페이지로 이동 (route('showtimes.seats', $showtime->id))

좌석 선택 페이지를 구현하세요.

**라우트**:
```php
Route::get('/showtimes/{showtime}/seats', [BookingController::class, 'selectSeats'])->name('showtimes.seats');
Route::post('/showtimes/{showtime}/lock-seats', [BookingController::class, 'lockSeats'])->name('showtimes.lock');
```

**BookingController**:
```bash
php artisan make:controller BookingController
```

selectSeats() 메서드:
- 회차 정보 조회 (with show, venue)
- 좌석 목록 조회 (section별 그룹화)
```php
$showtime = Showtime::with('show', 'venue')->findOrFail($id);
$seats = Seat::where('showtime_id', $showtime->id)
             ->orderBy('section')
             ->orderBy('row')
             ->orderBy('number')
             ->get()
             ->groupBy('section');
```

**Blade 뷰 (resources/views/bookings/select-seats.blade.php)**:
- 회차 정보 표시: 공연명, 날짜, 시간, 극장명
- 좌석 배치도 (section별 그리드)
  - VIP/R/S/A 구역별로 div 분리
  - 좌석 버튼: Alpine.js로 선택 토글
  ```html
  <div x-data="{ selectedSeats: [] }">
    @foreach($seats as $section => $sectionSeats)
      <div class="mb-8">
        <h3 class="text-lg font-bold mb-2">{{ $section }}석</h3>
        <div class="grid grid-cols-10 gap-2">
          @foreach($sectionSeats as $seat)
            <button
              @click="toggleSeat({{ $seat->id }})"
              :class="{
                'bg-gray-300': '{{ $seat->status }}' === 'booked',
                'bg-yellow-300': '{{ $seat->status }}' === 'pending',
                'bg-green-500': selectedSeats.includes({{ $seat->id }}),
                'bg-blue-500': '{{ $seat->status }}' === 'available' && !selectedSeats.includes({{ $seat->id }})
              }"
              :disabled="'{{ $seat->status }}' !== 'available'"
              class="w-10 h-10 rounded text-xs font-semibold"
            >
              {{ $seat->row }}{{ $seat->number }}
            </button>
          @endforeach
        </div>
      </div>
    @endforeach
    <button @click="lockSeats()" class="mt-4 bg-purple-600 text-white px-6 py-3 rounded">선택 완료</button>
  </div>
  ```
- Alpine.js 메서드:
  - toggleSeat(seatId): selectedSeats 배열에 추가/제거
  - lockSeats(): AJAX로 POST /showtimes/{showtime}/lock-seats (선택한 좌석 ID 전송)

lockSeats() 메서드 (BookingController):
- 선택한 좌석들의 status를 'pending'으로 변경
- locked_at = now(), locked_by_session = session()->getId()
- DB 트랜잭션 사용
- 중복 예약 방지: 낙관적 잠금 (whereIn + where status = 'available')
```php
DB::transaction(function () use ($seatIds, $sessionId) {
    $updated = Seat::whereIn('id', $seatIds)
                   ->where('status', 'available')
                   ->update([
                       'status' => 'pending',
                       'locked_at' => now(),
                       'locked_by_session' => $sessionId,
                   ]);
    if ($updated !== count($seatIds)) {
        throw new \Exception('일부 좌석이 이미 예약되었습니다.');
    }
});
```
- 성공 시 예약 정보 입력 페이지로 리다이렉트 (route('bookings.create', ['showtime' => $showtime->id, 'seats' => implode(',', $seatIds)]))

예약 정보 입력 및 확정 페이지를 구현하세요.

**라우트**:
```php
Route::get('/bookings/create', [BookingController::class, 'create'])->name('bookings.create');
Route::post('/bookings', [BookingController::class, 'store'])->name('bookings.store');
Route::get('/bookings/{booking}', [BookingController::class, 'show'])->name('bookings.show');
```

create() 메서드:
- 쿼리 파라미터로 showtime_id, seats (콤마 구분 좌석 ID) 받기
- 좌석 정보 조회 (locked_by_session이 현재 세션인지 확인)
```php
$seatIds = explode(',', request('seats'));
$seats = Seat::whereIn('id', $seatIds)
             ->where('locked_by_session', session()->getId())
             ->where('status', 'pending')
             ->get();
if ($seats->count() !== count($seatIds)) {
    return redirect()->route('shows.index')->with('error', '좌석 선택이 만료되었습니다.');
}
```
- 총 금액 계산: $totalPrice = $seats->sum('price');

**Blade 뷰 (resources/views/bookings/create.blade.php)**:
- 회차 정보, 선택한 좌석 목록, 총 금액 표시
- 예약자 정보 폼: 이름, 이메일, 전화번호, 결제 방법 (카드/계좌이체/현장결제)
- 5분 타이머 표시 (Alpine.js)
  ```html
  <div x-data="{ timeLeft: 300 }" x-init="setInterval(() => { timeLeft--; if (timeLeft <= 0) alert('시간 초과! 다시 선택해주세요.'); }, 1000)">
    <p>남은 시간: <span x-text="Math.floor(timeLeft / 60)"></span>:<span x-text="(timeLeft % 60).toString().padStart(2, '0')"></span></p>
  </div>
  ```
- [예약 확정] 버튼

store() 메서드:
- Form Request Validation 생성
```bash
php artisan make:request StoreBookingRequest
```
StoreBookingRequest:
```php
public function rules() {
    return [
        'booker_name' => 'required|string|max:100',
        'booker_email' => 'required|email',
        'booker_phone' => 'required|string|max:20',
        'payment_method' => 'required|in:card,bank_transfer,on_site',
        'seat_ids' => 'required|array',
    ];
}
```
- DB 트랜잭션으로 예약 생성
```php
$booking = DB::transaction(function () use ($validated, $showtimeId) {
    // 좌석 상태를 'booked'로 변경
    Seat::whereIn('id', $validated['seat_ids'])
        ->where('status', 'pending')
        ->where('locked_by_session', session()->getId())
        ->update(['status' => 'booked']);
    
    // 예약 생성
    $booking = Booking::create([
        'showtime_id' => $showtimeId,
        'seat_ids' => $validated['seat_ids'],
        'booker_name' => $validated['booker_name'],
        'booker_email' => $validated['booker_email'],
        'booker_phone' => $validated['booker_phone'],
        'total_price' => Seat::whereIn('id', $validated['seat_ids'])->sum('price'),
        'status' => 'confirmed',
        'payment_method' => $validated['payment_method'],
        'booking_number' => 'BK' . strtoupper(Str::random(10)),
    ]);
    
    return $booking;
});
```
- QR 코드 생성 (SimpleSoftwareIO/simple-qrcode 패키지)
```bash
composer require simplesoftwareio/simple-qrcode
```
```php
$qrCode = QrCode::size(200)->generate(route('bookings.show', $booking->id));
$booking->update(['qr_code' => $qrCode]);
```
- 예약 확인 이메일 발송 (Queue로 비동기 처리)
```bash
php artisan make:mail BookingConfirmationMail --markdown=emails.booking-confirmation
```
```php
Mail::to($booking->booker_email)->queue(new BookingConfirmationMail($booking));
```
- 예약 완료 페이지로 리다이렉트 (route('bookings.show', $booking->id))

예약 확인 페이지와 타임아웃 자동 해제 Job을 구현하세요.

**예약 확인 페이지 (BookingController::show)**:
```php
public function show(Booking $booking) {
    $booking->load('showtime.show', 'showtime.venue');
    $seats = Seat::whereIn('id', $booking->seat_ids)->get();
    return view('bookings.show', compact('booking', 'seats'));
}
```

**Blade 뷰 (resources/views/bookings/show.blade.php)**:
- 예약 번호, 예약자 정보, 공연 정보, 회차, 극장, 좌석 목록, 총 금액
- QR 코드 이미지 표시
```html
<div class="text-center">
  {!! $booking->qr_code !!}
  <p class="mt-2 text-sm text-gray-600">입장 시 QR 코드를 제시해주세요.</p>
</div>
```
- [예약 취소] 버튼 (선택 기능)

**타임아웃 자동 해제 Job 생성**:
```bash
php artisan make:job ReleasePendingSeatsJob
```

ReleasePendingSeatsJob:
```php
public function handle() {
    Seat::where('status', 'pending')
        ->where('locked_at', '<', now()->subMinutes(5))
        ->update([
            'status' => 'available',
            'locked_at' => null,
            'locked_by_session' => null,
        ]);
}
```

**스케줄러 등록 (app/Console/Kernel.php)**:
```php
protected function schedule(Schedule $schedule) {
    $schedule->job(new ReleasePendingSeatsJob)->everyMinute();
}
```

**크론 설정 (로컬 개발 중에는 `php artisan schedule:work` 실행)**:
```bash
php artisan schedule:work
```

또는 워커 실행:
```bash
php artisan queue:work
```

관리자 대시보드를 구현하세요.

**관리자 인증 미들웨어 생성**:
```bash
php artisan make:middleware AdminMiddleware
```

AdminMiddleware:
```php
public function handle($request, Closure $next) {
    if (!auth()->check() || !auth()->user()->is_admin) {
        abort(403, 'Unauthorized');
    }
    return $next($request);
}
```

app/Http/Kernel.php에 등록:
```php
protected $routeMiddleware = [
    'admin' => \App\Http\Middleware\AdminMiddleware::class,
];
```

users 테이블에 is_admin 컬럼 추가 마이그레이션:
```bash
php artisan make:migration add_is_admin_to_users_table
```
```php
Schema::table('users', function (Blueprint $table) {
    $table->boolean('is_admin')->default(false);
});
```

**관리자 라우트 (routes/web.php)**:
```php
Route::prefix('admin')->middleware(['auth', 'admin'])->group(function () {
    Route::get('/dashboard', [AdminController::class, 'dashboard'])->name('admin.dashboard');
    Route::resource('venues', VenueController::class);
    Route::resource('shows', AdminShowController::class);
    Route::resource('showtimes', ShowtimeController::class);
    Route::get('/bookings', [AdminBookingController::class, 'index'])->name('admin.bookings.index');
    Route::delete('/bookings/{booking}', [AdminBookingController::class, 'destroy'])->name('admin.bookings.destroy');
});
```

**AdminController::dashboard**:
```bash
php artisan make:controller Admin/AdminController
```

```php
public function dashboard() {
    $totalBookings = Booking::where('status', 'confirmed')->count();
    $totalRevenue = Booking::where('status', 'confirmed')->sum('total_price');
    $upcomingShowtimes = Showtime::where('show_date', '>=', now())->count();
    $recentBookings = Booking::with('showtime.show')->latest()->take(10)->get();
    
    // 일별 매출 차트 데이터 (최근 7일)
    $dailyRevenue = Booking::where('status', 'confirmed')
        ->where('created_at', '>=', now()->subDays(7))
        ->selectRaw('DATE(created_at) as date, SUM(total_price) as revenue')
        ->groupBy('date')
        ->orderBy('date')
        ->get();
    
    return view('admin.dashboard', compact('totalBookings', 'totalRevenue', 'upcomingShowtimes', 'recentBookings', 'dailyRevenue'));
}
```

**Blade 뷰 (resources/views/admin/dashboard.blade.php)**:
- 통계 카드: 총 예약 수, 총 매출, 예정된 회차 수
- 최근 예약 목록 (테이블)
- 일별 매출 차트 (Chart.js)
```html
<canvas id="revenueChart"></canvas>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script>
const ctx = document.getElementById('revenueChart').getContext('2d');
const chart = new Chart(ctx, {
    type: 'line',
    data: {
        labels: @json($dailyRevenue->pluck('date')),
        datasets: [{
            label: '일별 매출',
            data: @json($dailyRevenue->pluck('revenue')),
            borderColor: 'rgb(75, 192, 192)',
            tension: 0.1
        }]
    }
});
</script>
```

**극장/공연/회차 CRUD 컨트롤러 생성**:
```bash
php artisan make:controller Admin/VenueController --resource
php artisan make:controller Admin/AdminShowController --resource
php artisan make:controller Admin/ShowtimeController --resource
php artisan make:controller Admin/AdminBookingController
```

각 컨트롤러에 CRUD 메서드 구현 (index, create, store, edit, update, destroy).

Blade 뷰는 Tailwind CSS로 폼 스타일링.

성능 최적화 및 보너스 기능을 추가하세요.

**1. 캐싱 최적화**:
- 공연 목록 캐싱 (이미 구현)
- 회차별 좌석 상태 캐싱 (Redis)
```php
$seats = Cache::remember("seats_showtime_{$showtimeId}", 60, function () use ($showtimeId) {
    return Seat::where('showtime_id', $showtimeId)->get();
});
```
- 좌석 상태 변경 시 캐시 무효화
```php
Cache::forget("seats_showtime_{$showtimeId}");
```

**2. 인덱스 최적화**:
- 자주 조회되는 컬럼에 인덱스 추가 (이미 마이그레이션에 포함)
- Explain 쿼리로 성능 확인

**3. Eager Loading**:
- N+1 쿼리 방지 (이미 구현)

**4. 엑셀 다운로드 기능**:
```bash
composer require maatwebsite/excel
```

예약 내역 Export:
```bash
php artisan make:export BookingsExport --model=Booking
```

BookingsExport:
```php
public function collection() {
    return Booking::with('showtime.show')->where('status', 'confirmed')->get();
}
```

관리자 라우트:
```php
Route::get('/admin/bookings/export', [AdminBookingController::class, 'export'])->name('admin.bookings.export');
```

AdminBookingController::export:
```php
public function export() {
    return Excel::download(new BookingsExport, 'bookings.xlsx');
}
```

**5. 공연 리뷰 시스템 (보너스)**:
```bash
php artisan make:migration create_reviews_table
```

reviews 테이블:
- id, booking_id (FK), rating (1~5), comment, created_at, updated_at

Review 모델 생성 및 관계 정의.

공연 상세 페이지에 리뷰 목록 표시.

**6. 알림 시스템 (보너스)**:
```bash
php artisan make:notification ShowOpenNotification
```

공연 오픈 시 구독자에게 알림 발송 (Queue로 처리).

**7. 모바일 반응형 디자인**:
- Tailwind CSS 반응형 클래스 활용 (sm:, md:, lg:)
- 좌석 선택 페이지 모바일 최적화 (작은 화면에서 그리드 조정)

**8. 테스트 작성 (선택)**:
```bash
php artisan make:test BookingTest
```

예약 생성, 좌석 잠금, 타임아웃 해제 등 주요 기능 테스트.