How to write a custom Views 3 filter handler

It's still very messy and far from production state, but here it is :

/**
 * Simple filter to handle greater than/less than filters
 */
class interval_select_handler_filter_interval extends views_handler_filter_numeric {
  var $always_multiple = TRUE;
  function option_definition() {
    $options = parent::option_definition();

    $options['value'] = array(
      'contains' => array(
        'min' => array('default' => ''),
        'max' => array('default' => ''),
        'value' => array('default' => ''),
      ),
    );

    return $options;
  }

  function operators() {
    $operators = array(
      'between' => array(
        'title' => t('Is between'),
        'method' => 'op_between',
        'short' => t('between'),
        'values' => 2,
      ),
      'not between' => array(
        'title' => t('Is not between'),
        'method' => 'op_between',
        'short' => t('not between'),
        'values' => 2,
      ),
    );

    // if the definition allows for the empty operator, add it.
    if (!empty($this->definition['allow empty'])) {
      $operators += array(
        'empty' => array(
          'title' => t('Is empty (NULL)'),
          'method' => 'op_empty',
          'short' => t('empty'),
          'values' => 0,
        ),
        'not empty' => array(
          'title' => t('Is not empty (NOT NULL)'),
          'method' => 'op_empty',
          'short' => t('not empty'),
          'values' => 0,
        ),
      );
    }

    return $operators;
  }

  /**
   * Provide a list of all the numeric operators
   */
  function operator_options($which = 'title') {
    $options = array();
    foreach ($this->operators() as $id => $info) {
      $options[$id] = $info[$which];
    }

    return $options;
  }

  function operator_values($values = 1) {
    $options = array();
    foreach ($this->operators() as $id => $info) {
      if ($info['values'] == $values) {
        $options[] = $id;
      }
    }

    return $options;
  }
  /**
   * Provide a simple textfield for equality
   */
  function value_form(&$form, &$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 = ($form['operator']['#type'] == 'radios') ? 'radio:options[operator]' : 'edit-options-operator';
    }

    if (!empty($form_state['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->operator_values(2)) ? 'minmax' : 'value';
      }
      else {
        $source = 'edit-' . drupal_html_id($this->options['expose']['operator_id']);
      }
    }

    if ($which == 'all') {
      $form['value']['value'] = array(
        '#type' => 'textfield',
        '#title' => empty($form_state['exposed']) ? t('Value') : '',
        '#size' => 30,
        '#default_value' => $this->value['value'],
        '#dependency' => array($source => $this->operator_values(1)),
      );
      if (!empty($form_state['exposed']) && !isset($form_state['input'][$identifier]['value'])) {
        $form_state['input'][$identifier]['value'] = $this->value['value'];
      }
    }
    elseif ($which == 'value') {
      // When exposed we drop the value-value and just do value if
      // the operator is locked.
      $form['value'] = array(
        '#type' => 'textfield',
        '#title' => empty($form_state['exposed']) ? t('Value') : '',
        '#size' => 30,
        '#default_value' => $this->value['value'],
      );
      if (!empty($form_state['exposed']) && !isset($form_state['input'][$identifier])) {
        $form_state['input'][$identifier] = $this->value['value'];
      }
    }

    if ($which == 'all' || $which == 'minmax') {
        $tranches_prix = array(
          10000000 => 'Indifférent',
          100000 => '< 100 000 €',
          200000 => '100 000 € - 200 000 €',
          300000 => '200 000 € - 300 000 €',
          400000 => '300 000 € - 400 000 €',
          500000 => '> 400 000 €',
        );
      
      $form['value']['interval'] = array(
        '#type' => 'select',
        '#title' => 'Entre :',
//        '#size' => 30,
        '#options' => $tranches_prix,
//        '#default_value' => $this->value['min'],
      );
      $form['value']['min'] = array(
        '#type' => 'textfield',
        '#title' => empty($form_state['exposed']) ? t('Min') : '',
        '#size' => 30,
        '#default_value' => $this->value['min'],
      );
      $form['value']['max'] = array(
        '#type' => 'textfield',
        '#title' => empty($form_state['exposed']) ? t('And max') : t('And'),
        '#size' => 30,
        '#default_value' => $this->value['max'],
      );
      if ($which == 'all') {
        $dependency = array(
          '#dependency' => array($source => $this->operator_values(2)),
        );
        $form['value']['min'] += $dependency;
        $form['value']['max'] += $dependency;
      }
      if (!empty($form_state['exposed']) && !isset($form_state['input'][$identifier]['min'])) {
        $form_state['input'][$identifier]['min'] = $this->value['min'];
      }
      if (!empty($form_state['exposed']) && !isset($form_state['input'][$identifier]['max'])) {
        $form_state['input'][$identifier]['max'] = $this->value['max'];
      }

      if (!isset($form['value'])) {
        // Ensure there is something in the 'value'.
        $form['value'] = array(
          '#type' => 'value',
          '#value' => NULL
        );
      }
    }
  }

