Ajout des commentaires dans le code
This commit is contained in:
PTA
@@ -16,13 +16,22 @@ use PDO;
|
||||
*/
|
||||
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';
|
||||
|
||||
private const SESSION_KEY = 'pta_access';
|
||||
|
||||
/** @var array<string, array<string, bool>> */
|
||||
/**
|
||||
* 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>> */
|
||||
@@ -33,6 +42,11 @@ final class Access
|
||||
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();
|
||||
@@ -45,6 +59,7 @@ final class Access
|
||||
return $role === self::ROLE_SERVICE;
|
||||
}
|
||||
|
||||
/** 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'] ?? '')));
|
||||
@@ -53,6 +68,7 @@ final class Access
|
||||
: 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, [
|
||||
@@ -61,6 +77,13 @@ final class Access
|
||||
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) {
|
||||
@@ -76,6 +99,16 @@ final class Access
|
||||
return $value === false ? null : (int) $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enregistre la sélection de rôle en session.
|
||||
*
|
||||
* ATTENTION : ceci est un sélecteur, PAS une authentification — l'utilisateur
|
||||
* choisit librement son identité. C'est la faille ouverte la plus importante
|
||||
* du projet ; un passage en production doit remplacer cet appel par une
|
||||
* authentification réelle, sans toucher au reste de la mécanique de droits.
|
||||
*
|
||||
* @throws \DomainException Si le rôle est inconnu ou l'identité inactive.
|
||||
*/
|
||||
public function select(string $role, ?int $agentId = null, ?int $structureId = null): void
|
||||
{
|
||||
$role = strtoupper(trim($role));
|
||||
@@ -97,6 +130,8 @@ final class Access
|
||||
$selection['structure_id'] = $structureId;
|
||||
}
|
||||
|
||||
// Regénération de l'identifiant de session à chaque changement de rôle :
|
||||
// parade classique à la fixation de session.
|
||||
session_regenerate_id(true);
|
||||
$_SESSION[self::SESSION_KEY] = $selection;
|
||||
// Le jeton CSRF suit le cycle de vie de la session : un changement de
|
||||
@@ -104,12 +139,21 @@ final class Access
|
||||
unset($_SESSION['csrf_token']);
|
||||
}
|
||||
|
||||
/** Abandonne la sélection courante (« changer de rôle »). */
|
||||
public function clear(): void
|
||||
{
|
||||
unset($_SESSION[self::SESSION_KEY], $_SESSION['csrf_token']);
|
||||
session_regenerate_id(true);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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();
|
||||
@@ -172,6 +216,7 @@ final class Access
|
||||
return $this->permissionCache[$role];
|
||||
}
|
||||
|
||||
/** Raccourci de lecture d'une permission ; absente = refusée. */
|
||||
public function hasPermission(string $permission): bool
|
||||
{
|
||||
return $this->permissions()[$permission] ?? false;
|
||||
@@ -200,6 +245,10 @@ final class Access
|
||||
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);
|
||||
@@ -224,6 +273,12 @@ final class Access
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* 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()) {
|
||||
@@ -236,6 +291,12 @@ final class Access
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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()) {
|
||||
@@ -246,16 +307,19 @@ final class Access
|
||||
}
|
||||
}
|
||||
|
||||
/** Réservé au Service Enfance : validation, référentiels, administration. */
|
||||
public function requireService(): void
|
||||
{
|
||||
$this->requireRoles([self::ROLE_SERVICE]);
|
||||
}
|
||||
|
||||
/** 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]);
|
||||
@@ -264,6 +328,7 @@ final class Access
|
||||
}
|
||||
}
|
||||
|
||||
/** Édition dans un lieu : un responsable est confiné au sien. */
|
||||
public function requireStructureEdit(int $structureId): void
|
||||
{
|
||||
$this->requireDraftEditor();
|
||||
@@ -272,6 +337,11 @@ final class Access
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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]);
|
||||
@@ -287,6 +357,10 @@ final class Access
|
||||
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();
|
||||
@@ -304,6 +378,7 @@ final class Access
|
||||
$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();
|
||||
@@ -321,11 +396,16 @@ final class Access
|
||||
$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()) {
|
||||
@@ -336,6 +416,7 @@ final class Access
|
||||
};
|
||||
}
|
||||
|
||||
/** Les vues v_acces_identite_* ne listent que les identités ACTIVES. */
|
||||
private function activeAgentExists(int $agentId): bool
|
||||
{
|
||||
$stmt = $this->pdo->prepare('SELECT 1 FROM v_acces_identite_agent WHERE id_agent = :id LIMIT 1');
|
||||
@@ -350,6 +431,11 @@ final class Access
|
||||
return $stmt->fetchColumn() !== false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fiche de l'agent en session.
|
||||
*
|
||||
* @return array<string, mixed>|null
|
||||
*/
|
||||
private function agentRecord(): ?array
|
||||
{
|
||||
$agentId = $this->agentId();
|
||||
@@ -365,6 +451,11 @@ final class Access
|
||||
return $stmt->fetch() ?: null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fiche du lieu en session.
|
||||
*
|
||||
* @return array<string, mixed>|null
|
||||
*/
|
||||
private function structureRecord(): ?array
|
||||
{
|
||||
$structureId = $this->structureId();
|
||||
@@ -380,6 +471,10 @@ final class Access
|
||||
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();
|
||||
|
||||
@@ -4,8 +4,22 @@ declare(strict_types=1);
|
||||
|
||||
namespace App\Core;
|
||||
|
||||
/**
|
||||
* Base des contrôleurs qui rendent une page HTML.
|
||||
*
|
||||
* Les contrôleurs d'API n'en héritent pas : ils écrivent directement leur
|
||||
* réponse via JsonResponse::send() et n'ont donc aucune vue à rendre.
|
||||
*/
|
||||
abstract class Controller
|
||||
{
|
||||
/**
|
||||
* Rend une vue de app/Views/ en lui exposant $data comme variables locales.
|
||||
*
|
||||
* @param string $view Chemin relatif sans extension, ex. « pages/planning ».
|
||||
* @param array<string, mixed> $data Variables mises à disposition de la vue.
|
||||
*
|
||||
* @throws \RuntimeException Si le fichier de vue n'existe pas.
|
||||
*/
|
||||
protected function render(string $view, array $data = []): void
|
||||
{
|
||||
$viewFile = dirname(__DIR__) . '/Views/' . $view . '.php';
|
||||
@@ -13,6 +27,8 @@ abstract class Controller
|
||||
throw new \RuntimeException('Vue introuvable : ' . $view);
|
||||
}
|
||||
|
||||
// EXTR_SKIP : une clé de $data ne peut pas écraser $view ni $viewFile,
|
||||
// ce qui rendrait le require imprévisible.
|
||||
extract($data, EXTR_SKIP);
|
||||
require $viewFile;
|
||||
}
|
||||
|
||||
@@ -4,8 +4,21 @@ declare(strict_types=1);
|
||||
|
||||
namespace App\Core;
|
||||
|
||||
/**
|
||||
* Jeton anti-CSRF, transporté dans le corps JSON et non dans un en-tête.
|
||||
*
|
||||
* Le jeton est publié dans window.PTA_CONFIG.csrfToken par layouts/footer.php ;
|
||||
* le JS le recopie dans chaque charge utile mutante sous la clé « csrf_token ».
|
||||
* Ce choix évite d'avoir à gérer une requête préliminaire CORS et garde les
|
||||
* appels fetch() identiques d'un module à l'autre.
|
||||
*/
|
||||
final class Csrf
|
||||
{
|
||||
/**
|
||||
* Renvoie le jeton de la session courante, en le créant au premier appel.
|
||||
* Le jeton vit aussi longtemps que la session : il n'est pas renouvelé à
|
||||
* chaque requête, sans quoi deux onglets ouverts s'invalideraient l'un l'autre.
|
||||
*/
|
||||
public static function ensureToken(): string
|
||||
{
|
||||
Session::start();
|
||||
@@ -17,12 +30,21 @@ final class Csrf
|
||||
return (string) $_SESSION['csrf_token'];
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie le jeton d'une charge utile et interrompt la requête si besoin.
|
||||
*
|
||||
* À appeler en tête de TOUT endpoint mutant, sans exception. La comparaison
|
||||
* passe par hash_equals() pour ne pas être sensible au temps d'exécution.
|
||||
*
|
||||
* @param array<string, mixed> $payload Corps JSON déjà décodé.
|
||||
*/
|
||||
public static function assertPayload(array $payload): void
|
||||
{
|
||||
$expected = self::ensureToken();
|
||||
$provided = (string) ($payload['csrf_token'] ?? '');
|
||||
|
||||
if ($provided === '' || !hash_equals($expected, $provided)) {
|
||||
// send() termine le script : rien ne s'exécute après ce point.
|
||||
JsonResponse::send(403, ['error' => 'Jeton de sécurité invalide. Rechargez la page.']);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,15 +4,35 @@ declare(strict_types=1);
|
||||
|
||||
namespace App\Core;
|
||||
|
||||
/**
|
||||
* Sortie JSON des endpoints d'API.
|
||||
*
|
||||
* Le JavaScript de PTA refuse toute réponse qui n'est pas du JSON : une notice
|
||||
* PHP ou une page d'erreur HTML se traduirait côté client par un message
|
||||
* incompréhensible. bootstrap() garantit donc que même un warning ou une
|
||||
* exception non rattrapée ressort en JSON.
|
||||
*
|
||||
* Les endpoints PDF sont la seule exception : ils émettent des octets binaires
|
||||
* et n'appellent volontairement pas bootstrap() (voir PdfResponse).
|
||||
*/
|
||||
final class JsonResponse
|
||||
{
|
||||
/**
|
||||
* Installe les gestionnaires d'erreur/exception qui convertissent tout
|
||||
* incident en réponse JSON 500. À appeler en toute première instruction du
|
||||
* point d'entrée, avant même l'ouverture de la connexion PDO.
|
||||
*/
|
||||
public static function bootstrap(): void
|
||||
{
|
||||
ini_set('display_errors', '0');
|
||||
ini_set('html_errors', '0');
|
||||
error_reporting(E_ALL);
|
||||
|
||||
// Les warnings/notices deviennent des ErrorException : elles remontent
|
||||
// ainsi au gestionnaire d'exception ci-dessous au lieu de polluer la
|
||||
// sortie avec du HTML qui casserait le JSON.
|
||||
set_error_handler(static function (int $severity, string $message, string $file, int $line): bool {
|
||||
// Respecte @ et error_reporting() : on laisse alors PHP gérer.
|
||||
if (!(error_reporting() & $severity)) {
|
||||
return false;
|
||||
}
|
||||
@@ -34,15 +54,27 @@ final class JsonResponse
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Émet la réponse JSON et TERMINE le script.
|
||||
*
|
||||
* Ce exit final est ce qui permet aux gardes (Access, Csrf, Request) de
|
||||
* s'écrire en une ligne sans que l'appelant ait à tester leur retour.
|
||||
*
|
||||
* @param int $status Code HTTP (200, 403, 409, 422, 500…).
|
||||
* @param array<string, mixed> $payload Corps sérialisé en JSON.
|
||||
*/
|
||||
public static function send(int $status, array $payload): void
|
||||
{
|
||||
if (!headers_sent()) {
|
||||
header('Content-Type: application/json; charset=utf-8');
|
||||
header('X-Content-Type-Options: nosniff');
|
||||
// Les réponses dépendent du rôle en session : jamais de cache partagé.
|
||||
header('Cache-Control: no-store');
|
||||
}
|
||||
|
||||
http_response_code($status);
|
||||
// UNESCAPED_UNICODE garde les accents lisibles ; INVALID_UTF8_SUBSTITUTE
|
||||
// évite qu'une donnée mal encodée en base fasse échouer tout l'encodage.
|
||||
echo json_encode($payload, JSON_UNESCAPED_UNICODE | JSON_INVALID_UTF8_SUBSTITUTE);
|
||||
exit;
|
||||
}
|
||||
|
||||
@@ -4,8 +4,24 @@ declare(strict_types=1);
|
||||
|
||||
namespace App\Core;
|
||||
|
||||
/**
|
||||
* Émission d'un PDF généré par les services de app/Services/.
|
||||
*
|
||||
* Les points d'entrée PDF n'appellent PAS JsonResponse::bootstrap() : ils
|
||||
* produisent un flux binaire, et un gestionnaire d'erreur qui écrirait du JSON
|
||||
* au milieu corromprait le document.
|
||||
*/
|
||||
final class PdfResponse
|
||||
{
|
||||
/**
|
||||
* Envoie le document en affichage direct dans le navigateur, puis TERMINE
|
||||
* le script.
|
||||
*
|
||||
* @param string $content Octets du PDF déjà assemblé.
|
||||
* @param string $filename Nom proposé ; il est assaini avant d'atterrir dans
|
||||
* l'en-tête Content-Disposition, où un guillemet ou
|
||||
* un retour ligne permettrait une injection d'en-tête.
|
||||
*/
|
||||
public static function inline(string $content, string $filename): void
|
||||
{
|
||||
$safeFilename = preg_replace('/[^A-Za-z0-9._-]+/', '_', $filename) ?: 'planning.pdf';
|
||||
@@ -17,6 +33,8 @@ final class PdfResponse
|
||||
header('Content-Type: application/pdf');
|
||||
header('Content-Disposition: inline; filename="' . $safeFilename . '"');
|
||||
header('Content-Length: ' . strlen($content));
|
||||
// Un planning peut être revalidé d'une minute à l'autre : on interdit
|
||||
// au navigateur de resservir une version périmée.
|
||||
header('Cache-Control: private, max-age=0, must-revalidate');
|
||||
header('Pragma: public');
|
||||
}
|
||||
|
||||
@@ -4,8 +4,19 @@ declare(strict_types=1);
|
||||
|
||||
namespace App\Core;
|
||||
|
||||
/**
|
||||
* Lecture de la requête entrante pour les endpoints JSON.
|
||||
*
|
||||
* Les deux méthodes coupent l'exécution en cas de non-conformité plutôt que de
|
||||
* lever une exception : l'appelant peut donc enchaîner sans bloc try/catch.
|
||||
*/
|
||||
final class Request
|
||||
{
|
||||
/**
|
||||
* Décode le corps JSON de la requête.
|
||||
*
|
||||
* @return array<string, mixed>
|
||||
*/
|
||||
public static function json(): array
|
||||
{
|
||||
$payload = json_decode((string) file_get_contents('php://input'), true);
|
||||
@@ -16,6 +27,9 @@ final class Request
|
||||
return $payload;
|
||||
}
|
||||
|
||||
/**
|
||||
* Impose le verbe HTTP attendu (typiquement « POST » pour un endpoint mutant).
|
||||
*/
|
||||
public static function requireMethod(string $method): void
|
||||
{
|
||||
if (strtoupper($_SERVER['REQUEST_METHOD'] ?? 'GET') !== strtoupper($method)) {
|
||||
|
||||
Reference in New Issue
Block a user