Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
0.00% |
0 / 7 |
CRAP | |
0.00% |
0 / 90 |
| ResourceBase | |
0.00% |
0 / 1 |
|
0.00% |
0 / 7 |
342 | |
0.00% |
0 / 90 |
| __construct | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 4 |
|||
| create | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 8 |
|||
| permissions | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 10 |
|||
| routes | |
0.00% |
0 / 1 |
90 | |
0.00% |
0 / 33 |
|||
| requestMethods | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 12 |
|||
| availableMethods | |
0.00% |
0 / 1 |
12 | |
0.00% |
0 / 9 |
|||
| getBaseRoute | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 14 |
|||
| <?php | |
| /** | |
| * @file | |
| * Contains \Drupal\rest\Plugin\ResourceBase. | |
| */ | |
| namespace Drupal\rest\Plugin; | |
| use Drupal\Core\Plugin\ContainerFactoryPluginInterface; | |
| use Drupal\Core\Plugin\PluginBase; | |
| use Psr\Log\LoggerInterface; | |
| use Symfony\Component\DependencyInjection\ContainerInterface; | |
| use Symfony\Component\Routing\Route; | |
| use Symfony\Component\Routing\RouteCollection; | |
| /** | |
| * Common base class for resource plugins. | |
| * | |
| * @see \Drupal\rest\Annotation\RestResource | |
| * @see \Drupal\rest\Plugin\Type\ResourcePluginManager | |
| * @see \Drupal\rest\Plugin\ResourceInterface | |
| * @see plugin_api | |
| * | |
| * @ingroup third_party | |
| */ | |
| 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(), | |
| // The HTTP method is a requirement for this route. | |
| array($method) | |
| ); | |
| return $route; | |
| } | |
| } |