You are here

Home » API reference » Search API Synonym 8 » ExportPluginManager.php

class ExportPluginManager in Search API Synonym 8

Base class for search api synonym export plugin managers.

Hierarchy

Expanded class hierarchy of ExportPluginManager

2 files declare their use of ExportPluginManager
SynonymDrushCommands.php in src/Command/SynonymDrushCommands.php
Drush commands for the Search API Synonym module.
SynonymSettingsForm.php in src/Form/SynonymSettingsForm.php
1 string reference to 'ExportPluginManager'
search_api_synonym.services.yml in ./search_api_synonym.services.yml
search_api_synonym.services.yml
1 service uses ExportPluginManager
plugin.manager.search_api_synonym.export in ./search_api_synonym.services.yml
Drupal\search_api_synonym\Export\ExportPluginManager

File

src/Export/ExportPluginManager.php, line 15

Namespace

Drupal\search_api_synonym\Export
View source 
class ExportPluginManager extends DefaultPluginManager {

  /**
   * Active plugin id
   *
   * @var string
   */
  protected $pluginId;

  /**
   * Export options.
   *
   * @var array
   */
  protected $exportOptions;

  /**
   * The file system service.
   *
   * @var \Drupal\Core\File\FileSystemInterface
   */
  protected $fileSystem;

  /**
   * {@inheritdoc}
   */
  public function __construct(\Traversable $namespaces, CacheBackendInterface $cache_backend, ModuleHandlerInterface $module_handler, FileSystemInterface $file_system = NULL) {
    parent::__construct('Plugin/search_api_synonym/export', $namespaces, $module_handler, 'Drupal\\search_api_synonym\\Export\\ExportPluginInterface', 'Drupal\\search_api_synonym\\Annotation\\SearchApiSynonymExport');
    $this
      ->alterInfo('search_api_synonym_export_info');
    $this
      ->setCacheBackend($cache_backend, 'search_api_synonym_export_info_plugins');
    $this->fileSystem = $file_system;
  }

  /**
   * Set active plugin.
   *
   * @param string $plugin_id
   *   The active plugin.
   */
  public function setPluginId($plugin_id) {
    $this->pluginId = $plugin_id;
  }

  /**
   * Get active plugin.
   *
   * @return string
   *   The active plugin.
   */
  public function getPluginId() {
    return $this->pluginId;
  }

  /**
   * Set export options.
   *
   * @param array $export_options
   *   Array with export options
   */
  public function setExportOptions(array $export_options) {
    $this->exportOptions = $export_options;
  }

  /**
   * Get export options.
   *
   * @return array
   *   Array with export options
   */
  public function getExportOptions() {
    return $this->exportOptions;
  }

  /**
   * Get single export option.
   *
   * @param string $key
   *   Option key
   *
   * @return string
   *   Option value
   */
  public function getExportOption($key) {
    return isset($this->exportOptions[$key]) ? $this->exportOptions[$key] : '';
  }

  /**
   * Gets a list of available export plugins.
   *
   * @return array
   *   An array with the plugin names as keys and the descriptions as values.
   */
  public function getAvailableExportPlugins() {

    // Use plugin system to get list of available export plugins.
    $plugins = $this
      ->getDefinitions();
    $output = [];
    foreach ($plugins as $id => $definition) {
      $output[$id] = $definition;
    }
    return $output;
  }

  /**
   * Validate that a specific export plugin exists.
   *
   * @param string $plugin
   *   The plugin machine name.
   *
   * @return boolean
   *   TRUE if the plugin exists.
   */
  public function validatePlugin($plugin) {
    if ($this
      ->getDefinition($plugin, FALSE)) {
      return TRUE;
    }
    else {
      return FALSE;
    }
  }

  /**
   * Execute the synonym export.
   *
   * @return mixed
   *   Export result
   */
  public function executeExport() {

    // Export plugin instance
    $instance = $this
      ->createInstance($this
      ->getPluginId(), []);

    // Get synonyms data matching the options.
    $synonyms = $this
      ->getSynonymsData();

    // We only export if full export or if their is new synonyms.
    if (!($this
      ->getExportOption('incremental') && empty($synonyms))) {

      // Get data in the plugin instance format
      $data = $instance
        ->getFormattedSynonyms($synonyms);
      return $this
        ->saveSynonymsFile($data);
    }
    else {
      return FALSE;
    }
  }

