# Séances formateur : plan d'implémentation (révisé)
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
**Goal:** Permettre au formateur de pointer sa séance (ouverture, puis clôture avec appel et bilan), à l'admin et au gestionnaire de suivre ces séances sur une page unique, et enrichir le rapport de fin de formation.
**Architecture:** Une table `seances` (une ligne par formateur × formation × jour). Leçons et présents d'une séance ne sont jamais stockés : ils sont dérivés en direct de `lecons_du_jour` et `presences` (source unique, aucune contradiction possible). Les écritures passent par des Actions (`app/Actions/Seances/`) appelées par `Staff\SeanceController` ; l'appel réutilise `Actions\Presence\ValiderPresenceParFormateur`. Autorisation dans `SeancePolicy`, portée par `Seance::visibleTo()`. Une seule page « Séances » adaptée au rôle.
**Tech Stack:** Laravel 12, Inertia.js + React 18, Tailwind CSS v3, PHPUnit (SQLite en mémoire), barryvdh/laravel-dompdf.
**Spec:** `docs/superpowers/specs/2026-09-24-seances-formateur-design.md` (révisée le 2026-09-24, voir son § 10)
## Global Constraints
- Langue : tout texte visible, commentaire de code et message d'erreur en **français** ; noms métier en français comme dans le reste du projet (`Seance`, `OuvrirSeance`).
- Pas de suppression physique : `SoftDeletes` sur `Seance`.
- Colonnes `date` : écrire avec `->toDateString()`, comparer avec `whereDate()` (piège documenté dans CLAUDE.md : SQLite des tests ne tronque pas l'heure).
- Cloisonnement : tout identifiant venant de l'URL ou du corps de requête est revérifié (Policy, `visibleTo()`, filtres forcés pour un acteur non admin).
- Partenaire : jamais de texte libre (prévision, bilan) ni de donnée nominative ; seulement des heures agrégées.
- Formulaires en modale : `Modal` + formulaire `p-4 sm:p-6` + boutons dans `ModalActions` (convention du 2026-09-24).
- Champs : `TextInput`, `Select` (renvoie une **chaîne**), `DatePicker` (`min`/`max`), `Checkbox` existants ; aucune nouvelle dépendance npm/composer.
- Pas de glyphes Unicode décoratifs ni de tirets cadratins `—` dans la prose visible ; `'—'` reste accepté comme valeur vide dans une cellule de tableau (usage existant).
- Durée d'une séance : 1 à 720 minutes. Rattrapage : de J-7 à J-1 inclus.
- Leçons et présents d'une séance : **toujours dérivés** (`SerialiserSeances::leconsPar()` / `presentsPar()`), jamais stockés.
- Commits : **uniquement si le porteur de projet les a autorisés** pour ce chantier ; sinon sauter les étapes « Commit ».
- CLAUDE.md mis à jour à la fin (Task 11).
## Review Focus
1. **Séance restée ouverte la veille** : le lendemain, la carte propose de la clôturer (pas d'en ouvrir une nouvelle), durée à saisir, `cloture_tardive = true`, appel appliqué au jour de la séance. Testé Task 3 (`test_closing_the_next_day_is_flagged_late`) et Task 7 (`test_card_shows_yesterdays_open_session`).
2. **Présences corrigées après la clôture depuis la page Présence** : la séance affiche les présents à jour, jamais un chiffre figé contradictoire. Testé Task 6 (`test_presents_and_lessons_are_read_live`).
3. **Formateur avec plusieurs formations** : deux séances le même jour (une par formation) oui, deux ouvertes en même temps non, deux sur la même formation non. Testé Task 2.
4. **Gestionnaire qui force `centre_id` / `formateur_id` ou l'URL d'une séance d'un autre centre** : aucune donnée d'un autre centre, correction refusée. Testé Task 4 et Task 6.
5. **Rattrapage** : jour déjà saisi, hors fenêtre ou hors période refusé ; après l'enregistrement, arrivée sur la page Présence du bon jour et de la bonne formation. Testé Task 5.
---
## Structure des fichiers
Créés :
- `database/migrations/2026_09_25_000001_create_seances_table.php`
- `app/Models/Seance.php`
- `app/Policies/SeancePolicy.php`
- `app/Actions/Seances/OuvrirSeance.php`, `FaireAppel.php`, `CloturerSeance.php`, `SaisirSeancePassee.php`, `SerialiserSeances.php`, `DonneesCarteSeance.php`
- `app/Http/Requests/StoreSeanceRequest.php`, `CloturerSeanceRequest.php`, `UpdateSeanceRequest.php`, `StoreRattrapageSeanceRequest.php`
- `app/Http/Controllers/Staff/SeanceController.php`
- `resources/views/pdf/rapport-formation.blade.php`
- `resources/js/lib/seances.js`
- `resources/js/Pages/Staff/Seances/Index.jsx`
- `resources/js/Pages/Staff/Seances/Partials/ChampDuree.jsx`, `ListeAppel.jsx`, `OuvrirSeanceForm.jsx`, `CloturerSeanceForm.jsx`, `RattrapageSeanceForm.jsx`, `DetailSeance.jsx`, `CarteSeance.jsx`
- `tests/Feature/Seances/ScenarioSeance.php` (trait), `SeancePolicyTest.php`, `SeanceOuvertureTest.php`, `SeanceClotureTest.php`, `SeanceCorrectionTest.php`, `SeanceRattrapageTest.php`, `PageSeancesTest.php`, `SeanceCarteTest.php`, `RapportFormationTest.php`
Modifiés :
- `app/Models/User.php` (relation `seances()`)
- `routes/staff.php`
- `app/Http/Controllers/Staff/DashboardController.php` (`formateur()`)
- `app/Http/Controllers/Partenaire/DashboardController.php`
- `app/Http/Controllers/Staff/RapportController.php`
- `resources/js/Pages/Staff/Dashboard/Formateur.jsx`, `resources/js/Pages/Staff/Presences/Index.jsx`, `resources/js/Pages/Partenaire/Dashboard.jsx`, `resources/js/Pages/Staff/Rapports/Index.jsx`
- `resources/js/Layouts/AuthenticatedLayout.jsx` (`LIENS_PAR_ROLE`)
- `tests/Feature/Metier/PartenaireDashboardFiltreTest.php`
- `CLAUDE.md`
Routes finales (dans le groupe `auth:web` de `routes/staff.php`, sous `presences.update`, **dans cet ordre**) :
```php
Route::get('seances', [SeanceController::class, 'index'])->name('seances.index');
Route::post('seances', [SeanceController::class, 'store'])->name('seances.store');
Route::post('seances/rattrapage', [SeanceController::class, 'rattrapage'])->name('seances.rattrapage');
Route::patch('seances/{seance}/cloturer', [SeanceController::class, 'cloturer'])->name('seances.cloturer');
Route::put('seances/{seance}', [SeanceController::class, 'update'])->name('seances.update');
```
---
### Task 1: Données, modèle, Policy et scénario de test
**Files:**
- Create: `database/migrations/2026_09_25_000001_create_seances_table.php`
- Create: `app/Models/Seance.php`
- Create: `app/Policies/SeancePolicy.php`
- Modify: `app/Models/User.php` (relation `seances()` après `formations()`)
- Create: `tests/Feature/Seances/ScenarioSeance.php`
- Test: `tests/Feature/Seances/SeancePolicyTest.php`
**Interfaces:**
- Produces: modèle `App\Models\Seance` (relations `formateur()`, `formation()`, `centre()`, `corrigeePar()`, scope `visibleTo(User)`, statique `formaterDuree(?int): string`) ; `SeancePolicy` abilities `viewAny(User)`, `view(User, Seance)`, `create(User, ?Formation)`, `cloturer(User, Seance)`, `update(User, Seance)` ; trait de test `ScenarioSeance` (propriétés `centre`, `formation`, `formateur`, `chapitre`, `module1`, `module2`, `module3`, `leconDuJour`, `inscriptions[0..2]` ; méthodes `preparerScenario()`, `seanceOuverte(array $attrs = []): Seance`, `formateurDUnAutreCentre(): User`).
- [ ] **Step 1: Écrire la migration**
`database/migrations/2026_09_25_000001_create_seances_table.php` :
```php
id();
$table->foreignId('formateur_id')->constrained('users');
$table->foreignId('formation_id')->constrained('formations');
$table->foreignId('centre_id')->constrained('centres');
$table->date('date');
$table->dateTime('ouverte_le')->nullable();
$table->text('prevision')->nullable();
$table->dateTime('cloturee_le')->nullable();
$table->unsignedSmallInteger('duree_minutes')->nullable();
$table->text('bilan')->nullable();
$table->unsignedSmallInteger('nb_inscrits')->nullable();
$table->boolean('saisie_a_posteriori')->default(false);
$table->boolean('cloture_tardive')->default(false);
$table->foreignId('corrigee_par_id')->nullable()->constrained('users')->nullOnDelete();
$table->dateTime('corrigee_le')->nullable();
$table->timestamps();
$table->softDeletes();
$table->unique(['formateur_id', 'formation_id', 'date']);
});
}
public function down(): void
{
Schema::dropIfExists('seances');
}
};
```
- [ ] **Step 2: Écrire le modèle `Seance`**
`app/Models/Seance.php` :
```php
'integer',
'formation_id' => 'integer',
'centre_id' => 'integer',
'date' => 'date:Y-m-d',
'ouverte_le' => 'datetime',
'cloturee_le' => 'datetime',
'corrigee_le' => 'datetime',
'duree_minutes' => 'integer',
'nb_inscrits' => 'integer',
'saisie_a_posteriori' => 'boolean',
'cloture_tardive' => 'boolean',
];
}
public function formateur(): BelongsTo
{
return $this->belongsTo(User::class, 'formateur_id');
}
public function formation(): BelongsTo
{
return $this->belongsTo(Formation::class);
}
public function centre(): BelongsTo
{
return $this->belongsTo(Centre::class);
}
public function corrigeePar(): BelongsTo
{
return $this->belongsTo(User::class, 'corrigee_par_id');
}
/**
* Admin : tout ; gestionnaire : son centre ; formateur : ses séances ;
* autres rôles : rien (le partenaire n'a que des agrégats).
*/
public function scopeVisibleTo(Builder $query, User $user): Builder
{
return match ($user->role) {
RoleStaff::Admin => $query,
RoleStaff::Gestionnaire => $query->where('centre_id', $user->centre_id),
RoleStaff::Formateur => $query->where('formateur_id', $user->id),
default => $query->whereRaw('1 = 0'),
};
}
/** « 3 h 15 », « 45 min », « 2 h », ou '—' si inconnue. */
public static function formaterDuree(?int $minutes): string
{
if ($minutes === null) {
return '—';
}
$heures = intdiv($minutes, 60);
$reste = $minutes % 60;
if ($heures === 0) {
return "{$reste} min";
}
return $reste === 0 ? "{$heures} h" : sprintf('%d h %02d', $heures, $reste);
}
}
```
Dans `app/Models/User.php` (l'import `HasMany` existe déjà), après la méthode `formations()` :
```php
/** Séances pointées par ce formateur (2026-09-25). */
public function seances(): HasMany
{
return $this->hasMany(Seance::class, 'formateur_id');
}
```
- [ ] **Step 3: Écrire la Policy**
`app/Policies/SeancePolicy.php` (découverte automatique Laravel `App\Models\Seance` → `App\Policies\SeancePolicy`, rien à enregistrer) :
```php
role !== RoleStaff::Admin) {
return null;
}
// create / cloturer / update : décidés par les méthodes (un admin ne
// pointe jamais et ne corrige qu'une séance clôturée).
return in_array($ability, ['create', 'cloturer', 'update'], true) ? null : true;
}
public function viewAny(User $user): bool
{
return in_array($user->role, [RoleStaff::Gestionnaire, RoleStaff::Formateur], true);
}
public function view(User $user, Seance $seance): bool
{
return match ($user->role) {
RoleStaff::Gestionnaire => $seance->centre_id === $user->centre_id,
RoleStaff::Formateur => $seance->formateur_id === $user->id,
default => false,
};
}
public function create(User $user, ?Formation $formation = null): bool
{
return $user->role === RoleStaff::Formateur
&& $user->centre_id !== null
&& (! $formation || $user->formations()->where('formations.id', $formation->id)->exists());
}
public function cloturer(User $user, Seance $seance): bool
{
return $user->role === RoleStaff::Formateur
&& $seance->formateur_id === $user->id
&& $seance->cloturee_le === null;
}
/** Durée et bilan : admin sur toute séance clôturée ; formateur la sienne, le jour de la clôture. */
public function update(User $user, Seance $seance): bool
{
if ($seance->cloturee_le === null) {
return false;
}
if ($user->role === RoleStaff::Admin) {
return true;
}
return $user->role === RoleStaff::Formateur
&& $seance->formateur_id === $user->id
&& $seance->cloturee_le->isToday();
}
}
```
- [ ] **Step 4: Écrire le trait de scénario de test**
`tests/Feature/Seances/ScenarioSeance.php` :
```php
*/
protected array $inscriptions = [];
protected function preparerScenario(): void
{
$this->travelTo(Carbon::parse('2026-10-05 08:00:00'));
$this->centre = Centre::create(['nom' => 'Goz Beida', 'ville' => 'Goz Beida', 'statut' => StatutCentre::Actif]);
$this->formation = Formation::create(['titre' => 'Alphabétisation', 'saisie_libre_autorisee' => false]);
$this->formateur = User::factory()->create(['role' => RoleStaff::Formateur, 'centre_id' => $this->centre->id, 'name' => 'Nicolas']);
$this->formateur->formations()->attach($this->formation->id);
$this->chapitre = Chapitre::create(['formation_id' => $this->formation->id, 'centre_id' => $this->centre->id, 'titre' => 'Chapitre 1', 'ordre' => 1]);
$this->module1 = ModuleFormation::create(['formation_id' => $this->formation->id, 'chapitre_id' => $this->chapitre->id, 'titre' => 'Les voyelles', 'ordre' => 1]);
$this->module2 = ModuleFormation::create(['formation_id' => $this->formation->id, 'chapitre_id' => $this->chapitre->id, 'titre' => 'Les consonnes', 'ordre' => 2]);
$this->module3 = ModuleFormation::create(['formation_id' => $this->formation->id, 'chapitre_id' => $this->chapitre->id, 'titre' => 'Les syllabes', 'ordre' => 3]);
$this->leconDuJour = LeconDuJour::create(['module_formation_id' => $this->module1->id, 'date_prevue' => '2026-10-05']);
foreach (['Awa', 'Brahim', 'Chantal'] as $index => $nom) {
$apprenant = Apprenant::create([
'identifiant' => strtolower($nom).'.test',
'password_visible' => Crypt::encryptString('1234'),
'nom_prenom' => $nom,
'formation_id' => $this->formation->id,
'centre_id' => $this->centre->id,
'inscrit_par_id' => $this->formateur->id,
]);
$this->inscriptions[$index] = Inscription::create([
'apprenant_id' => $apprenant->id,
'formation_id' => $this->formation->id,
'statut' => StatutInscription::EnCours,
'inscrit_par_id' => $this->formateur->id,
]);
}
}
/** Séance ouverte aujourd'hui à 08:00 par le formateur du scénario. */
protected function seanceOuverte(array $attrs = []): Seance
{
return Seance::create(array_merge([
'formateur_id' => $this->formateur->id,
'formation_id' => $this->formation->id,
'centre_id' => $this->centre->id,
'date' => '2026-10-05',
'ouverte_le' => Carbon::parse('2026-10-05 08:00:00'),
'prevision' => 'Révision des voyelles',
], $attrs));
}
protected function formateurDUnAutreCentre(): User
{
$autre = Centre::create(['nom' => 'Gerreda', 'ville' => 'Gerreda', 'statut' => StatutCentre::Actif]);
$formateur = User::factory()->create(['role' => RoleStaff::Formateur, 'centre_id' => $autre->id, 'name' => 'Zakaria']);
$formateur->formations()->attach($this->formation->id);
return $formateur;
}
}
```
Note : une leçon (`module_formation_id`) n'a qu'**une** date planifiée (contrainte d'unicité du 2026-08-13). Pour planifier un autre jour, utiliser `module2` ou `module3`, jamais deux fois le même module.
- [ ] **Step 5: Écrire le test de la Policy**
`tests/Feature/Seances/SeancePolicyTest.php` :
```php
preparerScenario();
}
public function test_only_a_formateur_of_the_formation_can_open(): void
{
$admin = User::factory()->create(['role' => RoleStaff::Admin]);
$gestionnaire = User::factory()->create(['role' => RoleStaff::Gestionnaire, 'centre_id' => $this->centre->id]);
$autreFormation = Formation::create(['titre' => 'Informatique']);
$this->assertTrue($this->formateur->can('create', [Seance::class, $this->formation]));
$this->assertFalse($this->formateur->can('create', [Seance::class, $autreFormation]));
$this->assertFalse($admin->can('create', [Seance::class, $this->formation]));
$this->assertFalse($gestionnaire->can('create', [Seance::class, $this->formation]));
}
public function test_view_any_and_view_are_scoped_by_role(): void
{
$seance = $this->seanceOuverte();
$gestionnaire = User::factory()->create(['role' => RoleStaff::Gestionnaire, 'centre_id' => $this->centre->id]);
$gestionnaireAutre = User::factory()->create(['role' => RoleStaff::Gestionnaire, 'centre_id' => $this->formateurDUnAutreCentre()->centre_id]);
$secretaire = User::factory()->create(['role' => RoleStaff::Secretaire, 'centre_id' => $this->centre->id]);
$partenaire = User::factory()->create(['role' => RoleStaff::Partenaire]);
$admin = User::factory()->create(['role' => RoleStaff::Admin]);
foreach ([$this->formateur, $gestionnaire, $admin] as $acteur) {
$this->assertTrue($acteur->can('viewAny', Seance::class));
$this->assertTrue($acteur->can('view', $seance));
}
$this->assertFalse($gestionnaireAutre->can('view', $seance));
foreach ([$secretaire, $partenaire] as $acteur) {
$this->assertFalse($acteur->can('viewAny', Seance::class));
$this->assertFalse($acteur->can('view', $seance));
}
}
public function test_update_rules(): void
{
$admin = User::factory()->create(['role' => RoleStaff::Admin]);
$ouverte = $this->seanceOuverte();
$this->assertFalse($this->formateur->can('update', $ouverte));
$this->assertFalse($admin->can('update', $ouverte));
$ouverte->update(['cloturee_le' => Carbon::parse('2026-10-05 11:00:00'), 'duree_minutes' => 180]);
$this->assertTrue($this->formateur->can('update', $ouverte->fresh()));
$this->travelTo(Carbon::parse('2026-10-06 08:00:00'));
$this->assertFalse($this->formateur->can('update', $ouverte->fresh()));
$this->assertTrue($admin->can('update', $ouverte->fresh()));
}
public function test_visible_to_scope(): void
{
$this->seanceOuverte();
$autre = $this->formateurDUnAutreCentre();
Seance::create([
'formateur_id' => $autre->id, 'formation_id' => $this->formation->id, 'centre_id' => $autre->centre_id,
'date' => '2026-10-05', 'ouverte_le' => now(),
]);
$gestionnaire = User::factory()->create(['role' => RoleStaff::Gestionnaire, 'centre_id' => $this->centre->id]);
$secretaire = User::factory()->create(['role' => RoleStaff::Secretaire, 'centre_id' => $this->centre->id]);
$this->assertSame(1, Seance::visibleTo($this->formateur)->count());
$this->assertSame(1, Seance::visibleTo($gestionnaire)->count());
$this->assertSame(2, Seance::visibleTo(User::factory()->create(['role' => RoleStaff::Admin]))->count());
$this->assertSame(0, Seance::visibleTo($secretaire)->count());
}
public function test_formater_duree(): void
{
$this->assertSame('3 h 15', Seance::formaterDuree(195));
$this->assertSame('2 h', Seance::formaterDuree(120));
$this->assertSame('45 min', Seance::formaterDuree(45));
$this->assertSame('—', Seance::formaterDuree(null));
}
}
```
- [ ] **Step 6: Lancer le test**
Run: `php artisan test --filter=SeancePolicyTest`
Expected: PASS (5 tests).
- [ ] **Step 7: Commit (si autorisé)**
```bash
git add database/migrations/2026_09_25_000001_create_seances_table.php app/Models/Seance.php app/Models/User.php app/Policies/SeancePolicy.php tests/Feature/Seances/ScenarioSeance.php tests/Feature/Seances/SeancePolicyTest.php
git commit -m "Ajoute le modele Seance et sa Policy"
```
---
### Task 2: Ouvrir une séance
**Files:**
- Create: `app/Http/Requests/StoreSeanceRequest.php`
- Create: `app/Actions/Seances/OuvrirSeance.php`
- Create: `app/Http/Controllers/Staff/SeanceController.php` (méthode `store`)
- Modify: `routes/staff.php`
- Test: `tests/Feature/Seances/SeanceOuvertureTest.php`
**Interfaces:**
- Consumes: `Seance`, `SeancePolicy::create`, `App\Rules\DansLaPeriodeDeLaFormation(?Formation, int $nombreJours = 1)` (existante).
- Produces: route `POST seances` → `seances.store` (champs `formation_id`, `prevision`) ; `OuvrirSeance::execute(User $formateur, Formation $formation, ?string $prevision): Seance` ; classe `SeanceController`.
- [ ] **Step 1: Écrire les tests (échouent)**
`tests/Feature/Seances/SeanceOuvertureTest.php` :
```php
preparerScenario();
}
private function ouvrir(User $acteur, array $surcharge = [])
{
return $this->actingAs($acteur)->post(route('seances.store'), array_merge([
'formation_id' => $this->formation->id,
'prevision' => 'Révision des voyelles',
], $surcharge));
}
private function informatiqueEnseignee(): Formation
{
$informatique = Formation::create(['titre' => 'Informatique']);
$this->formateur->formations()->attach($informatique->id);
return $informatique;
}
public function test_formateur_opens_a_session_with_arrival_time(): void
{
$this->ouvrir($this->formateur)->assertSessionHasNoErrors()->assertRedirect();
$seance = Seance::firstOrFail();
$this->assertSame('2026-10-05', $seance->date->toDateString());
$this->assertSame('2026-10-05 08:00:00', $seance->ouverte_le->format('Y-m-d H:i:s'));
$this->assertNull($seance->cloturee_le);
$this->assertSame($this->centre->id, $seance->centre_id);
$this->assertSame('Révision des voyelles', $seance->prevision);
}
public function test_cannot_open_a_second_session_while_one_is_open(): void
{
$informatique = $this->informatiqueEnseignee();
$this->seanceOuverte();
$this->ouvrir($this->formateur, ['formation_id' => $informatique->id])
->assertSessionHasErrors('formation_id');
$this->assertSame(1, Seance::count());
}
public function test_can_chain_a_second_formation_after_closing_the_first(): void
{
$informatique = $this->informatiqueEnseignee();
$this->seanceOuverte(['cloturee_le' => now(), 'duree_minutes' => 60]);
$this->ouvrir($this->formateur, ['formation_id' => $informatique->id])->assertSessionHasNoErrors();
$this->assertSame(2, Seance::count());
}
public function test_cannot_open_the_same_formation_twice_the_same_day(): void
{
$this->seanceOuverte(['cloturee_le' => now(), 'duree_minutes' => 60]);
$this->ouvrir($this->formateur)->assertSessionHasErrors('formation_id');
}
public function test_cannot_open_for_a_formation_not_taught(): void
{
$informatique = Formation::create(['titre' => 'Informatique']);
$this->ouvrir($this->formateur, ['formation_id' => $informatique->id])->assertForbidden();
}
public function test_cannot_open_outside_the_formation_period(): void
{
$this->formation->update(['date_debut' => '2026-11-01', 'date_fin' => '2026-11-30']);
$this->ouvrir($this->formateur)->assertSessionHasErrors('formation_id');
}
public function test_prevision_is_limited(): void
{
$this->ouvrir($this->formateur, ['prevision' => str_repeat('a', 2001)])->assertSessionHasErrors('prevision');
}
public function test_admin_and_gestionnaire_cannot_open(): void
{
$this->ouvrir(User::factory()->create(['role' => RoleStaff::Admin]))->assertForbidden();
$this->ouvrir(User::factory()->create(['role' => RoleStaff::Gestionnaire, 'centre_id' => $this->centre->id]))->assertForbidden();
}
}
```
- [ ] **Step 2: Lancer les tests pour vérifier qu'ils échouent**
Run: `php artisan test --filter=SeanceOuvertureTest`
Expected: FAIL avec « Route [seances.store] not defined ».
- [ ] **Step 3: Écrire la Form Request**
`app/Http/Requests/StoreSeanceRequest.php` :
```php
user()->can('create', [Seance::class, Formation::find($this->integer('formation_id'))]);
}
public function rules(): array
{
return [
'formation_id' => ['required', 'integer', 'exists:formations,id'],
'prevision' => ['nullable', 'string', 'max:2000'],
];
}
public function withValidator($validator): void
{
$validator->after(function ($validator) {
if ($validator->errors()->isNotEmpty()) {
return;
}
$user = $this->user();
$formation = Formation::findOrFail($this->integer('formation_id'));
if (Seance::where('formateur_id', $user->id)->whereNull('cloturee_le')->exists()) {
$validator->errors()->add('formation_id', "Vous avez déjà une séance en cours : clôturez-la avant d'en commencer une autre.");
return;
}
if (Seance::where('formateur_id', $user->id)->where('formation_id', $formation->id)->whereDate('date', today())->exists()) {
$validator->errors()->add('formation_id', "Vous avez déjà pointé une séance pour cette formation aujourd'hui.");
return;
}
(new DansLaPeriodeDeLaFormation($formation))->validate(
'formation_id',
today()->toDateString(),
fn () => $validator->errors()->add('formation_id', sprintf(
"Aujourd'hui est en dehors de la période de cette formation (du %s au %s).",
$formation->date_debut->format('d/m/Y'),
$formation->date_fin->format('d/m/Y'),
)),
);
});
}
}
```
- [ ] **Step 4: Écrire l'Action**
`app/Actions/Seances/OuvrirSeance.php` :
```php
$formateur->id,
'formation_id' => $formation->id,
'centre_id' => $formateur->centre_id,
'date' => now()->toDateString(),
'ouverte_le' => now(),
'prevision' => $prevision,
]);
}
}
```
- [ ] **Step 5: Écrire le contrôleur (méthode `store`) et la route**
`app/Http/Controllers/Staff/SeanceController.php` :
```php
execute(
$request->user(),
Formation::findOrFail($request->integer('formation_id')),
$request->input('prevision'),
);
return back()->with('status', 'Séance commencée. Bonne séance !');
}
}
```
Dans `routes/staff.php` : ajouter `use App\Http\Controllers\Staff\SeanceController;` entre `RapportController` et `UserController`, puis sous la ligne `Route::put('presences/{inscription}', ...)` :
```php
// Séances formateur (2026-09-25) : pointage, cahier de séance, appel.
Route::post('seances', [SeanceController::class, 'store'])->name('seances.store');
```
- [ ] **Step 6: Lancer les tests**
Run: `php artisan test --filter=SeanceOuvertureTest`
Expected: PASS (8 tests).
- [ ] **Step 7: Commit (si autorisé)**
```bash
git add app/Http/Requests/StoreSeanceRequest.php app/Actions/Seances/OuvrirSeance.php app/Http/Controllers/Staff/SeanceController.php routes/staff.php tests/Feature/Seances/SeanceOuvertureTest.php
git commit -m "Permet au formateur d'ouvrir une seance"
```
---
### Task 3: Clôturer une séance avec l'appel
**Files:**
- Create: `app/Actions/Seances/FaireAppel.php`
- Create: `app/Actions/Seances/CloturerSeance.php`
- Create: `app/Http/Requests/CloturerSeanceRequest.php`
- Modify: `app/Http/Controllers/Staff/SeanceController.php` (méthode `cloturer`)
- Modify: `routes/staff.php`
- Test: `tests/Feature/Seances/SeanceClotureTest.php`
**Interfaces:**
- Consumes: `App\Actions\Presence\ValiderPresenceParFormateur::execute(Inscription, string $date, bool $present): void` (existante).
- Produces: `FaireAppel::execute(Seance, array $inscriptionIdsPresents): int` (renvoie le nombre d'inscrits), `FaireAppel::inscriptionsDeLaSeance(Seance): Builder`, `FaireAppel::listePourAppel(Seance): array` (`[['inscription_id' => int, 'nom_prenom' => string, 'present' => bool], ...]` trié par nom) ; `CloturerSeance::execute(Seance, int $dureeMinutes, ?string $bilan, array $presents): Seance` ; route `PATCH seances/{seance}/cloturer` → `seances.cloturer` (champs `duree_minutes`, `bilan`, `presents[]`).
- [ ] **Step 1: Écrire les tests (échouent)**
`tests/Feature/Seances/SeanceClotureTest.php` :
```php
preparerScenario();
}
private function cloturer($seance, array $surcharge = [])
{
return $this->actingAs($this->formateur)->patch(route('seances.cloturer', $seance), array_merge([
'duree_minutes' => 195,
'bilan' => 'Voyelles révisées, bonne participation.',
'presents' => [$this->inscriptions[0]->id, $this->inscriptions[1]->id],
], $surcharge));
}
private function present(int $index, string $date): ?bool
{
$valeur = $this->inscriptions[$index]->presences()->whereDate('date_session', $date)->value('present');
return $valeur === null ? null : (bool) $valeur;
}
public function test_closing_records_duration_bilan_and_enrolled_snapshot(): void
{
$seance = $this->seanceOuverte();
$this->travelTo(Carbon::parse('2026-10-05 11:15:00'));
$this->cloturer($seance)->assertSessionHasNoErrors()->assertRedirect();
$seance->refresh();
$this->assertSame('2026-10-05 11:15:00', $seance->cloturee_le->format('Y-m-d H:i:s'));
$this->assertSame(195, $seance->duree_minutes);
$this->assertSame('Voyelles révisées, bonne participation.', $seance->bilan);
$this->assertSame(3, $seance->nb_inscrits);
$this->assertFalse($seance->cloture_tardive);
}
public function test_roll_call_marks_present_and_checks_the_lessons_of_the_day(): void
{
$this->cloturer($this->seanceOuverte());
$this->assertTrue($this->present(0, '2026-10-05'));
$this->assertTrue(ProgressionModule::where('inscription_id', $this->inscriptions[0]->id)
->where('lecon_du_jour_id', $this->leconDuJour->id)->exists());
$this->assertNull($this->present(2, '2026-10-05'));
}
public function test_unchecking_a_present_apprenant_marks_them_absent(): void
{
Presence::create(['inscription_id' => $this->inscriptions[2]->id, 'date_session' => '2026-10-05', 'present' => true]);
$this->cloturer($this->seanceOuverte());
$this->assertFalse($this->present(2, '2026-10-05'));
}
public function test_closing_the_next_day_is_flagged_late(): void
{
$seance = $this->seanceOuverte();
$this->travelTo(Carbon::parse('2026-10-06 07:30:00'));
$this->cloturer($seance, ['duree_minutes' => 180])->assertSessionHasNoErrors();
$seance->refresh();
$this->assertTrue($seance->cloture_tardive);
$this->assertSame(180, $seance->duree_minutes);
// L'appel s'applique au jour de la séance, pas au jour de la clôture.
$this->assertTrue($this->present(0, '2026-10-05'));
$this->assertNull($this->present(0, '2026-10-06'));
}
public function test_cannot_close_twice_or_someone_elses_session(): void
{
$seance = $this->seanceOuverte();
$this->cloturer($seance);
$this->cloturer($seance)->assertForbidden();
$autre = $this->formateurDUnAutreCentre();
$seanceAutre = $this->seanceOuverte(['formateur_id' => $autre->id, 'centre_id' => $autre->centre_id]);
$this->cloturer($seanceAutre)->assertForbidden();
}
public function test_duration_is_bounded(): void
{
$seance = $this->seanceOuverte();
$this->cloturer($seance, ['duree_minutes' => 721])->assertSessionHasErrors('duree_minutes');
$this->cloturer($seance, ['duree_minutes' => 0])->assertSessionHasErrors('duree_minutes');
$this->assertNull($seance->fresh()->cloturee_le);
}
public function test_foreign_ids_in_the_roll_call_are_ignored(): void
{
$this->cloturer($this->seanceOuverte(), ['presents' => [$this->inscriptions[0]->id, 999999]])
->assertSessionHasNoErrors();
$this->assertSame(1, Presence::where('present', true)->count());
}
}
```
- [ ] **Step 2: Lancer pour vérifier l'échec**
Run: `php artisan test --filter=SeanceClotureTest`
Expected: FAIL avec « Route [seances.cloturer] not defined ».
- [ ] **Step 3: Écrire `FaireAppel`**
`app/Actions/Seances/FaireAppel.php` :
```php
date->toDateString();
$presents = array_map('intval', $inscriptionIdsPresents);
$inscriptions = self::inscriptionsDeLaSeance($seance)
->with(['apprenant', 'presences' => fn ($q) => $q->whereDate('date_session', $date)])
->get();
foreach ($inscriptions as $inscription) {
$etaitPresent = (bool) $inscription->presences->first()?->present;
$doitEtrePresent = in_array($inscription->id, $presents, true);
if ($etaitPresent !== $doitEtrePresent) {
$this->valider->execute($inscription, $date, $doitEtrePresent);
}
}
return $inscriptions->count();
}
/** Inscriptions actives de la formation dans le centre de la séance. */
public static function inscriptionsDeLaSeance(Seance $seance): Builder
{
return Inscription::query()
->where('statut', StatutInscription::EnCours)
->where('formation_id', $seance->formation_id)
->whereHas('apprenant', fn ($q) => $q->where('centre_id', $seance->centre_id));
}
/** Liste pour l'écran d'appel, présents du jour cochés d'office. */
public static function listePourAppel(Seance $seance): array
{
$date = $seance->date->toDateString();
return self::inscriptionsDeLaSeance($seance)
->with(['apprenant', 'presences' => fn ($q) => $q->whereDate('date_session', $date)])
->get()
->map(fn (Inscription $i) => [
'inscription_id' => $i->id,
'nom_prenom' => $i->apprenant->nom_prenom,
'present' => (bool) $i->presences->first()?->present,
])
->sortBy('nom_prenom', SORT_NATURAL | SORT_FLAG_CASE)
->values()
->all();
}
}
```
- [ ] **Step 4: Écrire `CloturerSeance`**
`app/Actions/Seances/CloturerSeance.php` :
```php
appel->execute($seance, $presents);
$seance->update([
'cloturee_le' => now(),
'duree_minutes' => $dureeMinutes,
'bilan' => $bilan,
'nb_inscrits' => $nbInscrits,
'cloture_tardive' => now()->toDateString() !== $seance->date->toDateString(),
]);
return $seance;
});
}
}
```
- [ ] **Step 5: Écrire la Form Request**
`app/Http/Requests/CloturerSeanceRequest.php` :
```php
user()->can('cloturer', $this->route('seance'));
}
public function rules(): array
{
return [
'duree_minutes' => ['required', 'integer', 'min:1', 'max:720'],
'bilan' => ['nullable', 'string', 'max:4000'],
'presents' => ['nullable', 'array'],
'presents.*' => ['integer'],
];
}
public function messages(): array
{
return [
'duree_minutes.required' => 'Indiquez la durée de la séance.',
'duree_minutes.min' => 'Indiquez la durée de la séance.',
'duree_minutes.max' => 'Une séance ne peut pas dépasser 12 heures.',
];
}
}
```
- [ ] **Step 6: Ajouter la méthode `cloturer` et la route**
Dans `SeanceController`, imports `use App\Actions\Seances\CloturerSeance;`, `use App\Http\Requests\CloturerSeanceRequest;`, `use App\Models\Seance;`, puis :
```php
public function cloturer(CloturerSeanceRequest $request, Seance $seance, CloturerSeance $cloturer): RedirectResponse
{
$data = $request->validated();
$cloturer->execute($seance, (int) $data['duree_minutes'], $data['bilan'] ?? null, $data['presents'] ?? []);
return back()->with('status', 'Séance clôturée.');
}
```
Dans `routes/staff.php`, sous `seances.store` :
```php
Route::patch('seances/{seance}/cloturer', [SeanceController::class, 'cloturer'])->name('seances.cloturer');
```
- [ ] **Step 7: Lancer les tests**
Run: `php artisan test --filter="SeanceClotureTest|PresenceValidationFormateurTest"`
Expected: PASS (7 + 8 tests).
- [ ] **Step 8: Commit (si autorisé)**
```bash
git add app/Actions/Seances/FaireAppel.php app/Actions/Seances/CloturerSeance.php app/Http/Requests/CloturerSeanceRequest.php app/Http/Controllers/Staff/SeanceController.php routes/staff.php tests/Feature/Seances/SeanceClotureTest.php
git commit -m "Permet de cloturer une seance avec l'appel de la classe"
```
---
### Task 4: Corriger une séance (durée, bilan)
**Files:**
- Create: `app/Http/Requests/UpdateSeanceRequest.php`
- Modify: `app/Http/Controllers/Staff/SeanceController.php` (méthode `update`)
- Modify: `routes/staff.php`
- Test: `tests/Feature/Seances/SeanceCorrectionTest.php`
**Interfaces:**
- Consumes: `SeancePolicy::update`.
- Produces: route `PUT seances/{seance}` → `seances.update` (champs `duree_minutes`, `bilan`), même contrat pour le formateur et l'admin.
- [ ] **Step 1: Écrire les tests (échouent)**
`tests/Feature/Seances/SeanceCorrectionTest.php` :
```php
preparerScenario();
}
private function seanceCloturee()
{
return $this->seanceOuverte([
'cloturee_le' => Carbon::parse('2026-10-05 11:00:00'),
'duree_minutes' => 180,
'bilan' => 'Bilan initial',
'nb_inscrits' => 3,
]);
}
private function corriger(User $acteur, $seance, array $donnees = ['duree_minutes' => 150, 'bilan' => 'Bilan corrigé'])
{
return $this->actingAs($acteur)->put(route('seances.update', $seance), $donnees);
}
public function test_formateur_corrects_the_same_day(): void
{
$seance = $this->seanceCloturee();
$this->corriger($this->formateur, $seance)->assertSessionHasNoErrors()->assertRedirect();
$seance->refresh();
$this->assertSame(150, $seance->duree_minutes);
$this->assertSame('Bilan corrigé', $seance->bilan);
$this->assertNull($seance->corrigee_par_id);
}
public function test_formateur_cannot_correct_the_next_day(): void
{
$seance = $this->seanceCloturee();
$this->travelTo(Carbon::parse('2026-10-06 09:00:00'));
$this->corriger($this->formateur, $seance)->assertForbidden();
}
public function test_admin_corrects_any_day_and_it_is_traced(): void
{
$seance = $this->seanceCloturee();
$this->travelTo(Carbon::parse('2026-10-10 09:00:00'));
$admin = User::factory()->create(['role' => RoleStaff::Admin]);
$this->corriger($admin, $seance, ['duree_minutes' => 120, 'bilan' => 'Corrigé par admin'])->assertSessionHasNoErrors();
$seance->refresh();
$this->assertSame(120, $seance->duree_minutes);
$this->assertSame('Corrigé par admin', $seance->bilan);
$this->assertSame($admin->id, $seance->corrigee_par_id);
$this->assertSame('2026-10-10', $seance->corrigee_le->toDateString());
$this->assertSame('Révision des voyelles', $seance->prevision);
}
public function test_an_open_session_cannot_be_corrected(): void
{
$seance = $this->seanceOuverte();
$this->corriger(User::factory()->create(['role' => RoleStaff::Admin]), $seance)->assertForbidden();
$this->corriger($this->formateur, $seance)->assertForbidden();
}
public function test_gestionnaire_and_other_formateur_cannot_correct(): void
{
$seance = $this->seanceCloturee();
$this->corriger(User::factory()->create(['role' => RoleStaff::Gestionnaire, 'centre_id' => $this->centre->id]), $seance)->assertForbidden();
$this->corriger($this->formateurDUnAutreCentre(), $seance)->assertForbidden();
}
public function test_duration_is_bounded(): void
{
$this->corriger($this->formateur, $this->seanceCloturee(), ['duree_minutes' => 0, 'bilan' => 'x'])
->assertSessionHasErrors('duree_minutes');
}
}
```
- [ ] **Step 2: Lancer pour vérifier l'échec**
Run: `php artisan test --filter=SeanceCorrectionTest`
Expected: FAIL avec « Route [seances.update] not defined ».
- [ ] **Step 3: Écrire la Form Request**
`app/Http/Requests/UpdateSeanceRequest.php` :
```php
user()->can('update', $this->route('seance'));
}
public function rules(): array
{
return [
'duree_minutes' => ['required', 'integer', 'min:1', 'max:720'],
'bilan' => ['nullable', 'string', 'max:4000'],
];
}
public function messages(): array
{
return [
'duree_minutes.required' => 'Indiquez la durée de la séance.',
'duree_minutes.min' => 'Indiquez la durée de la séance.',
'duree_minutes.max' => 'Une séance ne peut pas dépasser 12 heures.',
];
}
}
```
- [ ] **Step 4: Ajouter la méthode `update` et la route**
Dans `SeanceController`, imports `use App\Enums\RoleStaff;`, `use App\Http\Requests\UpdateSeanceRequest;`, puis :
```php
/** Durée et bilan. Formateur : le jour de la clôture ; admin : toujours, tracé. */
public function update(UpdateSeanceRequest $request, Seance $seance): RedirectResponse
{
$admin = $request->user()->role === RoleStaff::Admin;
$seance->update([
'duree_minutes' => (int) $request->validated('duree_minutes'),
'bilan' => $request->validated('bilan'),
...($admin ? ['corrigee_par_id' => $request->user()->id, 'corrigee_le' => now()] : []),
]);
return back()->with('status', $admin ? 'Séance corrigée.' : 'Séance mise à jour.');
}
```
Route, sous `seances.cloturer` :
```php
Route::put('seances/{seance}', [SeanceController::class, 'update'])->name('seances.update');
```
- [ ] **Step 5: Lancer les tests**
Run: `php artisan test --filter=SeanceCorrectionTest`
Expected: PASS (6 tests).
- [ ] **Step 6: Commit (si autorisé)**
```bash
git add app/Http/Requests/UpdateSeanceRequest.php app/Http/Controllers/Staff/SeanceController.php routes/staff.php tests/Feature/Seances/SeanceCorrectionTest.php
git commit -m "Permet de corriger la duree et le bilan d'une seance"
```
---
### Task 5: Rattrapage d'une séance passée
**Files:**
- Create: `app/Http/Requests/StoreRattrapageSeanceRequest.php`
- Create: `app/Actions/Seances/SaisirSeancePassee.php`
- Modify: `app/Http/Controllers/Staff/SeanceController.php` (méthode `rattrapage`)
- Modify: `routes/staff.php`
- Test: `tests/Feature/Seances/SeanceRattrapageTest.php`
**Interfaces:**
- Consumes: `FaireAppel::inscriptionsDeLaSeance`, `DansLaPeriodeDeLaFormation`, route existante `presences.index` (lit `formation_id` et `date` en query).
- Produces: route `POST seances/rattrapage` → `seances.rattrapage` (champs `formation_id`, `date`, `duree_minutes`, `bilan`) ; `SaisirSeancePassee::execute(User $formateur, Formation $formation, string $date, int $dureeMinutes, ?string $bilan): Seance`.
- [ ] **Step 1: Écrire les tests (échouent)**
`tests/Feature/Seances/SeanceRattrapageTest.php` :
```php
preparerScenario();
}
private function rattraper(array $surcharge = [], ?User $acteur = null)
{
return $this->actingAs($acteur ?? $this->formateur)->post(route('seances.rattrapage'), array_merge([
'formation_id' => $this->formation->id,
'date' => '2026-10-02',
'duree_minutes' => 210,
'bilan' => 'Séance oubliée, rattrapée.',
], $surcharge));
}
public function test_past_session_is_recorded_flagged_and_leads_to_the_roll_call(): void
{
$this->rattraper()
->assertSessionHasNoErrors()
->assertRedirect(route('presences.index', ['formation_id' => $this->formation->id, 'date' => '2026-10-02']));
$seance = Seance::firstOrFail();
$this->assertTrue($seance->saisie_a_posteriori);
$this->assertFalse($seance->cloture_tardive);
$this->assertSame('2026-10-02', $seance->date->toDateString());
$this->assertNull($seance->ouverte_le);
$this->assertNotNull($seance->cloturee_le);
$this->assertSame(210, $seance->duree_minutes);
$this->assertSame(3, $seance->nb_inscrits);
}
public function test_date_window_is_seven_days_before_today(): void
{
$this->rattraper(['date' => '2026-09-27'])->assertSessionHasErrors('date');
$this->rattraper(['date' => '2026-10-05'])->assertSessionHasErrors('date');
$this->rattraper(['date' => '2026-09-28'])->assertSessionHasNoErrors();
}
public function test_cannot_catch_up_a_day_already_recorded(): void
{
$this->rattraper()->assertSessionHasNoErrors();
$this->rattraper()->assertSessionHasErrors('date');
$this->assertSame(1, Seance::count());
}
public function test_catch_up_outside_the_formation_period_is_refused(): void
{
$this->formation->update(['date_debut' => '2026-10-03', 'date_fin' => '2026-10-31']);
$this->rattraper()->assertSessionHasErrors('date');
}
public function test_formateur_can_correct_a_catch_up_the_day_it_was_entered(): void
{
$this->rattraper();
$this->assertTrue($this->formateur->can('update', Seance::firstOrFail()));
}
public function test_only_a_formateur_can_catch_up(): void
{
$this->rattraper([], User::factory()->create(['role' => RoleStaff::Admin]))->assertForbidden();
$this->rattraper([], User::factory()->create(['role' => RoleStaff::Gestionnaire, 'centre_id' => $this->centre->id]))->assertForbidden();
}
}
```
- [ ] **Step 2: Lancer pour vérifier l'échec**
Run: `php artisan test --filter=SeanceRattrapageTest`
Expected: FAIL avec « Route [seances.rattrapage] not defined ».
- [ ] **Step 3: Écrire la Form Request**
`app/Http/Requests/StoreRattrapageSeanceRequest.php` :
```php
user()->can('create', [Seance::class, Formation::find($this->integer('formation_id'))]);
}
public function rules(): array
{
return [
'formation_id' => ['required', 'integer', 'exists:formations,id'],
'date' => [
'required',
'date_format:Y-m-d',
'after_or_equal:'.today()->subDays(7)->toDateString(),
'before:'.today()->toDateString(),
new DansLaPeriodeDeLaFormation(Formation::find($this->integer('formation_id'))),
],
'duree_minutes' => ['required', 'integer', 'min:1', 'max:720'],
'bilan' => ['nullable', 'string', 'max:4000'],
];
}
public function messages(): array
{
return [
'date.after_or_equal' => 'Une séance ne peut être rattrapée que dans les 7 derniers jours.',
'date.before' => "Pour aujourd'hui, utilisez « Commencer la séance ».",
'duree_minutes.required' => 'Indiquez la durée de la séance.',
'duree_minutes.min' => 'Indiquez la durée de la séance.',
'duree_minutes.max' => 'Une séance ne peut pas dépasser 12 heures.',
];
}
public function withValidator($validator): void
{
$validator->after(function ($validator) {
if ($validator->errors()->isNotEmpty()) {
return;
}
$dejaSaisie = Seance::where('formateur_id', $this->user()->id)
->where('formation_id', $this->integer('formation_id'))
->whereDate('date', $this->input('date'))
->exists();
if ($dejaSaisie) {
$validator->errors()->add('date', 'Une séance existe déjà pour cette formation ce jour-là.');
}
});
}
}
```
- [ ] **Step 4: Écrire l'Action**
`app/Actions/Seances/SaisirSeancePassee.php` :
```php
$formateur->id,
'formation_id' => $formation->id,
'centre_id' => $formateur->centre_id,
'date' => Carbon::parse($date)->toDateString(),
'ouverte_le' => null,
'cloturee_le' => now(),
'duree_minutes' => $dureeMinutes,
'bilan' => $bilan,
'saisie_a_posteriori' => true,
]);
$seance->update(['nb_inscrits' => FaireAppel::inscriptionsDeLaSeance($seance)->count()]);
return $seance;
});
}
}
```
- [ ] **Step 5: Ajouter la méthode et la route**
Dans `SeanceController`, imports `use App\Actions\Seances\SaisirSeancePassee;`, `use App\Http\Requests\StoreRattrapageSeanceRequest;`, puis :
```php
/** Séance oubliée : enregistrée, puis direction la page Présence de ce jour pour l'appel. */
public function rattrapage(StoreRattrapageSeanceRequest $request, SaisirSeancePassee $saisir): RedirectResponse
{
$data = $request->validated();
$seance = $saisir->execute(
$request->user(),
Formation::findOrFail($data['formation_id']),
$data['date'],
(int) $data['duree_minutes'],
$data['bilan'] ?? null,
);
return redirect()
->route('presences.index', ['formation_id' => $seance->formation_id, 'date' => $seance->date->toDateString()])
->with('status', 'Séance du '.$seance->date->format('d/m/Y')." enregistrée. Faites maintenant l'appel de ce jour-là.");
}
```
Route, juste sous `seances.store` (littéral avant `seances/{seance}`) :
```php
Route::post('seances/rattrapage', [SeanceController::class, 'rattrapage'])->name('seances.rattrapage');
```
- [ ] **Step 6: Lancer les tests**
Run: `php artisan test --filter=SeanceRattrapageTest`
Expected: PASS (6 tests).
- [ ] **Step 7: Commit (si autorisé)**
```bash
git add app/Http/Requests/StoreRattrapageSeanceRequest.php app/Actions/Seances/SaisirSeancePassee.php app/Http/Controllers/Staff/SeanceController.php routes/staff.php tests/Feature/Seances/SeanceRattrapageTest.php
git commit -m "Permet de saisir une seance passee (rattrapage 7 jours)"
```
---
### Task 6: Page « Séances » (serveur) et format commun
**Files:**
- Create: `app/Actions/Seances/SerialiserSeances.php`
- Modify: `app/Http/Controllers/Staff/SeanceController.php` (méthodes `index`, `parFormateur`)
- Modify: `routes/staff.php`
- Test: `tests/Feature/Seances/PageSeancesTest.php`
**Interfaces:**
- Consumes: `Seance::visibleTo`, `SeancePolicy::viewAny` / `update`.
- Produces:
- `SerialiserSeances::pour(Collection $seances, User $user): Collection` d'éléments `SeanceListe = {id, date, formateur_id, formateur, formation_id, formation, centre, ouverte_le (ISO|null), cloturee_le (ISO|null), duree_minutes, prevision, bilan, presents: string[], nb_inscrits, lecons: string[], saisie_a_posteriori, cloture_tardive, corrigee_le, corrigee_par, modifiable: bool}` ;
- statiques `SerialiserSeances::cle(Seance): string` (`"formation-centre-date"`), `presentsPar(Collection): Collection` et `leconsPar(Collection): Collection` (clé → liste de noms / titres) ;
- route `GET seances` → `seances.index`, query `mois=YYYY-MM`, `centre_id` (admin), `formateur_id` (admin, gestionnaire) ; props `{mois, mois_courant, filtres: {centre_id, formateur_id}, stats: {minutes, seances, a_surveiller}, seances: SeanceListe[]}` + pour admin/gestionnaire `{en_seance: string[], par_formateur: [{id, nom, centre, minutes, seances, assiduite, jours_sans_seance}], centres, formateurs: [{id, nom, centre}]}`.
- [ ] **Step 1: Écrire les tests (échouent)**
`tests/Feature/Seances/PageSeancesTest.php` :
```php
preparerScenario();
$this->admin = User::factory()->create(['role' => RoleStaff::Admin]);
}
private function seanceCloturee(string $date, int $minutes, array $attrs = []): Seance
{
return $this->seanceOuverte(array_merge([
'date' => $date,
'ouverte_le' => Carbon::parse($date.' 08:00'),
'cloturee_le' => Carbon::parse($date.' 08:00')->addMinutes($minutes),
'duree_minutes' => $minutes,
'nb_inscrits' => 3,
], $attrs));
}
private function seanceDeZakaria(string $date, int $minutes, array $attrs = []): Seance
{
$autre = $this->formateurDUnAutreCentre();
return $this->seanceCloturee($date, $minutes, array_merge(['formateur_id' => $autre->id, 'centre_id' => $autre->centre_id], $attrs));
}
public function test_formateur_sees_only_his_sessions_of_the_month(): void
{
$this->seanceCloturee('2026-10-05', 180);
$this->seanceCloturee('2026-10-01', 120);
$this->seanceCloturee('2026-09-30', 120);
$this->seanceDeZakaria('2026-10-05', 60);
$this->actingAs($this->formateur)->get(route('seances.index'))
->assertOk()
->assertInertia(fn (Assert $page) => $page
->component('Staff/Seances/Index')
->where('mois', '2026-10')
->has('seances', 2)
->where('seances.0.date', '2026-10-05')
->where('stats.minutes', 300)
->missing('par_formateur')
->missing('en_seance')
);
}
public function test_month_parameter_and_future_months(): void
{
$this->seanceCloturee('2026-09-30', 120);
$this->actingAs($this->formateur)->get(route('seances.index', ['mois' => '2026-09']))
->assertInertia(fn (Assert $page) => $page->where('mois', '2026-09')->has('seances', 1));
$this->actingAs($this->formateur)->get(route('seances.index', ['mois' => 'n-importe-quoi']))
->assertInertia(fn (Assert $page) => $page->where('mois', '2026-10'));
$this->actingAs($this->formateur)->get(route('seances.index', ['mois' => '2026-11']))
->assertInertia(fn (Assert $page) => $page->where('mois', '2026-10'));
}
public function test_presents_and_lessons_are_read_live(): void
{
$this->seanceCloturee('2026-10-05', 180);
// Présences corrigées après la clôture, depuis la page Présence.
Presence::create(['inscription_id' => $this->inscriptions[2]->id, 'date_session' => '2026-10-05', 'present' => true]);
Presence::create(['inscription_id' => $this->inscriptions[0]->id, 'date_session' => '2026-10-05', 'present' => true]);
Presence::create(['inscription_id' => $this->inscriptions[1]->id, 'date_session' => '2026-10-05', 'present' => false]);
$this->actingAs($this->formateur)->get(route('seances.index'))
->assertInertia(fn (Assert $page) => $page
->where('seances.0.presents', ['Awa', 'Chantal'])
->where('seances.0.nb_inscrits', 3)
->where('seances.0.lecons', ['Les voyelles'])
->where('seances.0.modifiable', true)
);
}
public function test_admin_sees_everything_and_who_is_in_session(): void
{
$this->seanceCloturee('2026-10-02', 180);
$this->seanceOuverte();
$this->seanceDeZakaria('2026-10-05', 60, ['cloture_tardive' => true]);
$this->actingAs($this->admin)->get(route('seances.index'))
->assertInertia(fn (Assert $page) => $page
->where('stats.minutes', 240)
->where('stats.seances', 3)
->where('stats.a_surveiller', 1)
->where('en_seance', ['Nicolas'])
->has('par_formateur', 2)
->has('centres', 2)
->has('formateurs', 2)
->where('seances.0.modifiable', true)
);
}
public function test_gestionnaire_is_limited_to_his_centre_even_with_forced_filters(): void
{
$this->seanceCloturee('2026-10-05', 180);
$zakaria = $this->seanceDeZakaria('2026-10-05', 60);
$gestionnaire = User::factory()->create(['role' => RoleStaff::Gestionnaire, 'centre_id' => $this->centre->id]);
$this->actingAs($gestionnaire)->get(route('seances.index', ['centre_id' => $zakaria->centre_id]))
->assertInertia(fn (Assert $page) => $page
->has('seances', 1)
->where('stats.minutes', 180)
->where('seances.0.modifiable', false)
->has('par_formateur', 1)
->where('centres', [])
);
$this->actingAs($gestionnaire)->get(route('seances.index', ['formateur_id' => $zakaria->formateur_id]))
->assertInertia(fn (Assert $page) => $page->has('seances', 0)->has('par_formateur', 0));
}
public function test_days_without_session_and_attendance_per_formateur(): void
{
// Leçons planifiées le 01/10, le 02/10 et aujourd'hui (05/10) ; séance le 02/10 seulement.
LeconDuJour::create(['module_formation_id' => $this->module2->id, 'date_prevue' => '2026-10-01']);
LeconDuJour::create(['module_formation_id' => $this->module3->id, 'date_prevue' => '2026-10-02']);
$this->seanceCloturee('2026-10-02', 120, ['nb_inscrits' => 2]);
Presence::create(['inscription_id' => $this->inscriptions[0]->id, 'date_session' => '2026-10-02', 'present' => true]);
$this->actingAs($this->admin)->get(route('seances.index'))
->assertInertia(fn (Assert $page) => $page
->where('par_formateur.0.nom', 'Nicolas')
->where('par_formateur.0.minutes', 120)
// Le 01/10 manque ; aujourd'hui n'est pas compté (journée en cours).
->where('par_formateur.0.jours_sans_seance', 1)
->where('par_formateur.0.assiduite', 50)
);
}
public function test_other_roles_are_forbidden(): void
{
foreach ([RoleStaff::Secretaire, RoleStaff::Partenaire] as $role) {
$this->actingAs(User::factory()->create(['role' => $role, 'centre_id' => $this->centre->id]))
->get(route('seances.index'))
->assertForbidden();
}
}
}
```
- [ ] **Step 2: Lancer pour vérifier l'échec**
Run: `php artisan test --filter=PageSeancesTest`
Expected: FAIL avec « Route [seances.index] not defined ».
- [ ] **Step 3: Écrire `SerialiserSeances`**
`app/Actions/Seances/SerialiserSeances.php` :
```php
$seances */
public function pour(Collection $seances, User $user): Collection
{
// Une collection de base (ex. issue d'un merge) n'a pas loadMissing().
$seances = EloquentCollection::make($seances->all());
$seances->loadMissing(['formateur:id,name', 'formation:id,titre', 'centre:id,nom', 'corrigeePar:id,name']);
$presents = self::presentsPar($seances);
$lecons = self::leconsPar($seances);
return $seances->map(fn (Seance $s) => [
'id' => $s->id,
'date' => $s->date->toDateString(),
'formateur_id' => $s->formateur_id,
'formateur' => $s->formateur?->name,
'formation_id' => $s->formation_id,
'formation' => $s->formation?->titre,
'centre' => $s->centre?->nom,
'ouverte_le' => $s->ouverte_le?->toIso8601String(),
'cloturee_le' => $s->cloturee_le?->toIso8601String(),
'duree_minutes' => $s->duree_minutes,
'prevision' => $s->prevision,
'bilan' => $s->bilan,
'presents' => $presents->get(self::cle($s), collect())->values()->all(),
'nb_inscrits' => $s->nb_inscrits,
'lecons' => $lecons->get(self::cle($s), collect())->values()->all(),
'saisie_a_posteriori' => $s->saisie_a_posteriori,
'cloture_tardive' => $s->cloture_tardive,
'corrigee_le' => $s->corrigee_le?->toIso8601String(),
'corrigee_par' => $s->corrigeePar?->name,
'modifiable' => $user->can('update', $s),
])->values();
}
/** Clé de regroupement « formation-centre-date » (présence et planning sont par jour). */
public static function cle(Seance $s): string
{
return "{$s->formation_id}-{$s->centre_id}-{$s->date->toDateString()}";
}
/** Noms des apprenants présents, par clé, triés. */
public static function presentsPar(Collection $seances): Collection
{
if ($seances->isEmpty()) {
return collect();
}
$dates = $seances->map(fn (Seance $s) => $s->date->toDateString());
return Presence::query()
->where('present', true)
->whereDate('date_session', '>=', $dates->min())
->whereDate('date_session', '<=', $dates->max())
->whereHas('inscription', fn ($q) => $q
->whereIn('formation_id', $seances->pluck('formation_id')->unique())
->whereHas('apprenant', fn ($q2) => $q2->whereIn('centre_id', $seances->pluck('centre_id')->unique())))
->with('inscription.apprenant:id,nom_prenom,centre_id')
->get()
->filter(fn (Presence $p) => $p->inscription?->apprenant)
->groupBy(fn (Presence $p) => "{$p->inscription->formation_id}-{$p->inscription->apprenant->centre_id}-{$p->date_session->toDateString()}")
->map(fn (Collection $groupe) => $groupe
->pluck('inscription.apprenant.nom_prenom')
->sort(SORT_NATURAL | SORT_FLAG_CASE)
->values());
}
/** Titres des leçons planifiées, par clé, dans l'ordre du programme. */
public static function leconsPar(Collection $seances): Collection
{
if ($seances->isEmpty()) {
return collect();
}
$dates = $seances->map(fn (Seance $s) => $s->date->toDateString());
return LeconDuJour::query()
->whereDate('date_prevue', '>=', $dates->min())
->whereDate('date_prevue', '<=', $dates->max())
->whereHas('moduleFormation.chapitre', fn ($q) => $q
->whereIn('formation_id', $seances->pluck('formation_id')->unique())
->whereIn('centre_id', $seances->pluck('centre_id')->unique()))
->with(['moduleFormation:id,titre,ordre,chapitre_id', 'moduleFormation.chapitre:id,formation_id,centre_id,ordre'])
->get()
->sortBy(fn (LeconDuJour $l) => sprintf('%05d-%05d', $l->moduleFormation->chapitre->ordre, $l->moduleFormation->ordre))
->groupBy(fn (LeconDuJour $l) => "{$l->moduleFormation->chapitre->formation_id}-{$l->moduleFormation->chapitre->centre_id}-{$l->date_prevue->toDateString()}")
->map(fn (Collection $groupe) => $groupe->pluck('moduleFormation.titre')->values());
}
}
```
- [ ] **Step 4: Méthode `index` et synthèse par formateur**
Dans `SeanceController`, imports `use App\Actions\Seances\SerialiserSeances;`, `use App\Models\Centre;`, `use App\Models\LeconDuJour;`, `use App\Models\User;`, `use Illuminate\Http\Request;`, `use Illuminate\Support\Carbon;`, `use Illuminate\Support\Collection;`, `use Inertia\Inertia;`, `use Inertia\Response;`, puis :
```php
/**
* Page « Séances » : le formateur voit les siennes, le gestionnaire son
* centre (lecture), l'admin tout (correction). Navigation par mois.
* Les props lourdes sont des closures : le rafraîchissement périodique
* de « en séance maintenant » ne recalcule qu'elle.
*/
public function index(Request $request, SerialiserSeances $serialiser): Response
{
$this->authorize('viewAny', Seance::class);
$user = $request->user();
$admin = $user->role === RoleStaff::Admin;
$suivi = $user->role !== RoleStaff::Formateur;
$moisCourant = today()->format('Y-m');
$demande = (string) $request->query('mois');
$mois = preg_match('/^\d{4}-(0[1-9]|1[0-2])$/', $demande) && $demande <= $moisCourant ? $demande : $moisCourant;
$debut = Carbon::createFromFormat('Y-m-d', $mois.'-01')->startOfDay();
$fin = $debut->copy()->endOfMonth()->startOfDay();
$centreId = $admin ? ($request->integer('centre_id') ?: null) : null;
$formateurId = $suivi ? ($request->integer('formateur_id') ?: null) : null;
$lignes = null;
$chargerLignes = function () use (&$lignes, $serialiser, $user, $debut, $fin, $centreId, $formateurId): Collection {
return $lignes ??= $serialiser->pour(
Seance::visibleTo($user)
->whereDate('date', '>=', $debut)
->whereDate('date', '<=', $fin)
->when($centreId, fn ($q) => $q->where('centre_id', $centreId))
->when($formateurId, fn ($q) => $q->where('formateur_id', $formateurId))
->orderByDesc('date')
->orderByDesc('id')
->get(),
$user,
);
};
$props = [
'mois' => $mois,
'mois_courant' => $moisCourant,
'filtres' => ['centre_id' => $centreId, 'formateur_id' => $formateurId],
'stats' => fn () => [
'minutes' => (int) $chargerLignes()->sum('duree_minutes'),
'seances' => $chargerLignes()->count(),
'a_surveiller' => $chargerLignes()->filter(fn (array $s) => $s['cloture_tardive']
|| $s['saisie_a_posteriori']
|| ($s['cloturee_le'] === null && $s['date'] < today()->toDateString()))->count(),
],
'seances' => fn () => $chargerLignes()->all(),
];
if ($suivi) {
$formateurs = User::where('role', RoleStaff::Formateur)
->when(! $admin, fn ($q) => $q->where('centre_id', $user->centre_id))
->when($centreId, fn ($q) => $q->where('centre_id', $centreId))
->with(['centre:id,nom', 'formations' => fn ($q) => $q->select('formations.id')])
->orderBy('name')
->get(['id', 'name', 'centre_id']);
$props += [
'en_seance' => fn () => Seance::visibleTo($user)
->whereNull('cloturee_le')
->whereDate('date', today())
->when($centreId, fn ($q) => $q->where('centre_id', $centreId))
->with('formateur:id,name')
->get()
->pluck('formateur.name')
->filter()
->sort(SORT_NATURAL | SORT_FLAG_CASE)
->values()
->all(),
'par_formateur' => fn () => $this->parFormateur(
$formateurs->when($formateurId, fn (Collection $c) => $c->where('id', $formateurId)),
$chargerLignes(),
$debut,
$fin,
),
'centres' => $admin ? Centre::orderBy('nom')->get(['id', 'nom']) : [],
'formateurs' => $formateurs->map(fn (User $f) => ['id' => $f->id, 'nom' => $f->name, 'centre' => $f->centre?->nom])->values(),
];
}
return Inertia::render('Staff/Seances/Index', $props);
}
/**
* Heures, séances, assiduité moyenne (présents / inscrits) et jours sans
* séance : couples (formation, jour) du mois, jusqu'à la veille, où une
* leçon était planifiée dans son centre pour une de ses formations sans
* séance de sa part pour cette formation. Une seule requête de leçons.
*/
private function parFormateur(Collection $formateurs, Collection $lignes, Carbon $debut, Carbon $fin): array
{
$jusqua = $fin->lt(today()->subDay()) ? $fin : today()->subDay();
$planifies = $formateurs->isEmpty() || $jusqua->lt($debut) ? collect() : LeconDuJour::query()
->whereDate('date_prevue', '>=', $debut)
->whereDate('date_prevue', '<=', $jusqua)
->whereHas('moduleFormation.chapitre', fn ($q) => $q->whereIn('centre_id', $formateurs->pluck('centre_id')->filter()->unique()))
->with('moduleFormation.chapitre:id,formation_id,centre_id')
->get()
->map(fn (LeconDuJour $l) => [
'centre_id' => $l->moduleFormation->chapitre->centre_id,
'formation_id' => $l->moduleFormation->chapitre->formation_id,
'cle' => $l->moduleFormation->chapitre->formation_id.'|'.$l->date_prevue->toDateString(),
]);
return $formateurs->map(function (User $f) use ($lignes, $planifies) {
$siennes = $lignes->where('formateur_id', $f->id);
$avecAppel = $siennes->filter(fn (array $s) => $s['cloturee_le'] !== null && $s['nb_inscrits'] > 0);
$formationIds = $f->formations->pluck('id')->all();
$attendus = $planifies
->filter(fn (array $p) => $p['centre_id'] == $f->centre_id && in_array($p['formation_id'], $formationIds))
->pluck('cle')
->unique();
$pointes = $siennes->map(fn (array $s) => $s['formation_id'].'|'.$s['date'])->unique();
return [
'id' => $f->id,
'nom' => $f->name,
'centre' => $f->centre?->nom,
'minutes' => (int) $siennes->sum('duree_minutes'),
'seances' => $siennes->count(),
'assiduite' => $avecAppel->isEmpty()
? null
: (int) round($avecAppel->avg(fn (array $s) => count($s['presents']) / $s['nb_inscrits']) * 100),
'jours_sans_seance' => $attendus->diff($pointes)->count(),
];
})->values()->all();
}
```
Route, **en tête** des routes séances (avant `seances.store`) :
```php
Route::get('seances', [SeanceController::class, 'index'])->name('seances.index');
```
- [ ] **Step 5: Lancer les tests**
Run: `php artisan test --filter=PageSeancesTest`
Expected: PASS (7 tests). La page React n'existe pas encore : les tests Inertia n'en ont pas besoin (`assertInertia` ne rend pas le composant).
- [ ] **Step 6: Commit (si autorisé)**
```bash
git add app/Actions/Seances/SerialiserSeances.php app/Http/Controllers/Staff/SeanceController.php routes/staff.php tests/Feature/Seances/PageSeancesTest.php
git commit -m "Ajoute la page Seances (portee selon le role) cote serveur"
```
---
### Task 7: Données de la carte « Ma séance du jour »
**Files:**
- Create: `app/Actions/Seances/DonneesCarteSeance.php`
- Modify: `app/Http/Controllers/Staff/DashboardController.php` (méthode `formateur`)
- Test: `tests/Feature/Seances/SeanceCarteTest.php`
**Interfaces:**
- Consumes: `SerialiserSeances::pour`, `FaireAppel::listePourAppel`.
- Produces: prop Inertia `seance` sur `Staff/Dashboard/Formateur` :
```
{
en_cours: (SeanceListe & {appel: [{inscription_id, nom_prenom, present}]}) | null,
du_jour: SeanceListe[], // clôturées aujourd'hui
formations: [{id, titre}], // toutes les siennes (rattrapage)
formations_disponibles: [{id, titre}], // pas encore pointées aujourd'hui, [] si une séance est ouverte
lecons_du_jour: {[formation_id]: string[]}, // titres planifiés aujourd'hui dans son centre
}
```
- [ ] **Step 1: Écrire les tests (échouent)**
`tests/Feature/Seances/SeanceCarteTest.php` :
```php
preparerScenario();
}
public function test_card_offers_to_start_when_nothing_is_open(): void
{
$this->actingAs($this->formateur)->get(route('dashboard'))
->assertOk()
->assertInertia(fn (Assert $page) => $page
->where('seance.en_cours', null)
->has('seance.formations', 1)
->has('seance.formations_disponibles', 1)
->where('seance.lecons_du_jour.'.$this->formation->id, ['Les voyelles'])
);
}
public function test_card_shows_the_open_session_with_its_roll_call(): void
{
$seance = $this->seanceOuverte();
$this->actingAs($this->formateur)->get(route('dashboard'))
->assertInertia(fn (Assert $page) => $page
->where('seance.en_cours.id', $seance->id)
->where('seance.en_cours.prevision', 'Révision des voyelles')
->where('seance.en_cours.lecons', ['Les voyelles'])
->has('seance.en_cours.appel', 3)
->where('seance.en_cours.appel.0.nom_prenom', 'Awa')
->has('seance.formations_disponibles', 0)
);
}
public function test_card_shows_yesterdays_open_session(): void
{
$seance = $this->seanceOuverte();
$this->travelTo(Carbon::parse('2026-10-06 08:00:00'));
$this->actingAs($this->formateur)->get(route('dashboard'))
->assertInertia(fn (Assert $page) => $page
->where('seance.en_cours.id', $seance->id)
->where('seance.en_cours.date', '2026-10-05')
->has('seance.formations_disponibles', 0)
);
}
public function test_closed_sessions_of_the_day_are_listed(): void
{
$this->seanceOuverte(['cloturee_le' => now(), 'duree_minutes' => 60, 'nb_inscrits' => 3]);
$this->actingAs($this->formateur)->get(route('dashboard'))
->assertInertia(fn (Assert $page) => $page
->where('seance.en_cours', null)
->has('seance.du_jour', 1)
->where('seance.du_jour.0.modifiable', true)
->has('seance.formations_disponibles', 0)
);
}
}
```
- [ ] **Step 2: Lancer pour vérifier l'échec**
Run: `php artisan test --filter=SeanceCarteTest`
Expected: FAIL (prop `seance` absente).
- [ ] **Step 3: Écrire `DonneesCarteSeance`**
`app/Actions/Seances/DonneesCarteSeance.php` :
```php
toDateString();
$formations = $formateur->formations()->orderBy('titre')->get(['formations.id', 'formations.titre'])
->map(fn ($f) => ['id' => $f->id, 'titre' => $f->titre])
->values();
$enCours = Seance::where('formateur_id', $formateur->id)->whereNull('cloturee_le')->first();
$duJour = Seance::where('formateur_id', $formateur->id)
->whereDate('date', $aujourdhui)
->whereNotNull('cloturee_le')
->orderBy('id')
->get();
$serialisees = $this->serialiser
->pour(collect([$enCours])->filter()->merge($duJour), $formateur)
->keyBy('id');
$dejaPointees = Seance::where('formateur_id', $formateur->id)->whereDate('date', $aujourdhui)->pluck('formation_id');
$leconsDuJour = LeconDuJour::query()
->whereDate('date_prevue', $aujourdhui)
->whereHas('moduleFormation.chapitre', fn ($q) => $q
->whereIn('formation_id', $formations->pluck('id'))
->where('centre_id', $formateur->centre_id))
->with(['moduleFormation:id,titre,ordre,chapitre_id', 'moduleFormation.chapitre:id,formation_id,ordre'])
->get()
->sortBy(fn (LeconDuJour $l) => sprintf('%05d-%05d', $l->moduleFormation->chapitre->ordre, $l->moduleFormation->ordre))
->groupBy(fn (LeconDuJour $l) => $l->moduleFormation->chapitre->formation_id)
->map(fn ($lecons) => $lecons->pluck('moduleFormation.titre')->values());
return [
'en_cours' => $enCours
? array_merge($serialisees[$enCours->id], ['appel' => FaireAppel::listePourAppel($enCours)])
: null,
'du_jour' => $duJour->map(fn (Seance $s) => $serialisees[$s->id])->values(),
'formations' => $formations,
'formations_disponibles' => $enCours ? [] : $formations->whereNotIn('id', $dejaPointees)->values(),
'lecons_du_jour' => $leconsDuJour,
];
}
}
```
- [ ] **Step 4: Brancher la carte dans `DashboardController::formateur()`**
Ajouter l'import `use App\Actions\Seances\DonneesCarteSeance;` et, dans le tableau de `Inertia::render('Staff/Dashboard/Formateur', [...])`, après `'activite_recente' => ...` :
```php
// Carte « Ma séance du jour » (2026-09-25).
'seance' => app(DonneesCarteSeance::class)->pour($user),
```
- [ ] **Step 5: Lancer les tests**
Run: `php artisan test --filter="SeanceCarteTest|DashboardRedirectTest"`
Expected: PASS.
- [ ] **Step 6: Commit (si autorisé)**
```bash
git add app/Actions/Seances/DonneesCarteSeance.php app/Http/Controllers/Staff/DashboardController.php tests/Feature/Seances/SeanceCarteTest.php
git commit -m "Prepare les donnees de la carte Ma seance du jour"
```
---
### Task 8: Interface (carte, modales, page Séances, menu, messages)
**Files:**
- Create: `resources/js/lib/seances.js`
- Create: `resources/js/Pages/Staff/Seances/Partials/ChampDuree.jsx`, `ListeAppel.jsx`, `OuvrirSeanceForm.jsx`, `CloturerSeanceForm.jsx`, `RattrapageSeanceForm.jsx`, `DetailSeance.jsx`, `CarteSeance.jsx`
- Create: `resources/js/Pages/Staff/Seances/Index.jsx`
- Modify: `resources/js/Pages/Staff/Dashboard/Formateur.jsx`
- Modify: `resources/js/Pages/Staff/Presences/Index.jsx` (afficher `FlashStatus`)
- Modify: `resources/js/Layouts/AuthenticatedLayout.jsx` (`LIENS_PAR_ROLE`)
**Interfaces:**
- Consumes: props des Tasks 6 et 7 ; routes `seances.index`, `seances.store`, `seances.cloturer`, `seances.update`, `seances.rattrapage` ; `usePolling(only, intervalMs, actif)` ; composants `Modal` (`show`, `onClose`, `title`), `ModalActions`, `Select` (valeur renvoyée en chaîne), `DatePicker` (`min`, `max`), `DataTable` (`columns`, `rows`, `actions`, `empty`, `numerote`), `StatTile` (`icon`, `valeur`, `libelle`, `couleur`, `fond`), `Badge` (`tone`), `FiltreChamp` (`icon`, `label`), `FlashStatus`.
- Produces: fonctions de `resources/js/lib/seances.js` : `formaterDuree`, `minutesDepuis`, `arrondiQuartDHeure`, `heureLocale`, `dateLocaleISO`, `decalerJours`, `formatDateFr`, `etatsSeance`, `decalerMois`, `libelleMois`.
Aucun test JS dans ce projet : la vérification est le build + la suite PHP + contrôle visuel par le porteur de projet.
- [ ] **Step 1: Utilitaires**
`resources/js/lib/seances.js` :
```js
// Utilitaires d'affichage des séances formateur (2026-09-25).
export function formaterDuree(minutes) {
if (minutes === null || minutes === undefined) return '—';
const heures = Math.floor(minutes / 60);
const reste = minutes % 60;
if (heures === 0) return `${reste} min`;
return reste === 0 ? `${heures} h` : `${heures} h ${String(reste).padStart(2, '0')}`;
}
export function minutesDepuis(iso, maintenant = new Date()) {
return Math.max(0, Math.floor((maintenant - new Date(iso)) / 60000));
}
// Durée proposée à la clôture : arrondie au quart d'heure, entre 15 min et 12 h.
export function arrondiQuartDHeure(minutes) {
return Math.min(720, Math.max(15, Math.round(minutes / 15) * 15));
}
export function heureLocale(iso) {
return new Date(iso).toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit' });
}
// Date locale 'YYYY-MM-DD' (toISOString() convertit en UTC : piège documenté).
export function dateLocaleISO(date = new Date()) {
const mois = String(date.getMonth() + 1).padStart(2, '0');
const jour = String(date.getDate()).padStart(2, '0');
return `${date.getFullYear()}-${mois}-${jour}`;
}
export function decalerJours(jours) {
const d = new Date();
d.setDate(d.getDate() + jours);
return dateLocaleISO(d);
}
export function formatDateFr(iso) {
const [annee, mois, jour] = iso.slice(0, 10).split('-');
return `${jour}/${mois}/${annee}`;
}
// Badges d'état d'une séance, tons de Components/Badge.
export function etatsSeance(seance) {
if (!seance.cloturee_le) return [{ label: 'En cours', tone: 'info' }];
const etats = [];
if (seance.cloture_tardive) etats.push({ label: 'Tardive', tone: 'warning' });
if (seance.saisie_a_posteriori) etats.push({ label: 'A posteriori', tone: 'neutral' });
if (seance.corrigee_le) etats.push({ label: 'Corrigée', tone: 'neutral' });
if (etats.length === 0) etats.push({ label: 'Clôturée', tone: 'success' });
return etats;
}
export function decalerMois(mois, delta) {
const [annee, m] = mois.split('-').map(Number);
const d = new Date(annee, m - 1 + delta, 1);
return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}`;
}
export function libelleMois(mois) {
const [annee, m] = mois.split('-').map(Number);
const texte = new Date(annee, m - 1, 1).toLocaleDateString('fr-FR', { month: 'long', year: 'numeric' });
return texte.charAt(0).toUpperCase() + texte.slice(1);
}
```
- [ ] **Step 2: Champs partagés**
`resources/js/Pages/Staff/Seances/Partials/ChampDuree.jsx` :
```jsx
import Select from '@/Components/Select';
import TextInput from '@/Components/TextInput';
// Durée saisie en heures + minutes, renvoyée en minutes (2026-09-25).
export default function ChampDuree({ id = 'duree', minutes, onChange }) {
const total = minutes || 0;
const heures = Math.floor(total / 60);
const reste = total % 60;
const quarts = [0, 15, 30, 45];
const options = (quarts.includes(reste) ? quarts : [...quarts, reste].sort((a, b) => a - b))
.map((m) => ({ value: m, label: String(m).padStart(2, '0') }));
const maj = (h, m) => onChange(Math.min(12, Math.max(0, h)) * 60 + m);
return (
maj(Number(e.target.value) || 0, reste)}
/>
h
);
}
```
`resources/js/Pages/Staff/Seances/Partials/ListeAppel.jsx` :
```jsx
import Checkbox from '@/Components/Checkbox';
// Appel de la classe : présents cochés, « Tous présents » en un clic.
export default function ListeAppel({ apprenants, presents, onChange }) {
const basculer = (id) => onChange(presents.includes(id) ? presents.filter((x) => x !== id) : [...presents, id]);
if (apprenants.length === 0) {
return
Aucun apprenant inscrit à cette formation.
;
}
return (
{presents.length} présent{presents.length > 1 ? 's' : ''} sur {apprenants.length}
{apprenants.map((a) => (
))}
Un apprenant coché est marqué présent et ses leçons du jour sont validées. Décocher un apprenant
déjà présent annule sa présence et ses leçons du jour.
);
}
```
- [ ] **Step 3: Modales d'ouverture, de clôture et de rattrapage**
`resources/js/Pages/Staff/Seances/Partials/OuvrirSeanceForm.jsx` :
```jsx
import InputError from '@/Components/InputError';
import InputLabel from '@/Components/InputLabel';
import ModalActions from '@/Components/ModalActions';
import PrimaryButton from '@/Components/PrimaryButton';
import SecondaryButton from '@/Components/SecondaryButton';
import Select from '@/Components/Select';
import { useForm } from '@inertiajs/react';
const zoneTexte =
'mt-1 block w-full rounded-lg border-slate-300 px-3.5 py-2.5 text-base shadow-sm focus:border-slate-400 focus:ring-slate-400 sm:text-sm';
export default function OuvrirSeanceForm({ carte, onClose }) {
const formations = carte.formations_disponibles;
const { data, setData, post, processing, errors } = useForm({
formation_id: formations[0]?.id ?? '',
prevision: '',
});
const lecons = carte.lecons_du_jour[data.formation_id] ?? [];
const submit = (e) => {
e.preventDefault();
post(route('seances.store'), { preserveScroll: true, onSuccess: onClose });
};
return (