/**
* {@inheritdoc}
*/
public static function propertyDefinitions(FieldStorageDefinitionInterface $field_definition)
{
$settings = $field_definition->getSettings();
$target_type_info = \Drupal::entityManager()->getDefinition($settings['target_type']);
$target_id_data_type = 'string';
if ($target_type_info->isSubclassOf('\\Drupal\\Core\\Entity\\FieldableEntityInterface')) {
$id_definition = \Drupal::entityManager()->getBaseFieldDefinitions($settings['target_type'])[$target_type_info->getKey('id')];
if ($id_definition->getType() === 'integer') {
$target_id_data_type = 'integer';
}
}
if ($target_id_data_type === 'integer') {
$target_id_definition = DataDefinition::create('integer')->setLabel(t('@label ID', array($target_type_info->getLabel())))->setSetting('unsigned', TRUE);
} else {
$target_id_definition = DataDefinition::create('string')->setLabel(t('@label ID', array($target_type_info->getLabel())));
}
$target_id_definition->setRequired(TRUE);
$properties['target_id'] = $target_id_definition;
$properties['entity'] = DataReferenceDefinition::create('entity')->setLabel($target_type_info->getLabel())->setDescription(t('The referenced entity'))->setComputed(TRUE)->setReadOnly(FALSE)->setTargetDefinition(EntityDataDefinition::create($settings['target_type']))->addConstraint('EntityType', $settings['target_type']);
if (isset($settings['target_bundle'])) {
$properties['entity']->addConstraint('Bundle', $settings['target_bundle']);
// Set any further bundle constraints on the target definition as well,
// such that it can derive more special data types if possible. For
// example, "entity:node:page" instead of "entity:node".
$properties['entity']->getTargetDefinition()->addConstraint('Bundle', $settings['target_bundle']);
}
return $properties;
}
/**
* Creates an instance wrapping the given entity.
*
* @param \Drupal\Core\Entity\EntityInterface|null $entity
* The entity object to wrap.
*
* @return static
*/
public static function createFromEntity(EntityInterface $entity)
{
$definition = EntityDataDefinition::create()->setEntityTypeId($entity->getEntityTypeId())->setBundles([$entity->bundle()]);
$instance = new static($definition);
$instance->setValue($entity);
return $instance;
}
/**
* {@inheritdoc}
*/
public static function propertyDefinitions(FieldStorageDefinitionInterface $field_definition)
{
$settings = $field_definition->getSettings();
$target_type_info = \Drupal::entityManager()->getDefinition($settings['target_type']);
if ($target_type_info->isSubclassOf('\\Drupal\\Core\\Entity\\FieldableEntityInterface')) {
// @todo: Lookup the entity type's ID data type and use it here.
// https://drupal.org/node/2107249
$target_id_definition = DataDefinition::create('integer')->setLabel(t('@label ID', array($target_type_info->getLabel())))->setSetting('unsigned', TRUE);
} else {
$target_id_definition = DataDefinition::create('string')->setLabel(t('@label ID', array($target_type_info->getLabel())));
}
$properties['target_id'] = $target_id_definition;
$properties['entity'] = DataReferenceDefinition::create('entity')->setLabel($target_type_info->getLabel())->setDescription(t('The referenced entity'))->setComputed(TRUE)->setReadOnly(FALSE)->setTargetDefinition(EntityDataDefinition::create($settings['target_type']));
if (isset($settings['target_bundle'])) {
$properties['entity']->getTargetDefinition()->addConstraint('Bundle', $settings['target_bundle']);
}
return $properties;
}
/**
* {@inheritdoc}
*/
public static function propertyDefinitions(FieldStorageDefinitionInterface $field_definition)
{
$settings = $field_definition->getSettings();
$target_type_info = \Drupal::entityManager()->getDefinition($settings['target_type']);
$target_id_data_type = 'string';
if ($target_type_info->isSubclassOf('\\Drupal\\Core\\Entity\\FieldableEntityInterface')) {
$id_definition = \Drupal::entityManager()->getBaseFieldDefinitions($settings['target_type'])[$target_type_info->getKey('id')];
if ($id_definition->getType() === 'integer') {
$target_id_data_type = 'integer';
}
}
if ($target_id_data_type === 'integer') {
$target_id_definition = DataReferenceTargetDefinition::create('integer')->setLabel(new TranslatableMarkup('@label ID', ['@label' => $target_type_info->getLabel()]))->setSetting('unsigned', TRUE);
} else {
$target_id_definition = DataReferenceTargetDefinition::create('string')->setLabel(new TranslatableMarkup('@label ID', ['@label' => $target_type_info->getLabel()]));
}
$target_id_definition->setRequired(TRUE);
$properties['target_id'] = $target_id_definition;
$properties['entity'] = DataReferenceDefinition::create('entity')->setLabel($target_type_info->getLabel())->setDescription(new TranslatableMarkup('The referenced entity'))->setComputed(TRUE)->setReadOnly(FALSE)->setTargetDefinition(EntityDataDefinition::create($settings['target_type']))->addConstraint('EntityType', $settings['target_type']);
return $properties;
}
/**
* Executes the introspection tests for the given entity type.
*
* @param string $entity_type
* The entity type to run the tests with.
*/
protected function checkIntrospection($entity_type)
{
// Test getting metadata upfront. The entity types used for this test have
// a default bundle that is the same as the entity type.
$definitions = \Drupal::entityManager()->getFieldDefinitions($entity_type, $entity_type);
$this->assertEqual($definitions['name']->getType(), 'string', $entity_type . ': Name field found.');
$this->assertEqual($definitions['user_id']->getType(), 'entity_reference', $entity_type . ': User field found.');
$this->assertEqual($definitions['field_test_text']->getType(), 'text', $entity_type . ': Test-text-field field found.');
// Test deriving further metadata.
$this->assertTrue($definitions['name'] instanceof FieldDefinitionInterface);
$field_item_definition = $definitions['name']->getItemDefinition();
$this->assertTrue($field_item_definition instanceof ComplexDataDefinitionInterface);
$this->assertEqual($field_item_definition->getDataType(), 'field_item:string');
$value_definition = $field_item_definition->getPropertyDefinition('value');
$this->assertTrue($value_definition instanceof DataDefinitionInterface);
$this->assertEqual($value_definition->getDataType(), 'string');
// Test deriving metadata from references.
$entity_definition = \Drupal\Core\Entity\TypedData\EntityDataDefinition::create($entity_type);
$reference_definition = $entity_definition->getPropertyDefinition('langcode')->getPropertyDefinition('language')->getTargetDefinition();
$this->assertEqual($reference_definition->getDataType(), 'language');
$reference_definition = $entity_definition->getPropertyDefinition('user_id')->getPropertyDefinition('entity')->getTargetDefinition();
$this->assertTrue($reference_definition instanceof \Drupal\Core\Entity\TypedData\EntityDataDefinitionInterface, 'Definition of the referenced user retrieved.');
$this->assertEqual($reference_definition->getEntityTypeId(), 'user', 'Referenced entity is of type "user".');
// Test propagating down.
$name_definition = $reference_definition->getPropertyDefinition('name');
$this->assertTrue($name_definition instanceof FieldDefinitionInterface);
$this->assertEqual($name_definition->getPropertyDefinition('value')->getDataType(), 'string');
// Test introspecting an entity object.
// @todo: Add bundles and test bundles as well.
$entity = entity_create($entity_type);
$definitions = $entity->getFieldDefinitions();
$this->assertEqual($definitions['name']->getType(), 'string', $entity_type . ': Name field found.');
$this->assertEqual($definitions['user_id']->getType(), 'entity_reference', $entity_type . ': User field found.');
$this->assertEqual($definitions['field_test_text']->getType(), 'text', $entity_type . ': Test-text-field field found.');
$name_properties = $entity->name->getFieldDefinition()->getPropertyDefinitions();
$this->assertEqual($name_properties['value']->getDataType(), 'string', $entity_type . ': String value property of the name found.');
$userref_properties = $entity->user_id->getFieldDefinition()->getPropertyDefinitions();
$this->assertEqual($userref_properties['target_id']->getDataType(), 'integer', $entity_type . ': Entity id property of the user found.');
$this->assertEqual($userref_properties['entity']->getDataType(), 'entity_reference', $entity_type . ': Entity reference property of the user found.');
$textfield_properties = $entity->field_test_text->getFieldDefinition()->getFieldStorageDefinition()->getPropertyDefinitions();
$this->assertEqual($textfield_properties['value']->getDataType(), 'string', $entity_type . ': String value property of the test-text field found.');
$this->assertEqual($textfield_properties['format']->getDataType(), 'filter_format', $entity_type . ': String format field of the test-text field found.');
$this->assertEqual($textfield_properties['processed']->getDataType(), 'string', $entity_type . ': String processed property of the test-text field found.');
// Make sure provided contextual information is right.
$entity_adapter = $entity->getTypedData();
$this->assertIdentical($entity_adapter->getRoot(), $entity_adapter, 'Entity is root object.');
$this->assertEqual($entity_adapter->getPropertyPath(), '');
$this->assertEqual($entity_adapter->getName(), '');
$this->assertEqual($entity_adapter->getParent(), NULL);
$field = $entity->user_id;
$this->assertIdentical($field->getRoot()->getValue(), $entity, 'Entity is root object.');
$this->assertIdentical($field->getEntity(), $entity, 'getEntity() returns the entity.');
$this->assertEqual($field->getPropertyPath(), 'user_id');
$this->assertEqual($field->getName(), 'user_id');
$this->assertIdentical($field->getParent()->getValue(), $entity, 'Parent object matches.');
$field_item = $field[0];
$this->assertIdentical($field_item->getRoot()->getValue(), $entity, 'Entity is root object.');
$this->assertIdentical($field_item->getEntity(), $entity, 'getEntity() returns the entity.');
$this->assertEqual($field_item->getPropertyPath(), 'user_id.0');
$this->assertEqual($field_item->getName(), '0');
$this->assertIdentical($field_item->getParent(), $field, 'Parent object matches.');
$item_value = $field_item->get('entity');
$this->assertIdentical($item_value->getRoot()->getValue(), $entity, 'Entity is root object.');
$this->assertEqual($item_value->getPropertyPath(), 'user_id.0.entity');
$this->assertEqual($item_value->getName(), 'entity');
$this->assertIdentical($item_value->getParent(), $field_item, 'Parent object matches.');
}
/**
* {@inheritdoc}
*/
public static function propertyDefinitions(FieldStorageDefinitionInterface $field_definition)
{
$settings = $field_definition->getSettings();
$target_type_info = \Drupal::entityTypeManager()->getDefinition($settings['target_type']);
$properties = parent::propertyDefinitions($field_definition);
if ($target_type_info->getKey('revision')) {
$target_revision_id_definition = DataReferenceTargetDefinition::create('integer')->setLabel(t('@label revision ID', array('@label' => $target_type_info->getLabel())))->setSetting('unsigned', TRUE);
$target_revision_id_definition->setRequired(TRUE);
$properties['target_revision_id'] = $target_revision_id_definition;
}
$properties['entity'] = DataReferenceDefinition::create('entity_revision')->setLabel($target_type_info->getLabel())->setDescription(t('The referenced entity revision'))->setComputed(TRUE)->setReadOnly(FALSE)->setTargetDefinition(EntityDataDefinition::create($settings['target_type']));
return $properties;
}
/**
* Tests deriving metadata about entities.
*/
public function testEntities()
{
$entity_definition = EntityDataDefinition::create('node');
// Entities are complex data.
$this->assertFalse($entity_definition instanceof ListDataDefinitionInterface);
$this->assertTrue($entity_definition instanceof ComplexDataDefinitionInterface);
$field_definitions = $entity_definition->getPropertyDefinitions();
// Comparison should ignore the internal static cache, so compare the
// serialized objects instead.
$this->assertEqual(serialize($field_definitions), serialize(\Drupal::entityManager()->getBaseFieldDefinitions('node')));
$this->assertEqual($entity_definition->getPropertyDefinition('title')->getItemDefinition()->getDataType(), 'field_item:string');
$this->assertNull($entity_definition->getMainPropertyName());
$this->assertNull($entity_definition->getPropertyDefinition('invalid'));
$entity_definition2 = $this->typedDataManager->createDataDefinition('entity:node');
$this->assertFalse($entity_definition2 instanceof ListDataDefinitionInterface);
$this->assertTrue($entity_definition2 instanceof ComplexDataDefinitionInterface);
$this->assertEqual(serialize($entity_definition), serialize($entity_definition2));
// Test that the definition factory creates the right definitions for all
// entity data types variants.
$this->assertEqual($this->typedDataManager->createDataDefinition('entity'), EntityDataDefinition::create());
$this->assertEqual($this->typedDataManager->createDataDefinition('entity:node'), EntityDataDefinition::create('node'));
// Config entities don't support typed data.
$entity_definition = EntityDataDefinition::create('node_type');
$this->assertEqual(array(), $entity_definition->getPropertyDefinitions());
}
/**
* {@inheritdoc}
*/
public function getDataDefinition()
{
if (!$this->dataDefinition) {
$this->dataDefinition = EntityDataDefinition::create($this->getEntityTypeId());
$this->dataDefinition->setBundles(array($this->bundle()));
}
return $this->dataDefinition;
}
/**
* @cover fetchDataByPropertyPath
* @expectedException \Drupal\Core\TypedData\Exception\MissingDataException
* @expectedExceptionMessageRegExp #Unable to apply data selector 'field_integer.0.value' at 'field_integer':.*#
*/
public function testFetchingFromEmptyData()
{
$data_empty = $this->typedDataManager->create(EntityDataDefinition::create('node'));
// This should trigger an exception.
$this->dataFetcher->fetchDataByPropertyPath($data_empty, 'field_integer.0.value')->getValue();
}
