LegacyMessenger.php in Drupal 8

Namespace

Drupal\Core\Messenger

File

core/lib/Drupal/Core/Messenger/LegacyMessenger.php

<?php

namespace Drupal\Core\Messenger;

use Drupal\Component\Render\MarkupInterface;
use Drupal\Core\Render\Markup;

/**
 * Provides a LegacyMessenger implementation.
 *
 * This implementation is for handling messages in a backwards compatible way
 * using core's previous $_SESSION storage method.
 *
 * You should not instantiate a new instance of this class directly. Instead,
 * you should inject the "messenger" service into your own services or use
 * \Drupal::messenger() in procedural functions.
 *
 * @see https://www.drupal.org/node/2774931
 * @see https://www.drupal.org/node/2928994
 *
 * @deprecated in drupal:8.5.0 and is removed from drupal:9.0.0.
 *   Use \Drupal\Core\Messenger\Messenger instead.
 */
class LegacyMessenger implements MessengerInterface {

  /**
   * The messages.
   *
   * Note: this property must remain static because it must behave in a
   * persistent manner, similar to $_SESSION['messages']. Creating a new class
   * each time would destroy any previously set messages.
   *
   * @var array
   */
  protected static $messages;

  /**
   * {@inheritdoc}
   */
  public function addError($message, $repeat = FALSE) {
    return $this
      ->addMessage($message, static::TYPE_ERROR, $repeat);
  }

  /**
   * {@inheritdoc}
   */
  public function addMessage($message, $type = self::TYPE_STATUS, $repeat = FALSE) {

    // Proxy to the Messenger service, if it exists.
    if ($messenger = $this
      ->getMessengerService()) {
      return $messenger
        ->addMessage($message, $type, $repeat);
    }
    if (!isset(static::$messages[$type])) {
      static::$messages[$type] = [];
    }
    if (!$message instanceof Markup && $message instanceof MarkupInterface) {
      $message = Markup::create((string) $message);
    }

    // Do not use strict type checking so that equivalent string and
    // MarkupInterface objects are detected.
    if ($repeat || !in_array($message, static::$messages[$type])) {
      static::$messages[$type][] = $message;
    }
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function addStatus($message, $repeat = FALSE) {
    return $this
      ->addMessage($message, static::TYPE_STATUS, $repeat);
  }

  /**
   * {@inheritdoc}
   */
  public function addWarning($message, $repeat = FALSE) {
    return $this
      ->addMessage($message, static::TYPE_WARNING, $repeat);
  }

  /**
   * {@inheritdoc}
   */
  public function all() {

    // Proxy to the Messenger service, if it exists.
    if ($messenger = $this
      ->getMessengerService()) {
      return $messenger
        ->all();
    }
    return static::$messages;
  }

  /**
   * Returns the Messenger service.
   *
   * @return \Drupal\Core\Messenger\MessengerInterface|null
   *   The Messenger service.
   */
  protected function getMessengerService() {

    // Use the Messenger service, if it exists.
    if (\Drupal::hasService('messenger')) {

      // Note: because the container has the potential to be rebuilt during
      // requests, this service cannot be directly stored on this class.

      /** @var \Drupal\Core\Messenger\MessengerInterface $messenger */
      $messenger = \Drupal::service('messenger');

      // Transfer any messages into the service.
      if (isset(static::$messages)) {
        foreach (static::$messages as $type => $messages) {
          foreach ($messages as $message) {

            // Force repeat to TRUE since this is merging existing messages to
            // the Messenger service and would have already checked this prior.
            $messenger
              ->addMessage($message, $type, TRUE);
          }
        }
        static::$messages = NULL;
      }
      return $messenger;
    }

    // Otherwise, trigger an error.
    @trigger_error('Adding or retrieving messages prior to the container being initialized was deprecated in Drupal 8.5.0 and this functionality will be removed before Drupal 9.0.0. Please report this usage at https://www.drupal.org/node/2928994.', E_USER_DEPRECATED);

    // Prematurely creating $_SESSION['messages'] in this class' constructor
    // causes issues when the container attempts to initialize its own session
    // later down the road. This can only be done after it has been determined
    // the Messenger service is not available (i.e. no container). It is also
    // reasonable to assume that if the container becomes available in a
    // subsequent request, a new instance of this class will be created and
    // this code will never be reached. This is merely for BC purposes.
    if (!isset(static::$messages)) {

      // A "session" was already created, perhaps to simply allow usage of
      // the previous method core used to store messages, use it.
      if (isset($_SESSION)) {
        if (!isset($_SESSION['messages'])) {
          $_SESSION['messages'] = [];
        }
        static::$messages =& $_SESSION['messages'];
      }
      else {
        static::$messages = [];
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function messagesByType($type) {

    // Proxy to the Messenger service, if it exists.
    if ($messenger = $this
      ->getMessengerService()) {
      return $messenger
        ->messagesByType($type);
    }
    return static::$messages[$type];
  }

  /**
   * {@inheritdoc}
   */
  public function deleteAll() {

    // Proxy to the Messenger service, if it exists.
    if ($messenger = $this
      ->getMessengerService()) {
      return $messenger
        ->deleteAll();
    }
    $messages = static::$messages;
    static::$messages = NULL;
    return $messages;
  }

  /**
   * {@inheritdoc}
   */
  public function deleteByType($type) {

    // Proxy to the Messenger service, if it exists.
    if ($messenger = $this
      ->getMessengerService()) {
      return $messenger
        ->deleteByType($type);
    }
    $messages = static::$messages[$type];
    unset(static::$messages[$type]);
    return $messages;
  }

}

Classes

Name	Description
LegacyMessenger Deprecated	Provides a LegacyMessenger implementation.