ArgumentPluginBase.php

Same filename in other branches
  1. 9 core/modules/views/src/Plugin/views/argument/ArgumentPluginBase.php
  2. 8.9.x core/modules/views/src/Plugin/views/argument/ArgumentPluginBase.php
  3. 10 core/modules/views/src/Plugin/views/argument/ArgumentPluginBase.php

Namespace

Drupal\views\Plugin\views\argument

File

core/modules/views/src/Plugin/views/argument/ArgumentPluginBase.php

View source
<?php

namespace Drupal\views\Plugin\views\argument;

use Drupal\Component\Plugin\DependentPluginInterface;
use Drupal\Component\Utility\Html;
use Drupal\Component\Utility\NestedArray;
use Drupal\Core\Cache\Cache;
use Drupal\Core\Cache\CacheableDependencyInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Render\Element;
use Drupal\views\Plugin\views\display\DisplayPluginBase;
use Drupal\views\ViewExecutable;
use Drupal\views\Plugin\views\HandlerBase;
use Drupal\views\Views;

/**
 * @defgroup views_argument_handlers Views argument handlers
 * @{
 * Handler plugins for Views contextual filters.
 *
 * Handler plugins help build the view query object. Views argument handlers
 * are for contextual filtering.
 *
 * Views argument handlers extend
 * \Drupal\views\Plugin\views\argument\ArgumentPluginBase. They must be
 * annotated with \Drupal\views\Annotation\ViewsArgument annotation, and they
 * must be in namespace directory Plugin\views\argument.
 *
 * @ingroup views_plugins
 * @see plugin_api
 */

/**
 * Base class for argument (contextual filter) handler plugins.
 *
 * The basic argument works for very simple arguments such as nid and uid
 *
 * Definition terms for this handler:
 * - name field: The field to use for the name to use in the summary, which is
 *               the displayed output. For example, for the node: nid argument,
 *               the argument itself is the nid, but node.title is displayed.
 * - name table: The table to use for the name, should it not be in the same
 *               table as the argument.
 * - empty field name: For arguments that can have no value, such as taxonomy
 *                     which can have "no term", this is the string which
 *                     will be displayed for this lack of value. Be sure to use
 *                     $this->t().
 * - validate type: A little used string to allow an argument to restrict
 *                  which validator is available to just one. Use the
 *                  validator ID. This probably should not be used at all,
 *                  and may disappear or change.
 * - numeric: If set to TRUE this field is numeric and will use %d instead of
 *            %s in queries.
 */
abstract class ArgumentPluginBase extends HandlerBase implements CacheableDependencyInterface {
    public $validator = NULL;
    public $argument = NULL;
    public $value = NULL;
    
    /**
     * The table to use for the name, should it not be in the same table as the argument.
     * @var string
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName, Drupal.Commenting.VariableComment.Missing
    public $name_table;
    
    /**
     * The name table alias.
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName, Drupal.Commenting.VariableComment.Missing
    public string $name_table_alias;
    
    /**
     * The field to use for the name to display in the summary.
     *
     * For example, for the node: nid argument, the argument itself is the nid,
     * but node.title is displayed.
     *
     * @var string
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName, Drupal.Commenting.VariableComment.Missing
    public $name_field;
    
    /**
     * The alias for the field.
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName, Drupal.Commenting.VariableComment.Missing
    public string $name_alias;
    
    /**
     * The base table alias.
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName, Drupal.Commenting.VariableComment.Missing
    public string $base_alias;
    
    /**
     * The alias count.
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName, Drupal.Commenting.VariableComment.Missing
    public string $count_alias;
    
    /**
     * Is argument validated.
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName, Drupal.Commenting.VariableComment.Missing
    public ?bool $argument_validated;
    
    /**
     * Is argument a default.
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName, Drupal.Commenting.VariableComment.Missing
    public bool $is_default;
    
    /**
     * The operator used for the query: or|and.
     */
    public string $operator;
    
    /**
     * The title set by argument validation.
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName, Drupal.Commenting.VariableComment.Missing
    public ?string $validated_title;
    
    /**
     * Keyed array by alias of table relations.
     *
     * @var string[]
     */
    public ?array $tableAliases;
    
    /**
     * Overrides Drupal\views\Plugin\views\HandlerBase:init().
     */
    public function init(ViewExecutable $view, DisplayPluginBase $display, ?array &$options = NULL) {
        parent::init($view, $display, $options);
        if (!empty($this->definition['name field'])) {
            $this->name_field = $this->definition['name field'];
        }
        if (!empty($this->definition['name table'])) {
            $this->name_table = $this->definition['name table'];
        }
    }
    public function isException($arg = NULL) {
        if (!isset($arg)) {
            $arg = $this->argument ?? NULL;
        }
        return !empty($this->options['exception']['value']) && $this->options['exception']['value'] === $arg;
    }
    public function exceptionTitle() {
        // If title overriding is off for the exception, return the normal title.
        if (empty($this->options['exception']['title_enable'])) {
            return $this->getTitle();
        }
        return $this->options['exception']['title'];
    }
    
