mkdir workshop-enrollment-certificate-platform && cd workshop-enrollment-certificate-platform

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

Laravel 13.x + Inertia.js + React 19 풀스택 프로젝트를 생성하세요.

다음 명령어로 Laravel Breeze(React+Inertia) starter kit을 설치합니다:
```bash
composer create-project laravel/laravel .
composer require laravel/breeze --dev
php artisan breeze:install react
npm install
npm run dev
```

프로젝트 구조:
- Laravel 백엔드 (routes/web.php, app/Http/Controllers, app/Models)
- React 프론트엔드 (resources/js/Pages, resources/js/Components)
- Inertia.js가 둘을 연결 (별도 API 라우트 불필요)

데이터베이스는 SQLite를 사용합니다. .env 파일에서 DB_CONNECTION=sqlite로 설정하고, database/database.sqlite 파일을 생성하세요.

다음 3개의 모델과 마이그레이션을 생성하세요:

1. Workshop 모델 (워크숍 정보)
   - title (string, 워크숍 제목)
   - description (text, 상세 설명)
   - instructor (string, 강사명)
   - category (string, 카테고리: 디자인/개발/마케팅 등)
   - start_date (date, 시작일)
   - end_date (date, 종료일)
   - capacity (integer, 정원)
   - image_url (string, nullable, 썸네일 이미지)
   - timestamps

2. Enrollment 모델 (등록 정보)
   - workshop_id (foreignId, workshops 테이블 참조)
   - name (string, 참가자 이름)
   - email (string, 이메일)
   - phone (string, 전화번호)
   - motivation (text, 참여 동기)
   - status (enum: 'registered', 'attended', 'completed', 'waiting', 기본값 'registered')
   - attended_sessions (integer, 기본값 0, 출석한 세션 수)
   - total_sessions (integer, 기본값 4, 전체 세션 수)
   - timestamps

3. User 모델 (기본 Laravel Breeze 제공, 추가 수정 불필요)

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

Workshop 모델에 Enrollment와의 관계 설정:
```php
public function enrollments()
{
    return $this->hasMany(Enrollment::class);
}

public function availableSeats()
{
    return $this->capacity - $this->enrollments()->count();
}
```

Enrollment 모델에 Workshop과의 관계 설정:
```php
public function workshop()
{
    return $this->belongsTo(Workshop::class);
}
```

시더(Seeder)를 작성하여 더미 워크숍 데이터 5개를 생성하세요:
```bash
php artisan make:seeder WorkshopSeeder
```

WorkshopSeeder 내용:
```php
Workshop::create([
    'title' => 'React 19 실전 워크숍',
    'description' => 'React 최신 기능을 활용한 SPA 개발 실습',
    'instructor' => '김개발',
    'category' => '개발',
    'start_date' => now()->addDays(10),
    'end_date' => now()->addDays(12),
    'capacity' => 20,
    'image_url' => 'https://via.placeholder.com/400x300?text=React+Workshop',
]);
// 나머지 4개 워크숍도 유사하게 생성 (디자인, 마케팅 카테고리 포함)
```

시더 실행:
```bash
php artisan db:seed --class=WorkshopSeeder
```

프로젝트가 정상적으로 실행되는지 확인:
```bash
php artisan serve
```

http://localhost:8000 접속 시 Laravel Breeze 기본 화면이 나타나면 성공입니다.

워크숍 목록 페이지를 구현하세요.

Laravel 컨트롤러를 생성합니다:
```bash
php artisan make:controller WorkshopController
```

WorkshopController에 index 메서드 작성:
```php
use Inertia\Inertia;
use App\Models\Workshop;

public function index()
{
    $workshops = Workshop::withCount('enrollments')
        ->orderBy('start_date', 'asc')
        ->get()
        ->map(function ($workshop) {
            return [
                'id' => $workshop->id,
                'title' => $workshop->title,
                'instructor' => $workshop->instructor,
                'category' => $workshop->category,
                'start_date' => $workshop->start_date->format('Y-m-d'),
                'capacity' => $workshop->capacity,
                'enrolled' => $workshop->enrollments_count,
                'available' => $workshop->capacity - $workshop->enrollments_count,
                'image_url' => $workshop->image_url,
            ];
        });

    return Inertia::render('Workshops/Index', [
        'workshops' => $workshops,
    ]);
}
```

