You are here

abstract class WizardPluginBase in Drupal 9

Same name and namespace in other branches
  1. 8 core/modules/views/src/Plugin/views/wizard/WizardPluginBase.php \Drupal\views\Plugin\views\wizard\WizardPluginBase

Base class for Views wizard plugins.

This is a very generic Views Wizard class that can be constructed for any base table.

Hierarchy

Expanded class hierarchy of WizardPluginBase

Related topics

12 files declare their use of WizardPluginBase
BlockContent.php in core/modules/block_content/src/Plugin/views/wizard/BlockContent.php
Comment.php in core/modules/comment/src/Plugin/views/wizard/Comment.php
File.php in core/modules/file/src/Plugin/views/wizard/File.php
Media.php in core/modules/media/src/Plugin/views/wizard/Media.php
MediaRevision.php in core/modules/media/src/Plugin/views/wizard/MediaRevision.php

... See full list

File

core/modules/views/src/Plugin/views/wizard/WizardPluginBase.php, line 38

Namespace

Drupal\views\Plugin\views\wizard
View source
abstract class WizardPluginBase extends PluginBase implements WizardInterface {

  /**
   * The base table connected with the wizard.
   *
   * @var string
   */
  protected $base_table;

  /**
   * The entity type connected with the wizard.
   *
   * There might be base tables connected with entity types, if not this would
   * be empty.
   *
   * @var string
   */
  protected $entityTypeId;

  /**
   * Contains the information from entity_get_info of the $entity_type.
   *
   * @var \Drupal\Core\Entity\EntityTypeInterface
   */
  protected $entityType;

  /**
   * An array of validated view objects, keyed by a hash.
   *
   * @var array
   */
  protected $validated_views = [];

  /**
   * The table column used for sorting by create date of this wizard.
   *
   * @var string
   */
  protected $createdColumn;

  /**
   * Views items configuration arrays for filters added by the wizard.
   *
   * @var array
   */
  protected $filters = [];

  /**
   * Views items configuration arrays for sorts added by the wizard.
   *
   * @var array
   */
  protected $sorts = [];

  /**
   * The available store criteria.
   *
   * @var array
   */
  protected $availableSorts = [];

  /**
   * Default values for filters.
   *
   * By default, filters are not exposed and added to the first non-reserved
   * filter group.
   *
   * @var array
   */
  protected $filter_defaults = [
    'id' => NULL,
    'expose' => [
      'operator' => FALSE,
    ],
    'group' => 1,
  ];

  /**
   * The bundle info service.
   *
   * @var \Drupal\Core\Entity\EntityTypeBundleInfoInterface
   */
  protected $bundleInfoService;

