class AutocompleteService in Synonyms 2.0.x

Synonyms behavior service for autocomplete.

Hierarchy

class \Drupal\synonyms_autocomplete\SynonymsService\Behavior\AutocompleteService implements BehaviorInterface, WidgetInterface uses StringTranslationTrait

Expanded class hierarchy of AutocompleteService

1 file declares its use of AutocompleteService

EntityAutocomplete.php in modules/synonyms_autocomplete/src/Controller/EntityAutocomplete.php

1 string reference to 'AutocompleteService'

synonyms_autocomplete.services.yml in modules/synonyms_autocomplete/synonyms_autocomplete.services.yml: modules/synonyms_autocomplete/synonyms_autocomplete.services.yml

1 service uses AutocompleteService

synonyms.behavior.autocomplete in modules/synonyms_autocomplete/synonyms_autocomplete.services.yml: Drupal\synonyms_autocomplete\SynonymsService\Behavior\AutocompleteService

File

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

Namespace

Drupal\synonyms_autocomplete\SynonymsService\Behavior

View source

class AutocompleteService implements BehaviorInterface, WidgetInterface {
  use StringTranslationTrait;

  /**
   * The key value.
   *
   * @var \Drupal\Core\KeyValueStore\KeyValueFactoryInterface
   */
  protected $keyValue;

  /**
   * The entity reference selection handler plugin manager.
   *
   * @var \Drupal\Core\Entity\EntityReferenceSelection\SelectionPluginManagerInterface
   */
  protected $selectionManager;

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

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

  /**
   * The synonyms provider service.
   *
   * @var \Drupal\synonyms\SynonymsService\ProviderService
   */
  protected $providerService;

  /**
   * AutocompleteService constructor.
   */
  public function __construct(KeyValueFactoryInterface $key_value, SelectionPluginManagerInterface $selection_plugin_manager, Connection $database, EntityTypeManagerInterface $entity_type_manager, ProviderService $provider_service) {
    $this->keyValue = $key_value
      ->get('synonyms_entity_autocomplete');
    $this->selectionManager = $selection_plugin_manager;
    $this->database = $database;
    $this->entityTypeManager = $entity_type_manager;
    $this->providerService = $provider_service;
  }

  /**
   * {@inheritdoc}
   */
  public function getId() {
    return 'autocomplete';
  }

  /**
   * {@inheritdoc}
   */
  public function getTitle() {
    return $this
      ->t('Autocomplete');
  }

  /**
   * {@inheritdoc}
   */
  public function getWidgetTitle() {
    return $this
      ->t('Synonyms-friendly autocomplete');
  }

  /**
   * Execute synonym-friendly lookup of entities by a given keyword.
   *
   * @param string $keyword
   *   Keyword to search for.
   * @param string $key_value_key
   *   Key under which additional settings about the lookup are stored in
   *   key-value storage.
   *
   * @return 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
   */
  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;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
AutocompleteService::$database	protected	property	The database connection.
AutocompleteService::$entityTypeManager	protected	property	The entity type manager.
AutocompleteService::$keyValue	protected	property	The key value.
AutocompleteService::$providerService	protected	property	The synonyms provider service.
AutocompleteService::$selectionManager	protected	property	The entity reference selection handler plugin manager.
AutocompleteService::autocompleteLookup	public	function	Execute synonym-friendly lookup of entities by a given keyword.
AutocompleteService::getId	public	function	Get machine readable ID of this behavior. Overrides BehaviorInterface::getId
AutocompleteService::getTitle	public	function	Get human readable title of this behavior. Overrides BehaviorInterface::getTitle
AutocompleteService::getWidgetTitle	public	function	Get human readable title of this widget. Overrides WidgetInterface::getWidgetTitle
AutocompleteService::__construct	public	function	AutocompleteService constructor.
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.

You are here

class AutocompleteService in Synonyms 2.0.x

Hierarchy

File

Namespace

Members

API Navigation