Drupal\graphql_views\Plugin\GraphQL\Fields\View

Complexity

Total Complexity

24

Size/Duplication

Total Lines	173
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	create()	0	8	1
B	resolveValues()	0	49	8
A	getCacheDependencies()	0	5	1
B	extractContextualFilters()	0	23	7
B	extractExposedInput()	0	25	6

<?php

namespace Drupal\graphql_views\Plugin\GraphQL\Fields;

use Drupal\Core\DependencyInjection\DependencySerializationTrait;
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
use Drupal\graphql\GraphQL\Execution\ResolveContext;
use Drupal\graphql\Plugin\GraphQL\Fields\FieldPluginBase;
use GraphQL\Type\Definition\ResolveInfo;
use Symfony\Component\DependencyInjection\ContainerInterface;

/**
 * Expose views as root fields.
 *
 * @GraphQLField(
 *   id = "view",
 *   secure = true,
 *   parents = {"Root"},
 *   provider = "views",
 *   deriver = "Drupal\graphql_views\Plugin\Deriver\Fields\ViewDeriver"
 * )
 */
class View extends FieldPluginBase implements ContainerFactoryPluginInterface {
  use DependencySerializationTrait;

  /**
   * The entity type manager.
   *
   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
   */
  protected $entityTypeManager;

  /**
   * {@inheritdoc}
   */
  public function __construct(
    array $configuration,
    $pluginId,
    $pluginDefinition,
    EntityTypeManagerInterface $entityTypeManager
  ) {
    $this->entityTypeManager = $entityTypeManager;
    parent::__construct($configuration, $pluginId, $pluginDefinition);
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $pluginId, $pluginDefinition) {
    return new static(
      $configuration,
      $pluginId,
      $pluginDefinition,
      $container->get('entity_type.manager')
    );
  }

  /**
   * {@inheritdoc}
   */
  public function resolveValues($value, array $args, ResolveContext $context, ResolveInfo $info) {
    $storage = $this->entityTypeManager->getStorage('view');
    $definition = $this->getPluginDefinition();

    /** @var \Drupal\views\Entity\View $view */
    if ($view = $storage->load($definition['view'])) {
      $executable = $view->getExecutable();
      $executable->setDisplay($definition['display']);

      // Set view contextual filters.
      /* @see \Drupal\graphql_views\ViewDeriverHelperTrait::getArgumentsInfo() */
      if (!empty($definition['arguments_info'])) {
        $arguments = $this->extractContextualFilters($value, $args);
        $executable->setArguments($arguments);
      }

      $filters = $executable->getDisplay()->getOption('filters');;
      $input = $this->extractExposedInput($value, $args, $filters);
      $executable->setExposedInput($input);

      // This is a workaround for the Taxonomy Term filter which requires a full
      // exposed form to be sent OR the display being an attachment to just
      // accept input values.
      $executable->is_attachment = TRUE;
      $executable->exposed_raw_input = $input;

      if (!empty($definition['paged'])) {
        // Set paging parameters.
        $executable->setItemsPerPage($args['pageSize']);
        $executable->setCurrentPage($args['page']);
      }

      if (isset($args['offset']) && !empty($args['offset'])) {
        $executable->setOffset($args['offset']);
      }

      $result = $executable->render($definition['display']);
      /** @var \Drupal\Core\Cache\CacheableMetadata $cache */
      if ($cache = $result['cache']) {
        $cache->setCacheContexts(
          array_filter($cache->getCacheContexts(), function ($context) {
            // Don't emit the url cache contexts.
            return $context !== 'url' && strpos($context, 'url.') !== 0;
          })
        );
      }
      yield $result;
    }
  }

  /**
   * {@inheritdoc}
   */
  protected function getCacheDependencies(array $result, $value, array $args, ResolveContext $context, ResolveInfo $info) {
    return array_map(function ($item) {
      return $item['cache'];
    }, $result);
  }

  /**
   * Retrieves the contextual filter argument from the parent value or args.
   *
   * @param $value
   *   The resolved parent value.
   * @param $args
   *   The arguments provided to the field.
   *
   * @return array
   *   An array of arguments containing the contextual filter value from the
   *   parent or provided args if any.
   */
  protected function extractContextualFilters($value, $args) {
    $definition = $this->getPluginDefinition();
    $arguments = [];

    foreach ($definition['arguments_info'] as $argumentId => $argumentInfo) {
      if (isset($args['contextualFilter'][$argumentId])) {
        $arguments[$argumentInfo['index']] = $args['contextualFilter'][$argumentId];
      }
      elseif (
        $value instanceof EntityInterface &&

The class Drupal\Core\Entity\EntityInterface does not exist. Did you forget a USE statement, or did you not list all dependencies?

        $value->getEntityTypeId() === $argumentInfo['entity_type'] &&
        (empty($argumentInfo['bundles']) ||
          in_array($value->bundle(), $argumentInfo['bundles'], TRUE))
      ) {
        $arguments[$argumentInfo['index']] = $value->id();
      }
      else {
        $arguments[$argumentInfo['index']] = NULL;
      }
    }

    return $arguments;
  }

  /**
   * Retrieves sort and filter arguments from the provided field args.
   *
   * @param $value
   *   The resolved parent value.
   * @param $args
   *   The array of arguments provided to the field.
   * @param $filters
   *   The available filters for the configured view.
   *
   * @return array
   *   The array of sort and filter arguments to execute the view with.
   */
  protected function extractExposedInput($value, $args, $filters) {
    // Prepare arguments for use as exposed form input.
    $input = array_filter([
      // Sorting arguments.
      'sort_by' => isset($args['sortBy']) ? $args['sortBy'] : NULL,
      'sort_order' => isset($args['sortDirection']) ? $args['sortDirection'] : NULL,
    ]);

    // If some filters are missing from the input, set them to an empty string
    // explicitly. Otherwise views module generates "Undefined index" notice.
    foreach ($filters as $filterKey => $filterRow) {
      if (!isset($filterRow['expose']['identifier'])) {
        continue;
      }

      $inputKey = $filterRow['expose']['identifier'];
      if (!isset($args['filter'][$inputKey])) {
        $input[$inputKey] = $filterRow['value'];
      } else {
        $input[$inputKey] = $args['filter'][$inputKey];
      }
    }

    return $input;
  }

}