  /**
   * The parent form selector service.
   *
   * @var \Drupal\Core\Menu\MenuParentFormSelectorInterface
   */
  protected $parentFormSelector;

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
    return new static($configuration, $plugin_id, $plugin_definition, $container
      ->get('entity_type.bundle.info'), $container
      ->get('menu.parent_form_selector'));
  }

  /**
   * Constructs a WizardPluginBase object.
   */
  public function __construct(array $configuration, $plugin_id, $plugin_definition, EntityTypeBundleInfoInterface $bundle_info_service, MenuParentFormSelectorInterface $parent_form_selector = NULL) {
    parent::__construct($configuration, $plugin_id, $plugin_definition);
    $this->bundleInfoService = $bundle_info_service;
    $this->base_table = $this->definition['base_table'];
    if (!$parent_form_selector) {
      @trigger_error('Calling ' . __METHOD__ . '() without the $parent_form_selector argument is deprecated in drupal:9.3.0 and the $parent_form_selector argument will be required in drupal:10.0.0. See https://www.drupal.org/node/3027559', E_USER_DEPRECATED);
      $parent_form_selector = \Drupal::service('menu.parent_form_selector');
    }
    $this->parentFormSelector = $parent_form_selector;
    $entity_types = \Drupal::entityTypeManager()
      ->getDefinitions();
    foreach ($entity_types as $entity_type_id => $entity_type) {
      if (in_array($this->base_table, [
        $entity_type
          ->getBaseTable(),
        $entity_type
          ->getDataTable(),
        $entity_type
          ->getRevisionTable(),
        $entity_type
          ->getRevisionDataTable(),
      ], TRUE)) {
        $this->entityType = $entity_type;
        $this->entityTypeId = $entity_type_id;
      }
    }
  }

  /**
   * Gets the createdColumn property.
   *
   * @return string
   *   The name of the column containing the created date.
   */
  public function getCreatedColumn() {
    return $this->createdColumn;
  }

  /**
   * Gets the filters property.
   *
   * @return array
   */
  public function getFilters() {
    $filters = [];

    // Add a default filter on the publishing status field, if available.
    if ($this->entityType && is_subclass_of($this->entityType
      ->getClass(), EntityPublishedInterface::class)) {
      $field_name = $this->entityType
        ->getKey('published');
      $this->filters = [
        $field_name => [
          'value' => TRUE,
          'table' => $this->base_table,
          'field' => $field_name,
          'plugin_id' => 'boolean',
          'entity_type' => $this->entityTypeId,
          'entity_field' => $field_name,
        ],
      ] + $this->filters;
    }
    $default = $this->filter_defaults;
    foreach ($this->filters as $name => $info) {
      $default['id'] = $name;
      $filters[$name] = $info + $default;
    }
    return $filters;
  }

  /**
   * Gets the availableSorts property.
   *
   * @return array
   */
  public function getAvailableSorts() {
    return $this->availableSorts;
  }

  /**
   * Gets the sorts property.
   *
   * @return array
   */
  public function getSorts() {
    return $this->sorts;
  }

  /**
   * {@inheritdoc}
   */
  public function buildForm(array $form, FormStateInterface $form_state) {
    $style_options = Views::fetchPluginNames('style', 'normal', [
      $this->base_table,
    ]);
    $feed_row_options = Views::fetchPluginNames('row', 'feed', [
      $this->base_table,
    ]);
    $path_prefix = Url::fromRoute('<none>', [], [
      'absolute' => TRUE,
    ])
      ->toString();

    // Add filters and sorts which apply to the view as a whole.
    $this
      ->buildFilters($form, $form_state);
    $this
      ->buildSorts($form, $form_state);
    $form['displays']['page'] = [
      '#type' => 'fieldset',
      '#title' => $this
        ->t('Page settings'),
      '#attributes' => [
        'class' => [
          'views-attachment',
          'fieldset-no-legend',
        ],
      ],
      '#tree' => TRUE,
    ];
    $form['displays']['page']['create'] = [
      '#title' => $this
        ->t('Create a page'),
      '#type' => 'checkbox',
      '#attributes' => [
        'class' => [
          'strong',
        ],
      ],
      '#default_value' => FALSE,
      '#id' => 'edit-page-create',
    ];

    // All options for the page display are included in this container so they
    // can be hidden as a group when the "Create a page" checkbox is unchecked.
    $form['displays']['page']['options'] = [
      '#type' => 'container',
      '#attributes' => [
        'class' => [
          'options-set',
        ],
      ],
      '#states' => [
        'visible' => [
          ':input[name="page[create]"]' => [
            'checked' => TRUE,
          ],
        ],
      ],
      '#prefix' => '<div><div id="edit-page-wrapper">',
      '#suffix' => '</div></div>',
      '#parents' => [
        'page',
      ],
    ];
    $form['displays']['page']['options']['title'] = [
      '#title' => $this
        ->t('Page title'),
      '#type' => 'textfield',
      '#maxlength' => 255,
    ];
    $form['displays']['page']['options']['path'] = [
      '#title' => $this
        ->t('Path'),
      '#type' => 'textfield',
      '#field_prefix' => $path_prefix,
      // Account for the leading backslash.
      '#maxlength' => 254,
    ];
    $form['displays']['page']['options']['style'] = [
      '#type' => 'fieldset',
      '#title' => $this
        ->t('Page display settings'),
      '#attributes' => [
        'class' => [
          'container-inline',
          'fieldset-no-legend',
        ],
      ],
    ];

    // Create the dropdown for choosing the display format.
    $form['displays']['page']['options']['style']['style_plugin'] = [
      '#title' => $this
        ->t('Display format'),
      '#type' => 'select',
      '#options' => $style_options,
    ];
    $style_form =& $form['displays']['page']['options']['style'];
    $style_form['style_plugin']['#default_value'] = static::getSelected($form_state, [
      'page',
      'style',
      'style_plugin',
    ], 'default', $style_form['style_plugin']);

    // Changing this dropdown updates $form['displays']['page']['options'] via
    // AJAX.
    views_ui_add_ajax_trigger($style_form, 'style_plugin', [
      'displays',
      'page',
      'options',
    ]);
    $this
      ->buildFormStyle($form, $form_state, 'page');
    $form['displays']['page']['options']['items_per_page'] = [
      '#title' => $this
        ->t('Items to display'),
      '#type' => 'number',
      '#default_value' => 10,
      '#min' => 0,
    ];
    $form['displays']['page']['options']['pager'] = [
      '#title' => $this
        ->t('Use a pager'),
      '#type' => 'checkbox',
      '#default_value' => TRUE,
    ];
    $form['displays']['page']['options']['link'] = [
      '#title' => $this
        ->t('Create a menu link'),
      '#type' => 'checkbox',
      '#id' => 'edit-page-link',
    ];
    $form['displays']['page']['options']['link_properties'] = [
      '#type' => 'container',
      '#states' => [
        'visible' => [
          ':input[name="page[link]"]' => [
            'checked' => TRUE,
          ],
        ],
      ],
      '#prefix' => '<div id="edit-page-link-properties-wrapper">',
      '#suffix' => '</div>',
    ];
    $form['displays']['page']['options']['link_properties']['parent'] = $this->parentFormSelector
      ->parentSelectElement('admin:');
    $form['displays']['page']['options']['link_properties']['parent'] += [
      '#title' => $this
        ->t('Menu'),
    ];
    $form['displays']['page']['options']['link_properties']['title'] = [
      '#title' => $this
        ->t('Link text'),
      '#type' => 'textfield',
    ];

    // Only offer a feed if we have at least one available feed row style.
    if ($feed_row_options) {
      $form['displays']['page']['options']['feed'] = [
        '#title' => $this
          ->t('Include an RSS feed'),
        '#type' => 'checkbox',
        '#id' => 'edit-page-feed',
      ];
      $form['displays']['page']['options']['feed_properties'] = [
        '#type' => 'container',
        '#states' => [
          'visible' => [
            ':input[name="page[feed]"]' => [
              'checked' => TRUE,
            ],
          ],
        ],
        '#prefix' => '<div id="edit-page-feed-properties-wrapper">',
        '#suffix' => '</div>',
      ];
      $form['displays']['page']['options']['feed_properties']['path'] = [
        '#title' => $this
          ->t('Feed path'),
        '#type' => 'textfield',
        '#field_prefix' => $path_prefix,
        // Account for the leading backslash.
        '#maxlength' => 254,
      ];

      // This will almost never be visible.
      $form['displays']['page']['options']['feed_properties']['row_plugin'] = [
        '#title' => $this
          ->t('Feed row style'),
        '#type' => 'select',
        '#options' => $feed_row_options,
        '#default_value' => key($feed_row_options),
        '#access' => count($feed_row_options) > 1,
        '#states' => [
          'visible' => [
            ':input[name="page[feed]"]' => [
              'checked' => TRUE,
            ],
          ],
        ],
        '#prefix' => '<div id="edit-page-feed-properties-row-plugin-wrapper">',
        '#suffix' => '</div>',
      ];
    }

    // Only offer the block settings if the module is enabled.
    if (\Drupal::moduleHandler()
      ->moduleExists('block')) {
      $form['displays']['block'] = [
        '#type' => 'fieldset',
        '#title' => $this
          ->t('Block settings'),
        '#attributes' => [
          'class' => [
            'views-attachment',
            'fieldset-no-legend',
          ],
        ],
        '#tree' => TRUE,
      ];
      $form['displays']['block']['create'] = [
        '#title' => $this
          ->t('Create a block'),
        '#type' => 'checkbox',
        '#attributes' => [
          'class' => [
            'strong',
          ],
        ],
        '#id' => 'edit-block-create',
      ];

      // All options for the block display are included in this container so
      // they can be hidden as a group when the "Create a block" checkbox is
      // unchecked.
      $form['displays']['block']['options'] = [
        '#type' => 'container',
        '#attributes' => [
          'class' => [
            'options-set',
          ],
        ],
        '#states' => [
          'visible' => [
            ':input[name="block[create]"]' => [
              'checked' => TRUE,
            ],
          ],
        ],
        '#prefix' => '<div id="edit-block-wrapper">',
        '#suffix' => '</div>',
        '#parents' => [
          'block',
        ],
      ];
      $form['displays']['block']['options']['title'] = [
        '#title' => $this
          ->t('Block title'),
        '#type' => 'textfield',
        '#maxlength' => 255,
      ];
      $form['displays']['block']['options']['style'] = [
        '#type' => 'fieldset',
        '#title' => $this
          ->t('Block display settings'),
        '#attributes' => [
          'class' => [
            'container-inline',
            'fieldset-no-legend',
          ],
        ],
      ];

      // Create the dropdown for choosing the display format.
      $form['displays']['block']['options']['style']['style_plugin'] = [
        '#title' => $this
          ->t('Display format'),
        '#type' => 'select',
        '#options' => $style_options,
      ];
      $style_form =& $form['displays']['block']['options']['style'];
      $style_form['style_plugin']['#default_value'] = static::getSelected($form_state, [
        'block',
        'style',
        'style_plugin',
      ], 'default', $style_form['style_plugin']);

      // Changing this dropdown updates $form['displays']['block']['options']
      // via AJAX.
      views_ui_add_ajax_trigger($style_form, 'style_plugin', [
        'displays',
        'block',
        'options',
      ]);
      $this
        ->buildFormStyle($form, $form_state, 'block');
      $form['displays']['block']['options']['items_per_page'] = [
        '#title' => $this
          ->t('Items per block'),
        '#type' => 'number',
        '#default_value' => 5,
        '#min' => 0,
      ];
      $form['displays']['block']['options']['pager'] = [
        '#title' => $this
          ->t('Use a pager'),
        '#type' => 'checkbox',
        '#default_value' => FALSE,
      ];
    }

    // Only offer the REST export settings if the module is enabled.
    if (\Drupal::moduleHandler()
      ->moduleExists('rest')) {
      $form['displays']['rest_export'] = [
        '#type' => 'fieldset',
        '#title' => $this
          ->t('REST export settings'),
        '#attributes' => [
          'class' => [
            'views-attachment',
            'fieldset-no-legend',
          ],
        ],
        '#tree' => TRUE,
      ];
      $form['displays']['rest_export']['create'] = [
        '#title' => $this
          ->t('Provide a REST export'),
        '#type' => 'checkbox',
        '#attributes' => [
          'class' => [
            'strong',
          ],
        ],
        '#id' => 'edit-rest-export-create',
      ];

      // All options for the REST export display are included in this container
      // so they can be hidden as a group when the "Provide a REST export"
      // checkbox is unchecked.
      $form['displays']['rest_export']['options'] = [
        '#type' => 'container',
        '#attributes' => [
          'class' => [
            'options-set',
          ],
        ],
        '#states' => [
          'visible' => [
            ':input[name="rest_export[create]"]' => [
              'checked' => TRUE,
            ],
          ],
        ],
        '#prefix' => '<div id="edit-rest-export-wrapper">',
        '#suffix' => '</div>',
        '#parents' => [
          'rest_export',
        ],
      ];
      $form['displays']['rest_export']['options']['path'] = [
        '#title' => $this
          ->t('REST export path'),
        '#type' => 'textfield',
        '#field_prefix' => $path_prefix,
        // Account for the leading backslash.
        '#maxlength' => 254,
      ];
    }
    return $form;
  }

  /**
   * Gets the current value of a #select element, from within a form constructor function.
   *
   * This function is intended for use in highly dynamic forms (in particular the
   * add view wizard) which are rebuilt in different ways depending on which
   * triggering element (AJAX or otherwise) was most recently fired. For example,
   * sometimes it is necessary to decide how to build one dynamic form element
   * based on the value of a different dynamic form element that may not have
   * even been present on the form the last time it was submitted. This function
   * takes care of resolving those conflicts and gives you the proper current
   * value of the requested #select element.
   *
   * By necessity, this function sometimes uses non-validated user input from
   * FormState::$input in making its determination. Although it performs some
   * minor validation of its own, it is not complete. The intention is that the
   * return value of this function should only be used to help decide how to
   * build the current form the next time it is reloaded, not to be saved as if
   * it had gone through the normal, final form validation process. Do NOT use
   * the results of this function for any other purpose besides deciding how to
   * build the next version of the form.
   *
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the form.
   * @param $parents
   *   An array of parent keys that point to the part of the submitted form
   *   values that are expected to contain the element's value (in the case where
   *   this form element was actually submitted). In a simple case (assuming
   *   #tree is TRUE throughout the form), if the select element is located in
   *   $form['wrapper']['select'], so that the submitted form values would
   *   normally be found in $form_state->getValue(array('wrapper', 'select')),
   *   you would pass array('wrapper', 'select') for this parameter.
   * @param $default_value
   *   The default value to return if the #select element does not currently have
   *   a proper value set based on the submitted input.
   * @param $element
   *   An array representing the current version of the #select element within
   *   the form.
   *
   * @return
   *   The current value of the #select element. A common use for this is to feed
   *   it back into $element['#default_value'] so that the form will be rendered
   *   with the correct value selected.
   */
  public static function getSelected(FormStateInterface $form_state, $parents, $default_value, $element) {

    // For now, don't trust this to work on anything but a #select element.
    if (!isset($element['#type']) || $element['#type'] != 'select' || !isset($element['#options'])) {
      return $default_value;
    }

    // If there is a user-submitted value for this element that matches one of
    // the currently available options attached to it, use that. However, only
    // perform this check during the form rebuild. During the initial build
    // after #ajax is triggered, we need to rebuild the form as it was
    // initially. We need to check FormState::getUserInput() rather than
    // $form_state->getValues() here because the triggering element often has
    // the #limit_validation_errors property set to prevent unwanted errors
    // elsewhere on the form. This means that the $form_state->getValues() array
    // won't be complete. We could make it complete by adding each required part
    // of the form to the #limit_validation_errors property individually as the
    // form is being built, but this is difficult to do for a highly dynamic and
    // extensible form. This method is much simpler.
    $user_input = $form_state
      ->isRebuilding() ? $form_state
      ->getUserInput() : [];
    if (!empty($user_input)) {
      $key_exists = NULL;
      $submitted = NestedArray::getValue($user_input, $parents, $key_exists);

      // Check that the user-submitted value is one of the allowed options before
      // returning it. This is not a substitute for actual form validation;
      // rather it is necessary because, for example, the same select element
      // might have #options A, B, and C under one set of conditions but #options
      // D, E, F under a different set of conditions. So the form submission
      // might have occurred with option A selected, but when the form is rebuilt
      // option A is no longer one of the choices. In that case, we don't want to
      // use the value that was submitted anymore but rather fall back to the
      // default value.
      if ($key_exists && in_array($submitted, array_keys($element['#options']))) {
        return $submitted;
      }
    }

    // Fall back on returning the default value if nothing was returned above.
    return $default_value;
  }

  /**
   * Adds the style options to the wizard form.
   *
   * @param array $form
   *   The full wizard form array.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the wizard form.
   * @param string $type
   *   The display ID (e.g. 'page' or 'block').
   */
  protected function buildFormStyle(array &$form, FormStateInterface $form_state, $type) {
    $style_form =& $form['displays'][$type]['options']['style'];
    $style = $style_form['style_plugin']['#default_value'];
    $style_plugin = Views::pluginManager('style')
      ->createInstance($style);
    if (isset($style_plugin) && $style_plugin
      ->usesRowPlugin()) {
      $options = $this
        ->rowStyleOptions();
      $style_form['row_plugin'] = [
        '#type' => 'select',
        '#title' => $this
          ->t('of'),
        '#options' => $options,
        '#access' => count($options) > 1,
      ];

      // For the block display, the default value should be "titles (linked)",
      // if it's available (since that's the most common use case).
      $block_with_linked_titles_available = $type == 'block' && isset($options['titles_linked']);
      $default_value = $block_with_linked_titles_available ? 'titles_linked' : key($options);
      $style_form['row_plugin']['#default_value'] = static::getSelected($form_state, [
        $type,
        'style',
        'row_plugin',
      ], $default_value, $style_form['row_plugin']);

      // Changing this dropdown updates the individual row options via AJAX.
      views_ui_add_ajax_trigger($style_form, 'row_plugin', [
        'displays',
        $type,
        'options',
        'style',
        'row_options',
      ]);

      // This is the region that can be updated by AJAX. The base class doesn't
      // add anything here, but child classes can.
      $style_form['row_options'] = [
        '#theme_wrappers' => [
          'container',
        ],
      ];
    }
    elseif ($style_plugin
      ->usesFields()) {
      $style_form['row_plugin'] = [
        '#markup' => '<span>' . $this
          ->t('of fields') . '</span>',
      ];
    }
  }

  /**
   * Retrieves row style plugin names.
   *
   * @return array
   *   Returns the plugin names available for the base table of the wizard.
   */
  protected function rowStyleOptions() {

    // Get all available row plugins by default.
    $options = Views::fetchPluginNames('row', 'normal', [
      $this->base_table,
    ]);
    return $options;
  }

  /**
   * Builds the form structure for selecting the view's filters.
   *
   * By default, this adds "of type" and "tagged with" filters (when they are
   * available).
   */
  protected function buildFilters(&$form, FormStateInterface $form_state) {
    module_load_include('inc', 'views_ui', 'admin');
    $bundles = $this->bundleInfoService
      ->getBundleInfo($this->entityTypeId);

    // If the current base table support bundles and has more than one (like user).
    if (!empty($bundles) && $this->entityType && $this->entityType
      ->hasKey('bundle')) {

      // Get all bundles and their human readable names.
      $options = [
        'all' => $this
          ->t('All'),
      ];
      foreach ($bundles as $type => $bundle) {
        $options[$type] = $bundle['label'];
      }
      $form['displays']['show']['type'] = [
        '#type' => 'select',
        '#title' => $this
          ->t('of type'),
        '#options' => $options,
      ];
      $selected_bundle = static::getSelected($form_state, [
        'show',
        'type',
      ], 'all', $form['displays']['show']['type']);
      $form['displays']['show']['type']['#default_value'] = $selected_bundle;

      // Changing this dropdown updates the entire content of $form['displays']
      // via AJAX, since each bundle might have entirely different fields
      // attached to it, etc.
      views_ui_add_ajax_trigger($form['displays']['show'], 'type', [
        'displays',
      ]);
    }
  }

  /**
   * Builds the form structure for selecting the view's sort order.
   *
   * By default, this adds a "sorted by [date]" filter (when it is available).
   */
  protected function buildSorts(&$form, FormStateInterface $form_state) {
    $sorts = [
      'none' => $this
        ->t('Unsorted'),
    ];

    // Check if we are allowed to sort by creation date.
    $created_column = $this
      ->getCreatedColumn();
    if ($created_column) {
      $sorts += [
        $created_column . ':DESC' => $this
          ->t('Newest first'),
        $created_column . ':ASC' => $this
          ->t('Oldest first'),
      ];
    }
    if ($available_sorts = $this
      ->getAvailableSorts()) {
      $sorts += $available_sorts;
    }

    // If there is no sorts option available continue.
    if (!empty($sorts)) {
      $form['displays']['show']['sort'] = [
        '#type' => 'select',
        '#title' => $this
          ->t('sorted by'),
        '#options' => $sorts,
        '#default_value' => isset($created_column) ? $created_column . ':DESC' : 'none',
      ];
    }
  }

  /**
   * Instantiates a view object from form values.
   *
   * @return \Drupal\views_ui\ViewUI
   *   The instantiated view UI object.
   */
  protected function instantiateView($form, FormStateInterface $form_state) {

    // Build the basic view properties and create the view.
    $values = [
      'id' => $form_state
        ->getValue('id'),
      'label' => $form_state
        ->getValue('label'),
      'description' => $form_state
        ->getValue('description'),
      'base_table' => $this->base_table,
      'langcode' => \Drupal::languageManager()
        ->getDefaultLanguage()
        ->getId(),
    ];
    $view = View::create($values);

    // Build all display options for this view.
    $display_options = $this
      ->buildDisplayOptions($form, $form_state);

    // Allow the fully built options to be altered. This happens before adding
    // the options to the view, so that once they are eventually added we will
    // be able to get all the overrides correct.
    $this
      ->alterDisplayOptions($display_options, $form, $form_state);
    $this
      ->addDisplays($view, $display_options, $form, $form_state);
    return new ViewUI($view);
  }

  /**
   * Builds an array of display options for the view.
   *
   * @return array
   *   An array whose keys are the names of each display and whose values are
   *   arrays of options for that display.
   */
  protected function buildDisplayOptions($form, FormStateInterface $form_state) {

    // Display: Default
    $display_options['default'] = $this
      ->defaultDisplayOptions();
    $display_options['default'] += [
      'filters' => [],
      'sorts' => [],
    ];
    $display_options['default']['filters'] += $this
      ->defaultDisplayFilters($form, $form_state);
    $display_options['default']['sorts'] += $this
      ->defaultDisplaySorts($form, $form_state);

    // Display: Page
    if (!$form_state
      ->isValueEmpty([
      'page',
      'create',
    ])) {
      $display_options['page'] = $this
        ->pageDisplayOptions($form, $form_state);

      // Display: Feed (attached to the page)
      if (!$form_state
        ->isValueEmpty([
        'page',
        'feed',
      ])) {
        $display_options['feed'] = $this
          ->pageFeedDisplayOptions($form, $form_state);
      }
    }

    // Display: Block
    if (!$form_state
      ->isValueEmpty([
      'block',
      'create',
    ])) {
      $display_options['block'] = $this
        ->blockDisplayOptions($form, $form_state);
    }

    // Display: REST export.
    if (!$form_state
      ->isValueEmpty([
      'rest_export',
      'create',
    ])) {
      $display_options['rest_export'] = $this
        ->restExportDisplayOptions($form, $form_state);
    }
    return $display_options;
  }

  /**
   * Alters the full array of display options before they are added to the view.
   */
  protected function alterDisplayOptions(&$display_options, $form, FormStateInterface $form_state) {
    foreach ($display_options as $display_type => $options) {

      // Allow style plugins to hook in and provide some settings.
      $style_plugin = Views::pluginManager('style')
        ->createInstance($options['style']['type']);
      $style_plugin
        ->wizardSubmit($form, $form_state, $this, $display_options, $display_type);
    }
  }

  /**
   * Adds the array of display options to the view, with appropriate overrides.
   */
  protected function addDisplays(View $view, $display_options, $form, FormStateInterface $form_state) {

    // Initialize and store the view executable to get the display plugin
    // instances.
    $executable = $view
      ->getExecutable();

    // Display: Default
    $default_display = $executable
      ->newDisplay('default', 'Default', 'default');
    foreach ($display_options['default'] as $option => $value) {
      $default_display
        ->setOption($option, $value);
    }

    // Display: Page
    if (isset($display_options['page'])) {
      $display = $executable
        ->newDisplay('page', 'Page', 'page_1');

      // The page display is usually the main one (from the user's point of
      // view). Its options should therefore become the overall view defaults,
      // so that new displays which are added later automatically inherit them.
      $this
        ->setDefaultOptions($display_options['page'], $display, $default_display);

      // Display: Feed (attached to the page).
      if (isset($display_options['feed'])) {
        $display = $executable
          ->newDisplay('feed', 'Feed', 'feed_1');
        $this
          ->setOverrideOptions($display_options['feed'], $display, $default_display);
      }
    }

    // Display: Block.
    if (isset($display_options['block'])) {
      $display = $executable
        ->newDisplay('block', 'Block', 'block_1');

      // When there is no page, the block display options should become the
      // overall view defaults.
      if (!isset($display_options['page'])) {
        $this
          ->setDefaultOptions($display_options['block'], $display, $default_display);
      }
      else {
        $this
          ->setOverrideOptions($display_options['block'], $display, $default_display);
      }
    }

    // Display: REST export.
    if (isset($display_options['rest_export'])) {
      $display = $executable
        ->newDisplay('rest_export', 'REST export', 'rest_export_1');

      // If there is no page or block, the REST export display options should
      // become the overall view defaults.
      if (!isset($display_options['page']) && !isset($display_options['block'])) {
        $this
          ->setDefaultOptions($display_options['rest_export'], $display, $default_display);
      }
      else {
        $this
          ->setOverrideOptions($display_options['rest_export'], $display, $default_display);
      }
    }

    // Initialize displays and merge all plugin default values.
    $executable
      ->mergeDefaults();
  }

  /**
   * Assembles the default display options for the view.
   *
   * Most wizards will need to override this method to provide some fields
   * or a different row plugin.
   *
   * @return array
   *   Returns an array of display options.
   */
  protected function defaultDisplayOptions() {
    $display_options = [];
    $display_options['access']['type'] = 'none';
    $display_options['cache']['type'] = 'tag';
    $display_options['query']['type'] = 'views_query';
    $display_options['exposed_form']['type'] = 'basic';
    $display_options['pager']['type'] = 'mini';
    $display_options['style']['type'] = 'default';
    $display_options['row']['type'] = 'fields';

    // Add default options array to each plugin type.
    foreach ($display_options as &$options) {
      $options['options'] = [];
    }

    // Add a least one field so the view validates and the user has a preview.
    // The base field can provide a default in its base settings; otherwise,
    // choose the first field with a field handler.
    $default_table = $this->base_table;
    $data = Views::viewsData()
      ->get($default_table);
    if (isset($data['table']['base']['defaults']['field'])) {
      $default_field = $data['table']['base']['defaults']['field'];

      // If the table for the default field is different to the base table,
      // load the view table data for this table.
      if (isset($data['table']['base']['defaults']['table']) && $data['table']['base']['defaults']['table'] != $default_table) {
        $default_table = $data['table']['base']['defaults']['table'];
        $data = Views::viewsData()
          ->get($default_table);
      }
    }
    else {
      foreach ($data as $default_field => $field_data) {
        if (isset($field_data['field']['id'])) {
          break;
        }
      }
    }

    // @todo Refactor the code to use ViewExecutable::addHandler. See
    //   https://www.drupal.org/node/2383157.
    $display_options['fields'][$default_field] = [
      'table' => $default_table,
      'field' => $default_field,
      'id' => $default_field,
      'entity_type' => isset($data[$default_field]['entity type']) ? $data[$default_field]['entity type'] : NULL,
      'entity_field' => isset($data[$default_field]['entity field']) ? $data[$default_field]['entity field'] : NULL,
      'plugin_id' => $data[$default_field]['field']['id'],
    ];
    return $display_options;
  }

  /**
   * Retrieves all filter information used by the default display.
   *
   * Additional to the one provided by the plugin this method takes care about
   * adding additional filters based on user input.
   *
   * @param array $form
   *   The full wizard form array.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the wizard form.
   *
   * @return array
   *   An array of filter arrays keyed by ID. A sort array contains the options
   *   accepted by a filter handler.
   */
  protected function defaultDisplayFilters($form, FormStateInterface $form_state) {
    $filters = [];

    // Add any filters provided by the plugin.
    foreach ($this
      ->getFilters() as $name => $info) {
      $filters[$name] = $info;
    }

    // Add any filters specified by the user when filling out the wizard.
    $filters = array_merge($filters, $this
      ->defaultDisplayFiltersUser($form, $form_state));
    return $filters;
  }

  /**
   * Retrieves filter information based on user input for the default display.
   *
   * @param array $form
   *   The full wizard form array.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the wizard form.
   *
   * @return array
   *   An array of filter arrays keyed by ID. A sort array contains the options
   *   accepted by a filter handler.
   */
  protected function defaultDisplayFiltersUser(array $form, FormStateInterface $form_state) {
    $filters = [];
    if (($type = $form_state
      ->getValue([
      'show',
      'type',
    ])) && $type != 'all') {
      $bundle_key = $this->entityType
        ->getKey('bundle');

      // Figure out the table where $bundle_key lives. It may not be the same as
      // the base table for the view; the taxonomy vocabulary machine_name, for
      // example, is stored in taxonomy_vocabulary, not taxonomy_term_data.
      module_load_include('inc', 'views_ui', 'admin');
      $fields = Views::viewsDataHelper()
        ->fetchFields($this->base_table, 'filter');
      $table = FALSE;
      if (isset($fields[$this->base_table . '.' . $bundle_key])) {
        $table = $this->base_table;
      }
      else {
        foreach ($fields as $field_name => $value) {
          if ($pos = strpos($field_name, '.' . $bundle_key)) {
            $table = substr($field_name, 0, $pos);
            break;
          }
        }
      }

      // Some entities have bundles but don't provide their bundle data on the
      // base table. In this case the entities wizard should provide a
      // relationship to the relevant data.
      // @see \Drupal\node\Plugin\views\wizard\NodeRevision
      if (!empty($table)) {
        $table_data = Views::viewsData()
          ->get($table);

        // If the 'in' operator is being used, map the values to an array.
        $handler = $table_data[$bundle_key]['filter']['id'];
        $handler_definition = Views::pluginManager('filter')
          ->getDefinition($handler);
        if ($handler == 'in_operator' || is_subclass_of($handler_definition['class'], 'Drupal\\views\\Plugin\\views\\filter\\InOperator')) {
          $value = [
            $type => $type,
          ];
        }
        else {
          $value = $type;
        }
        $filters[$bundle_key] = [
          'id' => $bundle_key,
          'table' => $table,
          'field' => $bundle_key,
          'value' => $value,
          'entity_type' => isset($table_data['table']['entity type']) ? $table_data['table']['entity type'] : NULL,
          'entity_field' => isset($table_data[$bundle_key]['entity field']) ? $table_data[$bundle_key]['entity field'] : NULL,
          'plugin_id' => $handler,
        ];
      }
    }
    return $filters;
  }

  /**
   * Retrieves all sort information used by the default display.
   *
   * Additional to the one provided by the plugin this method takes care about
   * adding additional sorts based on user input.
   *
   * @param array $form
   *   The full wizard form array.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the wizard form.
   *
   * @return array
   *   An array of sort arrays keyed by ID. A sort array contains the options
   *   accepted by a sort handler.
   */
  protected function defaultDisplaySorts($form, FormStateInterface $form_state) {
    $sorts = [];

    // Add any sorts provided by the plugin.
    foreach ($this
      ->getSorts() as $name => $info) {
      $sorts[$name] = $info;
    }

    // Add any sorts specified by the user when filling out the wizard.
    $sorts = array_merge($sorts, $this
      ->defaultDisplaySortsUser($form, $form_state));
    return $sorts;
  }

  /**
   * Retrieves sort information based on user input for the default display.
   *
   * @param array $form
   *   The full wizard form array.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the wizard form.
   *
   * @return array
   *   An array of sort arrays keyed by ID. A sort array contains the options
   *   accepted by a sort handler.
   */
  protected function defaultDisplaySortsUser($form, FormStateInterface $form_state) {
    $sorts = [];

    // Don't add a sort if there is no form value or the user set the sort to
    // 'none'.
    if (($sort_type = $form_state
      ->getValue([
      'show',
      'sort',
    ])) && $sort_type != 'none') {
      list($column, $sort) = explode(':', $sort_type);

      // Column either be a column-name or the table-column-name.
      $column = explode('-', $column);
      if (count($column) > 1) {
        $table = $column[0];
        $column = $column[1];
      }
      else {
        $table = $this->base_table;
        $column = $column[0];
      }

      // If the input is invalid, for example when the #default_value contains
      // created from node, but the wizard type is another base table, make
      // sure it is not added. This usually don't happen if you have js
      // enabled.
      $data = Views::viewsData()
        ->get($table);
      if (isset($data[$column]['sort'])) {
        $sorts[$column] = [
          'id' => $column,
          'table' => $table,
          'field' => $column,
          'order' => $sort,
          'entity_type' => isset($data['table']['entity type']) ? $data['table']['entity type'] : NULL,
          'entity_field' => isset($data[$column]['entity field']) ? $data[$column]['entity field'] : NULL,
          'plugin_id' => $data[$column]['sort']['id'],
        ];
      }
    }
    return $sorts;
  }

  /**
   * Retrieves the page display options.
   *
   * @param array $form
   *   The full wizard form array.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the wizard form.
   *
   * @return array
   *   Returns an array of display options.
   */
  protected function pageDisplayOptions(array $form, FormStateInterface $form_state) {
    $display_options = [];
    $page = $form_state
      ->getValue('page');
    $display_options['title'] = $page['title'];
    $display_options['path'] = $page['path'];
    $display_options['style'] = [
      'type' => $page['style']['style_plugin'],
    ];

    // Not every style plugin supports row style plugins.
    // Make sure that the selected row plugin is a valid one.
    $options = $this
      ->rowStyleOptions();
    $display_options['row'] = [
      'type' => isset($page['style']['row_plugin']) && isset($options[$page['style']['row_plugin']]) ? $page['style']['row_plugin'] : 'fields',
    ];

    // If the specific 0 items per page, use no pager.
    if (empty($page['items_per_page'])) {
      $display_options['pager']['type'] = 'none';
    }
    elseif (!empty($page['pager'])) {
      $display_options['pager']['type'] = 'mini';
    }
    else {
      $display_options['pager']['type'] = 'some';
    }
    $display_options['pager']['options']['items_per_page'] = $page['items_per_page'];

    // Generate the menu links settings if the user checked the link checkbox.
    if (!empty($page['link'])) {
      $display_options['menu']['type'] = 'normal';
      $display_options['menu']['title'] = $page['link_properties']['title'];
      list($display_options['menu']['menu_name'], $display_options['menu']['parent']) = explode(':', $page['link_properties']['parent'], 2);
    }
    return $display_options;
  }

  /**
   * Retrieves the block display options.
   *
   * @param array $form
   *   The full wizard form array.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the wizard form.
   *
   * @return array
   *   Returns an array of display options.
   */
  protected function blockDisplayOptions(array $form, FormStateInterface $form_state) {
    $display_options = [];
    $block = $form_state
      ->getValue('block');
    $display_options['title'] = $block['title'];
    $display_options['style'] = [
      'type' => $block['style']['style_plugin'],
    ];
    $options = $this
      ->rowStyleOptions();
    $display_options['row'] = [
      'type' => isset($block['style']['row_plugin']) && isset($options[$block['style']['row_plugin']]) ? $block['style']['row_plugin'] : 'fields',
    ];
    $display_options['pager']['type'] = $block['pager'] ? 'full' : (empty($block['items_per_page']) ? 'none' : 'some');
    $display_options['pager']['options']['items_per_page'] = $block['items_per_page'];
    return $display_options;
  }

  /**
   * Retrieves the REST export display options from the submitted form values.
   *
   * @param array $form
   *   The full wizard form array.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the wizard form.
   *
   * @return array
   *   Returns an array of display options.
   */
  protected function restExportDisplayOptions(array $form, FormStateInterface $form_state) {
    $display_options = [];
    $display_options['path'] = $form_state
      ->getValue([
      'rest_export',
      'path',
    ]);
    $display_options['style'] = [
      'type' => 'serializer',
    ];
    return $display_options;
  }

  /**
   * Retrieves the feed display options.
   *
   * @param array $form
   *   The full wizard form array.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the wizard form.
   *
   * @return array
   *   Returns an array of display options.
   */
  protected function pageFeedDisplayOptions($form, FormStateInterface $form_state) {
    $display_options = [];
    $display_options['pager']['type'] = 'some';
    $display_options['style'] = [
      'type' => 'rss',
    ];
    $display_options['row'] = [
      'type' => $form_state
        ->getValue([
        'page',
        'feed_properties',
        'row_plugin',
      ]),
    ];
    $display_options['path'] = $form_state
      ->getValue([
      'page',
      'feed_properties',
      'path',
    ]);
    $display_options['title'] = $form_state
      ->getValue([
      'page',
      'title',
    ]);
    $display_options['displays'] = [
      'default' => 'default',
      'page_1' => 'page_1',
    ];
    return $display_options;
  }

  /**
   * Sets options for a display and makes them the default options if possible.
   *
   * This function can be used to set options for a display when it is desired
   * that the options also become the defaults for the view whenever possible.
   * This should be done for the "primary" display created in the view wizard,
   * so that new displays which the user adds later will be similar to this
   * one.
   *
   * @param array $options
   *   An array whose keys are the name of each option and whose values are the
   *   desired values to set.
   * @param \Drupal\views\Plugin\views\display\DisplayPluginBase $display
   *   The display handler which the options will be applied to. The default
   *   display will actually be assigned the options (and this display will
   *   inherit them) when possible.
   * @param \Drupal\views\Plugin\views\display\DisplayPluginBase $default_display
   *   The default display handler, which will store the options when possible.
   */
  protected function setDefaultOptions($options, DisplayPluginBase $display, DisplayPluginBase $default_display) {
    foreach ($options as $option => $value) {

      // If the default display supports this option, set the value there.
      // Otherwise, set it on the provided display.
      $default_value = $default_display
        ->getOption($option);
      if (isset($default_value)) {
        $default_display
          ->setOption($option, $value);
      }
      else {
        $display
          ->setOption($option, $value);
      }
    }
  }

  /**
   * Sets options for a display, inheriting from the defaults when possible.
   *
   * This function can be used to set options for a display when it is desired
   * that the options inherit from the default display whenever possible. This
   * avoids setting too many options as overrides, which will be harder for the
   * user to modify later. For example, if $this->setDefaultOptions() was
   * previously called on a page display and then this function is called on a
   * block display, and if the user entered the same title for both displays in
   * the views wizard, then the view will wind up with the title stored as the
   * default (with the page and block both inheriting from it).
   *
   * @param array $options
   *   An array whose keys are the name of each option and whose values are the
   *   desired values to set.
   * @param \Drupal\views\Plugin\views\display\DisplayPluginBase $display
   *   The display handler which the options will be applied to. The default
   *   display will actually be assigned the options (and this display will
   *   inherit them) when possible.
   * @param \Drupal\views\Plugin\views\display\DisplayPluginBase $default_display
   *   The default display handler, which will store the options when possible.
   */
  protected function setOverrideOptions(array $options, DisplayPluginBase $display, DisplayPluginBase $default_display) {
    foreach ($options as $option => $value) {

      // Only override the default value if it is different from the value that
      // was provided.
      $default_value = $default_display
        ->getOption($option);
      if (!isset($default_value)) {
        $display
          ->setOption($option, $value);
      }
      elseif ($default_value !== $value) {
        $display
          ->overrideOption($option, $value);
      }
    }
  }

  /**
   * Retrieves a validated view for a form submission.
   *
   * @param array $form
   *   The full wizard form array.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the wizard form.
   * @param bool $unset
   *   Should the view be removed from the list of validated views.
   *
   * @return \Drupal\views_ui\ViewUI
   *   The validated view object.
   */
  protected function retrieveValidatedView(array $form, FormStateInterface $form_state, $unset = TRUE) {

    // @todo Figure out why all this hashing is done. Wouldn't it be easier to
    //   store a single entry and that's it?
    $key = hash('sha256', serialize($form_state
      ->getValues()));
    $view = isset($this->validated_views[$key]) ? $this->validated_views[$key] : NULL;
    if ($unset) {
      unset($this->validated_views[$key]);
    }
    return $view;
  }

  /**
   * Stores a validated view from a form submission.
   *
   * @param array $form
   *   The full wizard form array.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the wizard form.
   * @param \Drupal\views_ui\ViewUI $view
   *   The validated view object.
   */
  protected function setValidatedView(array $form, FormStateInterface $form_state, ViewUI $view) {
    $key = hash('sha256', serialize($form_state
      ->getValues()));
    $this->validated_views[$key] = $view;
  }

  /**
   * Implements Drupal\views\Plugin\views\wizard\WizardInterface::validate().
   *
   * Instantiates the view from the form submission and validates its values.
   */
  public function validateView(array $form, FormStateInterface $form_state) {
    $view = $this
      ->instantiateView($form, $form_state);
    $errors = $view
      ->getExecutable()
      ->validate();
    if (empty($errors)) {
      $this
        ->setValidatedView($form, $form_state, $view);
    }
    return $errors;
  }

  /**
   * {@inheritdoc}
   */
  public function createView(array $form, FormStateInterface $form_state) {
    $view = $this
      ->retrieveValidatedView($form, $form_state);
    if (empty($view)) {
      throw new WizardException('Attempted to create a view with values that have not been validated.');
    }
    return $view;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
DependencySerializationTrait::$_entityStorages protected property
DependencySerializationTrait::$_serviceIds protected property
DependencySerializationTrait::__sleep public function 2
DependencySerializationTrait::__wakeup public function 2
MessengerTrait::$messenger protected property The messenger. 27
MessengerTrait::messenger public function Gets the messenger. 27
MessengerTrait::setMessenger public function Sets the messenger.
PluginBase::$configuration protected property Configuration information passed into the plugin. 1
PluginBase::$definition public property Plugins's definition.
PluginBase::$displayHandler public property The display object this plugin is for.
PluginBase::$options public property Options for this plugin will be held here.
PluginBase::$pluginDefinition protected property The plugin implementation definition. 1
PluginBase::$pluginId protected property The plugin_id.
PluginBase::$renderer protected property Stores the render API renderer. 3
PluginBase::$usesOptions protected property Denotes whether the plugin has an additional options form. 8
PluginBase::$view public property The top object of a view. 1
PluginBase::buildOptionsForm public function Provide a form to edit options for this plugin. Overrides ViewsPluginInterface::buildOptionsForm 16
PluginBase::calculateDependencies public function Calculates dependencies for the configured plugin. Overrides DependentPluginInterface::calculateDependencies 14
PluginBase::defineOptions protected function Information about options for all kinds of purposes will be held here. 18
PluginBase::DERIVATIVE_SEPARATOR constant A string which is used to separate base plugin IDs from the derivative ID.
PluginBase::destroy public function Clears a plugin. Overrides ViewsPluginInterface::destroy 2
PluginBase::doFilterByDefinedOptions protected function Do the work to filter out stored options depending on the defined options.
PluginBase::filterByDefinedOptions public function Filter out stored options depending on the defined options. Overrides ViewsPluginInterface::filterByDefinedOptions
PluginBase::getAvailableGlobalTokens public function Returns an array of available token replacements. Overrides ViewsPluginInterface::getAvailableGlobalTokens
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 2
PluginBase::getPluginId public function Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
PluginBase::getProvider public function Returns the plugin provider. Overrides ViewsPluginInterface::getProvider
PluginBase::getRenderer protected function Returns the render API renderer. 1
PluginBase::globalTokenForm public function Adds elements for available core tokens to a form. Overrides ViewsPluginInterface::globalTokenForm
PluginBase::globalTokenReplace public function Returns a string with any core tokens replaced. Overrides ViewsPluginInterface::globalTokenReplace
PluginBase::INCLUDE_ENTITY constant Include entity row languages when listing languages.
PluginBase::INCLUDE_NEGOTIATED constant Include negotiated languages when listing languages.
PluginBase::init public function Initialize the plugin. Overrides ViewsPluginInterface::init 6
PluginBase::isConfigurable public function Determines if the plugin is configurable.
PluginBase::listLanguages protected function Makes an array of languages, optionally including special languages.
PluginBase::pluginTitle public function Return the human readable name of the display. Overrides ViewsPluginInterface::pluginTitle
PluginBase::preRenderAddFieldsetMarkup public static function Moves form elements into fieldsets for presentation purposes. Overrides ViewsPluginInterface::preRenderAddFieldsetMarkup
PluginBase::preRenderFlattenData public static function Flattens the structure of form elements. Overrides ViewsPluginInterface::preRenderFlattenData
PluginBase::query public function Add anything to the query that we might need to. Overrides ViewsPluginInterface::query 8
PluginBase::queryLanguageSubstitutions public static function Returns substitutions for Views queries for languages.
PluginBase::setOptionDefaults protected function Fills up the options of the plugin with defaults.
PluginBase::submitOptionsForm public function Handle any special handling on the validate form. Overrides ViewsPluginInterface::submitOptionsForm 16
PluginBase::summaryTitle public function Returns the summary of the settings in the display. Overrides ViewsPluginInterface::summaryTitle 6
PluginBase::themeFunctions public function Provide a full list of possible theme templates used by this style. Overrides ViewsPluginInterface::themeFunctions 1
PluginBase::trustedCallbacks public static function Lists the trusted callbacks provided by the implementing class. Overrides TrustedCallbackInterface::trustedCallbacks 6
PluginBase::unpackOptions public function Unpack options over our existing defaults, drilling down into arrays so that defaults don't get totally blown away. Overrides ViewsPluginInterface::unpackOptions
PluginBase::usesOptions public function Returns the usesOptions property. Overrides ViewsPluginInterface::usesOptions 8
PluginBase::validate public function Validate that the plugin is correct and can be saved. Overrides ViewsPluginInterface::validate 6
PluginBase::validateOptionsForm public function Validate the options form. Overrides ViewsPluginInterface::validateOptionsForm 15
PluginBase::viewsTokenReplace protected function Replaces Views' tokens in a given string. The resulting string will be sanitized with Xss::filterAdmin. 1
PluginBase::VIEWS_QUERY_LANGUAGE_SITE_DEFAULT constant Query string to indicate the site default language.
StringTranslationTrait::$stringTranslation protected property The string translation service. 4
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.
TrustedCallbackInterface::THROW_EXCEPTION constant Untrusted callbacks throw exceptions.
TrustedCallbackInterface::TRIGGER_SILENCED_DEPRECATION constant Untrusted callbacks trigger silenced E_USER_DEPRECATION errors.
TrustedCallbackInterface::TRIGGER_WARNING constant Untrusted callbacks trigger E_USER_WARNING errors.
WizardPluginBase::$availableSorts protected property The available store criteria.
WizardPluginBase::$base_table protected property The base table connected with the wizard.
WizardPluginBase::$bundleInfoService protected property The bundle info service.
WizardPluginBase::$createdColumn protected property The table column used for sorting by create date of this wizard. 8
WizardPluginBase::$entityType protected property Contains the information from entity_get_info of the $entity_type.
WizardPluginBase::$entityTypeId protected property The entity type connected with the wizard.
WizardPluginBase::$filters protected property Views items configuration arrays for filters added by the wizard. 2
WizardPluginBase::$filter_defaults protected property Default values for filters.
WizardPluginBase::$parentFormSelector protected property The parent form selector service.
WizardPluginBase::$sorts protected property Views items configuration arrays for sorts added by the wizard.
WizardPluginBase::$validated_views protected property An array of validated view objects, keyed by a hash.
WizardPluginBase::addDisplays protected function Adds the array of display options to the view, with appropriate overrides.
WizardPluginBase::alterDisplayOptions protected function Alters the full array of display options before they are added to the view.
WizardPluginBase::blockDisplayOptions protected function Retrieves the block display options. 1
WizardPluginBase::buildDisplayOptions protected function Builds an array of display options for the view. 1
WizardPluginBase::buildFilters protected function Builds the form structure for selecting the view's filters. 1
WizardPluginBase::buildForm public function Form callback to build other elements in the "show" form. Overrides WizardInterface::buildForm
WizardPluginBase::buildFormStyle protected function Adds the style options to the wizard form.
WizardPluginBase::buildSorts protected function Builds the form structure for selecting the view's sort order.
WizardPluginBase::create public static function Creates an instance of the plugin. Overrides PluginBase::create 1
WizardPluginBase::createView public function Creates a view from values that have already been validated. Overrides WizardInterface::createView
WizardPluginBase::defaultDisplayFilters protected function Retrieves all filter information used by the default display.
WizardPluginBase::defaultDisplayFiltersUser protected function Retrieves filter information based on user input for the default display. 2
WizardPluginBase::defaultDisplayOptions protected function Assembles the default display options for the view. 9
WizardPluginBase::defaultDisplaySorts protected function Retrieves all sort information used by the default display.
WizardPluginBase::defaultDisplaySortsUser protected function Retrieves sort information based on user input for the default display.
WizardPluginBase::getAvailableSorts public function Gets the availableSorts property. 2
WizardPluginBase::getCreatedColumn public function Gets the createdColumn property.
WizardPluginBase::getFilters public function Gets the filters property. 1
WizardPluginBase::getSelected public static function Gets the current value of a #select element, from within a form constructor function.
WizardPluginBase::getSorts public function Gets the sorts property.
WizardPluginBase::instantiateView protected function Instantiates a view object from form values.
WizardPluginBase::pageDisplayOptions protected function Retrieves the page display options. 1
WizardPluginBase::pageFeedDisplayOptions protected function Retrieves the feed display options.
WizardPluginBase::restExportDisplayOptions protected function Retrieves the REST export display options from the submitted form values.
WizardPluginBase::retrieveValidatedView protected function Retrieves a validated view for a form submission.
WizardPluginBase::rowStyleOptions protected function Retrieves row style plugin names. 3
WizardPluginBase::setDefaultOptions protected function Sets options for a display and makes them the default options if possible.
WizardPluginBase::setOverrideOptions protected function Sets options for a display, inheriting from the defaults when possible.
WizardPluginBase::setValidatedView protected function Stores a validated view from a form submission.
WizardPluginBase::validateView public function Implements Drupal\views\Plugin\views\wizard\WizardInterface::validate(). Overrides WizardInterface::validateView
WizardPluginBase::__construct public function Constructs a WizardPluginBase object. Overrides PluginBase::__construct 1