routes/web.php에 라우트 추가:
```php
use App\Http\Controllers\WorkshopController;

Route::get('/workshops', [WorkshopController::class, 'index'])->name('workshops.index');
```

React 컴포넌트 생성:
resources/js/Pages/Workshops/Index.jsx 파일을 만들고 다음 내용을 작성하세요:

```jsx
import React, { useState } from 'react';
import { Head, Link } from '@inertiajs/react';
import AuthenticatedLayout from '@/Layouts/AuthenticatedLayout';

export default function Index({ auth, workshops }) {
    const [selectedCategory, setSelectedCategory] = useState('all');

    const categories = ['all', '개발', '디자인', '마케팅'];

    const filteredWorkshops = selectedCategory === 'all'
        ? workshops
        : workshops.filter(w => w.category === selectedCategory);

    return (
        <AuthenticatedLayout user={auth.user}>
            <Head title="워크숍 목록" />

            <div className="py-12">
                <div className="max-w-7xl mx-auto sm:px-6 lg:px-8">
                    <div className="bg-white overflow-hidden shadow-sm sm:rounded-lg p-6">
                        <h1 className="text-3xl font-bold mb-6">워크숍 목록</h1>

                        {/* 카테고리 필터 */}
                        <div className="flex gap-2 mb-6">
                            {categories.map(cat => (
                                <button
                                    key={cat}
                                    onClick={() => setSelectedCategory(cat)}
                                    className={`px-4 py-2 rounded-lg font-medium transition ${
                                        selectedCategory === cat
                                            ? 'bg-indigo-600 text-white'
                                            : 'bg-gray-200 text-gray-700 hover:bg-gray-300'
                                    }`}
                                >
                                    {cat === 'all' ? '전체' : cat}
                                </button>
                            ))}
                        </div>

                        {/* 워크숍 카드 그리드 */}
                        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
                            {filteredWorkshops.map(workshop => (
                                <div key={workshop.id} className="border rounded-lg overflow-hidden shadow hover:shadow-lg transition">
                                    <img src={workshop.image_url} alt={workshop.title} className="w-full h-48 object-cover" />
                                    <div className="p-4">
                                        <span className="inline-block bg-blue-100 text-blue-800 text-xs px-2 py-1 rounded mb-2">
                                            {workshop.category}
                                        </span>
                                        <h3 className="text-xl font-bold mb-2">{workshop.title}</h3>
                                        <p className="text-gray-600 text-sm mb-2">강사: {workshop.instructor}</p>
                                        <p className="text-gray-600 text-sm mb-4">시작일: {workshop.start_date}</p>
                                        <div className="flex justify-between items-center">
                                            <span className={`text-sm font-medium ${
                                                workshop.available > 0 ? 'text-green-600' : 'text-red-600'
                                            }`}>
                                                {workshop.available > 0
                                                    ? `잔여석 ${workshop.available}석`
                                                    : '마감'}
                                            </span>
                                            <Link
                                                href={`/workshops/${workshop.id}`}
                                                className="bg-indigo-600 text-white px-4 py-2 rounded hover:bg-indigo-700 transition"
                                            >
                                                자세히 보기
                                            </Link>
                                        </div>
                                    </div>
                                </div>
                            ))}
                        </div>
                    </div>
                </div>
            </div>
        </AuthenticatedLayout>
    );
}
```

네비게이션 메뉴에 워크숍 링크 추가:
resources/js/Layouts/AuthenticatedLayout.jsx 파일에서 네비게이션 부분에 다음 링크를 추가하세요:
```jsx
<Link href="/workshops" className="...">
    워크숍
</Link>
```

