🎭 공연 프로듀서 시즌 관리 플랫폼 - 기획부터 정산까지 올인원 시스템

mkdir theater-season-producer-platform && cd theater-season-producer-platform

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

# 프로젝트 초기 설정

1. Laravel 13.x 프로젝트 생성:
```bash
composer create-project laravel/laravel . "13.*"
```

2. 필수 패키지 설치:
```bash
composer require barryvdh/laravel-dompdf intervention/image predis/predis
npm install alpinejs @tailwindcss/forms @tailwindcss/typography
```

3. Tailwind CSS 설정:
- `tailwind.config.js` 생성 및 content 경로 설정
- `resources/css/app.css`에 Tailwind 디렉티브 추가
- Alpine.js를 `resources/js/app.js`에 임포트

4. `.env` 파일 설정:
```
DB_CONNECTION=sqlite
QUEUE_CONNECTION=redis
REDIS_CLIENT=predis
SESSION_DRIVER=redis
CACHE_DRIVER=redis
```

5. 데이터베이스 마이그레이션 파일 생성:
```bash
php artisan make:migration create_seasons_table
php artisan make:migration create_shows_table
php artisan make:migration create_venues_table
php artisan make:migration create_seats_table
php artisan make:migration create_bookings_table
php artisan make:migration create_performers_table
php artisan make:migration create_contracts_table
php artisan make:migration create_settlements_table
php artisan make:migration create_customers_table
php artisan make:migration create_reviews_table
```

각 마이그레이션 파일에 다음 스키마를 작성하세요:

### seasons 테이블
- id, name, description, start_date, end_date, status (upcoming/ongoing/completed), created_at, updated_at

### shows 테이블
- id, season_id, title, description, genre (musical/play/concert), poster_image, duration_minutes, created_at, updated_at

### venues 테이블
- id, name, address, total_seats, seat_map_svg (좌석 배치도 SVG), created_at, updated_at

### seats 테이블
- id, venue_id, row, number, grade (VIP/R/S/A), price, status (available/occupied/blocked), created_at, updated_at

### bookings 테이블
- id, customer_id, show_id, show_date, show_time, seat_ids (JSON), total_price, payment_status (pending/paid/refunded), payment_method, qr_code, created_at, updated_at

### performers 테이블
- id, name, role (actor/singer/staff), profile_image, bio, contact_email, contact_phone, created_at, updated_at

### contracts 테이블
- id, show_id, performer_id, role_in_show, fee_amount, payment_schedule (JSON), contract_pdf, signed_at, created_at, updated_at

### settlements 테이블
- id, show_id, total_revenue, performer_share, company_share, investor_share, settlement_date, pdf_report, created_at, updated_at

### customers 테이블
- id, name, email, phone, membership_tier (regular/vip/platinum), total_spent, created_at, updated_at

### reviews 테이블
- id, booking_id, customer_id, show_id, rating (1~5), comment, created_at, updated_at

6. 모델 생성:
```bash
php artisan make:model Season
php artisan make:model Show
php artisan make:model Venue
php artisan make:model Seat
php artisan make:model Booking
php artisan make:model Performer
php artisan make:model Contract
php artisan make:model Settlement
php artisan make:model Customer
php artisan make:model Review
```

각 모델에 관계 정의:
- Season hasMany Shows
- Show belongsTo Season, hasMany Bookings, hasMany Contracts, hasMany Reviews
- Venue hasMany Seats
- Booking belongsTo Customer, belongsTo Show, hasOne Review
- Contract belongsTo Show, belongsTo Performer
- Settlement belongsTo Show
- Customer hasMany Bookings, hasMany Reviews
- Review belongsTo Booking, belongsTo Customer, belongsTo Show

7. 마이그레이션 실행:
```bash
php artisan migrate
```

8. Seeder 생성 및 실행:
```bash
php artisan make:seeder SeasonSeeder
php artisan make:seeder ShowSeeder
php artisan make:seeder VenueSeeder
php artisan make:seeder SeatSeeder
php artisan db:seed
```

더미 데이터 예시:
- 시즌 3개 (2024 봄 시즌, 여름 시즌, 가을 시즌)
- 공연 각 시즌당 2~3개
- 공연장 2개 (대극장 500석, 소극장 200석)
- 좌석 자동 생성 (VIP 10%, R석 30%, S석 40%, A석 20%)

프로젝트 구조가 완성되면 다음 단계로 진행하겠습니다.

# 시즌 & 공연 관리 기능 구현

1. 컨트롤러 생성:
```bash
php artisan make:controller SeasonController
php artisan make:controller ShowController
php artisan make:controller VenueController
```

2. `routes/web.php`에 라우트 추가:
```php
Route::get('/', [SeasonController::class, 'index'])->name('home');
Route::resource('seasons', SeasonController::class);
Route::resource('shows', ShowController::class);
Route::resource('venues', VenueController::class);
```

3. `SeasonController`에 다음 메서드 구현:
- index(): 시즌 목록 (카드 그리드, 상태별 필터)
- create(): 시즌 생성 폼
- store(): 시즌 저장
- show($id): 시즌 상세 & 포함된 공연 목록
- edit($id): 시즌 수정 폼
- update($id): 시즌 업데이트
- destroy($id): 시즌 삭제

4. `ShowController`에 다음 메서드 구현:
- index(): 전체 공연 목록 (장르별 필터, 검색)
- create(): 공연 생성 폼 (시즌 선택 드롭다운)
- store(): 공연 저장 + 포스터 이미지 업로드 (intervention/image로 리사이징)
- show($id): 공연 상세 (포스터, 설명, 회차 목록, 출연진)
- edit($id): 공연 수정 폼
- update($id): 공연 업데이트
- destroy($id): 공연 삭제

5. Blade 뷰 파일 생성:

### `resources/views/layouts/app.blade.php`
- 기본 레이아웃 템플릿
- Tailwind CSS + Alpine.js 로드
- 네비게이션 바 (시즌/공연/공연장/출연진/정산 메뉴)
- 푸터

