initial commit

app/Http/Controllers/Api/V1/AuthController.php

@@ -0,0 +1,133 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Requests\Api\V1\Auth\LoginRequest;
+use App\Http\Requests\Api\V1\Auth\RefreshRequest;
+use App\Http\Requests\Api\V1\Auth\RegisterRequest;
+use App\Http\Resources\UserResource;
+use App\Models\User;
+use App\Models\Wallet;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Hash;
+use Laravel\Sanctum\PersonalAccessToken;
+
+class AuthController extends Controller
+{
+    use RespondsWithJson;
+
+    public function register(RegisterRequest $request): JsonResponse
+    {
+        $user = User::query()->create([
+            'first_name' => $request->string('first_name')->toString(),
+            'last_name' => $request->string('last_name')->toString(),
+            'email' => $request->string('email')->toString(),
+            'phone' => $request->input('phone'),
+            'birthdate' => $request->input('birthdate'),
+            'password' => $request->string('password')->toString(),
+            'locale' => $request->input('locale', 'fr'),
+            'is_active' => true,
+        ]);
+
+        Wallet::query()->create([
+            'user_id' => $user->id,
+            'currency' => 'EUR',
+            'current_balance' => 0,
+            'status' => 'active',
+        ]);
+
+        $tokens = $this->issueTokenPair($user, $request->input('device_name', 'mobile'));
+
+        return $this->created([
+            'user' => new UserResource($user),
+            ...$tokens,
+        ], 'Inscription réussie.');
+    }
+
+    public function login(LoginRequest $request): JsonResponse
+    {
+        $user = User::query()->where('email', $request->string('email')->toString())->first();
+
+        if ($user === null || ! Hash::check($request->string('password')->toString(), $user->password)) {
+            return $this->error('Identifiants invalides.', 401);
+        }
+
+        if (! $user->is_active) {
+            return $this->error('Compte utilisateur désactivé.', 403);
+        }
+
+        $tokens = $this->issueTokenPair($user, $request->input('device_name', 'mobile'));
+
+        return $this->success([
+            'user' => new UserResource($user),
+            ...$tokens,
+        ], 'Connexion réussie.');
+    }
+
+    public function refresh(RefreshRequest $request): JsonResponse
+    {
+        $token = PersonalAccessToken::findToken($request->string('refresh_token')->toString());
+
+        if ($token === null || ! $token->can('refresh') || ! $token->can('user')) {
+            return $this->error('Refresh token invalide.', 401);
+        }
+
+        $user = $token->tokenable;
+
+        if (! $user instanceof User || ! $user->is_active) {
+            return $this->error('Utilisateur non autorisé.', 403);
+        }
+
+        $token->delete();
+        $user->tokens()->where('name', 'like', '%-access')->delete();
+
+        $tokens = $this->issueTokenPair($user, 'mobile');
+
+        return $this->success([
+            'user' => new UserResource($user),
+            ...$tokens,
+        ], 'Token renouvelé.');
+    }
+
+    public function logout(Request $request): JsonResponse
+    {
+        $request->user()?->currentAccessToken()?->delete();
+
+        return $this->success(message: 'Déconnexion réussie.');
+    }
+
+    public function me(Request $request): JsonResponse
+    {
+        return $this->success([
+            'user' => new UserResource($request->user()),
+        ]);
+    }
+
+    private function issueTokenPair(User $user, string $deviceName): array
+    {
+        $accessMinutes = (int) config('laverie.auth.access_token_ttl_minutes', 60);
+        $refreshDays = (int) config('laverie.auth.refresh_token_ttl_days', 30);
+
+        $accessToken = $user->createToken(
+            "{$deviceName}-access",
+            ['user', 'access'],
+            now()->addMinutes($accessMinutes),
+        );
+
+        $refreshToken = $user->createToken(
+            "{$deviceName}-refresh",
+            ['user', 'refresh'],
+            now()->addDays($refreshDays),
+        );
+
+        return [
+            'access_token' => $accessToken->plainTextToken,
+            'refresh_token' => $refreshToken->plainTextToken,
+            'token_type' => 'Bearer',
+            'expires_in' => $accessMinutes * 60,
+        ];
+    }
+}

app/Http/Controllers/Api/V1/BookingController.php

@@ -0,0 +1,131 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1;
+
+use App\Exceptions\BookingConflictException;
+use App\Exceptions\WalletInsufficientFundsException;
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Requests\Api\V1\Booking\MoveBookingRequest;
+use App\Http\Requests\Api\V1\Booking\StoreBookingRequest;
+use App\Http\Resources\BookingResource;
+use App\Models\Booking;
+use App\Models\Machine;
+use App\Services\BookingService;
+use Carbon\Carbon;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class BookingController extends Controller
+{
+    use RespondsWithJson;
+
+    public function __construct(
+        private readonly BookingService $bookingService,
+    ) {}
+
+    public function store(StoreBookingRequest $request): JsonResponse
+    {
+        $machine = Machine::query()
+            ->where('uuid', $request->string('machine_uuid')->toString())
+            ->firstOrFail();
+
+        try {
+            $booking = $this->bookingService->createBooking(
+                $request->user(),
+                $machine,
+                Carbon::parse($request->input('slot_start')),
+                Carbon::parse($request->input('slot_end')),
+                $request->input('idempotency_key'),
+            );
+        } catch (BookingConflictException $e) {
+            return $this->error($e->getMessage(), 409);
+        } catch (WalletInsufficientFundsException $e) {
+            return $this->error($e->getMessage(), 402);
+        } catch (\RuntimeException|\InvalidArgumentException $e) {
+            return $this->error($e->getMessage(), 422);
+        }
+
+        return $this->created([
+            'booking' => new BookingResource($booking->load('machine.establishment')),
+        ], 'Réservation créée.');
+    }
+
+    public function index(Request $request): JsonResponse
+    {
+        $bookings = Booking::query()
+            ->where('user_id', $request->user()->id)
+            ->with(['machine.establishment'])
+            ->when($request->filled('status'), fn ($q) => $q->where('status', $request->string('status')->toString()))
+            ->orderByDesc('slot_start')
+            ->paginate($request->integer('per_page', 20));
+
+        return $this->success([
+            'bookings' => BookingResource::collection($bookings),
+            'meta' => [
+                'current_page' => $bookings->currentPage(),
+                'last_page' => $bookings->lastPage(),
+                'per_page' => $bookings->perPage(),
+                'total' => $bookings->total(),
+            ],
+        ]);
+    }
+
+    public function show(Request $request, string $uuid): JsonResponse
+    {
+        $booking = Booking::query()
+            ->where('uuid', $uuid)
+            ->where('user_id', $request->user()->id)
+            ->with(['machine.establishment'])
+            ->firstOrFail();
+
+        return $this->success([
+            'booking' => new BookingResource($booking),
+        ]);
+    }
+
+    public function cancel(Request $request, string $uuid): JsonResponse
+    {
+        $booking = Booking::query()
+            ->where('uuid', $uuid)
+            ->where('user_id', $request->user()->id)
+            ->firstOrFail();
+
+        try {
+            $booking = $this->bookingService->cancelBooking($booking, $request->user());
+        } catch (\RuntimeException $e) {
+            return $this->error($e->getMessage(), 422);
+        }
+
+        return $this->success([
+            'booking' => new BookingResource($booking->load('machine.establishment')),
+        ], 'Réservation annulée.');
+    }
+
+    public function move(MoveBookingRequest $request, string $uuid): JsonResponse
+    {
+        $booking = Booking::query()
+            ->where('uuid', $uuid)
+            ->where('user_id', $request->user()->id)
+            ->firstOrFail();
+
+        try {
+            $booking = $this->bookingService->moveBooking(
+                $booking,
+                $request->user(),
+                Carbon::parse($request->input('slot_start')),
+                Carbon::parse($request->input('slot_end')),
+            );
+        } catch (BookingConflictException $e) {
+            return $this->error($e->getMessage(), 409);
+        } catch (WalletInsufficientFundsException $e) {
+            return $this->error($e->getMessage(), 402);
+        } catch (\RuntimeException|\InvalidArgumentException $e) {
+            return $this->error($e->getMessage(), 422);
+        }
+
+        return $this->success([
+            'booking' => new BookingResource($booking->load('machine.establishment')),
+        ], 'Réservation déplacée.');
+    }
+}

