648 lines
24 KiB
PHP
648 lines
24 KiB
PHP
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace App\Core;
|
||
|
||
use PDO;
|
||
|
||
/**
|
||
* Contrôle des rôles et des périmètres.
|
||
*
|
||
* Aucune règle de droit n'est écrite ici : les pages autorisées, les
|
||
* permissions fonctionnelles et les périmètres de visibilité sont lus dans les
|
||
* vues SQL créées par database/migration_v7_8_securite_acces.sql. Cette classe
|
||
* ne fait que poser la question à la base et appliquer la réponse.
|
||
*/
|
||
final class Access
|
||
{
|
||
/** Lecture seule sur son propre planning. */
|
||
public const ROLE_AGENT = 'AGENT';
|
||
/** Édition des brouillons de son seul lieu d'affectation. */
|
||
public const ROLE_RESPONSABLE = 'RESPONSABLE_STRUCTURE';
|
||
/** Périmètre complet ; seul rôle habilité à valider un planning. */
|
||
public const ROLE_SERVICE = 'SERVICE_ENFANCE';
|
||
/**
|
||
* Administration technique (V7.11) : comptes d'accès, jetons et journal.
|
||
* Aucun droit métier — la DSI ne voit ni les plannings, ni les agents.
|
||
*/
|
||
public const ROLE_DSI = 'DSI';
|
||
|
||
private const SESSION_KEY = 'pta_access';
|
||
|
||
/** @var array<int, string> Les quatre rôles connus de l'application. */
|
||
private const ROLES = [self::ROLE_AGENT, self::ROLE_RESPONSABLE, self::ROLE_SERVICE, self::ROLE_DSI];
|
||
|
||
/**
|
||
* Caches par requête : les vues d'accès sont interrogées une seule fois par
|
||
* rôle et par requête HTTP. Rien n'est mis en cache entre deux requêtes, pour
|
||
* qu'une modification SQL des droits s'applique sans redéploiement.
|
||
*
|
||
* @var array<string, array<string, bool>>
|
||
*/
|
||
private array $permissionCache = [];
|
||
|
||
/** @var array<string, array<int, string>> */
|
||
private array $pageCache = [];
|
||
|
||
/**
|
||
* Compte d'accès de la session, relu UNE FOIS par requête.
|
||
*
|
||
* Il est relu à chaque requête et non conservé en session : c'est ce qui
|
||
* fait qu'un jeton désactivé par la DSI coupe l'accès à la requête suivante,
|
||
* sans attendre l'expiration de la session.
|
||
*
|
||
* @var array<string, mixed>|null
|
||
*/
|
||
private ?array $accountCache = null;
|
||
|
||
private bool $accountLoaded = false;
|
||
|
||
public function __construct(private PDO $pdo)
|
||
{
|
||
Session::start();
|
||
}
|
||
|
||
/**
|
||
* Vrai si la sélection en session est complète et pointe encore vers une
|
||
* identité active. Un agent ou un lieu désactivé en base fait donc retomber
|
||
* l'utilisateur sur role.php à la requête suivante.
|
||
*/
|
||
public function isConfigured(): bool
|
||
{
|
||
$role = $this->role();
|
||
if ($role === null) {
|
||
return false;
|
||
}
|
||
|
||
// Depuis la V7.11, toute session est adossée à un compte d'accès actif :
|
||
// pas de compte vivant, pas de session. Un jeton révoqué, un agent
|
||
// désactivé ou un lieu fermé referment donc l'accès immédiatement.
|
||
$compte = $this->accountRecord();
|
||
if ($compte === null) {
|
||
return false;
|
||
}
|
||
|
||
if ($role === self::ROLE_AGENT) {
|
||
return $this->agentId() !== null && $this->agentRecord() !== null;
|
||
}
|
||
if ($role === self::ROLE_RESPONSABLE) {
|
||
return $this->structureId() !== null && $this->structureRecord() !== null;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/** Rôle en session, ou null si aucun rôle valide n'est sélectionné. */
|
||
public function role(): ?string
|
||
{
|
||
$role = strtoupper(trim((string) ($_SESSION[self::SESSION_KEY]['role'] ?? '')));
|
||
return in_array($role, self::ROLES, true) ? $role : null;
|
||
}
|
||
|
||
/** Agent sélectionné (rôle AGENT uniquement), ou null. */
|
||
public function agentId(): ?int
|
||
{
|
||
$value = filter_var($_SESSION[self::SESSION_KEY]['agent_id'] ?? null, FILTER_VALIDATE_INT, [
|
||
'options' => ['min_range' => 1],
|
||
]);
|
||
return $value === false ? null : (int) $value;
|
||
}
|
||
|
||
/**
|
||
* Lieu de référence de la session.
|
||
*
|
||
* Pour un AGENT, il n'est pas stocké en session mais dérivé de son
|
||
* rattachement en base : l'agent ne le choisit pas, et le déplacer d'un lieu
|
||
* à l'autre doit prendre effet immédiatement.
|
||
*/
|
||
public function structureId(): ?int
|
||
{
|
||
if ($this->role() === self::ROLE_AGENT) {
|
||
$agent = $this->agentRecord();
|
||
return isset($agent['id_structure']) && $agent['id_structure'] !== null
|
||
? (int) $agent['id_structure']
|
||
: null;
|
||
}
|
||
|
||
$value = filter_var($_SESSION[self::SESSION_KEY]['structure_id'] ?? null, FILTER_VALIDATE_INT, [
|
||
'options' => ['min_range' => 1],
|
||
]);
|
||
return $value === false ? null : (int) $value;
|
||
}
|
||
|
||
/**
|
||
* Ouvre la session de travail à partir d'un compte d'accès authentifié.
|
||
*
|
||
* DEPUIS LA V7.11, C'EST LE SEUL CHEMIN D'ENTRÉE : l'ancien sélecteur libre
|
||
* (select()) a disparu, une session ne peut plus naître que de la
|
||
* présentation d'un jeton valide. Le rôle, l'agent et le lieu ne sont plus
|
||
* choisis par l'utilisateur mais LUS SUR LE COMPTE — c'est ce qui rend la
|
||
* mécanique de droits opposable.
|
||
*
|
||
* La vérification du jeton elle-même appartient à CompteModel : cette
|
||
* méthode reçoit un compte déjà authentifié.
|
||
*
|
||
* @param array<string, mixed> $compte Ligne de v_acces_compte.
|
||
*/
|
||
public function openSession(array $compte): void
|
||
{
|
||
// Regénération de l'identifiant de session à chaque ouverture : parade
|
||
// classique à la fixation de session.
|
||
session_regenerate_id(true);
|
||
|
||
$_SESSION[self::SESSION_KEY] = [
|
||
'role' => (string) $compte['role'],
|
||
'agent_id' => isset($compte['id_agent']) && $compte['id_agent'] !== null
|
||
? (int) $compte['id_agent']
|
||
: null,
|
||
'structure_id' => isset($compte['id_structure']) && $compte['id_structure'] !== null
|
||
? (int) $compte['id_structure']
|
||
: null,
|
||
'compte_id' => (int) $compte['id_compte'],
|
||
// Libellé figé pour le journal : il évite une jointure à chaque trace.
|
||
'acteur' => (string) ($compte['identite_libelle'] ?? $compte['libelle'] ?? ''),
|
||
];
|
||
|
||
// Le jeton CSRF suit le cycle de vie de la session : une nouvelle
|
||
// connexion invalide le jeton précédent.
|
||
unset($_SESSION['csrf_token']);
|
||
$this->accountCache = null;
|
||
$this->accountLoaded = false;
|
||
}
|
||
|
||
/** Ferme la session de travail (déconnexion). */
|
||
public function clear(): void
|
||
{
|
||
unset($_SESSION[self::SESSION_KEY], $_SESSION['csrf_token']);
|
||
session_regenerate_id(true);
|
||
$this->accountCache = null;
|
||
$this->accountLoaded = false;
|
||
}
|
||
|
||
/** Identifiant du compte d'accès de la session, ou null. */
|
||
public function accountId(): ?int
|
||
{
|
||
$value = filter_var($_SESSION[self::SESSION_KEY]['compte_id'] ?? null, FILTER_VALIDATE_INT, [
|
||
'options' => ['min_range' => 1],
|
||
]);
|
||
return $value === false ? null : (int) $value;
|
||
}
|
||
|
||
/**
|
||
* Instantané de session destiné au JOURNAL, lisible sans instancier Access
|
||
* ni ouvrir de connexion.
|
||
*
|
||
* Il expose la clé de session privée sous une forme stable : Journal (et lui
|
||
* seul) a besoin de connaître l'acteur courant depuis un contexte statique,
|
||
* sans pouvoir dépendre d'une instance.
|
||
*
|
||
* @return array{id_compte: int|null, role: string|null, acteur: string|null}
|
||
*/
|
||
public static function sessionSnapshot(): array
|
||
{
|
||
$selection = $_SESSION[self::SESSION_KEY] ?? [];
|
||
$compteId = filter_var($selection['compte_id'] ?? null, FILTER_VALIDATE_INT, [
|
||
'options' => ['min_range' => 1],
|
||
]);
|
||
$role = strtoupper(trim((string) ($selection['role'] ?? '')));
|
||
$acteur = trim((string) ($selection['acteur'] ?? ''));
|
||
|
||
return [
|
||
'id_compte' => $compteId === false ? null : (int) $compteId,
|
||
'role' => in_array($role, self::ROLES, true) ? $role : null,
|
||
'acteur' => $acteur === '' ? null : $acteur,
|
||
];
|
||
}
|
||
|
||
/**
|
||
* Profil affichable de la session, publié tel quel dans window.PTA_CONFIG
|
||
* par layouts/footer.php et réutilisé par les en-têtes de PDF.
|
||
*
|
||
* @return array<string, mixed> role, role_label, label, agent_id,
|
||
* structure_id, permissions, et selon le rôle
|
||
* matricule / structure_name / structure_code.
|
||
*/
|
||
public function profile(): array
|
||
{
|
||
$role = $this->role();
|
||
$permissions = $this->permissions();
|
||
$profile = [
|
||
'role' => $role,
|
||
'role_label' => $this->roleLabel(),
|
||
'label' => $this->roleLabel(),
|
||
'agent_id' => $this->agentId(),
|
||
'structure_id' => $this->structureId(),
|
||
'account_id' => $this->accountId(),
|
||
'permissions' => $permissions,
|
||
];
|
||
|
||
if ($role === self::ROLE_AGENT) {
|
||
$agent = $this->agentRecord();
|
||
if ($agent !== null) {
|
||
$profile['label'] = trim((string) $agent['prenom'] . ' ' . (string) $agent['nom']);
|
||
$profile['matricule'] = $agent['matricule'];
|
||
$profile['structure_name'] = $agent['structure_nom'];
|
||
$profile['structure_id'] = $agent['id_structure'] !== null ? (int) $agent['id_structure'] : null;
|
||
}
|
||
} elseif ($role === self::ROLE_RESPONSABLE) {
|
||
$structure = $this->structureRecord();
|
||
if ($structure !== null) {
|
||
$profile['label'] = (string) $structure['nom'];
|
||
$profile['structure_name'] = (string) $structure['nom'];
|
||
$profile['structure_code'] = (string) $structure['code'];
|
||
}
|
||
} else {
|
||
// Service Enfance et DSI ne portent aucune identité métier : le
|
||
// libellé affiché est celui du compte (« Direction des systèmes
|
||
// d'information », « Service Enfance — Camille »…).
|
||
$compte = $this->accountRecord();
|
||
if ($compte !== null) {
|
||
$profile['label'] = (string) $compte['identite_libelle'];
|
||
}
|
||
}
|
||
|
||
return $profile;
|
||
}
|
||
|
||
/**
|
||
* Permissions fonctionnelles lues dans v_acces_role_permission.
|
||
* Une permission absente de la base vaut « refusé ».
|
||
*
|
||
* @return array<string, bool>
|
||
*/
|
||
public function permissions(): array
|
||
{
|
||
$role = $this->role();
|
||
if ($role === null) {
|
||
return [];
|
||
}
|
||
|
||
if (!isset($this->permissionCache[$role])) {
|
||
$stmt = $this->pdo->prepare(
|
||
'SELECT permission, autorise FROM v_acces_role_permission WHERE role = :role'
|
||
);
|
||
$stmt->execute(['role' => $role]);
|
||
|
||
$permissions = [];
|
||
foreach ($stmt->fetchAll() as $row) {
|
||
$permissions[(string) $row['permission']] = (bool) $row['autorise'];
|
||
}
|
||
$this->permissionCache[$role] = $permissions;
|
||
}
|
||
|
||
return $this->permissionCache[$role];
|
||
}
|
||
|
||
/** Raccourci de lecture d'une permission ; absente = refusée. */
|
||
public function hasPermission(string $permission): bool
|
||
{
|
||
return $this->permissions()[$permission] ?? false;
|
||
}
|
||
|
||
/**
|
||
* Pages autorisées lues dans v_acces_role_page.
|
||
*
|
||
* @return array<int, string>
|
||
*/
|
||
public function allowedPages(): array
|
||
{
|
||
$role = $this->role();
|
||
if ($role === null) {
|
||
return [];
|
||
}
|
||
|
||
if (!isset($this->pageCache[$role])) {
|
||
$stmt = $this->pdo->prepare(
|
||
'SELECT page FROM v_acces_role_page WHERE role = :role ORDER BY ordre_affichage, page'
|
||
);
|
||
$stmt->execute(['role' => $role]);
|
||
$this->pageCache[$role] = array_map('strval', $stmt->fetchAll(PDO::FETCH_COLUMN));
|
||
}
|
||
|
||
return $this->pageCache[$role];
|
||
}
|
||
|
||
/**
|
||
* $page est la clé logique de la page (« planning », « dashboard »…), telle
|
||
* qu'inscrite dans acces_role_page et passée à runPage().
|
||
*/
|
||
public function canAccessPage(string $page): bool
|
||
{
|
||
return in_array($page, $this->allowedPages(), true);
|
||
}
|
||
|
||
/**
|
||
* Page d'atterrissage du rôle.
|
||
*
|
||
* Le Service Enfance arrive sur son tableau de bord plutôt que sur l'écran
|
||
* de saisie : son travail commence par le contrôle, pas par la saisie. Le
|
||
* repli sur « planning » est indispensable, car la page « dashboard » n'est
|
||
* autorisée que si la migration V7.9 a été jouée — sans ce repli,
|
||
* requirePage() renverrait indéfiniment vers une page interdite.
|
||
*/
|
||
public function homeUrl(): string
|
||
{
|
||
return match ($this->role()) {
|
||
self::ROLE_AGENT => 'agents.php?agent_id=' . (int) $this->agentId(),
|
||
self::ROLE_RESPONSABLE => 'planning.php?structure_id=' . (int) $this->structureId(),
|
||
self::ROLE_SERVICE => $this->canAccessPage('dashboard') ? 'dashboard.php' : 'planning.php',
|
||
// La DSI n'a qu'une page ; le repli sur role.php évite la boucle de
|
||
// redirection si la migration V7.11 n'est pas jouée.
|
||
self::ROLE_DSI => $this->canAccessPage('dsi') ? 'dsi.php' : 'role.php',
|
||
default => 'role.php',
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Garde des pages HTML : redirige au lieu de renvoyer une erreur, puis
|
||
* TERMINE le script. Sans rôle configuré on renvoie vers le sélecteur ;
|
||
* page interdite, on renvoie vers l'accueil du rôle avec access_denied=1
|
||
* pour que l'interface puisse expliquer le refus.
|
||
*/
|
||
public function requirePage(string $page): void
|
||
{
|
||
if (!$this->isConfigured()) {
|
||
header('Location: role.php', true, 302);
|
||
exit;
|
||
}
|
||
if (!$this->canAccessPage($page)) {
|
||
Journal::refus(
|
||
'PAGE_REFUSEE',
|
||
sprintf('Accès refusé à la page « %s ».', $page),
|
||
['contexte' => ['page' => $page]]
|
||
);
|
||
header('Location: ' . $this->homeUrl() . (str_contains($this->homeUrl(), '?') ? '&' : '?') . 'access_denied=1', true, 302);
|
||
exit;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Garde des endpoints JSON : émet un 401/403 JSON et TERMINE le script.
|
||
* Toutes les gardes require*() ci-dessous en dérivent.
|
||
*
|
||
* @param array<int, string> $roles Rôles acceptés.
|
||
*/
|
||
public function requireRoles(array $roles): void
|
||
{
|
||
if (!$this->isConfigured()) {
|
||
$this->refuser(401, 'SESSION_ABSENTE', 'Appel d’API sans session valide.', [
|
||
'endpoint' => $this->endpointCourant(),
|
||
]);
|
||
JsonResponse::send(401, ['error' => 'Connectez-vous avec votre jeton d’accès avant de continuer.', 'code' => 'ROLE_REQUIRED']);
|
||
}
|
||
if (!in_array($this->role(), $roles, true)) {
|
||
$this->refuser(403, 'ROLE_INSUFFISANT', 'Rôle insuffisant pour cette action.', [
|
||
'endpoint' => $this->endpointCourant(),
|
||
'roles_attendus' => array_values($roles),
|
||
]);
|
||
JsonResponse::send(403, ['error' => 'Votre rôle ne permet pas cette action.', 'code' => 'ACCESS_DENIED']);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Journalise un refus d'API. Méthode privée volontairement minuscule : elle
|
||
* n'existe que pour que les gardes ci-dessous tiennent en deux lignes.
|
||
*
|
||
* @param array<string, mixed> $contexte
|
||
*/
|
||
private function refuser(int $status, string $action, string $description, array $contexte = []): void
|
||
{
|
||
Journal::refus($action, $description, [
|
||
'contexte' => array_merge(['statut_http' => $status], $contexte),
|
||
]);
|
||
}
|
||
|
||
/** Chemin de l'endpoint appelé, pour situer un refus dans le journal. */
|
||
private function endpointCourant(): string
|
||
{
|
||
$chemin = (string) ($_SERVER['SCRIPT_NAME'] ?? '');
|
||
return $chemin !== '' ? basename($chemin) : 'inconnu';
|
||
}
|
||
|
||
/** Réservé au Service Enfance : validation, référentiels, administration. */
|
||
public function requireService(): void
|
||
{
|
||
$this->requireRoles([self::ROLE_SERVICE]);
|
||
}
|
||
|
||
/**
|
||
* Réservé à la DSI : gestion des comptes d'accès et lecture du journal.
|
||
*
|
||
* Cette garde double le contrôle de page : la page « dsi » n'est autorisée
|
||
* qu'au rôle DSI dans acces_role_page, mais un endpoint doit rester sûr même
|
||
* si quelqu'un ouvrait ce droit à un autre rôle par une requête SQL.
|
||
*/
|
||
public function requireDsi(): void
|
||
{
|
||
$this->requireRoles([self::ROLE_DSI]);
|
||
}
|
||
|
||
/** Rôles autorisés à modifier un brouillon (l'agent est en lecture seule). */
|
||
public function requireDraftEditor(): void
|
||
{
|
||
$this->requireRoles([self::ROLE_RESPONSABLE, self::ROLE_SERVICE]);
|
||
}
|
||
|
||
/** Consultation d'un lieu : hors Service Enfance, seul le lieu de rattachement. */
|
||
public function requireStructureView(int $structureId): void
|
||
{
|
||
$this->requireRoles([self::ROLE_AGENT, self::ROLE_RESPONSABLE, self::ROLE_SERVICE]);
|
||
if ($this->role() !== self::ROLE_SERVICE && $this->structureId() !== $structureId) {
|
||
$this->refuser(403, 'PERIMETRE_LIEU', 'Consultation d’un lieu hors périmètre.', ['id_structure' => $structureId]);
|
||
JsonResponse::send(403, ['error' => 'Vous ne pouvez consulter que le planning de votre lieu de rattachement.', 'code' => 'STRUCTURE_SCOPE']);
|
||
}
|
||
}
|
||
|
||
/** Édition dans un lieu : un responsable est confiné au sien. */
|
||
public function requireStructureEdit(int $structureId): void
|
||
{
|
||
$this->requireDraftEditor();
|
||
if ($this->role() === self::ROLE_RESPONSABLE && $this->structureId() !== $structureId) {
|
||
$this->refuser(403, 'PERIMETRE_LIEU', 'Modification d’un lieu hors périmètre.', ['id_structure' => $structureId]);
|
||
JsonResponse::send(403, ['error' => 'Vous ne pouvez modifier que les brouillons de votre lieu.', 'code' => 'STRUCTURE_SCOPE']);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Consultation d'un agent. Un responsable y a droit dès que l'agent est
|
||
* planifié chez lui, même s'il y est rattaché ailleurs : un agent peut
|
||
* travailler sur plusieurs lieux la même semaine (v_acces_agent_par_structure).
|
||
*/
|
||
public function requireAgentView(int $agentId): void
|
||
{
|
||
$this->requireRoles([self::ROLE_AGENT, self::ROLE_RESPONSABLE, self::ROLE_SERVICE]);
|
||
if ($this->role() === self::ROLE_SERVICE) {
|
||
return;
|
||
}
|
||
if ($this->role() === self::ROLE_AGENT && $this->agentId() === $agentId) {
|
||
return;
|
||
}
|
||
if ($this->role() === self::ROLE_RESPONSABLE && $this->responsibleCanViewAgent($agentId)) {
|
||
return;
|
||
}
|
||
$this->refuser(403, 'PERIMETRE_AGENT', 'Consultation d’un agent hors périmètre.', ['id_agent' => $agentId]);
|
||
JsonResponse::send(403, ['error' => 'Vous ne pouvez pas consulter le planning de cet agent.', 'code' => 'AGENT_SCOPE']);
|
||
}
|
||
|
||
/**
|
||
* Édition d'un créneau, dont le périmètre est déduit du planning porteur.
|
||
* Un identifiant inconnu donne un 404 avant tout contrôle de rôle plus fin.
|
||
*/
|
||
public function requireEntryEdit(int $entryId): void
|
||
{
|
||
$this->requireDraftEditor();
|
||
if ($this->role() === self::ROLE_SERVICE) {
|
||
return;
|
||
}
|
||
$stmt = $this->pdo->prepare(
|
||
'SELECT id_structure FROM v_acces_perimetre_creneau WHERE id_creneau = :id LIMIT 1'
|
||
);
|
||
$stmt->execute(['id' => $entryId]);
|
||
$structureId = $stmt->fetchColumn();
|
||
if ($structureId === false) {
|
||
JsonResponse::send(404, ['error' => 'Créneau introuvable.']);
|
||
}
|
||
$this->requireStructureEdit((int) $structureId);
|
||
}
|
||
|
||
/** Édition d'un planning identifié, périmètre déduit de son lieu. */
|
||
public function requirePlanningEdit(int $planningId): void
|
||
{
|
||
$this->requireDraftEditor();
|
||
if ($this->role() === self::ROLE_SERVICE) {
|
||
return;
|
||
}
|
||
$stmt = $this->pdo->prepare(
|
||
'SELECT id_structure FROM v_acces_perimetre_planning WHERE id_planning = :id LIMIT 1'
|
||
);
|
||
$stmt->execute(['id' => $planningId]);
|
||
$structureId = $stmt->fetchColumn();
|
||
if ($structureId === false) {
|
||
JsonResponse::send(404, ['error' => 'Planning introuvable.']);
|
||
}
|
||
$this->requireStructureEdit((int) $structureId);
|
||
}
|
||
|
||
/**
|
||
* Lieu à pré-sélectionner et à verrouiller dans l'interface, ou null quand
|
||
* l'utilisateur peut choisir librement (Service Enfance).
|
||
*/
|
||
public function editableStructureId(): ?int
|
||
{
|
||
return $this->role() === self::ROLE_RESPONSABLE ? $this->structureId() : null;
|
||
}
|
||
|
||
/** Libellé lisible du rôle, affiché dans l'en-tête et sur les PDF. */
|
||
private function roleLabel(): string
|
||
{
|
||
return match ($this->role()) {
|
||
self::ROLE_AGENT => 'Agent',
|
||
self::ROLE_RESPONSABLE => 'Responsable de structure',
|
||
self::ROLE_SERVICE => 'Service Enfance',
|
||
self::ROLE_DSI => 'DSI',
|
||
default => 'Rôle non sélectionné',
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Compte d'accès de la session, relu une fois par requête.
|
||
*
|
||
* La vue ne renvoie le compte que s'il est actif ET que l'identité qu'il
|
||
* porte l'est aussi (`identite_active`) : désactiver un agent suffit donc à
|
||
* lui couper l'accès, sans avoir à toucher à son jeton.
|
||
*
|
||
* @return array<string, mixed>|null
|
||
*/
|
||
private function accountRecord(): ?array
|
||
{
|
||
if ($this->accountLoaded) {
|
||
return $this->accountCache;
|
||
}
|
||
|
||
$this->accountLoaded = true;
|
||
$this->accountCache = null;
|
||
|
||
$compteId = $this->accountId();
|
||
if ($compteId === null) {
|
||
return null;
|
||
}
|
||
|
||
$stmt = $this->pdo->prepare(
|
||
'SELECT id_compte, role, libelle, id_agent, id_structure, identite_libelle
|
||
FROM v_acces_compte
|
||
WHERE id_compte = :id AND actif = 1 AND identite_active = 1
|
||
LIMIT 1'
|
||
);
|
||
$stmt->execute(['id' => $compteId]);
|
||
$compte = $stmt->fetch();
|
||
|
||
// Le rôle de la session doit toujours correspondre à celui du compte :
|
||
// une session forgée ou survivant à un changement de rôle du compte est
|
||
// refusée plutôt que réparée.
|
||
if ($compte !== false && (string) $compte['role'] === $this->role()) {
|
||
$this->accountCache = $compte;
|
||
}
|
||
|
||
return $this->accountCache;
|
||
}
|
||
|
||
/**
|
||
* Fiche de l'agent en session.
|
||
*
|
||
* @return array<string, mixed>|null
|
||
*/
|
||
private function agentRecord(): ?array
|
||
{
|
||
$agentId = $this->agentId();
|
||
if ($agentId === null) {
|
||
return null;
|
||
}
|
||
$stmt = $this->pdo->prepare(
|
||
'SELECT id_agent, matricule, nom, prenom, id_structure, structure_nom
|
||
FROM v_acces_identite_agent
|
||
WHERE id_agent = :id LIMIT 1'
|
||
);
|
||
$stmt->execute(['id' => $agentId]);
|
||
return $stmt->fetch() ?: null;
|
||
}
|
||
|
||
/**
|
||
* Fiche du lieu en session.
|
||
*
|
||
* @return array<string, mixed>|null
|
||
*/
|
||
private function structureRecord(): ?array
|
||
{
|
||
$structureId = $this->structureId();
|
||
if ($structureId === null) {
|
||
return null;
|
||
}
|
||
$stmt = $this->pdo->prepare(
|
||
'SELECT id_structure, code, nom
|
||
FROM v_acces_identite_structure
|
||
WHERE id_structure = :id LIMIT 1'
|
||
);
|
||
$stmt->execute(['id' => $structureId]);
|
||
return $stmt->fetch() ?: null;
|
||
}
|
||
|
||
/**
|
||
* Vrai si l'agent apparaît dans le périmètre du responsable : rattachement
|
||
* par défaut OU présence d'un planning dans son lieu.
|
||
*/
|
||
private function responsibleCanViewAgent(int $agentId): bool
|
||
{
|
||
$structureId = $this->structureId();
|
||
if ($structureId === null) {
|
||
return false;
|
||
}
|
||
$stmt = $this->pdo->prepare(
|
||
'SELECT 1 FROM v_acces_agent_par_structure
|
||
WHERE id_agent = :agent_id AND id_structure_autorisee = :structure_id
|
||
LIMIT 1'
|
||
);
|
||
$stmt->execute(['agent_id' => $agentId, 'structure_id' => $structureId]);
|
||
return $stmt->fetchColumn() !== false;
|
||
}
|
||
}
|