View source
<?php
namespace Drupal\feeds\Plugin\Type\Target;
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Entity\TranslatableInterface;
use Drupal\Core\Field\FieldDefinitionInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Language\LanguageInterface;
use Drupal\Core\Language\LanguageManagerInterface;
use Drupal\feeds\Exception\EmptyFeedException;
use Drupal\feeds\Exception\TargetValidationException;
use Drupal\feeds\FeedInterface;
use Drupal\feeds\FeedTypeInterface;
use Drupal\feeds\FieldTargetDefinition;
use Drupal\feeds\Plugin\Type\Processor\EntityProcessorInterface;
abstract class FieldTargetBase extends TargetBase implements ConfigurableTargetInterface, TranslatableTargetInterface {
protected $fieldSettings;
protected $languageManager;
public static function targets(array &$targets, FeedTypeInterface $feed_type, array $definition) {
$processor = $feed_type
->getProcessor();
if (!$processor instanceof EntityProcessorInterface) {
return $targets;
}
$field_definitions = \Drupal::service('entity_field.manager')
->getFieldDefinitions($processor
->entityType(), $processor
->bundle());
foreach ($field_definitions as $id => $field_definition) {
if (isset($targets[$id])) {
continue;
}
if ($id === $processor
->bundleKey()) {
continue;
}
if (in_array($field_definition
->getType(), $definition['field_types'])) {
if ($target = static::prepareTarget($field_definition)) {
$target
->setPluginId($definition['id']);
$targets[$id] = $target;
}
}
}
}
protected static function prepareTarget(FieldDefinitionInterface $field_definition) {
return FieldTargetDefinition::createFromFieldDefinition($field_definition)
->addProperty('value');
}
public function __construct(array $configuration, $plugin_id, array $plugin_definition) {
$this->targetDefinition = $configuration['target_definition'];
$this->settings = $this->targetDefinition
->getFieldDefinition()
->getSettings();
parent::__construct($configuration, $plugin_id, $plugin_definition);
}
public function setTarget(FeedInterface $feed, EntityInterface $entity, $field_name, array $values) {
if ($values = $this
->prepareValues($values)) {
$entity_target = $this
->getEntityTarget($feed, $entity);
if (!empty($entity_target)) {
$item_list = $entity_target
->get($field_name);
$values = array_merge($item_list
->getValue(), $values);
$item_list
->setValue($values);
}
}
}
public function isMutable() {
return !$this->targetDefinition
->getFieldDefinition()
->isReadOnly();
}
public function isEmpty(FeedInterface $feed, EntityInterface $entity, $field_name) {
return $entity
->get($field_name)
->isEmpty();
}
public function getEntityTarget(FeedInterface $feed, EntityInterface $entity) {
if ($entity instanceof TranslatableInterface && $this
->isTargetTranslatable()) {
if ($this
->languageExists()) {
$processor = $feed
->getType()
->getProcessor();
if ($processor instanceof EntityProcessorInterface) {
return $processor
->getEntityTranslation($feed, $entity, $this
->getLangcode());
}
}
return;
}
return $entity;
}
protected function prepareValues(array $values) {
$return = [];
foreach ($values as $delta => $columns) {
try {
$this
->prepareValue($delta, $columns);
$return[] = $columns;
} catch (EmptyFeedException $e) {
} catch (TargetValidationException $e) {
$this
->addMessage($e
->getFormattedMessage(), 'error');
}
}
return $return;
}
protected function prepareValue($delta, array &$values) {
foreach ($values as $column => $value) {
$values[$column] = (string) $value;
}
}
protected function getUniqueQuery() {
return \Drupal::entityQuery($this->feedType
->getProcessor()
->entityType())
->range(0, 1)
->accessCheck(FALSE);
}
public function getUniqueValue(FeedInterface $feed, $target, $key, $value) {
$base_fields = \Drupal::service('entity_field.manager')
->getBaseFieldDefinitions($this->feedType
->getProcessor()
->entityType());
if (isset($base_fields[$target])) {
$field = $target;
}
else {
$field = "{$target}.{$key}";
}
$query = $this
->getUniqueQuery()
->condition($field, $value);
$bundle_key = $this->feedType
->getProcessor()
->bundleKey();
if ($bundle_key) {
$query
->condition($bundle_key, $this->feedType
->getProcessor()
->bundle());
}
if ($result = $query
->execute()) {
return reset($result);
}
}
protected function getMessenger() {
return \Drupal::messenger();
}
protected function addMessage($message, $type = 'status', $repeat = FALSE) {
$this
->getMessenger()
->addMessage($message, $type, $repeat);
}
public function calculateDependencies() {
$this->dependencies = parent::calculateDependencies();
$field_definition = $this->targetDefinition
->getFieldDefinition();
if ($field_definition && $field_definition instanceof EntityInterface) {
$this->dependencies['config'][] = $field_definition
->getConfigDependencyName();
}
return $this->dependencies;
}
public function onDependencyRemoval(array $dependencies) {
$remove = FALSE;
$current_dependencies = $this
->calculateDependencies();
foreach ($current_dependencies as $group => $dependency_list) {
foreach ($dependency_list as $config_key) {
if (isset($dependencies[$group]) && array_key_exists($config_key, $dependencies[$group])) {
$remove = TRUE;
break 2;
}
}
}
return $remove;
}
public function defaultConfiguration() {
$configuration = [];
if ($this
->isTargetFieldTranslatable()) {
$configuration['language'] = NULL;
}
return $configuration;
}
public function getSummary() {
$summary = [];
if (!$this
->isMutable()) {
$summary[] = $this
->t('Read only');
}
if ($this
->isTargetTranslatable()) {
$language = $this
->getLanguageManager()
->getLanguage($this->configuration['language']);
if ($language instanceof LanguageInterface) {
$summary[] = $this
->t('Language: @language', [
'@language' => $language
->getName(),
]);
}
}
return $summary;
}
public function buildConfigurationForm(array $form, FormStateInterface $form_state) {
if ($this
->isTargetFieldTranslatable()) {
$languages = $this
->getLanguageManager()
->getLanguages();
$options = [
'' => $this
->t('Default'),
];
foreach ($languages as $langcode => $language) {
$options[$langcode] = $language
->getName();
}
$language_default = !empty($this->configuration['language']) ? $this->configuration['language'] : '';
$form['language'] = [
'#title' => $this
->t('Language'),
'#options' => $options,
'#type' => 'select',
'#default_value' => $language_default,
];
}
return $form;
}
protected function getLanguageManager() {
if (!isset($this->languageManager)) {
$this
->setLanguageManager(\Drupal::service('language_manager'));
}
return $this->languageManager;
}
public function setLanguageManager(LanguageManagerInterface $language_manager) {
$this->languageManager = $language_manager;
}
public function languageExists() {
return $this
->getLanguageManager()
->getLanguage($this->configuration['language']) instanceof LanguageInterface;
}
public function isTargetTranslatable() {
return $this
->isTargetFieldTranslatable() && !empty($this->configuration['language']);
}
protected function isTargetFieldTranslatable() {
$field_storage = $this->targetDefinition
->getFieldDefinition()
->getFieldStorageDefinition();
return !empty($field_storage) && $field_storage
->isTranslatable();
}
public function getLangcode() {
if (!empty($this->configuration['language'])) {
return $this->configuration['language'];
}
$processor = $this->feedType
->getProcessor();
if ($processor instanceof EntityProcessorInterface) {
return $processor
->entityLanguage();
}
return $this
->getLanguageManager()
->getDefaultLanguage()
->getId();
}
}