You are here

Home » API reference » Drupal 10 » NumericFilter.php

class NumericFilter in Drupal 10

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

Simple filter to handle greater than/less than filters.

Plugin annotation

@ViewsFilter("numeric");

Hierarchy

Expanded class hierarchy of NumericFilter

Related topics

Views filter handler plugins
Plugins that handle views filtering.
1 file declares its use of NumericFilter
HandlerAllTest.php in core/modules/views/tests/src/Functional/Handler/HandlerAllTest.php

File

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

Namespace

Drupal\views\Plugin\views\filter
View source 
class NumericFilter extends FilterPluginBase {
  protected $alwaysMultiple = TRUE;
  protected function defineOptions() {
    $options = parent::defineOptions();
    $options['value'] = [
      'contains' => [
        'min' => [
          'default' => '',
        ],
        'max' => [
          'default' => '',
        ],
        'value' => [
          'default' => '',
        ],
      ],
    ];
    $options['expose']['contains']['placeholder'] = [
      'default' => '',
    ];
    $options['expose']['contains']['min_placeholder'] = [
      'default' => '',
    ];
    $options['expose']['contains']['max_placeholder'] = [
      'default' => '',
    ];
    return $options;
  }

  /**
   * {@inheritdoc}
   */
  public function defaultExposeOptions() {
    parent::defaultExposeOptions();
    $this->options['expose']['min_placeholder'] = NULL;
    $this->options['expose']['max_placeholder'] = NULL;
    $this->options['expose']['placeholder'] = NULL;
  }

  /**
   * {@inheritdoc}
   */
  public function buildExposeForm(&$form, FormStateInterface $form_state) {
    parent::buildExposeForm($form, $form_state);
    $form['expose']['min_placeholder'] = [
      '#type' => 'textfield',
      '#default_value' => $this->options['expose']['min_placeholder'],
      '#title' => $this
        ->t('Min placeholder'),
      '#size' => 40,
      '#description' => $this
        ->t('Hint text that appears inside the Min field when empty.'),
    ];
    $form['expose']['max_placeholder'] = [
      '#type' => 'textfield',
      '#default_value' => $this->options['expose']['max_placeholder'],
      '#title' => $this
        ->t('Max placeholder'),
      '#size' => 40,
      '#description' => $this
        ->t('Hint text that appears inside the Max field when empty.'),
    ];

    // Setup #states for all operators with two value.
    $states = [
      [
        ':input[name="options[expose][use_operator]"]' => [
          'checked' => TRUE,
        ],
      ],
    ];
    foreach ($this
      ->operatorValues(2) as $operator) {
      $states[] = [
        ':input[name="options[operator]"]' => [
          'value' => $operator,
        ],
      ];
    }
    $form['expose']['min_placeholder']['#states']['visible'] = $states;
    $form['expose']['max_placeholder']['#states']['visible'] = $states;
    $form['expose']['placeholder'] = [
      '#type' => 'textfield',
      '#default_value' => $this->options['expose']['placeholder'],
      '#title' => $this
        ->t('Placeholder'),
      '#size' => 40,
      '#description' => $this
        ->t('Hint text that appears inside the field when empty.'),
    ];

    // Setup #states for all operators with one value.
    $form['expose']['placeholder']['#states']['visible'] = [
      [
        ':input[name="options[expose][use_operator]"]' => [
          'checked' => TRUE,
        ],
      ],
    ];
    foreach ($this
      ->operatorValues(1) as $operator) {
      $form['expose']['placeholder']['#states']['visible'][] = [
        ':input[name="options[operator]"]' => [
          'value' => $operator,
        ],
      ];
    }
  }
  public function operators() {
    $operators = [
      '<' => [
        'title' => $this
          ->t('Is less than'),
        'method' => 'opSimple',
        'short' => $this
          ->t('<'),
        'values' => 1,
      ],
      '<=' => [
        'title' => $this
          ->t('Is less than or equal to'),
        'method' => 'opSimple',
        'short' => $this
          ->t('<='),
        'values' => 1,
      ],
      '=' => [
        'title' => $this
          ->t('Is equal to'),
        'method' => 'opSimple',
        'short' => $this
          ->t('='),
        'values' => 1,
      ],
      '!=' => [
        'title' => $this
          ->t('Is not equal to'),
        'method' => 'opSimple',
        'short' => $this
          ->t('!='),
        'values' => 1,
      ],
      '>=' => [
        'title' => $this
          ->t('Is greater than or equal to'),
        'method' => 'opSimple',
        'short' => $this
          ->t('>='),
        'values' => 1,
      ],
      '>' => [
        'title' => $this
          ->t('Is greater than'),
        'method' => 'opSimple',
        'short' => $this
          ->t('>'),
        'values' => 1,
      ],
      'between' => [
        'title' => $this
          ->t('Is between'),
        'method' => 'opBetween',
        'short' => $this
          ->t('between'),
        'values' => 2,
      ],
      'not between' => [
        'title' => $this
          ->t('Is not between'),
        'method' => 'opBetween',
        'short' => $this
          ->t('not between'),
        'values' => 2,
      ],
      'regular_expression' => [
        'title' => $this
          ->t('Regular expression'),
        'short' => $this
          ->t('regex'),
        'method' => 'opRegex',
        'values' => 1,
      ],
    ];

    // 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;
  }

