You are here

Home » API reference » Drupal 10 » ManyToOne.php

class ManyToOne in Drupal 10

Same name and namespace in other branches
  1. 8 core/modules/views/src/Plugin/views/filter/ManyToOne.php \Drupal\views\Plugin\views\filter\ManyToOne
  2. 9 core/modules/views/src/Plugin/views/filter/ManyToOne.php \Drupal\views\Plugin\views\filter\ManyToOne

Complex filter to handle filtering for many to one relationships, such as terms (many terms per node) or roles (many roles per user).

The construct method needs to be overridden to provide a list of options; alternately, the valueForm and adminSummary methods need to be overridden to provide something that isn't just a select list.

Plugin annotation

@ViewsFilter("many_to_one");

Hierarchy

Expanded class hierarchy of ManyToOne

Related topics

Views filter handler plugins
Plugins that handle views filtering.
4 files declare their use of ManyToOne
ListField.php in core/modules/options/src/Plugin/views/filter/ListField.php
Permissions.php in core/modules/user/src/Plugin/views/filter/Permissions.php
Roles.php in core/modules/user/src/Plugin/views/filter/Roles.php
TaxonomyIndexTid.php in core/modules/taxonomy/src/Plugin/views/filter/TaxonomyIndexTid.php

File

core/modules/views/src/Plugin/views/filter/ManyToOne.php, line 22

Namespace

Drupal\views\Plugin\views\filter
View source 
class ManyToOne extends InOperator {

  /**
   * @var \Drupal\views\ManyToOneHelper
   *
   * Stores the Helper object which handles the many_to_one complexity.
   */
  public $helper = NULL;

  /**
   * {@inheritdoc}
   */
  public function init(ViewExecutable $view, DisplayPluginBase $display, array &$options = NULL) {
    parent::init($view, $display, $options);
    $this->helper = new ManyToOneHelper($this);
  }
  protected function defineOptions() {
    $options = parent::defineOptions();
    $options['operator']['default'] = 'or';
    $options['value']['default'] = [];
    if (isset($this->helper)) {
      $this->helper
        ->defineOptions($options);
    }
    else {
      $helper = new ManyToOneHelper($this);
      $helper
        ->defineOptions($options);
    }
    return $options;
  }
  public function operators() {
    $operators = [
      'or' => [
        'title' => $this
          ->t('Is one of'),
        'short' => $this
          ->t('or'),
        'short_single' => $this
          ->t('='),
        'method' => 'opHelper',
        'values' => 1,
        'ensure_my_table' => 'helper',
      ],
      'and' => [
        'title' => $this
          ->t('Is all of'),
        'short' => $this
          ->t('and'),
        'short_single' => $this
          ->t('='),
        'method' => 'opHelper',
        'values' => 1,
        'ensure_my_table' => 'helper',
      ],
      'not' => [
        'title' => $this
          ->t('Is none of'),
        'short' => $this
          ->t('not'),
        'short_single' => $this
          ->t('<>'),
        'method' => 'opHelper',
        'values' => 1,
        'ensure_my_table' => 'helper',
      ],
    ];

    // if the definition allows for the empty operator, add it.
    if (!empty($this->definition['allow empty'])) {
      $operators += [
        'empty' => [
          'title' => $this
            ->t('Is empty (NULL)'),
          'method' => 'opEmpty',
          'short' => $this
            ->t('empty'),
          'values' => 0,
        ],
        'not empty' => [
          'title' => $this
            ->t('Is not empty (NOT NULL)'),
          'method' => 'opEmpty',
          'short' => $this
            ->t('not empty'),
          'values' => 0,
        ],
      ];
    }
    return $operators;
  }
  protected $valueFormType = 'select';
  protected function valueForm(&$form, FormStateInterface $form_state) {
    parent::valueForm($form, $form_state);
    if (!$form_state
      ->get('exposed')) {
      $this->helper
        ->buildOptionsForm($form, $form_state);
    }
  }

  /**
   * Override ensureMyTable so we can control how this joins in.
   * The operator actually has influence over joining.
   */
  public function ensureMyTable() {

    // Defer to helper if the operator specifies it.
    $info = $this
      ->operators();
    if (isset($info[$this->operator]['ensure_my_table']) && $info[$this->operator]['ensure_my_table'] == 'helper') {
      return $this->helper
        ->ensureMyTable();
    }
    return parent::ensureMyTable();
  }
  protected function opHelper() {
    if (empty($this->value)) {
      return;
    }

    // Form API returns unchecked options in the form of option_id => 0. This
    // breaks the generated query for "is all of" filters so we remove them.
    $this->value = array_filter($this->value, [
      static::class,
      'arrayFilterZero',
    ]);
    $this->helper
      ->addFilter();
  }

}

Members

