fix(rbac) : rattache le rôle de base « user » et gate le frontend par permission

Un user avec des permissions sur le rôle RBAC « user » ne voyait rien : le
ROLE_USER legacy n'a aucun lien avec le RBAC et getEffectivePermissions() ne lit
que rbacRoles + permissions directes, alors qu'aucun user n'était rattaché au
rôle « user » (table user_role vide, jamais backfillée).

Backend
- DefaultUserRoleAssigner + UserDefaultRoleListener (prePersist) : tout nouvel
  utilisateur est rattaché au rôle « user » sur tous les chemins de persistance.
- Commande app:assign-default-roles (backfill idempotent) + ajout au deploy.sh.
- AppFixtures : seed des rôles système avant la création des users.

Frontend (gating par permission au lieu de ROLE_ADMIN legacy)
- Nouveau middleware « permission » + augmentation PageMeta : definePageMeta
  ({ permission }) (string = requise, array = any), ROLE_ADMIN bypasse.
- Pages directory/reporting/admin gatées par permission ; SidebarFilter accepte
  une liste de permissions (any) ; section admin sans gate de rôle.
- team-absences reste en ROLE_ADMIN (module Absence non RBAC-isé côté backend).

src/DataFixtures/AppFixtures.php

@@ -45,6 +45,11 @@ class AppFixtures extends Fixture
 
     public function load(ObjectManager $manager): void
     {
+        // Seed des rôles système RBAC (admin, user) AVANT toute création d'utilisateur :
+        // UserDefaultRoleListener (prePersist) rattache le rôle « user » à chaque user,
+        // le rôle doit donc déjà exister en base au moment du persist().
+        $this->rbacSeeder->ensureSystemRoles();
+
         // Users
         $admin = new User();
         $admin->setUsername('admin');
@@ -826,9 +831,5 @@ class AppFixtures extends Fixture
         $manager->persist($pendingMarriage);
 
         $manager->flush();
-
-        // Seed des rôles système RBAC (admin, user). Idempotent ; aucune matrice
-        // métier attachée (cf. Décision 4 : les modules métier arrivent en 2.x).
-        $this->rbacSeeder->ensureSystemRoles();
     }
 }

src/Module/Core/Application/Rbac/DefaultUserRoleAssigner.php

@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Application\Rbac;
+
+use App\Module\Core\Domain\Entity\User;
+use App\Module\Core\Domain\Repository\RoleRepositoryInterface;
+use App\Module\Core\Domain\Security\SystemRoles;
+use Doctrine\ORM\EntityManagerInterface;
+
+use function count;
+
+/**
+ * Garantit que chaque utilisateur porte le rôle RBAC de base « user ».
+ *
+ * Le rôle « user » est le socle commun : il porte les permissions par défaut
+ * des non-admins. Sans rattachement explicite dans user_role,
+ * User::getEffectivePermissions() reste vide — le ROLE_USER legacy n'a aucun
+ * lien avec le rôle RBAC « user ».
+ */
+final readonly class DefaultUserRoleAssigner
+{
+    public function __construct(
+        private RoleRepositoryInterface $roles,
+        private EntityManagerInterface $em,
+    ) {}
+
+    /**
+     * Ajoute le rôle « user » à l'utilisateur s'il ne l'a pas déjà.
+     * Ne flush pas : appelé en prePersist (création) ou par le backfill.
+     */
+    public function ensureDefaultRole(User $user): void
+    {
+        $userRole = $this->roles->findByCode(SystemRoles::USER_CODE);
+        if (null === $userRole) {
+            // Rôle non seedé : dégradation gracieuse, on ne bloque pas la création.
+            return;
+        }
+
+        foreach ($user->getRbacRoles() as $role) {
+            if (SystemRoles::USER_CODE === $role->getCode()) {
+                return;
+            }
+        }
+
+        $user->addRbacRole($userRole);
+    }
+
+    /**
+     * Rattache le rôle « user » à tous les utilisateurs qui ne l'ont pas.
+     * Idempotent. Retourne le nombre d'utilisateurs modifiés.
+     */
+    public function backfill(): int
+    {
+        $userRole = $this->roles->findByCode(SystemRoles::USER_CODE);
+        if (null === $userRole) {
+            return 0;
+        }
+
+        /** @var list<User> $users */
+        $users = $this->em
+            ->createQuery('SELECT u FROM '.User::class.' u WHERE :role NOT MEMBER OF u.rbacRoles')
+            ->setParameter('role', $userRole)
+            ->getResult()
+        ;
+
+        foreach ($users as $user) {
+            $user->addRbacRole($userRole);
+        }
+
+        $this->em->flush();
+
+        return count($users);
+    }
+}