  /**
   * Provide a list of all the numeric operators.
   */
  public function operatorOptions($which = 'title') {
    $options = [];
    foreach ($this
      ->operators() as $id => $info) {
      $options[$id] = $info[$which];
    }
    return $options;
  }
  protected function operatorValues($values = 1) {
    $options = [];
    foreach ($this
      ->operators() as $id => $info) {
      if ($info['values'] == $values) {
        $options[] = $id;
      }
    }
    return $options;
  }

  /**
   * Provide a simple textfield for equality.
   */
  protected function valueForm(&$form, FormStateInterface $form_state) {
    $form['value']['#tree'] = TRUE;

    // We have to make some choices when creating this as an exposed
    // filter form. For example, if the operator is locked and thus
    // not rendered, we can't render dependencies; instead we only
    // render the form items we need.
    $which = 'all';
    if (!empty($form['operator'])) {
      $source = ':input[name="options[operator]"]';
    }
    if ($exposed = $form_state
      ->get('exposed')) {
      $identifier = $this->options['expose']['identifier'];
      if (empty($this->options['expose']['use_operator']) || empty($this->options['expose']['operator_id'])) {

        // exposed and locked.
        $which = in_array($this->operator, $this
          ->operatorValues(2)) ? 'minmax' : 'value';
      }
      else {
        $source = ':input[name="' . $this->options['expose']['operator_id'] . '"]';
      }
    }
    $user_input = $form_state
      ->getUserInput();
    if ($which == 'all') {
      $form['value']['value'] = [
        '#type' => 'textfield',
        '#title' => !$exposed ? $this
          ->t('Value') : '',
        '#size' => 30,
        '#default_value' => $this->value['value'],
      ];
      if (!empty($this->options['expose']['placeholder'])) {
        $form['value']['value']['#attributes']['placeholder'] = $this->options['expose']['placeholder'];
      }

      // Setup #states for all operators with one value.
      foreach ($this
        ->operatorValues(1) as $operator) {
        $form['value']['value']['#states']['visible'][] = [
          $source => [
            'value' => $operator,
          ],
        ];
      }
      if ($exposed && !isset($user_input[$identifier]['value'])) {
        $user_input[$identifier]['value'] = $this->value['value'];
        $form_state
          ->setUserInput($user_input);
      }
    }
    elseif ($which == 'value') {

      // When exposed we drop the value-value and just do value if
      // the operator is locked.
      $form['value'] = [
        '#type' => 'textfield',
        '#title' => !$exposed ? $this
          ->t('Value') : '',
        '#size' => 30,
        '#default_value' => $this->value['value'],
      ];
      if (!empty($this->options['expose']['placeholder'])) {
        $form['value']['#attributes']['placeholder'] = $this->options['expose']['placeholder'];
      }
      if ($exposed && !isset($user_input[$identifier])) {
        $user_input[$identifier] = $this->value['value'];
        $form_state
          ->setUserInput($user_input);
      }
    }

    // Minimum and maximum form fields are associated to some specific operators
    // like 'between'. Ensure that min and max fields are only visible if
    // the associated operator is not excluded from the operator list.
    $two_value_operators_available = $which == 'all' || $which == 'minmax';
    if (!empty($this->options['expose']['operator_limit_selection']) && !empty($this->options['expose']['operator_list'])) {
      $two_value_operators_available = FALSE;
      foreach ($this->options['expose']['operator_list'] as $operator) {
        if (in_array($operator, $this
          ->operatorValues(2), TRUE)) {
          $two_value_operators_available = TRUE;
          break;
        }
      }
    }
    if ($two_value_operators_available) {
      $form['value']['min'] = [
        '#type' => 'textfield',
        '#title' => $this
          ->t('Min'),
        '#size' => 30,
        '#default_value' => $this->value['min'],
      ];
      if (!empty($this->options['expose']['min_placeholder'])) {
        $form['value']['min']['#attributes']['placeholder'] = $this->options['expose']['min_placeholder'];
      }
      $form['value']['max'] = [
        '#type' => 'textfield',
        '#title' => $this
          ->t('Max'),
        '#size' => 30,
        '#default_value' => $this->value['max'],
      ];
      if (!empty($this->options['expose']['max_placeholder'])) {
        $form['value']['max']['#attributes']['placeholder'] = $this->options['expose']['max_placeholder'];
      }
      if ($which == 'all') {
        $states = [];

        // Setup #states for all operators with two values.
        foreach ($this
          ->operatorValues(2) as $operator) {
          $states['#states']['visible'][] = [
            $source => [
              'value' => $operator,
            ],
          ];
        }
        $form['value']['min'] += $states;
        $form['value']['max'] += $states;
      }
      if ($exposed && !isset($user_input[$identifier]['min'])) {
        $user_input[$identifier]['min'] = $this->value['min'];
      }
      if ($exposed && !isset($user_input[$identifier]['max'])) {
        $user_input[$identifier]['max'] = $this->value['max'];
      }
      if (!isset($form['value'])) {

        // Ensure there is something in the 'value'.
        $form['value'] = [
          '#type' => 'value',
          '#value' => NULL,
        ];
      }
    }
  }
  public function query() {
    $this
      ->ensureMyTable();
    $field = "{$this->tableAlias}.{$this->realField}";
    $info = $this
      ->operators();
    if (!empty($info[$this->operator]['method'])) {
      $this
        ->{$info[$this->operator]['method']}($field);
    }
  }