  function query() {
    $this->ensure_my_table();
    $field = "$this->table_alias.$this->real_field";

    $info = $this->operators();
    if (!empty($info[$this->operator]['method'])) {
      $this->{$info[$this->operator]['method']}($field);
    }
  }

  function op_between($field) {
    // A changer pour intervalle
//          10000000 => 'Indifférent',
//          100000 => '< 100 000 €',
//          200000 => '100 000 € - 200 000 €',
//          300000 => '200 000 € - 300 000 €',
//          400000 => '300 000 € - 400 000 €',
//          500000 => '> 400 000 €',
//dsm($this->value['interval']);
    switch ($this->value['interval']) {
      case 10000000:
        $min = 0;
        $max = 10000000;
        break;
      case 100000:
        $min = 0;
        $max = 100000;
        break;
      case 200000:
        $min = 100000;
        $max = 200000;
        break;
      case 300000:
        $min = 200000;
        $max = 300000;
        break;
      case 400000:
        $min = 300000;
        $max = 400000;
        break;
      case 500000:
        $min = 500000;
        $max = 10000000;
        break;        
    }
    if ($this->operator == 'between') {
      $this->query->add_where($this->options['group'], $field, array($min, $max), 'BETWEEN');
    }
    else {
      $this->query->add_where($this->options['group'], db_or()->condition($field, $this->value['min'], '<=')->condition($field, $this->value['max'], '>='));
    }
  }

  function op_simple($field) {
    $this->query->add_where($this->options['group'], $field, $this->value['value'], $this->operator);
  }

  function op_empty($field) {
    if ($this->operator == 'empty') {
      $operator = "IS NULL";
    }
    else {
      $operator = "IS NOT NULL";
    }

    $this->query->add_where($this->options['group'], $field, NULL, $operator);
  }

  function admin_summary() {
    if (!empty($this->options['exposed'])) {
      return t('exposed');
    }

    $options = $this->operator_options('short');
    $output = check_plain($options[$this->operator]);
    if (in_array($this->operator, $this->operator_values(2))) {
      $output .= ' ' . t('@min and @max', array('@min' => $this->value['min'], '@max' => $this->value['max']));
    }
    elseif (in_array($this->operator, $this->operator_values(1))) {
      $output .= ' ' . check_plain($this->value['value']);
    }
    return $output;
  }

  /**
   * Do some minor translation of the exposed input
   */
  function accept_exposed_input($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 = array(
          'value' => $value,
        );
      }
    }

    $rc = parent::accept_exposed_input($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;
  }
}

It's basicaly a cut and paste from the original handler. The query seems correct except for the wrong field :

SELECT node.title AS node_title, node.nid AS nid, node.created AS node_created, 'node' AS field_data_field_pv_node_entity_type
FROM 
{node} node
WHERE (( (node.status = '1') AND (node.type IN  ('annonce')) AND (node.field_pv_value BETWEEN '200000' AND '300000') ))
ORDER BY node_created DESC

I tried this code :

  $data['field_data_field_pv']['field_pv_value'] = array(    
    'group' => t('Annonce'),
    'title' => t('Prix de vente du bien'),
    'help' => t('Filtrer sur intervalles de prix.'), // The help that appears on the UI,  
    'real field' => 'field_pv_value',
    'filter' => array(
      'handler' => 'interval_select_handler_filter_interval',
    ),    
  );

... simply replacing 'node' with the field's table name, and got this error :

Warning : class_exists() expects parameter 1 to be string, array given dans _views_create_handler() (ligne 22 dans /srv/sites/web59/web/sites/all/modules/views/includes/handlers.inc).

... repeated four times.

It worked ! And in the meantime, I understood something new : I really thought hook_views_data was mandatory for any handler.

For the record, here's the definitive code I placed in my .views.inc:

function interval_select_views_data_alter(&$data) {
  $data['field_data_field_pv']['prix'] = array(
    'title' => t('Prix'),
    'group' => 'Annonces',
    'help' => t('Le prix de vente'),
   'real field' => 'field_pv_value',
   'filter' => array(
      'handler' => 'interval_select_handler_filter_interval',
    ),        
  );    
}

Thanks a lot for your time.

As usual, I'm amazed at the same time at how the solution was elegant and how hard it was to find the info.

Sorry to reopen (kind of), but I have another problem : I stumble on the 'An illegal choice has been detected' issue filed here http://drupal.org/node/1177882.