    /**
     * Determine if the argument needs a style plugin.
     *
     * @return bool
     */
    public function needsStylePlugin() {
        $info = $this->defaultActions($this->options['default_action']);
        $validate_info = $this->defaultActions($this->options['validate']['fail']);
        return !empty($info['style plugin']) || !empty($validate_info['style plugin']);
    }
    protected function defineOptions() {
        $options = parent::defineOptions();
        $options['default_action'] = [
            'default' => 'ignore',
        ];
        $options['exception'] = [
            'contains' => [
                'value' => [
                    'default' => 'all',
                ],
                'title_enable' => [
                    'default' => FALSE,
                ],
                'title' => [
                    'default' => 'All',
                ],
            ],
        ];
        $options['title_enable'] = [
            'default' => FALSE,
        ];
        $options['title'] = [
            'default' => '',
        ];
        $options['default_argument_type'] = [
            'default' => 'fixed',
        ];
        $options['default_argument_options'] = [
            'default' => [],
        ];
        $options['summary_options'] = [
            'default' => [],
        ];
        $options['summary'] = [
            'contains' => [
                'sort_order' => [
                    'default' => 'asc',
                ],
                'number_of_records' => [
                    'default' => 0,
                ],
                'format' => [
                    'default' => 'default_summary',
                ],
            ],
        ];
        $options['specify_validation'] = [
            'default' => FALSE,
        ];
        $options['validate'] = [
            'contains' => [
                'type' => [
                    'default' => 'none',
                ],
                'fail' => [
                    'default' => 'not found',
                ],
            ],
        ];
        $options['validate_options'] = [
            'default' => [],
        ];
        return $options;
    }
    
    /**
     * {@inheritdoc}
     */
    public static function trustedCallbacks() {
        $callbacks = parent::trustedCallbacks();
        $callbacks[] = 'preRenderMoveArgumentOptions';
        return $callbacks;
    }
    public function buildOptionsForm(&$form, FormStateInterface $form_state) {
        parent::buildOptionsForm($form, $form_state);
        $argument_text = $this->view->display_handler
            ->getArgumentText();
        $form['#pre_render'][] = [
            static::class,
            'preRenderMoveArgumentOptions',
        ];
        $form['description'] = [
            '#markup' => $argument_text['description'],
            '#theme_wrappers' => [
                'container',
            ],
            '#attributes' => [
                'class' => [
                    'description',
                ],
            ],
        ];
        $form['no_argument'] = [
            '#type' => 'details',
            '#title' => $argument_text['filter value not present'],
            '#open' => TRUE,
        ];
        // Everything in the details is floated, so the last element needs to
        // clear those floats.
        $form['no_argument']['clearfix'] = [
            '#weight' => 1000,
            '#markup' => '<div class="clearfix"></div>',
        ];
        $form['default_action'] = [
            '#title' => $this->t('Default actions'),
            '#title_display' => 'invisible',
            '#type' => 'radios',
            '#process' => [
                [
                    $this,
                    'processContainerRadios',
                ],
            ],
            '#default_value' => $this->options['default_action'],
            '#fieldset' => 'no_argument',
        ];
        $form['exception'] = [
            '#type' => 'details',
            '#title' => $this->t('Exceptions'),
            '#fieldset' => 'no_argument',
        ];
        $form['exception']['value'] = [
            '#type' => 'textfield',
            '#title' => $this->t('Exception value'),
            '#size' => 20,
            '#default_value' => $this->options['exception']['value'],
            '#description' => $this->t('If this value is received, the filter will be ignored; i.e, "all values"'),
        ];
        $form['exception']['title_enable'] = [
            '#type' => 'checkbox',
            '#title' => $this->t('Override title'),
            '#default_value' => $this->options['exception']['title_enable'],
        ];
        $form['exception']['title'] = [
            '#type' => 'textfield',
            '#title' => $this->t('Override title'),
            '#title_display' => 'invisible',
            '#size' => 20,
            '#default_value' => $this->options['exception']['title'],
            '#description' => $this->t('Override the view and other argument titles. You may use Twig syntax in this field as well as the "arguments" and "raw_arguments" arrays.'),
            '#states' => [
                'visible' => [
                    ':input[name="options[exception][title_enable]"]' => [
                        'checked' => TRUE,
                    ],
                ],
            ],
        ];
        $options = [];
        $defaults = $this->defaultActions();
        $validate_options = [];
        foreach ($defaults as $id => $info) {
            $options[$id] = $info['title'];
            if (empty($info['default only'])) {
                $validate_options[$id] = $info['title'];
            }
            if (!empty($info['form method'])) {
                $this->{$info['form method']}($form, $form_state);
            }
        }
        $form['default_action']['#options'] = $options;
        $form['argument_present'] = [
            '#type' => 'details',
            '#title' => $argument_text['filter value present'],
            '#open' => TRUE,
        ];
        $form['title_enable'] = [
            '#type' => 'checkbox',
            '#title' => $this->t('Override title'),
            '#default_value' => $this->options['title_enable'],
            '#fieldset' => 'argument_present',
        ];
        $form['title'] = [
            '#type' => 'textfield',
            '#title' => $this->t('Provide title'),
            '#title_display' => 'invisible',
            '#default_value' => $this->options['title'],
            '#description' => $this->t('Override the view and other argument titles. You may use Twig syntax in this field.'),
            '#states' => [
                'visible' => [
                    ':input[name="options[title_enable]"]' => [
                        'checked' => TRUE,
                    ],
                ],
            ],
            '#fieldset' => 'argument_present',
        ];
        $output = $this->getTokenHelp();
        $form['token_help'] = [
            '#type' => 'details',
            '#title' => $this->t('Replacement patterns'),
            '#value' => $output,
            '#states' => [
                'visible' => [
                    [
                        ':input[name="options[title_enable]"]' => [
                            'checked' => TRUE,
                        ],
                    ],
                    [
                        ':input[name="options[exception][title_enable]"]' => [
                            'checked' => TRUE,
                        ],
                    ],
                ],
            ],
        ];
        $form['specify_validation'] = [
            '#type' => 'checkbox',
            '#title' => $this->t('Specify validation criteria'),
            '#default_value' => $this->options['specify_validation'],
            '#fieldset' => 'argument_present',
        ];
        $form['validate'] = [
            '#type' => 'container',
            '#fieldset' => 'argument_present',
        ];
        // Validator options include derivatives with :. These are sanitized for js
        // and reverted on submission.
        $form['validate']['type'] = [
            '#type' => 'select',
            '#title' => $this->t('Validator'),
            '#default_value' => static::encodeValidatorId($this->options['validate']['type']),
            '#states' => [
                'visible' => [
                    ':input[name="options[specify_validation]"]' => [
                        'checked' => TRUE,
                    ],
                ],
            ],
        ];
        $plugins = Views::pluginManager('argument_validator')->getDefinitions();
        foreach ($plugins as $id => $info) {
            if (!empty($info['no_ui'])) {
                continue;
            }
            $valid = TRUE;
            if (!empty($info['type'])) {
                $valid = FALSE;
                if (empty($this->definition['validate type'])) {
                    continue;
                }
                foreach ((array) $info['type'] as $type) {
                    if ($type == $this->definition['validate type']) {
                        $valid = TRUE;
                        break;
                    }
                }
            }
            // If we decide this validator is ok, add it to the list.
            if ($valid) {
                $plugin = $this->getPlugin('argument_validator', $id);
                if ($plugin) {
                    if ($plugin->access() || $this->options['validate']['type'] == $id) {
                        // Sanitize ID for js.
                        $sanitized_id = static::encodeValidatorId($id);
                        $form['validate']['options'][$sanitized_id] = [
                            '#prefix' => '<div id="edit-options-validate-options-' . $sanitized_id . '-wrapper">',
                            '#suffix' => '</div>',
                            '#type' => 'item',
                            // Even if the plugin has no options add the key to the form_state.
                            // trick it into checking input to make #process run.
'#input' => TRUE,
                            '#states' => [
                                'visible' => [
                                    ':input[name="options[specify_validation]"]' => [
                                        'checked' => TRUE,
                                    ],
                                    ':input[name="options[validate][type]"]' => [
                                        'value' => $sanitized_id,
                                    ],
                                ],
                            ],
                            '#id' => 'edit-options-validate-options-' . $sanitized_id,
                            '#default_value' => [],
                        ];
                        $plugin->buildOptionsForm($form['validate']['options'][$sanitized_id], $form_state);
                        $validate_types[$sanitized_id] = $info['title'];
                    }
                }
            }
        }
        asort($validate_types);
        $form['validate']['type']['#options'] = $validate_types;
        $form['validate']['fail'] = [
            '#type' => 'select',
            '#title' => $this->t('Action to take if filter value does not validate'),
            '#default_value' => $this->options['validate']['fail'],
            '#options' => $validate_options,
            '#states' => [
                'visible' => [
                    ':input[name="options[specify_validation]"]' => [
                        'checked' => TRUE,
                    ],
                ],
            ],
            '#fieldset' => 'argument_present',
        ];
    }
    
