FieldConfig.php 11.6 KB
Newer Older
1
2
<?php

3
namespace Drupal\field\Entity;
4

5
use Drupal\Core\Entity\EntityStorageInterface;
6
use Drupal\Core\Entity\FieldableEntityStorageInterface;
7
use Drupal\Core\Field\FieldConfigBase;
8
use Drupal\Core\Field\FieldException;
9
use Drupal\field\FieldStorageConfigInterface;
10
use Drupal\field\FieldConfigInterface;
11
12

/**
13
 * Defines the Field entity.
14
 *
15
 * @ConfigEntityType(
16
17
 *   id = "field_config",
 *   label = @Translation("Field"),
18
 *   handlers = {
19
20
 *     "access" = "Drupal\field\FieldConfigAccessControlHandler",
 *     "storage" = "Drupal\field\FieldConfigStorage"
21
 *   },
22
 *   config_prefix = "field",
23
24
 *   entity_keys = {
 *     "id" = "id",
25
 *     "label" = "label"
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 *   },
 *   config_export = {
 *     "id",
 *     "field_name",
 *     "entity_type",
 *     "bundle",
 *     "label",
 *     "description",
 *     "required",
 *     "translatable",
 *     "default_value",
 *     "default_value_callback",
 *     "settings",
 *     "field_type",
40
41
42
 *   }
 * )
 */
43
class FieldConfig extends FieldConfigBase implements FieldConfigInterface {
44
45

  /**
46
   * Flag indicating whether the field is deleted.
47
   *
48
   * The delete() method marks the field as "deleted" and removes the
49
50
51
52
   * corresponding entry from the config storage, but keeps its definition in
   * the state storage while field data is purged by a separate
   * garbage-collection process.
   *
53
   * Deleted fields stay out of the regular entity lifecycle (notably, their
54
55
56
57
   * values are not populated in loaded entities, and are not saved back).
   *
   * @var bool
   */
58
  protected $deleted = FALSE;
59

60
  /**
61
   * The associated FieldStorageConfig entity.
62
   *
63
   * @var \Drupal\field\Entity\FieldStorageConfig
64
   */
65
  protected $fieldStorage;
66

67
  /**
68
   * Constructs a FieldConfig object.
69
   *
70
   * In most cases, Field entities are created via
71
   * FieldConfig::create($values), where $values is the same
72
73
   * parameter as in this constructor.
   *
74
   * @param array $values
75
   *   An array of field properties, keyed by property name. The
76
   *   storage associated with the field can be specified either with:
77
78
79
   *   - field_storage: the FieldStorageConfigInterface object,
   *   or by referring to an existing field storage in the current configuration
   *   with:
80
81
82
   *   - field_name: The field name.
   *   - entity_type: The entity type.
   *   Additionally, a 'bundle' property is required to indicate the entity
83
   *   bundle to which the field is attached to. Other array elements will be
84
85
86
   *   used to set the corresponding properties on the class; see the class
   *   property documentation for details.
   *
87
   * @see entity_create()
88
   */
89
  public function __construct(array $values, $entity_type = 'field_config') {
90
    // Allow either an injected FieldStorageConfig object, or a field_name and
91
    // entity_type.
92
93
    if (isset($values['field_storage'])) {
      if (!$values['field_storage'] instanceof FieldStorageConfigInterface) {
94
        throw new FieldException('Attempt to create a configurable field for a non-configurable field storage.');
95
      }
96
97
98
      $field_storage = $values['field_storage'];
      $values['field_name'] = $field_storage->getName();
      $values['entity_type'] = $field_storage->getTargetEntityTypeId();
99
100
101
      // The internal property is fieldStorage, not field_storage.
      unset($values['field_storage']);
      $values['fieldStorage'] = $field_storage;
102
    }
103
104
    else {
      if (empty($values['field_name'])) {
105
        throw new FieldException('Attempt to create a field without a field_name.');
106
107
      }
      if (empty($values['entity_type'])) {
108
        throw new FieldException("Attempt to create a field '{$values['field_name']}' without an entity_type.");
109
      }
110
    }
111
    // 'bundle' is required in either case.
112
    if (empty($values['bundle'])) {
113
      throw new FieldException("Attempt to create a field '{$values['field_name']}' without a bundle.");
114
115
116
117
118
    }

    parent::__construct($values, $entity_type);
  }

119
120
121
122
  /**
   * {@inheritdoc}
   */
  public function postCreate(EntityStorageInterface $storage) {
123
124
    parent::postCreate($storage);

125
    // Validate that we have a valid storage for this field. This throws an
126
    // exception if the storage is invalid.
127
    $this->getFieldStorageDefinition();
128

129
130
    // 'Label' defaults to the field name (mostly useful for fields created in
    // tests).
131
    if (empty($this->label)) {
132
      $this->label = $this->getName();
133
134
135
    }
  }

136
  /**
137
   * Overrides \Drupal\Core\Entity\Entity::preSave().
138
   *
139
   * @throws \Drupal\Core\Field\FieldException
140
   *   If the field definition is invalid.
141
142
   * @throws \Drupal\Core\Entity\EntityStorageException
   *   In case of failures at the configuration storage level.
143
   */
144
  public function preSave(EntityStorageInterface $storage) {
145
146
147
    $entity_manager = \Drupal::entityManager();
    $field_type_manager = \Drupal::service('plugin.manager.field.field_type');

148
    $storage_definition = $this->getFieldStorageDefinition();
149

150
151
152
    // Filter out unknown settings and make sure all settings are present, so
    // that a complete field definition is passed to the various hooks and
    // written to config.
153
    $default_settings = $field_type_manager->getDefaultFieldSettings($storage_definition->getType());
154
155
    $this->settings = array_intersect_key($this->settings, $default_settings) + $default_settings;

156
    if ($this->isNew()) {
157
      // Notify the entity storage.
158
      $entity_manager->onFieldDefinitionCreate($this);
159
160
    }
    else {
161
162
      // Some updates are always disallowed.
      if ($this->entity_type != $this->original->entity_type) {
163
        throw new FieldException("Cannot change an existing field's entity_type.");
164
      }
165
      if ($this->bundle != $this->original->bundle) {
166
        throw new FieldException("Cannot change an existing field's bundle.");
167
      }
168
      if ($storage_definition->uuid() != $this->original->getFieldStorageDefinition()->uuid()) {
169
        throw new FieldException("Cannot change an existing field's storage.");
170
      }
171
      // Notify the entity storage.
172
      $entity_manager->onFieldDefinitionUpdate($this, $this->original);
173
    }
174
175

    parent::preSave($storage);
176
177
178
179
180
181
182
  }

