You are here

Home » API reference » Drupal 10 » Combine.php

class Combine in Drupal 10

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

Filter handler which allows to search on multiple fields.

Plugin annotation

@ViewsFilter("combine");

Hierarchy

Expanded class hierarchy of Combine

1 string reference to 'Combine'
views.filter.schema.yml in core/modules/views/config/schema/views.filter.schema.yml
core/modules/views/config/schema/views.filter.schema.yml

File

core/modules/views/src/Plugin/views/filter/Combine.php, line 14

Namespace

Drupal\views\Plugin\views\filter
View source 
class Combine extends StringFilter {

  /**
   * @var views_plugin_query_default
   */
  public $query;
  protected function defineOptions() {
    $options = parent::defineOptions();
    $options['fields'] = [
      'default' => [],
    ];
    return $options;
  }
  public function buildOptionsForm(&$form, FormStateInterface $form_state) {
    parent::buildOptionsForm($form, $form_state);
    $this->view
      ->initStyle();

    // Allow to choose all fields as possible
    if ($this->view->style_plugin
      ->usesFields()) {
      $options = [];
      foreach ($this->view->display_handler
        ->getHandlers('field') as $name => $field) {

        // Only allow clickSortable fields. Fields without clickSorting will
        // probably break in the Combine filter.
        if ($field
          ->clickSortable()) {
          $options[$name] = $field
            ->adminLabel(TRUE);
        }
      }
      if ($options) {
        $form['fields'] = [
          '#type' => 'select',
          '#title' => $this
            ->t('Choose fields to combine for filtering'),
          '#description' => $this
            ->t("This filter doesn't work for very special field handlers."),
          '#multiple' => TRUE,
          '#options' => $options,
          '#default_value' => $this->options['fields'],
        ];
      }
      else {
        $form_state
          ->setErrorByName('', $this
          ->t('You have to add some fields to be able to use this filter.'));
      }
    }
  }
  public function query() {
    $this->view
      ->_build('field');
    $fields = [];

    // Only add the fields if they have a proper field and table alias.
    foreach ($this->options['fields'] as $id) {

      // Overridden fields can lead to fields missing from a display that are
      // still set in the non-overridden combined filter.
      if (!isset($this->view->field[$id])) {

        // If fields are no longer available that are needed to filter by, make
        // sure no results are shown to prevent displaying more then intended.
        $this->view->build_info['fail'] = TRUE;
        continue;
      }
      $field = $this->view->field[$id];

      // Always add the table of the selected fields to be sure a table alias exists.
      $field
        ->ensureMyTable();
      if (!empty($field->field_alias) && !empty($field->field_alias)) {
        $fields[] = "{$field->tableAlias}.{$field->realField}";
      }
    }
    if ($fields) {

      // We do not use the CONCAT_WS operator when there is only a single field.
      // Using the CONCAT_WS operator with a single field is not a problem for
      // the by core supported databases. Only the MS SQL Server requires the
      // CONCAT_WS operator to be used with at least three arguments.
      if (count($fields) == 1) {
        $expression = reset($fields);
      }
      else {

        // Multiple fields are separated by 3 spaces so that so that search
        // strings that contain spaces are still only matched to single field
        // values and not to multi-field values that exist only because we do
        // the concatenation/LIKE trick.
        $expression = implode(", ' ', ", $fields);
        $expression = "CONCAT_WS(' ', {$expression})";
      }
      $info = $this
        ->operators();
      if (!empty($info[$this->operator]['method'])) {
        $this
          ->{$info[$this->operator]['method']}($expression);
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function validate() {
    $errors = parent::validate();
    if ($this->displayHandler
      ->usesFields()) {
      $fields = $this->displayHandler
        ->getHandlers('field');
      foreach ($this->options['fields'] as $id) {
        if (!isset($fields[$id])) {

          // Combined field filter only works with fields that are in the field
          // settings.
          $errors[] = $this
            ->t('Field %field set in %filter is not set in display %display.', [
            '%field' => $id,
            '%filter' => $this
              ->adminLabel(),
            '%display' => $this->displayHandler->display['display_title'],
          ]);
          break;
        }
        elseif (!$fields[$id]
          ->clickSortable()) {

          // Combined field filter only works with simple fields. If the field
          // is not click sortable we can assume it is not a simple field.
          // @todo change this check to isComputed. See
          // https://www.drupal.org/node/2349465
          $errors[] = $this
            ->t('Field %field set in %filter is not usable for this filter type. Combined field filter only works for simple fields.', [
            '%field' => $fields[$id]
              ->adminLabel(),
            '%filter' => $this
              ->adminLabel(),
          ]);
        }
      }
    }
    else {
      $errors[] = $this
        ->t('%display: %filter can only be used on displays that use fields. Set the style or row format for that display to one using fields to use the combine field filter.', [
        '%display' => $this->displayHandler->display['display_title'],
        '%filter' => $this
          ->adminLabel(),
      ]);
    }
    return $errors;
  }

  /**
   * By default things like opEqual uses add_where, that doesn't support
   * complex expressions, so override opEqual (and all operators below).
   */
  public function opEqual($expression) {
    $placeholder = $this
      ->placeholder();
    $operator = $this
      ->getConditionOperator('LIKE');
    $this->query
      ->addWhereExpression($this->options['group'], "{$expression} {$operator} {$placeholder}", [
      $placeholder => $this->value,
    ]);
  }
  protected function opContains($expression) {
    $placeholder = $this
      ->placeholder();
    $operator = $this
      ->getConditionOperator('LIKE');
    $this->query
      ->addWhereExpression($this->options['group'], "{$expression} {$operator} {$placeholder}", [
      $placeholder => '%' . $this->connection
        ->escapeLike($this->value) . '%',
    ]);
  }

  /**
   * Filters by one or more words.
   *
   * By default opContainsWord uses add_where, that doesn't support complex
   * expressions.
   *
   * @param string $expression
   *   The expression to add to the query.
   */
  protected function opContainsWord($expression) {
    $placeholder = $this
      ->placeholder();

    // Don't filter on empty strings.
    if (empty($this->value)) {
      return;
    }

    // Match all words separated by spaces or sentences encapsulated by double
    // quotes.
    preg_match_all(static::WORDS_PATTERN, ' ' . $this->value, $matches, PREG_SET_ORDER);

    // Switch between the 'word' and 'allwords' operator.
    $type = $this->operator == 'word' ? 'OR' : 'AND';
    $group = $this->query
      ->setWhereGroup($type);
    $operator = $this
      ->getConditionOperator('LIKE');
    foreach ($matches as $match_key => $match) {
      $temp_placeholder = $placeholder . '_' . $match_key;

      // Clean up the user input and remove the sentence delimiters.
      $word = trim($match[2], ',?!();:-"');
      $this->query
        ->addWhereExpression($group, "{$expression} {$operator} {$temp_placeholder}", [
        $temp_placeholder => '%' . $this->connection
          ->escapeLike($word) . '%',
      ]);
    }
  }
  protected function opStartsWith($expression) {
    $placeholder = $this
      ->placeholder();
    $operator = $this
      ->getConditionOperator('LIKE');
    $this->query
      ->addWhereExpression($this->options['group'], "{$expression} {$operator} {$placeholder}", [
      $placeholder => $this->connection
        ->escapeLike($this->value) . '%',
    ]);
  }
  protected function opNotStartsWith($expression) {
    $placeholder = $this
      ->placeholder();
    $operator = $this
      ->getConditionOperator('NOT LIKE');
    $this->query
      ->addWhereExpression($this->options['group'], "{$expression} {$operator} {$placeholder}", [
      $placeholder => $this->connection
        ->escapeLike($this->value) . '%',
    ]);
  }
  protected function opEndsWith($expression) {
    $placeholder = $this
      ->placeholder();
    $operator = $this
      ->getConditionOperator('LIKE');
    $this->query
      ->addWhereExpression($this->options['group'], "{$expression} {$operator} {$placeholder}", [
      $placeholder => '%' . $this->connection
        ->escapeLike($this->value),
    ]);
  }
  protected function opNotEndsWith($expression) {
    $placeholder = $this
      ->placeholder();
    $operator = $this
      ->getConditionOperator('NOT LIKE');
    $this->query
      ->addWhereExpression($this->options['group'], "{$expression} {$operator} {$placeholder}", [
      $placeholder => '%' . $this->connection
        ->escapeLike($this->value),
    ]);
  }
  protected function opNotLike($expression) {
    $placeholder = $this
      ->placeholder();
    $operator = $this
      ->getConditionOperator('NOT LIKE');
    $this->query
      ->addWhereExpression($this->options['group'], "{$expression} {$operator} {$placeholder}", [
      $placeholder => '%' . $this->connection
        ->escapeLike($this->value) . '%',
    ]);
  }
  protected function opRegex($expression) {
    $placeholder = $this
      ->placeholder();
    $this->query
      ->addWhereExpression($this->options['group'], "{$expression} REGEXP {$placeholder}", [
      $placeholder => $this->value,
    ]);
  }
  protected function opEmpty($expression) {
    if ($this->operator == 'empty') {
      $operator = "IS NULL";
    }
    else {
      $operator = "IS NOT NULL";
    }
    $this->query
      ->addWhereExpression($this->options['group'], "{$expression} {$operator}");
  }

}

Members

Namesort descending Modifiers Type Description Overrides
Combine::$query public property
Combine::buildOptionsForm public function Provide the basic form which calls through to subforms. Overrides FilterPluginBase::buildOptionsForm
Combine::defineOptions protected function Overrides StringFilter::defineOptions
Combine::opContains protected function Overrides StringFilter::opContains
Combine::opContainsWord protected function Filters by one or more words. Overrides StringFilter::opContainsWord
Combine::opEmpty protected function Overrides StringFilter::opEmpty
Combine::opEndsWith protected function Overrides StringFilter::opEndsWith
Combine::opEqual public function By default things like opEqual uses add_where, that doesn't support complex expressions, so override opEqual (and all operators below). Overrides StringFilter::opEqual
Combine::opNotEndsWith protected function Overrides StringFilter::opNotEndsWith
Combine::opNotLike protected function Overrides StringFilter::opNotLike
Combine::opNotStartsWith protected function Overrides StringFilter::opNotStartsWith
Combine::opRegex protected function Filters by a regular expression. Overrides StringFilter::opRegex
Combine::opStartsWith protected function Overrides StringFilter::opStartsWith
Combine::query public function Add this filter to the query. Overrides StringFilter::query
Combine::validate public function Overrides FilterPluginBase::validate
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::acceptExposedInput public function Determines if the input from a filter should change the generated query. 2
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::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 5
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::init public function Overrides \Drupal\views\Plugin\views\HandlerBase::init(). 2
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::valueSubmit protected function Perform any necessary changes to the form values prior to storage. 1
FilterPluginBase::valueValidate protected function Validate the options form. 2
StringFilter::$alwaysMultiple protected property Exposed filter options. Overrides FilterPluginBase::$alwaysMultiple
StringFilter::$connection protected property The database connection.
StringFilter::adminSummary public function Display the filter on the administrative summary. Overrides FilterPluginBase::adminSummary
StringFilter::buildExposeForm public function Options form subform for exposed filter options. Overrides FilterPluginBase::buildExposeForm
StringFilter::create public static function
StringFilter::defaultExposeOptions public function Provide default options for exposed filters. Overrides FilterPluginBase::defaultExposeOptions
StringFilter::getConditionOperator protected function Get specified condition operator mapping value.
StringFilter::operator public function Get the query operator.
StringFilter::operatorOptions public function Build strings from the operators() for 'select' options. Overrides FilterPluginBase::operatorOptions
StringFilter::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.
StringFilter::operatorValues protected function
StringFilter::opLongerThan protected function
StringFilter::opShorterThan protected function
StringFilter::valueForm protected function Provide a simple textfield for equality. Overrides FilterPluginBase::valueForm
StringFilter::WORDS_PATTERN constant All words separated by spaces or sentences encapsulated by double quotes.
StringFilter::__construct public function Constructs a new StringFilter object.