dev#141440 activities add effectif total

 * add fckeditor img in result activities
 * detail-session display first contenu before information

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_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

cosmogramme/sql/patch/patch_431.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/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()));
   }
 
 
-