    /**
     * Provide token help information for the argument.
     *
     * @return array
     *   A render array.
     */
    protected function getTokenHelp() {
        $output = [];
        foreach ($this->view->display_handler
            ->getHandlers('argument') as $arg => $handler) {
            
            /** @var \Drupal\views\Plugin\views\argument\ArgumentPluginBase $handler */
            $options[(string) $this->t('Arguments')]["{{ arguments.{$arg} }}"] = $this->t('@argument title', [
                '@argument' => $handler->adminLabel(),
            ]);
            $options[(string) $this->t('Arguments')]["{{ raw_arguments.{$arg} }}"] = $this->t('@argument input', [
                '@argument' => $handler->adminLabel(),
            ]);
        }
        // We have some options, so make a list.
        if (!empty($options)) {
            $output[] = [
                '#markup' => '<p>' . $this->t("The following replacement tokens are available for this argument.") . '</p>',
            ];
            foreach (array_keys($options) as $type) {
                if (!empty($options[$type])) {
                    $items = [];
                    foreach ($options[$type] as $key => $value) {
                        $items[] = $key . ' == ' . $value;
                    }
                    $item_list = [
                        '#theme' => 'item_list',
                        '#items' => $items,
                    ];
                    $output[] = $item_list;
                }
            }
        }
        return $output;
    }
    public function validateOptionsForm(&$form, FormStateInterface $form_state) {
        $option_values =& $form_state->getValue('options');
        if (empty($option_values)) {
            return;
        }
        // Let the plugins do validation.
        $default_id = $option_values['default_argument_type'];
        $plugin = $this->getPlugin('argument_default', $default_id);
        if ($plugin) {
            $plugin->validateOptionsForm($form['argument_default'][$default_id], $form_state, $option_values['argument_default'][$default_id]);
        }
        // Summary plugin
        $summary_id = $option_values['summary']['format'];
        $plugin = $this->getPlugin('style', $summary_id);
        if ($plugin) {
            $plugin->validateOptionsForm($form['summary']['options'][$summary_id], $form_state, $option_values['summary']['options'][$summary_id]);
        }
        $sanitized_id = $option_values['validate']['type'];
        // Correct ID for js sanitized version.
        $validate_id = static::decodeValidatorId($sanitized_id);
        $plugin = $this->getPlugin('argument_validator', $validate_id);
        if ($plugin) {
            $plugin->validateOptionsForm($form['validate']['options'][$default_id], $form_state, $option_values['validate']['options'][$sanitized_id]);
        }
    }
    public function submitOptionsForm(&$form, FormStateInterface $form_state) {
        $option_values =& $form_state->getValue('options');
        if (empty($option_values)) {
            return;
        }
        // Let the plugins make submit modifications if necessary.
        $default_id = $option_values['default_argument_type'];
        $plugin = $this->getPlugin('argument_default', $default_id);
        if ($plugin) {
            $options =& $option_values['argument_default'][$default_id];
            $plugin->submitOptionsForm($form['argument_default'][$default_id], $form_state, $options);
            // Copy the now submitted options to their final resting place so they get saved.
            $option_values['default_argument_options'] = $options;
        }
        // Summary plugin
        $summary_id = $option_values['summary']['format'];
        $plugin = $this->getPlugin('style', $summary_id);
        if ($plugin) {
            $options =& $option_values['summary']['options'][$summary_id];
            $plugin->submitOptionsForm($form['summary']['options'][$summary_id], $form_state, $options);
            // Copy the now submitted options to their final resting place so they get saved.
            $option_values['summary_options'] = $options;
        }
        // If the 'Specify validation criteria' checkbox is not checked, reset the
        // validation options.
        if (empty($option_values['specify_validation'])) {
            $option_values['validate']['type'] = 'none';
            // We need to keep the empty array of options for the 'None' plugin as
            // it will be needed later.
            $option_values['validate']['options'] = [
                'none' => [],
            ];
            $option_values['validate']['fail'] = 'not found';
        }
        $sanitized_id = $option_values['validate']['type'];
        // Correct ID for js sanitized version.
        $option_values['validate']['type'] = $validate_id = static::decodeValidatorId($sanitized_id);
        $plugin = $this->getPlugin('argument_validator', $validate_id);
        if ($plugin) {
            $options =& $option_values['validate']['options'][$sanitized_id];
            $plugin->submitOptionsForm($form['validate']['options'][$sanitized_id], $form_state, $options);
            // Copy the now submitted options to their final resting place so they get saved.
            $option_values['validate_options'] = $options;
        }
        // Clear out the content of title if it's not enabled.
        if (empty($option_values['title_enable'])) {
            $option_values['title'] = '';
        }
    }
    