  /**
   * {@inheritdoc}
   */
  public function calculateDependencies() {
    parent::calculateDependencies();
183
    // Mark the field_storage_config as a dependency.
184
    $this->addDependency('config', $this->getFieldStorageDefinition()->getConfigDependencyName());
185
    return $this;
186
  }
187

188
  /**
189
   * {@inheritdoc}
190
   */
191
  public static function preDelete(EntityStorageInterface $storage, array $fields) {
192
    $state = \Drupal::state();
193
    $entity_type_manager = \Drupal::entityTypeManager();
194

195
    parent::preDelete($storage, $fields);
196
    // Keep the field definitions in the state storage so we can use them
197
    // later during field_purge_batch().
198
    $deleted_fields = $state->get('field.field.deleted') ?: [];
199
200

    /** @var \Drupal\field\FieldConfigInterface $field */
201
    foreach ($fields as $field) {
202
203
204
205
      // Only mark a field for purging if there is data. Otherwise, just remove
      // it.
      $target_entity_storage = $entity_type_manager->getStorage($field->getTargetEntityTypeId());
      if (!$field->deleted && $target_entity_storage instanceof FieldableEntityStorageInterface && $target_entity_storage->countFieldData($field->getFieldStorageDefinition(), TRUE)) {
206
        $config = $field->toArray();
207
        $config['deleted'] = TRUE;
208
209
        $config['field_storage_uuid'] = $field->getFieldStorageDefinition()->uuid();
        $deleted_fields[$field->uuid()] = $config;
210
      }
211
    }
212
    $state->set('field.field.deleted', $deleted_fields);
213
214
  }

215
  /**
216
   * {@inheritdoc}
217
   */
218
  public static function postDelete(EntityStorageInterface $storage, array $fields) {
219
    // Clear the cache upfront, to refresh the results of getBundles().
220
    \Drupal::entityManager()->clearCachedFieldDefinitions();
221

222
    // Notify the entity storage.
223
224
    foreach ($fields as $field) {
      if (!$field->deleted) {
225
        \Drupal::entityManager()->onFieldDefinitionDelete($field);
226
      }
227
    }
228

229
230
    // If this is part of a configuration synchronization then the following
    // configuration updates are not necessary.
231
    $entity = reset($fields);
232
233
234
235
    if ($entity->isSyncing()) {
      return;
    }

236
237
    // Delete the associated field storages if they are not used anymore and are
    // not persistent.
238
    $storages_to_delete = [];
239
240
    foreach ($fields as $field) {
      $storage_definition = $field->getFieldStorageDefinition();
241
      if (!$field->deleted && !$field->isUninstalling() && $storage_definition->isDeletable()) {
242
243
        // Key by field UUID to avoid deleting the same storage twice.
        $storages_to_delete[$storage_definition->uuid()] = $storage_definition;
244
      }
245
    }
246
247
    if ($storages_to_delete) {
      \Drupal::entityManager()->getStorage('field_storage_config')->delete($storages_to_delete);
248
    }
249
250
  }

251
252
253
  /**
   * {@inheritdoc}
   */
254
255
256
  protected function linkTemplates() {
    $link_templates = parent::linkTemplates();
    if (\Drupal::moduleHandler()->moduleExists('field_ui')) {
257
258
259
      $link_templates["{$this->entity_type}-field-edit-form"] = 'entity.field_config.' . $this->entity_type . '_field_edit_form';
      $link_templates["{$this->entity_type}-storage-edit-form"] = 'entity.field_config.' . $this->entity_type . '_storage_edit_form';
      $link_templates["{$this->entity_type}-field-delete-form"] = 'entity.field_config.' . $this->entity_type . '_field_delete_form';
260

261
262
      if (isset($link_templates['config-translation-overview'])) {
        $link_templates["config-translation-overview.{$this->entity_type}"] = "entity.field_config.config_translation_overview.{$this->entity_type}";
263
      }
264
    }
265
266
    return $link_templates;
  }
267

268
269
270
  /**
   * {@inheritdoc}
   */
271
272
  protected function urlRouteParameters($rel) {
    $parameters = parent::urlRouteParameters($rel);
273
    $entity_type = \Drupal::entityManager()->getDefinition($this->entity_type);
274
275
    $bundle_parameter_key = $entity_type->getBundleEntityType() ?: 'bundle';
    $parameters[$bundle_parameter_key] = $this->bundle;
276
    return $parameters;
277
278
  }

279
280
281
  /**
   * {@inheritdoc}
   */
282
283
  public function isDeleted() {
    return $this->deleted;
284
285
  }

286
287
288
  /**
   * {@inheritdoc}
   */
289
290
291
292
  public function getFieldStorageDefinition() {
    if (!$this->fieldStorage) {
      $fields = $this->entityManager()->getFieldStorageDefinitions($this->entity_type);
      if (!isset($fields[$this->field_name])) {
293
        throw new FieldException("Attempt to create a field {$this->field_name} that does not exist on entity type {$this->entity_type}.");
294
      }
295
      if (!$fields[$this->field_name] instanceof FieldStorageConfigInterface) {
296
        throw new FieldException("Attempt to create a configurable field of non-configurable field storage {$this->field_name}.");
297
298
      }
      $this->fieldStorage = $fields[$this->field_name];
299
    }
300
301

    return $this->fieldStorage;
302
303
  }

304
305
306
307
308
309
310
311
312
313
314
315
  /**
   * {@inheritdoc}
   */
  public function isDisplayConfigurable($context) {
    return TRUE;
  }

  /**
   * {@inheritdoc}
   */
  public function getDisplayOptions($display_context) {
    // Hide configurable fields by default.
316
    return ['region' => 'hidden'];
317
318
  }

319
320
321
322
323
324
325
326
327
328
329
330
331
332
  /**
   * {@inheritdoc}
   */
  public function isReadOnly() {
    return FALSE;
  }

  /**
   * {@inheritdoc}
   */
  public function isComputed() {
    return FALSE;
  }

333
334
335
336
337
338
339
340
341
342
343
  /**
   * Loads a field config entity based on the entity type and field name.
   *
   * @param string $entity_type_id
   *   ID of the entity type.
   * @param string $bundle
   *   Bundle name.
   * @param string $field_name
   *   Name of the field.
   *
   * @return static
344
   *   The field config entity if one exists for the provided field
345
346
347
   *   name, otherwise NULL.
   */
  public static function loadByName($entity_type_id, $bundle, $field_name) {
348
    return \Drupal::entityManager()->getStorage('field_config')->load($entity_type_id . '.' . $bundle . '.' . $field_name);
349
350
  }

351
}