/** * {@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(); }