### `resources/views/seasons/index.blade.php`
- 시즌 카드 그리드 (3열)
- 각 카드: 시즌명, 기간, 상태 배지, 포함된 공연 수
- 상태별 필터 버튼 (전체/진행중/예정/종료)
- "새 시즌 추가" 버튼

### `resources/views/seasons/create.blade.php`
- 시즌 생성 폼
- 필드: 시즌명, 설명, 시작일, 종료일
- Tailwind CSS 폼 스타일링

### `resources/views/seasons/show.blade.php`
- 시즌 상세 정보
- 포함된 공연 목록 (카드 형태)
- "공연 추가" 버튼
- 수정/삭제 버튼

### `resources/views/shows/index.blade.php`
- 공연 카드 그리드 (4열)
- 각 카드: 포스터 이미지, 제목, 장르 배지, 공연 기간
- 장르별 필터 (뮤지컬/연극/콘서트)
- 검색 바 (제목 검색)

### `resources/views/shows/create.blade.php`
- 공연 생성 폼
- 필드: 시즌 선택, 제목, 설명, 장르, 포스터 이미지 업로드, 공연 시간(분)
- 이미지 미리보기 (Alpine.js)

### `resources/views/shows/show.blade.php`
- 공연 상세 정보
- 포스터 이미지 (큰 사이즈)
- 공연 설명
- 회차 목록 (날짜/시간별 버튼)
- 출연진 목록 (프로필 카드)
- 리뷰 & 별점 섹션
- "티켓 예매" 버튼

6. 이미지 업로드 처리:
- `ShowController@store`에서 `intervention/image`로 포스터 이미지 리사이징 (800x1200px)
- `storage/app/public/posters` 폴더에 저장
- `php artisan storage:link` 실행하여 심볼릭 링크 생성

7. 폼 Validation:
- `php artisan make:request StoreSeasonRequest`
- `php artisan make:request StoreShowRequest`
- 각 Request 클래스에 validation 규칙 정의

8. UI 개선:
- Tailwind CSS로 모던한 디자인 (그라디언트, 그림자, 호버 효과)
- Alpine.js로 필터/검색 실시간 적용
- 로딩 스피너 (Alpine.js x-show)

모든 기능이 작동하면 다음 단계로 진행하겠습니다.

# 실시간 좌석 예매 시스템 구현

1. 컨트롤러 생성:
```bash
php artisan make:controller BookingController
php artisan make:controller SeatController
```

2. `routes/web.php`에 라우트 추가:
```php
Route::get('/shows/{show}/booking', [BookingController::class, 'create'])->name('booking.create');
Route::post('/shows/{show}/booking', [BookingController::class, 'store'])->name('booking.store');
Route::get('/bookings/{booking}', [BookingController::class, 'show'])->name('booking.show');
Route::delete('/bookings/{booking}', [BookingController::class, 'cancel'])->name('booking.cancel');
Route::get('/api/shows/{show}/seats', [SeatController::class, 'getAvailableSeats']);
Route::post('/api/seats/{seat}/lock', [SeatController::class, 'lockSeat']);
Route::post('/api/seats/{seat}/unlock', [SeatController::class, 'unlockSeat']);
```

3. `BookingController`에 다음 메서드 구현:

### create($showId)
- 공연 정보 로드
- 공연장 좌석 맵 로드 (venue의 seat_map_svg)
- 예매 가능한 좌석 목록 (status='available')
- Blade 뷰에 데이터 전달

### store(Request $request, $showId)
- 선택된 좌석 ID 배열 받기
- Redis로 좌석 잠금 확인 (동시성 제어)
- 고객 정보 입력 또는 로그인
- Booking 레코드 생성 (payment_status='pending')
- 결제 페이지로 리다이렉트 (PortOne/Toss Payments 연동)

### show($bookingId)
- 예매 확인 페이지
- QR 코드 티켓 표시 (SimpleSoftwareIO/simple-qrcode 사용)
- 예매 상세 정보 (공연명, 날짜, 좌석, 결제 금액)

### cancel($bookingId)
- 예매 취소 처리
- 좌석 상태를 'available'로 변경
- 환불 처리 (결제 API 호출)

4. `SeatController`에 다음 메서드 구현:

### getAvailableSeats($showId)
- JSON API: 예매 가능한 좌석 목록 반환
- 좌석 정보 (id, row, number, grade, price, status)

### lockSeat($seatId)
- Redis로 좌석 임시 잠금 (5분 TTL)
- 다른 사용자가 선택 중인 좌석 표시

### unlockSeat($seatId)
- Redis 잠금 해제

5. Blade 뷰 생성:

### `resources/views/bookings/create.blade.php`
- 공연 정보 헤더 (포스터, 제목, 날짜/시간)
- SVG 좌석 맵 (venue의 seat_map_svg 렌더링)
- Alpine.js로 좌석 클릭 선택 구현
- 선택된 좌석 목록 사이드바 (좌석 번호, 등급, 가격)
- 총 결제 금액 표시
- 고객 정보 입력 폼 (이름, 이메일, 전화번호)
- "예매하기" 버튼

Alpine.js 로직:
```javascript
function bookingApp() {
  return {
    selectedSeats: [],
    seats: [],
    async init() {
      const response = await fetch(`/api/shows/${showId}/seats`);
      this.seats = await response.json();
    },
    async selectSeat(seat) {
      if (this.selectedSeats.includes(seat.id)) {
        this.selectedSeats = this.selectedSeats.filter(id => id !== seat.id);
        await fetch(`/api/seats/${seat.id}/unlock`, { method: 'POST' });
      } else {
        const lockResponse = await fetch(`/api/seats/${seat.id}/lock`, { method: 'POST' });
        if (lockResponse.ok) {
          this.selectedSeats.push(seat.id);
        } else {
          alert('이미 다른 사용자가 선택한 좌석입니다.');
        }
      }
    },
    getTotalPrice() {
      return this.selectedSeats.reduce((total, seatId) => {
        const seat = this.seats.find(s => s.id === seatId);
        return total + (seat ? seat.price : 0);
      }, 0);
    }
  }
}
```

