You are here

Home » API reference » Zircon Profile 8 » ResourceBase.php

abstract class ResourceBase in Zircon Profile 8

Same name and namespace in other branches
  1. 8.0 core/modules/rest/src/Plugin/ResourceBase.php \Drupal\rest\Plugin\ResourceBase

Common base class for resource plugins.

Hierarchy

Expanded class hierarchy of ResourceBase

See also

\Drupal\rest\Annotation\RestResource

\Drupal\rest\Plugin\Type\ResourcePluginManager

\Drupal\rest\Plugin\ResourceInterface

Plugin API

Related topics

REST and Application Integration
Integrating third-party applications using REST and related operations.
2 files declare their use of ResourceBase
DBLogResource.php in core/modules/dblog/src/Plugin/rest/resource/DBLogResource.php
Contains \Drupal\dblog\Plugin\rest\resource\DBLogResource.
EntityResource.php in core/modules/rest/src/Plugin/rest/resource/EntityResource.php
Contains \Drupal\rest\Plugin\rest\resource\EntityResource.

File

core/modules/rest/src/Plugin/ResourceBase.php, line 27
Contains \Drupal\rest\Plugin\ResourceBase.

Namespace

Drupal\rest\Plugin
View source 
abstract class ResourceBase extends PluginBase implements ContainerFactoryPluginInterface, ResourceInterface {

  /**
   * The available serialization formats.
   *
   * @var array
   */
  protected $serializerFormats = array();

  /**
   * A logger instance.
   *
   * @var \Psr\Log\LoggerInterface
   */
  protected $logger;

  /**
   * Constructs a Drupal\rest\Plugin\ResourceBase object.
   *
   * @param array $configuration
   *   A configuration array containing information about the plugin instance.
   * @param string $plugin_id
   *   The plugin_id for the plugin instance.
   * @param mixed $plugin_definition
   *   The plugin implementation definition.
   * @param array $serializer_formats
   *   The available serialization formats.
   * @param \Psr\Log\LoggerInterface $logger
   *   A logger instance.
   */
  public function __construct(array $configuration, $plugin_id, $plugin_definition, array $serializer_formats, LoggerInterface $logger) {
    parent::__construct($configuration, $plugin_id, $plugin_definition);
    $this->serializerFormats = $serializer_formats;
    $this->logger = $logger;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
    return new static($configuration, $plugin_id, $plugin_definition, $container
      ->getParameter('serializer.formats'), $container
      ->get('logger.factory')
      ->get('rest'));
  }

  /**
   * Implements ResourceInterface::permissions().
   *
   * Every plugin operation method gets its own user permission. Example:
   * "restful delete entity:node" with the title "Access DELETE on Node
   * resource".
   */
  public function permissions() {
    $permissions = array();
    $definition = $this
      ->getPluginDefinition();
    foreach ($this
      ->availableMethods() as $method) {
      $lowered_method = strtolower($method);
      $permissions["restful {$lowered_method} {$this->pluginId}"] = array(
        'title' => $this
          ->t('Access @method on %label resource', array(
          '@method' => $method,
          '%label' => $definition['label'],
        )),
      );
    }
    return $permissions;
  }

  /**
   * {@inheritdoc}
   */
  public function routes() {
    $collection = new RouteCollection();
    $definition = $this
      ->getPluginDefinition();
    $canonical_path = isset($definition['uri_paths']['canonical']) ? $definition['uri_paths']['canonical'] : '/' . strtr($this->pluginId, ':', '/') . '/{id}';
    $create_path = isset($definition['uri_paths']['https://www.drupal.org/link-relations/create']) ? $definition['uri_paths']['https://www.drupal.org/link-relations/create'] : '/' . strtr($this->pluginId, ':', '/');
    $route_name = strtr($this->pluginId, ':', '.');
    $methods = $this
      ->availableMethods();
    foreach ($methods as $method) {
      $route = $this
        ->getBaseRoute($canonical_path, $method);
      switch ($method) {
        case 'POST':
          $route
            ->setPath($create_path);

          // Restrict the incoming HTTP Content-type header to the known
          // serialization formats.
          $route
            ->addRequirements(array(
            '_content_type_format' => implode('|', $this->serializerFormats),
          ));
          $collection
            ->add("{$route_name}.{$method}", $route);
          break;
        case 'PATCH':

          // Restrict the incoming HTTP Content-type header to the known
          // serialization formats.
          $route
            ->addRequirements(array(
            '_content_type_format' => implode('|', $this->serializerFormats),
          ));
          $collection
            ->add("{$route_name}.{$method}", $route);
          break;
        case 'GET':
        case 'HEAD':

          // Restrict GET and HEAD requests to the media type specified in the
          // HTTP Accept headers.
          foreach ($this->serializerFormats as $format_name) {

            // Expose one route per available format.
            $format_route = clone $route;
            $format_route
              ->addRequirements(array(
              '_format' => $format_name,
            ));
            $collection
              ->add("{$route_name}.{$method}.{$format_name}", $format_route);
          }
          break;
        default:
          $collection
            ->add("{$route_name}.{$method}", $route);
          break;
      }
    }
    return $collection;
  }

