class WrapperTarget in Feeds Paragraphs 8

Defines a wrapper target around a paragraph bundle's target field.

Plugin annotation


@FeedsTarget(
  id = "wrapper_target",
  field_types = {
    "entity_reference_revisions",
  },
  arguments = {
    "@messenger",
    "@plugin.manager.feeds.target",
    "@feeds_para_mapper.mapper",
  }
)

Hierarchy

class \Drupal\Component\Plugin\PluginBase implements DerivativeInspectionInterface, PluginInspectionInterface
- class \Drupal\Core\Plugin\PluginBase uses DependencySerializationTrait, MessengerTrait, StringTranslationTrait
  - class \Drupal\feeds\Plugin\Type\PluginBase implements FeedsPluginInterface uses DependencyTrait
    class \Drupal\feeds\Plugin\Type\ConfigurablePluginBase implements PluginFormInterface
    class \Drupal\feeds\Plugin\Type\Target\TargetBase implements TargetInterface
    class \Drupal\feeds\Plugin\Type\Target\FieldTargetBase implements ConfigurableTargetInterface, TranslatableTargetInterface
    class \Drupal\feeds_para_mapper\Feeds\Target\WrapperTarget implements ConfigurableTargetInterface

Expanded class hierarchy of WrapperTarget

2 files declare their use of WrapperTarget

FpmTestBase.php in tests/src/Unit/FpmTestBase.php
TestWrapperTarget.php in tests/src/Unit/TestWrapperTarget.php

File

src/Feeds/Target/WrapperTarget.php, line 36

Namespace

Drupal\feeds_para_mapper\Feeds\Target

View source

class WrapperTarget extends FieldTargetBase implements ConfigurableTargetInterface {

  /**
   * @var MessengerInterface
   */
  protected $messenger;

  /**
   * @var FeedsPluginManager
   */
  protected $plugin_manager;

  /**
   * @var Mapper
   */
  protected $mapper;

  /**
   * @var FieldConfigInterface
   */
  protected $field;

  /**
   * @var FieldTargetBase
   */
  protected $targetInstance;
  public function __construct(array $configuration, $plugin_id, array $plugin_definition, MessengerInterface $messenger, FeedsPluginManager $plugin_manager, Mapper $mapper) {
    $this->messenger = $messenger;
    $this->plugin_manager = $plugin_manager;
    $this->mapper = $mapper;
    $this->configuration = $configuration;
    $this->targetDefinition = $configuration['target_definition'];
    $this->field = $this->targetDefinition
      ->getFieldDefinition();
    $this->targetInstance = $this
      ->createTargetInstance();
    parent::__construct($configuration, $plugin_id, $plugin_definition);
  }

  /**
   * {@inheritdoc}
   */
  public static function targets(array &$targets, FeedTypeInterface $feed_type, array $definition) {
    $processor = $feed_type
      ->getProcessor();
    $entity_type = $processor
      ->entityType();
    $bundle = $processor
      ->bundle();

    /**
     * @var Mapper $mapper
     */
    $mapper = \Drupal::service('feeds_para_mapper.mapper');
    $sub_fields = $mapper
      ->getTargets($entity_type, $bundle);
    foreach ($sub_fields as $field) {
      $field
        ->set('field_type', 'entity_reference_revisions');
      $wrapper_target = self::prepareTarget($field);
      if (!isset($wrapper_target)) {
        continue;
      }
      $properties = $wrapper_target
        ->getProperties();
      $mapper
        ->updateInfo($field, 'properties', $properties);
      $wrapper_target
        ->setPluginId("wrapper_target");
      $path = $mapper
        ->getInfo($field, 'path');
      $last_host = end($path);
      $wrapper_target
        ->setPluginId("wrapper_target");
      $id = $last_host['bundle'] . "_" . $field
        ->getName();
      $exist = isset($targets[$id]);
      $num = 0;
      while ($exist) {
        $num++;
        $id .= "_" . $num;
        $exist = isset($targets[$id]);
      }
      $targets[$id] = $wrapper_target;
    }
  }
  public function createTargetInstance() {
    $mapper = $this
      ->getMapper();
    $plugin = $mapper
      ->getInfo($this->field, 'plugin');
    $class = $plugin['class'];
    $target = $class::prepareTarget($this->field);
    if (!isset($target)) {
      return null;
    }
    $target
      ->setPluginId($plugin['id']);
    $instance = null;
    try {
      $instance = $this->plugin_manager
        ->createInstance($plugin['id'], $this->configuration);
    } catch (PluginException $e) {
    }
    return $instance;
  }

