class NodeSearch in Drupal 9

Same name and namespace in other branches

8 core/modules/node/src/Plugin/Search/NodeSearch.php \Drupal\node\Plugin\Search\NodeSearch

Handles searching for node entities using the Search module index.

Plugin annotation


@SearchPlugin(
  id = "node_search",
  title = @Translation("Content")
)

Hierarchy

class \Drupal\Component\Plugin\PluginBase implements DerivativeInspectionInterface, PluginInspectionInterface
- class \Drupal\Core\Plugin\PluginBase uses DependencySerializationTrait, MessengerTrait, StringTranslationTrait
  - class \Drupal\search\Plugin\SearchPluginBase implements RefinableCacheableDependencyInterface, ContainerFactoryPluginInterface, SearchInterface uses RefinableCacheableDependencyTrait
    class \Drupal\search\Plugin\ConfigurableSearchPluginBase implements ConfigurableSearchPluginInterface
    class \Drupal\node\Plugin\Search\NodeSearch implements AccessibleInterface, TrustedCallbackInterface, SearchIndexingInterface

Expanded class hierarchy of NodeSearch

File

core/modules/node/src/Plugin/Search/NodeSearch.php, line 37

Namespace

Drupal\node\Plugin\Search

View source

class NodeSearch extends ConfigurableSearchPluginBase implements AccessibleInterface, SearchIndexingInterface, TrustedCallbackInterface {

  /**
   * The current database connection.
   *
   * @var \Drupal\Core\Database\Connection
   */
  protected $database;

  /**
   * The replica database connection.
   *
   * @var \Drupal\Core\Database\Connection
   */
  protected $databaseReplica;

  /**
   * The entity type manager.
   *
   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
   */
  protected $entityTypeManager;

  /**
   * A module manager object.
   *
   * @var \Drupal\Core\Extension\ModuleHandlerInterface
   */
  protected $moduleHandler;

  /**
   * A config object for 'search.settings'.
   *
   * @var \Drupal\Core\Config\Config
   */
  protected $searchSettings;

  /**
   * The language manager.
   *
   * @var \Drupal\Core\Language\LanguageManagerInterface
   */
  protected $languageManager;

  /**
   * The Drupal account to use for checking for access to advanced search.
   *
   * @var \Drupal\Core\Session\AccountInterface
   */
  protected $account;

  /**
   * The Renderer service to format the username and node.
   *
   * @var \Drupal\Core\Render\RendererInterface
   */
  protected $renderer;

  /**
   * The search index.
   *
   * @var \Drupal\search\SearchIndexInterface
   */
  protected $searchIndex;

  /**
   * An array of additional rankings from hook_ranking().
   *
   * @var array
   */
  protected $rankings;

  /**
   * The list of options and info for advanced search filters.
   *
   * Each entry in the array has the option as the key and for its value, an
   * array that determines how the value is matched in the database query. The
   * possible keys in that array are:
   * - column: (required) Name of the database column to match against.
   * - join: (optional) Information on a table to join. By default the data is
   *   matched against the {node_field_data} table.
   * - operator: (optional) OR or AND, defaults to OR.
   *
   * @var array
   */
  protected $advanced = [
    'type' => [
      'column' => 'n.type',
    ],
    'language' => [
      'column' => 'i.langcode',
    ],
    'author' => [
      'column' => 'n.uid',
    ],
    'term' => [
      'column' => 'ti.tid',
      'join' => [
        'table' => 'taxonomy_index',
        'alias' => 'ti',
        'condition' => 'n.nid = ti.nid',
      ],
    ],
  ];

  /**
   * A constant for setting and checking the query string.
   */
  const ADVANCED_FORM = 'advanced-form';