    /**
     * Default actions.
     *
     * Provide a list of default behaviors for this argument if the argument
     * is not present.
     *
     * Override this method to provide additional (or fewer) default behaviors.
     */
    protected function defaultActions($which = NULL) {
        $defaults = [
            'ignore' => [
                'title' => $this->t('Display all results for the specified field'),
                'method' => 'defaultIgnore',
            ],
            'default' => [
                'title' => $this->t('Provide default value'),
                'method' => 'defaultDefault',
                'form method' => 'defaultArgumentForm',
                'has default argument' => TRUE,
                // This can only be used for missing argument, not validation failure.
'default only' => TRUE,
            ],
            'not found' => [
                'title' => $this->t('Hide view'),
                'method' => 'defaultNotFound',
                // This is a hard fail condition.
'hard fail' => TRUE,
            ],
            'summary' => [
                'title' => $this->t('Display a summary'),
                'method' => 'defaultSummary',
                'form method' => 'defaultSummaryForm',
                'style plugin' => TRUE,
            ],
            'empty' => [
                'title' => $this->t('Display contents of "No results found"'),
                'method' => 'defaultEmpty',
            ],
            'access denied' => [
                'title' => $this->t('Display "Access Denied"'),
                'method' => 'defaultAccessDenied',
            ],
        ];
        if ($this->view->display_handler
            ->hasPath()) {
            $defaults['not found']['title'] = $this->t('Show "Page not found"');
        }
        if ($which) {
            if (!empty($defaults[$which])) {
                return $defaults[$which];
            }
        }
        else {
            return $defaults;
        }
    }
    
    /**
     * Provides a form for selecting the default argument.
     *
     * This is used when the default action provides a default argument.
     */
    public function defaultArgumentForm(&$form, FormStateInterface $form_state) {
        $plugins = Views::pluginManager('argument_default')->getDefinitions();
        $options = [];
        $form['default_argument_type'] = [
            '#prefix' => '<div id="edit-options-default-argument-type-wrapper">',
            '#suffix' => '</div>',
            '#type' => 'select',
            '#id' => 'edit-options-default-argument-type',
            '#title' => $this->t('Type'),
            '#default_value' => $this->options['default_argument_type'],
            '#states' => [
                'visible' => [
                    ':input[name="options[default_action]"]' => [
                        'value' => 'default',
                    ],
                ],
            ],
            // Views custom key, moves this element to the appropriate container
            // under the radio button.
'#argument_option' => 'default',
        ];
        foreach ($plugins as $id => $info) {
            if (!empty($info['no_ui'])) {
                continue;
            }
            $plugin = $this->getPlugin('argument_default', $id);
            if ($plugin) {
                if ($plugin->access() || $this->options['default_argument_type'] == $id) {
                    $form['argument_default']['#argument_option'] = 'default';
                    $form['argument_default'][$id] = [
                        '#prefix' => '<div id="edit-options-argument-default-options-' . $id . '-wrapper">',
                        '#suffix' => '</div>',
                        '#id' => 'edit-options-argument-default-options-' . $id,
                        '#type' => 'item',
                        // Even if the plugin has no options add the key to the form_state.
'#input' => TRUE,
                        '#states' => [
                            'visible' => [
                                ':input[name="options[default_action]"]' => [
                                    'value' => 'default',
                                ],
                                ':input[name="options[default_argument_type]"]' => [
                                    'value' => $id,
                                ],
                            ],
                        ],
                        '#default_value' => [],
                    ];
                    $options[$id] = $info['title'];
                    $plugin->buildOptionsForm($form['argument_default'][$id], $form_state);
                }
            }
        }
        asort($options);
        $form['default_argument_type']['#options'] = $options;
    }
    