브라우저에서 http://localhost:8000/workshops 접속 시 워크숍 카드 그리드가 표시되고, 카테고리 필터가 작동하는지 확인하세요.

워크숍 상세 페이지와 등록 폼을 구현하세요.

WorkshopController에 show 메서드 추가:
```php
public function show($id)
{
    $workshop = Workshop::withCount('enrollments')->findOrFail($id);

    return Inertia::render('Workshops/Show', [
        'workshop' => [
            'id' => $workshop->id,
            'title' => $workshop->title,
            'description' => $workshop->description,
            'instructor' => $workshop->instructor,
            'category' => $workshop->category,
            'start_date' => $workshop->start_date->format('Y-m-d'),
            'end_date' => $workshop->end_date->format('Y-m-d'),
            'capacity' => $workshop->capacity,
            'enrolled' => $workshop->enrollments_count,
            'available' => $workshop->capacity - $workshop->enrollments_count,
            'image_url' => $workshop->image_url,
        ],
    ]);
}
```

routes/web.php에 라우트 추가:
```php
Route::get('/workshops/{id}', [WorkshopController::class, 'show'])->name('workshops.show');
```

React 컴포넌트 생성:
resources/js/Pages/Workshops/Show.jsx 파일을 만들고 다음 내용을 작성하세요:

```jsx
import React, { useState } from 'react';
import { Head, useForm } from '@inertiajs/react';
import AuthenticatedLayout from '@/Layouts/AuthenticatedLayout';

export default function Show({ auth, workshop }) {
    const [showForm, setShowForm] = useState(false);

    const { data, setData, post, processing, errors } = useForm({
        name: '',
        email: '',
        phone: '',
        motivation: '',
    });

    const handleSubmit = (e) => {
        e.preventDefault();
        post(`/workshops/${workshop.id}/enroll`, {
            onSuccess: () => {
                alert('등록이 완료되었습니다!');
                setShowForm(false);
            },
        });
    };

    return (
        <AuthenticatedLayout user={auth.user}>
            <Head title={workshop.title} />

            <div className="py-12">
                <div className="max-w-4xl mx-auto sm:px-6 lg:px-8">
                    <div className="bg-white overflow-hidden shadow-sm sm:rounded-lg p-6">
                        <img src={workshop.image_url} alt={workshop.title} className="w-full h-64 object-cover rounded-lg mb-6" />

                        <span className="inline-block bg-blue-100 text-blue-800 text-sm px-3 py-1 rounded mb-4">
                            {workshop.category}
                        </span>

                        <h1 className="text-4xl font-bold mb-4">{workshop.title}</h1>
                        <p className="text-gray-600 mb-2">강사: <strong>{workshop.instructor}</strong></p>
                        <p className="text-gray-600 mb-2">기간: {workshop.start_date} ~ {workshop.end_date}</p>
                        <p className="text-gray-600 mb-6">정원: {workshop.capacity}명 (잔여석 {workshop.available}석)</p>

                        <div className="prose max-w-none mb-6">
                            <h2 className="text-2xl font-bold mb-2">워크숍 소개</h2>
                            <p>{workshop.description}</p>
                        </div>

                        {workshop.available > 0 ? (
                            <button
                                onClick={() => setShowForm(!showForm)}
                                className="bg-indigo-600 text-white px-6 py-3 rounded-lg hover:bg-indigo-700 transition font-medium"
                            >
                                {showForm ? '등록 폼 닫기' : '지금 등록하기'}
                            </button>
                        ) : (
                            <div className="bg-red-100 text-red-800 px-4 py-3 rounded-lg">
                                현재 정원이 마감되었습니다.
                            </div>
                        )}

                        {showForm && (
                            <form onSubmit={handleSubmit} className="mt-6 space-y-4 border-t pt-6">
                                <h3 className="text-2xl font-bold mb-4">등록 정보 입력</h3>

                                <div>
                                    <label className="block text-sm font-medium mb-1">이름</label>
                                    <input
                                        type="text"
                                        value={data.name}
                                        onChange={e => setData('name', e.target.value)}
                                        className="w-full border rounded-lg px-4 py-2"
                                        required
                                    />
                                    {errors.name && <p className="text-red-600 text-sm mt-1">{errors.name}</p>}
                                </div>

                                <div>
                                    <label className="block text-sm font-medium mb-1">이메일</label>
                                    <input
                                        type="email"
                                        value={data.email}
                                        onChange={e => setData('email', e.target.value)}
                                        className="w-full border rounded-lg px-4 py-2"
                                        required
                                    />
                                    {errors.email && <p className="text-red-600 text-sm mt-1">{errors.email}</p>}
                                </div>

                                <div>
                                    <label className="block text-sm font-medium mb-1">전화번호</label>
                                    <input
                                        type="tel"
                                        value={data.phone}
                                        onChange={e => setData('phone', e.target.value)}
                                        className="w-full border rounded-lg px-4 py-2"
                                        required
                                    />
                                    {errors.phone && <p className="text-red-600 text-sm mt-1">{errors.phone}</p>}
                                </div>

                                <div>
                                    <label className="block text-sm font-medium mb-1">참여 동기</label>
                                    <textarea
                                        value={data.motivation}
                                        onChange={e => setData('motivation', e.target.value)}
                                        className="w-full border rounded-lg px-4 py-2 h-32"
                                        required
                                    />
                                    {errors.motivation && <p className="text-red-600 text-sm mt-1">{errors.motivation}</p>}
                                </div>

                                <button
                                    type="submit"
                                    disabled={processing}
                                    className="bg-green-600 text-white px-6 py-3 rounded-lg hover:bg-green-700 transition font-medium disabled:opacity-50"
                                >
                                    {processing ? '등록 중...' : '등록 완료'}
                                </button>
                            </form>
                        )}
                    </div>
                </div>
            </div>
        </AuthenticatedLayout>
    );
}
```

