Drupal\graphql_views\Plugin\Deriver\Fields\ViewDeriver

Complexity

Total Complexity

24

Size/Duplication

Total Lines	185
Duplicated Lines	30.27 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
B	getDerivativeDefinitions()	0	39	5
A	getPagerArguments()	0	6	2
A	getContextualArguments()	11	11	2
A	getSortArguments()	14	14	3
A	getFilterArguments()	11	11	4
B	getTypes()	20	40	8

<?php

namespace Drupal\graphql_views\Plugin\Deriver\Fields;

use Drupal\Core\Plugin\Discovery\ContainerDeriverInterface;
use Drupal\graphql\Utility\StringHelper;
use Drupal\graphql_views\Plugin\Deriver\ViewDeriverBase;
use Drupal\views\Plugin\views\display\DisplayPluginInterface;
use Drupal\views\Views;

/**
 * Derive fields from configured views.
 */
class ViewDeriver extends ViewDeriverBase implements ContainerDeriverInterface {

  /**
   * {@inheritdoc}
   */
  public function getDerivativeDefinitions($basePluginDefinition) {
    if ($this->entityTypeManager->hasDefinition('view')) {
      $viewStorage = $this->entityTypeManager->getStorage('view');

      foreach (Views::getApplicableViews('graphql_display') as list($viewId, $displayId)) {
        /** @var \Drupal\views\ViewEntityInterface $view */
        $view = $viewStorage->load($viewId);
        if (!$this->getRowResolveType($view, $displayId)) {

The expression $this->getRowResolveType($view, $displayId) of type null|string is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

          continue;
        }

        /** @var \Drupal\graphql_views\Plugin\views\display\GraphQL $display */
        $display = $this->getViewDisplay($view, $displayId);

        $id = implode('-', [$viewId, $displayId, 'view']);
        $info = $this->getArgumentsInfo($display->getOption('arguments') ?: []);
        $arguments = [];
        $arguments += $this->getContextualArguments($info, $id);
        $arguments += $this->getPagerArguments($display);
        $arguments += $this->getSortArguments($display, $id);
        $arguments += $this->getFilterArguments($display, $id);
        $types = $this->getTypes($display, $info);

        $this->derivatives[$id] = [
          'id' => $id,
          'name' => $display->getGraphQLQueryName(),
          'type' => $display->getGraphQLResultName(),
          'parents' => $types,
          'arguments' => $arguments,
          'view' => $viewId,
          'display' => $displayId,
          'paged' => $this->isPaged($display),
          'arguments_info' => $info,
        ] + $this->getCacheMetadataDefinition($view, $display) + $basePluginDefinition;
      }
    }

    return parent::getDerivativeDefinitions($basePluginDefinition);
  }

  /**
   * Helper function to return the contextual filter argument if any exist.
   *
   * @param array $arguments
   *   The array of available arguments.
   * @param $id
   *   The plugin derivative id.
   *
   * @return array
   *   The contextual filter argument if applicable.
   */
  protected function getContextualArguments(array $arguments, $id) {

This method seems to be duplicated in your project.

    if (!empty($arguments)) {
      return [
        'contextualFilter' => [
          'type' => StringHelper::camelCase($id, 'contextual', 'filter', 'input'),
        ],
      ];
    }

    return [];
  }

  /**
   * Helper function to retrieve the sort arguments if any are exposed.
   *
   * @param \Drupal\views\Plugin\views\display\DisplayPluginInterface $display
   *   The display plugin.
   * @param $id
   *   The plugin derivative id.
   *
   * @return array
   *   The sort arguments if any exposed sorts are available.
   */
  protected function getSortArguments(DisplayPluginInterface $display, $id) {

This method seems to be duplicated in your project.

    $sorts = array_filter($display->getOption('sorts') ?: [], function ($sort) {
      return $sort['exposed'];
    });
    return $sorts ? [
      'sortDirection' => [
        'type' => 'ViewSortDirection',
        'default' => 'asc',
      ],
      'sortBy' => [
        'type' => StringHelper::camelCase($id, 'sort', 'by'),
      ],
    ] : [];
  }

  /**
   * Helper function to return the filter argument if applicable.
   *
   * @param \Drupal\views\Plugin\views\display\DisplayPluginInterface $display
   *   The display plugin.
   * @param $id
   *   The plugin derivative id.
   *
   * @return array
   *   The filter argument if any exposed filters are available.
   */
  protected function getFilterArguments(DisplayPluginInterface $display, $id) {

This method seems to be duplicated in your project.

    $filters = array_filter($display->getOption('filters') ?: [], function($filter) {
      return array_key_exists('exposed', $filter) && $filter['exposed'];
    });

    return !empty($filters) ? [
      'filter' => [
        'type' => $display->getGraphQLFilterInputName(),
      ],
    ] : [];
  }

  /**
   * Helper function to retrieve the pager arguments if the display is paged.
   *
   * @param \Drupal\views\Plugin\views\display\DisplayPluginInterface $display
   *   The display plugin.
   *
   * @return array
   *   An array of pager arguments if the view display is paged.
   */
  protected function getPagerArguments(DisplayPluginInterface $display) {
    return $this->isPaged($display) ? [
      'page' => ['type' => 'Int', 'default' => $this->getPagerOffset($display)],
      'pageSize' => ['type' => 'Int', 'default' => $this->getPagerLimit($display)],
    ] : [];
  }

  /**
   * Helper function to retrieve the types that the view can be attached to.
   *
   * @param \Drupal\views\Plugin\views\display\DisplayPluginInterface $display
   *   The display plugin.
   * @param array $arguments
   *   An array containing information about the available arguments.
   * @return array
   *   An array of additional types the view can be embedded in.
   */
  protected function getTypes(DisplayPluginInterface $display, array $arguments) {
    $types = ['Root'];

    if (($entity_type = $display->getOption('entity_type'))) {
      $types = array_merge($types, [StringHelper::camelCase($entity_type)]);

      if (($bundles = $display->getOption('bundles'))) {
        $types = array_merge($types, array_map(function ($bundle) use ($entity_type) {
          return StringHelper::camelCase($entity_type, $bundle);
        }, $bundles));
      }
    }

    if (empty($arguments)) {
      return $types;
    }

    foreach ($arguments as $argument) {

This code seems to be duplicated across your project.

      // Depending on whether bundles are known, we expose the view field
      // either on the interface (e.g. Node) or on the type (e.g. NodePage)
      // level. Here we specify types managed by other graphql_* modules,
      // yet we don't define these modules as dependencies. If types are not
      // in the schema, the resulting GraphQL field will be attached to
      // nowhere, so it won't go into the schema.
      if (empty($argument['bundles']) && empty($argument['entity_type'])) {
        continue;
      }

      if (empty($argument['bundles'])) {
        $types = array_merge($types, [StringHelper::camelCase($argument['entity_type'])]);
      }
      else {
        $types = array_merge($types, array_map(function ($bundle) use ($argument) {
          return StringHelper::camelCase($argument['entity_type'], $bundle);
        }, array_keys($argument['bundles'])));
      }
    }

    return $types;
  }

}