    /**
     * Provides a form for selecting summary options.
     *
     * This is used when the default action displays a summary.
     */
    public function defaultSummaryForm(&$form, FormStateInterface $form_state) {
        $style_plugins = Views::pluginManager('style')->getDefinitions();
        $summary_plugins = [];
        $format_options = [];
        foreach ($style_plugins as $key => $plugin) {
            if (isset($plugin['display_types']) && in_array('summary', $plugin['display_types'])) {
                $summary_plugins[$key] = $plugin;
                $format_options[$key] = $plugin['title'];
            }
        }
        $form['summary'] = [
            // Views custom key, moves this element to the appropriate container
            // under the radio button.
'#argument_option' => 'summary',
        ];
        $form['summary']['sort_order'] = [
            '#type' => 'radios',
            '#title' => $this->t('Sort order'),
            '#options' => [
                'asc' => $this->t('Ascending'),
                'desc' => $this->t('Descending'),
            ],
            '#default_value' => $this->options['summary']['sort_order'],
            '#states' => [
                'visible' => [
                    ':input[name="options[default_action]"]' => [
                        'value' => 'summary',
                    ],
                ],
            ],
        ];
        $form['summary']['number_of_records'] = [
            '#type' => 'radios',
            '#title' => $this->t('Sort by'),
            '#default_value' => $this->options['summary']['number_of_records'],
            '#options' => [
                0 => $this->getSortName(),
                1 => $this->t('Number of records'),
            ],
            '#states' => [
                'visible' => [
                    ':input[name="options[default_action]"]' => [
                        'value' => 'summary',
                    ],
                ],
            ],
        ];
        $form['summary']['format'] = [
            '#type' => 'radios',
            '#title' => $this->t('Format'),
            '#options' => $format_options,
            '#default_value' => $this->options['summary']['format'],
            '#states' => [
                'visible' => [
                    ':input[name="options[default_action]"]' => [
                        'value' => 'summary',
                    ],
                ],
            ],
        ];
        foreach ($summary_plugins as $id => $info) {
            $plugin = $this->getPlugin('style', $id);
            if (!$plugin->usesOptions()) {
                continue;
            }
            if ($plugin) {
                $form['summary']['options'][$id] = [
                    '#prefix' => '<div id="edit-options-summary-options-' . $id . '-wrapper">',
                    '#suffix' => '</div>',
                    '#id' => 'edit-options-summary-options-' . $id,
                    '#type' => 'item',
                    // Trick it into checking input to make #process run.
'#input' => TRUE,
                    '#states' => [
                        'visible' => [
                            ':input[name="options[default_action]"]' => [
                                'value' => 'summary',
                            ],
                            ':input[name="options[summary][format]"]' => [
                                'value' => $id,
                            ],
                        ],
                    ],
                    '#default_value' => [],
                ];
                $options[$id] = $info['title'];
                $plugin->buildOptionsForm($form['summary']['options'][$id], $form_state);
            }
        }
    }
    
    /**
     * Handle the default action, which means our argument wasn't present.
     *
     * Override this method only with extreme care.
     *
     * @return bool
     *   A boolean value; if TRUE, continue building this view. If FALSE,
     *   building the view will be aborted here.
     */
    public function defaultAction($info = NULL) {
        if (!isset($info)) {
            $info = $this->defaultActions($this->options['default_action']);
        }
        if (!$info) {
            return FALSE;
        }
        if (!empty($info['method args'])) {
            return call_user_func_array([
                &$this,
                $info['method'],
            ], $info['method args']);
        }
        else {
            return $this->{$info['method']}();
        }
    }
    
    /**
     * How to act if validation fails.
     */
    public function validateFail() {
        $info = $this->defaultActions($this->options['validate']['fail']);
        return $this->defaultAction($info);
    }
    
    /**
     * Default action: ignore.
     *
     * If an argument was expected and was not given, in this case, simply
     * ignore the argument entirely.
     */
    public function defaultIgnore() {
        return TRUE;
    }
    
    /**
     * Default action: not found.
     *
     * If an argument was expected and was not given, in this case, report
     * the view as 'not found' or hide it.
     */
    protected function defaultNotFound() {
        // Set a failure condition and let the display manager handle it.
        $this->view->build_info['fail'] = TRUE;
        return FALSE;
    }
    
    /**
     * Default action: access denied.
     *
     * If an argument was expected and was not given, in this case, report
     * the view as 'access denied'.
     */
    public function defaultAccessDenied() {
        $this->view->build_info['denied'] = TRUE;
        return FALSE;
    }
    
    /**
     * Default action: empty.
     *
     * If an argument was expected and was not given, in this case, display
     * the view's empty text
     */
    public function defaultEmpty() {
        // We return with no query; this will force the empty text.
        $this->view->built = TRUE;
        $this->view->executed = TRUE;
        $this->view->result = [];
        return FALSE;
    }
    
    /**
     * Returns true, since the argument builder knows where to find the argument.
     */
    protected function defaultDefault() {
        return TRUE;
    }
    
    /**
     * Determine if the argument is set to provide a default argument.
     */
    public function hasDefaultArgument() {
        $info = $this->defaultActions($this->options['default_action']);
        return !empty($info['has default argument']);
    }
    
    /**
     * Get a default argument, if available.
     */
    public function getDefaultArgument() {
        $plugin = $this->getPlugin('argument_default');
        if ($plugin) {
            return $plugin->getArgument();
        }
    }
    
    /**
     * Process the summary arguments for display.
     *
     * For example, the validation plugin may want to alter an argument for use in
     * the URL.
     */
    public function processSummaryArguments(&$args) {
        if ($this->options['validate']['type'] != 'none') {
            if (isset($this->validator) || ($this->validator = $this->getPlugin('argument_validator'))) {
                $this->validator
                    ->processSummaryArguments($args);
            }
        }
    }
    