WorkshopController에 enroll 메서드 추가 (등록 처리):
```php
use App\Models\Enrollment;
use Illuminate\Http\Request;

public function enroll(Request $request, $id)
{
    $workshop = Workshop::findOrFail($id);

    // 정원 체크
    if ($workshop->enrollments()->count() >= $workshop->capacity) {
        return back()->withErrors(['error' => '정원이 마감되었습니다.']);
    }

    $validated = $request->validate([
        'name' => 'required|string|max:255',
        'email' => 'required|email|max:255',
        'phone' => 'required|string|max:20',
        'motivation' => 'required|string',
    ]);

    Enrollment::create([
        'workshop_id' => $workshop->id,
        'name' => $validated['name'],
        'email' => $validated['email'],
        'phone' => $validated['phone'],
        'motivation' => $validated['motivation'],
        'status' => 'registered',
        'total_sessions' => 4, // 기본 4회차
    ]);

    return redirect()->route('workshops.index')->with('success', '등록이 완료되었습니다!');
}
```

routes/web.php에 라우트 추가:
```php
Route::post('/workshops/{id}/enroll', [WorkshopController::class, 'enroll'])->name('workshops.enroll');
```

브라우저에서 워크숍 상세 페이지 접속 후 등록 폼을 작성하고 제출하세요. DB에 Enrollment 레코드가 생성되는지 확인하세요.

나의 등록 내역 페이지를 구현하세요.