app/Http/Controllers/Api/V1/EstablishmentController.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Resources\EstablishmentResource;
+use App\Models\Establishment;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class EstablishmentController extends Controller
+{
+    use RespondsWithJson;
+
+    public function index(Request $request): JsonResponse
+    {
+        $establishments = Establishment::query()
+            ->where('is_active', true)
+            ->when($request->filled('city'), fn ($q) => $q->where('city', $request->string('city')->toString()))
+            ->orderBy('name')
+            ->get();
+
+        return $this->success([
+            'establishments' => EstablishmentResource::collection($establishments),
+        ]);
+    }
+
+    public function show(string $uuid): JsonResponse
+    {
+        $establishment = Establishment::query()
+            ->where('uuid', $uuid)
+            ->where('is_active', true)
+            ->with(['machines' => fn ($q) => $q->orderBy('name')])
+            ->firstOrFail();
+
+        return $this->success([
+            'establishment' => new EstablishmentResource($establishment),
+        ]);
+    }
+}

app/Http/Controllers/Api/V1/Integration/MachineEventController.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1\Integration;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Requests\Api\V1\Integration\AckCommandRequest;
+use App\Http\Requests\Api\V1\Integration\HeartbeatRequest;
+use App\Http\Requests\Api\V1\Integration\MachineEventRequest;
+use App\Models\MachineCommand;
+use App\Models\MachineIntegration;
+use App\Services\MachineIntegrationService;
+use Illuminate\Http\JsonResponse;
+
+class MachineEventController extends Controller
+{
+    use RespondsWithJson;
+
+    public function __construct(
+        private readonly MachineIntegrationService $machineIntegrationService,
+    ) {}
+
+    public function store(MachineEventRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+
+        $this->machineIntegrationService->handleInboundEvent(
+            $payload['provider'],
+            $payload,
+        );
+
+        return $this->created(['received' => true], 'Événement enregistré.');
+    }
+
+    public function heartbeat(HeartbeatRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $payload['event_type'] = 'heartbeat';
+        $payload['occurred_at'] = $payload['occurred_at'] ?? now()->toIso8601String();
+
+        $integration = MachineIntegration::query()
+            ->where('provider', $payload['provider'])
+            ->where('external_machine_id', $payload['machine_external_id'])
+            ->where('is_active', true)
+            ->with('machine')
+            ->first();
+
+        if ($integration?->machine !== null) {
+            $integration->machine->update(['last_heartbeat_at' => now()]);
+        }
+
+        $this->machineIntegrationService->handleInboundEvent(
+            $payload['provider'],
+            $payload,
+        );
+
+        return $this->success(['received' => true], 'Heartbeat enregistré.');
+    }
+
+    public function ackCommand(AckCommandRequest $request, string $uuid): JsonResponse
+    {
+        $command = MachineCommand::query()->where('uuid', $uuid)->firstOrFail();
+
+        $command->update([
+            'status' => $request->string('status')->toString(),
+            'external_reference' => $request->input('external_reference'),
+            'responded_at' => now(),
+            'payload' => array_merge($command->payload ?? [], [
+                'ack' => $request->input('data', []),
+            ]),
+        ]);
+
+        return $this->success([
+            'command_uuid' => $command->uuid,
+            'status' => $command->status,
+        ], 'Accusé de réception enregistré.');
+    }
+}

app/Http/Controllers/Api/V1/MachineController.php

@@ -0,0 +1,105 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Resources\MachineResource;
+use App\Models\Booking;
+use App\Models\Machine;
+use App\Services\PricingService;
+use Carbon\Carbon;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class MachineController extends Controller
+{
+    use RespondsWithJson;
+
+    public function __construct(
+        private readonly PricingService $pricingService,
+    ) {}
+
+    public function show(string $uuid): JsonResponse
+    {
+        $machine = Machine::query()
+            ->where('uuid', $uuid)
+            ->with('establishment')
+            ->firstOrFail();
+
+        return $this->success([
+            'machine' => new MachineResource($machine),
+        ]);
+    }
+
+    public function availability(Request $request, string $uuid): JsonResponse
+    {
+        $machine = Machine::query()
+            ->where('uuid', $uuid)
+            ->with('establishment')
+            ->firstOrFail();
+
+        $date = $request->filled('date')
+            ? Carbon::parse($request->string('date')->toString())->startOfDay()
+            : now()->startOfDay();
+
+        $slotDuration = $request->integer('slot_minutes', 60);
+        $dayStart = $date->copy()->setTime(7, 0);
+        $dayEnd = $date->copy()->setTime(22, 0);
+
+        $bookings = Booking::query()
+            ->where('machine_id', $machine->id)
+            ->whereIn('status', ['pending', 'confirmed', 'active'])
+            ->where('slot_start', '<', $dayEnd)
+            ->where('slot_end', '>', $dayStart)
+            ->get(['slot_start', 'slot_end']);
+
+        $slots = [];
+        $cursor = $dayStart->copy();
+
+        while ($cursor->copy()->addMinutes($slotDuration)->lte($dayEnd)) {
+            $slotEnd = $cursor->copy()->addMinutes($slotDuration);
+            $isAvailable = $cursor->isFuture() && ! in_array($machine->status, ['offline', 'maintenance', 'out_of_order'], true);
+
+            if ($isAvailable) {
+                foreach ($bookings as $booking) {
+                    if ($booking->slot_start < $slotEnd && $booking->slot_end > $cursor) {
+                        $isAvailable = false;
+                        break;
+                    }
+                }
+            }
+
+            if ($isAvailable) {
+                $slots[] = [
+                    'start' => $cursor->toIso8601String(),
+                    'end' => $slotEnd->toIso8601String(),
+                ];
+            }
+
+            $cursor->addMinutes($slotDuration);
+        }
+
+        return $this->success([
+            'machine_uuid' => $machine->uuid,
+            'date' => $date->toDateString(),
+            'slots' => $slots,
+        ]);
+    }
+
+    public function pricing(string $uuid): JsonResponse
+    {
+        $machine = Machine::query()
+            ->where('uuid', $uuid)
+            ->with('establishment')
+            ->firstOrFail();
+
+        $price = $this->pricingService->getActivePrice($machine);
+
+        return $this->success([
+            'machine_uuid' => $machine->uuid,
+            'price' => $price,
+            'currency' => 'EUR',
+        ]);
+    }
+}

app/Http/Controllers/Api/V1/Supervisor/AuthController.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Requests\Api\V1\Supervisor\LoginRequest;
+use App\Http\Resources\SupervisorResource;
+use App\Models\Supervisor;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Hash;
+
+class AuthController extends Controller
+{
+    use RespondsWithJson;
+
+    public function login(LoginRequest $request): JsonResponse
+    {
+        $supervisor = Supervisor::query()
+            ->where('email', $request->string('email')->toString())
+            ->first();
+
+        if ($supervisor === null || ! Hash::check($request->string('password')->toString(), $supervisor->password)) {
+            return $this->error('Identifiants invalides.', 401);
+        }
+
+        if (! $supervisor->is_active) {
+            return $this->error('Compte superviseur désactivé.', 403);
+        }
+
+        $supervisor->update(['last_login_at' => now()]);
+
+        $deviceName = $request->input('device_name', 'backoffice');
+        $accessMinutes = (int) config('laverie.auth.access_token_ttl_minutes', 60);
+        $refreshDays = (int) config('laverie.auth.refresh_token_ttl_days', 30);
+
+        $accessToken = $supervisor->createToken(
+            "{$deviceName}-access",
+            ['supervisor', 'access'],
+            now()->addMinutes($accessMinutes),
+        );
+
+        $refreshToken = $supervisor->createToken(
+            "{$deviceName}-refresh",
+            ['supervisor', 'refresh'],
+            now()->addDays($refreshDays),
+        );
+
+        Auth::guard('supervisor')->login($supervisor);
+
+        return $this->success([
+            'supervisor' => new SupervisorResource($supervisor),
+            'access_token' => $accessToken->plainTextToken,
+            'refresh_token' => $refreshToken->plainTextToken,
+            'token_type' => 'Bearer',
+            'expires_in' => $accessMinutes * 60,
+        ], 'Connexion superviseur réussie.');
+    }
+
+    public function logout(Request $request): JsonResponse
+    {
+        $user = $request->user();
+
+        if ($user instanceof Supervisor) {
+            $user->currentAccessToken()?->delete();
+        }
+
+        Auth::guard('supervisor')->logout();
+
+        return $this->success(message: 'Déconnexion superviseur réussie.');
+    }
+}