    /**
     * Default action: summary.
     *
     * If an argument was expected and was not given, in this case, display
     * a summary query.
     */
    protected function defaultSummary() {
        $this->view->build_info['summary'] = TRUE;
        $this->view->build_info['summary_level'] = $this->options['id'];
        // Change the display style to the summary style for this
        // argument.
        $this->view->style_plugin = Views::pluginManager("style")->createInstance($this->options['summary']['format']);
        $this->view->style_plugin
            ->init($this->view, $this->displayHandler, $this->options['summary_options']);
        // Clear out the normal primary field and whatever else may have
        // been added and let the summary do the work.
        $this->query
            ->clearFields();
        $this->summaryQuery();
        $by = $this->options['summary']['number_of_records'] ? 'num_records' : NULL;
        $this->summarySort($this->options['summary']['sort_order'], $by);
        // Summaries have their own sorting and fields, so tell the View not
        // to build these.
        $this->view->build_sort = FALSE;
        return TRUE;
    }
    
    /**
     * Build the info for the summary query.
     *
     * This must:
     * - addGroupBy: group on this field in order to create summaries.
     * - addField: add a 'num_nodes' field for the count. Usually it will
     *   be a count on $view->base_field
     * - setCountField: Reset the count field so we get the right paging.
     */
    protected function summaryQuery() {
        $this->ensureMyTable();
        // Add the field.
        $this->base_alias = $this->query
            ->addField($this->tableAlias, $this->realField);
        $this->summaryNameField();
        $this->summaryBasics();
    }
    
    /**
     * Adds the name field, which is the field displayed in summary queries.
     *
     * This is often used when the argument is numeric.
     */
    protected function summaryNameField() {
        // Add the 'name' field. For example, if this is a uid argument, the
        // name field would be 'name' (i.e, the username).
        if (isset($this->name_table)) {
            // If the alias is different then we're probably added, not ensured,
            // so look up the join and add it instead.
            if ($this->tableAlias != $this->name_table) {
                $j = HandlerBase::getTableJoin($this->name_table, $this->table);
                if ($j) {
                    $join = clone $j;
                    $join->leftTable = $this->tableAlias;
                    $this->name_table_alias = $this->query
                        ->addTable($this->name_table, $this->relationship, $join);
                }
            }
            else {
                $this->name_table_alias = $this->query
                    ->ensureTable($this->name_table, $this->relationship);
            }
        }
        else {
            $this->name_table_alias = $this->tableAlias;
        }
        if (isset($this->name_field)) {
            $this->name_alias = $this->query
                ->addField($this->name_table_alias, $this->name_field);
        }
        else {
            $this->name_alias = $this->base_alias;
        }
    }
    
    /**
     * Adds basic information to the summary query.
     *
     * Some basic summary behavior that doesn't need to be repeated as much as
     * code that goes into summaryQuery()
     */
    public function summaryBasics($count_field = TRUE) {
        // Add the number of nodes counter
        $distinct = $this->view->display_handler
            ->getOption('distinct') && empty($this->query->no_distinct);
        $count_alias = $this->query
            ->addField($this->view->storage
            ->get('base_table'), $this->view->storage
            ->get('base_field'), 'num_records', [
            'count' => TRUE,
            'distinct' => $distinct,
        ]);
        $this->query
            ->addGroupBy($this->name_alias);
        if ($count_field) {
            $this->query
                ->setCountField($this->tableAlias, $this->realField);
        }
        $this->count_alias = $count_alias;
    }
    
    /**
     * Sorts the summary based upon the user's selection.
     *
     * The base variant of this is usually adequate.
     *
     * @param $order
     *   The order selected in the UI.
     * @param string|null $by
     *   (optional) This parameter sets the direction for which to order.
     *   Defaults to NULL.
     */
    public function summarySort($order, $by = NULL) {
        $this->query
            ->addOrderBy(NULL, NULL, $order, !empty($by) ? $by : $this->name_alias);
    }
    
    /**
     * Provides the argument to use to link from the summary to the next level.
     *
     * This will be called once per row of a summary, and used as part of
     * $view->getUrl().
     *
     * @param $data
     *   The query results for the row.
     */
    public function summaryArgument($data) {
        return $data->{$this->base_alias};
    }
    
    /**
     * Provides the name to use for the summary, defaults to the name field.
     *
     * @param $data
     *   The query results for the row.
     */
    public function summaryName($data) {
        $value = (string) $data->{$this->name_alias};
        if ($value === '' && isset($this->definition['empty field name'])) {
            $value = $this->definition['empty field name'];
        }
        return $value;
    }
    
    /**
     * Set up the query for this argument.
     *
     * The argument sent may be found at $this->argument.
     */
    public function query($group_by = FALSE) {
        $this->ensureMyTable();
        $this->query
            ->addWhere(0, "{$this->tableAlias}.{$this->realField}", $this->argument);
    }
    
    /**
     * Get the title this argument will assign the view, given the argument.
     *
     * This usually needs to be overridden to provide a proper title.
     */
    public function title() {
        return $this->argument;
    }
    
    /**
     * Determines the title to use for the view.
     *
     * This may be set by a validator so we don't necessarily call through to
     * title().
     */
    public function getTitle() {
        if (isset($this->validated_title)) {
            return $this->validated_title;
        }
        else {
            return $this->title();
        }
    }
    