### `resources/views/bookings/show.blade.php`
- 예매 완료 메시지
- QR 코드 티켓 (SimpleSoftwareIO/simple-qrcode)
- 예매 정보 (공연명, 날짜, 좌석, 금액)
- "예매 취소" 버튼
- "이메일로 티켓 전송" 버튼

6. Redis 좌석 잠금 로직:
```php
// SeatController@lockSeat
use Illuminate\Support\Facades\Redis;

public function lockSeat($seatId)
{
    $key = "seat_lock:{$seatId}";
    $locked = Redis::set($key, auth()->id() ?? session()->getId(), 'EX', 300, 'NX');
    
    if ($locked) {
        return response()->json(['success' => true]);
    }
    
    return response()->json(['success' => false, 'message' => 'Seat already locked'], 409);
}
```

7. QR 코드 생성:
```bash
composer require simplesoftwareio/simple-qrcode
```

`BookingController@show`에서:
```php
use SimpleSoftwareIO\QrCode\Facades\QrCode;

public function show($bookingId)
{
    $booking = Booking::findOrFail($bookingId);
    $qrCode = QrCode::size(200)->generate(route('booking.verify', $booking->id));
    
    return view('bookings.show', compact('booking', 'qrCode'));
}
```

8. 결제 연동 (PortOne 예시):
```bash
composer require iamport/iamport-rest-client-php
```

`BookingController@store`에서:
```php
use Iamport\RestClient\RestClient;

public function store(Request $request, $showId)
{
    // ... 예매 생성 로직
    
    // PortOne 결제 요청
    $iamport = new RestClient('YOUR_API_KEY', 'YOUR_API_SECRET');
    $paymentData = [
        'merchant_uid' => 'booking_' . $booking->id,
        'amount' => $booking->total_price,
        'buyer_name' => $request->name,
        'buyer_email' => $request->email,
    ];
    
    // 결제 페이지로 리다이렉트
    return view('bookings.payment', compact('booking', 'paymentData'));
}
```

9. 예매 취소 로직:
```php
public function cancel($bookingId)
{
    $booking = Booking::findOrFail($bookingId);
    
    // 좌석 상태 변경
    Seat::whereIn('id', $booking->seat_ids)->update(['status' => 'available']);
    
    // 환불 처리 (결제 API 호출)
    // ...
    
    $booking->update(['payment_status' => 'refunded']);
    
    return redirect()->route('home')->with('success', '예매가 취소되었습니다.');
}
```

모든 기능이 작동하면 다음 단계로 진행하겠습니다.

# 출연진 & 계약 관리 기능 구현

1. 컨트롤러 생성:
```bash
php artisan make:controller PerformerController
php artisan make:controller ContractController
```

2. `routes/web.php`에 라우트 추가:
```php
Route::resource('performers', PerformerController::class);
Route::get('/shows/{show}/contracts/create', [ContractController::class, 'create'])->name('contracts.create');
Route::post('/shows/{show}/contracts', [ContractController::class, 'store'])->name('contracts.store');
Route::get('/contracts/{contract}', [ContractController::class, 'show'])->name('contracts.show');
Route::get('/contracts/{contract}/pdf', [ContractController::class, 'generatePdf'])->name('contracts.pdf');
```

3. `PerformerController`에 다음 메서드 구현:

### index()
- 출연진/스태프 목록 (카드 그리드)
- 역할별 필터 (배우/가수/스태프)
- 검색 기능 (이름)

### create()
- 출연진 등록 폼
- 필드: 이름, 역할, 프로필 이미지, 약력, 연락처(이메일, 전화)

### store()
- 출연진 저장
- 프로필 이미지 업로드 (intervention/image로 리사이징)

### show($id)
- 출연진 상세 정보
- 출연한 공연 목록
- 계약 내역

### edit($id), update($id), destroy($id)
- 수정/삭제 기능

4. `ContractController`에 다음 메서드 구현:

### create($showId)
- 계약서 작성 폼
- 공연 정보 표시
- 출연진 선택 드롭다운
- 필드: 출연진, 공연 내 역할, 출연료, 지급 일정 (JSON: [{date, amount}])

### store(Request $request, $showId)
- 계약 정보 저장
- PDF 계약서 자동 생성 (barryvdh/laravel-dompdf)
- `storage/app/public/contracts` 폴더에 저장

### show($contractId)
- 계약 상세 정보
- PDF 계약서 미리보기
- "전자서명" 버튼
- 지급 일정 타임라인

### generatePdf($contractId)
- PDF 계약서 다운로드
- 계약 내용 템플릿 (공연명, 출연진명, 역할, 출연료, 지급 일정)

5. Blade 뷰 생성:

### `resources/views/performers/index.blade.php`
- 출연진 카드 그리드 (4열)
- 각 카드: 프로필 이미지, 이름, 역할 배지
- 역할별 필터 버튼
- "출연진 추가" 버튼

### `resources/views/performers/create.blade.php`
- 출연진 등록 폼
- 이미지 업로드 미리보기 (Alpine.js)

### `resources/views/performers/show.blade.php`
- 출연진 프로필
- 출연한 공연 목록 (카드)
- 계약 내역 테이블

### `resources/views/contracts/create.blade.php`
- 계약서 작성 폼
- 출연진 선택 (Select2 또는 Alpine.js 드롭다운)
- 지급 일정 동적 추가/삭제 (Alpine.js)
```javascript
function contractForm() {
  return {
    schedules: [{date: '', amount: 0}],
    addSchedule() {
      this.schedules.push({date: '', amount: 0});
    },
    removeSchedule(index) {
      this.schedules.splice(index, 1);
    }
  }
}
```

### `resources/views/contracts/show.blade.php`
- 계약 상세 정보
- PDF 계약서 임베드 (iframe)
- 지급 일정 타임라인 (Tailwind CSS로 스타일링)
- "PDF 다운로드" 버튼

### `resources/views/contracts/pdf.blade.php`
- PDF 계약서 템플릿
- 헤더: 회사 로고, 제목 "출연 계약서"
- 내용: 공연명, 출연진명, 역할, 출연료, 지급 일정 테이블
- 서명란 (전자서명 이미지 또는 빈 공간)