app/Http/Controllers/Api/V1/Supervisor/BookingController.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Middleware\EnsureSupervisorScope;
+use App\Http\Resources\BookingResource;
+use App\Models\Supervisor;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class BookingController extends Controller
+{
+    use RespondsWithJson;
+
+    public function index(Request $request): JsonResponse
+    {
+        /** @var Supervisor $supervisor */
+        $supervisor = $request->attributes->get('supervisor') ?? $request->user();
+
+        $bookings = EnsureSupervisorScope::bookingsQuery($supervisor)
+            ->when($request->filled('status'), fn ($q) => $q->where('status', $request->string('status')->toString()))
+            ->when($request->filled('date'), fn ($q) => $q->whereDate('slot_start', $request->string('date')->toString()))
+            ->orderByDesc('slot_start')
+            ->paginate($request->integer('per_page', 50));
+
+        return $this->success([
+            'bookings' => BookingResource::collection($bookings),
+            'meta' => [
+                'current_page' => $bookings->currentPage(),
+                'last_page' => $bookings->lastPage(),
+                'per_page' => $bookings->perPage(),
+                'total' => $bookings->total(),
+            ],
+        ]);
+    }
+}

app/Http/Controllers/Api/V1/Supervisor/DashboardController.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Middleware\EnsureSupervisorScope;
+use App\Models\Supervisor;
+use Carbon\Carbon;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class DashboardController extends Controller
+{
+    use RespondsWithJson;
+
+    public function index(Request $request): JsonResponse
+    {
+        /** @var Supervisor $supervisor */
+        $supervisor = $request->attributes->get('supervisor') ?? $request->user();
+
+        $today = Carbon::today();
+        $statsQuery = EnsureSupervisorScope::dailyStatsQuery($supervisor)
+            ->where('stat_date', $today);
+
+        $todayStats = $statsQuery->get();
+
+        $machinesQuery = EnsureSupervisorScope::machinesQuery($supervisor);
+        $offlineThreshold = now()->subMinutes((int) config('laverie.machine.offline_threshold_minutes', 10));
+
+        return $this->success([
+            'summary' => [
+                'machines_total' => (clone $machinesQuery)->count(),
+                'machines_available' => (clone $machinesQuery)->where('status', 'available')->count(),
+                'machines_running' => (clone $machinesQuery)->where('status', 'running')->count(),
+                'machines_offline' => (clone $machinesQuery)->where(function ($q) use ($offlineThreshold) {
+                    $q->where('status', 'offline')
+                        ->orWhere(fn ($q) => $q->where('last_heartbeat_at', '<', $offlineThreshold));
+                })->count(),
+                'bookings_today' => EnsureSupervisorScope::bookingsQuery($supervisor)
+                    ->whereDate('slot_start', $today)
+                    ->count(),
+                'washes_today' => EnsureSupervisorScope::washesQuery($supervisor)
+                    ->whereDate('started_at', $today)
+                    ->count(),
+                'revenue_today' => (float) $todayStats->sum('total_revenue'),
+                'top_up_today' => (float) $todayStats->sum('top_up_amount'),
+            ],
+            'establishments' => $todayStats->map(fn ($stat) => [
+                'establishment_id' => $stat->establishment_id,
+                'establishment_name' => $stat->establishment?->name,
+                'total_washes' => $stat->total_washes,
+                'total_revenue' => (float) $stat->total_revenue,
+                'bookings_count' => $stat->bookings_count,
+                'no_show_count' => $stat->no_show_count,
+                'occupancy_rate' => (float) $stat->occupancy_rate,
+            ]),
+        ]);
+    }
+}

app/Http/Controllers/Api/V1/Supervisor/MachineController.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Middleware\EnsureSupervisorScope;
+use App\Http\Resources\MachineResource;
+use App\Models\Supervisor;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class MachineController extends Controller
+{
+    use RespondsWithJson;
+
+    public function index(Request $request): JsonResponse
+    {
+        /** @var Supervisor $supervisor */
+        $supervisor = $request->attributes->get('supervisor') ?? $request->user();
+
+        $machines = EnsureSupervisorScope::machinesQuery($supervisor)
+            ->when($request->filled('status'), fn ($q) => $q->where('status', $request->string('status')->toString()))
+            ->when($request->filled('establishment_id'), fn ($q) => $q->where('establishment_id', $request->integer('establishment_id')))
+            ->orderBy('name')
+            ->paginate($request->integer('per_page', 50));
+
+        return $this->success([
+            'machines' => MachineResource::collection($machines),
+            'meta' => [
+                'current_page' => $machines->currentPage(),
+                'last_page' => $machines->lastPage(),
+                'per_page' => $machines->perPage(),
+                'total' => $machines->total(),
+            ],
+        ]);
+    }
+}

app/Http/Controllers/Api/V1/Supervisor/PricingController.php

@@ -0,0 +1,91 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Middleware\EnsureSupervisorScope;
+use App\Http\Requests\Api\V1\Supervisor\StorePricingRequest;
+use App\Http\Requests\Api\V1\Supervisor\UpdatePricingRequest;
+use App\Http\Resources\PricingRuleResource;
+use App\Models\Establishment;
+use App\Models\PricingRule;
+use App\Models\Supervisor;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class PricingController extends Controller
+{
+    use RespondsWithJson;
+
+    public function index(Request $request): JsonResponse
+    {
+        /** @var Supervisor $supervisor */
+        $supervisor = $request->attributes->get('supervisor') ?? $request->user();
+
+        $rules = EnsureSupervisorScope::pricingRulesQuery($supervisor)
+            ->when($request->filled('establishment_id'), fn ($q) => $q->where('establishment_id', $request->integer('establishment_id')))
+            ->orderBy('priority')
+            ->paginate($request->integer('per_page', 50));
+
+        return $this->success([
+            'pricing_rules' => PricingRuleResource::collection($rules),
+            'meta' => [
+                'current_page' => $rules->currentPage(),
+                'last_page' => $rules->lastPage(),
+                'per_page' => $rules->perPage(),
+                'total' => $rules->total(),
+            ],
+        ]);
+    }
+
+    public function store(StorePricingRequest $request): JsonResponse
+    {
+        /** @var Supervisor $supervisor */
+        $supervisor = $request->attributes->get('supervisor') ?? $request->user();
+
+        $establishment = Establishment::query()->findOrFail($request->integer('establishment_id'));
+
+        if ($establishment->organization_id !== $supervisor->organization_id) {
+            return $this->error('Établissement hors périmètre.', 403);
+        }
+
+        if ($supervisor->establishment_id !== null && $supervisor->establishment_id !== $establishment->id) {
+            return $this->error('Établissement hors périmètre.', 403);
+        }
+
+        $rule = PricingRule::query()->create([
+            'establishment_id' => $establishment->id,
+            'machine_id' => $request->input('machine_id'),
+            'machine_type' => $request->input('machine_type'),
+            'day_type' => $request->string('day_type')->toString(),
+            'slot_start' => $request->string('slot_start')->toString(),
+            'slot_end' => $request->string('slot_end')->toString(),
+            'price' => $request->input('price'),
+            'label' => $request->input('label'),
+            'requires_app' => $request->boolean('requires_app'),
+            'priority' => $request->integer('priority', 100),
+            'is_active' => $request->boolean('is_active', true),
+        ]);
+
+        return $this->created([
+            'pricing_rule' => new PricingRuleResource($rule->load(['establishment', 'machine'])),
+        ], 'Règle tarifaire créée.');
+    }
+
+    public function update(UpdatePricingRequest $request, int $id): JsonResponse
+    {
+        /** @var Supervisor $supervisor */
+        $supervisor = $request->attributes->get('supervisor') ?? $request->user();
+
+        $rule = EnsureSupervisorScope::pricingRulesQuery($supervisor)
+            ->whereKey($id)
+            ->firstOrFail();
+
+        $rule->update($request->validated());
+
+        return $this->success([
+            'pricing_rule' => new PricingRuleResource($rule->fresh(['establishment', 'machine'])),
+        ], 'Règle tarifaire mise à jour.');
+    }
+}

app/Http/Controllers/Api/V1/Supervisor/PromotionController.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Middleware\EnsureSupervisorScope;
+use App\Http\Resources\PromotionResource;
+use App\Models\Supervisor;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class PromotionController extends Controller
+{
+    use RespondsWithJson;
+
+    public function index(Request $request): JsonResponse
+    {
+        /** @var Supervisor $supervisor */
+        $supervisor = $request->attributes->get('supervisor') ?? $request->user();
+
+        $promotions = EnsureSupervisorScope::promotionsQuery($supervisor)
+            ->when($request->filled('establishment_id'), fn ($q) => $q->where('establishment_id', $request->integer('establishment_id')))
+            ->when($request->boolean('active_only'), fn ($q) => $q->where('is_active', true))
+            ->orderByDesc('starts_at')
+            ->paginate($request->integer('per_page', 50));
+
+        return $this->success([
+            'promotions' => PromotionResource::collection($promotions),
+            'meta' => [
+                'current_page' => $promotions->currentPage(),
+                'last_page' => $promotions->lastPage(),
+                'per_page' => $promotions->perPage(),
+                'total' => $promotions->total(),
+            ],
+        ]);
+    }
+}

