vendor/contao/core-bundle/src/Resources/contao/library/Contao/Message.php line 138

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of Contao.
  5.  *
  6.  * (c) Leo Feyer
  7.  *
  8.  * @license LGPL-3.0-or-later
  9.  */
  11. namespace Contao;
  13. /**
  14.  * Stores and outputs messages
  15.  *
  16.  * The class handles system messages which are shown to the user. You can add
  17.  * messages from anywhere in the application.
  18.  *
  19.  * Usage:
  20.  *
  21.  *     Message::addError('Please enter your name');
  22.  *     Message::addConfirmation('The data has been stored');
  23.  *     Message::addNew('There are two new messages');
  24.  *     Message::addInfo('You can upload only two files');
  25.  *
  26.  * @author Leo Feyer <https://github.com/leofeyer>
  27.  */
  28. class Message
  29. {
  30.     /**
  31.      * Add an error message
  32.      *
  33.      * @param string $strMessage The error message
  34.      * @param string $strScope   An optional message scope
  35.      */
  36.     public static function addError($strMessage, $strScope=TL_MODE)
  37.     {
  38.         static::add($strMessage, 'TL_ERROR', $strScope);
  39.     }
  41.     /**
  42.      * Add a confirmation message
  43.      *
  44.      * @param string $strMessage The confirmation message
  45.      * @param string $strScope   An optional message scope
  46.      */
  47.     public static function addConfirmation($strMessage, $strScope=TL_MODE)
  48.     {
  49.         static::add($strMessage, 'TL_CONFIRM', $strScope);
  50.     }
  52.     /**
  53.      * Add a new message
  54.      *
  55.      * @param string $strMessage The new message
  56.      * @param string $strScope   An optional message scope
  57.      */
  58.     public static function addNew($strMessage, $strScope=TL_MODE)
  59.     {
  60.         static::add($strMessage, 'TL_NEW', $strScope);
  61.     }
  63.     /**
  64.      * Add an info message
  65.      *
  66.      * @param string $strMessage The info message
  67.      * @param string $strScope   An optional message scope
  68.      */
  69.     public static function addInfo($strMessage, $strScope=TL_MODE)
  70.     {
  71.         static::add($strMessage, 'TL_INFO', $strScope);
  72.     }
  74.     /**
  75.      * Add a preformatted message
  76.      *
  77.      * @param string $strMessage The preformatted message
  78.      * @param string $strScope   An optional message scope
  79.      */
  80.     public static function addRaw($strMessage, $strScope=TL_MODE)
  81.     {
  82.         static::add($strMessage, 'TL_RAW', $strScope);
  83.     }
  85.     /**
  86.      * Add a message
  87.      *
  88.      * @param string $strMessage The message text
  89.      * @param string $strType    The message type
  90.      * @param string $strScope   An optional message scope
  91.      *
  92.      * @throws \Exception If $strType is not a valid message type
  93.      */
  94.     public static function add($strMessage, $strType, $strScope=TL_MODE)
  95.     {
  96.         if (!$strMessage)
  97.         {
  98.             return;
  99.         }
  101.         if (!\in_array($strType, static::getTypes()))
  102.         {
  103.             throw new \Exception("Invalid message type $strType");
  104.         }
  106.         System::getContainer()->get('session')->getFlashBag()->add(static::getFlashBagKey($strType, $strScope), $strMessage);
  107.     }
  109.     /**
  110.      * Return the messages with a wrapping container as HTML
  111.      *
  112.      * @param string $strScope An optional message scope
  113.      *
  114.      * @return string The messages HTML markup
  115.      */
  116.     public static function generate($strScope=TL_MODE)
  117.     {
  118.         $strMessages = static::generateUnwrapped($strScope);
  120.         if ($strMessages)
  121.         {
  122.             $strMessages = '<div class="tl_message">' . $strMessages . '</div>';
  123.         }
  125.         return $strMessages;
  126.     }
  128.     /**
  129.      * Return the messages as HTML
  130.      *
  131.      * @param string  $strScope An optional message scope
  132.      * @param boolean $blnRaw   Optionally return the raw messages
  133.      *
  134.      * @return string The messages HTML markup
  135.      */
  136.     public static function generateUnwrapped($strScope=TL_MODE, $blnRaw=false)
  137.     {
  138.         $session = System::getContainer()->get('session');
  140.         if (!$session->isStarted())
  141.         {
  142.             return '';
  143.         }
  145.         $strMessages = '';
  146.         $flashBag = $session->getFlashBag();
  148.         foreach (static::getTypes() as $strType)
  149.         {
  150.             $strClass = strtolower($strType);
  151.             $arrMessages = $flashBag->get(static::getFlashBagKey($strType, $strScope));
  153.             foreach (array_unique($arrMessages) as $strMessage)
  154.             {
  155.                 if ($strType == 'TL_RAW' || $blnRaw)
  156.                 {
  157.                     $strMessages .= $strMessage;
  158.                 }
  159.                 else
  160.                 {
  161.                     $strMessages .= '<p class="' . $strClass . '">' . $strMessage . '</p>';
  162.                 }
  163.             }
  164.         }
  166.         return trim($strMessages);
  167.     }
  169.     /**
  170.      * Reset the message system
  171.      */
  172.     public static function reset()
  173.     {
  174.         $session = System::getContainer()->get('session');
  176.         if (!$session->isStarted())
  177.         {
  178.             return;
  179.         }
  181.         $flashBag = $session->getFlashBag();
  183.         // Find all contao. keys (see #3393)
  184.         $keys = preg_grep('(^contao\.)', $flashBag->keys());
  186.         foreach ($keys as $key)
  187.         {
  188.             $flashBag->get($key); // clears the message
  189.         }
  190.     }
  192.     /**
  193.      * Return all available message types
  194.      *
  195.      * @return array An array of message types
  196.      */
  197.     public static function getTypes()
  198.     {
  199.         return array('TL_ERROR', 'TL_CONFIRM', 'TL_NEW', 'TL_INFO', 'TL_RAW');
  200.     }
  202.     /**
  203.      * Check if there are error messages
  204.      *
  205.      * @param string $strScope An optional message scope
  206.      *
  207.      * @return boolean True if there are error messages
  208.      */
  209.     public static function hasError($strScope=TL_MODE)
  210.     {
  211.         $session = System::getContainer()->get('session');
  213.         if (!$session->isStarted())
  214.         {
  215.             return false;
  216.         }
  218.         return $session->getFlashBag()->has(static::getFlashBagKey('error', $strScope));
  219.     }
  221.     /**
  222.      * Check if there are confirmation messages
  223.      *
  224.      * @param string $strScope An optional message scope
  225.      *
  226.      * @return boolean True if there are confirmation messages
  227.      */
  228.     public static function hasConfirmation($strScope=TL_MODE)
  229.     {
  230.         $session = System::getContainer()->get('session');
  232.         if (!$session->isStarted())
  233.         {
  234.             return false;
  235.         }
  237.         return $session->getFlashBag()->has(static::getFlashBagKey('confirm', $strScope));
  238.     }
  240.     /**
  241.      * Check if there are new messages
  242.      *
  243.      * @param string $strScope An optional message scope
  244.      *
  245.      * @return boolean True if there are new messages
  246.      */
  247.     public static function hasNew($strScope=TL_MODE)
  248.     {
  249.         $session = System::getContainer()->get('session');
  251.         if (!$session->isStarted())
  252.         {
  253.             return false;
  254.         }
  256.         return $session->getFlashBag()->has(static::getFlashBagKey('new', $strScope));
  257.     }
  259.     /**
  260.      * Check if there are info messages
  261.      *
  262.      * @param string $strScope An optional message scope
  263.      *
  264.      * @return boolean True if there are info messages
  265.      */
  266.     public static function hasInfo($strScope=TL_MODE)
  267.     {
  268.         $session = System::getContainer()->get('session');
  270.         if (!$session->isStarted())
  271.         {
  272.             return false;
  273.         }
  275.         return $session->getFlashBag()->has(static::getFlashBagKey('info', $strScope));
  276.     }
  278.     /**
  279.      * Check if there are raw messages
  280.      *
  281.      * @param string $strScope An optional message scope
  282.      *
  283.      * @return boolean True if there are raw messages
  284.      */
  285.     public static function hasRaw($strScope=TL_MODE)
  286.     {
  287.         $session = System::getContainer()->get('session');
  289.         if (!$session->isStarted())
  290.         {
  291.             return false;
  292.         }
  294.         return $session->getFlashBag()->has(static::getFlashBagKey('raw', $strScope));
  295.     }
  297.     /**
  298.      * Check if there are any messages
  299.      *
  300.      * @param string $strScope An optional message scope
  301.      *
  302.      * @return boolean True if there are messages
  303.      */
  304.     public static function hasMessages($strScope=TL_MODE)
  305.     {
  306.         return static::hasError($strScope) || static::hasConfirmation($strScope) || static::hasNew($strScope) || static::hasInfo($strScope) || static::hasRaw($strScope);
  307.     }
  309.     /**
  310.      * Return the flash bag key
  311.      *
  312.      * @param string      $strType  The message type
  313.      * @param string|null $strScope The message scope
  314.      *
  315.      * @return string The flash bag key
  316.      */
  317.     protected static function getFlashBagKey($strType, $strScope=TL_MODE)
  318.     {
  319.         return 'contao.' . $strScope . '.' . strtolower(str_replace('TL_', '', $strType));
  320.     }
  321. }
  323. class_alias(Message::class, 'Message');