  /**
   * Provides predefined HTTP request methods.
   *
   * Plugins can override this method to provide additional custom request
   * methods.
   *
   * @return array
   *   The list of allowed HTTP request method strings.
   */
  protected function requestMethods() {
    return array(
      'HEAD',
      'GET',
      'POST',
      'PUT',
      'DELETE',
      'TRACE',
      'OPTIONS',
      'CONNECT',
      'PATCH',
    );
  }

  /**
   * {@inheritdoc}
   */
  public function availableMethods() {
    $methods = $this
      ->requestMethods();
    $available = array();
    foreach ($methods as $method) {

      // Only expose methods where the HTTP request method exists on the plugin.
      if (method_exists($this, strtolower($method))) {
        $available[] = $method;
      }
    }
    return $available;
  }

  /**
   * Setups the base route for all HTTP methods.
   *
   * @param string $canonical_path
   *   The canonical path for the resource.
   * @param string $method
   *   The HTTP method to be used for the route.
   *
   * @return \Symfony\Component\Routing\Route
   *   The created base route.
   */
  protected function getBaseRoute($canonical_path, $method) {
    $lower_method = strtolower($method);
    $route = new Route($canonical_path, array(
      '_controller' => 'Drupal\\rest\\RequestHandler::handle',
      // Pass the resource plugin ID along as default property.
      '_plugin' => $this->pluginId,
    ), array(
      '_permission' => "restful {$lower_method} {$this->pluginId}",
    ), array(), '', array(), array(
      $method,
    ));
    return $route;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
DependencySerializationTrait::$_serviceIds protected property An array of service IDs keyed by property name used for serialization.
DependencySerializationTrait::__sleep public function 1
DependencySerializationTrait::__wakeup public function 2
PluginBase::$configuration protected property Configuration information passed into the plugin. 2
PluginBase::$pluginDefinition protected property The plugin implementation definition.
PluginBase::$pluginId protected property The plugin_id.
PluginBase::DERIVATIVE_SEPARATOR constant A string which is used to separate base plugin IDs from the derivative ID.
PluginBase::getBaseId public function Gets the base_plugin_id of the plugin instance. Overrides DerivativeInspectionInterface::getBaseId
PluginBase::getDerivativeId public function Gets the derivative_id of the plugin instance. Overrides DerivativeInspectionInterface::getDerivativeId
PluginBase::getPluginDefinition public function Gets the definition of the plugin implementation. Overrides PluginInspectionInterface::getPluginDefinition
PluginBase::getPluginId public function Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
ResourceBase::$logger protected property A logger instance.
ResourceBase::$serializerFormats protected property The available serialization formats.
ResourceBase::availableMethods public function Returns the available HTTP request methods on this plugin. Overrides ResourceInterface::availableMethods
ResourceBase::create public static function Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface::create
ResourceBase::getBaseRoute protected function Setups the base route for all HTTP methods. 1
ResourceBase::permissions public function Implements ResourceInterface::permissions(). Overrides ResourceInterface::permissions
ResourceBase::requestMethods protected function Provides predefined HTTP request methods.
ResourceBase::routes public function Returns a collection of routes with URL path information for the resource. Overrides ResourceInterface::routes
ResourceBase::__construct public function Constructs a Drupal\rest\Plugin\ResourceBase object. Overrides PluginBase::__construct
StringTranslationTrait::$stringTranslation protected property The string translation service.
StringTranslationTrait::formatPlural protected function Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals protected function Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation protected function Gets the string translation service.
StringTranslationTrait::setStringTranslation public function Sets the string translation service to use. 2
StringTranslationTrait::t protected function Translates a string to the current language or to a given language.