WorkshopController에 myEnrollments 메서드 추가:
```php
public function myEnrollments(Request $request)
{
    // 현재 로그인한 사용자의 이메일로 등록 내역 조회 (간단한 구현)
    // 실무에서는 User 모델과 연결하는 것이 좋지만, 여기서는 이메일 기반으로 조회
    $email = $request->user()->email;

    $enrollments = Enrollment::with('workshop')
        ->where('email', $email)
        ->orderBy('created_at', 'desc')
        ->get()
        ->map(function ($enrollment) {
            return [
                'id' => $enrollment->id,
                'workshop_title' => $enrollment->workshop->title,
                'workshop_instructor' => $enrollment->workshop->instructor,
                'workshop_start_date' => $enrollment->workshop->start_date->format('Y-m-d'),
                'status' => $enrollment->status,
                'attended_sessions' => $enrollment->attended_sessions,
                'total_sessions' => $enrollment->total_sessions,
                'attendance_rate' => round(($enrollment->attended_sessions / $enrollment->total_sessions) * 100),
                'can_certificate' => $enrollment->attended_sessions >= ($enrollment->total_sessions * 0.8),
            ];
        });

    return Inertia::render('Workshops/MyEnrollments', [
        'enrollments' => $enrollments,
    ]);
}
```

routes/web.php에 라우트 추가:
```php
Route::get('/my-enrollments', [WorkshopController::class, 'myEnrollments'])->name('workshops.my-enrollments');
```

React 컴포넌트 생성:
resources/js/Pages/Workshops/MyEnrollments.jsx 파일을 만들고 다음 내용을 작성하세요:

```jsx
import React from 'react';
import { Head, Link } from '@inertiajs/react';
import AuthenticatedLayout from '@/Layouts/AuthenticatedLayout';

export default function MyEnrollments({ auth, enrollments }) {
    const statusLabels = {
        registered: '등록 완료',
        attended: '출석 중',
        completed: '수료',
        waiting: '대기',
    };

    const statusColors = {
        registered: 'bg-blue-100 text-blue-800',
        attended: 'bg-yellow-100 text-yellow-800',
        completed: 'bg-green-100 text-green-800',
        waiting: 'bg-gray-100 text-gray-800',
    };

    return (
        <AuthenticatedLayout user={auth.user}>
            <Head title="나의 등록 내역" />

            <div className="py-12">
                <div className="max-w-7xl mx-auto sm:px-6 lg:px-8">
                    <div className="bg-white overflow-hidden shadow-sm sm:rounded-lg p-6">
                        <h1 className="text-3xl font-bold mb-6">나의 등록 내역</h1>

                        {enrollments.length === 0 ? (
                            <div className="text-center py-12">
                                <p className="text-gray-600 mb-4">등록한 워크숍이 없습니다.</p>
                                <Link
                                    href="/workshops"
                                    className="bg-indigo-600 text-white px-6 py-3 rounded-lg hover:bg-indigo-700 transition"
                                >
                                    워크숍 둘러보기
                                </Link>
                            </div>
                        ) : (
                            <div className="space-y-4">
                                {enrollments.map(enrollment => (
                                    <div key={enrollment.id} className="border rounded-lg p-6 hover:shadow-lg transition">
                                        <div className="flex justify-between items-start mb-4">
                                            <div>
                                                <h3 className="text-xl font-bold mb-1">{enrollment.workshop_title}</h3>
                                                <p className="text-gray-600 text-sm">강사: {enrollment.workshop_instructor}</p>
                                                <p className="text-gray-600 text-sm">시작일: {enrollment.workshop_start_date}</p>
                                            </div>
                                            <span className={`px-3 py-1 rounded text-sm font-medium ${statusColors[enrollment.status]}`}>
                                                {statusLabels[enrollment.status]}
                                            </span>
                                        </div>

                                        <div className="bg-gray-50 rounded-lg p-4 mb-4">
                                            <div className="flex justify-between items-center mb-2">
                                                <span className="text-sm font-medium">출석률</span>
                                                <span className="text-sm font-bold">{enrollment.attendance_rate}%</span>
                                            </div>
                                            <div className="w-full bg-gray-200 rounded-full h-2">
                                                <div
                                                    className={`h-2 rounded-full ${
                                                        enrollment.attendance_rate >= 80 ? 'bg-green-600' : 'bg-yellow-600'
                                                    }`}
                                                    style={{ width: `${enrollment.attendance_rate}%` }}
                                                />
                                            </div>
                                            <p className="text-xs text-gray-600 mt-1">
                                                {enrollment.attended_sessions} / {enrollment.total_sessions} 세션 출석
                                            </p>
                                        </div>

                                        {enrollment.can_certificate ? (
                                            <Link
                                                href={`/certificates/${enrollment.id}`}
                                                className="bg-green-600 text-white px-4 py-2 rounded hover:bg-green-700 transition inline-block"
                                            >
                                                수료증 발급받기
                                            </Link>
                                        ) : (
                                            <p className="text-sm text-gray-600">
                                                출석률 80% 이상 달성 시 수료증을 발급받을 수 있습니다.
                                            </p>
                                        )}
                                    </div>
                                ))}
                            </div>
                        )}
                    </div>
                </div>
            </div>
        </AuthenticatedLayout>
    );
}
```