app/Http/Controllers/Api/V1/Supervisor/WashController.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Middleware\EnsureSupervisorScope;
+use App\Http\Resources\WashResource;
+use App\Models\Supervisor;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class WashController extends Controller
+{
+    use RespondsWithJson;
+
+    public function index(Request $request): JsonResponse
+    {
+        /** @var Supervisor $supervisor */
+        $supervisor = $request->attributes->get('supervisor') ?? $request->user();
+
+        $washes = EnsureSupervisorScope::washesQuery($supervisor)
+            ->when($request->filled('status'), fn ($q) => $q->where('status', $request->string('status')->toString()))
+            ->when($request->filled('date'), fn ($q) => $q->whereDate('started_at', $request->string('date')->toString()))
+            ->orderByDesc('started_at')
+            ->paginate($request->integer('per_page', 50));
+
+        return $this->success([
+            'washes' => WashResource::collection($washes),
+            'meta' => [
+                'current_page' => $washes->currentPage(),
+                'last_page' => $washes->lastPage(),
+                'per_page' => $washes->perPage(),
+                'total' => $washes->total(),
+            ],
+        ]);
+    }
+}

app/Http/Controllers/Api/V1/WalletController.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Requests\Api\V1\Wallet\ConfirmTopUpRequest;
+use App\Http\Requests\Api\V1\Wallet\InitiateTopUpRequest;
+use App\Http\Resources\PaymentTransactionResource;
+use App\Http\Resources\WalletResource;
+use App\Http\Resources\WalletTransactionResource;
+use App\Models\Wallet;
+use App\Models\WalletTransaction;
+use App\Services\PaymentService;
+use App\Services\WalletService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class WalletController extends Controller
+{
+    use RespondsWithJson;
+
+    public function __construct(
+        private readonly WalletService $walletService,
+        private readonly PaymentService $paymentService,
+    ) {}
+
+    public function index(Request $request): JsonResponse
+    {
+        $user = $request->user();
+        $wallet = Wallet::query()->firstOrCreate(
+            ['user_id' => $user->id],
+            ['currency' => 'EUR', 'current_balance' => 0, 'status' => 'active'],
+        );
+
+        return $this->success([
+            'balance' => $this->walletService->getBalance($user),
+            'wallet' => new WalletResource($wallet->fresh()),
+        ]);
+    }
+
+    public function transactions(Request $request): JsonResponse
+    {
+        $wallet = Wallet::query()->where('user_id', $request->user()->id)->first();
+
+        if ($wallet === null) {
+            return $this->success(['transactions' => []]);
+        }
+
+        $transactions = WalletTransaction::query()
+            ->where('wallet_id', $wallet->id)
+            ->orderByDesc('created_at')
+            ->paginate($request->integer('per_page', 20));
+
+        return $this->success([
+            'transactions' => WalletTransactionResource::collection($transactions),
+            'meta' => [
+                'current_page' => $transactions->currentPage(),
+                'last_page' => $transactions->lastPage(),
+                'per_page' => $transactions->perPage(),
+                'total' => $transactions->total(),
+            ],
+        ]);
+    }
+
+    public function initiateTopUp(InitiateTopUpRequest $request): JsonResponse
+    {
+        $payment = $this->paymentService->initiateTopUp(
+            $request->user(),
+            (float) $request->input('amount'),
+            $request->string('idempotency_key')->toString(),
+            $request->input('return_url'),
+        );
+
+        return $this->created([
+            'payment' => new PaymentTransactionResource($payment),
+        ], 'Rechargement initié.');
+    }
+
+    public function confirmTopUp(ConfirmTopUpRequest $request): JsonResponse
+    {
+        $payment = $this->paymentService->confirmTopUp(
+            $request->string('payment_uuid')->toString(),
+        );
+
+        if ($payment->user_id !== $request->user()->id) {
+            return $this->error('Paiement non autorisé.', 403);
+        }
+
+        return $this->success([
+            'payment' => new PaymentTransactionResource($payment),
+            'balance' => $this->walletService->getBalance($request->user()),
+        ], 'Rechargement confirmé.');
+    }
+
+    public function webhook(Request $request, string $provider): JsonResponse
+    {
+        $this->paymentService->handleWebhook($provider, $request->all());
+
+        return $this->success(message: 'Webhook traité.');
+    }
+}

app/Http/Controllers/Api/V1/WashController.php

@@ -0,0 +1,93 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1;
+
+use App\Exceptions\MachineNotAvailableException;
+use App\Exceptions\WalletInsufficientFundsException;
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Concerns\RespondsWithJson;
+use App\Http\Requests\Api\V1\Wash\StartWashRequest;
+use App\Http\Resources\WashResource;
+use App\Models\Booking;
+use App\Models\Machine;
+use App\Models\Wash;
+use App\Services\WashService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class WashController extends Controller
+{
+    use RespondsWithJson;
+
+    public function __construct(
+        private readonly WashService $washService,
+    ) {}
+
+    public function start(StartWashRequest $request): JsonResponse
+    {
+        $machine = Machine::query()
+            ->where('uuid', $request->string('machine_uuid')->toString())
+            ->firstOrFail();
+
+        $bookingId = null;
+        if ($request->filled('booking_uuid')) {
+            $bookingId = Booking::query()
+                ->where('uuid', $request->string('booking_uuid')->toString())
+                ->where('user_id', $request->user()->id)
+                ->value('id');
+        }
+
+        try {
+            $wash = $this->washService->startWash(
+                $request->user(),
+                $machine,
+                $request->string('trigger_method')->toString(),
+                $bookingId,
+                $request->input('program'),
+            );
+        } catch (MachineNotAvailableException $e) {
+            return $this->error($e->getMessage(), 409);
+        } catch (WalletInsufficientFundsException $e) {
+            return $this->error($e->getMessage(), 402);
+        } catch (\RuntimeException $e) {
+            return $this->error($e->getMessage(), 422);
+        }
+
+        return $this->created([
+            'wash' => new WashResource($wash),
+        ], 'Lavage démarré.');
+    }
+
+    public function index(Request $request): JsonResponse
+    {
+        $washes = Wash::query()
+            ->where('user_id', $request->user()->id)
+            ->with(['machine.establishment', 'booking'])
+            ->when($request->filled('status'), fn ($q) => $q->where('status', $request->string('status')->toString()))
+            ->orderByDesc('created_at')
+            ->paginate($request->integer('per_page', 20));
+
+        return $this->success([
+            'washes' => WashResource::collection($washes),
+            'meta' => [
+                'current_page' => $washes->currentPage(),
+                'last_page' => $washes->lastPage(),
+                'per_page' => $washes->perPage(),
+                'total' => $washes->total(),
+            ],
+        ]);
+    }
+
+    public function show(Request $request, string $uuid): JsonResponse
+    {
+        $wash = Wash::query()
+            ->where('uuid', $uuid)
+            ->where('user_id', $request->user()->id)
+            ->with(['machine.establishment', 'booking'])
+            ->firstOrFail();
+
+        return $this->success([
+            'wash' => new WashResource($wash),
+        ]);
+    }
+}

app/Http/Controllers/Auth/AuthenticatedSessionController.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use App\Http\Requests\Auth\LoginRequest;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Route;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class AuthenticatedSessionController extends Controller
+{
+    /**
+     * Display the login view.
+     */
+    public function create(): Response
+    {
+        return Inertia::render('Auth/Login', [
+            'canResetPassword' => Route::has('password.request'),
+            'status' => session('status'),
+        ]);
+    }
+
+    /**
+     * Handle an incoming authentication request.
+     */
+    public function store(LoginRequest $request): RedirectResponse
+    {
+        $request->authenticate();
+
+        $request->session()->regenerate();
+
+        return redirect()->intended(route('dashboard', absolute: false));
+    }
+
+    /**
+     * Destroy an authenticated session.
+     */
+    public function destroy(Request $request): RedirectResponse
+    {
+        Auth::guard('web')->logout();
+
+        $request->session()->invalidate();
+
+        $request->session()->regenerateToken();
+
+        return redirect('/');
+    }
+}

app/Http/Controllers/Auth/ConfirmablePasswordController.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Validation\ValidationException;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class ConfirmablePasswordController extends Controller
+{
+    /**
+     * Show the confirm password view.
+     */
+    public function show(): Response
+    {
+        return Inertia::render('Auth/ConfirmPassword');
+    }
+
+    /**
+     * Confirm the user's password.
+     */
+    public function store(Request $request): RedirectResponse
+    {
+        if (! Auth::guard('web')->validate([
+            'email' => $request->user()->email,
+            'password' => $request->password,
+        ])) {
+            throw ValidationException::withMessages([
+                'password' => __('auth.password'),
+            ]);
+        }
+
+        $request->session()->put('auth.password_confirmed_at', time());
+
+        return redirect()->intended(route('dashboard', absolute: false));
+    }
+}

