FEATURES/141440

+        '141440' =>
+            ['Label' => $this->_('Ajout d'une jauge permettant de gérer plus finement la limite du nombre de participants'),
+             'Desc' => $this->_('La jauge maximum et minimum total offre une possibilité de s\'abstreindre des jauges adulte et enfant, pour gérer la limite maximum de participants de la session'),
+             'Image' => '',
+             'Video' => '',
+             'Category' => $this->_('Activités'),
+             'Right' => function($feature_description, $user) {return true;},
+             'Wiki' => 'https://wiki.bokeh-library-portal.org/index.php?title=Gestion_des_activit%C3%A9s#Cr.C3.A9er_une_session',
+             'Test' => '',
+             'Date' => '2022-03-29'],
\ No newline at end of file

VERSIONS_HOTLINE/154017

+ - correctif #154017 : PNB Dilicom : l'export des prêts PNB en CSV comporte dorénavant la date de retour attendue.
\ No newline at end of file

VERSIONS_HOTLINE/155100

+ - correctif #155100 : Magasin de thèmes : correction de la génération des URLs des images.
\ No newline at end of file

VERSIONS_HOTLINE/155428

+ - fonctionnalité #155428 : Magasin de thèmes : Avec le SIGB Nanook, le détail de la notice affiche maintenant le dépouillement de périodiques.
\ No newline at end of file

VERSIONS_WIP/141440

+ - fonctionnalité #141440 : Ajout d'une jauge permettant de gérer plus finement la limite du nombre de participants
\ No newline at end of file

VERSIONS_WIP/156519

+ - fonctionnalité #156519 : Magasin de thèmes : ajout d'un nouveau paramètre
+   		  	    Bokeh 2022_05_improve_thumbnail_rendering.css dans
+			    la configuration des thèmes.
+   		  	    Activer ce paramètre dans la configation de votre thème,
+			    vous permet d'importer les améliorations de rendu sur
+			    les vignettes.
\ No newline at end of file

cosmogramme/sql/patch/patch_432.php

+<?php
+$adapter = Zend_Db_Table_Abstract::getDefaultAdapter();
+
+try {
+  $adapter->query('alter table session_activity add column effectif_total_min int(11) unsigned not null default 0, add column effectif_total_max int(11) unsigned not null default 0');
+} catch(Exception $e) {}

library/Class/AdminVar.php

@@ -589,7 +589,7 @@ Pour vous désabonner de la lettre d\'information, merci de cliquer sur le lien
 
 
   protected function _getActivityVars() {
-    return ['ACTIVITY' => Class_AdminVar_Meta::newOnOff($this->_('Activer ou désactiver le module d\'activité')),
+    return ['ACTIVITY' => Class_AdminVar_Meta::newOnOff($this->_('Activer ou désactiver le module d\'activité'))->bePrivate(),
             'ACTIVITY_SESSION_QUOTAS' => Class_AdminVar_Meta::newOnOff($this->_('Activer ou désactiver la gestion des quotas pour les activités')),
             'ACTIVITY_NOTIFICATION_DELAY' => Class_AdminVar_Meta::newDefault($this->_('Délai d\'envoi des rappels pour les activités (en jours)'), ['value' => '0']),
             'ACTIVITY_NOTIFICATION_SUBJECT' => Class_AdminVar_Meta::newDefault($this->_('Sujet de l\'email de rappel pour les activités'), ['value'=> 'Rappel : {session.libelle_activity}']),

library/Class/Article.php

@@ -634,6 +634,12 @@ class Class_Article extends Storm_Model_Abstract {
   }
 
 
+  public function getFirstImageRelativeURL() : string {
+    return $this->withFirstImageDo(function($url) {return Class_Url::relative($url);});
+  }
+
+
+
   public function getFirstImagePath() {
     return $this->withFirstImageDo(function($url) {return $this->getPathFromURL($url);});
   }

library/Class/FileManager.php

@@ -588,6 +588,11 @@ class Class_FileManager extends Class_Entity {
   }
 
 
+  public function getRelativeUrl() : string {
+    return Class_Url::relative($this->getPath(), null, true);
+  }
+
+
   public function getRealpath() {
     return $this->_attribs['Realpath'];
   }

library/Class/SessionActivity.php

@@ -136,6 +136,8 @@ class Class_SessionActivity extends Storm_Model_Abstract {
                                           'effectif_max' => 10,
                                           'effectif_child_min' => 0,
                                           'effectif_child_max' => 0,
+                                          'effectif_total_min' => 0,
+                                          'effectif_total_max' => 0,
                                           'age_child_max' => 0,
                                           'age_child_min' => 0,
                                           'all_day' => 1,
@@ -415,18 +417,6 @@ class Class_SessionActivity extends Storm_Model_Abstract {
     if (!Class_AdminVar::isActivitySessionQuotasEnabled())
       return;
 
-    $this->checkAttribute("effectif_max",
-                          $this->getEffectifInscriptionMax() <= $this->getEffectifMax(),
-                          $this->_("L'effectif maximum doit être supérieur ou égal à l'effectif maximum par inscription"));
-
-    $this->checkAttribute("effectif_child_max",
-                          $this->getEffectifChildMin() <= $this->getEffectifChildMax(),
-                          $this->_("L'effectif enfants maximum doit être supérieur ou égal à l'effectif enfants minimum"));
-
-    $this->checkAttribute("effectif_child_max",
-                          $this->getEffectifInscriptionChildMax() <= $this->getEffectifChildMax(),
-                          $this->_("L'effectif enfants maximum doit être supérieur ou égal à l'effectif enfants maximum par inscription"));
-
     $this->checkAttribute('age_child_max',
                           $this->getEffectifChildMax() <= 0 || $this->getAgeChildMax() > 0,
                           $this->_("L'âge maximum pour les enfants doit être renseigné"));
@@ -435,6 +425,15 @@ class Class_SessionActivity extends Storm_Model_Abstract {
                           $this->getAgeChildMin() <= $this->getAgeChildMax(),
                           $this->_("L'âge minimum doit être inférieur à l'âge maximum pour les enfants"));
 
+    $this->checkAttribute("effectif_inscription_max",
+                          $this->getEffectifInscriptionMax() > 0
+                          || $this->getEffectifInscriptionChildMax() > 0,
+                          $this->_("Au moins un maximum par inscription doit être renseigné"));
+    $this->checkAttribute("effectif_inscription_child_max",
+                          $this->getEffectifInscriptionMax() > 0
+                          || $this->getEffectifInscriptionChildMax() > 0,
+                          $this->_("Au moins un maximum par inscription doit être renseigné"));
+
     $this->checkAttribute("effectif_inscription_max",
                           $this->getEffectifMax() <= 0 || $this->getEffectifInscriptionMax() > 0,
                           $this->_("Adultes maximum par inscription doit être renseigné"));
@@ -443,6 +442,42 @@ class Class_SessionActivity extends Storm_Model_Abstract {
                           $this->getEffectifChildMax() <= 0
                           || $this->getEffectifInscriptionChildMax() > 0,
                           $this->_("Enfants maximum par inscription doit être renseigné"));
+
+    if ($this->getEffectifTotalMax() > 0)
+      return $this->_checkEffectifTotal();
+
+    $this->checkAttribute("effectif_max",
+                          $this->getEffectifInscriptionMax() <= $this->getEffectifMax(),
+                          $this->_("L'effectif maximum doit être supérieur ou égal à l'effectif maximum par inscription"));
+
+    $this->checkAttribute("effectif_child_max",
+                          $this->getEffectifChildMin() <= $this->getEffectifChildMax(),
+                          $this->_("L'effectif enfants maximum doit être supérieur ou égal à l'effectif enfants minimum"));
+
+    $this->checkAttribute("effectif_child_max",
+                          $this->getEffectifInscriptionChildMax() <= $this->getEffectifChildMax(),
+                          $this->_("L'effectif enfants maximum doit être supérieur ou égal à l'effectif enfants maximum par inscription"));
+  }
+
+
+  protected function _checkEffectifTotal() : self {
+    $this->checkAttribute('effectif_total_max',
+                          $this->getEffectifInscriptionMax() <= $this->getEffectifTotalMax(),
+                          $this->_("L'effectif total maximum doit être supérieur ou égal à l'effectif maximum par inscription"));
+
+    $this->checkAttribute('effectif_total_max',
+                          $this->getEffectifTotalMin() <= $this->getEffectifTotalMax(),
+                          $this->_("L'effectif total maximum doit être supérieur ou égal à l'effectif total minimum"));
+
+    $this->checkAttribute('effectif_total_max',
+                          $this->getEffectifTotalMax() >= $this->getEffectifChildMax(),
+                          $this->_("Le nombre d'enfants maximum ne peut dépasser l'effectif maximum total"));
+
+    $this->checkAttribute('effectif_total_max',
+                          $this->getEffectifTotalMax() >= $this->getEffectifMax(),
+                          $this->_("Le nombre d'adultes maximum ne peut dépasser l'effectif maximum total"));
+
+    return $this;
   }
 
 
@@ -462,6 +497,11 @@ class Class_SessionActivity extends Storm_Model_Abstract {
   }
 
 
+  public function getNextTotalFor(?Class_SessionActivityInscription $registration = null) : int {
+    return $this->_getAttendees()->getNextTotalFor($registration);
+  }
+
+
   public function getNextAdultsMax() {
     return $this->_getAttendees()->getNextAdultsMax() ;
   }

library/Class/SessionActivityAttendees.php

@@ -27,192 +27,280 @@ class Class_SessionActivityAttendees {
     $_session_with_quotas,
     $_is_max_registration_limited = true;
 
-  public static function newFor($session) {
+  public static function newFor(Class_SessionActivity $session) {
     return $session->isQueueAttendees()
       ? new Class_SessionActivityAttendeesWithQueue($session)
       : new Class_SessionActivityAttendees($session);
   }
 
 
-  public function __construct($session) {
+  public function __construct(Class_SessionActivity $session) {
     $this->_session_activity = $session;
     $this->_session_with_quotas = Class_AdminVar::isActivitySessionQuotasEnabled();
   }
 
 
-  public function isFull() {
+  public function isFull() : bool {
+    if (($total = $this->getEffectifTotalMax()) > 0)
+      return $total <= $this->count();
+
     return $this->isFullAdults() && $this->isFullChildren();
   }
 
 
-  public function isFullAdults() {
-    return 0 == $this->getEffectifMax()
-      || $this->getEffectifMax() <= $this->numberOfAdults();
+  public function isFullAdults() : bool {
+    return 0 == $this->getEffectifMaxOrTotal()
+      || $this->getEffectifMaxOrTotal() <= $this->numberOfAdults();
   }
 
 
-  public function isFullChildren() {
-    return !$this->_session_with_quotas
-      || 0 == $this->getEffectifChildMax()
-      || $this->getEffectifChildMax() <= $this->numberOfChildren();
+  public function isFullChildren() : bool {
+    if (!$this->_session_with_quotas)
+      return true;
+
+    return 0 == $this->getEffectifChildMaxOrTotal()
+      || $this->getEffectifChildMaxOrTotal() <= $this->numberOfChildren();
   }
 
 
-  public function getMin() {
-    return (int)$this->getEffectifMin() + (int)$this->getEffectifChildMin();
+  public function getMin() : int {
+    if (($total = $this->getEffectifTotalMin()) > 0)
+      return $total;
+
+    return $this->getEffectifMin() + $this->getEffectifChildMin();
   }
 
 
-  public function getMax() {
-    return (int)$this->getEffectifMax() + (int)$this->getEffectifChildMax();
+  public function getMax() : int {
+    if (($total = $this->getEffectifTotalMax()) > 0)
+      return $total;
+
+    return $this->getEffectifMaxOrTotal() + $this->getEffectifChildMaxOrTotal();
   }
 
 
-  public function count() {
+  public function count() : int {
     return $this->numberOfAdults() + $this->numberOfChildren();
   }
 
 
-  public function countInQueue() {
+  public function countInQueue() : int {
     return 0;
   }
 
 
-  public function getEffectifMax() {
-    return $this->_session_activity->getEffectifMax();
+  public function getEffectifMax() : int {
+    return (int) $this->_session_activity->getEffectifMax();
   }
 
 
-  public function getEffectifMin() {
-    return $this->_session_activity->getEffectifMin();
+  public function getEffectifMaxOrTotal() : int {
+    return ($max = $this->getEffectifMax()) > 0
+      ? $max
+      : $this->getEffectifTotalMax();
   }
 
 
-  public function getEffectifChildMax() {
-    return $this->_session_with_quotas ? $this->_session_activity->getEffectifChildMax() : 0;
+  public function getEffectifMin() : int {
+    return ($min = (int) $this->_session_activity->getEffectifMin()) > 0
+      ? $min
+      : $this->getEffectifTotalMin();
   }
 
 
-  public function getEffectifChildMin() {
-    return $this->_session_with_quotas ? $this->_session_activity->getEffectifChildMin() : 0;
+  public function getEffectifChildMax() : int {
+    if (!$this->_session_with_quotas)
+      return 0;
+
+    return (int) $this->_session_activity->getEffectifChildMax();
   }
 
 
-  public function numberOfAdults() {
+  public function getEffectifChildMaxOrTotal() : int {
+    if (!$this->_session_with_quotas)
+      return 0;
+
+    return ($max = $this->getEffectifChildMax()) > 0
+      ? $max
+      : $this->getEffectifTotalMax();
+  }
+
+
+  public function getEffectifChildMin() : int {
+    if (!$this->_session_with_quotas)
+      return 0;
+
+    return ($min = (int) $this->_session_activity->getEffectifChildMin()) > 0
+      ? $min
+      : $this->getEffectifTotalMin();
+  }
+
+
+  public function getEffectifTotalMin() : int {
+    return $this->_session_with_quotas
+      ? (int) $this->_session_activity->getEffectifTotalMin()
+      : 0;
+  }
+
+
+  public function getEffectifTotalMax() : int {
+    return $this->_session_with_quotas
+      ? (int) $this->_session_activity->getEffectifTotalMax()
+      : 0;
+  }
+
+
+  public function getEffectifInscriptionMax() : int {
+    return $this->_session_with_quotas
+      ? (int) $this->_session_activity->getEffectifInscriptionMax()
+      : 0;
+  }
+
+
+  public function getEffectifInscriptionChildMax() : int {
+    return $this->_session_with_quotas
+      ? (int) $this->_session_activity->getEffectifInscriptionChildMax()
+      : 0;
+  }
+
+
+  public function numberOfAdults() : int {
     return $this->_countInscriptions('adults');
   }
 
 
-  public function numberOfChildren() {
-    return $this->_session_with_quotas ? $this->_countInscriptions('children') : 0;
+  public function numberOfChildren() : int {
+    return $this->_session_with_quotas
+      ? $this->_countInscriptions('children')
+      : 0;
   }
 
 
-  public function numberOfAdultsQueue() {
+  public function numberOfAdultsQueue() : int {
     return 0;
   }
 
 
-  public function numberOfChildrenQueue() {
+  public function numberOfChildrenQueue() : int {
     return 0;
   }
 
 
-  public function isFullForQueue($inscription) {
+  public function isFullForQueue(Class_SessionActivityInscription $inscription) : bool {
     return false;
   }
 
 
-  public function bypassMaxRegistration() {
+  public function bypassMaxRegistration() : self {
     $this->_is_max_registration_limited = false;
     return $this;
   }
 
 
-  public function getNextAdultsMax() {
-    return $this->_getMin($this->_session_activity
-                          ->getEffectifInscriptionMax(), $this->_remainingAdults());
+  public function getNextTotalFor($registration = null) : int {
+    if ($this->_session_activity->isQueueAttendees()
+        || $this->getEffectifTotalMax() <= 0
+        || !$registration)
+      return -1;
+
+    $remain_total = $this->getEffectifTotalMax() - $this->count();
+    if ($remain_total >= ($this->_remainingAdults() + $this->_remainingChildren()))
+      return -1;
+
+    return ($remain_total < ($registration->getAdults() + $registration->getChildren()))
+      ? $remain_total
+      : -1;
+  }
+
+
+  public function getNextAdultsMax() : int {
+    return $this->_getMin($this->getEffectifInscriptionMax(), $this->_remainingAdults());
   }
 
 
-  public function getNextAdultsMaxQueue() {
+  public function getNextAdultsMaxQueue() : int {
     return 0;
   }
 
 
-  public function getNextAdultsMaxFor($registration) {
-    return $this->_getMin($this->_session_activity
-                          ->getEffectifInscriptionMax(),
+  public function getNextAdultsMaxFor(Class_SessionActivityInscription $registration) : int {
+    return $this->_getMin($this->getEffectifInscriptionMax(),
                           ($this->_remainingAdults() + $registration->getAdults()));
   }
 
 
-  public function getNextChildrenMax() {
+  public function getNextChildrenMax() : int {
     return $this->_session_with_quotas
-      ? $this->_getMin($this->_session_activity
-                       ->getEffectifInscriptionChildMax(), $this->_remainingChildren())
+      ? $this->_getMin($this->getEffectifInscriptionChildMax(), $this->_remainingChildren())
       : 0;
   }
 
 
-  public function getNextChildrenMaxQueue() {
+  public function getNextChildrenMaxQueue() : int {
     return 0;
   }
 
 
-  public function getNextChildrenMaxFor($registration) {
+  public function getNextChildrenMaxFor(Class_SessionActivityInscription $registration) : int {
     return $this->_session_with_quotas
-        ? $this->_getMin($this->_session_activity
-                         ->getEffectifInscriptionChildMax(),
-                         $this->_remainingChildren() + $registration->getChildren())
-        : 0;
+      ? $this->_getMin($this->getEffectifInscriptionChildMax(),
+                       ($this->_remainingChildren() + $registration->getChildren()))
+      : 0;
   }
 
 
-  public function withQueuedInscriptionDo($callback) {
+  public function withQueuedInscriptionDo($callback) : self {
     return $this;
   }
 
 
   public function acceptVisitor($view) {
     if (!$this->_session_with_quotas) {
-      $view->visitLegacy($this->numberOfAdults(), $this->getEffectifMin(), $this->getEffectifMax());
+      $view->visitLegacy($this->numberOfAdults(), $this->getEffectifMin(), $this->getEffectifMaxOrTotal());
       return;
     }
 
-    if ($nb_max_adults = $this->getEffectifMax())
+    if ($nb_max_adults = $this->getEffectifMaxOrTotal())
       $view->visitAdults($this->numberOfAdults(),
                          $this->getEffectifMin(),
                          $nb_max_adults);
 
-    if ($nb_max_children = $this->getEffectifChildMax())
+    if ($nb_max_children = $this->getEffectifChildMaxOrTotal())
       $view->visitChildren($this->numberOfChildren(),
                            $this->getEffectifChildMin(),
                            $nb_max_children);
   }
 
 
-  protected function _remainingAdults() {
-    return $this->getEffectifMax() - $this->numberOfAdults();
+  protected function _remainingAdults() : int {
+    if ($this->getEffectifTotalMax() > 0)
+      return min(($this->getEffectifTotalMax() - $this->count()),
+                 ($this->getEffectifMaxOrTotal() - $this->numberOfAdults()));
+
+    return $this->getEffectifMaxOrTotal() - $this->numberOfAdults();
   }
 
 
-  protected function _remainingChildren() {
+  protected function _remainingChildren() : int {
     if (!$this->_session_with_quotas)
       return 0;
 
-    return $this->getEffectifChildMax() - $this->numberOfChildren();
+    if ($this->getEffectifTotalMax() > 0)
+      return min(($this->getEffectifTotalMax() - $this->count()),
+                 ($this->getEffectifChildMaxOrTotal() - $this->numberOfChildren()));
+
+    return $this->getEffectifChildMaxOrTotal() - $this->numberOfChildren();
   }
 
 
-  protected function _getMin($effectif_max, $remaining) {
+  protected function _getMin(int $effectif_max, int $remaining) : int {
     return $this->_is_max_registration_limited
       ? min($effectif_max, $remaining)
       : $remaining;
   }
 
 
-  protected function _countInscriptions($attribut, $with_queue=false) {
+  protected function _countInscriptions(string $attribut, bool $with_queue=false) : int {
     return $this->_registrations()
                 ->injectInto(0,
                              function($next_value, $inscription) use($attribut, $with_queue)
@@ -225,7 +313,7 @@ class Class_SessionActivityAttendees {
   }
 
 
-  protected function _registrations() {
+  protected function _registrations() : Storm_Model_Collection {
     return new Storm_Model_Collection($this->_session_activity->getSessionActivityInscriptions());
   }
 }
@@ -235,32 +323,39 @@ class Class_SessionActivityAttendees {
 
 class Class_SessionActivityAttendeesWithQueue extends Class_SessionActivityAttendees {
 
-  public function isFullAdults() {
-    return 0 == $this->getEffectifMax();
+  public function isFull() : bool {
+    return $this->isFullAdults() && $this->isFullChildren();
+  }
+
+
+  public function isFullAdults() : bool {
+    return 0 == $this->getEffectifMaxOrTotal();
   }
 
 
-  public function isFullChildren() {
-    return !$this->_session_with_quotas || 0 == $this->getEffectifChildMax();
+  public function isFullChildren() : bool {
+    return !$this->_session_with_quotas || 0 == $this->getEffectifChildMaxOrTotal();
   }
 
 
-  public function countInQueue() {
+  public function countInQueue() : int {
     return $this->numberOfAdultsQueue() + $this->numberOfChildrenQueue();
   }
 
 
-  public function numberOfAdultsQueue() {
+  public function numberOfAdultsQueue() : int {
     return $this->_countInscriptions('adults', true);
   }
 
 
-  public function numberOfChildrenQueue() {
-    return $this->_session_with_quotas ? $this->_countInscriptions('children', true) : 0;
+  public function numberOfChildrenQueue() : int {
+    return $this->_session_with_quotas
+      ? $this->_countInscriptions('children', true)
+      : 0;
   }
 
 
-  public function isFullForQueue($inscription) {
+  public function isFullForQueue(Class_SessionActivityInscription $inscription) : bool {
     $total_adults_remaining = $this->_remainingAdultsForQueue() - $inscription->getAdults();
     $total_children_remaining = $this->_session_with_quotas
       ? $this->_remainingChildrenForQueue() - $inscription->getChildren()
@@ -270,72 +365,66 @@ class Class_SessionActivityAttendeesWithQueue extends Class_SessionActivityAtten
   }
 
 
-  public function getNextAdultsMax() {
+  public function getNextAdultsMax() : int {
     return $this->_is_max_registration_limited
-      ? $this->_session_activity->getEffectifInscriptionMax()
-      : $this->getEffectifMax();
+      ? $this->getEffectifInscriptionMax()
+      : $this->getEffectifMaxOrTotal();
   }
 
 
-  public function getNextAdultsMaxQueue() {
-    return $this->_getMin($this->_session_activity->getEffectifInscriptionMax(),
+  public function getNextAdultsMaxQueue() : int {
+    return $this->_getMin($this->getEffectifInscriptionMax(),
                           $this->_remainingAdultsForQueue());
   }
 
 
-  public function getNextAdultsMaxFor($registration) {
+  public function getNextAdultsMaxFor(Class_SessionActivityInscription $registration) : int {
     return $registration->isQueue()
       ? $this->getNextAdultsMax()
-      : $this->_getMin($this->_session_activity->getEffectifInscriptionMax(),
+      : $this->_getMin($this->getEffectifInscriptionMax(),
                        ($this->_remainingAdultsForQueue() + $registration->getAdults()));
   }
 
 
-  public function getNextChildrenMax() {
+  public function getNextChildrenMax() : int {
     if (!$this->_session_with_quotas)
       return 0;
 
     return $this->_is_max_registration_limited
-      ? $this->_session_activity->getEffectifInscriptionChildMax()
-      : $this->getEffectifChildMax();
+      ? $this->getEffectifInscriptionChildMax()
+      : $this->getEffectifChildMaxOrTotal();
   }
 
 
-  public function getNextChildrenMaxQueue() {
+  public function getNextChildrenMaxQueue() : int {
     return $this->_session_with_quotas
-      ? $this->_getMin($this->_session_activity->getEffectifInscriptionChildMax(),
+      ? $this->_getMin($this->getEffectifInscriptionChildMax(),
                        $this->_remainingChildrenForQueue())
       : 0;
   }
 
 
-  public function getNextChildrenMaxFor($registration) {
+  public function getNextChildrenMaxFor(Class_SessionActivityInscription $registration) : int {
     if (!$this->_session_with_quotas)
       return 0;
 
     return $registration->isQueue()
       ? $this->getNextChildrenMax()
-      : $this->_getMin($this->_session_activity
-                       ->getEffectifInscriptionChildMax(),
+      : $this->_getMin($this->getEffectifInscriptionChildMax(),
                        ($this->_remainingChildrenForQueue() + $registration->getChildren()));
   }
 
 
-  public function withQueuedInscriptionDo($callback) {
+  public function withQueuedInscriptionDo($callback) : self {
     $collection = new Storm_Model_Collection($this->_session_activity
                                              ->getSessionActivityInscriptions());
 
     $collection = $collection
-      ->select(function($inscription)
-               {
-                 return $inscription->isQueue();
-               });
+      ->select(fn($inscription) => $inscription->isQueue());
 
     $collection
-      ->uasort(function($inscription_1, $inscription_2)
-               {
-                 return strcmp($inscription_1->getCreatedAt(), $inscription_2->getCreatedAt());
-               });
+      ->uasort(fn($inscription_1, $inscription_2) => strcmp($inscription_1->getCreatedAt(),
+                                                            $inscription_2->getCreatedAt()));
 
     $collection->eachDo($callback);
 
@@ -351,25 +440,25 @@ class Class_SessionActivityAttendeesWithQueue extends Class_SessionActivityAtten
   }
 
 
-  protected function _remainingAdults() {
-    return $this->_session_activity->getEffectifInscriptionMax();
+  protected function _remainingAdults() : int {
+    return $this->getEffectifInscriptionMax();
   }
 
 
-  protected function _remainingAdultsForQueue() {
-    return $this->getEffectifMax() - $this->numberOfAdults();
+  protected function _remainingAdultsForQueue() : int {
+    return $this->getEffectifMaxOrTotal() - $this->numberOfAdults();
   }
 
 
-  protected function _remainingChildren() {
+  protected function _remainingChildren() : int {
     if (!$this->_session_with_quotas)
       return 0;
 
-    return $this->_session_activity->getEffectifInscriptionChildMax();
+    return $this->getEffectifInscriptionChildMax();
   }
 
 
-  protected function _remainingChildrenForQueue() {
-    return $this->getEffectifChildMax() - $this->numberOfChildren();
+  protected function _remainingChildrenForQueue() : int {
+    return $this->getEffectifChildMaxOrTotal() - $this->numberOfChildren();
   }
-}
\ No newline at end of file
+}

library/Class/SessionActivityInscription.php

@@ -96,10 +96,34 @@ class Class_SessionActivityInscription extends Storm_Model_Abstract {
                        0 < $this->getAdults() || 0 < $this->getChildren(),
                        $this->_('Au moins un adulte ou un enfant doit s\'inscrire'));
 
+    if ($this->_checkAttributeTotal())
+      return;
+
     $this
       ->_checkRemaining('adults', 'next_adults_max', [$this, '_adultsRemainingError'])
-      ->_checkRemaining('children', 'next_children_max', [$this, '_childrenRemainingError'])
-      ;
+      ->_checkRemaining('children', 'next_children_max', [$this, '_childrenRemainingError']);
+  }
+
+
+  protected function _checkAttributeTotal() : bool {
+    $remaining = $this->isNew()
+      ? $this->getSessionActivity()->getNextTotalFor($this)
+      : $this->_getUserSessionAttribute('next_total_for');
+
+    if ($remaining < 0)
+      return false;
+
+    $plural = $this->_plural($remaining,
+                             'aucune restante',
+                             '1 restante',
+                             '%d restantes',
+                             $remaining);
+    $error_message = $this->_('Le nombre de participants au total est supérieur au nombre de places total disponibles (%s)',
+                              $plural);
+    $this->checkAttribute('adults', false, $error_message);
+    $this->checkAttribute('children', false, $error_message);
+
+    return true;
   }
 
 

library/Class/TableDescription/PNBLoans.php

@@ -25,11 +25,10 @@ class Class_TableDescription_PNBLoans extends Class_TableDescription {
 
   public function init() {
     $this
-      ->addColumn($this->_('Date'),
-                  function($model) { return $this->loanDate($model); })
+      ->addColumn($this->_('Date'), fn($model) => $this->loanDate($model))
+      ->addColumn($this->_('Retour'), fn($model) => $this->returnDate($model))
       ->addColumn($this->_('Titre'), 'title')
-      ->addColumn($this->_('Date de commande'),
-                  function($model) { return $this->orderDate($model); })
+      ->addColumn($this->_('Date de commande'), fn($model) => $this->orderDate($model))
       ->addColumn($this->_('Auteur'), 'main_author')
       ->addColumn($this->_('Éditeur'), 'first_editor')
       ->addColumn($this->_('Collection'), 'first_collection')
@@ -46,6 +45,11 @@ class Class_TableDescription_PNBLoans extends Class_TableDescription {
   }
 
 
+  public function returnDate($model) {
+    return $this->dayMonthYearOf($model->getExpectedReturnDate());
+  }
+
+
   public function orderDate($model) {
     return $this->dayMonthYearOf($model->getOrderDate());
   }

library/Class/Template.php

@@ -21,9 +21,11 @@
 
 
 class Class_Template {
+
   use
     Trait_Translator,
-    Trait_StaticFileWriter;
+    Trait_StormFileSystem;
+
 
   protected static $_instance;
 
@@ -726,4 +728,10 @@ class Class_Template {
   public function shouldHighlightRecords() : bool {
     return (bool) Class_AdminVar::isSearchTermHighlightedEnabled();
   }
-}
+
+
+  public function getCssPatchsFiles() : array {
+    $files_names = $this->getFileSystem()->fileNamesAt(TEMPLATES_CSS_PATCHS);
+    return array_combine($files_names, $files_names);
+  }
+}
\ No newline at end of file

library/Class/Template/NullPatcher.php

@@ -26,7 +26,7 @@ class Class_Template_NullPatcher {
   }
 
 
-  public function upgrade($profile) {
+  public function upgrade(Class_Profil $profile) {
     return $profile;
   }
 }

library/Class/User/SessionActivity.php

@@ -58,37 +58,52 @@ class Class_User_SessionActivity {
   }
 
 
-  public function isFullAdults() {
+  public function isFullAdults() : bool {
     return $this->_session_activity->isFullAdults();
   }
 
 
-  public function isFullChildren() {
+  public function isFullChildren() : bool {
     return $this->_session_activity->isFullChildren();
   }
 
 
-  public function getNextAdultsMax() {
+  public function getEffectifInscriptionMax() : int {
+    return $this->_session_activity->getEffectifInscriptionMax();
+  }
+
+
+  public function getEffectifInscriptionChildMax() : int {
+    return $this->_session_activity->getEffectifInscriptionChildMax();
+  }
+
+
+  public function getNextTotalFor() : int {
+    return $this->_session_activity->getNextTotalFor($this->_inscription);
+  }
+
+
+  public function getNextAdultsMax() : int {
     return $this->_session_activity->getNextAdultsMaxFor($this->_inscription);
   }
 
 
-  public function getNextChildrenMax() {
+  public function getNextChildrenMax() : int {
     return $this->_session_activity->getNextChildrenMaxFor($this->_inscription);
   }
 
 
-  public function getAgeChildMax() {
+  public function getAgeChildMax() : int {
     return $this->_session_activity->getAgeChildMax();
   }
 
 
-  public function getAgeChildMin() {
+  public function getAgeChildMin() : int {
     return $this->_session_activity->getAgeChildMin();
   }
 
 
-  public function isQueueAttendees() {
+  public function isQueueAttendees() : bool {
     return $this->_session_activity->isQueueAttendees();
   }
 }
@@ -97,12 +112,18 @@ class Class_User_SessionActivity {
 
 
 class Class_User_SessionActivityNull extends Class_User_SessionActivity {
-  public function getNextAdultsMax() {
+
+  public function getNextAdultsMax() : int {
     return 0;
   }
 
 
-  public function getNextChildrenMax() {
+  public function getNextChildrenMax() : int {
     return 0;
   }
+
+
+  public function getNextTotalFor() : int {
+    return -1;
+  }
 }

library/Trait/StormFileSystem.php

@@ -31,6 +31,6 @@ trait Trait_StormFileSystem {
   public static function getFileSystem() {
     if (null !== self::$_file_system)
       return self::$_file_system;
-    return new Storm_FileSystem_Disk();
+    return new Storm_FileSystem_Disk;
   }
 }
\ No newline at end of file

library/ZendAfi/Controller/Plugin/Manager/Manager.php

@@ -308,7 +308,6 @@ class ZendAfi_Controller_Plugin_Manager_Manager
 
   protected function _setupFormAndSave($model) {
     $form = $this->_getForm($model);
-
     $this->_view->form = $form;
     if (!$this->_request->isPost())
       return false;

library/ZendAfi/Form/Admin/SessionActivity.php

@@ -166,18 +166,20 @@ class ZendAfi_Form_Admin_SessionActivity extends ZendAfi_Form {
     $this
       ->_addNumber('effectif_min', $this->_('Adultes minimum'))
       ->_addNumber('effectif_max', $this->_('Adultes maximum'))
-      ->_addNumber('effectif_inscription_max',  $this->_('Adultes maximum par inscription'))
+      ->_addNumber('effectif_inscription_max',
+                   $this->_('Adultes maximum par inscription'), true)
       ->_addNumber('effectif_child_min', $this->_('Enfants minimum'))
       ->_addNumber('effectif_child_max', $this->_('Enfants maximum'))
-      ->_addNumber('effectif_inscription_child_max', $this->_('Enfants maximum par inscription'))
+      ->_addNumber('effectif_inscription_child_max',
+                   $this->_('Enfants maximum par inscription'), true)
       ->_addNumber('age_child_min', $this->_('Âge minimum des enfants'))
-      ->_addNumber('age_child_max', $this->_('Âge maximum des enfants'));
+      ->_addNumber('age_child_max', $this->_('Âge maximum des enfants'), true)
+      ->_addNumber('effectif_total_min', $this->_('Total minimum de participants'))
+      ->_addNumber('effectif_total_max', $this->_('Total maximum de participants'));
 
     return array_filter($elements,
-                        function($item)
-                        {
-                          return !in_array($item, ['effectif_min', 'effectif_max']);
-                        });
+                        fn($item) => !in_array($item, ['effectif_min',
+                                                       'effectif_max']));
   }
 
 
@@ -190,19 +192,22 @@ class ZendAfi_Form_Admin_SessionActivity extends ZendAfi_Form {
                                 'effectif_child_max',
                                 'effectif_inscription_child_max',
                                 'age_child_min',
-                                'age_child_max'],
+                                'age_child_max',
+                                'effectif_total_min',
+                                'effectif_total_max'],
                                'quotas',
                                ['legend' => $this->_('Effectif')])
       : $this;
   }
 
 
-  protected function _addNumber($name, $label) {
+  protected function _addNumber($name, $label, $required = false) {
     return $this->addElement('number', $name,
                              ['label' => $label,
                               'value' => 0,
                               'min' => 0,
-                              'required' => true,
-                              'allowEmpty' => false]);
+                              'required' => $required,
+                              'allowEmpty' => false
+                             ]);
   }
 }