handler_filter_entity.inc in Search API 7

Contains SearchApiViewsHandlerFilterEntity.

File

contrib/search_api_views/includes/handler_filter_entity.inc

<?php

/**
 * @file
 * Contains SearchApiViewsHandlerFilterEntity.
 */

/**
 * Views filter handler class for entities.
 *
 * Should be extended for specific entity types, such as
 * SearchApiViewsHandlerFilterUser and SearchApiViewsHandlerFilterTaxonomyTerm.
 *
 * Based on views_handler_filter_term_node_tid.
 */
abstract class SearchApiViewsHandlerFilterEntity extends SearchApiViewsHandlerFilter {

  /**
   * If exposed form input was successfully validated, the entered entity IDs.
   *
   * @var array
   */
  protected $validated_exposed_input;

  /**
   * Validates entered entity labels and converts them to entity IDs.
   *
   * Since this can come from either the form or the exposed filter, this is
   * abstracted out a bit so it can handle the multiple input sources.
   *
   * @param array $form
   *   The form or form element for which any errors should be set.
   * @param array $values
   *   The entered user names to validate.
   *
   * @return array
   *   The entity IDs corresponding to all entities that could be found.
   */
  protected abstract function validate_entity_strings(array &$form, array $values);

  /**
   * Transforms an array of entity IDs into a comma-separated list of labels.
   *
   * @param array $ids
   *   The entity IDs to transform.
   *
   * @return string
   *   A string containing the labels corresponding to the IDs, separated by
   *   commas.
   */
  protected abstract function ids_to_strings(array $ids);

  /**
   * {@inheritdoc}
   */
  public function operator_options() {
    $operators = array(
      '=' => $this
        ->isMultiValued() ? t('Is one of') : t('Is'),
      'all of' => t('Is all of'),
      '<>' => $this
        ->isMultiValued() ? t('Is not one of') : t('Is not'),
      'empty' => t('Is empty'),
      'not empty' => t('Is not empty'),
    );
    if (!$this
      ->isMultiValued()) {
      unset($operators['all of']);
    }
    return $operators;
  }

  /**
   * {@inheritdoc}
   */
  public function value_form(&$form, &$form_state) {
    parent::value_form($form, $form_state);
    if (!is_array($this->value)) {
      $this->value = $this->value ? array(
        $this->value,
      ) : array();
    }

    // Set the correct default value in case the admin-set value is used (and a
    // value is present). The value is used if the form is either not exposed,
    // or the exposed form wasn't submitted yet. (There doesn't seem to be an
    // easier way to check for that.)
    if ($this->value && (empty($form_state['input']) || !empty($form_state['input']['live_preview']))) {
      $form['value']['#default_value'] = $this
        ->ids_to_strings($this->value);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function value_validate($form, &$form_state) {
    if (!empty($form['value'])) {
      $value =& $form_state['values']['options']['value'];
      if (strlen($value)) {
        $values = $this
          ->isMultiValued($form_state['values']['options']) ? drupal_explode_tags($value) : array(
          $value,
        );
        $ids = $this
          ->validate_entity_strings($form['value'], $values);
        if ($ids) {
          $value = $ids;
        }
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function accept_exposed_input($input) {
    $rc = parent::accept_exposed_input($input);
    if ($rc) {

      // If we have previously validated input, override.
      if ($this->validated_exposed_input) {
        $this->value = $this->validated_exposed_input;
      }
    }
    return $rc;
  }

  /**
   * {@inheritdoc}
   */
  public function exposed_validate(&$form, &$form_state) {
    if (empty($this->options['exposed']) || empty($this->options['expose']['identifier'])) {
      return;
    }
    $this->validated_exposed_input = FALSE;
    $identifier = $this->options['expose']['identifier'];
    $input = $form_state['values'][$identifier];
    if ($this->options['is_grouped'] && isset($this->options['group_info']['group_items'][$input])) {
      $this->operator = $this->options['group_info']['group_items'][$input]['operator'];
      $input = $this->options['group_info']['group_items'][$input]['value'];
    }
    if (!strlen($input)) {
      return;
    }
    $values = $this
      ->isMultiValued() ? drupal_explode_tags($input) : array(
      $input,
    );
    if (!$this->options['is_grouped'] || $this->options['is_grouped'] && $input != 'All') {
      $this->validated_exposed_input = $this
        ->validate_entity_strings($form[$identifier], $values);
    }
  }

  /**
   * Determines whether multiple user names can be entered into this filter.
   *
   * This is either the case if the form isn't exposed, or if the " Allow
   * multiple selections" option is enabled.
   *
   * @param array $options
   *   (optional) The options array to use. If not supplied, the options set on
   *   this filter will be used.
   *
   * @return bool
   *   TRUE if multiple values can be entered for this filter, FALSE otherwise.
   */
  protected function isMultiValued(array $options = array()) {
    $options = $options ? $options : $this->options;
    return empty($options['exposed']) || !empty($options['expose']['multiple']);
  }

  /**
   * {@inheritdoc}
   */
  public function admin_summary() {
    if (!is_array($this->value)) {
      $this->value = $this->value ? array(
        $this->value,
      ) : array();
    }
    $value = $this->value;
    $this->value = empty($value) ? '' : $this
      ->ids_to_strings($value);
    $ret = parent::admin_summary();
    $this->value = $value;
    return $ret;
  }

  /**
   * {@inheritdoc}
   */
  public function query() {
    if ($this->operator === 'empty') {
      $this->query
        ->condition($this->real_field, NULL, '=', $this->options['group']);
    }
    elseif ($this->operator === 'not empty') {
      $this->query
        ->condition($this->real_field, NULL, '<>', $this->options['group']);
    }
    elseif (is_array($this->value)) {
      $all_of = $this->operator === 'all of';
      $operator = $all_of ? '=' : $this->operator;
      if (count($this->value) == 1) {
        $this->query
          ->condition($this->real_field, reset($this->value), $operator, $this->options['group']);
      }
      else {
        $filter = $this->query
          ->createFilter($operator === '<>' || $all_of ? 'AND' : 'OR');
        foreach ($this->value as $value) {
          $filter
            ->condition($this->real_field, $value, $operator);
        }
        $this->query
          ->filter($filter, $this->options['group']);
      }
    }
  }

}

Classes

Name	Description
SearchApiViewsHandlerFilterEntity	Views filter handler class for entities.