네비게이션 메뉴에 "나의 등록 내역" 링크 추가:
resources/js/Layouts/AuthenticatedLayout.jsx 파일에서 네비게이션 부분에 다음 링크를 추가하세요:
```jsx
<Link href="/my-enrollments" className="...">
    나의 등록 내역
</Link>
```

브라우저에서 http://localhost:8000/my-enrollments 접속 시 등록한 워크숍 목록과 출석률이 표시되는지 확인하세요.

출석 체크 기능(강사용 간단 인터페이스)을 구현하세요.

WorkshopController에 attendanceForm 메서드 추가 (출석 체크 페이지):
```php
public function attendanceForm($id)
{
    $workshop = Workshop::findOrFail($id);
    $enrollments = $workshop->enrollments()->get()->map(function ($enrollment) {
        return [
            'id' => $enrollment->id,
            'name' => $enrollment->name,
            'email' => $enrollment->email,
            'attended_sessions' => $enrollment->attended_sessions,
            'total_sessions' => $enrollment->total_sessions,
        ];
    });

    return Inertia::render('Workshops/Attendance', [
        'workshop' => [
            'id' => $workshop->id,
            'title' => $workshop->title,
        ],
        'enrollments' => $enrollments,
    ]);
}

public function markAttendance(Request $request, $id)
{
    $validated = $request->validate([
        'enrollment_id' => 'required|exists:enrollments,id',
    ]);

    $enrollment = Enrollment::findOrFail($validated['enrollment_id']);
    $enrollment->attended_sessions = min($enrollment->attended_sessions + 1, $enrollment->total_sessions);

    // 출석률 80% 이상 시 상태를 'completed'로 변경
    if ($enrollment->attended_sessions >= ($enrollment->total_sessions * 0.8)) {
        $enrollment->status = 'completed';
    } else {
        $enrollment->status = 'attended';
    }

    $enrollment->save();

    return back()->with('success', '출석이 기록되었습니다.');
}
```

routes/web.php에 라우트 추가:
```php
Route::get('/workshops/{id}/attendance', [WorkshopController::class, 'attendanceForm'])->name('workshops.attendance');
Route::post('/workshops/{id}/attendance', [WorkshopController::class, 'markAttendance'])->name('workshops.mark-attendance');
```

React 컴포넌트 생성:
resources/js/Pages/Workshops/Attendance.jsx 파일을 만들고 다음 내용을 작성하세요:

