public function AutocompleteService::autocompleteLookup in Synonyms 8

Execute synonym-friendly lookup of entities by a given keyword.

Parameters

string $keyword: Keyword to search for.

string $key_value_key: Key under which additional settings about the lookup are stored in key-value storage.

Return value

array Array of looked up suggestions. Each array will have the following structure:

• entity_id: (int) ID of the entity which this entry represents
• entity_label: (string) Label of the entity which this entry represents
• wording: (string) Wording with which this entry should be shown to the end user on the UI

File

src/SynonymsService/Behavior/AutocompleteService.php, line 147

Class

AutocompleteService

Synonyms behavior service for autocomplete.

Namespace

Drupal\synonyms\SynonymsService\Behavior

Code

public function autocompleteLookup($keyword, $key_value_key) {
  $suggestions = [];
  if ($this->keyValue
    ->has($key_value_key)) {
    $settings = $this->keyValue
      ->get($key_value_key);
    $suggested_entity_ids = [];
    $target_bundles = $settings['target_bundles'];
    $options = [
      'target_type' => $settings['target_type'],
      'handler' => 'default',
    ];
    if (!empty($target_bundles)) {
      $options['target_bundles'] = $target_bundles;
    }
    elseif (!$this->entityTypeManager
      ->getDefinition($settings['target_type'])
      ->hasKey('bundle')) {
      $target_bundles = [
        $settings['target_type'],
      ];
    }
    $handler = $this->selectionManager
      ->getInstance($options);
    foreach ($handler
      ->getReferenceableEntities($keyword, $settings['match'], $settings['suggestion_size']) as $suggested_entities) {
      foreach ($suggested_entities as $entity_id => $entity_label) {
        $suggestions[] = [
          'entity_id' => $entity_id,
          'entity_label' => $entity_label,
          'wording' => $entity_label,
        ];
        if ($settings['suggest_only_unique']) {
          $suggested_entity_ids[] = $entity_id;
        }
      }
    }
    if (count($suggestions) < $settings['suggestion_size']) {
      foreach ($this->behaviorService
        ->getSynonymConfigEntities('synonyms.behavior.autocomplete', $settings['target_type'], $target_bundles) as $behavior_service) {
        $plugin_instance = $behavior_service
          ->getProviderPluginInstance();
        $condition = new Condition('AND');
        switch ($settings['match']) {
          case 'CONTAINS':
            $condition
              ->condition(SynonymsFindProviderInterface::COLUMN_SYNONYM_PLACEHOLDER, '%' . $this->database
              ->escapeLike($keyword) . '%', 'LIKE');
            break;
          case 'STARTS_WITH':
            $condition
              ->condition(SynonymsFindProviderInterface::COLUMN_SYNONYM_PLACEHOLDER, $this->database
              ->escapeLike($keyword) . '%', 'LIKE');
            break;
        }
        if (!empty($suggested_entity_ids)) {
          $condition
            ->condition(SynonymsFindProviderInterface::COLUMN_ENTITY_ID_PLACEHOLDER, $suggested_entity_ids, 'NOT IN');
        }
        foreach ($plugin_instance
          ->synonymsFind($condition) as $row) {
          if (!in_array($row->entity_id, $suggested_entity_ids)) {
            $suggestions[] = [
              'entity_id' => $row->entity_id,
              'entity_label' => NULL,
              'synonym' => $row->synonym,
              'synonym_config_entity' => $behavior_service,
              'wording' => NULL,
            ];
          }
          if ($settings['suggest_only_unique']) {
            $suggested_entity_ids[] = $row->entity_id;
          }
          if (count($suggestions) == $settings['suggestion_size']) {
            break 2;
          }
        }
      }
    }
    $ids = [];
    foreach ($suggestions as $suggestion) {
      if (!$suggestion['entity_label']) {
        $ids[] = $suggestion['entity_id'];
      }
    }
    $ids = array_unique($ids);
    if (!empty($ids)) {
      $entities = $this->entityTypeManager
        ->getStorage($settings['target_type'])
        ->loadMultiple($ids);
      foreach ($suggestions as $k => $suggestion) {
        if (!$suggestion['entity_label']) {
          $suggestions[$k]['entity_label'] = $entities[$suggestion['entity_id']]
            ->label();
          $suggestions[$k]['wording'] = $suggestion['synonym_config_entity']
            ->getProviderPluginInstance()
            ->synonymFormatWording($suggestion['synonym'], $entities[$suggestion['entity_id']], $suggestion['synonym_config_entity']);
        }
      }
    }
  }
  return $suggestions;
}