src/Module/Core/Infrastructure/Console/AssignDefaultRolesCommand.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\Console;
+
+use App\Module\Core\Application\Rbac\DefaultUserRoleAssigner;
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+use function sprintf;
+
+#[AsCommand(
+    name: 'app:assign-default-roles',
+    description: 'Rattache le rôle RBAC de base « user » à tous les utilisateurs qui ne l\'ont pas.',
+)]
+final class AssignDefaultRolesCommand extends Command
+{
+    public function __construct(private readonly DefaultUserRoleAssigner $assigner)
+    {
+        parent::__construct();
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $io    = new SymfonyStyle($input, $output);
+        $count = $this->assigner->backfill();
+        $io->success(sprintf('%d utilisateur(s) rattaché(s) au rôle « user ».', $count));
+
+        return Command::SUCCESS;
+    }
+}

src/Module/Core/Infrastructure/EventListener/UserDefaultRoleListener.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\EventListener;
+
+use App\Module\Core\Application\Rbac\DefaultUserRoleAssigner;
+use App\Module\Core\Domain\Entity\User;
+use Doctrine\ORM\Event\PrePersistEventArgs;
+
+/**
+ * Assigne le rôle RBAC de base « user » à tout nouvel utilisateur qui n'en a pas,
+ * quel que soit le chemin de persistance (API Platform, fixtures, MCP).
+ *
+ * Sans ça, un user créé n'est rattaché à aucun rôle RBAC et ses permissions
+ * effectives restent vides, peu importe les permissions portées par le rôle.
+ */
+final readonly class UserDefaultRoleListener
+{
+    public function __construct(private DefaultUserRoleAssigner $assigner) {}
+
+    public function prePersist(User $user, PrePersistEventArgs $args): void
+    {
+        $this->assigner->ensureDefaultRole($user);
+    }
+}

src/Shared/Domain/Sidebar/SidebarFilter.php

@@ -7,10 +7,10 @@ namespace App\Shared\Domain\Sidebar;
 final class SidebarFilter
 {
     /**
-     * @param list<array{label:string, icon:string, roles?:list<string>, permission?:string, items: list<array{label:string, to:string, icon:string, module?:string, roles?:list<string>, permission?:string}>}> $sections
-     * @param list<string>                                                                                                                                                                                       $activeModuleIds
-     * @param list<string>                                                                                                                                                                                       $activeRoles
-     * @param list<string>                                                                                                                                                                                       $activePermissions
+     * @param list<array{label:string, icon:string, roles?:list<string>, permission?:list<string>|string, items: list<array{label:string, to:string, icon:string, module?:string, roles?:list<string>, permission?:list<string>|string}>}> $sections
+     * @param list<string>                                                                                                                                                                                                                 $activeModuleIds
+     * @param list<string>                                                                                                                                                                                                                 $activeRoles
+     * @param list<string>                                                                                                                                                                                                                 $activePermissions
      *
      * @return array{sections: list<array{label:string, icon:string, items: list<array{label:string, to:string, icon:string}>}>, disabledRoutes: list<string>}
      */
@@ -81,14 +81,21 @@ final class SidebarFilter
     }
 
     /**
-     * @param list<string> $activePermissions
+     * @param null|list<string>|string $required          une permission (string) ou un ensemble (any)
+     * @param list<string>             $activePermissions
      */
-    private static function permissionSatisfied(?string $required, array $activePermissions): bool
+    private static function permissionSatisfied(array|string|null $required, array $activePermissions): bool
     {
-        if (null === $required || '' === $required) {
+        if (null === $required || '' === $required || [] === $required) {
             return true;
         }
 
-        return in_array($required, $activePermissions, true);
+        foreach ((array) $required as $code) {
+            if (in_array($code, $activePermissions, true)) {
+                return true;
+            }
+        }
+
+        return false;
     }
 }