  /**
   * Get synonyms  matching the export options.
   *
   * @return array
   *   Array with synonyms
   */
  private function getSynonymsData() {

    // Create the db query.
    $query = \Drupal::database()
      ->select('search_api_synonym', 's');
    $query
      ->fields('s', [
      'sid',
      'type',
      'word',
      'synonyms',
    ]);
    $query
      ->condition('s.status', 1);
    $query
      ->condition('s.langcode', $this
      ->getExportOption('langcode'));
    $query
      ->orderBy('s.word');

    // Add type condition if it is set and different from all.
    $type = $this
      ->getExportOption('type');
    if ($type && $type != 'all') {
      $query
        ->condition('s.type', $type);
    }

    // Add filter condition if it is set and different from all.
    $filter = $this
      ->getExportOption('filter');
    if ($filter && $filter != 'all') {
      switch ($filter) {
        case 'nospace':
          $query
            ->condition('s.word', '% %', 'NOT LIKE');
          $query
            ->condition('s.synonyms', '% %', 'NOT LIKE');
          break;
        case 'onlyspace':
          $group = $query
            ->orConditionGroup()
            ->condition('s.word', '% %', 'LIKE')
            ->condition('s.synonyms', '% %', 'LIKE');
          $query = $query
            ->condition($group);
          break;
      }
    }

    // Add changed condition if incremental option is set.
    if ($incremental = $this
      ->getExportOption('incremental')) {
      $query
        ->condition('s.changed', $incremental, '>=');
    }

    // Fetch the result.
    return $query
      ->execute()
      ->fetchAllAssoc('sid');
  }

  /**
   * Save synonyms data to a file.
   *
   * @param string $data
   *   String with the synonyms data being written to a file.
   *
   * @return string
   *   Return path to the saved synonyms file.
   */
  private function saveSynonymsFile($data) {
    if ($file = $this
      ->getExportOption('file')) {
      $filename = $file;
    }
    else {
      $filename = $this
        ->generateFileName();
    }

    // Create folder if it does not exist.
    $folder = 'public://synonyms';
    $this->fileSystem
      ->prepareDirectory($folder, FileSystemInterface::CREATE_DIRECTORY | FileSystemInterface::MODIFY_PERMISSIONS);

    // Save file and return result.
    $path = $folder . '/' . $filename;
    return $this->fileSystem
      ->saveData($data, $path, FileSystemInterface::EXISTS_REPLACE);
  }

  /**
   * Generate an export file name based on export options.
   *
   * @return string
   *   The generated file name.
   */
  private function generateFileName() {
    $options = $this
      ->getExportOptions();

    // Add benning of file name
    $name[] = 'synonyms';

    // Add language code as the first part of the file name.
    $name[] = "lang_{$options['langcode']}";

    // Add type option to file name
    if (!empty($options['type'])) {
      $name[] = "type_{$options['type']}";
    }

    // Add filter option to file name
    if (!empty($options['filter'])) {
      $name[] = "filter_{$options['filter']}";
    }

    // Implode the name parts.
    return implode('__', $name) . '.txt';
  }

}

Members

