protected static function Routes::getIndividualRoutesForResourceType in Drupal 9

Same name and namespace in other branches

1. 8 core/modules/jsonapi/src/Routing/Routes.php \Drupal\jsonapi\Routing\Routes::getIndividualRoutesForResourceType()
2. 10 core/modules/jsonapi/src/Routing/Routes.php \Drupal\jsonapi\Routing\Routes::getIndividualRoutesForResourceType()

Gets a route collection for the given resource type.

Parameters

\Drupal\jsonapi\ResourceType\ResourceType $resource_type: The resource type for which the route collection should be created.

Return value

\Symfony\Component\Routing\RouteCollection The route collection.

1 call to Routes::getIndividualRoutesForResourceType()

Routes::getRoutesForResourceType in core/modules/jsonapi/src/Routing/Routes.php

Gets applicable resource routes for a JSON:API resource type.

File

core/modules/jsonapi/src/Routing/Routes.php, line 280

Class

Routes

Defines dynamic routes.

Namespace

Drupal\jsonapi\Routing

Code

protected static function getIndividualRoutesForResourceType(ResourceType $resource_type) {
  if (!$resource_type
    ->isLocatable()) {
    return new RouteCollection();
  }
  $routes = new RouteCollection();
  $path = $resource_type
    ->getPath();
  $entity_type_id = $resource_type
    ->getEntityTypeId();

  // Individual read, update and remove.
  $individual_route = new Route("/{$path}/{entity}");
  $individual_route
    ->addDefaults([
    RouteObjectInterface::CONTROLLER_NAME => static::CONTROLLER_SERVICE_NAME . ':getIndividual',
  ]);
  $individual_route
    ->setMethods([
    'GET',
  ]);

  // No _entity_access requirement because "view" and "view label" access are
  // checked in the controller. So it's safe to allow anybody access.
  $individual_route
    ->setRequirement('_access', 'TRUE');
  $routes
    ->add(static::getRouteName($resource_type, 'individual'), $individual_route);
  if ($resource_type
    ->isMutable()) {
    $individual_update_route = new Route($individual_route
      ->getPath());
    $individual_update_route
      ->addDefaults([
      RouteObjectInterface::CONTROLLER_NAME => static::CONTROLLER_SERVICE_NAME . ':patchIndividual',
    ]);
    $individual_update_route
      ->setMethods([
      'PATCH',
    ]);
    $individual_update_route
      ->setRequirement('_entity_access', "entity.update");
    $individual_update_route
      ->setRequirement('_csrf_request_header_token', 'TRUE');
    $routes
      ->add(static::getRouteName($resource_type, 'individual.patch'), $individual_update_route);
    $individual_remove_route = new Route($individual_route
      ->getPath());
    $individual_remove_route
      ->addDefaults([
      RouteObjectInterface::CONTROLLER_NAME => static::CONTROLLER_SERVICE_NAME . ':deleteIndividual',
    ]);
    $individual_remove_route
      ->setMethods([
      'DELETE',
    ]);
    $individual_remove_route
      ->setRequirement('_entity_access', "entity.delete");
    $individual_remove_route
      ->setRequirement('_csrf_request_header_token', 'TRUE');
    $routes
      ->add(static::getRouteName($resource_type, 'individual.delete'), $individual_remove_route);
  }
  foreach ($resource_type
    ->getRelatableResourceTypes() as $relationship_field_name => $target_resource_types) {

    // Read, update, add, or remove an individual resources relationships to
    // other resources.
    $relationship_route = new Route("/{$path}/{entity}/relationships/{$relationship_field_name}");
    $relationship_route
      ->addDefaults([
      '_on_relationship' => TRUE,
    ]);
    $relationship_route
      ->addDefaults([
      'related' => $relationship_field_name,
    ]);
    $relationship_route
      ->setRequirement('_csrf_request_header_token', 'TRUE');
    $relationship_route_methods = $resource_type
      ->isMutable() ? [
      'GET',
      'POST',
      'PATCH',
      'DELETE',
    ] : [
      'GET',
    ];
    $relationship_controller_methods = [
      'GET' => 'getRelationship',
      'POST' => 'addToRelationshipData',
      'PATCH' => 'replaceRelationshipData',
      'DELETE' => 'removeFromRelationshipData',
    ];
    foreach ($relationship_route_methods as $method) {
      $method_specific_relationship_route = clone $relationship_route;
      $field_operation = $method === 'GET' ? 'view' : 'edit';
      $method_specific_relationship_route
        ->setRequirement(RelationshipRouteAccessCheck::ROUTE_REQUIREMENT_KEY, "{$relationship_field_name}.{$field_operation}");
      $method_specific_relationship_route
        ->addDefaults([
        RouteObjectInterface::CONTROLLER_NAME => static::CONTROLLER_SERVICE_NAME . ":{$relationship_controller_methods[$method]}",
      ]);
      $method_specific_relationship_route
        ->setMethods($method);
      $routes
        ->add(static::getRouteName($resource_type, sprintf("%s.relationship.%s", $relationship_field_name, strtolower($method))), $method_specific_relationship_route);
    }

    // Only create routes for related routes that target at least one
    // non-internal resource type.
    if (static::hasNonInternalTargetResourceTypes($target_resource_types)) {

      // Get an individual resource's related resources.
      $related_route = new Route("/{$path}/{entity}/{$relationship_field_name}");
      $related_route
        ->setMethods([
        'GET',
      ]);
      $related_route
        ->addDefaults([
        RouteObjectInterface::CONTROLLER_NAME => static::CONTROLLER_SERVICE_NAME . ':getRelated',
      ]);
      $related_route
        ->addDefaults([
        'related' => $relationship_field_name,
      ]);
      $related_route
        ->setRequirement(RelationshipRouteAccessCheck::ROUTE_REQUIREMENT_KEY, "{$relationship_field_name}.view");
      $routes
        ->add(static::getRouteName($resource_type, "{$relationship_field_name}.related"), $related_route);
    }
  }

  // Add entity parameter conversion to every route.
  $routes
    ->addOptions([
    'parameters' => [
      'entity' => [
        'type' => 'entity:' . $entity_type_id,
      ],
    ],
  ]);
  return $routes;
}