View source
<?php
namespace Drupal\views_autocomplete_filters\Controller;
use Drupal\Component\Utility\Html;
use Drupal\Component\Utility\Unicode;
use Drupal\Component\Utility\Xss;
use Drupal\Core\Access\AccessResult;
use Drupal\Core\DependencyInjection\ContainerInjectionInterface;
use Drupal\views\Plugin\views\display\DisplayPluginBase;
use Drupal\views\ViewExecutable;
use Drupal\views\Views;
use Psr\Log\LoggerInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
class ViewsAutocompleteFiltersController implements ContainerInjectionInterface {
protected $logger;
public function __construct(LoggerInterface $logger) {
$this->logger = $logger;
}
public static function create(ContainerInterface $container) {
return new static($container
->get('logger.factory')
->get('views_autocomplete_filters'));
}
public function access($view_name, $view_display) {
$view = Views::getView($view_name);
if ($view
->access($view_display)) {
return AccessResult::allowed();
}
return AccessResult::forbidden();
}
public function autocomplete(Request $request, $view_name, $view_display, $filter_name, $view_args) {
$matches = $field_names = [];
$string = $request->query
->get('q');
$view = Views::getView($view_name);
$view
->setDisplay($view_display);
if (!empty($view_args)) {
$view
->setArguments(explode('||', $view_args));
}
$display_handler = $view->display_handler;
$arguments = $display_handler
->getOption('arguments');
if (!empty($arguments)) {
foreach ($arguments as $k => $argument) {
$arguments[$k]['default_action'] = 'ignore';
}
$display_handler
->setOption('arguments', $arguments);
}
$filters = $display_handler
->getOption('filters');
if (empty($filters[$filter_name]['exposed']) || empty($filters[$filter_name]['expose']['autocomplete_filter'])) {
throw new NotFoundHttpException();
}
$current_filter = $filters[$filter_name];
$expose_options = $current_filter['expose'];
if (strlen(trim($string)) < $expose_options['autocomplete_min_chars']) {
return new JsonResponse($matches);
}
if (empty($expose_options['autocomplete_field']) && !empty($current_filter['name'])) {
if ($view
->getHandler($view->current_display, 'field', $filters[$filter_name]['id'])) {
$field_names = [
[
$filter_name,
]['id'],
];
$expose_options['autocomplete_raw_suggestion'] = 1;
$expose_options['autocomplete_raw_dropdown'] = 1;
}
else {
$this->logger
->error('Field for autocomplete filter %label is not set in view %view, display %display', [
'%label' => $expose_options['label'],
'%view' => $view
->id(),
'%display' => $view->current_display,
]);
return new JsonResponse($matches);
}
}
elseif (!empty($expose_options['autocomplete_field'])) {
$field_names = [
$expose_options['autocomplete_field'],
];
}
elseif (!empty($current_filter['fields'])) {
$field_names = array_keys($current_filter['fields']);
}
foreach ($field_names as $field_name) {
$field_options = $view
->getHandler($view->current_display, 'field', $field_name);
if (empty($field_options)) {
$this->logger
->error('Field for autocomplete filter %label not exists in view %view, display %display', [
'%label' => $expose_options['label'],
'%view' => $view
->id(),
'%display' => $view->current_display,
]);
return new JsonResponse($matches);
}
}
$view
->setExposedInput($this
->getExposedInput($view, $request, $expose_options));
$display_handler
->setOption('cache', [
'type' => 'none',
]);
if (empty($expose_options['autocomplete_items'])) {
$pager_type = 'none';
}
else {
$pager_type = 'some';
}
$pager = [
'type' => $pager_type,
'options' => [
'items_per_page' => $expose_options['autocomplete_items'],
'offset' => 0,
],
];
$display_handler
->setOption('pager', $pager);
$view
->preExecute();
$view
->execute();
$view
->postExecute();
$display_handler = $view->display_handler;
$use_raw_suggestion = !empty($expose_options['autocomplete_raw_suggestion']);
$use_raw_dropdown = !empty($expose_options['autocomplete_raw_dropdown']);
$view->row_index = 0;
foreach ($view->result as $index => $row) {
$view->row_index = $index;
$style_plugin = $display_handler
->getPlugin('style');
foreach ($field_names as $field_name) {
$rendered_field = $raw_field = '';
if (!$use_raw_suggestion || !$use_raw_dropdown) {
$rendered_field = $style_plugin
->getField($index, $field_name);
}
if ($use_raw_suggestion || $use_raw_dropdown) {
$raw_field = $style_plugin
->getFieldValue($index, $field_name);
if (!is_array($raw_field)) {
$raw_field = [
[
'value' => $raw_field,
],
];
}
else {
$raw_field_items = $raw_field;
$raw_field = [];
foreach ($raw_field_items as $raw_field_item) {
$raw_field[] = [
'value' => $raw_field_item,
];
}
}
}
if (empty($raw_field) && !empty($rendered_field)) {
$raw_field = [
[
'value' => $rendered_field,
],
];
}
if (is_array($raw_field)) {
foreach ($raw_field as $delta => $item) {
if (isset($item['value']) && strstr(mb_strtolower($item['value']), mb_strtolower($string))) {
$dropdown = $use_raw_dropdown ? Html::escape($item['value']) : $rendered_field;
if ($dropdown != '') {
if ($use_raw_suggestion) {
$suggestion = Unicode::truncate(Html::escape($item['value']), 128);
}
else {
$suggestion = Unicode::truncate(Xss::filter($rendered_field, []), 128);
}
$suggestion = Html::decodeEntities($suggestion);
$matches[] = [
'value' => $suggestion,
'label' => $dropdown,
];
}
}
}
}
}
}
unset($view->row_index);
if (!empty($matches)) {
$matches = array_values(array_unique($matches, SORT_REGULAR));
}
return new JsonResponse($matches);
}
protected function getExposedInput(ViewExecutable $view, Request $request, array $expose_options) {
$display_handler = $view->display_handler;
$filters = $display_handler
->getOption('filters');
if (!empty($expose_options['autocomplete_dependent'])) {
$exposed_input = $view
->getExposedInput();
}
else {
$exposed_input = [];
foreach ($display_handler
->getOption('filters') as $name => $filter) {
if (!empty($filters[$name]['exposed'])) {
if (!empty($filter['is_grouped'])) {
$filters[$name]['group_info']['default_group'] = 'All';
}
$filters[$name]['value'] = [];
}
}
$display_handler
->setOption('filters', $filters);
}
$exposed_input[$expose_options['identifier']] = $request->query
->get('q');
return $exposed_input;
}
}