```jsx
import React from 'react';
import { Head, useForm } from '@inertiajs/react';
import AuthenticatedLayout from '@/Layouts/AuthenticatedLayout';

export default function Attendance({ auth, workshop, enrollments }) {
    const { post, processing } = useForm();

    const handleAttendance = (enrollmentId) => {
        if (confirm('출석 처리하시겠습니까?')) {
            post(`/workshops/${workshop.id}/attendance`, {
                data: { enrollment_id: enrollmentId },
                onSuccess: () => alert('출석이 기록되었습니다!'),
            });
        }
    };

    return (
        <AuthenticatedLayout user={auth.user}>
            <Head title={`출석 체크 - ${workshop.title}`} />

            <div className="py-12">
                <div className="max-w-5xl mx-auto sm:px-6 lg:px-8">
                    <div className="bg-white overflow-hidden shadow-sm sm:rounded-lg p-6">
                        <h1 className="text-3xl font-bold mb-2">{workshop.title}</h1>
                        <p className="text-gray-600 mb-6">출석 체크 (강사용)</p>

                        {enrollments.length === 0 ? (
                            <p className="text-gray-600">등록된 참가자가 없습니다.</p>
                        ) : (
                            <div className="overflow-x-auto">
                                <table className="min-w-full divide-y divide-gray-200">
                                    <thead className="bg-gray-50">
                                        <tr>
                                            <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                                                이름
                                            </th>
                                            <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                                                이메일
                                            </th>
                                            <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                                                출석 현황
                                            </th>
                                            <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                                                액션
                                            </th>
                                        </tr>
                                    </thead>
                                    <tbody className="bg-white divide-y divide-gray-200">
                                        {enrollments.map(enrollment => (
                                            <tr key={enrollment.id}>
                                                <td className="px-6 py-4 whitespace-nowrap">
                                                    <div className="text-sm font-medium text-gray-900">{enrollment.name}</div>
                                                </td>
                                                <td className="px-6 py-4 whitespace-nowrap">
                                                    <div className="text-sm text-gray-500">{enrollment.email}</div>
                                                </td>
                                                <td className="px-6 py-4 whitespace-nowrap">
                                                    <div className="text-sm text-gray-900">
                                                        {enrollment.attended_sessions} / {enrollment.total_sessions} 세션
                                                    </div>
                                                    <div className="w-32 bg-gray-200 rounded-full h-2 mt-1">
                                                        <div
                                                            className="bg-blue-600 h-2 rounded-full"
                                                            style={{
                                                                width: `${(enrollment.attended_sessions / enrollment.total_sessions) * 100}%`,
                                                            }}
                                                        />
                                                    </div>
                                                </td>
                                                <td className="px-6 py-4 whitespace-nowrap text-sm">
                                                    <button
                                                        onClick={() => handleAttendance(enrollment.id)}
                                                        disabled={processing || enrollment.attended_sessions >= enrollment.total_sessions}
                                                        className="bg-green-600 text-white px-4 py-2 rounded hover:bg-green-700 transition disabled:opacity-50 disabled:cursor-not-allowed"
                                                    >
                                                        {enrollment.attended_sessions >= enrollment.total_sessions
                                                            ? '출석 완료'
                                                            : '출석 체크'}
                                                    </button>
                                                </td>
                                            </tr>
                                        ))}
                                    </tbody>
                                </table>
                            </div>
                        )}
                    </div>
                </div>
            </div>
        </AuthenticatedLayout>
    );
}
```

워크숍 상세 페이지(Show.jsx)에 출석 체크 페이지로 이동하는 버튼 추가:
```jsx
<Link
    href={`/workshops/${workshop.id}/attendance`}
    className="bg-purple-600 text-white px-4 py-2 rounded hover:bg-purple-700 transition ml-2"
>
    출석 체크 (강사용)
</Link>
```

브라우저에서 출석 체크 페이지에 접속하여 참가자의 출석을 기록하세요. 출석 버튼 클릭 시 DB의 attended_sessions 값이 증가하는지 확인하세요.

수료증 자동 발급 기능을 구현하세요.

Laravel에서 PDF 생성을 위해 DomPDF 라이브러리를 설치합니다:
```bash
composer require barryvdh/laravel-dompdf
```

