support de la session

php/src/mail/MailTemplateHelper.php

@@ -3,6 +3,7 @@ namespace nulib\mail;
 
 use nulib\app\config;
 use nulib\cl;
+use nulib\web\session;
 
 class MailTemplateHelper {
   function __construct(?array $data) {

php/src/web/params/F.php

@@ -17,7 +17,7 @@ class F {
   }
 
   /** obtenir le paramètre $name en cherchant dans $_POST puis $_GET */
-  static final function get($name, $default=null, bool $trim=false) {
+  static final function get($name, $default=null, bool $trim=false): ?string {
     if ($name === null || $name === false) $value = $default;
     elseif (array_key_exists($name, $_POST)) $value = $_POST[$name];
     elseif (array_key_exists($name, $_GET)) $value = $_GET[$name];
@@ -47,6 +47,10 @@ class F {
     ));
   }
 
+  /**
+   * calculer la liste de tous les paramètres qui ont été passés. ensuite,
+   * fusionner le tableau $merge s'il est spécifié
+   */
   static final function merge(?array $merge=null): array {
     $params = [];
     foreach (self::get_names() as $name) {
@@ -56,7 +60,7 @@ class F {
   }
 
   /**
-   * retourner une liste des paramètres qui ont été passés, en les sélectionnant
+   * calculer une liste des paramètres qui ont été passés, en les sélectionnant
    * selon le contenu de $includes et $excludes. ensuite, fusionner le tableau
    * $merge s'il est spécifié
    *

php/src/web/params/G.php

@@ -15,7 +15,7 @@ class G {
   }
 
   /** obtenir le paramètre $name */
-  static final function get($name, $default=null, bool $trim=false) {
+  static final function get($name, $default=null, bool $trim=false): ?string {
     $value = cl::get($_GET, $name, $default);
     if ($trim) $value = str::trim($value);
     return $value;
@@ -26,7 +26,11 @@ class G {
     $_GET[$name] = $value;
   }
 
-  static final function xselect(?array $includes, ?array $excludes=null, ?array $merge=null): array {
+  static final function merge(?array $merge=null): array {
+    return cl::merge($_GET, $merge);
+  }
+
+  static final function select(?array $includes, ?array $excludes=null, ?array $merge=null): array {
     return cl::merge(cl::xselect($_GET, $includes, $excludes), $merge);
   }
 }

php/src/web/params/P.php

@@ -15,7 +15,7 @@ class P {
   }
 
   /** obtenir le paramètre $name */
-  static final function get($name, $default=null, bool $trim=false) {
+  static final function get($name, $default=null, bool $trim=false): ?string {
     $value = cl::get($_POST, $name, $default);
     if ($trim) $value = str::trim($value);
     return $value;
@@ -30,4 +30,12 @@ class P {
   static final function raw(): string {
     return file_get_contents("php://input");
   }
+
+  static final function merge(?array $merge=null): array {
+    return cl::merge($_POST, $merge);
+  }
+
+  static final function select(?array $includes, ?array $excludes=null, ?array $merge=null): array {
+    return cl::merge(cl::xselect($_POST, $includes, $excludes), $merge);
+  }
 }

php/src/web/params/R.php

@@ -15,7 +15,7 @@ class R {
   }
 
   /** obtenir le paramètre $name */
-  static final function get($name, $default=null, bool $trim=false) {
+  static final function get($name, $default=null, bool $trim=false): ?string {
     $value = cl::get($_REQUEST, $name, $default);
     if ($trim) $value = str::trim($value);
     return $value;

php/src/web/session.php

@@ -0,0 +1,244 @@
+<?php
+namespace nulib\web;
+
+use nulib\cl;
+
+/**
+ * Class session: gestion des sessions
+ */
+class session {
+  /** durée de session par défaut: 24 minutes */
+  const DURATION = 1440;
+
+  /** @var int */
+  protected static $duration;
+
+  /** obtenir la durée d'une session en secondes. */
+  static final function get_duration(): int {
+    $duration = self::$duration;
+    if ($duration === null) $duration = static::DURATION;
+    return $duration;
+  }
+
+  /**
+   * spécifier la durée d'une session en secondes.
+   * cette méthode doit être appelée avant start()
+   */
+  static final function set_duration(int $duration): void {
+    self::$duration = $duration;
+  }
+
+  /** vérifier si la session a été démarrée. */
+  static final function started(): bool {
+    return session_status() == PHP_SESSION_ACTIVE;
+  }
+
+  private static $started_once = false;
+
+  /** vérifier si la session a été démarrée au moins une fois */
+  static final function started_once(): bool {
+    return self::$started_once;
+  }
+
+  /** nom de la variable de session qui indique quand elle a été créée. */
+  const SESSION_CREATION_TIME = "nulib\\session_creation_time";
+
+  /**
+   * démarrer la session si nécessaire. étendre la durée du cookie de session
+   * de la valeur get_duration()
+   *
+   * la page est automatiquement configurée par PHP pour ne pas être mise en
+   * cache, il est donc inutile d'utiliser {@link http::no_cache()}
+   *
+   * retourner true si la session vient d'être créée, false si elle a été
+   * chargée depuis le disque
+   */
+  static final function start(): bool {
+    if (!self::started()) {
+      $duration = self::get_duration();
+      $canSetCookies = !headers_sent();
+      if ($canSetCookies) {
+        # durée initiale du cookie
+        session_set_cookie_params($duration);
+      }
+      session_start([
+        "gc_maxlifetime" => $duration,
+      ]);
+      self::$started_once = true;
+
+      $creation_time = self::get(self::SESSION_CREATION_TIME, false);
+      if (!$creation_time) {
+        # création initiale
+        self::set(self::SESSION_CREATION_TIME, time());
+        return true;
+      } elseif ($canSetCookies) {
+        # étendre la durée du cookie
+        $params = session_get_cookie_params();
+        setcookie(session_name(), session_id(), time() + $duration, $params["path"], $params["domain"], $params["secure"], $params["httponly"]);
+      }
+    }
+    return false;
+  }
+
+  /**
+   * enregistrer la session, la fermer et libérer son verrou.
+   *
+   * cette fonction peut être appelée avant une opération longue si on n'a plus
+   * besoin de la session.
+   *
+   * retourn true si la session a été fermée, false sinon.
+   */
+  static final function close(): bool {
+    if (self::started()) {
+      session_write_close();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * vider la session de toutes ses variables ($unsetOnly==true) ou la détruire
+   * ($unsetOnly==false). en cas de destruction de la session, supprimer aussi
+   * le cookie de session
+   *
+   * si $unsetOnly==true, refaire la variable SESSION_CREATION_TIME
+   */
+  static final function destroy(bool $unsetOnly=false, bool $clearCookie=true): void {
+    self::start();
+    if ($unsetOnly) {
+      session_unset();
+      self::set(self::SESSION_CREATION_TIME, time());
+    } else {
+      $canSetCookies = !headers_sent();
+      if ($clearCookie && $canSetCookies && ini_get("session.use_cookies")) {
+        $params = session_get_cookie_params();
+        setcookie(session_name(), '', time() - 42000, $params["path"], $params["domain"], $params["secure"], $params["httponly"]);
+      }
+      session_destroy();
+    }
+  }
+
+  /**
+   * Vider la session de toutes les clés spécifiées dans $keys qui ne sont pas
+   * mentionnées dans $keeps
+   *
+   * Si $keys vaut null, toutes les clés sont supprimées comme avec destroy(true)
+   * notamment, cela signifie que la variable SESSION_CREATION_TIME est refaite
+   */
+  static final function unset_keys(?array $keys, ?array $keeps=null): void {
+    $updateSessionCreationTime = false;
+    if ($keys === null) {
+      $keys = array_keys($_SESSION);
+      $updateSessionCreationTime = true;
+    }
+    if ($keeps !== null) $keys = array_diff($keys, $keeps);
+    foreach ($keys as $key) {
+      unset($_SESSION[$key]);
+    }
+    if ($updateSessionCreationTime) {
+      self::set(self::SESSION_CREATION_TIME, time());
+    }
+  }
+
+  /** vérifier si la session est démarrée et si la clé spécifiée existe. */
+  static final function has($key): bool {
+    if ($key === null || $key === false) return false;
+    return isset($_SESSION) && array_key_exists($key, $_SESSION);
+  }
+
+  /** obtenir la valeur associée à la clé spécifiée si la session est démarrée. */
+  static final function get(string $key, $default=null) {
+    if (!isset($_SESSION)) return $default;
+    return cl::get($_SESSION, $key, $default);
+  }
+
+  /**
+   * mettre à jour la valeur d'une variable de session.
+   *
+   * ne pas chercher à savoir si la session est démarrée ou non
+   */
+  static final function set(string $key, $value): void {
+    $_SESSION[$key] = $value;
+  }
+
+  /**
+   * comme {@link set()} mais rouvrir automatiquement la session si nécessaire,
+   * à condition qu'elle aie déjà été ouverte une fois
+   */
+  static final function setx(string $key, $value): void {
+    $close = !self::started() && self::started_once();
+    if ($close) self::start();
+    self::set($key, $value);
+    if ($close) self::close();
+  }
+
+  /**
+   * supprimer une variable de session.
+   *
+   * ne pas chercher à savoir si la session est démarrée ou non
+   */
+  static final function del(string $key): void {
+    unset($_SESSION[$key]);
+  }
+
+  /**
+   * comme {@link del()} mais rouvrir automatiquement la session si nécessaire,
+   * à condition qu'elle aie déjà été ouverte une fois
+   */
+  static final function delx(string $key): void {
+    $close = !self::started() && self::started_once();
+    if ($close) self::start();
+    self::del($key);
+    if ($close) self::close();
+  }
+
+  /** vérifier si chemin de clé spécifié existe dans la session. */
+  static final function phas($pkey): bool {
+    return isset($_SESSION) && cl::phas($_SESSION, $pkey);
+  }
+
+  /** obtenir la valeur associée au chemin de clé spécifié si la session est démarrée. */
+  static final function pget($pkey, $default=null) {
+    return isset($_SESSION) && cl::pget($_SESSION, $pkey, $default);
+  }
+
+  /**
+   * mettre à jour la valeur correspondant au chemin de clé spécifié.
+   *
+   * ne pas chercher à savoir si la session est démarrée ou non
+   */
+  static final function pset($pkey, $value): void {
+    cl::pset($_SESSION, $pkey, $value);
+  }
+
+  /**
+   * comme {@link pset()} mais rouvrir automatiquement la session si nécessaire,
+   * à condition qu'elle aie déjà été ouverte une fois
+   */
+  static final function psetx($pkey, $value): void {
+    $close = !self::started() && self::started_once();
+    if ($close) self::start();
+    self::pset($pkey, $value);
+    if ($close) self::close();
+  }
+
+  /**
+   * supprimer la variable au chemin de clé spécifié.
+   *
+   * ne pas chercher à savoir si la session est démarrée ou non
+   */
+  static final function pdel($pkey): void {
+    cl::pdel($_SESSION, $pkey);
+  }
+
+  /**
+   * comme {@link pdel()} mais rouvrir automatiquement la session si nécessaire,
+   * à condition qu'elle aie déjà été ouverte une fois
+   */
+  static final function pdelx(string $key): void {
+    $close = !self::started() && self::started_once();
+    if ($close) self::start();
+    self::pdel($key);
+    if ($close) self::close();
+  }
+}