/**
* Form builder callback.
*
* @todo I don't know why this needs to be separate from the form() method.
* It was in the form_alter version but we should see if we can just fold
* it into the method above.
*
* @param $entity_type
* @param \Drupal\Core\Config\Entity\ConfigEntityInterface $bundle
* @param array $form
* @param \Drupal\Core\Form\FormStateInterface $form_state
*/
public function formBuilderCallback($entity_type, ConfigEntityInterface $bundle, &$form, FormStateInterface $form_state)
{
// @todo write a test for this.
$bundle->setThirdPartySetting('workbench_moderation', 'enabled', $form_state->getValue('enable_moderation_state'));
$bundle->setThirdPartySetting('workbench_moderation', 'allowed_moderation_states', array_keys(array_filter($form_state->getValue('allowed_moderation_states'))));
$bundle->setThirdPartySetting('workbench_moderation', 'default_moderation_state', $form_state->getValue('default_moderation_state'));
}
/**
* {@inheritdoc}
*/
public static function sort(ConfigEntityInterface $a, ConfigEntityInterface $b)
{
if ($a->isLocked() == $b->isLocked()) {
$a_label = $a->label();
$b_label = $b->label();
return strnatcasecmp($a_label, $b_label);
}
return $a->isLocked() ? 1 : -1;
}
/**
* {@inheritdoc}
*/
public static function sort(ConfigEntityInterface $a, ConfigEntityInterface $b)
{
/** @var \Drupal\Core\Entity\EntityDisplayModeInterface $a */
/** @var \Drupal\Core\Entity\EntityDisplayModeInterface $b */
// Sort by the type of entity the view mode is used for.
$a_type = $a->getTargetType();
$b_type = $b->getTargetType();
$type_order = strnatcasecmp($a_type, $b_type);
return $type_order != 0 ? $type_order : parent::sort($a, $b);
}
/**
* {@inheritdoc}
*/
protected function getConfigNamesToDelete(ConfigEntityInterface $entity)
{
/** @var \Drupal\field\FieldStorageConfigInterface $field_storage */
$field_storage = $entity->getFieldStorageDefinition();
$config_names = [$entity->getConfigDependencyName()];
// If there is only one bundle left for this field storage, it will be
// deleted too, notify the user about dependencies.
if (count($field_storage->getBundles()) <= 1) {
$config_names[] = $field_storage->getConfigDependencyName();
}
return $config_names;
}
/**
* Asserts that a config entity can be imported without changing it.
*
* @param \Drupal\Core\Config\Entity\ConfigEntityInterface $entity
* The config entity to test importing.
*/
public function assertConfigEntityImport(ConfigEntityInterface $entity)
{
// Save original config information.
$entity_uuid = $entity->uuid();
$entity_type_id = $entity->getEntityTypeId();
$original_data = $entity->toArray();
// Copy everything to sync.
$this->copyConfig(\Drupal::service('config.storage'), \Drupal::service('config.storage.sync'));
// Delete the configuration from active. Don't worry about side effects of
// deleting config like fields cleaning up field storages. The coming import
// should recreate everything as necessary.
$entity->delete();
$this->configImporter()->reset()->import();
$imported_entity = \Drupal::entityManager()->loadEntityByUuid($entity_type_id, $entity_uuid);
$this->assertIdentical($original_data, $imported_entity->toArray());
}
/**
* Tests a tracker with a dependency that gets removed.
*
* @param bool $remove_dependency
* Whether to remove the dependency from the tracker when the object
* depended on is deleted.
*
* @dataProvider dependencyTestDataProvider
*/
public function testTrackerDependency($remove_dependency)
{
// Set the tracker for the index and save it. The tracker configuration
// contains the dependencies it will return – in our case, we use the test
// server.
$dependency_key = $this->dependency->getConfigDependencyKey();
$dependency_name = $this->dependency->getConfigDependencyName();
$tracker = \Drupal::getContainer()->get('plugin.manager.search_api.tracker')->createInstance('search_api_test_dependencies', array($dependency_key => array($dependency_name)));
$this->index->setTracker($tracker);
$this->index->save();
// Check the dependencies were calculated correctly.
$dependencies = $this->index->getDependencies();
$this->assertContains($dependency_name, $dependencies[$dependency_key], 'Tracker dependency correctly inserted');
// Set our magic state key to let the test plugin know whether the
// dependency should be removed or not. See
// \Drupal\search_api_test_dependencies\Plugin\search_api\tracker\TestTracker::onDependencyRemoval().
$key = 'search_api_test_dependencies.tracker.remove';
\Drupal::state()->set($key, $remove_dependency);
// If the index resets the tracker, it needs to know the ID of the default
// tracker.
if (!$remove_dependency) {
\Drupal::configFactory()->getEditable('search_api.settings')->set('default_tracker', 'default')->save();
}
// Delete the tracker's dependency.
$this->dependency->delete();
// Reload the index and check it's still there.
$this->reloadIndex();
$this->assertInstanceOf('Drupal\\search_api\\IndexInterface', $this->index, 'Index not removed');
// Make sure the dependency has been removed, one way or the other.
$dependencies = $this->index->getDependencies();
$dependencies += array($dependency_key => array());
$this->assertNotContains($dependency_name, $dependencies[$dependency_key], 'Tracker dependency removed from index');
// Depending on whether the plugin should have removed the dependency or
// not, make sure the right action was taken.
$tracker_instance = $this->index->getTrackerInstance();
$tracker_id = $tracker_instance->getPluginId();
$tracker_config = $tracker_instance->getConfiguration();
if ($remove_dependency) {
$this->assertEquals('search_api_test_dependencies', $tracker_id, 'Tracker not reset');
$this->assertEmpty($tracker_config, 'Tracker settings adapted');
} else {
$this->assertEquals('default', $tracker_id, 'Tracker was reset');
$this->assertEmpty($tracker_config, 'Tracker settings were cleared');
}
}
/**
* {@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 updateFromStorageRecord(ConfigEntityInterface $entity, array $values)
{
$entity->original = clone $entity;
$data = $this->mapFromStorageRecords(array($values));
$updated_entity = current($data);
foreach (array_keys($values) as $property) {
$value = $updated_entity->get($property);
$entity->set($property, $value);
}
return $entity;
}
/**
* Adds the configured context definitions from the config entity.
*
* Example: for a reaction rule config all context definitions of the event
* will be added.
*
* @param \Drupal\Core\Config\Entity\ConfigEntityInterface $rules_config
* The config entity.
*
* @return $this
*/
public function addContextDefinitionsFrom(ConfigEntityInterface $rules_config)
{
if ($rules_config instanceof ReactionRuleConfig) {
$event_name = $rules_config->getEvent();
// @todo Use setter injection for the service.
$event_definition = \Drupal::service('plugin.manager.rules_event')->getDefinition($event_name);
foreach ($event_definition['context'] as $context_name => $context_definition) {
$this->addContextDefinition($context_name, $context_definition);
}
}
return $this;
}
/**
* {@inheritdoc}
*/
public static function sort(ConfigEntityInterface $a, ConfigEntityInterface $b)
{
// Sort the entities using the entity class's sort() method.
// See \Drupal\Core\Config\Entity\ConfigEntityBase::sort().
/* @var $a WorkflowTransitionInterface */
/* @var $b WorkflowTransitionInterface */
if (!$a->getFromSid() || !$b->getFromSid()) {
return 0;
}
// First sort on From-State.
$from_state_a = $a->getFromState();
$from_state_b = $b->getFromState();
if ($from_state_a->weight < $from_state_b->weight) {
return -1;
}
if ($from_state_a->weight > $from_state_b->weight) {
return +1;
}
// Then sort on To-State.
$to_state_a = $a->getToState();
$to_state_b = $b->getToState();
if ($to_state_a->weight < $to_state_b->weight) {
return -1;
}
if ($to_state_a->weight > $to_state_b->weight) {
return +1;
}
return 0;
}
/**
* Sorts active blocks by weight; sorts inactive blocks by name.
*/
public static function sort(ConfigEntityInterface $a, ConfigEntityInterface $b)
{
// Separate enabled from disabled.
$status = $b->get('status') - $a->get('status');
if ($status) {
return $status;
}
// Sort by weight, unless disabled.
if ($a->get('region') != static::BLOCK_REGION_NONE) {
$weight = $a->get('weight') - $b->get('weight');
if ($weight) {
return $weight;
}
}
// Sort by label.
return strcmp($a->label(), $b->label());
}
/**
* {@inheritdoc}
*/
public static function sort(ConfigEntityInterface $a, ConfigEntityInterface $b)
{
$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);
}
/**
* Returns config names to delete for the deletion confirmation form.
*
* @param \Drupal\Core\Config\Entity\ConfigEntityInterface $entity
* The entity being deleted.
*
* @return string[]
* A list of configuration names that will be deleted by this form.
*/
protected function getConfigNamesToDelete(ConfigEntityInterface $entity)
{
return [$entity->getConfigDependencyName()];
}
/**
* @covers ::save
* @covers ::doSave
*
* @depends testSaveInsert
*/
public function testSaveRename(ConfigEntityInterface $entity)
{
$config_object = $this->getMockBuilder('Drupal\\Core\\Config\\Config')->disableOriginalConstructor()->getMock();
$config_object->expects($this->atLeastOnce())->method('isNew')->will($this->returnValue(FALSE));
$config_object->expects($this->exactly(1))->method('setData');
$config_object->expects($this->once())->method('save');
$config_object->expects($this->atLeastOnce())->method('get')->willReturn([]);
$this->cacheTagsInvalidator->expects($this->once())->method('invalidateTags')->with(array($this->entityTypeId . '_list'));
$this->configFactory->expects($this->once())->method('rename')->willReturn($this->configFactory);
$this->configFactory->expects($this->exactly(1))->method('getEditable')->with('the_config_prefix.bar')->will($this->returnValue($config_object));
$this->configFactory->expects($this->exactly(2))->method('loadMultiple')->with(array('the_config_prefix.foo'))->will($this->returnValue(array()));
$this->configFactory->expects($this->once())->method('get')->with('the_config_prefix.foo')->will($this->returnValue($config_object));
// Performing a rename does not change the original ID until saving.
$this->assertSame('foo', $entity->getOriginalId());
$entity->set('id', 'bar');
$this->assertSame('foo', $entity->getOriginalId());
$this->entityQuery->expects($this->once())->method('condition')->with('uuid', 'bar')->will($this->returnSelf());
$this->entityQuery->expects($this->once())->method('execute')->will($this->returnValue(array($entity->id())));
$return = $this->entityStorage->save($entity);
$this->assertSame(SAVED_UPDATED, $return);
$this->assertSame('bar', $entity->getOriginalId());
}
/**
* Builds a table row for overview form.
*
* @param \Drupal\Core\Config\Entity\ConfigEntityInterface $entity
* Data needed to build the list row.
*
* @return array
* A single table row for the overview.
*/
public function overviewRow(ConfigEntityInterface $entity)
{
$label = $entity->label() ?: $this->t('@type: @id', array('@type' => $entity->getEntityTypeId(), '@id' => $entity->id()));
// Get current job items for the entity to determine translation statuses.
$source_lang = $entity->language()->getId();
$current_job_items = tmgmt_job_item_load_latest('config', $entity->getEntityTypeId(), $entity->getConfigDependencyName(), $source_lang);
$row['id'] = $entity->id();
$definition = \Drupal::entityTypeManager()->getDefinition($entity->bundle());
$row['config_id'] = $definition->getConfigPrefix() . '.' . $entity->id();
if ($entity->hasLinkTemplate('edit-form')) {
$row['title'] = $entity->toLink($label, 'edit-form');
} else {
// If the entity doesn't have a link we display a label.
$row['title'] = $label;
}
// Load entity translation specific data.
foreach (\Drupal::languageManager()->getLanguages() as $langcode => $language) {
$translation_status = 'current';
if ($langcode == $source_lang) {
$translation_status = 'original';
} elseif (!$this->isTranslated($langcode, $entity->getConfigDependencyName())) {
$translation_status = 'missing';
}
// @todo Find a way to support marking configuration translations as outdated.
$build = $this->buildTranslationStatus($translation_status, isset($current_job_items[$langcode]) ? $current_job_items[$langcode] : NULL);
$row['langcode-' . $langcode] = ['data' => \Drupal::service('renderer')->render($build), 'class' => array('langstatus-' . $langcode)];
}
return $row;
}
/**
* {@inheritdoc}
*/
public static function sort(ConfigEntityInterface $a, ConfigEntityInterface $b)
{
/* @var $a WorkflowState */
/* @var $b WorkflowState */
$a_wid = $a->wid;
$b_wid = $b->wid;
if ($a_wid == $b_wid) {
$a_weight = $a->getWeight();
$b_weight = $b->getWeight();
return $a_weight < $b_weight ? -1 : 1;
}
return $a_wid < $b_wid ? -1 : 1;
}
/**
* Sorts active blocks by weight; sorts inactive blocks by name.
*/
public static function sort(ConfigEntityInterface $a, ConfigEntityInterface $b)
{
// Separate enabled from disabled.
$status = (int) $b->status() - (int) $a->status();
if ($status !== 0) {
return $status;
}
// Sort by weight, unless disabled.
if ($a->getRegion() != static::BLOCK_REGION_NONE) {
$weight = $a->getWeight() - $b->getWeight();
if ($weight) {
return $weight;
}
}
// Sort by label.
return strcmp($a->label(), $b->label());
}
/**
* Creates an event entity.
*
* @param \Drupal\Core\Config\Entity\ConfigEntityInterface
* An entity type.
* @param array $settings
* Additional settings for the new entity.
*
* @return \Drupal\Core\Entity\EntityInterface
* An event.
*/
function createEntity(ConfigEntityInterface $entity_type, $settings = [])
{
// @todo change to custom entity
$entity = $this->drupalCreateNode(['type' => $entity_type->id()] + $settings);
return $entity;
}
/**
* {@inheritdoc}
*/
public function getBaseRouteParameters()
{
return array($this->entityType => $this->entity->id());
}
/**
* {@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);
}
/**
* Calls an entity's onDependencyRemoval() method.
*
* A helper method to call onDependencyRemoval() with the correct list of
* affected entities. This list should only contain dependencies on the
* entity. Configuration and content entity dependencies will be converted
* into entity objects.
*
* @param \Drupal\Core\Config\Entity\ConfigEntityInterface $entity
* The entity to call onDependencyRemoval() on.
* @param \Drupal\Core\Config\Entity\ConfigEntityInterface[] $dependent_entities
* The list of dependent configuration entities.
* @param string $type
* The type of dependency being checked. Either 'module', 'theme', 'config'
* or 'content'.
* @param array $names
* The specific names to check. If $type equals 'module' or 'theme' then it
* should be a list of module names or theme names. In the case of 'config'
* or 'content' it should be a list of configuration dependency names.
*
* @return bool
* TRUE if the entity has changed as a result of calling the
* onDependencyRemoval() method, FALSE if not.
*/
protected function callOnDependencyRemoval(ConfigEntityInterface $entity, array $dependent_entities, $type, array $names)
{
$entity_dependencies = $entity->getDependencies();
if (empty($entity_dependencies)) {
// No dependent entities nothing to do.
return FALSE;
}
$affected_dependencies = array('config' => array(), 'content' => array(), 'module' => array(), 'theme' => array());
// Work out if any of the entity's dependencies are going to be affected.
if (isset($entity_dependencies[$type])) {
// Work out which dependencies the entity has in common with the provided
// $type and $names.
$affected_dependencies[$type] = array_intersect($entity_dependencies[$type], $names);
// If the dependencies are entities we need to convert them into objects.
if ($type == 'config' || $type == 'content') {
$affected_dependencies[$type] = array_map(function ($name) use($type) {
if ($type == 'config') {
return $this->loadConfigEntityByName($name);
} else {
// Ignore the bundle.
list($entity_type_id, , $uuid) = explode(':', $name);
return $this->entityManager->loadEntityByConfigTarget($entity_type_id, $uuid);
}
}, $affected_dependencies[$type]);
}
}
// Merge any other configuration entities into the list of affected
// dependencies if necessary.
if (isset($entity_dependencies['config'])) {
foreach ($dependent_entities as $dependent_entity) {
if (in_array($dependent_entity->getConfigDependencyName(), $entity_dependencies['config'])) {
$affected_dependencies['config'][] = $dependent_entity;
}
}
}
// Key the entity arrays by config dependency name to make searching easy.
foreach (['config', 'content'] as $dependency_type) {
$affected_dependencies[$dependency_type] = array_combine(array_map(function ($entity) {
return $entity->getConfigDependencyName();
}, $affected_dependencies[$dependency_type]), $affected_dependencies[$dependency_type]);
}
// Inform the entity.
return $entity->onDependencyRemoval($affected_dependencies);
}
/**
* Helper callback for uasort() to sort configuration entities by weight and label.
*/
public static function sort(ConfigEntityInterface $a, ConfigEntityInterface $b)
{
$a_weight = isset($a->weight) ? $a->weight : 0;
$b_weight = isset($b->weight) ? $b->weight : 0;
if ($a_weight == $b_weight) {
$a_label = $a->label();
$b_label = $b->label();
return strnatcasecmp($a_label, $b_label);
}
return $a_weight < $b_weight ? -1 : 1;
}
/**
* Sorts the flag entities, putting disabled flags at the bottom.
*
* @see \Drupal\Core\Config\Entity\ConfigEntityBase::sort()
*/
public static function sort(ConfigEntityInterface $a, ConfigEntityInterface $b) {
// Check if the entities are flags, if not go with the default.
if ($a instanceof FlagInterface && $b instanceof FlagInterface) {
if ($a->isEnabled() && $b->isEnabled()) {
return parent::sort($a, $b);
}
elseif (!$a->isEnabled()) {
return -1;
}
elseif (!$b->isEnabled()) {
return 1;
}
}
return parent::sort($a, $b);
}
