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

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. class Message
  27. {
  28.     /**
  29.      * Add an error message
  30.      *
  31.      * @param string $strMessage The error message
  32.      * @param string $strScope   An optional message scope
  33.      */
  34.     public static function addError($strMessage, $strScope=TL_MODE)
  35.     {
  36.         static::add($strMessage, 'TL_ERROR', $strScope);
  37.     }
  39.     /**
  40.      * Add a confirmation message
  41.      *
  42.      * @param string $strMessage The confirmation message
  43.      * @param string $strScope   An optional message scope
  44.      */
  45.     public static function addConfirmation($strMessage, $strScope=TL_MODE)
  46.     {
  47.         static::add($strMessage, 'TL_CONFIRM', $strScope);
  48.     }
  50.     /**
  51.      * Add a new message
  52.      *
  53.      * @param string $strMessage The new message
  54.      * @param string $strScope   An optional message scope
  55.      */
  56.     public static function addNew($strMessage, $strScope=TL_MODE)
  57.     {
  58.         static::add($strMessage, 'TL_NEW', $strScope);
  59.     }
  61.     /**
  62.      * Add an info message
  63.      *
  64.      * @param string $strMessage The info message
  65.      * @param string $strScope   An optional message scope
  66.      */
  67.     public static function addInfo($strMessage, $strScope=TL_MODE)
  68.     {
  69.         static::add($strMessage, 'TL_INFO', $strScope);
  70.     }
  72.     /**
  73.      * Add a preformatted message
  74.      *
  75.      * @param string $strMessage The preformatted message
  76.      * @param string $strScope   An optional message scope
  77.      */
  78.     public static function addRaw($strMessage, $strScope=TL_MODE)
  79.     {
  80.         static::add($strMessage, 'TL_RAW', $strScope);
  81.     }
  83.     /**
  84.      * Add a message
  85.      *
  86.      * @param string $strMessage The message text
  87.      * @param string $strType    The message type
  88.      * @param string $strScope   An optional message scope
  89.      *
  90.      * @throws \Exception If $strType is not a valid message type
  91.      */
  92.     public static function add($strMessage, $strType, $strScope=TL_MODE)
  93.     {
  94.         if (!$strMessage)
  95.         {
  96.             return;
  97.         }
  99.         if (!\in_array($strType, static::getTypes()))
  100.         {
  101.             throw new \Exception("Invalid message type $strType");
  102.         }
  104.         System::getContainer()->get('session')->getFlashBag()->add(static::getFlashBagKey($strType, $strScope), $strMessage);
  105.     }
  107.     /**
  108.      * Return the messages with a wrapping container as HTML
  109.      *
  110.      * @param string $strScope An optional message scope
  111.      *
  112.      * @return string The messages HTML markup
  113.      */
  114.     public static function generate($strScope=TL_MODE)
  115.     {
  116.         $strMessages = static::generateUnwrapped($strScope);
  118.         if ($strMessages)
  119.         {
  120.             $strMessages = '<div class="tl_message">' . $strMessages . '</div>';
  121.         }
  123.         return $strMessages;
  124.     }
  126.     /**
  127.      * Return the messages as HTML
  128.      *
  129.      * @param string  $strScope An optional message scope
  130.      * @param boolean $blnRaw   Optionally return the raw messages
  131.      *
  132.      * @return string The messages HTML markup
  133.      */
  134.     public static function generateUnwrapped($strScope=TL_MODE, $blnRaw=false)
  135.     {
  136.         $session = System::getContainer()->get('session');
  138.         if (!$session->isStarted())
  139.         {
  140.             return '';
  141.         }
  143.         $strMessages = '';
  144.         $flashBag = $session->getFlashBag();
  146.         foreach (static::getTypes() as $strType)
  147.         {
  148.             $strClass = strtolower($strType);
  149.             $arrMessages = $flashBag->get(static::getFlashBagKey($strType, $strScope));
  151.             foreach (array_unique($arrMessages) as $strMessage)
  152.             {
  153.                 if ($strType == 'TL_RAW' || $blnRaw)
  154.                 {
  155.                     $strMessages .= $strMessage;
  156.                 }
  157.                 else
  158.                 {
  159.                     $strMessages .= '<p class="' . $strClass . '">' . $strMessage . '</p>';
  160.                 }
  161.             }
  162.         }
  164.         return trim($strMessages);
  165.     }
  167.     /**
  168.      * Reset the message system
  169.      */
  170.     public static function reset()
  171.     {
  172.         $session = System::getContainer()->get('session');
  174.         if (!$session->isStarted())
  175.         {
  176.             return;
  177.         }
  179.         $flashBag = $session->getFlashBag();
  181.         // Find all contao. keys (see #3393)
  182.         $keys = preg_grep('(^contao\.)', $flashBag->keys());
  184.         foreach ($keys as $key)
  185.         {
  186.             $flashBag->get($key); // clears the message
  187.         }
  188.     }
  190.     /**
  191.      * Return all available message types
  192.      *
  193.      * @return array An array of message types
  194.      */
  195.     public static function getTypes()
  196.     {
  197.         return array('TL_ERROR', 'TL_CONFIRM', 'TL_NEW', 'TL_INFO', 'TL_RAW');
  198.     }
  200.     /**
  201.      * Check if there are error messages
  202.      *
  203.      * @param string $strScope An optional message scope
  204.      *
  205.      * @return boolean True if there are error messages
  206.      */
  207.     public static function hasError($strScope=TL_MODE)
  208.     {
  209.         $session = System::getContainer()->get('session');
  211.         if (!$session->isStarted())
  212.         {
  213.             return false;
  214.         }
  216.         return $session->getFlashBag()->has(static::getFlashBagKey('error', $strScope));
  217.     }
  219.     /**
  220.      * Check if there are confirmation messages
  221.      *
  222.      * @param string $strScope An optional message scope
  223.      *
  224.      * @return boolean True if there are confirmation messages
  225.      */
  226.     public static function hasConfirmation($strScope=TL_MODE)
  227.     {
  228.         $session = System::getContainer()->get('session');
  230.         if (!$session->isStarted())
  231.         {
  232.             return false;
  233.         }
  235.         return $session->getFlashBag()->has(static::getFlashBagKey('confirm', $strScope));
  236.     }
  238.     /**
  239.      * Check if there are new messages
  240.      *
  241.      * @param string $strScope An optional message scope
  242.      *
  243.      * @return boolean True if there are new messages
  244.      */
  245.     public static function hasNew($strScope=TL_MODE)
  246.     {
  247.         $session = System::getContainer()->get('session');
  249.         if (!$session->isStarted())
  250.         {
  251.             return false;
  252.         }
  254.         return $session->getFlashBag()->has(static::getFlashBagKey('new', $strScope));
  255.     }
  257.     /**
  258.      * Check if there are info messages
  259.      *
  260.      * @param string $strScope An optional message scope
  261.      *
  262.      * @return boolean True if there are info messages
  263.      */
  264.     public static function hasInfo($strScope=TL_MODE)
  265.     {
  266.         $session = System::getContainer()->get('session');
  268.         if (!$session->isStarted())
  269.         {
  270.             return false;
  271.         }
  273.         return $session->getFlashBag()->has(static::getFlashBagKey('info', $strScope));
  274.     }
  276.     /**
  277.      * Check if there are raw messages
  278.      *
  279.      * @param string $strScope An optional message scope
  280.      *
  281.      * @return boolean True if there are raw messages
  282.      */
  283.     public static function hasRaw($strScope=TL_MODE)
  284.     {
  285.         $session = System::getContainer()->get('session');
  287.         if (!$session->isStarted())
  288.         {
  289.             return false;
  290.         }
  292.         return $session->getFlashBag()->has(static::getFlashBagKey('raw', $strScope));
  293.     }
  295.     /**
  296.      * Check if there are any messages
  297.      *
  298.      * @param string $strScope An optional message scope
  299.      *
  300.      * @return boolean True if there are messages
  301.      */
  302.     public static function hasMessages($strScope=TL_MODE)
  303.     {
  304.         return static::hasError($strScope) || static::hasConfirmation($strScope) || static::hasNew($strScope) || static::hasInfo($strScope) || static::hasRaw($strScope);
  305.     }
  307.     /**
  308.      * Return the flash bag key
  309.      *
  310.      * @param string      $strType  The message type
  311.      * @param string|null $strScope The message scope
  312.      *
  313.      * @return string The flash bag key
  314.      */
  315.     protected static function getFlashBagKey($strType, $strScope=TL_MODE)
  316.     {
  317.         return 'contao.' . $strScope . '.' . strtolower(str_replace('TL_', '', $strType));
  318.     }
  319. }
  321. class_alias(Message::class, 'Message');