6. PDF 생성 로직:
```php
use Barryvdh\DomPDF\Facade\Pdf;

public function generatePdf($contractId)
{
    $contract = Contract::with('show', 'performer')->findOrFail($contractId);
    
    $pdf = Pdf::loadView('contracts.pdf', compact('contract'));
    
    return $pdf->download("contract_{$contract->id}.pdf");
}
```

7. 계약서 자동 생성 (store 메서드):
```php
public function store(Request $request, $showId)
{
    $validated = $request->validate([
        'performer_id' => 'required|exists:performers,id',
        'role_in_show' => 'required|string',
        'fee_amount' => 'required|numeric',
        'payment_schedule' => 'required|json',
    ]);
    
    $contract = Contract::create([
        'show_id' => $showId,
        'performer_id' => $validated['performer_id'],
        'role_in_show' => $validated['role_in_show'],
        'fee_amount' => $validated['fee_amount'],
        'payment_schedule' => $validated['payment_schedule'],
    ]);
    
    // PDF 자동 생성
    $pdf = Pdf::loadView('contracts.pdf', compact('contract'));
    $pdfPath = "contracts/contract_{$contract->id}.pdf";
    Storage::disk('public')->put($pdfPath, $pdf->output());
    
    $contract->update(['contract_pdf' => $pdfPath]);
    
    return redirect()->route('contracts.show', $contract)->with('success', '계약서가 생성되었습니다.');
}
```

8. 전자서명 기능 (선택):
- `signature_pad` 라이브러리 사용
- Canvas에 서명 입력
- Base64 이미지로 저장
- PDF에 서명 이미지 삽입

9. UI 개선:
- 지급 일정 타임라인 (Tailwind CSS로 수직 라인 + 날짜 마커)
- 계약 상태 배지 (대기중/서명완료/지급완료)

모든 기능이 작동하면 다음 단계로 진행하겠습니다.

# 수익 정산 & 대시보드 구현

1. 컨트롤러 생성:
```bash
php artisan make:controller SettlementController
php artisan make:controller DashboardController
```

2. `routes/web.php`에 라우트 추가:
```php
Route::get('/dashboard', [DashboardController::class, 'index'])->name('dashboard');
Route::get('/shows/{show}/settlement', [SettlementController::class, 'show'])->name('settlement.show');
Route::post('/shows/{show}/settlement', [SettlementController::class, 'generate'])->name('settlement.generate');
Route::get('/settlements/{settlement}/pdf', [SettlementController::class, 'downloadPdf'])->name('settlement.pdf');
```

3. `DashboardController@index()` 구현:

### 대시보드 데이터 수집
```php
public function index()
{
    // 전체 매출 통계
    $totalRevenue = Booking::where('payment_status', 'paid')->sum('total_price');
    $totalBookings = Booking::where('payment_status', 'paid')->count();
    $totalCustomers = Customer::count();
    
    // 이번 달 매출
    $monthlyRevenue = Booking::where('payment_status', 'paid')
        ->whereMonth('created_at', now()->month)
        ->sum('total_price');
    
    // 공연별 매출 순위 (Top 5)
    $topShows = Show::withCount('bookings')
        ->withSum('bookings', 'total_price')
        ->orderByDesc('bookings_sum_total_price')
        ->take(5)
        ->get();
    
    // 일별 매출 차트 데이터 (최근 30일)
    $dailyRevenue = Booking::where('payment_status', 'paid')
        ->where('created_at', '>=', now()->subDays(30))
        ->selectRaw('DATE(created_at) as date, SUM(total_price) as revenue')
        ->groupBy('date')
        ->orderBy('date')
        ->get();
    
    // 장르별 예매 분포
    $genreDistribution = Show::selectRaw('genre, COUNT(*) as count')
        ->groupBy('genre')
        ->get();
    
    return view('dashboard', compact(
        'totalRevenue',
        'totalBookings',
        'totalCustomers',
        'monthlyRevenue',
        'topShows',
        'dailyRevenue',
        'genreDistribution'
    ));
}
```

4. `SettlementController` 구현:

### show($showId)
- 공연별 정산 정보 표시
- 총 매출, 출연진 지급액, 회사 수익, 투자자 배당
- 정산 내역 테이블

### generate(Request $request, $showId)
```php
public function generate(Request $request, $showId)
{
    $show = Show::with('bookings', 'contracts')->findOrFail($showId);
    
    // 총 매출 계산
    $totalRevenue = $show->bookings()->where('payment_status', 'paid')->sum('total_price');
    
    // 출연진 지급액 계산
    $performerShare = $show->contracts->sum('fee_amount');
    
    // 수익 분배 (예: 회사 60%, 투자자 40%)
    $remainingRevenue = $totalRevenue - $performerShare;
    $companyShare = $remainingRevenue * 0.6;
    $investorShare = $remainingRevenue * 0.4;
    
    // 정산 레코드 생성
    $settlement = Settlement::create([
        'show_id' => $showId,
        'total_revenue' => $totalRevenue,
        'performer_share' => $performerShare,
        'company_share' => $companyShare,
        'investor_share' => $investorShare,
        'settlement_date' => now(),
    ]);
    
    // PDF 리포트 생성
    $pdf = Pdf::loadView('settlements.pdf', compact('settlement', 'show'));
    $pdfPath = "settlements/settlement_{$settlement->id}.pdf";
    Storage::disk('public')->put($pdfPath, $pdf->output());
    
    $settlement->update(['pdf_report' => $pdfPath]);
    
    return redirect()->route('settlement.show', $show)->with('success', '정산이 완료되었습니다.');
}
```

### downloadPdf($settlementId)
```php
public function downloadPdf($settlementId)
{
    $settlement = Settlement::with('show')->findOrFail($settlementId);
    
    return Storage::disk('public')->download($settlement->pdf_report);
}
```

5. Blade 뷰 생성:

### `resources/views/dashboard.blade.php`
- 대시보드 레이아웃
- 4개 통계 카드 (총 매출, 예매 수, 고객 수, 이번 달 매출)
- Chart.js로 일별 매출 라인 차트
- Chart.js로 장르별 예매 파이 차트
- Top 5 공연 순위 테이블

Chart.js 설치:
```bash
npm install chart.js
```