  /**
   * {@inheritdoc}
   */
  public function setTarget(FeedInterface $feed, EntityInterface $entity, $field_name, array $values) {
    $empty = $this
      ->valuesAreEmpty($values);
    if ($empty) {
      return;
    }
    $target = $this->targetDefinition;
    $target = $target
      ->getFieldDefinition();
    $type = $this->mapper
      ->getInfo($target, 'type');
    $target
      ->set('field_type', $type);
    try {
      $importer = \Drupal::service('feeds_para_mapper.importer');
      $importer
        ->import($this->feedType, $feed, $entity, $target, $this->configuration, $values, $this->targetInstance);
    } catch (\Exception $exception) {
      $this->messenger
        ->addError($exception);
    }
  }

  /**
   * Checks whether the values are empty.
   *
   * @param array $values
   *   The values
   *
   * @return bool
   *   True if the values are empty.
   */
  public function valuesAreEmpty(array $values) {
    $properties = $this->targetDefinition
      ->getProperties();
    $emptyValues = 0;
    foreach ($values as $value) {
      $currentProperties = array_keys($value);
      $emptyProps = [];
      foreach ($properties as $property) {
        foreach ($currentProperties as $currentProperty) {
          if ($currentProperty === $property) {
            if (is_array($value[$currentProperty])) {
              $emptySubValues = 0;
              foreach ($value[$currentProperty] as $subValue) {
                if (!strlen($subValue)) {
                  $emptySubValues++;
                }
              }
              if ($emptySubValues === count($value[$currentProperty])) {
                $emptyProps[] = $currentProperty;
              }
            }
            else {
              if (!strlen($value[$currentProperty])) {
                $emptyProps[] = $currentProperty;
              }
            }
          }
        }
      }
      if (count($emptyProps) === count($properties)) {
        $emptyValues++;
      }
    }
    return $emptyValues === count($values);
  }

  /**
   * {@inheritdoc}
   */
  protected static function prepareTarget(FieldDefinitionInterface $field_definition) {
    $mapper = \Drupal::service('feeds_para_mapper.mapper');
    $field_type = $mapper
      ->getInfo($field_definition, 'type');
    $plugin = $mapper
      ->getInfo($field_definition, 'plugin');
    $path = $mapper
      ->getInfo($field_definition, 'path');
    if (!isset($field_type) || !isset($plugin)) {
      return null;
    }
    $class = $plugin['class'];
    $field_definition
      ->set('field_type', $field_type);
    $targetDef = $class::prepareTarget($field_definition);
    if (!isset($targetDef)) {
      return null;
    }
    $label = $field_definition
      ->getLabel();
    $label .= ' (';
    foreach ($path as $i => $host) {
      if ($i + 1 === count($path)) {
        $label .= $host['host_field'];
      }
      else {
        $label .= $host['host_field'] . ":";
      }
    }
    $label .= ')';
    $field_definition
      ->set('label', $label);
    $field_definition
      ->set('field_type', 'entity_reference_revisions');
    return $targetDef;
  }

  /**
   * {@inheritdoc}
   */
  public function defaultConfiguration() {
    $mapper = $this
      ->getMapper();
    $config = $this->targetInstance
      ->defaultConfiguration();
    $has_settings = $mapper
      ->getInfo($this->field, 'has_settings');
    if ($has_settings) {
      $config['max_values'] = $mapper
        ->getMaxValues($this->field, $this->configuration);
    }
    return $config;
  }

