public function AutocompleteService::autocompleteLookup in Synonyms 2.0.x

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

modules/synonyms_autocomplete/src/SynonymsService/Behavior/AutocompleteService.php, line 107

Class

AutocompleteService

Synonyms behavior service for autocomplete.

Namespace

Drupal\synonyms_autocomplete\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 ($target_bundles as $target_bundle) {
        if ($this->providerService
          ->serviceIsEnabled($settings['target_type'], $target_bundle, $this
          ->getId())) {
          foreach ($this->providerService
            ->getSynonymConfigEntities($settings['target_type'], $target_bundle) as $synonym_config) {
            $plugin_instance = $synonym_config
              ->getProviderPluginInstance();
            $condition = new Condition('AND');
            switch ($settings['match']) {
              case 'CONTAINS':
                $condition
                  ->condition(FindInterface::COLUMN_SYNONYM_PLACEHOLDER, '%' . $this->database
                  ->escapeLike($keyword) . '%', 'LIKE');
                break;
              case 'STARTS_WITH':
                $condition
                  ->condition(FindInterface::COLUMN_SYNONYM_PLACEHOLDER, $this->database
                  ->escapeLike($keyword) . '%', 'LIKE');
                break;
            }
            if (!empty($suggested_entity_ids)) {
              $condition
                ->condition(FindInterface::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' => $synonym_config,
                  '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'], $this
            ->getId());
        }
      }
    }
  }
  return $suggestions;
}