`resources/js/app.js`에 추가:
```javascript
import Chart from 'chart.js/auto';

window.Chart = Chart;
```

Blade 뷰에서 차트 렌더링:
```html
<canvas id="revenueChart"></canvas>

<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(59, 130, 246)',
            tension: 0.1
        }]
    },
    options: {
        responsive: true,
        scales: {
            y: {
                beginAtZero: true
            }
        }
    }
});
</script>
```

### `resources/views/settlements/show.blade.php`
- 정산 요약 카드 (총 매출, 출연진 지급액, 회사 수익, 투자자 배당)
- "정산 실행" 버튼 (settlement가 없는 경우)
- 정산 내역 테이블
- "PDF 다운로드" 버튼

### `resources/views/settlements/pdf.blade.php`
- PDF 정산 리포트 템플릿
- 헤더: 회사 로고, 제목 "정산 리포트"
- 공연 정보 (제목, 시즌, 기간)
- 정산 내역 테이블 (항목, 금액)
- 출연진별 지급 내역 (이름, 역할, 출연료)
- 총계

6. Excel 리포트 다운로드 (보너스):
```bash
composer require maatwebsite/excel
```

```php
php artisan make:export SettlementExport
```

`SettlementExport` 클래스:
```php
use Maatwebsite\Excel\Concerns\FromCollection;
use Maatwebsite\Excel\Concerns\WithHeadings;

class SettlementExport implements FromCollection, WithHeadings
{
    protected $settlement;
    
    public function __construct(Settlement $settlement)
    {
        $this->settlement = $settlement;
    }
    
    public function collection()
    {
        return collect([
            ['총 매출', $this->settlement->total_revenue],
            ['출연진 지급액', $this->settlement->performer_share],
            ['회사 수익', $this->settlement->company_share],
            ['투자자 배당', $this->settlement->investor_share],
        ]);
    }
    
    public function headings(): array
    {
        return ['항목', '금액'];
    }
}
```

라우트 추가:
```php
Route::get('/settlements/{settlement}/excel', function ($settlementId) {
    $settlement = Settlement::findOrFail($settlementId);
    return Excel::download(new SettlementExport($settlement), "settlement_{$settlement->id}.xlsx");
})->name('settlement.excel');
```

7. UI 개선:
- 대시보드 통계 카드에 아이콘 추가 (Heroicons)
- 차트 색상 커스터마이징
- 정산 리포트 테이블 스타일링

모든 기능이 작동하면 다음 단계로 진행하겠습니다.

# 관객 관리 & 리뷰 시스템 구현

1. 컨트롤러 생성:
```bash
php artisan make:controller CustomerController
php artisan make:controller ReviewController
```

2. `routes/web.php`에 라우트 추가:
```php
Route::resource('customers', CustomerController::class);
Route::post('/bookings/{booking}/review', [ReviewController::class, 'store'])->name('reviews.store');
Route::get('/shows/{show}/reviews', [ReviewController::class, 'index'])->name('reviews.index');
```

3. `CustomerController` 구현:

### index()
- 관객 목록 (테이블)
- 필터: 멤버십 등급 (regular/vip/platinum)
- 검색: 이름, 이메일
- 정렬: 총 구매액, 가입일

### show($customerId)
- 관객 상세 정보
- 예매 내역 (카드 그리드)
- 리뷰 작성 내역
- 멤버십 등급 & 혜택 표시

### edit($customerId), update($customerId)
- 관객 정보 수정 (멤버십 등급 변경)

4. `ReviewController` 구현:

### store(Request $request, $bookingId)
```php
public function store(Request $request, $bookingId)
{
    $validated = $request->validate([
        'rating' => 'required|integer|min:1|max:5',
        'comment' => 'required|string|max:1000',
    ]);
    
    $booking = Booking::findOrFail($bookingId);
    
    // 이미 리뷰를 작성했는지 확인
    if ($booking->review) {
        return back()->with('error', '이미 리뷰를 작성하셨습니다.');
    }
    
    Review::create([
        'booking_id' => $bookingId,
        'customer_id' => $booking->customer_id,
        'show_id' => $booking->show_id,
        'rating' => $validated['rating'],
        'comment' => $validated['comment'],
    ]);
    
    return back()->with('success', '리뷰가 등록되었습니다.');
}
```

### index($showId)
- 공연별 리뷰 목록
- 평균 별점 표시
- 별점별 필터 (5점만, 4점 이상 등)
- 최신순/별점순 정렬

5. Blade 뷰 생성:

### `resources/views/customers/index.blade.php`
- 관객 목록 테이블
- 컬럼: 이름, 이메일, 전화번호, 멤버십 등급, 총 구매액, 가입일
- 멤버십 등급 배지 (색상 구분)
- 필터 & 검색 바

### `resources/views/customers/show.blade.php`
- 관객 프로필 카드
- 멤버십 등급 & 혜택 설명
- 예매 내역 (카드 그리드: 공연 포스터, 제목, 날짜, 좌석)
- 작성한 리뷰 목록

### `resources/views/reviews/index.blade.php`
- 공연 리뷰 목록
- 평균 별점 표시 (큰 숫자 + 별 아이콘)
- 별점 분포 차트 (5점: 50%, 4점: 30%, ...)
- 리뷰 카드 (프로필 이미지, 이름, 별점, 코멘트, 작성일)
- 별점별 필터 버튼

### `resources/views/bookings/show.blade.php`에 리뷰 작성 폼 추가
```html
@if(!$booking->review)
<div class="mt-8">
    <h3 class="text-xl font-bold mb-4">공연은 어떠셨나요?</h3>
    <form action="{{ route('reviews.store', $booking) }}" method="POST">
        @csrf
        <div class="mb-4">
            <label class="block text-sm font-medium mb-2">별점</label>
            <div x-data="{ rating: 0 }" class="flex gap-2">
                <template x-for="i in 5" :key="i">
                    <button type="button" @click="rating = i" class="text-3xl">
                        <span x-show="i <= rating">⭐</span>
                        <span x-show="i > rating">☆</span>
                    </button>
                </template>
                <input type="hidden" name="rating" x-model="rating">
            </div>
        </div>
        <div class="mb-4">
            <label class="block text-sm font-medium mb-2">후기</label>
            <textarea name="comment" rows="4" class="w-full border rounded-lg p-3" required></textarea>
        </div>
        <button type="submit" class="bg-blue-600 text-white px-6 py-2 rounded-lg hover:bg-blue-700">
            리뷰 등록
        </button>
    </form>
</div>
@endif
```