  /**
   * Filters by operator between.
   *
   * @param object $field
   *   The views field.
   */
  protected function opBetween($field) {
    if (is_numeric($this->value['min']) && is_numeric($this->value['max'])) {
      $operator = $this->operator == 'between' ? 'BETWEEN' : 'NOT BETWEEN';
      $this->query
        ->addWhere($this->options['group'], $field, [
        $this->value['min'],
        $this->value['max'],
      ], $operator);
    }
    elseif (is_numeric($this->value['min'])) {
      $operator = $this->operator == 'between' ? '>=' : '<';
      $this->query
        ->addWhere($this->options['group'], $field, $this->value['min'], $operator);
    }
    elseif (is_numeric($this->value['max'])) {
      $operator = $this->operator == 'between' ? '<=' : '>';
      $this->query
        ->addWhere($this->options['group'], $field, $this->value['max'], $operator);
    }
  }
  protected function opSimple($field) {
    $this->query
      ->addWhere($this->options['group'], $field, $this->value['value'], $this->operator);
  }
  protected function opEmpty($field) {
    if ($this->operator == 'empty') {
      $operator = "IS NULL";
    }
    else {
      $operator = "IS NOT NULL";
    }
    $this->query
      ->addWhere($this->options['group'], $field, NULL, $operator);
  }

  /**
   * Filters by a regular expression.
   *
   * @param string $field
   *   The expression pointing to the queries field, for example "foo.bar".
   */
  protected function opRegex($field) {
    $this->query
      ->addWhere($this->options['group'], $field, $this->value['value'], 'REGEXP');
  }
  public function adminSummary() {
    if ($this
      ->isAGroup()) {
      return $this
        ->t('grouped');
    }
    if (!empty($this->options['exposed'])) {
      return $this
        ->t('exposed');
    }
    $options = $this
      ->operatorOptions('short');
    $output = $options[$this->operator];
    if (in_array($this->operator, $this
      ->operatorValues(2))) {
      $output .= ' ' . $this
        ->t('@min and @max', [
        '@min' => $this->value['min'],
        '@max' => $this->value['max'],
      ]);
    }
    elseif (in_array($this->operator, $this
      ->operatorValues(1))) {
      $output .= ' ' . $this->value['value'];
    }
    return $output;
  }

  /**
   * Do some minor translation of the exposed input.
   */
  public function acceptExposedInput($input) {
    if (empty($this->options['exposed'])) {
      return TRUE;
    }

    // rewrite the input value so that it's in the correct format so that
    // the parent gets the right data.
    if (!empty($this->options['expose']['identifier'])) {
      $value =& $input[$this->options['expose']['identifier']];
      if (!is_array($value)) {
        $value = [
          'value' => $value,
        ];
      }
    }
    $rc = parent::acceptExposedInput($input);
    if (empty($this->options['expose']['required'])) {

      // We have to do some of our own checking for non-required filters.
      $info = $this
        ->operators();
      if (!empty($info[$this->operator]['values'])) {
        switch ($info[$this->operator]['values']) {
          case 1:
            if ($value['value'] === '') {
              return FALSE;
            }
            break;
          case 2:
            if ($value['min'] === '' && $value['max'] === '') {
              return FALSE;
            }
            break;
        }
      }
    }
    return $rc;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
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::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::validate public function 2
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
NumericFilter::$alwaysMultiple protected property Disable the possibility to force a single value. Overrides FilterPluginBase::$alwaysMultiple
NumericFilter::acceptExposedInput public function Do some minor translation of the exposed input. Overrides FilterPluginBase::acceptExposedInput 1
NumericFilter::adminSummary public function Display the filter on the administrative summary. Overrides FilterPluginBase::adminSummary
NumericFilter::buildExposeForm public function Options form subform for exposed filter options. Overrides FilterPluginBase::buildExposeForm
NumericFilter::defaultExposeOptions public function Provide default options for exposed filters. Overrides FilterPluginBase::defaultExposeOptions
NumericFilter::defineOptions protected function Overrides FilterPluginBase::defineOptions 1
NumericFilter::opBetween protected function Filters by operator between. 2
NumericFilter::opEmpty protected function 1
NumericFilter::operatorOptions public function Provide a list of all the numeric operators. Overrides FilterPluginBase::operatorOptions
NumericFilter::operators public function
NumericFilter::operatorValues protected function
NumericFilter::opRegex protected function Filters by a regular expression.
NumericFilter::opSimple protected function 2
NumericFilter::query public function Add this filter to the query. Overrides FilterPluginBase::query 2
NumericFilter::valueForm protected function Provide a simple textfield for equality. Overrides FilterPluginBase::valueForm 1