WorkshopController에 certificate 메서드 추가:
```php
use Barryvdh\DomPDF\Facade\Pdf;

public function certificate($enrollmentId)
{
    $enrollment = Enrollment::with('workshop')->findOrFail($enrollmentId);

    // 출석률 80% 미만이면 접근 거부
    if ($enrollment->attended_sessions < ($enrollment->total_sessions * 0.8)) {
        return back()->withErrors(['error' => '출석률 80% 이상 달성 시 수료증을 발급받을 수 있습니다.']);
    }

    // 수료증 데이터
    $data = [
        'name' => $enrollment->name,
        'workshop_title' => $enrollment->workshop->title,
        'instructor' => $enrollment->workshop->instructor,
        'start_date' => $enrollment->workshop->start_date->format('Y년 m월 d일'),
        'end_date' => $enrollment->workshop->end_date->format('Y년 m월 d일'),
        'issue_date' => now()->format('Y년 m월 d일'),
        'attendance_rate' => round(($enrollment->attended_sessions / $enrollment->total_sessions) * 100),
    ];

    // PDF 생성
    $pdf = Pdf::loadView('certificates.template', $data);

    return $pdf->download('certificate_' . $enrollment->id . '.pdf');
}
```

routes/web.php에 라우트 추가:
```php
Route::get('/certificates/{enrollmentId}', [WorkshopController::class, 'certificate'])->name('certificates.show');
```

수료증 템플릿 Blade 파일 생성:
resources/views/certificates/template.blade.php 파일을 만들고 다음 내용을 작성하세요:

```blade
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>수료증</title>
    <style>
        body {
            font-family: 'DejaVu Sans', sans-serif;
            text-align: center;
            padding: 50px;
        }
        .certificate {
            border: 10px solid #4F46E5;
            padding: 40px;
            margin: 0 auto;
            max-width: 800px;
        }
        h1 {
            font-size: 48px;
            margin-bottom: 20px;
            color: #4F46E5;
        }
        h2 {
            font-size: 32px;
            margin-bottom: 40px;
        }
        .content {
            font-size: 18px;
            line-height: 1.8;
            margin-bottom: 40px;
        }
        .signature {
            margin-top: 60px;
            font-size: 16px;
        }
        .footer {
            margin-top: 40px;
            font-size: 14px;
            color: #666;
        }
    </style>
</head>
<body>
    <div class="certificate">
        <h1>수료증</h1>
        <h2>Certificate of Completion</h2>

        <div class="content">
            <p style="font-size: 24px; margin-bottom: 10px;"><strong>{{ $name }}</strong> 님</p>
            <p>위 분은 아래의 워크숍을 성실히 이수하였기에 이 증서를 수여합니다.</p>
            <br>
            <p><strong>워크숍명:</strong> {{ $workshop_title }}</p>
            <p><strong>강사:</strong> {{ $instructor }}</p>
            <p><strong>교육 기간:</strong> {{ $start_date }} ~ {{ $end_date }}</p>
            <p><strong>출석률:</strong> {{ $attendance_rate }}%</p>
        </div>

        <div class="signature">
            <p>{{ $issue_date }}</p>
            <p>워크숍 운영진 일동</p>
        </div>

        <div class="footer">
            <p>본 수료증은 온라인 워크숍 플랫폼에서 자동 발급되었습니다.</p>
        </div>
    </div>
</body>
</html>
```

나의 등록 내역 페이지(MyEnrollments.jsx)에서 수료증 발급 링크가 제대로 작동하는지 확인하세요:
```jsx
<Link
    href={`/certificates/${enrollment.id}`}
    className="bg-green-600 text-white px-4 py-2 rounded hover:bg-green-700 transition inline-block"
>
    수료증 발급받기
</Link>
```

브라우저에서 출석률 80% 이상인 워크숍의 수료증 발급 버튼을 클릭하면 PDF 파일이 다운로드되는지 확인하세요.

만약 PDF 생성 시 한글 폰트가 깨진다면, resources/views/certificates/template.blade.php의 font-family를 'DejaVu Sans'로 설정하세요 (DomPDF가 기본 지원하는 폰트).

최종 테스트:
1. 워크숍 목록 페이지에서 카테고리 필터가 작동하는지 확인
2. 워크숍 상세 페이지에서 등록 폼이 정상 작동하는지 확인
3. 나의 등록 내역 페이지에서 출석률이 정확히 표시되는지 확인
4. 출석 체크 페이지에서 출석 기록이 정상 작동하는지 확인
5. 출석률 80% 이상 시 수료증 PDF가 정상 다운로드되는지 확인