Première étape avant la mise en place du système, la mise en place d’un système d’authentification s’appuyant sur la partie vérification de connexion ainsi que sur les profils afin de savoir si la personne doit être redirigée vers le front ou le back.

Cette partie a nécessité un peu de temps car il a fallu réussir a envoyer les infos de langues sur l’interface de connexion, puis réussir à gérer les redirections nécessaires sans avoir de page 403, qui est la norme par défaut.

Je passe sur le formulaire de création de compte ainsi que sur celui de connexion, il est important par contre de bien penser à mettre le token avec la directive blade @csrf dans les formulaires.

Voici donc les règles de test :

• Visiteur du site non connecté : accès au front autorisé, si tentative d’accès au back, redirection vers le formulaire de connexion.
• Personne connectée ayant un profil front : accès au front autorisé, si tentative d’accès au back, redirection vers le front.
• Personne connectée ayant un profil back : accès au back autorisé, si tentative d’accès au front, redirection vers le back.
• Personne connectée ayant le profil all : accès au front autorisé, accès au back autorisé.

Pour réaliser l’ensemble des opérations, j’ai donc utilisé le système de validation par un middleware, c’est un système qui permet de vérifier des données et, dans le cas de middlewares personnalisés, de réaliser une action en conséquence.

Le middleware de base pour rediriger vers le formulaire de connexion si le client n’est pas connecté par exemple est :

Route::get('/', 'home')->middleware('auth');

Dans ce cas on vérifie que la personne soit connectée pour afficher la page cible, sinon on la redirige vers la page login, qui doit être définie au préalable comme suit par exemple :

Route::get('/login', 'login')->name('login');

Mais dans le cas qui nous intéresse, il y a plusieurs cas à gérer, en plus il faut envoyer un paramètre indiquant le type d’accès souhaité, il se peut que ce paramètre puisse être obsolète puisque l’appel est accroché au BackController ou au FrontController mais pour le moment je fais simple, quoi que, puisque j’ai du chercher un peu pour savoir comment procéder.

Après avoir tester plusieurs pistes, je me suis arrêté sur un middleware spécifique nommé AccessMiddleware, pour lequel un alias a été créé dans le fichier bootstrap/app.php :

use App\Http\Middleware\AccessMiddleware;
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;

return Application::configure(basePath: dirname(DIR))
->withRouting(
web: DIR.'/../routes/web.php',
commands: DIR.'/../routes/console.php',
health: '/up',
)
->withMiddleware(function (Middleware $middleware) {
$middleware->alias([
'access' => AccessMiddleware::class
]);
})
->withExceptions(function (Exceptions $exceptions) {
//
})->create();

L’appel à ce middleware se fait donc de la manière suivante :

Route::controller(BackController::class)->middleware('access:access-back')->group(function() {

Route::get('/'.Configuration::getValue('_CORE_BACK_URL_'), 'dashboard')->name('dashboard');

});

Le middleware est donc appelé en passant son alias, puis le type d’accès à vérifier avec les :, il est à noter que les routes étant regroupées et que je souhaite tester l’accès sur l’ensemble de ces routes, le middleware est placé après l’indication du contrôleur, dans le cas où on ne regroupe pas les routes ou que l’on souhaite tester l’accès que sur une partie de ces dernières le middleware sera à placer au niveau des routes cibles.

Le middleware teste donc le type d’accès puis la situation de connexion de l’utilisateur et enfin le profil de cet utilisateur.

public function handle(Request $request, Closure $next, String $access): Response

{

switch ($access) {

case 'access-back':

$type = false;

if ($user = Auth::user()) {

$type = $user->profile()->get()->pluck('type')->first(); // Si l’utilisateur est connecté on récupère son type de profil

}

if (!$type || ($type !== 'all' && $type !== 'back')) {

if (!$type) {

return redirect('login'); // Si le type est faux, c’est que l’utilisateur n’est pas connecté

} else {

return redirect($user->getRedirectFromProfile()); // Si l’utilisateur est connecté, on le redirige vers l’url par défaut de son profil

}

}

break;

case 'access-front':

$type = true; // Par défaut tout le monde peut accéder au front

if ($user = Auth::user()) {

$type = $user->profile()->get()->pluck('type')->first();

}

if ($type !== true && ($type !== 'all' && $type !== 'front')) {

return redirect($user->getRedirectFromProfile());

}

break;

}

return $next($request);

}

Si l’utilisateur n’est pas connecté et qu’il souhaite accéder au front, on ne fait rien.

Avec cette première couche on peut donc vérifier les accès à l’une ou l’autre partie du site, les droits spécifiques aux profils feront l’objet d’un prochain billet.