ContextProviderTrait.php

<?php

namespace Drupal\rules\Context;

use Drupal\Component\Plugin\Exception\ContextException;
use Drupal\Core\Plugin\Context\Context;
use Symfony\Component\Routing\Route;

/**
 * A trait implementing the ContextProviderInterface.
 *
 * This trait is intended for context aware plugins that want to provide
 * context.
 *
 * The trait requires the plugin to use configuration as defined by the
 * ContextConfig class.
 *
 * @see \Drupal\rules\Context\ContextProviderInterface
 */
trait ContextProviderTrait {
  
  /**
   * The data objects that are provided by this plugin.
   *
   * @var \Drupal\Component\Plugin\Context\ContextInterface[]
   */
  protected $providedContext;
  
  /**
   * @see \Drupal\rules\Context\ContextProviderInterface
   */
  public function setProvidedValue($name, $value) {
    $context = $this->getProvidedContext($name);
    $new_context = Context::createFromContext($context, $value);
    $this->providedContext[$name] = $new_context;
    return $this;
  }
  
  /**
   * @see \Drupal\rules\Context\ContextProviderInterface
   */
  public function getProvidedContext($name) {
    // Check for a valid context value.
    if (!isset($this->providedContext[$name])) {
      $this->providedContext[$name] = new Context($this->getProvidedContextDefinition($name));
    }
    return $this->providedContext[$name];
  }
  
  /**
   * @see \Drupal\rules\Context\ContextProviderInterface
   */
  public function getProvidedContextDefinition($name) {
    $definition = $this->getPluginDefinition();
    if (empty($definition['provides'][$name])) {
      throw new ContextException(sprintf("The provided context '%s' is not valid.", $name));
    }
    return $definition['provides'][$name];
  }
  
  /**
   * @see \Drupal\rules\Context\ContextProviderInterface
   */
  public function getProvidedContextDefinitions() {
    $definition = $this->getPluginDefinition();
    return !empty($definition['provides']) ? $definition['provides'] : [];
  }
  
  /**
   * Upcasts an entity id to a full entity object.
   *
   * Returns the entity object if the upcast was successful, otherwise returns
   * NULL.
   *
   * @todo Rather than returning NULL, we should probably throw an exception.
   * That way the calling code may attempt an upcast, then continue on as it
   * used to if the upcast fails.
   *
   * @param string $id
   *   The unique entity id to upcast to a full entity.
   * @param string $type
   *   The entity data type. For example, "entity:node".
   *
   * @return \Drupal\Core\Entity\EntityInterface|null
   *   The upcasted entity object (if successful) or null (if not).
   */
  public function upcastEntityId($id, $type) {
    // If the passed value is (accidentally) already an object, just return it.
    if (is_object($id)) {
      return $id;
    }
    $paramConverterManager = \Drupal::service('paramconverter_manager');
    /** @var \Drupal\Core\ParamConverter\ParamConverterInterface $param_converter */
    $param_converter = $paramConverterManager->getConverter('paramconverter.entity');
    // The $name variable is just an arbitrary slug for use in the route object.
    $name = 'id_to_upcast';
    // The $definition variable declares what datatype the slug represents.
    $definition = [
      'type' => $type,
    ];
    // The Route class used here is just a data structure for holding data
    // necessary for a route definition. Creating an object of this type does
    // not in any way affect routing on the site. We only use Route here because
    // the paramconverter_manager requires this structure for one of its inputs.
    $route = new Route('/{$name}');
    // Check that the definition can be upcast and if so do it.
    if ($param_converter->applies($definition, $name, $route)) {
      $defaults = [
        $name => $id,
      ];
      $upcasted_object = $param_converter->convert(strtolower($id), $definition, $name, $defaults);
      return $upcasted_object;
    }
    else {
      return NULL;
    }
  }

}