    /**
     * Validate that this argument works. By default, all arguments are valid.
     */
    public function validateArgument($arg) {
        // By using % in URLs, arguments could be validated twice; this eases
        // that pain.
        if (isset($this->argument_validated)) {
            return $this->argument_validated;
        }
        if ($this->isException($arg)) {
            return $this->argument_validated = TRUE;
        }
        $plugin = $this->getPlugin('argument_validator');
        return $this->argument_validated = $plugin->validateArgument($arg);
    }
    
    /**
     * Called by the menu system to validate an argument.
     *
     * This checks to see if this is a 'soft fail', which means that if the
     * argument fails to validate, but there is an action to take anyway,
     * then validation cannot actually fail.
     */
    public function validateMenuArgument($arg) {
        $validate_info = $this->defaultActions($this->options['validate']['fail']);
        if (empty($validate_info['hard fail'])) {
            return TRUE;
        }
        $rc = $this->validateArgument($arg);
        // If the validator has changed the validate fail condition to a
        // soft fail, deal with that:
        $validate_info = $this->defaultActions($this->options['validate']['fail']);
        if (empty($validate_info['hard fail'])) {
            return TRUE;
        }
        return $rc;
    }
    
    /**
     * Set the input for this argument.
     *
     * @return TRUE if it successfully validates; FALSE if it does not.
     */
    public function setArgument($arg) {
        $this->argument = $arg;
        return $this->validateArgument($arg);
    }
    
    /**
     * Get the value of this argument.
     */
    public function getValue() {
        // If we already processed this argument, we're done.
        if (isset($this->argument)) {
            return $this->argument;
        }
        // Otherwise, we have to pretend to process ourselves to find the value.
        $value = NULL;
        // Find the position of this argument within the view.
        $position = 0;
        foreach ($this->view->argument as $id => $argument) {
            if ($id == $this->options['id']) {
                break;
            }
            $position++;
        }
        $arg = $this->view->args[$position] ?? NULL;
        $this->position = $position;
        // Clone ourselves so that we don't break things when we're really
        // processing the arguments.
        $argument = clone $this;
        if (!isset($arg) && $argument->hasDefaultArgument()) {
            $arg = $argument->getDefaultArgument();
            // Remember that this argument was computed, not passed on the URL.
            $this->is_default = TRUE;
        }
        // Set the argument, which will also validate that the argument can be set.
        if ($argument->setArgument($arg)) {
            $value = $argument->argument;
        }
        unset($argument);
        return $value;
    }
    
    /**
     * Get the display or row plugin, if it exists.
     */
    public function getPlugin($type = 'argument_default', $name = NULL) {
        $options = [];
        $plugin_name = match ($type) {    'argument_default' => $this->options['default_argument_type'] ?? NULL,
            'argument_validator' => $this->options['validate']['type'] ?? NULL,
            'style' => $this->options['summary']['format'] ?? NULL,
        
        };
        if ($plugin_name === NULL) {
            return NULL;
        }
        $options_name = match ($type) {    'argument_default' => 'default_argument_options',
            'argument_validator' => 'validate_options',
            'style' => 'summary_options',
        
        };
        if (!$name) {
            $name = $plugin_name;
        }
        // We only fetch the options if we're fetching the plugin actually
        // in use.
        if ($name == $plugin_name) {
            $options = $this->options[$options_name] ?? [];
        }
        $plugin = Views::pluginManager($type)->createInstance($name);
        if ($plugin) {
            $plugin->init($this->view, $this->displayHandler, $options);
            if ($type !== 'style') {
                // It's an argument_default/argument_validate plugin, so set the argument.
                $plugin->setArgument($this);
            }
            return $plugin;
        }
    }
    
    /**
     * Return a description of how the argument would normally be sorted.
     *
     * Subclasses should override this to specify what the default sort order of
     * their argument is (e.g. alphabetical, numeric, date).
     */
    public function getSortName() {
        return $this->t('Default sort', [], [
            'context' => 'Sort order',
        ]);
    }
    
    /**
     * Custom form radios process function.
     *
     * Roll out a single radios element to a list of radios, using the options
     * array as index. While doing that, create a container element underneath
     * each option, which contains the settings related to that option.
     *
     * @see \Drupal\Core\Render\Element\Radios::processRadios()
     */
    public static function processContainerRadios($element) {
        if (count($element['#options']) > 0) {
            foreach ($element['#options'] as $key => $choice) {
                $element += [
                    $key => [],
                ];
                // Generate the parents as the autogenerator does, so we will have a
                // unique id for each radio button.
                $parents_for_id = array_merge($element['#parents'], [
                    $key,
                ]);
                $element[$key] += [
                    '#type' => 'radio',
                    '#title' => $choice,
                    // The key is sanitized in drupal_attributes() during output from the
                    // theme function.
'#return_value' => $key,
                    '#default_value' => $element['#default_value'] ?? NULL,
                    '#attributes' => $element['#attributes'],
                    '#parents' => $element['#parents'],
                    '#id' => Html::getUniqueId('edit-' . implode('-', $parents_for_id)),
                    '#ajax' => $element['#ajax'] ?? NULL,
                ];
                $element[$key . '_options'] = [
                    '#type' => 'container',
                    '#attributes' => [
                        'class' => [
                            'views-admin-dependent',
                        ],
                    ],
                ];
            }
        }
        return $element;
    }
    
