View source
<?php
namespace Drupal\serialization\Normalizer;
use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\Entity\FieldableEntityInterface;
use Drupal\Core\Field\FieldItemInterface;
use Drupal\Core\Field\TypedData\FieldItemDataDefinitionInterface;
use Symfony\Component\Serializer\Exception\UnexpectedValueException;
trait FieldableEntityNormalizerTrait {
protected $entityFieldManager;
protected $entityTypeManager;
protected $entityTypeRepository;
protected function determineEntityTypeId($class, $context) {
return !empty($context['entity_type']) ? $context['entity_type'] : $this
->getEntityTypeRepository()
->getEntityTypeFromClass($class);
}
protected function getEntityTypeDefinition($entity_type_id) {
$entity_type_definition = $this
->getEntityTypeManager()
->getDefinition($entity_type_id, FALSE);
if (!$entity_type_definition) {
throw new UnexpectedValueException(sprintf('The specified entity type "%s" does not exist. A valid entity type is required for denormalization', $entity_type_id));
}
return $entity_type_definition;
}
protected function extractBundleData(array &$data, EntityTypeInterface $entity_type_definition) {
$bundle_key = $entity_type_definition
->getKey('bundle');
$base_field_definitions = $this
->getEntityFieldManager()
->getBaseFieldDefinitions($entity_type_definition
->id());
$key_id = isset($base_field_definitions[$bundle_key]) ? $base_field_definitions[$bundle_key]
->getFieldStorageDefinition()
->getMainPropertyName() : 'value';
$bundle_value = isset($data[$bundle_key][0][$key_id]) ? $data[$bundle_key][0][$key_id] : (isset($data[$bundle_key]) ? $data[$bundle_key] : NULL);
unset($data[$bundle_key]);
$bundle_type_id = $entity_type_definition
->getBundleEntityType();
$bundle_types = $bundle_type_id ? $this
->getEntityTypeManager()
->getStorage($bundle_type_id)
->getQuery()
->execute() : [];
if (!is_string($bundle_value)) {
throw new UnexpectedValueException(sprintf('Could not determine entity type bundle: "%s" field is missing.', $bundle_key));
}
if ($bundle_types && !in_array($bundle_value, $bundle_types)) {
throw new UnexpectedValueException(sprintf('"%s" is not a valid bundle type for denormalization.', $bundle_value));
}
return [
$bundle_key => $bundle_value,
];
}
protected function denormalizeFieldData(array $data, FieldableEntityInterface $entity, $format, array $context) {
foreach ($data as $field_name => $field_data) {
$field_item_list = $entity
->get($field_name);
$field_item_list
->setValue([]);
$field_item_list_class = get_class($field_item_list);
if ($field_data) {
$context['target_instance'] = $field_item_list;
$this->serializer
->denormalize($field_data, $field_item_list_class, $format, $context);
}
}
}
protected function getEntityTypeRepository() {
if (!$this->entityTypeRepository) {
@trigger_error('The entityTypeRepository property must be set on the FieldEntityNormalizerTrait, it is required before Drupal 9.0.0. See https://www.drupal.org/node/2549139.', E_USER_DEPRECATED);
$this->entityTypeRepository = \Drupal::service('entity_type.repository');
}
return $this->entityTypeRepository;
}
protected function getEntityFieldManager() {
if (!$this->entityFieldManager) {
@trigger_error('The entityFieldManager property must be set on the FieldEntityNormalizerTrait, it is required before Drupal 9.0.0. See https://www.drupal.org/node/2549139.', E_USER_DEPRECATED);
$this->entityFieldManager = \Drupal::service('entity_field.manager');
}
return $this->entityFieldManager;
}
protected function getEntityTypeManager() {
if (!$this->entityTypeManager) {
@trigger_error('The entityTypeManager property must be set on the FieldEntityNormalizerTrait, it is required before Drupal 9.0.0. See https://www.drupal.org/node/2549139.', E_USER_DEPRECATED);
$this->entityTypeManager = \Drupal::service('entity_type.manager');
}
return $this->entityTypeManager;
}
protected function constructValue($data, $context) {
$field_item = $context['target_instance'];
assert($field_item instanceof FieldItemInterface);
$field_definition = $field_item
->getFieldDefinition();
$item_definition = $field_definition
->getItemDefinition();
assert($item_definition instanceof FieldItemDataDefinitionInterface);
$property_definitions = $item_definition
->getPropertyDefinitions();
$serialized_property_names = $this
->getCustomSerializedPropertyNames($field_item);
$denormalize_property = function ($property_name, $property_value, $property_value_class, $context) use ($serialized_property_names) {
if ($this->serializer
->supportsDenormalization($property_value, $property_value_class, NULL, $context)) {
return $this->serializer
->denormalize($property_value, $property_value_class, NULL, $context);
}
else {
if (in_array($property_name, $serialized_property_names, TRUE)) {
$property_value = serialize($property_value);
}
return $property_value;
}
};
if (!is_array($data)) {
$property_value = $data;
$property_name = $item_definition
->getMainPropertyName();
$property_value_class = $property_definitions[$property_name]
->getClass();
return $denormalize_property($property_name, $property_value, $property_value_class, $context);
}
$data_internal = [];
if (!empty($property_definitions)) {
foreach ($property_definitions as $property_name => $property_definition) {
if (!array_key_exists($property_name, $data)) {
continue;
}
$property_value = $data[$property_name];
$property_value_class = $property_definition
->getClass();
$data_internal[$property_name] = $denormalize_property($property_name, $property_value, $property_value_class, $context);
}
}
else {
$data_internal = $data;
}
return $data_internal;
}
}