6. 멤버십 등급 자동 업그레이드 로직:

`app/Observers/BookingObserver.php` 생성:
```php
php artisan make:observer BookingObserver --model=Booking
```

```php
public function updated(Booking $booking)
{
    if ($booking->payment_status === 'paid') {
        $customer = $booking->customer;
        $totalSpent = $customer->bookings()->where('payment_status', 'paid')->sum('total_price');
        
        // 멤버십 등급 자동 업그레이드
        if ($totalSpent >= 1000000) {
            $customer->update(['membership_tier' => 'platinum']);
        } elseif ($totalSpent >= 500000) {
            $customer->update(['membership_tier' => 'vip']);
        }
        
        $customer->update(['total_spent' => $totalSpent]);
    }
}
```

`app/Providers/AppServiceProvider.php`에 등록:
```php
use App\Models\Booking;
use App\Observers\BookingObserver;

public function boot()
{
    Booking::observe(BookingObserver::class);
}
```

7. 리뷰 감정 분석 (보너스 - OpenAI API):
```bash
composer require openai-php/client
```

`ReviewController@store`에 추가:
```php
use OpenAI\Client;

public function store(Request $request, $bookingId)
{
    // ... 기존 로직
    
    $review = Review::create([...]);
    
    // 감정 분석 (큐로 처리)
    dispatch(function () use ($review) {
        $client = OpenAI::client(config('services.openai.key'));
        
        $result = $client->chat()->create([
            'model' => 'gpt-4',
            'messages' => [
                ['role' => 'system', 'content' => '다음 공연 리뷰의 감정을 분석하여 긍정/부정/중립 중 하나로 분류하세요.'],
                ['role' => 'user', 'content' => $review->comment],
            ],
        ]);
        
        $sentiment = $result->choices[0]->message->content;
        $review->update(['sentiment' => $sentiment]);
    });
    
    return back()->with('success', '리뷰가 등록되었습니다.');
}
```

8. UI 개선:
- 리뷰 카드에 감정 배지 추가 (긍정: 초록, 부정: 빨강, 중립: 회색)
- 별점 평균 시각화 (진행바)
- 멤버십 등급별 배지 색상 (regular: 회색, vip: 금색, platinum: 보라)

모든 기능이 작동하면 다음 단계로 진행하겠습니다.

# 알림 & 자동화 시스템 구현

1. Job & Notification 생성:
```bash
php artisan make:job SendBookingReminderJob
php artisan make:job SendTicketOpenNotificationJob
php artisan make:notification BookingReminderNotification
php artisan make:notification TicketOpenNotification
```

2. `SendBookingReminderJob` 구현:
```php
namespace App\Jobs;

use App\Models\Booking;
use App\Notifications\BookingReminderNotification;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class SendBookingReminderJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    protected $booking;
    
    public function __construct(Booking $booking)
    {
        $this->booking = $booking;
    }
    
    public function handle()
    {
        $this->booking->customer->notify(new BookingReminderNotification($this->booking));
    }
}
```

3. `BookingReminderNotification` 구현:
```php
namespace App\Notifications;

use App\Models\Booking;
use Illuminate\Bus\Queueable;
use Illuminate\Notifications\Messages\MailMessage;
use Illuminate\Notifications\Notification;

class BookingReminderNotification extends Notification
{
    use Queueable;
    
    protected $booking;
    
    public function __construct(Booking $booking)
    {
        $this->booking = $booking;
    }
    
    public function via($notifiable)
    {
        return ['mail', 'database'];
    }
    
    public function toMail($notifiable)
    {
        return (new MailMessage)
            ->subject('공연 관람 안내')
            ->greeting('안녕하세요, ' . $notifiable->name . '님!')
            ->line('예매하신 공연이 곧 시작됩니다.')
            ->line('공연명: ' . $this->booking->show->title)
            ->line('날짜: ' . $this->booking->show_date)
            ->line('시간: ' . $this->booking->show_time)
            ->action('티켓 확인', route('booking.show', $this->booking))
            ->line('즐거운 관람 되시길 바랍니다!');
    }
    
    public function toArray($notifiable)
    {
        return [
            'booking_id' => $this->booking->id,
            'show_title' => $this->booking->show->title,
            'show_date' => $this->booking->show_date,
        ];
    }
}
```

4. 스케줄러 설정 (`app/Console/Kernel.php`):
```php
protected function schedule(Schedule $schedule)
{
    // D-7 알림
    $schedule->call(function () {
        $bookings = Booking::where('payment_status', 'paid')
            ->whereDate('show_date', now()->addDays(7))
            ->get();
        
        foreach ($bookings as $booking) {
            SendBookingReminderJob::dispatch($booking);
        }
    })->daily();
    
    // D-1 알림
    $schedule->call(function () {
        $bookings = Booking::where('payment_status', 'paid')
            ->whereDate('show_date', now()->addDay())
            ->get();
        
        foreach ($bookings as $booking) {
            SendBookingReminderJob::dispatch($booking);
        }
    })->daily();
    
    // 정산 마감일 리마인더
    $schedule->call(function () {
        $shows = Show::whereDate('end_date', now()->addDays(3))
            ->whereDoesntHave('settlement')
            ->get();
        
        foreach ($shows as $show) {
            // 관리자에게 알림 (구현 생략)
        }
    })->daily();
}
```

5. 큐 워커 설정:

`.env`에 추가:
```
QUEUE_CONNECTION=redis
```

큐 워커 실행 (프로덕션):
```bash
php artisan queue:work --queue=default,notifications
```