app/Http/Controllers/Auth/EmailVerificationNotificationController.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+
+class EmailVerificationNotificationController extends Controller
+{
+    /**
+     * Send a new email verification notification.
+     */
+    public function store(Request $request): RedirectResponse
+    {
+        if ($request->user()->hasVerifiedEmail()) {
+            return redirect()->intended(route('dashboard', absolute: false));
+        }
+
+        $request->user()->sendEmailVerificationNotification();
+
+        return back()->with('status', 'verification-link-sent');
+    }
+}

app/Http/Controllers/Auth/EmailVerificationPromptController.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class EmailVerificationPromptController extends Controller
+{
+    /**
+     * Display the email verification prompt.
+     */
+    public function __invoke(Request $request): RedirectResponse|Response
+    {
+        return $request->user()->hasVerifiedEmail()
+                    ? redirect()->intended(route('dashboard', absolute: false))
+                    : Inertia::render('Auth/VerifyEmail', ['status' => session('status')]);
+    }
+}

app/Http/Controllers/Auth/NewPasswordController.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Auth\Events\PasswordReset;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Facades\Password;
+use Illuminate\Support\Str;
+use Illuminate\Validation\Rules;
+use Illuminate\Validation\ValidationException;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class NewPasswordController extends Controller
+{
+    /**
+     * Display the password reset view.
+     */
+    public function create(Request $request): Response
+    {
+        return Inertia::render('Auth/ResetPassword', [
+            'email' => $request->email,
+            'token' => $request->route('token'),
+        ]);
+    }
+
+    /**
+     * Handle an incoming new password request.
+     *
+     * @throws ValidationException
+     */
+    public function store(Request $request): RedirectResponse
+    {
+        $request->validate([
+            'token' => 'required',
+            'email' => 'required|email',
+            'password' => ['required', 'confirmed', Rules\Password::defaults()],
+        ]);
+
+        // Here we will attempt to reset the user's password. If it is successful we
+        // will update the password on an actual user model and persist it to the
+        // database. Otherwise we will parse the error and return the response.
+        $status = Password::reset(
+            $request->only('email', 'password', 'password_confirmation', 'token'),
+            function ($user) use ($request) {
+                $user->forceFill([
+                    'password' => Hash::make($request->password),
+                    'remember_token' => Str::random(60),
+                ])->save();
+
+                event(new PasswordReset($user));
+            }
+        );
+
+        // If the password was successfully reset, we will redirect the user back to
+        // the application's home authenticated view. If there is an error we can
+        // redirect them back to where they came from with their error message.
+        if ($status == Password::PASSWORD_RESET) {
+            return redirect()->route('login')->with('status', __($status));
+        }
+
+        throw ValidationException::withMessages([
+            'email' => [trans($status)],
+        ]);
+    }
+}

app/Http/Controllers/Auth/PasswordController.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Validation\Rules\Password;
+
+class PasswordController extends Controller
+{
+    /**
+     * Update the user's password.
+     */
+    public function update(Request $request): RedirectResponse
+    {
+        $validated = $request->validate([
+            'current_password' => ['required', 'current_password'],
+            'password' => ['required', Password::defaults(), 'confirmed'],
+        ]);
+
+        $request->user()->update([
+            'password' => Hash::make($validated['password']),
+        ]);
+
+        return back();
+    }
+}

app/Http/Controllers/Auth/PasswordResetLinkController.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Password;
+use Illuminate\Validation\ValidationException;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class PasswordResetLinkController extends Controller
+{
+    /**
+     * Display the password reset link request view.
+     */
+    public function create(): Response
+    {
+        return Inertia::render('Auth/ForgotPassword', [
+            'status' => session('status'),
+        ]);
+    }
+
+    /**
+     * Handle an incoming password reset link request.
+     *
+     * @throws ValidationException
+     */
+    public function store(Request $request): RedirectResponse
+    {
+        $request->validate([
+            'email' => 'required|email',
+        ]);
+
+        // We will send the password reset link to this user. Once we have attempted
+        // to send the link, we will examine the response then see the message we
+        // need to show to the user. Finally, we'll send out a proper response.
+        $status = Password::sendResetLink(
+            $request->only('email')
+        );
+
+        if ($status == Password::RESET_LINK_SENT) {
+            return back()->with('status', __($status));
+        }
+
+        throw ValidationException::withMessages([
+            'email' => [trans($status)],
+        ]);
+    }
+}

app/Http/Controllers/Auth/RegisteredUserController.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use App\Models\User;
+use Illuminate\Auth\Events\Registered;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Validation\Rules;
+use Illuminate\Validation\ValidationException;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class RegisteredUserController extends Controller
+{
+    /**
+     * Display the registration view.
+     */
+    public function create(): Response
+    {
+        return Inertia::render('Auth/Register');
+    }
+
+    /**
+     * Handle an incoming registration request.
+     *
+     * @throws ValidationException
+     */
+    public function store(Request $request): RedirectResponse
+    {
+        $request->validate([
+            'name' => 'required|string|max:255',
+            'email' => 'required|string|lowercase|email|max:255|unique:'.User::class,
+            'password' => ['required', 'confirmed', Rules\Password::defaults()],
+        ]);
+
+        $user = User::create([
+            'name' => $request->name,
+            'email' => $request->email,
+            'password' => Hash::make($request->password),
+        ]);
+
+        event(new Registered($user));
+
+        Auth::login($user);
+
+        return redirect(route('dashboard', absolute: false));
+    }
+}

app/Http/Controllers/Auth/VerifyEmailController.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Auth\Events\Verified;
+use Illuminate\Foundation\Auth\EmailVerificationRequest;
+use Illuminate\Http\RedirectResponse;
+
+class VerifyEmailController extends Controller
+{
+    /**
+     * Mark the authenticated user's email address as verified.
+     */
+    public function __invoke(EmailVerificationRequest $request): RedirectResponse
+    {
+        if ($request->user()->hasVerifiedEmail()) {
+            return redirect()->intended(route('dashboard', absolute: false).'?verified=1');
+        }
+
+        if ($request->user()->markEmailAsVerified()) {
+            event(new Verified($request->user()));
+        }
+
+        return redirect()->intended(route('dashboard', absolute: false).'?verified=1');
+    }
+}

app/Http/Controllers/Concerns/RespondsWithJson.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace App\Http\Controllers\Concerns;
+
+use Illuminate\Http\JsonResponse;
+
+trait RespondsWithJson
+{
+    protected function success(mixed $data = null, ?string $message = null, int $status = 200): JsonResponse
+    {
+        $payload = ['success' => true];
+
+        if ($message !== null) {
+            $payload['message'] = $message;
+        }
+
+        if ($data !== null) {
+            $payload['data'] = $data;
+        }
+
+        return response()->json($payload, $status);
+    }
+
+    protected function created(mixed $data, ?string $message = null): JsonResponse
+    {
+        return $this->success($data, $message, 201);
+    }
+
+    protected function error(string $message, int $status = 400, ?array $errors = null): JsonResponse
+    {
+        $payload = [
+            'success' => false,
+            'message' => $message,
+        ];
+
+        if ($errors !== null) {
+            $payload['errors'] = $errors;
+        }
+
+        return response()->json($payload, $status);
+    }
+}

app/Http/Controllers/Controller.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Http\Controllers;
+
+abstract class Controller
+{
+    //
+}

app/Http/Controllers/ProfileController.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Http\Requests\ProfileUpdateRequest;
+use Illuminate\Contracts\Auth\MustVerifyEmail;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Redirect;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class ProfileController extends Controller
+{
+    /**
+     * Display the user's profile form.
+     */
+    public function edit(Request $request): Response
+    {
+        return Inertia::render('Profile/Edit', [
+            'mustVerifyEmail' => $request->user() instanceof MustVerifyEmail,
+            'status' => session('status'),
+        ]);
+    }
+
+    /**
+     * Update the user's profile information.
+     */
+    public function update(ProfileUpdateRequest $request): RedirectResponse
+    {
+        $request->user()->fill($request->validated());
+
+        if ($request->user()->isDirty('email')) {
+            $request->user()->email_verified_at = null;
+        }
+
+        $request->user()->save();
+
+        return Redirect::route('profile.edit');
+    }
+
+    /**
+     * Delete the user's account.
+     */
+    public function destroy(Request $request): RedirectResponse
+    {
+        $request->validate([
+            'password' => ['required', 'current_password'],
+        ]);
+
+        $user = $request->user();
+
+        Auth::logout();
+
+        $user->delete();
+
+        $request->session()->invalidate();
+        $request->session()->regenerateToken();
+
+        return Redirect::to('/');
+    }
+}