I suspect my select lists are causing the trouble. They're produced that way (same as above, just repeating for convenience) in the value_form method :

    if ($which == 'all' || $which == 'minmax') {
        $tranches = array(
          10000000 => 'Any',
          100000 => '< 100 000 €',
          200000 => '100 000 € - 200 000 €',
          300000 => '200 000 € - 300 000 €',
          400000 => '300 000 € - 400 000 €',
          500000 => '> 400 000 €',
        );
      $form['value']['interval'] = array(
        '#type' => 'select',
        '#title' => ' ',
        '#options' => $tranches,
      );

And here is the op_between method overwritten by my handler :

  function op_between($field) {
        $min = 0;
        $max = 10000000;
        switch ($this->value['interval']) {
          case 10000000:
            $min = 0;
            $max = 10000000;
            break;
          case 100000:
            $min = 0;
            $max = 100000;
            break;
          case 200000:
            $min = 100000;
            $max = 200000;
            break;
          case 300000:
            $min = 200000;
            $max = 300000;
            break;
          case 400000:
            $min = 300000;
            $max = 400000;
            break;
          case 500000:
            $min = 400000;
            $max = 10000000;
            break;        
        }
      $this->query->add_where($this->options['group'], $field, array($min, $max), 'BETWEEN');
  }

I couldn't grep the message in Views code to see what triggers it.

The view works fine otherwise, except it seems to limit the results even if the default choice of 'Any' ('Indifférent' in french) is chosen in the list.

I noticed that my selects don't get the 'Any' value, so I looked into exposed_translate in views_handler_filter.inc.

If I comment this part :

    if ($type == 'value' && empty($this->always_required) && empty($this->options['expose']['required']) && $form['#type'] == 'select' && empty($form['#multiple'])) {
      $any_label = variable_get('views_exposed_filter_any_label', 'new_any') == 'old_any' ? t('<Any>') : t('- Any -');
      $form['#options'] = array('All' => $any_label) + $form['#options'];
      $form['#default_value'] = 'All';
    }

... the view generates one more message. What's strange is that dpm'ing $form['#options'] never outputs my custon filters but does print info about regular ones (mean : normal filters based on select widget fields).

So, the message is related to my issue, but the code doesn't seem to affect the custom selects.

Not sure about anything now ; I'm just trying to help people helping me.

Progressed a bit : One of my two very similar filters was causing the loss of records, because null values are not considered. So the issue actually splits in two, but all two problems are about filter handlers writing, so I'm sticking with this issue alone.

Here are the two issues :

1 - How to modify the query in case of a select widget filter to add an OR clause to pull rows with NULL values for the field ?

2 - How to explain, and get rid of, the error message 'An illegal choice was detected etc.' ?

Hope it's clear and interesting enough to obtain help from experimented views devs.

For point 1, I managed to condition the add_where to fit my needs, and saw some examples of adding OR clauses elsewhere in the code. Just for the record it's done like that :

      $this->query->add_where($this->options['group'], db_or()->condition($field, $this->value['min'], '<=')->condition($field, $this->value['max'], '>='));

So only the "Illegal choice" message needs to be explained, given it doesn't seem to prevent the view from functioning, except for the preview and th annoying message.

Putting this issue back to 'Support Request' until some kind of answer is given, or until a maintainer wants to discard it.

Here is the module. It's very case specific, so please don't take it for anything pretending to be universal.

Another information : when I set the filter values to be remembered, they are not.

After further investigation, including dumping info from form.inc, I'm pretty sure this has something to do with my handler not providing a default value.

If I set the #value in value_form, the error disappears. Of course, it's not a solution because then the filter always behaves like the user had entered the value I set, but it's the best hint I got yet.

So I'm gonna look at the original handler code and try to figure what method I should override to provide a default value. Any clue would be welcome as I'm at the very limit of my skills here.

Sorry but I'm not sure where to put this code.

Well, I just added an ['interval'] element and try to manage it as I can. As I don't really understand the processing of all this, it's hit and miss.

Setting something in option_definition doesn't seem to do any good.

I tried

    $options['value']['interval'] = array(
      'contains' => array(
        'value' => array('default' => 10000000),
      ),
    );

But it doesn't work either. I'm a bit lost.

Before your post, I was reduced to comment the form validating code in form.inc. I know it's genocidal from a kitten point of view, but the view works perfectly that way. I can't of course go production with this but it'll have to do as of now.

If you'd be glad enough to explain to me the basics of default values in filter handlers, I could try to do something, but as of now I'm clueless.

I tried various combinations with this array and cannot change anything. Even removing it entirely dosn't affect the handler's behavior.

I looked into the code of many (MANY) other handlers and couln't figure out how these defaults are handled. Googling about filters handlers led me to examples but no really meaningful explanation.

So I'll stick with my kitten slaughtering solution as of now and see if I can wrap my mind around this problem next week.

Thanks for your help.

It's been a while now, but if I remember correctly, kittens got killed in the process, because I couldn't figure out how to implement the correct default values.