6. 이메일 설정 (`.env`):
```
MAIL_MAILER=smtp
MAIL_HOST=smtp.gmail.com
MAIL_PORT=587
MAIL_USERNAME=your-email@gmail.com
MAIL_PASSWORD=your-app-password
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=noreply@theater-platform.com
MAIL_FROM_NAME="공연 프로듀서 플랫폼"
```

7. 알림 센터 UI 구현:

### 알림 테이블 마이그레이션 (Laravel 기본 제공):
```bash
php artisan notifications:table
php artisan migrate
```

### 알림 컨트롤러:
```bash
php artisan make:controller NotificationController
```

```php
public function index()
{
    $notifications = auth()->user()->notifications()->paginate(20);
    return view('notifications.index', compact('notifications'));
}

public function markAsRead($notificationId)
{
    auth()->user()->notifications()->findOrFail($notificationId)->markAsRead();
    return back();
}
```

### 라우트 추가:
```php
Route::get('/notifications', [NotificationController::class, 'index'])->name('notifications.index');
Route::post('/notifications/{notification}/read', [NotificationController::class, 'markAsRead'])->name('notifications.read');
```

### Blade 뷰 (`resources/views/notifications/index.blade.php`):
```html
<div class="max-w-4xl mx-auto">
    <h1 class="text-2xl font-bold mb-6">알림</h1>
    
    @forelse($notifications as $notification)
    <div class="bg-white border rounded-lg p-4 mb-4 {{ $notification->read_at ? 'opacity-60' : '' }}">
        <div class="flex justify-between items-start">
            <div>
                <p class="font-semibold">{{ $notification->data['show_title'] }}</p>
                <p class="text-sm text-gray-600">{{ $notification->data['show_date'] }}</p>
                <p class="text-xs text-gray-400 mt-2">{{ $notification->created_at->diffForHumans() }}</p>
            </div>
            @if(!$notification->read_at)
            <form action="{{ route('notifications.read', $notification) }}" method="POST">
                @csrf
                <button class="text-blue-600 text-sm">읽음으로 표시</button>
            </form>
            @endif
        </div>
    </div>
    @empty
    <p class="text-gray-500">알림이 없습니다.</p>
    @endforelse
    
    {{ $notifications->links() }}
</div>
```

### 네비게이션 바에 알림 아이콘 추가 (`resources/views/layouts/app.blade.php`):
```html
<div class="relative" x-data="{ open: false }">
    <button @click="open = !open" class="relative">
        🔔
        @if(auth()->user()->unreadNotifications->count() > 0)
        <span class="absolute -top-1 -right-1 bg-red-500 text-white text-xs rounded-full w-5 h-5 flex items-center justify-center">
            {{ auth()->user()->unreadNotifications->count() }}
        </span>
        @endif
    </button>
    
    <div x-show="open" @click.away="open = false" class="absolute right-0 mt-2 w-80 bg-white border rounded-lg shadow-lg">
        <div class="p-4">
            <h3 class="font-bold mb-2">최근 알림</h3>
            @foreach(auth()->user()->unreadNotifications->take(5) as $notification)
            <div class="py-2 border-b">
                <p class="text-sm">{{ $notification->data['show_title'] }}</p>
                <p class="text-xs text-gray-500">{{ $notification->created_at->diffForHumans() }}</p>
            </div>
            @endforeach
            <a href="{{ route('notifications.index') }}" class="block text-center text-blue-600 text-sm mt-2">
                모두 보기
            </a>
        </div>
    </div>
</div>
```

8. SMS 알림 (보너스 - Twilio):
```bash
composer require twilio/sdk
```

`BookingReminderNotification`에 SMS 채널 추가:
```php
public function via($notifiable)
{
    return ['mail', 'database', 'twilio'];
}

public function toTwilio($notifiable)
{
    return (new TwilioSmsMessage())
        ->content('공연 관람 안내: ' . $this->booking->show->title . ' (' . $this->booking->show_date . ')');
}
```

9. Redis 큐 모니터링 (Laravel Horizon):
```bash
composer require laravel/horizon
php artisan horizon:install
php artisan horizon
```

브라우저에서 `/horizon` 접속하여 큐 작업 모니터링.

모든 기능이 작동하면 다음 단계로 진행하겠습니다.

# 권한 관리 & 테스트 & 배포 준비

1. 권한 관리 (Policy & Gate) 구현:

### Policy 생성:
```bash
php artisan make:policy SeasonPolicy --model=Season
php artisan make:policy ShowPolicy --model=Show
php artisan make:policy BookingPolicy --model=Booking
```

### `SeasonPolicy` 구현:
```php
namespace App\Policies;

use App\Models\Season;
use App\Models\User;

class SeasonPolicy
{
    public function viewAny(User $user)
    {
        return true; // 모든 사용자 조회 가능
    }
    
    public function view(User $user, Season $season)
    {
        return true;
    }
    
    public function create(User $user)
    {
        return $user->is_admin; // 관리자만 생성 가능
    }
    
    public function update(User $user, Season $season)
    {
        return $user->is_admin;
    }
    
    public function delete(User $user, Season $season)
    {
        return $user->is_admin;
    }
}
```

### `ShowPolicy`, `BookingPolicy`도 유사하게 구현

### `app/Providers/AuthServiceProvider.php`에 등록:
```php
protected $policies = [
    Season::class => SeasonPolicy::class,
    Show::class => ShowPolicy::class,
    Booking::class => BookingPolicy::class,
];
```

### 컨트롤러에서 Policy 사용:
```php
public function create()
{
    $this->authorize('create', Season::class);
    return view('seasons.create');
}

public function update(Request $request, $id)
{
    $season = Season::findOrFail($id);
    $this->authorize('update', $season);
    // ...
}
```

### Blade 뷰에서 권한 확인:
```html
@can('create', App\Models\Season::class)
<a href="{{ route('seasons.create') }}" class="btn btn-primary">새 시즌 추가</a>
@endcan

@can('update', $season)
<a href="{{ route('seasons.edit', $season) }}" class="btn btn-secondary">수정</a>
@endcan
```

2. 사용자 역할 추가 (users 테이블 마이그레이션):
```bash
php artisan make:migration add_role_to_users_table
```

```php
public function up()
{
    Schema::table('users', function (Blueprint $table) {
        $table->boolean('is_admin')->default(false);
    });
}
```