Namesort descending Modifiers Type Description Overrides
DefaultPluginManager::$additionalAnnotationNamespaces protected property Additional namespaces the annotation discovery mechanism should scan for annotation definitions.
DefaultPluginManager::$alterHook protected property Name of the alter hook if one should be invoked.
DefaultPluginManager::$cacheKey protected property The cache key.
DefaultPluginManager::$cacheTags protected property An array of cache tags to use for the cached definitions.
DefaultPluginManager::$defaults protected property A set of defaults to be referenced by $this->processDefinition() if additional processing of plugins is necessary or helpful for development purposes. 9
DefaultPluginManager::$moduleHandler protected property The module handler to invoke the alter hook. 1
DefaultPluginManager::$namespaces protected property An object that implements \Traversable which contains the root paths keyed by the corresponding namespace to look for plugin implementations.
DefaultPluginManager::$pluginDefinitionAnnotationName protected property The name of the annotation that contains the plugin definition.
DefaultPluginManager::$pluginInterface protected property The interface each plugin should implement. 1
DefaultPluginManager::$subdir protected property The subdirectory within a namespace to look for plugins, or FALSE if the plugins are in the top level of the namespace.
DefaultPluginManager::alterDefinitions protected function Invokes the hook to alter the definitions if the alter hook is set. 1
DefaultPluginManager::alterInfo protected function Sets the alter hook name.
DefaultPluginManager::clearCachedDefinitions public function Clears static and persistent plugin definition caches. Overrides CachedDiscoveryInterface::clearCachedDefinitions 5
DefaultPluginManager::extractProviderFromDefinition protected function Extracts the provider from a plugin definition.
DefaultPluginManager::findDefinitions protected function Finds plugin definitions. 7
DefaultPluginManager::fixContextAwareDefinitions private function Fix the definitions of context-aware plugins.
DefaultPluginManager::getCacheContexts public function The cache contexts associated with this object. Overrides CacheableDependencyInterface::getCacheContexts
DefaultPluginManager::getCachedDefinitions protected function Returns the cached plugin definitions of the decorated discovery class.
DefaultPluginManager::getCacheMaxAge public function The maximum age for which this object may be cached. Overrides CacheableDependencyInterface::getCacheMaxAge
DefaultPluginManager::getCacheTags public function The cache tags associated with this object. Overrides CacheableDependencyInterface::getCacheTags
DefaultPluginManager::getDefinitions public function Gets the definition of all plugins for this type. Overrides DiscoveryTrait::getDefinitions 2
DefaultPluginManager::getDiscovery protected function Gets the plugin discovery. Overrides PluginManagerBase::getDiscovery 12
DefaultPluginManager::getFactory protected function Gets the plugin factory. Overrides PluginManagerBase::getFactory
DefaultPluginManager::processDefinition public function Performs extra processing on plugin definitions. 13
DefaultPluginManager::providerExists protected function Determines if the provider of a definition exists. 3
DefaultPluginManager::setCacheBackend public function Initialize the cache backend.
DefaultPluginManager::setCachedDefinitions protected function Sets a cache of plugin definitions for the decorated discovery class.
DefaultPluginManager::useCaches public function Disable the use of caches. Overrides CachedDiscoveryInterface::useCaches 1
DiscoveryCachedTrait::$definitions protected property Cached definitions array. 1
DiscoveryCachedTrait::getDefinition public function Overrides DiscoveryTrait::getDefinition 3
DiscoveryTrait::doGetDefinition protected function Gets a specific plugin definition.
DiscoveryTrait::hasDefinition public function
ExportPluginManager::$exportOptions protected property Export options.
ExportPluginManager::$fileSystem protected property The file system service.
ExportPluginManager::$pluginId protected property Active plugin id
ExportPluginManager::executeExport public function Execute the synonym export.
ExportPluginManager::generateFileName private function Generate an export file name based on export options.
ExportPluginManager::getAvailableExportPlugins public function Gets a list of available export plugins.
ExportPluginManager::getExportOption public function Get single export option.
ExportPluginManager::getExportOptions public function Get export options.
ExportPluginManager::getPluginId public function Get active plugin.
ExportPluginManager::getSynonymsData private function Get synonyms matching the export options.
ExportPluginManager::saveSynonymsFile private function Save synonyms data to a file.
ExportPluginManager::setExportOptions public function Set export options.
ExportPluginManager::setPluginId public function Set active plugin.
ExportPluginManager::validatePlugin public function Validate that a specific export plugin exists.
ExportPluginManager::__construct public function Creates the discovery object. Overrides DefaultPluginManager::__construct
PluginManagerBase::$discovery protected property The object that discovers plugins managed by this manager.
PluginManagerBase::$factory protected property The object that instantiates plugins managed by this manager.
PluginManagerBase::$mapper protected property The object that returns the preconfigured plugin instance appropriate for a particular runtime condition.
PluginManagerBase::createInstance public function Creates a pre-configured instance of a plugin. Overrides FactoryInterface::createInstance 12
PluginManagerBase::getInstance public function Gets a preconfigured instance of a plugin. Overrides MapperInterface::getInstance 7
PluginManagerBase::handlePluginNotFound protected function Allows plugin managers to specify custom behavior if a plugin is not found. 1
UseCacheBackendTrait::$cacheBackend protected property Cache backend instance.
UseCacheBackendTrait::$useCaches protected property Flag whether caches should be used or skipped.
UseCacheBackendTrait::cacheGet protected function Fetches from the cache backend, respecting the use caches flag. 1
UseCacheBackendTrait::cacheSet protected function Stores data in the persistent cache, respecting the use caches flag.