    /**
     * Moves argument options into their place.
     *
     * When configuring the default argument behavior, almost each of the radio
     * buttons has its own fieldset shown below it when the radio button is
     * clicked. That fieldset is created through a custom form process callback.
     * Each element that has #argument_option defined and pointing to a default
     * behavior gets moved to the appropriate fieldset.
     * So if #argument_option is specified as 'default', the element is moved
     * to the 'default_options' fieldset.
     */
    public static function preRenderMoveArgumentOptions($form) {
        foreach (Element::children($form) as $key) {
            $element = $form[$key];
            if (!empty($element['#argument_option'])) {
                $container_name = $element['#argument_option'] . '_options';
                if (isset($form['no_argument']['default_action'][$container_name])) {
                    $form['no_argument']['default_action'][$container_name][$key] = $element;
                }
                // Remove the original element this duplicates.
                unset($form[$key]);
            }
        }
        return $form;
    }
    
    /**
     * Sanitize validator options including derivatives with : for js.
     *
     * Reason and alternative: https://www.drupal.org/node/2035345.
     *
     * @param string $id
     *   The identifier to be sanitized.
     *
     * @return string
     *   The sanitized identifier.
     *
     * @see decodeValidatorId()
     */
    public static function encodeValidatorId($id) {
        return str_replace(':', '---', $id);
    }
    
    /**
     * Revert sanitized validator options.
     *
     * @param string $id
     *   The sanitized identifier to be reverted.
     *
     * @return string
     *   The original identifier.
     */
    public static function decodeValidatorId($id) {
        return str_replace('---', ':', $id);
    }
    
    /**
     * Splits an argument into value and operator properties on this instance.
     *
     * @param bool $force_int
     *   Enforce that values should be numeric.
     */
    protected function unpackArgumentValue($force_int = FALSE) {
        $break = static::breakString($this->argument, $force_int);
        $this->value = $break->value;
        $this->operator = $break->operator;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getCacheMaxAge() {
        $max_age = Cache::PERMANENT;
        // Asks all subplugins (argument defaults, argument validator and styles).
        if (($plugin = $this->getPlugin('argument_default')) && $plugin instanceof CacheableDependencyInterface) {
            $max_age = Cache::mergeMaxAges($max_age, $plugin->getCacheMaxAge());
        }
        if (($plugin = $this->getPlugin('argument_validator')) && $plugin instanceof CacheableDependencyInterface) {
            $max_age = Cache::mergeMaxAges($max_age, $plugin->getCacheMaxAge());
        }
        // Summaries use style plugins.
        if (($plugin = $this->getPlugin('style')) && $plugin instanceof CacheableDependencyInterface) {
            $max_age = Cache::mergeMaxAges($max_age, $plugin->getCacheMaxAge());
        }
        return $max_age;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getCacheContexts() {
        $contexts = [];
        // By definition arguments depends on the URL.
        // @todo Once contexts are properly injected into block views we could pull
        //   the information from there.
        $contexts[] = 'url';
        // Asks all subplugins (argument defaults, argument validator and styles).
        if (($plugin = $this->getPlugin('argument_default')) && $plugin instanceof CacheableDependencyInterface) {
            $contexts = Cache::mergeContexts($contexts, $plugin->getCacheContexts());
        }
        if (($plugin = $this->getPlugin('argument_validator')) && $plugin instanceof CacheableDependencyInterface) {
            $contexts = Cache::mergeContexts($contexts, $plugin->getCacheContexts());
        }
        if (($plugin = $this->getPlugin('style')) && $plugin instanceof CacheableDependencyInterface) {
            $contexts = Cache::mergeContexts($contexts, $plugin->getCacheContexts());
        }
        return $contexts;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getCacheTags() {
        $tags = [];
        // Asks all subplugins (argument defaults, argument validator and styles).
        if (($plugin = $this->getPlugin('argument_default')) && $plugin instanceof CacheableDependencyInterface) {
            $tags = Cache::mergeTags($tags, $plugin->getCacheTags());
        }
        if (($plugin = $this->getPlugin('argument_validator')) && $plugin instanceof CacheableDependencyInterface) {
            $tags = Cache::mergeTags($tags, $plugin->getCacheTags());
        }
        if (($plugin = $this->getPlugin('style')) && $plugin instanceof CacheableDependencyInterface) {
            $tags = Cache::mergeTags($tags, $plugin->getCacheTags());
        }
        return $tags;
    }
    
    /**
     * {@inheritdoc}
     */
    public function calculateDependencies() {
        $dependencies = [];
        if (($argument_default = $this->getPlugin('argument_default')) && $argument_default instanceof DependentPluginInterface) {
            $dependencies = NestedArray::mergeDeep($dependencies, $argument_default->calculateDependencies());
        }
        if (($argument_validator = $this->getPlugin('argument_validator')) && $argument_validator instanceof DependentPluginInterface) {
            $dependencies = NestedArray::mergeDeep($dependencies, $argument_validator->calculateDependencies());
        }
        if (($style = $this->getPlugin('style')) && $style instanceof DependentPluginInterface) {
            $dependencies = NestedArray::mergeDeep($dependencies, $style->calculateDependencies());
        }
        return $dependencies;
    }
    
    /**
     * Returns a context definition for this argument.
     *
     * @return \Drupal\Core\Plugin\Context\ContextDefinitionInterface|null
     *   A context definition that represents the argument or NULL if that is
     *   not possible.
     */
    public function getContextDefinition() {
        return $this->getPlugin('argument_validator')
            ->getContextDefinition();
    }
    
    /**
     * {@inheritdoc}
     */
    public function adminSummary() {
        // If an argument default has been set, show which argument default has been
        // set.
        if ($this->options['default_action'] === 'default') {
            $plugin = $this->getPlugin();
            if ($plugin) {
                return $this->t('Default: @plugin_title', [
                    '@plugin_title' => $plugin->pluginTitle(),
                ]);
            }
        }
        return '';
    }

}

/**
 * @}
 */

Classes

Title Deprecated Summary
ArgumentPluginBase Base class for argument (contextual filter) handler plugins.

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.