  /**
   * {@inheritdoc}
   */
  public function buildConfigurationForm(array $form, FormStateInterface $form_state) {
    $config = $this->targetInstance
      ->buildConfigurationForm($form, $form_state);
    $has_settings = $this->mapper
      ->getInfo($this->field, 'has_settings');
    if ($has_settings) {
      $escaped = array(
        '@field' => $this->field
          ->getName(),
      );
      $des = $this
        ->t('When @field field exceeds this number of values,
     a new paragraph entity will be created to hold the remaining values.', $escaped);
      $element = array(
        '#type' => 'textfield',
        '#title' => $this
          ->t("Maximum Values"),
        '#default_value' => $this->configuration['max_values'],
        '#description' => $des,
      );
      $config['max_values'] = $element;
    }
    return $config;
  }

  /**
   * {@inheritdoc}
   */
  public function submitConfigurationForm(array &$form, FormStateInterface $form_state) {
    $delta = $form_state
      ->getTriggeringElement()['#delta'];
    $configuration = $form_state
      ->getValue([
      'mappings',
      $delta,
      'settings',
    ]);
    $this->targetInstance
      ->submitConfigurationForm($form, $form_state);
    $this
      ->setConfiguration($configuration);
  }

  /**
   * {@inheritdoc}
   */
  public function getSummary() {
    $mapper = $this
      ->getMapper();
    $sum = null;
    if ($this->targetInstance instanceof ConfigurableTargetInterface) {
      $sum = $this->targetInstance
        ->getSummary();
    }
    $has_settings = $mapper
      ->getInfo($this->field, 'has_settings');
    $final_str = $sum;
    if ($has_settings) {
      $temp_sum = "Maximum values: " . $this->configuration['max_values'];
      if (isset($sum) && $sum instanceof TranslatableMarkup) {
        $final_str = $sum
          ->getUntranslatedString();
        $final_str .= "<br>" . $temp_sum;
        $args = $sum
          ->getArguments();
        if (isset($args)) {
          $final_str = $this
            ->t($final_str, $args);
        }
        else {
          $final_str = $this
            ->t($final_str);
        }
      }
      else {
        $final_str = $sum . "<br>" . $this
          ->t($temp_sum);
      }
    }
    return $final_str;
  }

  /**
   * Gets the mapper object.
   *
   * @return Mapper
   */
  private function getMapper() {
    if (isset($this->mapper)) {
      return $this->mapper;
    }
    return \Drupal::service('feeds_para_mapper.mapper');
  }

  /**
   * {@inheritdoc}
   */
  public function calculateDependencies() {
    $this->dependencies = parent::calculateDependencies();

    // Add the configured field as a dependency.
    $field_definition = $this->targetDefinition
      ->getFieldDefinition();

    // We need to add all parent fields as dependencies
    $fields = $this->mapper
      ->loadParentFields($field_definition);
    $fields[] = $field_definition;
    foreach ($fields as $field) {
      if ($field && $field instanceof EntityInterface) {
        $this->dependencies['config'][] = $field
          ->getConfigDependencyName();
      }
    }
    return $this->dependencies;
  }

  /**
   * {@inheritdoc}
   */
  public function onDependencyRemoval(array $dependencies) {
    return parent::onDependencyRemoval($dependencies);
  }

}

Members

Name	Modifiers	Type	Description	Overrides
ConfigurablePluginBase::validateConfigurationForm	public	function	Form validation handler. Overrides PluginFormInterface::validateConfigurationForm
DependencySerializationTrait::$_entityStorages	protected	property	An array of entity type IDs keyed by the property name of their storages.
DependencySerializationTrait::$_serviceIds	protected	property	An array of service IDs keyed by property name used for serialization.
DependencySerializationTrait::__sleep	public	function		1
DependencySerializationTrait::__wakeup	public	function		2
DependencyTrait::$dependencies	protected	property	The object's dependencies.
DependencyTrait::addDependencies	protected	function	Adds multiple dependencies.
DependencyTrait::addDependency	protected	function	Adds a dependency.
FieldTargetBase::$fieldSettings	protected	property	The field settings.
FieldTargetBase::$languageManager	protected	property	The language manager.
FieldTargetBase::addMessage	protected	function	Adds a message.
FieldTargetBase::getEntityTarget	public	function	Get entity, or entity translation to set the map.
FieldTargetBase::getLangcode	public	function	Gets the configured language. Overrides TranslatableTargetInterface::getLangcode
FieldTargetBase::getLanguageManager	protected	function	Gets the language manager.
FieldTargetBase::getMessenger	protected	function	Returns the messenger to use.
FieldTargetBase::getUniqueQuery	protected	function	Constructs a base query which is used to find an existing entity.
FieldTargetBase::getUniqueValue	public	function	Looks for an existing entity and returns an entity ID if found.
FieldTargetBase::isEmpty	public	function	Returns if the value for the target is empty. Overrides TargetInterface::isEmpty
FieldTargetBase::isMutable	public	function	Returns if the target is mutable. Overrides TargetInterface::isMutable	1
FieldTargetBase::isTargetFieldTranslatable	protected	function	Checks if the targeted field is translatable.
FieldTargetBase::isTargetTranslatable	public	function	Checks if the target is translatable. Overrides TranslatableTargetInterface::isTargetTranslatable
FieldTargetBase::languageExists	public	function	Checks if the language selected on the target exists. Overrides TranslatableTargetInterface::languageExists
FieldTargetBase::prepareValue	protected	function	Prepares a single value.	12
FieldTargetBase::prepareValues	protected	function	Prepares the the values that will be mapped to an entity.
FieldTargetBase::setLanguageManager	public	function	Sets the language manager.
MessengerTrait::messenger	public	function	Gets the messenger.	29
MessengerTrait::setMessenger	public	function	Sets the messenger.
PluginBase::$configuration	protected	property	Configuration information passed into the plugin.	1
PluginBase::$feedType	protected	property	The importer this plugin is working for.
PluginBase::$linkGenerator	protected	property	The link generator.
PluginBase::$pluginDefinition	protected	property	The plugin implementation definition.	1
PluginBase::$pluginId	protected	property	The plugin_id.
PluginBase::$urlGenerator	protected	property	The url generator.
PluginBase::container	private	function	Returns the service container.
PluginBase::defaultFeedConfiguration	public	function	Returns default feed configuration. Overrides FeedsPluginInterface::defaultFeedConfiguration	3
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::getConfiguration	public	function	Gets this plugin's configuration. Overrides ConfigurableInterface::getConfiguration
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	3
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.
PluginBase::l	protected	function	Renders a link to a route given a route name and its parameters.
PluginBase::linkGenerator	protected	function	Returns the link generator service.
PluginBase::onFeedDeleteMultiple	public	function	A feed is being deleted.	3
PluginBase::onFeedSave	public	function	A feed is being saved.
PluginBase::onFeedTypeDelete	public	function	The feed type is being deleted.	1
PluginBase::onFeedTypeSave	public	function	The feed type is being saved.	1
PluginBase::pluginType	public	function	Returns the type of plugin. Overrides FeedsPluginInterface::pluginType
PluginBase::setConfiguration	public	function	Sets the configuration for this plugin instance. Overrides ConfigurableInterface::setConfiguration	1
PluginBase::url	protected	function	Generates a URL or path for a specific route based on the given parameters.
PluginBase::urlGenerator	protected	function	Returns the URL generator service.
StringTranslationTrait::$stringTranslation	protected	property	The string translation service.	1
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.
TargetBase::$targetDefinition	protected	property	The target definition.
TargetBase::getTargetDefinition	public	function	Returns the target's definition. Overrides TargetInterface::getTargetDefinition
WrapperTarget::$field	protected	property
WrapperTarget::$mapper	protected	property
WrapperTarget::$messenger	protected	property	Overrides MessengerTrait::$messenger
WrapperTarget::$plugin_manager	protected	property
WrapperTarget::$targetInstance	protected	property
WrapperTarget::buildConfigurationForm	public	function	Form constructor. Overrides FieldTargetBase::buildConfigurationForm
WrapperTarget::calculateDependencies	public	function	Calculates dependencies for the configured plugin. Overrides FieldTargetBase::calculateDependencies
WrapperTarget::createTargetInstance	public	function
WrapperTarget::defaultConfiguration	public	function	Gets default configuration for this plugin. Overrides FieldTargetBase::defaultConfiguration
WrapperTarget::getMapper	private	function	Gets the mapper object.
WrapperTarget::getSummary	public	function	Returns the summary for a target. Overrides FieldTargetBase::getSummary
WrapperTarget::onDependencyRemoval	public	function	Allows a plugin to define whether it should be removed. Overrides FieldTargetBase::onDependencyRemoval
WrapperTarget::prepareTarget	protected static	function	Prepares a target definition. Overrides FieldTargetBase::prepareTarget
WrapperTarget::setTarget	public	function	Sets the values on an object. Overrides FieldTargetBase::setTarget
WrapperTarget::submitConfigurationForm	public	function	Form submission handler. Overrides TargetBase::submitConfigurationForm
WrapperTarget::targets	public static	function	Returns the targets defined by this plugin. Overrides FieldTargetBase::targets
WrapperTarget::valuesAreEmpty	public	function	Checks whether the values are empty.
WrapperTarget::__construct	public	function	Constructs a TargetBase object. Overrides FieldTargetBase::__construct

You are here

class WrapperTarget in Feeds Paragraphs 8

Plugin annotation

Hierarchy

File

Namespace

Members

API Navigation