View source
<?php
namespace Drupal\efq_views\Plugin\views\filter;
use Drupal\Core\Form\FormStateInterface;
use Drupal\views\Plugin\views\display\DisplayPluginBase;
use Drupal\views\ViewExecutable;
class TermReference extends FieldInOperator {
var $validated_exposed_input = NULL;
public function init(ViewExecutable $view, DisplayPluginBase $display, array &$options = NULL) {
parent::init($view, $options);
if (!empty($this->definition['vocabulary'])) {
$this->options['vocabulary'] = $this->definition['vocabulary'];
}
}
public function hasExtraOptions() {
return TRUE;
}
public function getValueOptions() {
}
protected function defineOptions() {
$options = parent::defineOptions();
$options['type'] = array(
'default' => 'textfield',
);
$options['limit'] = array(
'default' => TRUE,
'bool' => TRUE,
);
$options['vocabulary'] = array(
'default' => 0,
);
$options['error_message'] = array(
'default' => TRUE,
'bool' => TRUE,
);
return $options;
}
public function buildExtraOptionsForm(&$form, FormStateInterface $form_state) {
$vocabularies = taxonomy_get_vocabularies();
$options = array();
foreach ($vocabularies as $voc) {
$options[$voc->machine_name] = check_plain($voc->name);
}
if ($this->options['limit']) {
if (empty($this->options['vocabulary'])) {
$first_vocabulary = reset($vocabularies);
$this->options['vocabulary'] = $first_vocabulary->machine_name;
}
if (empty($this->definition['vocabulary'])) {
$form['vocabulary'] = array(
'#type' => 'radios',
'#title' => t('Vocabulary'),
'#options' => $options,
'#description' => t('Select which vocabulary to show terms for in the regular options.'),
'#default_value' => $this->options['vocabulary'],
);
}
}
$form['type'] = array(
'#type' => 'radios',
'#title' => t('Selection type'),
'#options' => array(
'select' => t('Dropdown'),
'textfield' => t('Autocomplete'),
),
'#default_value' => $this->options['type'],
);
}
protected function valueForm(&$form, FormStateInterface $form_state) {
$vocabulary = taxonomy_vocabulary_machine_name_load($this->options['vocabulary']);
if (empty($vocabulary) && $this->options['limit']) {
$form['markup'] = array(
'#markup' => '<div class="form-item">' . t('An invalid vocabulary is selected. Please change it in the options.') . '</div>',
);
return;
}
if ($this->options['type'] == 'textfield') {
$default = '';
if ($this->value) {
$query = new EntityFieldQuery();
$result = $query
->entityCondition('entity_type', 'taxonomy_term')
->entityCondition('entity_id', $this->value)
->execute();
if (!empty($result['taxonomy_term'])) {
$terms = entity_load('taxonomy_term', array_keys($result['taxonomy_term']));
foreach ($terms as $term) {
if ($default) {
$default .= ', ';
}
$default .= $term->name;
}
}
}
$form['value'] = array(
'#title' => t('Select terms from vocabulary @voc', array(
'@voc' => $vocabulary->name,
)),
'#type' => 'textfield',
'#default_value' => $default,
);
if ($this->options['limit']) {
$form['value']['#autocomplete_path'] = 'admin/views/ajax/autocomplete/taxonomy/' . $vocabulary->vid;
}
}
else {
$options = array();
$query = new EntityFieldQuery();
$query
->entityCondition('entity_type', 'taxonomy_term');
if ($this->options['limit']) {
$query
->propertyCondition('vid', (int) $vocabulary->vid);
}
$result = $query
->execute();
if (!empty($result['taxonomy_term'])) {
$terms = entity_load('taxonomy_term', array_keys($result['taxonomy_term']));
foreach ($terms as $term) {
$options[$term->tid] = $term->name;
}
}
$default_value = (array) $this->value;
if (!empty($form_state['exposed'])) {
$identifier = $this->options['expose']['identifier'];
if (!empty($this->options['expose']['reduce'])) {
$options = $this
->reduce_valueOptions($options);
if (!empty($this->options['expose']['multiple']) && empty($this->options['expose']['required'])) {
$default_value = array();
}
}
if (empty($this->options['expose']['multiple'])) {
if (empty($this->options['expose']['required']) && (empty($default_value) || !empty($this->options['expose']['reduce']))) {
$default_value = 'All';
}
elseif (empty($default_value)) {
$keys = array_keys($options);
$default_value = array_shift($keys);
}
else {
$copy = $default_value;
$default_value = array_shift($copy);
}
}
}
$form['value'] = array(
'#type' => 'select',
'#title' => $this->options['limit'] ? t('Select terms from vocabulary @voc', array(
'@voc' => $vocabulary->name,
)) : t('Select terms'),
'#multiple' => TRUE,
'#options' => $options,
'#size' => min(9, count($options)),
'#default_value' => $default_value,
);
if (!empty($form_state['exposed']) && isset($identifier) && !isset($form_state['input'][$identifier])) {
$form_state['input'][$identifier] = $default_value;
}
}
}
protected function valueValidate($form, FormStateInterface $form_state) {
if ($this->options['type'] != 'textfield') {
return;
}
$values = drupal_explode_tags($form_state['values']['options']['value']);
$tids = $this
->validateTermStrings($form['value'], $values);
if ($tids) {
$form_state['values']['options']['value'] = $tids;
}
}
public function acceptExposedInput($input) {
if (empty($this->options['exposed'])) {
return TRUE;
}
if (!empty($this->view->is_attachment) && $this->view->display_handler
->uses_exposed()) {
$this->validated_exposed_input = (array) $this->view->exposed_raw_input[$this->options['expose']['identifier']];
}
if (!$this->options['expose']['required'] && empty($this->validated_exposed_input)) {
return FALSE;
}
$rc = parent::acceptExposedInput($input);
if ($rc) {
if (isset($this->validated_exposed_input)) {
$this->value = $this->validated_exposed_input;
}
}
return $rc;
}
public function validateExposed(&$form, FormStateInterface $form_state) {
if (empty($this->options['exposed'])) {
return;
}
$identifier = $this->options['expose']['identifier'];
if ($this->options['type'] != 'textfield') {
if ($form_state['values'][$identifier] != 'All') {
$this->validated_exposed_input = (array) $form_state['values'][$identifier];
}
return;
}
if (empty($this->options['expose']['identifier'])) {
return;
}
$values = drupal_explode_tags($form_state['values'][$identifier]);
$tids = $this
->validateTermStrings($form[$identifier], $values);
if ($tids) {
$this->validated_exposed_input = $tids;
}
}
function validateTermStrings(&$form, $values) {
if (empty($values)) {
return array();
}
$vocabulary = taxonomy_vocabulary_machine_name_load($this->options['vocabulary']);
$tids = array();
$names = array();
$missing = array();
foreach ($values as $value) {
$missing[strtolower($value)] = TRUE;
$names[] = $value;
}
if (!$names) {
return FALSE;
}
$query = new EntityFieldQuery();
$result = $query
->entityCondition('entity_type', 'taxonomy_term')
->propertyCondition('vid', (int) $vocabulary->vid)
->propertyCondition('name', $names)
->execute();
if (!empty($result['taxonomy_term'])) {
$terms = entity_load('taxonomy_term', array_keys($result['taxonomy_term']));
foreach ($terms as $term) {
unset($missing[strtolower($term->name)]);
$tids[] = $term->tid;
}
}
if ($missing && !empty($this->options['error_message'])) {
form_error($form, format_plural(count($missing), 'Unable to find term: @terms', 'Unable to find terms: @terms', array(
'@terms' => implode(', ', array_keys($missing)),
)));
}
elseif ($missing && empty($this->options['error_message'])) {
$tids = array(
0,
);
}
return $tids;
}
function valueSubmit($form, &$form_state) {
}
function buildExposeForm(&$form, FormStateInterface $form_state) {
parent::buildExposeForm($form, $form_state);
if ($this->options['type'] != 'select') {
unset($form['expose']['reduce']);
}
$form['error_message'] = array(
'#type' => 'checkbox',
'#title' => t('Display error message'),
'#default_value' => !empty($this->options['error_message']),
);
}
function adminSummary() {
$this->valueOptions = array();
if ($this->value) {
$this->value = array_filter($this->value);
$query = new EntityFieldQuery();
$result = $query
->entityCondition('entity_type', 'taxonomy_term')
->entityCondition('entity_id', $this->value)
->execute();
if (!empty($result['taxonomy_term'])) {
$terms = entity_load('taxonomy_term', array_keys($result['taxonomy_term']));
foreach ($terms as $term) {
$this->valueOptions[$term->tid] = $term->name;
}
}
}
return parent::adminSummary();
}
}