  /**
   * The messenger.
   *
   * @var \Drupal\Core\Messenger\MessengerInterface
   */
  protected $messenger;

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
    return new static($configuration, $plugin_id, $plugin_definition, $container
      ->get('database'), $container
      ->get('entity_type.manager'), $container
      ->get('module_handler'), $container
      ->get('config.factory')
      ->get('search.settings'), $container
      ->get('language_manager'), $container
      ->get('renderer'), $container
      ->get('messenger'), $container
      ->get('current_user'), $container
      ->get('database.replica'), $container
      ->get('search.index'));
  }

  /**
   * Constructs a \Drupal\node\Plugin\Search\NodeSearch object.
   *
   * @param array $configuration
   *   A configuration array containing information about the plugin instance.
   * @param string $plugin_id
   *   The plugin_id for the plugin instance.
   * @param mixed $plugin_definition
   *   The plugin implementation definition.
   * @param \Drupal\Core\Database\Connection $database
   *   The current database connection.
   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
   *   The entity type manager.
   * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
   *   A module manager object.
   * @param \Drupal\Core\Config\Config $search_settings
   *   A config object for 'search.settings'.
   * @param \Drupal\Core\Language\LanguageManagerInterface $language_manager
   *   The language manager.
   * @param \Drupal\Core\Render\RendererInterface $renderer
   *   The renderer.
   * @param \Drupal\Core\Messenger\MessengerInterface $messenger
   *   The messenger.
   * @param \Drupal\Core\Session\AccountInterface $account
   *   The $account object to use for checking for access to advanced search.
   * @param \Drupal\Core\Database\Connection|null $database_replica
   *   The replica database connection.
   * @param \Drupal\search\SearchIndexInterface $search_index
   *   The search index.
   */
  public function __construct(array $configuration, $plugin_id, $plugin_definition, Connection $database, EntityTypeManagerInterface $entity_type_manager, ModuleHandlerInterface $module_handler, Config $search_settings, LanguageManagerInterface $language_manager, RendererInterface $renderer, MessengerInterface $messenger, AccountInterface $account, Connection $database_replica, SearchIndexInterface $search_index) {
    $this->database = $database;
    $this->databaseReplica = $database_replica;
    $this->entityTypeManager = $entity_type_manager;
    $this->moduleHandler = $module_handler;
    $this->searchSettings = $search_settings;
    $this->languageManager = $language_manager;
    $this->renderer = $renderer;
    $this->messenger = $messenger;
    $this->account = $account;
    parent::__construct($configuration, $plugin_id, $plugin_definition);
    $this
      ->addCacheTags([
      'node_list',
    ]);
    $this->searchIndex = $search_index;
  }

  /**
   * {@inheritdoc}
   */
  public function access($operation = 'view', AccountInterface $account = NULL, $return_as_object = FALSE) {
    $result = AccessResult::allowedIfHasPermission($account, 'access content');
    return $return_as_object ? $result : $result
      ->isAllowed();
  }

  /**
   * {@inheritdoc}
   */
  public function isSearchExecutable() {

    // Node search is executable if we have keywords or an advanced parameter.
    // At least, we should parse out the parameters and see if there are any
    // keyword matches in that case, rather than just printing out the
    // "Please enter keywords" message.
    return !empty($this->keywords) || isset($this->searchParameters['f']) && count($this->searchParameters['f']);
  }

  /**
   * {@inheritdoc}
   */
  public function getType() {
    return $this
      ->getPluginId();
  }

  /**
   * {@inheritdoc}
   */
  public function execute() {
    if ($this
      ->isSearchExecutable()) {
      $results = $this
        ->findResults();
      if ($results) {
        return $this
          ->prepareResults($results);
      }
    }
    return [];
  }

  /**
   * Queries to find search results, and sets status messages.
   *
   * This method can assume that $this->isSearchExecutable() has already been
   * checked and returned TRUE.
   *
   * @return \Drupal\Core\Database\StatementInterface|null
   *   Results from search query execute() method, or NULL if the search
   *   failed.
   */
  protected function findResults() {
    $keys = $this->keywords;

    // Build matching conditions.
    $query = $this->databaseReplica
      ->select('search_index', 'i')
      ->extend(SearchQuery::class)
      ->extend(PagerSelectExtender::class);
    $query
      ->join('node_field_data', 'n', '[n].[nid] = [i].[sid] AND [n].[langcode] = [i].[langcode]');
    $query
      ->condition('n.status', 1)
      ->addTag('node_access')
      ->searchExpression($keys, $this
      ->getPluginId());

    // Handle advanced search filters in the f query string.
    // \Drupal::request()->query->get('f') is an array that looks like this in
    // the URL: ?f[]=type:page&f[]=term:27&f[]=term:13&f[]=langcode:en
    // So $parameters['f'] looks like:
    // array('type:page', 'term:27', 'term:13', 'langcode:en');
    // We need to parse this out into query conditions, some of which go into
    // the keywords string, and some of which are separate conditions.
    $parameters = $this
      ->getParameters();
    if (!empty($parameters['f']) && is_array($parameters['f'])) {
      $filters = [];

      // Match any query value that is an expected option and a value
      // separated by ':' like 'term:27'.
      $pattern = '/^(' . implode('|', array_keys($this->advanced)) . '):([^ ]*)/i';
      foreach ($parameters['f'] as $item) {
        if (preg_match($pattern, $item, $m)) {

          // Use the matched value as the array key to eliminate duplicates.
          $filters[$m[1]][$m[2]] = $m[2];
        }
      }

      // Now turn these into query conditions. This assumes that everything in
      // $filters is a known type of advanced search.
      foreach ($filters as $option => $matched) {
        $info = $this->advanced[$option];

        // Insert additional conditions. By default, all use the OR operator.
        $operator = empty($info['operator']) ? 'OR' : $info['operator'];
        $where = $this->databaseReplica
          ->condition($operator);
        foreach ($matched as $value) {
          $where
            ->condition($info['column'], $value);
        }
        $query
          ->condition($where);
        if (!empty($info['join'])) {
          $query
            ->join($info['join']['table'], $info['join']['alias'], $info['join']['condition']);
        }
      }
    }

    // Add the ranking expressions.
    $this
      ->addNodeRankings($query);

    // Run the query.
    $find = $query
      ->fields('i', [
      'langcode',
    ])
      ->groupBy('i.langcode')
      ->limit(10)
      ->execute();

    // Check query status and set messages if needed.
    $status = $query
      ->getStatus();
    if ($status & SearchQuery::EXPRESSIONS_IGNORED) {
      $this->messenger
        ->addWarning($this
        ->t('Your search used too many AND/OR expressions. Only the first @count terms were included in this search.', [
        '@count' => $this->searchSettings
          ->get('and_or_limit'),
      ]));
    }
    if ($status & SearchQuery::LOWER_CASE_OR) {
      $this->messenger
        ->addWarning($this
        ->t('Search for either of the two terms with uppercase <strong>OR</strong>. For example, <strong>cats OR dogs</strong>.'));
    }
    if ($status & SearchQuery::NO_POSITIVE_KEYWORDS) {
      $this->messenger
        ->addWarning($this
        ->formatPlural($this->searchSettings
        ->get('index.minimum_word_size'), 'You must include at least one keyword to match in the content, and punctuation is ignored.', 'You must include at least one keyword to match in the content. Keywords must be at least @count characters, and punctuation is ignored.'));
    }
    return $find;
  }

  /**
   * Prepares search results for rendering.
   *
   * @param \Drupal\Core\Database\StatementInterface $found
   *   Results found from a successful search query execute() method.
   *
   * @return array
   *   Array of search result item render arrays (empty array if no results).
   */
  protected function prepareResults(StatementInterface $found) {
    $results = [];
    $node_storage = $this->entityTypeManager
      ->getStorage('node');
    $node_render = $this->entityTypeManager
      ->getViewBuilder('node');
    $keys = $this->keywords;
    foreach ($found as $item) {

      // Render the node.

      /** @var \Drupal\node\NodeInterface $node */
      $node = $node_storage
        ->load($item->sid)
        ->getTranslation($item->langcode);
      $build = $node_render
        ->view($node, 'search_result', $item->langcode);

      /** @var \Drupal\node\NodeTypeInterface $type*/
      $type = $this->entityTypeManager
        ->getStorage('node_type')
        ->load($node
        ->bundle());
      unset($build['#theme']);
      $build['#pre_render'][] = [
        $this,
        'removeSubmittedInfo',
      ];

      // Fetch comments for snippet.
      $rendered = $this->renderer
        ->renderPlain($build);
      $this
        ->addCacheableDependency(CacheableMetadata::createFromRenderArray($build));
      $rendered .= ' ' . $this->moduleHandler
        ->invoke('comment', 'node_update_index', [
        $node,
      ]);
      $extra = $this->moduleHandler
        ->invokeAll('node_search_result', [
        $node,
      ]);
      $username = [
        '#theme' => 'username',
        '#account' => $node
          ->getOwner(),
      ];
      $result = [
        'link' => $node
          ->toUrl('canonical', [
          'absolute' => TRUE,
        ])
          ->toString(),
        'type' => $type
          ->label(),
        'title' => $node
          ->label(),
        'node' => $node,
        'extra' => $extra,
        'score' => $item->calculated_score,
        'snippet' => search_excerpt($keys, $rendered, $item->langcode),
        'langcode' => $node
          ->language()
          ->getId(),
      ];
      $this
        ->addCacheableDependency($node);

      // We have to separately add the node owner's cache tags because search
      // module doesn't use the rendering system, it does its own rendering
      // without taking cacheability metadata into account. So we have to do it
      // explicitly here.
      $this
        ->addCacheableDependency($node
        ->getOwner());
      if ($type
        ->displaySubmitted()) {
        $result += [
          'user' => $this->renderer
            ->renderPlain($username),
          'date' => $node
            ->getChangedTime(),
        ];
      }
      $results[] = $result;
    }
    return $results;
  }

  /**
   * Removes the submitted by information from the build array.
   *
   * This information is being removed from the rendered node that is used to
   * build the search result snippet. It just doesn't make sense to have it
   * displayed in the snippet.
   *
   * @param array $build
   *   The build array.
   *
   * @return array
   *   The modified build array.
   */
  public function removeSubmittedInfo(array $build) {
    unset($build['created']);
    unset($build['uid']);
    return $build;
  }

  /**
   * Adds the configured rankings to the search query.
   *
   * @param $query
   *   A query object that has been extended with the Search DB Extender.
   */
  protected function addNodeRankings(SelectExtender $query) {
    if ($ranking = $this
      ->getRankings()) {
      $tables =& $query
        ->getTables();
      foreach ($ranking as $rank => $values) {
        if (isset($this->configuration['rankings'][$rank]) && !empty($this->configuration['rankings'][$rank])) {
          $node_rank = $this->configuration['rankings'][$rank];

          // If the table defined in the ranking isn't already joined, then add it.
          if (isset($values['join']) && !isset($tables[$values['join']['alias']])) {
            $query
              ->addJoin($values['join']['type'], $values['join']['table'], $values['join']['alias'], $values['join']['on']);
          }
          $arguments = isset($values['arguments']) ? $values['arguments'] : [];
          $query
            ->addScore($values['score'], $arguments, $node_rank);
        }
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function updateIndex() {

    // Interpret the cron limit setting as the maximum number of nodes to index
    // per cron run.
    $limit = (int) $this->searchSettings
      ->get('index.cron_limit');
    $query = $this->databaseReplica
      ->select('node', 'n');
    $query
      ->addField('n', 'nid');
    $query
      ->leftJoin('search_dataset', 'sd', '[sd].[sid] = [n].[nid] AND [sd].[type] = :type', [
      ':type' => $this
        ->getPluginId(),
    ]);
    $query
      ->addExpression('CASE MAX([sd].[reindex]) WHEN NULL THEN 0 ELSE 1 END', 'ex');
    $query
      ->addExpression('MAX([sd].[reindex])', 'ex2');
    $query
      ->condition($query
      ->orConditionGroup()
      ->where('[sd].[sid] IS NULL')
      ->condition('sd.reindex', 0, '<>'));
    $query
      ->orderBy('ex', 'DESC')
      ->orderBy('ex2')
      ->orderBy('n.nid')
      ->groupBy('n.nid')
      ->range(0, $limit);
    $nids = $query
      ->execute()
      ->fetchCol();
    if (!$nids) {
      return;
    }
    $node_storage = $this->entityTypeManager
      ->getStorage('node');
    $words = [];
    try {
      foreach ($node_storage
        ->loadMultiple($nids) as $node) {
        $words += $this
          ->indexNode($node);
      }
    } finally {
      $this->searchIndex
        ->updateWordWeights($words);
    }
  }

  /**
   * Indexes a single node.
   *
   * @param \Drupal\node\NodeInterface $node
   *   The node to index.
   *
   * @return array
   *   An array of words to update after indexing.
   */
  protected function indexNode(NodeInterface $node) {
    $words = [];
    $languages = $node
      ->getTranslationLanguages();
    $node_render = $this->entityTypeManager
      ->getViewBuilder('node');
    foreach ($languages as $language) {
      $node = $node
        ->getTranslation($language
        ->getId());

      // Render the node.
      $build = $node_render
        ->view($node, 'search_index', $language
        ->getId());
      unset($build['#theme']);

      // Add the title to text so it is searchable.
      $build['search_title'] = [
        '#prefix' => '<h1>',
        '#plain_text' => $node
          ->label(),
        '#suffix' => '</h1>',
        '#weight' => -1000,
      ];
      $text = $this->renderer
        ->renderPlain($build);

      // Fetch extra data normally not visible.
      $extra = $this->moduleHandler
        ->invokeAll('node_update_index', [
        $node,
      ]);
      foreach ($extra as $t) {
        $text .= $t;
      }

      // Update index, using search index "type" equal to the plugin ID.
      $words += $this->searchIndex
        ->index($this
        ->getPluginId(), $node
        ->id(), $language
        ->getId(), $text, FALSE);
    }
    return $words;
  }

  /**
   * {@inheritdoc}
   */
  public function indexClear() {

    // All NodeSearch pages share a common search index "type" equal to
    // the plugin ID.
    $this->searchIndex
      ->clear($this
      ->getPluginId());
  }

  /**
   * {@inheritdoc}
   */
  public function markForReindex() {

    // All NodeSearch pages share a common search index "type" equal to
    // the plugin ID.
    $this->searchIndex
      ->markForReindex($this
      ->getPluginId());
  }

  /**
   * {@inheritdoc}
   */
  public function indexStatus() {
    $total = $this->database
      ->query('SELECT COUNT(*) FROM {node}')
      ->fetchField();
    $remaining = $this->database
      ->query("SELECT COUNT(DISTINCT [n].[nid]) FROM {node} [n] LEFT JOIN {search_dataset} [sd] ON [sd].[sid] = [n].[nid] AND [sd].[type] = :type WHERE [sd].[sid] IS NULL OR [sd].[reindex] <> 0", [
      ':type' => $this
        ->getPluginId(),
    ])
      ->fetchField();
    return [
      'remaining' => $remaining,
      'total' => $total,
    ];
  }

  /**
   * {@inheritdoc}
   */
  public function searchFormAlter(array &$form, FormStateInterface $form_state) {
    $parameters = $this
      ->getParameters();
    $keys = $this
      ->getKeywords();
    $used_advanced = !empty($parameters[self::ADVANCED_FORM]);
    if ($used_advanced) {
      $f = isset($parameters['f']) ? (array) $parameters['f'] : [];
      $defaults = $this
        ->parseAdvancedDefaults($f, $keys);
    }
    else {
      $defaults = [
        'keys' => $keys,
      ];
    }
    $form['basic']['keys']['#default_value'] = $defaults['keys'];

    // Add advanced search keyword-related boxes.
    $form['advanced'] = [
      '#type' => 'details',
      '#title' => t('Advanced search'),
      '#attributes' => [
        'class' => [
          'search-advanced',
        ],
      ],
      '#access' => $this->account && $this->account
        ->hasPermission('use advanced search'),
      '#open' => $used_advanced,
    ];
    $form['advanced']['keywords-fieldset'] = [
      '#type' => 'fieldset',
      '#title' => t('Keywords'),
    ];
    $form['advanced']['keywords'] = [
      '#prefix' => '<div class="criterion">',
      '#suffix' => '</div>',
    ];
    $form['advanced']['keywords-fieldset']['keywords']['or'] = [
      '#type' => 'textfield',
      '#title' => t('Containing any of the words'),
      '#size' => 30,
      '#maxlength' => 255,
      '#default_value' => isset($defaults['or']) ? $defaults['or'] : '',
    ];
    $form['advanced']['keywords-fieldset']['keywords']['phrase'] = [
      '#type' => 'textfield',
      '#title' => t('Containing the phrase'),
      '#size' => 30,
      '#maxlength' => 255,
      '#default_value' => isset($defaults['phrase']) ? $defaults['phrase'] : '',
    ];
    $form['advanced']['keywords-fieldset']['keywords']['negative'] = [
      '#type' => 'textfield',
      '#title' => t('Containing none of the words'),
      '#size' => 30,
      '#maxlength' => 255,
      '#default_value' => isset($defaults['negative']) ? $defaults['negative'] : '',
    ];

    // Add node types.
    $types = array_map([
      '\\Drupal\\Component\\Utility\\Html',
      'escape',
    ], node_type_get_names());
    $form['advanced']['types-fieldset'] = [
      '#type' => 'fieldset',
      '#title' => t('Types'),
    ];
    $form['advanced']['types-fieldset']['type'] = [
      '#type' => 'checkboxes',
      '#title' => t('Only of the type(s)'),
      '#prefix' => '<div class="criterion">',
      '#suffix' => '</div>',
      '#options' => $types,
      '#default_value' => isset($defaults['type']) ? $defaults['type'] : [],
    ];
    $form['advanced']['submit'] = [
      '#type' => 'submit',
      '#value' => t('Advanced search'),
      '#prefix' => '<div class="action">',
      '#suffix' => '</div>',
      '#weight' => 100,
    ];

    // Add languages.
    $language_options = [];
    $language_list = $this->languageManager
      ->getLanguages(LanguageInterface::STATE_ALL);
    foreach ($language_list as $langcode => $language) {

      // Make locked languages appear special in the list.
      $language_options[$langcode] = $language
        ->isLocked() ? t('- @name -', [
        '@name' => $language
          ->getName(),
      ]) : $language
        ->getName();
    }
    if (count($language_options) > 1) {
      $form['advanced']['lang-fieldset'] = [
        '#type' => 'fieldset',
        '#title' => t('Languages'),
      ];
      $form['advanced']['lang-fieldset']['language'] = [
        '#type' => 'checkboxes',
        '#title' => t('Languages'),
        '#prefix' => '<div class="criterion">',
        '#suffix' => '</div>',
        '#options' => $language_options,
        '#default_value' => isset($defaults['language']) ? $defaults['language'] : [],
      ];
    }
  }

  /**
   * {@inheritdoc}
   */
  public function buildSearchUrlQuery(FormStateInterface $form_state) {

    // Read keyword and advanced search information from the form values,
    // and put these into the GET parameters.
    $keys = trim($form_state
      ->getValue('keys'));
    $advanced = FALSE;

    // Collect extra filters.
    $filters = [];
    if ($form_state
      ->hasValue('type') && is_array($form_state
      ->getValue('type'))) {

      // Retrieve selected types - Form API sets the value of unselected
      // checkboxes to 0.
      foreach ($form_state
        ->getValue('type') as $type) {
        if ($type) {
          $advanced = TRUE;
          $filters[] = 'type:' . $type;
        }
      }
    }
    if ($form_state
      ->hasValue('term') && is_array($form_state
      ->getValue('term'))) {
      foreach ($form_state
        ->getValue('term') as $term) {
        $filters[] = 'term:' . $term;
        $advanced = TRUE;
      }
    }
    if ($form_state
      ->hasValue('language') && is_array($form_state
      ->getValue('language'))) {
      foreach ($form_state
        ->getValue('language') as $language) {
        if ($language) {
          $advanced = TRUE;
          $filters[] = 'language:' . $language;
        }
      }
    }
    if ($form_state
      ->getValue('or') != '') {
      if (preg_match_all('/ ("[^"]+"|[^" ]+)/i', ' ' . $form_state
        ->getValue('or'), $matches)) {
        $keys .= ' ' . implode(' OR ', $matches[1]);
        $advanced = TRUE;
      }
    }
    if ($form_state
      ->getValue('negative') != '') {
      if (preg_match_all('/ ("[^"]+"|[^" ]+)/i', ' ' . $form_state
        ->getValue('negative'), $matches)) {
        $keys .= ' -' . implode(' -', $matches[1]);
        $advanced = TRUE;
      }
    }
    if ($form_state
      ->getValue('phrase') != '') {
      $keys .= ' "' . str_replace('"', ' ', $form_state
        ->getValue('phrase')) . '"';
      $advanced = TRUE;
    }
    $keys = trim($keys);

    // Put the keywords and advanced parameters into GET parameters. Make sure
    // to put keywords into the query even if it is empty, because the page
    // controller uses that to decide it's time to check for search results.
    $query = [
      'keys' => $keys,
    ];
    if ($filters) {
      $query['f'] = $filters;
    }

    // Record that the person used the advanced search form, if they did.
    if ($advanced) {
      $query[self::ADVANCED_FORM] = '1';
    }
    return $query;
  }

  /**
   * Parses the advanced search form default values.
   *
   * @param array $f
   *   The 'f' query parameter set up in self::buildUrlSearchQuery(), which
   *   contains the advanced query values.
   * @param string $keys
   *   The search keywords string, which contains some information from the
   *   advanced search form.
   *
   * @return array
   *   Array of default form values for the advanced search form, including
   *   a modified 'keys' element for the bare search keywords.
   */
  protected function parseAdvancedDefaults($f, $keys) {
    $defaults = [];

    // Split out the advanced search parameters.
    foreach ($f as $advanced) {
      list($key, $value) = explode(':', $advanced, 2);
      if (!isset($defaults[$key])) {
        $defaults[$key] = [];
      }
      $defaults[$key][] = $value;
    }

    // Split out the negative, phrase, and OR parts of keywords.
    // For phrases, the form only supports one phrase.
    $matches = [];
    $keys = ' ' . $keys . ' ';
    if (preg_match('/ "([^"]+)" /', $keys, $matches)) {
      $keys = str_replace($matches[0], ' ', $keys);
      $defaults['phrase'] = $matches[1];
    }

    // Negative keywords: pull all of them out.
    if (preg_match_all('/ -([^ ]+)/', $keys, $matches)) {
      $keys = str_replace($matches[0], ' ', $keys);
      $defaults['negative'] = implode(' ', $matches[1]);
    }

    // OR keywords: pull up to one set of them out of the query.
    if (preg_match('/ [^ ]+( OR [^ ]+)+ /', $keys, $matches)) {
      $keys = str_replace($matches[0], ' ', $keys);
      $words = explode(' OR ', trim($matches[0]));
      $defaults['or'] = implode(' ', $words);
    }

    // Put remaining keywords string back into keywords.
    $defaults['keys'] = trim($keys);
    return $defaults;
  }

  /**
   * Gathers ranking definitions from hook_ranking().
   *
   * @return array
   *   An array of ranking definitions.
   */
  protected function getRankings() {
    if (!$this->rankings) {
      $this->rankings = $this->moduleHandler
        ->invokeAll('ranking');
    }
    return $this->rankings;
  }

  /**
   * {@inheritdoc}
   */
  public function defaultConfiguration() {
    $configuration = [
      'rankings' => [],
    ];
    return $configuration;
  }

  /**
   * {@inheritdoc}
   */
  public function buildConfigurationForm(array $form, FormStateInterface $form_state) {

    // Output form for defining rank factor weights.
    $form['content_ranking'] = [
      '#type' => 'details',
      '#title' => t('Content ranking'),
      '#open' => TRUE,
    ];
    $form['content_ranking']['info'] = [
      '#markup' => '<p><em>' . $this
        ->t('Influence is a numeric multiplier used in ordering search results. A higher number means the corresponding factor has more influence on search results; zero means the factor is ignored. Changing these numbers does not require the search index to be rebuilt. Changes take effect immediately.') . '</em></p>',
    ];

    // Prepare table.
    $header = [
      $this
        ->t('Factor'),
      $this
        ->t('Influence'),
    ];
    $form['content_ranking']['rankings'] = [
      '#type' => 'table',
      '#header' => $header,
    ];

    // Note: reversed to reflect that higher number = higher ranking.
    $range = range(0, 10);
    $options = array_combine($range, $range);
    foreach ($this
      ->getRankings() as $var => $values) {
      $form['content_ranking']['rankings'][$var]['name'] = [
        '#markup' => $values['title'],
      ];
      $form['content_ranking']['rankings'][$var]['value'] = [
        '#type' => 'select',
        '#options' => $options,
        '#attributes' => [
          'aria-label' => $this
            ->t("Influence of '@title'", [
            '@title' => $values['title'],
          ]),
        ],
        '#default_value' => isset($this->configuration['rankings'][$var]) ? $this->configuration['rankings'][$var] : 0,
      ];
    }
    return $form;
  }

  /**
   * {@inheritdoc}
   */
  public function submitConfigurationForm(array &$form, FormStateInterface $form_state) {
    foreach ($this
      ->getRankings() as $var => $values) {
      if (!$form_state
        ->isValueEmpty([
        'rankings',
        $var,
        'value',
      ])) {
        $this->configuration['rankings'][$var] = $form_state
          ->getValue([
          'rankings',
          $var,
          'value',
        ]);
      }
      else {
        unset($this->configuration['rankings'][$var]);
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public static function trustedCallbacks() {
    return [
      'removeSubmittedInfo',
    ];
  }

}

Members

Name	Modifiers	Type	Description	Overrides
CacheableDependencyTrait::$cacheContexts	protected	property	Cache contexts.
CacheableDependencyTrait::$cacheMaxAge	protected	property	Cache max-age.
CacheableDependencyTrait::$cacheTags	protected	property	Cache tags.
CacheableDependencyTrait::getCacheContexts	public	function		4
CacheableDependencyTrait::getCacheMaxAge	public	function		4
CacheableDependencyTrait::getCacheTags	public	function		4
CacheableDependencyTrait::setCacheability	protected	function	Sets cacheability; useful for value object constructors.
ConfigurableSearchPluginBase::$searchPageId	protected	property	The unique ID for the search page using this plugin.
ConfigurableSearchPluginBase::calculateDependencies	public	function	Calculates dependencies for the configured plugin. Overrides DependentPluginInterface::calculateDependencies
ConfigurableSearchPluginBase::getConfiguration	public	function	Gets this plugin's configuration. Overrides ConfigurableInterface::getConfiguration
ConfigurableSearchPluginBase::setConfiguration	public	function	Sets the configuration for this plugin instance. Overrides ConfigurableInterface::setConfiguration
ConfigurableSearchPluginBase::setSearchPageId	public	function	Sets the ID for the search page using this plugin. Overrides ConfigurableSearchPluginInterface::setSearchPageId
ConfigurableSearchPluginBase::validateConfigurationForm	public	function	Form validation handler. Overrides PluginFormInterface::validateConfigurationForm
DependencySerializationTrait::$_entityStorages	protected	property
DependencySerializationTrait::$_serviceIds	protected	property
DependencySerializationTrait::__sleep	public	function		2
DependencySerializationTrait::__wakeup	public	function		2
MessengerTrait::messenger	public	function	Gets the messenger.	27
MessengerTrait::setMessenger	public	function	Sets the messenger.
NodeSearch::$account	protected	property	The Drupal account to use for checking for access to advanced search.
NodeSearch::$advanced	protected	property	The list of options and info for advanced search filters.
NodeSearch::$database	protected	property	The current database connection.
NodeSearch::$databaseReplica	protected	property	The replica database connection.
NodeSearch::$entityTypeManager	protected	property	The entity type manager.
NodeSearch::$languageManager	protected	property	The language manager.
NodeSearch::$messenger	protected	property	The messenger. Overrides MessengerTrait::$messenger
NodeSearch::$moduleHandler	protected	property	A module manager object.
NodeSearch::$rankings	protected	property	An array of additional rankings from hook_ranking().
NodeSearch::$renderer	protected	property	The Renderer service to format the username and node.
NodeSearch::$searchIndex	protected	property	The search index.
NodeSearch::$searchSettings	protected	property	A config object for 'search.settings'.
NodeSearch::access	public	function	Checks data value access. Overrides AccessibleInterface::access
NodeSearch::addNodeRankings	protected	function	Adds the configured rankings to the search query.
NodeSearch::ADVANCED_FORM		constant	A constant for setting and checking the query string.
NodeSearch::buildConfigurationForm	public	function	Form constructor. Overrides PluginFormInterface::buildConfigurationForm
NodeSearch::buildSearchUrlQuery	public	function	Builds the URL GET query parameters array for search. Overrides SearchPluginBase::buildSearchUrlQuery
NodeSearch::create	public static	function	Creates an instance of the plugin. Overrides SearchPluginBase::create
NodeSearch::defaultConfiguration	public	function	Gets default configuration for this plugin. Overrides ConfigurableSearchPluginBase::defaultConfiguration
NodeSearch::execute	public	function	Executes the search. Overrides SearchInterface::execute
NodeSearch::findResults	protected	function	Queries to find search results, and sets status messages.
NodeSearch::getRankings	protected	function	Gathers ranking definitions from hook_ranking().
NodeSearch::getType	public	function	Returns the search index type this plugin uses. Overrides SearchPluginBase::getType
NodeSearch::indexClear	public	function	Clears the search index for this plugin. Overrides SearchIndexingInterface::indexClear
NodeSearch::indexNode	protected	function	Indexes a single node.
NodeSearch::indexStatus	public	function	Reports the status of indexing. Overrides SearchIndexingInterface::indexStatus
NodeSearch::isSearchExecutable	public	function	Verifies if the values set via setSearch() are valid and sufficient. Overrides SearchPluginBase::isSearchExecutable
NodeSearch::markForReindex	public	function	Marks the search index for reindexing for this plugin. Overrides SearchIndexingInterface::markForReindex
NodeSearch::parseAdvancedDefaults	protected	function	Parses the advanced search form default values.
NodeSearch::prepareResults	protected	function	Prepares search results for rendering.
NodeSearch::removeSubmittedInfo	public	function	Removes the submitted by information from the build array.
NodeSearch::searchFormAlter	public	function	Alters the search form when being built for a given plugin. Overrides SearchPluginBase::searchFormAlter
NodeSearch::submitConfigurationForm	public	function	Form submission handler. Overrides PluginFormInterface::submitConfigurationForm
NodeSearch::trustedCallbacks	public static	function	Lists the trusted callbacks provided by the implementing class. Overrides TrustedCallbackInterface::trustedCallbacks
NodeSearch::updateIndex	public	function	Updates the search index for this plugin. Overrides SearchIndexingInterface::updateIndex
NodeSearch::__construct	public	function	Constructs a \Drupal\node\Plugin\Search\NodeSearch object. Overrides ConfigurableSearchPluginBase::__construct
PluginBase::$configuration	protected	property	Configuration information passed into the plugin.	1
PluginBase::$pluginDefinition	protected	property	The plugin implementation definition.	1
PluginBase::$pluginId	protected	property	The plugin_id.
PluginBase::DERIVATIVE_SEPARATOR		constant	A string which is used to separate base plugin IDs from the derivative ID.
PluginBase::getBaseId	public	function	Gets the base_plugin_id of the plugin instance. Overrides DerivativeInspectionInterface::getBaseId
PluginBase::getDerivativeId	public	function	Gets the derivative_id of the plugin instance. Overrides DerivativeInspectionInterface::getDerivativeId
PluginBase::getPluginDefinition	public	function	Gets the definition of the plugin implementation. Overrides PluginInspectionInterface::getPluginDefinition	2
PluginBase::getPluginId	public	function	Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
PluginBase::isConfigurable	public	function	Determines if the plugin is configurable.
RefinableCacheableDependencyTrait::addCacheableDependency	public	function		1
RefinableCacheableDependencyTrait::addCacheContexts	public	function
RefinableCacheableDependencyTrait::addCacheTags	public	function
RefinableCacheableDependencyTrait::mergeCacheMaxAge	public	function
SearchPluginBase::$keywords	protected	property	The keywords to use in a search.
SearchPluginBase::$searchAttributes	protected	property	Array of attributes - usually from the request object.
SearchPluginBase::$searchParameters	protected	property	Array of parameters from the query string from the request.
SearchPluginBase::buildResults	public	function	Executes the search and builds render arrays for the result items. Overrides SearchInterface::buildResults	1
SearchPluginBase::getAttributes	public	function	Returns the currently set attributes (from the request). Overrides SearchInterface::getAttributes
SearchPluginBase::getHelp	public	function	Returns the searching help. Overrides SearchInterface::getHelp	1
SearchPluginBase::getKeywords	public	function	Returns the currently set keywords of the plugin instance. Overrides SearchInterface::getKeywords
SearchPluginBase::getParameters	public	function	Returns the current parameters set using setSearch(). Overrides SearchInterface::getParameters
SearchPluginBase::setSearch	public	function	Sets the keywords, parameters, and attributes to be used by execute(). Overrides SearchInterface::setSearch	1
SearchPluginBase::suggestedTitle	public	function	Provides a suggested title for a page of search results. Overrides SearchInterface::suggestedTitle
SearchPluginBase::usesAdminTheme	public	function	Returns whether or not search results should be displayed in admin theme. Overrides SearchInterface::usesAdminTheme
StringTranslationTrait::$stringTranslation	protected	property	The string translation service.	4
StringTranslationTrait::formatPlural	protected	function	Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals	protected	function	Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation	protected	function	Gets the string translation service.
StringTranslationTrait::setStringTranslation	public	function	Sets the string translation service to use.	2
StringTranslationTrait::t	protected	function	Translates a string to the current language or to a given language.
TrustedCallbackInterface::THROW_EXCEPTION		constant	Untrusted callbacks throw exceptions.
TrustedCallbackInterface::TRIGGER_SILENCED_DEPRECATION		constant	Untrusted callbacks trigger silenced E_USER_DEPRECATION errors.
TrustedCallbackInterface::TRIGGER_WARNING		constant	Untrusted callbacks trigger E_USER_WARNING errors.

You are here

class NodeSearch in Drupal 9

Plugin annotation

Hierarchy

File

Namespace

Members

API Navigation