```bash
php artisan migrate
```

3. PHPUnit 테스트 작성:

### Feature 테스트 생성:
```bash
php artisan make:test SeasonTest
php artisan make:test ShowTest
php artisan make:test BookingTest
```

### `SeasonTest` 예시:
```php
namespace Tests\Feature;

use App\Models\Season;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class SeasonTest extends TestCase
{
    use RefreshDatabase;
    
    public function test_user_can_view_seasons()
    {
        $season = Season::factory()->create();
        
        $response = $this->get(route('seasons.index'));
        
        $response->assertStatus(200);
        $response->assertSee($season->name);
    }
    
    public function test_admin_can_create_season()
    {
        $admin = User::factory()->create(['is_admin' => true]);
        
        $response = $this->actingAs($admin)->post(route('seasons.store'), [
            'name' => '2024 봄 시즌',
            'description' => '설명',
            'start_date' => '2024-03-01',
            'end_date' => '2024-05-31',
        ]);
        
        $response->assertRedirect();
        $this->assertDatabaseHas('seasons', ['name' => '2024 봄 시즌']);
    }
    
    public function test_regular_user_cannot_create_season()
    {
        $user = User::factory()->create(['is_admin' => false]);
        
        $response = $this->actingAs($user)->post(route('seasons.store'), [
            'name' => '2024 봄 시즌',
        ]);
        
        $response->assertForbidden();
    }
}
```

### `BookingTest` 예시:
```php
public function test_user_can_book_available_seats()
{
    $show = Show::factory()->create();
    $seat = Seat::factory()->create(['status' => 'available']);
    $customer = Customer::factory()->create();
    
    $response = $this->post(route('booking.store', $show), [
        'seat_ids' => [$seat->id],
        'customer_id' => $customer->id,
        'show_date' => '2024-06-01',
        'show_time' => '19:00',
    ]);
    
    $response->assertRedirect();
    $this->assertDatabaseHas('bookings', [
        'customer_id' => $customer->id,
        'show_id' => $show->id,
    ]);
}

public function test_user_cannot_book_occupied_seats()
{
    $show = Show::factory()->create();
    $seat = Seat::factory()->create(['status' => 'occupied']);
    $customer = Customer::factory()->create();
    
    $response = $this->post(route('booking.store', $show), [
        'seat_ids' => [$seat->id],
        'customer_id' => $customer->id,
    ]);
    
    $response->assertSessionHasErrors();
}
```

### 테스트 실행:
```bash
php artisan test
```

4. Factory 생성 (테스트용 더미 데이터):
```bash
php artisan make:factory SeasonFactory
php artisan make:factory ShowFactory
php artisan make:factory BookingFactory
```

### `SeasonFactory` 예시:
```php
namespace Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;

class SeasonFactory extends Factory
{
    public function definition()
    {
        return [
            'name' => $this->faker->words(3, true) . ' 시즌',
            'description' => $this->faker->paragraph,
            'start_date' => $this->faker->date(),
            'end_date' => $this->faker->date(),
            'status' => $this->faker->randomElement(['upcoming', 'ongoing', 'completed']),
        ];
    }
}
```

5. 환경 변수 보안:

### `.env.example` 파일 업데이트:
```
APP_NAME="공연 프로듀서 플랫폼"
APP_ENV=production
APP_KEY=
APP_DEBUG=false
APP_URL=https://your-domain.com

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=theater_platform
DB_USERNAME=root
DB_PASSWORD=

QUEUE_CONNECTION=redis
REDIS_HOST=127.0.0.1

MAIL_MAILER=smtp
MAIL_HOST=smtp.gmail.com
MAIL_PORT=587
MAIL_USERNAME=
MAIL_PASSWORD=

PORTONE_API_KEY=
PORTONE_API_SECRET=
```

6. 프로덕션 최적화:
```bash
php artisan config:cache
php artisan route:cache
php artisan view:cache
php artisan optimize
```

7. 배포 체크리스트:
- [ ] `.env` 파일 설정 (프로덕션 DB, 메일, 결제 API 키)
- [ ] `APP_DEBUG=false` 설정
- [ ] `php artisan key:generate` 실행
- [ ] 데이터베이스 마이그레이션 실행
- [ ] Redis 서버 실행
- [ ] 큐 워커 실행 (`php artisan queue:work`)
- [ ] 스케줄러 Cron 설정 (`* * * * * php /path/to/artisan schedule:run >> /dev/null 2>&1`)
- [ ] SSL 인증서 설치 (Let's Encrypt)
- [ ] Nginx/Apache 설정
- [ ] 방화벽 설정 (포트 80, 443 열기)

8. 보안 개선:
- CSRF 토큰 검증 (Laravel 기본 제공)
- SQL Injection 방지 (Eloquent 사용)
- XSS 방지 (Blade `{{ }}` 자동 이스케이프)
- Rate Limiting (API 라우트에 `throttle` 미들웨어 적용)

```php
Route::middleware('throttle:60,1')->group(function () {
    Route::post('/bookings', [BookingController::class, 'store']);
});
```

9. 모니터링 & 로깅:
- Laravel Telescope 설치 (개발 환경)
```bash
composer require laravel/telescope --dev
php artisan telescope:install
php artisan migrate
```

- 프로덕션 로그 모니터링 (Sentry, Bugsnag 등)

10. README.md 작성:
```markdown
# 🎭 공연 프로듀서 시즌 관리 플랫폼

공연 제작사를 위한 올인원 시즌 관리 시스템입니다.

## 주요 기능
- 시즌 & 공연 관리
- 실시간 좌석 예매
- 출연진 계약 관리
- 수익 정산 & 리포트
- 관객 리뷰 & 멤버십
- 자동 알림 시스템

## 설치 방법
1. `git clone https://github.com/your-repo/theater-season-producer-platform.git`
2. `composer install`
3. `npm install && npm run build`
4. `.env` 파일 설정
5. `php artisan key:generate`
6. `php artisan migrate --seed`
7. `php artisan serve`

## 라이선스
MIT
```

프로젝트가 완성되었습니다! 🎉