/** * {@inheritdoc} */ public static function postDelete(EntityStorageInterface $storage, array $entities) { parent::postDelete($storage, $entities); foreach ($entities as $entity) { entity_invoke_bundle_hook('delete', $entity->getEntityType()->getBundleOf(), $entity->id()); } }
/** * {@inheritdoc} */ public static function postDelete(EntityStorageInterface $storage, array $entities) { parent::postDelete($storage, $entities); foreach ($entities as $entity) { $entity->deleteDisplays(); \Drupal::entityManager()->onBundleDelete($entity->id(), $entity->getEntityType()->getBundleOf()); } }
/** * {@inheritdoc} */ public function preSave(EntityStorageInterface $storage) { parent::preSave($storage); $errors = $this->validate(); if (!empty($errors)) { throw new EncryptException(implode(';', $errors)); } }
/** * {@inheritdoc} */ public function calculateDependencies() { parent::calculateDependencies(); // Make sure we save any explicit module dependencies. if ($provider = $this->get('module')) { $this->addDependency('module', $provider); } return $this->dependencies; }
/** * {@inheritdoc} */ public function calculateDependencies() { parent::calculateDependencies(); if ($this->stateFrom) { $this->addDependency('config', ModerationState::load($this->stateFrom)->getConfigDependencyName()); } if ($this->stateTo) { $this->addDependency('config', ModerationState::load($this->stateTo)->getConfigDependencyName()); } return $this; }
/** * Acts on an entity before the presave hook is invoked. * * Used before the entity is saved and before invoking the presave hook. * * Ensure that config entities which are bundles of other entities cannot have * their ID changed. * * @param \Drupal\Core\Entity\EntityStorageInterface $storage * The entity storage object. * * @throws \Drupal\Core\Config\ConfigNameException * Thrown when attempting to rename a bundle entity. */ public function preSave(EntityStorageInterface $storage) { parent::preSave($storage); // Only handle renames, not creations. if (!$this->isNew() && $this->getOriginalId() !== $this->id()) { $bundle_type = $this->getEntityType(); $bundle_of = $bundle_type->getBundleOf(); if (!empty($bundle_of)) { throw new ConfigNameException("The machine name of the '{$bundle_type->getLabel()}' bundle cannot be changed."); } } }
/** * {@inheritdoc} */ public function calculateDependencies() { parent::calculateDependencies(); $prefix = $this->getModerationStateConfigPrefix() . '.'; if ($this->stateFrom) { $this->addDependency('config', $prefix . $this->stateFrom); } if ($this->stateTo) { $this->addDependency('config', $prefix . $this->stateTo); } return $this; }
/** * {@inheritdoc} */ public static function preDelete(EntityStorageInterface $storage, array $entities) { parent::preDelete($storage, $entities); foreach ($entities as $entity) { $storage->deleteAssignedShortcutSets($entity); // Next, delete the shortcuts for this set. $shortcut_ids = \Drupal::entityQuery('shortcut')->condition('shortcut_set', $entity->id(), '=')->execute(); $controller = \Drupal::entityManager()->getStorage('shortcut'); $entities = $controller->loadMultiple($shortcut_ids); $controller->delete($entities); } }
/** * @covers ::getThirdPartySetting * @covers ::setThirdPartySetting * @covers ::getThirdPartySettings * @covers ::unsetThirdPartySetting * @covers ::getThirdPartyProviders */ public function testThirdPartySettings() { $key = 'test'; $third_party = 'test_provider'; $value = $this->getRandomGenerator()->string(); // Test getThirdPartySetting() with no settings. $this->assertEquals($value, $this->entity->getThirdPartySetting($third_party, $key, $value)); $this->assertNull($this->entity->getThirdPartySetting($third_party, $key)); // Test setThirdPartySetting(). $this->entity->setThirdPartySetting($third_party, $key, $value); $this->assertEquals($value, $this->entity->getThirdPartySetting($third_party, $key)); $this->assertEquals($value, $this->entity->getThirdPartySetting($third_party, $key, $this->randomGenerator->string())); // Test getThirdPartySettings(). $this->entity->setThirdPartySetting($third_party, 'test2', 'value2'); $this->assertEquals(array($key => $value, 'test2' => 'value2'), $this->entity->getThirdPartySettings($third_party)); // Test getThirdPartyProviders(). $this->entity->setThirdPartySetting('test_provider2', $key, $value); $this->assertEquals(array($third_party, 'test_provider2'), $this->entity->getThirdPartyProviders()); // Test unsetThirdPartyProviders(). $this->entity->unsetThirdPartySetting('test_provider2', $key); $this->assertEquals(array($third_party), $this->entity->getThirdPartyProviders()); }
/** * {@inheritdoc} */ public function postCreate(EntityStorageInterface $storage) { parent::postCreate($storage); // If it was not present in the $values passed to create(), (e.g. for // programmatic creation), populate the denormalized field_type property // from the field storage, so that it gets saved in the config record. if (empty($this->field_type)) { $this->field_type = $this->getFieldStorageDefinition()->getType(); } }
/** * Get all states in the system, with options to filter, only where a workflow exists. * * @_deprecated WorkflowState::getStates() ==> WorkflowState::loadMultiple() * * {@inheritdoc} * * @param $wid * The requested Workflow ID. * @param bool $reset * An option to refresh all caches. * * @return WorkflowState[] $states * An array of cached states. */ public static function loadMultiple(array $ids = NULL, $wid = '', $reset = FALSE) { if ($reset) { self::$states = array(); } if (empty(self::$states)) { self::$states = parent::loadMultiple(); usort(self::$states, ['Drupal\\workflow\\Entity\\WorkflowState', 'sort']); } if (!$wid) { // All states are requested and cached: return them. $result = self::$states; } else { // All states of only 1 Workflow is requested: return this one. // E.g., when called by Workflow->getStates(). $result = array(); foreach (self::$states as $state) { /* @var $state WorkflowState */ if ($state->wid == $wid) { $result[$state->id()] = $state; } } } return $result; }
/** * {@inheritdoc} */ public static function preDelete(EntityStorageInterface $storage, array $entities) { parent::preDelete($storage, $entities); \Drupal::entityManager()->clearCachedFieldDefinitions(); }
/** * {@inheritdoc} */ public static function postDelete(EntityStorageInterface $storage, array $entities) { parent::postDelete($storage, $entities); static::routeBuilder()->setRebuildNeeded(); }
/** * {@inheritdoc} */ public function calculateDependencies() { parent::calculateDependencies(); $providers = \Drupal::service('breakpoint.manager')->getGroupProviders($this->breakpoint_group); foreach ($providers as $provider => $type) { $this->addDependency($type, $provider); } // Extract all the styles from the image style mappings. $styles = ImageStyle::loadMultiple($this->getImageStyleIds()); array_walk($styles, function ($style) { $this->addDependency('config', $style->getConfigDependencyName()); }); return $this; }
/** * {@inheritdoc} */ public function getCacheTags() { $tags = parent::getCacheTags(); return Cache::mergeTags($tags, ['block_visibility_group:' . $this->id]); }
/** * {@inheritdoc} */ public static function postDelete(EntityStorageInterface $storage, array $entities) { parent::postDelete($storage, $entities); $language_manager = \Drupal::languageManager(); $language_manager->reset(); $entity = reset($entities); if ($language_manager instanceof ConfigurableLanguageManagerInterface && !$entity->isUninstalling() && !$entity->isSyncing()) { $language_manager->updateLockedLanguageWeights(); } // If after deleting this language the site will become monolingual, we need // to rebuild language services. if (!\Drupal::languageManager()->isMultilingual()) { ConfigurableLanguageManager::rebuildServices(); } }
/** * {@inheritdoc} */ public function calculateDependencies() { parent::calculateDependencies(); if ($this->getPlugin()) { $this->addDependency('module', $this->getPlugin()->getPluginDefinition()['provider']); } return $this; }
/** * {@inheritdoc} */ public function postSave(EntityStorageInterface $storage, $update = TRUE) { parent::postSave($storage, $update); // Clear the static caches of filter_formats() and others. filter_formats_reset(); if (!$update && !$this->isSyncing()) { // Default configuration of modules and installation profiles is allowed // to specify a list of user roles to grant access to for the new format; // apply the defined user role permissions when a new format is inserted // and has a non-empty $roles property. // Note: user_role_change_permissions() triggers a call chain back into // \Drupal\filter\FilterPermissions::permissions() and lastly // filter_formats(), so its cache must be reset upfront. if (($roles = $this->get('roles')) && ($permission = $this->getPermissionName())) { foreach (user_roles() as $rid => $name) { $enabled = in_array($rid, $roles, TRUE); user_role_change_permissions($rid, array($permission => $enabled)); } } } }
/** * {@inheritdoc} */ public function get($property_name) { if ($property_name == 'default') { return $this->isDefault(); } else { return parent::get($property_name); } }
/** * {@inheritdoc} */ public static function postDelete(EntityStorageInterface $storage, array $entities) { parent::postDelete($storage, $entities); foreach ($entities as $style) { // Flush cached media for the deleted style. $style->flush(); // Check whether field settings need to be updated. // In case no replacement style was specified, all image fields that are // using the deleted style are left in a broken state. if (!$style->isSyncing() && ($new_id = $style->getReplacementID())) { // The deleted ID is still set as originalID. $style->setName($new_id); static::replaceImageStyle($style); } } }
/** * {@inheritdoc} */ public function delete() { foreach (array_keys($this->getLinks([], TRUE)) as $link_key) { $this->getMenuLinkManager()->removeDefinition($link_key, FALSE); } parent::delete(); }
/** * {@inheritdoc} */ public function onDependencyRemoval(array $dependencies) { $changed = parent::onDependencyRemoval($dependencies); if (!isset($this->dependencies['enforced']['config'])) { return $changed; } $fix_deps = \Drupal::state()->get('config_test.fix_dependencies', array()); foreach ($dependencies['config'] as $entity) { if (in_array($entity->getConfigDependencyName(), $fix_deps)) { $key = array_search($entity->getConfigDependencyName(), $this->dependencies['enforced']['config']); if ($key !== FALSE) { $changed = TRUE; unset($this->dependencies['enforced']['config'][$key]); } } } return $changed; }
/** * {@inheritdoc} */ public static function preDelete(EntityStorageInterface $storage, array $field_storages) { $state = \Drupal::state(); // Set the static flag so that we don't delete field storages whilst // deleting fields. static::$inDeletion = TRUE; // Delete or fix any configuration that is dependent, for example, fields. parent::preDelete($storage, $field_storages); // Keep the field definitions in the state storage so we can use them later // during field_purge_batch(). $deleted_storages = $state->get('field.storage.deleted') ?: array(); foreach ($field_storages as $field_storage) { if (!$field_storage->deleted) { $config = $field_storage->toArray(); $config['deleted'] = TRUE; $config['bundles'] = $field_storage->getBundles(); $deleted_storages[$field_storage->uuid()] = $config; } } $state->set('field.storage.deleted', $deleted_storages); }
/** * {@inheritdoc} */ public static function sort(ConfigEntityInterface $a, ConfigEntityInterface $b) { /** @var $a \Drupal\search\SearchPageInterface */ /** @var $b \Drupal\search\SearchPageInterface */ $a_status = (int) $a->status(); $b_status = (int) $b->status(); if ($a_status != $b_status) { return $a_status > $b_status ? -1 : 1; } return parent::sort($a, $b); }
/** * {@inheritdoc} */ public function calculateDependencies() { parent::calculateDependencies(); foreach ($this->tipsCollection as $instance) { $definition = $instance->getPluginDefinition(); $this->addDependency('module', $definition['provider']); } $this->addDependency('module', $this->module); return $this; }
/** * Overrides Drupal\Core\Entity\Entity:preCreate(). */ public static function preCreate(EntityStorageInterface $storage_controller, array &$values) { parent::preCreate($storage_controller, $values); $loader = \Drupal::service('domain.loader'); $creator = \Drupal::service('domain.creator'); $default = $loader->loadDefaultId(); $domains = $loader->loadMultiple(); $values += array('scheme' => empty($GLOBALS['is_https']) ? 'http' : 'https', 'status' => 1, 'weight' => count($domains) + 1, 'is_default' => (int) empty($default), 'domain_id' => $creator->createNextId()); }
/** * {@inheritdoc} */ public static function sort(ConfigEntityInterface $a, ConfigEntityInterface $b) { /** @var \Drupal\system\ActionConfigEntityInterface $a */ /** @var \Drupal\system\ActionConfigEntityInterface $b */ $a_type = $a->getType(); $b_type = $b->getType(); if ($a_type != $b_type) { return strnatcasecmp($a_type, $b_type); } return parent::sort($a, $b); }
/** * {@inheritdoc} */ public function calculateDependencies() { parent::calculateDependencies(); foreach ($this->test_dependencies as $type => $deps) { foreach ($deps as $dep) { $this->addDependency($type, $dep); } } }
/** * {@inheritdoc} */ public function postSave(EntityStorageInterface $storage_controller, $update = TRUE) { parent::postSave($storage_controller, $update); // Set bypass permissions. $roles = $this->getBypassRoles(); $permission = $this->getPermissionName(); if ($roles && $permission) { foreach (user_roles() as $rid => $name) { $enabled = in_array($rid, $roles, TRUE); user_role_change_permissions($rid, array($permission => $enabled)); } } }
/** * {@inheritdoc} */ public function calculateDependencies() { parent::calculateDependencies(); // Create a dependency on the associated FilterFormat. $this->addDependency('config', $this->getFilterFormat()->getConfigDependencyName()); // @todo use EntityWithPluginCollectionInterface so configuration between // config entity and dependency on provider is managed automatically. $definition = $this->editorPluginManager()->createInstance($this->editor)->getPluginDefinition(); $this->addDependency('module', $definition['provider']); return $this->dependencies; }