app/Http/Controllers/Supervisor/AuthController.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Http\Controllers\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Requests\Supervisor\LoginRequest;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class AuthController extends Controller
+{
+    public function create(): Response
+    {
+        return Inertia::render('Supervisor/Auth/Login', [
+            'status' => session('status'),
+        ]);
+    }
+
+    public function store(LoginRequest $request): RedirectResponse
+    {
+        $request->authenticate();
+
+        $request->session()->regenerate();
+
+        $supervisor = Auth::guard('supervisor')->user();
+        $supervisor?->update(['last_login_at' => now()]);
+
+        return redirect()->intended(route('supervisor.dashboard'));
+    }
+
+    public function destroy(Request $request): RedirectResponse
+    {
+        Auth::guard('supervisor')->logout();
+
+        $request->session()->invalidate();
+        $request->session()->regenerateToken();
+
+        return redirect()->route('login');
+    }
+}

app/Http/Controllers/Supervisor/BookingPageController.php

@@ -0,0 +1,85 @@
+<?php
+
+namespace App\Http\Controllers\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Supervisor\Concerns\ScopesSupervisorResources;
+use App\Models\Booking;
+use Illuminate\Http\Request;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class BookingPageController extends Controller
+{
+    use ScopesSupervisorResources;
+
+    public function index(Request $request): Response
+    {
+        $query = Booking::query()
+            ->with(['user:id,first_name,last_name,email', 'machine:id,uuid,name,establishment_id', 'machine.establishment:id,name']);
+
+        $this->scopeMachineRelationQuery($query);
+
+        if ($request->filled('status')) {
+            $query->where('status', $request->string('status'));
+        }
+
+        if ($request->filled('date')) {
+            $query->whereDate('slot_start', $request->string('date'));
+        }
+
+        $bookings = $query
+            ->orderByDesc('slot_start')
+            ->paginate(20)
+            ->withQueryString()
+            ->through(fn (Booking $booking) => [
+                'uuid' => $booking->uuid,
+                'status' => $booking->status,
+                'status_label' => $this->statusLabel($booking->status),
+                'slot_start' => $booking->slot_start?->toIso8601String(),
+                'slot_end' => $booking->slot_end?->toIso8601String(),
+                'booking_fee' => (float) $booking->booking_fee,
+                'reserved_amount' => (float) $booking->reserved_amount,
+                'penalty_amount' => (float) $booking->penalty_amount,
+                'user' => $booking->user ? [
+                    'name' => trim($booking->user->first_name.' '.$booking->user->last_name),
+                    'email' => $booking->user->email,
+                ] : null,
+                'machine' => $booking->machine ? [
+                    'uuid' => $booking->machine->uuid,
+                    'name' => $booking->machine->name,
+                    'establishment_name' => $booking->machine->establishment?->name,
+                ] : null,
+            ]);
+
+        return Inertia::render('Supervisor/Bookings/Index', [
+            'bookings' => $bookings,
+            'filters' => [
+                'status' => $request->string('status')->toString() ?: null,
+                'date' => $request->string('date')->toString() ?: null,
+            ],
+            'statusOptions' => $this->statusOptions(),
+        ]);
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    private function statusOptions(): array
+    {
+        return [
+            'pending' => 'En attente',
+            'confirmed' => 'Confirmée',
+            'cancelled' => 'Annulée',
+            'expired' => 'Expirée',
+            'active' => 'Active',
+            'completed' => 'Terminée',
+            'no_show' => 'Absent',
+        ];
+    }
+
+    private function statusLabel(string $status): string
+    {
+        return $this->statusOptions()[$status] ?? $status;
+    }
+}

app/Http/Controllers/Supervisor/Concerns/ScopesSupervisorResources.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace App\Http\Controllers\Supervisor\Concerns;
+
+use App\Models\Supervisor;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Support\Facades\Auth;
+
+trait ScopesSupervisorResources
+{
+    protected function supervisor(): Supervisor
+    {
+        /** @var Supervisor $supervisor */
+        $supervisor = Auth::guard('supervisor')->user();
+
+        return $supervisor;
+    }
+
+    protected function scopeEstablishmentQuery(Builder $query, string $establishmentColumn = 'establishment_id'): Builder
+    {
+        $supervisor = $this->supervisor();
+
+        $query->whereHas('establishment', function (Builder $query) use ($supervisor) {
+            $query->where('organization_id', $supervisor->organization_id);
+
+            if ($supervisor->establishment_id !== null) {
+                $query->where('id', $supervisor->establishment_id);
+            }
+        });
+
+        if ($supervisor->establishment_id !== null && $establishmentColumn !== '') {
+            $query->where($establishmentColumn, $supervisor->establishment_id);
+        }
+
+        return $query;
+    }
+
+    protected function scopeMachineRelationQuery(Builder $query): Builder
+    {
+        $supervisor = $this->supervisor();
+
+        return $query->whereHas('machine.establishment', function (Builder $query) use ($supervisor) {
+            $query->where('organization_id', $supervisor->organization_id);
+
+            if ($supervisor->establishment_id !== null) {
+                $query->where('id', $supervisor->establishment_id);
+            }
+        });
+    }
+}

app/Http/Controllers/Supervisor/DashboardController.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Http\Controllers\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Supervisor\Concerns\ScopesSupervisorResources;
+use App\Services\DashboardService;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class DashboardController extends Controller
+{
+    use ScopesSupervisorResources;
+
+    public function index(DashboardService $dashboardService): Response
+    {
+        $supervisor = $this->supervisor();
+
+        return Inertia::render('Supervisor/Dashboard', [
+            'kpis' => $dashboardService->getKpis($supervisor),
+            'alerts' => $dashboardService->getAlerts($supervisor),
+            'machinesOverview' => $dashboardService->getMachinesOverview($supervisor),
+        ]);
+    }
+}

app/Http/Controllers/Supervisor/MachinePageController.php

@@ -0,0 +1,180 @@
+<?php
+
+namespace App\Http\Controllers\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Supervisor\Concerns\ScopesSupervisorResources;
+use App\Models\Machine;
+use App\Models\MachineEvent;
+use Illuminate\Http\Request;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class MachinePageController extends Controller
+{
+    use ScopesSupervisorResources;
+
+    public function index(Request $request): Response
+    {
+        $query = Machine::query()
+            ->with('establishment:id,name,uuid');
+
+        $this->scopeEstablishmentQuery($query);
+
+        if ($request->filled('status')) {
+            $query->where('status', $request->string('status'));
+        }
+
+        if ($request->filled('type')) {
+            $query->where('type', $request->string('type'));
+        }
+
+        if ($request->filled('search')) {
+            $search = $request->string('search');
+            $query->where(function ($query) use ($search) {
+                $query->where('name', 'like', "%{$search}%")
+                    ->orWhere('qr_code', 'like', "%{$search}%");
+            });
+        }
+
+        $machines = $query
+            ->orderBy('name')
+            ->paginate(20)
+            ->withQueryString()
+            ->through(fn (Machine $machine) => $this->formatMachineListItem($machine));
+
+        return Inertia::render('Supervisor/Machines/Index', [
+            'machines' => $machines,
+            'filters' => [
+                'status' => $request->string('status')->toString() ?: null,
+                'type' => $request->string('type')->toString() ?: null,
+                'search' => $request->string('search')->toString() ?: null,
+            ],
+            'statusOptions' => $this->statusOptions(),
+            'typeOptions' => $this->typeOptions(),
+        ]);
+    }
+
+    public function show(string $uuid): Response
+    {
+        $query = Machine::query()->where('uuid', $uuid);
+        $this->scopeEstablishmentQuery($query);
+
+        $machine = $query
+            ->with(['establishment:id,name,uuid,address,city', 'machineIntegration', 'currentUser:id,first_name,last_name,email'])
+            ->firstOrFail();
+
+        $recentEvents = MachineEvent::query()
+            ->where('machine_id', $machine->id)
+            ->orderByDesc('occurred_at')
+            ->limit(20)
+            ->get()
+            ->map(fn (MachineEvent $event) => [
+                'event_type' => $event->event_type,
+                'event_type_label' => $this->eventTypeLabel($event->event_type),
+                'occurred_at' => $event->occurred_at?->toIso8601String(),
+                'processing_status' => $event->processing_status,
+            ]);
+
+        return Inertia::render('Supervisor/Machines/Show', [
+            'machine' => [
+                'uuid' => $machine->uuid,
+                'name' => $machine->name,
+                'type' => $machine->type,
+                'type_label' => $this->typeLabel($machine->type),
+                'qr_code' => $machine->qr_code,
+                'status' => $machine->status,
+                'status_label' => $this->statusLabel($machine->status),
+                'cycle_started_at' => $machine->cycle_started_at?->toIso8601String(),
+                'cycle_ends_at' => $machine->cycle_ends_at?->toIso8601String(),
+                'last_heartbeat_at' => $machine->last_heartbeat_at?->toIso8601String(),
+                'establishment' => $machine->establishment ? [
+                    'uuid' => $machine->establishment->uuid,
+                    'name' => $machine->establishment->name,
+                    'address' => $machine->establishment->address,
+                    'city' => $machine->establishment->city,
+                ] : null,
+                'current_user' => $machine->currentUser ? [
+                    'name' => trim($machine->currentUser->first_name.' '.$machine->currentUser->last_name),
+                    'email' => $machine->currentUser->email,
+                ] : null,
+                'integration' => $machine->machineIntegration ? [
+                    'provider' => $machine->machineIntegration->provider,
+                    'mode' => $machine->machineIntegration->mode,
+                    'is_active' => $machine->machineIntegration->is_active,
+                ] : null,
+            ],
+            'recentEvents' => $recentEvents,
+        ]);
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function formatMachineListItem(Machine $machine): array
+    {
+        return [
+            'uuid' => $machine->uuid,
+            'name' => $machine->name,
+            'type' => $machine->type,
+            'type_label' => $this->typeLabel($machine->type),
+            'status' => $machine->status,
+            'status_label' => $this->statusLabel($machine->status),
+            'establishment_name' => $machine->establishment?->name,
+            'last_heartbeat_at' => $machine->last_heartbeat_at?->toIso8601String(),
+        ];
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    private function statusOptions(): array
+    {
+        return [
+            'available' => 'Disponible',
+            'reserved' => 'Réservée',
+            'running' => 'En cours',
+            'maintenance' => 'Maintenance',
+            'offline' => 'Hors ligne',
+            'error' => 'Erreur',
+        ];
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    private function typeOptions(): array
+    {
+        return [
+            'washer_small' => 'Lave-linge petit',
+            'washer_large' => 'Lave-linge grand',
+            'dryer_small' => 'Sèche-linge petit',
+            'dryer_large' => 'Sèche-linge grand',
+        ];
+    }
+
+    private function statusLabel(string $status): string
+    {
+        return $this->statusOptions()[$status] ?? $status;
+    }
+
+    private function typeLabel(string $type): string
+    {
+        return $this->typeOptions()[$type] ?? $type;
+    }
+
+    private function eventTypeLabel(string $type): string
+    {
+        return match ($type) {
+            'heartbeat' => 'Signal de vie',
+            'machine_online' => 'En ligne',
+            'machine_offline' => 'Hors ligne',
+            'cycle_started' => 'Cycle démarré',
+            'cycle_completed' => 'Cycle terminé',
+            'cycle_failed' => 'Cycle échoué',
+            'error_reported' => 'Erreur signalée',
+            'status_changed' => 'Changement de statut',
+            default => $type,
+        };
+    }
+}

app/Http/Controllers/Supervisor/PricingPageController.php

@@ -0,0 +1,178 @@
+<?php
+
+namespace App\Http\Controllers\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Supervisor\Concerns\ScopesSupervisorResources;
+use App\Models\Establishment;
+use App\Models\PricingRule;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class PricingPageController extends Controller
+{
+    use ScopesSupervisorResources;
+
+    public function index(Request $request): Response
+    {
+        $query = PricingRule::query()
+            ->with(['establishment:id,name', 'machine:id,uuid,name']);
+
+        $this->scopeEstablishmentQuery($query);
+
+        $rules = $query
+            ->orderBy('priority')
+            ->orderBy('slot_start')
+            ->get()
+            ->map(fn (PricingRule $rule) => $this->formatRule($rule));
+
+        return Inertia::render('Supervisor/Pricing/Index', [
+            'rules' => $rules,
+            'establishments' => $this->establishmentOptions(),
+            'machineTypes' => $this->machineTypeOptions(),
+            'dayTypes' => $this->dayTypeOptions(),
+        ]);
+    }
+
+    public function store(Request $request): RedirectResponse
+    {
+        $validated = $this->validateRule($request);
+        $this->assertEstablishmentAccessible((int) $validated['establishment_id']);
+
+        PricingRule::query()->create($validated);
+
+        return redirect()->route('supervisor.pricing.index')
+            ->with('success', 'Règle tarifaire créée.');
+    }
+
+    public function update(Request $request, int $id): RedirectResponse
+    {
+        $rule = $this->findAccessibleRule($id);
+        $validated = $this->validateRule($request);
+        $this->assertEstablishmentAccessible((int) $validated['establishment_id']);
+
+        $rule->update($validated);
+
+        return redirect()->route('supervisor.pricing.index')
+            ->with('success', 'Règle tarifaire mise à jour.');
+    }
+
+    public function destroy(int $id): RedirectResponse
+    {
+        $rule = $this->findAccessibleRule($id);
+        $rule->delete();
+
+        return redirect()->route('supervisor.pricing.index')
+            ->with('success', 'Règle tarifaire supprimée.');
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function validateRule(Request $request): array
+    {
+        return $request->validate([
+            'establishment_id' => ['required', 'integer', 'exists:establishments,id'],
+            'machine_id' => ['nullable', 'integer', 'exists:machines,id'],
+            'machine_type' => ['nullable', 'in:washer_small,washer_large,dryer_small,dryer_large'],
+            'day_type' => ['required', 'in:weekday,weekend,holiday,all'],
+            'slot_start' => ['required', 'date_format:H:i'],
+            'slot_end' => ['required', 'date_format:H:i', 'after:slot_start'],
+            'price' => ['required', 'numeric', 'min:0'],
+            'label' => ['nullable', 'string', 'max:100'],
+            'requires_app' => ['boolean'],
+            'priority' => ['integer', 'min:0'],
+            'is_active' => ['boolean'],
+        ]);
+    }
+
+    private function findAccessibleRule(int $id): PricingRule
+    {
+        $query = PricingRule::query()->where('id', $id);
+        $this->scopeEstablishmentQuery($query);
+
+        return $query->firstOrFail();
+    }
+
+    private function assertEstablishmentAccessible(int $establishmentId): void
+    {
+        $supervisor = $this->supervisor();
+
+        $exists = Establishment::query()
+            ->where('id', $establishmentId)
+            ->where('organization_id', $supervisor->organization_id)
+            ->when($supervisor->establishment_id, fn ($q) => $q->where('id', $supervisor->establishment_id))
+            ->exists();
+
+        abort_unless($exists, 403);
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function formatRule(PricingRule $rule): array
+    {
+        return [
+            'id' => $rule->id,
+            'establishment_id' => $rule->establishment_id,
+            'establishment_name' => $rule->establishment?->name,
+            'machine_id' => $rule->machine_id,
+            'machine_name' => $rule->machine?->name,
+            'machine_type' => $rule->machine_type,
+            'machine_type_label' => $rule->machine_type ? ($this->machineTypeOptions()[$rule->machine_type] ?? $rule->machine_type) : null,
+            'day_type' => $rule->day_type,
+            'day_type_label' => $this->dayTypeOptions()[$rule->day_type] ?? $rule->day_type,
+            'slot_start' => $rule->slot_start ? substr((string) $rule->slot_start, 0, 5) : null,
+            'slot_end' => $rule->slot_end ? substr((string) $rule->slot_end, 0, 5) : null,
+            'price' => (float) $rule->price,
+            'label' => $rule->label,
+            'requires_app' => $rule->requires_app,
+            'priority' => $rule->priority,
+            'is_active' => $rule->is_active,
+        ];
+    }
+
+    /**
+     * @return array<int, array{id: int, name: string}>
+     */
+    private function establishmentOptions(): array
+    {
+        $supervisor = $this->supervisor();
+
+        return Establishment::query()
+            ->where('organization_id', $supervisor->organization_id)
+            ->when($supervisor->establishment_id, fn ($q) => $q->where('id', $supervisor->establishment_id))
+            ->orderBy('name')
+            ->get(['id', 'name'])
+            ->map(fn (Establishment $e) => ['id' => $e->id, 'name' => $e->name])
+            ->all();
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    private function machineTypeOptions(): array
+    {
+        return [
+            'washer_small' => 'Lave-linge petit',
+            'washer_large' => 'Lave-linge grand',
+            'dryer_small' => 'Sèche-linge petit',
+            'dryer_large' => 'Sèche-linge grand',
+        ];
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    private function dayTypeOptions(): array
+    {
+        return [
+            'all' => 'Tous les jours',
+            'weekday' => 'Semaine',
+            'weekend' => 'Week-end',
+            'holiday' => 'Jours fériés',
+        ];
+    }
+}

app/Http/Controllers/Supervisor/PromotionPageController.php

@@ -0,0 +1,167 @@
+<?php
+
+namespace App\Http\Controllers\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Supervisor\Concerns\ScopesSupervisorResources;
+use App\Models\Establishment;
+use App\Models\Promotion;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class PromotionPageController extends Controller
+{
+    use ScopesSupervisorResources;
+
+    public function index(): Response
+    {
+        $query = Promotion::query()->with('establishment:id,name');
+        $this->scopeEstablishmentQuery($query);
+
+        $promotions = $query
+            ->orderByDesc('starts_at')
+            ->get()
+            ->map(fn (Promotion $promotion) => $this->formatPromotion($promotion));
+
+        return Inertia::render('Supervisor/Promotions/Index', [
+            'promotions' => $promotions,
+            'establishments' => $this->establishmentOptions(),
+            'machineTypes' => $this->machineTypeOptions(),
+            'discountTypes' => $this->discountTypeOptions(),
+        ]);
+    }
+
+    public function store(Request $request): RedirectResponse
+    {
+        $validated = $this->validatePromotion($request);
+        $this->assertEstablishmentAccessible((int) $validated['establishment_id']);
+
+        Promotion::query()->create($validated);
+
+        return redirect()->route('supervisor.promotions.index')
+            ->with('success', 'Promotion créée.');
+    }
+
+    public function update(Request $request, int $id): RedirectResponse
+    {
+        $promotion = $this->findAccessiblePromotion($id);
+        $validated = $this->validatePromotion($request);
+        $this->assertEstablishmentAccessible((int) $validated['establishment_id']);
+
+        $promotion->update($validated);
+
+        return redirect()->route('supervisor.promotions.index')
+            ->with('success', 'Promotion mise à jour.');
+    }
+
+    public function destroy(int $id): RedirectResponse
+    {
+        $promotion = $this->findAccessiblePromotion($id);
+        $promotion->delete();
+
+        return redirect()->route('supervisor.promotions.index')
+            ->with('success', 'Promotion supprimée.');
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function validatePromotion(Request $request): array
+    {
+        return $request->validate([
+            'establishment_id' => ['required', 'integer', 'exists:establishments,id'],
+            'machine_type' => ['required', 'in:washer_small,washer_large,dryer_small,dryer_large,all'],
+            'discount_type' => ['required', 'in:percent,fixed'],
+            'discount_value' => ['required', 'numeric', 'min:0'],
+            'starts_at' => ['required', 'date'],
+            'ends_at' => ['required', 'date', 'after:starts_at'],
+            'description' => ['nullable', 'string', 'max:500'],
+            'is_active' => ['boolean'],
+        ]);
+    }
+
+    private function findAccessiblePromotion(int $id): Promotion
+    {
+        $query = Promotion::query()->where('id', $id);
+        $this->scopeEstablishmentQuery($query);
+
+        return $query->firstOrFail();
+    }
+
+    private function assertEstablishmentAccessible(int $establishmentId): void
+    {
+        $supervisor = $this->supervisor();
+
+        $exists = Establishment::query()
+            ->where('id', $establishmentId)
+            ->where('organization_id', $supervisor->organization_id)
+            ->when($supervisor->establishment_id, fn ($q) => $q->where('id', $supervisor->establishment_id))
+            ->exists();
+
+        abort_unless($exists, 403);
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function formatPromotion(Promotion $promotion): array
+    {
+        return [
+            'id' => $promotion->id,
+            'establishment_id' => $promotion->establishment_id,
+            'establishment_name' => $promotion->establishment?->name,
+            'machine_type' => $promotion->machine_type,
+            'machine_type_label' => $this->machineTypeOptions()[$promotion->machine_type] ?? $promotion->machine_type,
+            'discount_type' => $promotion->discount_type,
+            'discount_type_label' => $this->discountTypeOptions()[$promotion->discount_type] ?? $promotion->discount_type,
+            'discount_value' => (float) $promotion->discount_value,
+            'starts_at' => $promotion->starts_at?->format('Y-m-d\TH:i'),
+            'ends_at' => $promotion->ends_at?->format('Y-m-d\TH:i'),
+            'description' => $promotion->description,
+            'is_active' => $promotion->is_active,
+        ];
+    }
+
+    /**
+     * @return array<int, array{id: int, name: string}>
+     */
+    private function establishmentOptions(): array
+    {
+        $supervisor = $this->supervisor();
+
+        return Establishment::query()
+            ->where('organization_id', $supervisor->organization_id)
+            ->when($supervisor->establishment_id, fn ($q) => $q->where('id', $supervisor->establishment_id))
+            ->orderBy('name')
+            ->get(['id', 'name'])
+            ->map(fn (Establishment $e) => ['id' => $e->id, 'name' => $e->name])
+            ->all();
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    private function machineTypeOptions(): array
+    {
+        return [
+            'all' => 'Toutes les machines',
+            'washer_small' => 'Lave-linge petit',
+            'washer_large' => 'Lave-linge grand',
+            'dryer_small' => 'Sèche-linge petit',
+            'dryer_large' => 'Sèche-linge grand',
+        ];
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    private function discountTypeOptions(): array
+    {
+        return [
+            'percent' => 'Pourcentage',
+            'fixed' => 'Montant fixe',
+        ];
+    }
+}

app/Http/Controllers/Supervisor/WashPageController.php

@@ -0,0 +1,96 @@
+<?php
+
+namespace App\Http\Controllers\Supervisor;
+
+use App\Http\Controllers\Controller;
+use App\Http\Controllers\Supervisor\Concerns\ScopesSupervisorResources;
+use App\Models\Wash;
+use Illuminate\Http\Request;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class WashPageController extends Controller
+{
+    use ScopesSupervisorResources;
+
+    public function index(Request $request): Response
+    {
+        $query = Wash::query()
+            ->with(['user:id,first_name,last_name,email', 'machine:id,uuid,name,establishment_id', 'machine.establishment:id,name']);
+
+        $this->scopeMachineRelationQuery($query);
+
+        if ($request->filled('status')) {
+            $query->where('status', $request->string('status'));
+        }
+
+        if ($request->filled('date')) {
+            $query->whereDate('started_at', $request->string('date'));
+        }
+
+        $washes = $query
+            ->orderByDesc('started_at')
+            ->paginate(20)
+            ->withQueryString()
+            ->through(fn (Wash $wash) => [
+                'uuid' => $wash->uuid,
+                'status' => $wash->status,
+                'status_label' => $this->statusLabel($wash->status),
+                'program' => $wash->program,
+                'trigger_method' => $wash->trigger_method,
+                'trigger_method_label' => $this->triggerMethodLabel($wash->trigger_method),
+                'started_at' => $wash->started_at?->toIso8601String(),
+                'ended_at' => $wash->ended_at?->toIso8601String(),
+                'duration_minutes' => $wash->duration_minutes,
+                'cost' => (float) $wash->cost,
+                'user' => $wash->user ? [
+                    'name' => trim($wash->user->first_name.' '.$wash->user->last_name),
+                    'email' => $wash->user->email,
+                ] : null,
+                'machine' => $wash->machine ? [
+                    'uuid' => $wash->machine->uuid,
+                    'name' => $wash->machine->name,
+                    'establishment_name' => $wash->machine->establishment?->name,
+                ] : null,
+            ]);
+
+        return Inertia::render('Supervisor/Washes/Index', [
+            'washes' => $washes,
+            'filters' => [
+                'status' => $request->string('status')->toString() ?: null,
+                'date' => $request->string('date')->toString() ?: null,
+            ],
+            'statusOptions' => $this->statusOptions(),
+        ]);
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    private function statusOptions(): array
+    {
+        return [
+            'pending_start' => 'En attente',
+            'running' => 'En cours',
+            'completed' => 'Terminé',
+            'failed' => 'Échoué',
+            'cancelled' => 'Annulé',
+        ];
+    }
+
+    private function statusLabel(string $status): string
+    {
+        return $this->statusOptions()[$status] ?? $status;
+    }
+
+    private function triggerMethodLabel(string $method): string
+    {
+        return match ($method) {
+            'qr_code' => 'QR code',
+            'booking' => 'Réservation',
+            'supervisor' => 'Superviseur',
+            'system' => 'Système',
+            default => $method,
+        };
+    }
+}