Namesort descending Modifiers Type Description Overrides
FilterPluginBase::$alwaysMultiple protected property Disable the possibility to force a single value. 4
FilterPluginBase::$always_required public property Disable the possibility to allow an exposed input to be optional.
FilterPluginBase::$group_info public property Contains the information of the selected item in a grouped filter.
FilterPluginBase::$no_operator public property Disable the possibility to use operators. 1
FilterPluginBase::$operator public property Contains the operator which is used on the query.
FilterPluginBase::$value public property Contains the actual value of the field,either configured in the views ui or entered in the exposed filters.
FilterPluginBase::addGroupForm public function Add a new group to the exposed filter groups.
FilterPluginBase::arrayFilterZero protected static function Filter by no empty values, though allow the use of (string) "0".
FilterPluginBase::buildExposedFiltersGroupForm protected function Build the form to let users create the group of exposed filters.
FilterPluginBase::buildExposedForm public function Render our chunk of the exposed filter form when selecting.
FilterPluginBase::buildGroupForm public function Displays the Build Group form.
FilterPluginBase::buildGroupOptions protected function Provide default options for exposed filters.
FilterPluginBase::buildGroupSubmit protected function Save new group items, re-enumerates and remove groups marked to delete.
FilterPluginBase::buildGroupValidate protected function Validate the build group options form.
FilterPluginBase::buildOptionsForm public function Provide the basic form which calls through to subforms. 2
FilterPluginBase::buildValueWrapper protected function Builds wrapper for value and operator forms.
FilterPluginBase::canBuildGroup protected function Determine if a filter can be converted into a group.
FilterPluginBase::canExpose public function Determine if a filter can be exposed. 5
FilterPluginBase::canGroup public function Can this filter be used in OR groups? 1
FilterPluginBase::convertExposedInput public function Transform the input from a grouped filter into a standard filter.
FilterPluginBase::exposedInfo public function Tell the renderer about our exposed form. This only needs to be overridden for particularly complex forms. And maybe not even then.
FilterPluginBase::exposedTranslate protected function Make some translations to a form item to make it more suitable to exposing.
FilterPluginBase::getCacheContexts public function The cache contexts associated with this object. Overrides CacheableDependencyInterface::getCacheContexts 6
FilterPluginBase::getCacheMaxAge public function The maximum age for which this object may be cached. Overrides CacheableDependencyInterface::getCacheMaxAge
FilterPluginBase::getCacheTags public function The cache tags associated with this object. Overrides CacheableDependencyInterface::getCacheTags 1
FilterPluginBase::groupForm public function Build a form containing a group of operator | values to apply as a single filter.
FilterPluginBase::groupMultipleExposedInput public function Returns the options available for a grouped filter that users checkboxes as widget, and therefore has to be applied several times, one per item selected.
FilterPluginBase::hasValidGroupedValue protected function Determines if the given grouped filter entry has a valid value. 1
FilterPluginBase::isAGroup public function Returns TRUE if the exposed filter works like a grouped filter.
FilterPluginBase::multipleExposedInput public function Returns TRUE if users can select multiple groups items of a grouped exposed filter.
FilterPluginBase::operatorForm protected function Options form subform for setting the operator. 5
FilterPluginBase::operatorSubmit public function Perform any necessary changes to the form values prior to storage.
FilterPluginBase::operatorValidate protected function Validate the operator form.
FilterPluginBase::prepareFilterSelectOptions protected function Sanitizes the HTML select element's options.
FilterPluginBase::showBuildGroupButton protected function Shortcut to display the build_group/hide button.
FilterPluginBase::showBuildGroupForm public function Shortcut to display the exposed options form.
FilterPluginBase::showExposeButton public function Shortcut to display the expose/hide button.
FilterPluginBase::showOperatorForm public function Shortcut to display the operator form.
FilterPluginBase::showValueForm protected function Shortcut to display the value form.
FilterPluginBase::storeExposedInput public function
FilterPluginBase::storeGroupInput public function If set to remember exposed input in the session, store it there.
FilterPluginBase::submitOptionsForm public function Simple submit handler.
FilterPluginBase::trustedCallbacks public static function
FilterPluginBase::validateExposeForm public function Validate the options form.
FilterPluginBase::validateIdentifier protected function Validates a filter identifier.
FilterPluginBase::validateOptionsForm public function Simple validate handler. 1
FilterPluginBase::valueValidate protected function Validate the options form. 2
InOperator::$valueOptions protected property Stores all operations which are available on the form.
InOperator::$valueTitle protected property The filter title.
InOperator::acceptExposedInput public function Determines if the input from a filter should change the generated query. Overrides FilterPluginBase::acceptExposedInput 2
InOperator::adminSummary public function Display the filter on the administrative summary. Overrides FilterPluginBase::adminSummary 2
InOperator::buildExposeForm public function Options form subform for exposed filter options. Overrides FilterPluginBase::buildExposeForm 1
InOperator::defaultExposeOptions public function Provide default options for exposed filters. Overrides FilterPluginBase::defaultExposeOptions
InOperator::getValueOptions public function Child classes should be used to override this function and set the 'value options', unless 'options callback' is defined as a valid function or static public method to generate these values. 9
InOperator::opEmpty protected function
InOperator::operatorOptions public function Build strings from the operators() for 'select' options. Overrides FilterPluginBase::operatorOptions 1
InOperator::operatorValues protected function
InOperator::opSimple protected function 1
InOperator::query public function Add this filter to the query. Overrides FilterPluginBase::query 5
InOperator::reduceValueOptions public function When using exposed filters, we may be required to reduce the set.
InOperator::validate public function Overrides FilterPluginBase::validate
InOperator::valueSubmit protected function Perform any necessary changes to the form values prior to storage. Overrides FilterPluginBase::valueSubmit 2
ManyToOne::$helper public property Stores the Helper object which handles the many_to_one complexity.
ManyToOne::$valueFormType protected property Overrides InOperator::$valueFormType
ManyToOne::defineOptions protected function Overrides InOperator::defineOptions 1
ManyToOne::ensureMyTable public function Override ensureMyTable so we can control how this joins in. The operator actually has influence over joining.
ManyToOne::init public function Overrides \Drupal\views\Plugin\views\HandlerBase::init(). Overrides InOperator::init 2
ManyToOne::operators public function This kind of construct makes it relatively easy for a child class to add or remove functionality by overriding this function and adding/removing items from this array. Overrides InOperator::operators 1
ManyToOne::opHelper protected function
ManyToOne::valueForm protected function Options form subform for setting options. Overrides InOperator::valueForm 1