예제 #1
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     $target_entity_type = \Drupal::entityManager()->getDefinition($this->targetEntityType);
     $this->addDependency('module', $target_entity_type->getProvider());
     return $this;
 }
 /**
  * @covers ::calculateDependencies
  */
 public function testCalculateDependenciesWithThirdPartySettings()
 {
     $this->entity = $this->getMockForAbstractClass('\\Drupal\\Tests\\Core\\Config\\Entity\\Fixtures\\ConfigEntityBaseWithThirdPartySettings', array(array(), $this->entityTypeId));
     $this->entity->setThirdPartySetting('test_provider', 'test', 'test');
     $this->entity->setThirdPartySetting('test_provider2', 'test', 'test');
     $this->entity->setThirdPartySetting($this->provider, 'test', 'test');
     $this->assertEquals(array('test_provider', 'test_provider2'), $this->entity->calculateDependencies()['module']);
 }
예제 #3
0
 /**
  * {@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;
 }
예제 #5
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     if (isset($this->breakpointGroup)) {
         // @todo Implement toArray() so we do not have reload the
         //   entity since this property is changed in
         //   \Drupal\responsive_image\Entity\ResponsiveImageMapping::save().
         $breakpoint_group = \Drupal::entityManager()->getStorage('breakpoint_group')->load($this->breakpointGroup);
         $this->addDependency('entity', $breakpoint_group->getConfigDependencyName());
     }
     return $this->dependencies;
 }
 /**
  * {@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;
 }
예제 #7
0
 /**
  * @covers ::calculateDependencies
  * @covers ::getDependencies
  * @covers ::onDependencyRemoval
  */
 public function testCalculateDependenciesWithThirdPartySettings()
 {
     $this->entity = $this->getMockForAbstractClass('\\Drupal\\Core\\Config\\Entity\\ConfigEntityBase', array(array(), $this->entityTypeId));
     $this->entity->setThirdPartySetting('test_provider', 'test', 'test');
     $this->entity->setThirdPartySetting('test_provider2', 'test', 'test');
     $this->entity->setThirdPartySetting($this->provider, 'test', 'test');
     $this->assertEquals(array('test_provider', 'test_provider2'), $this->entity->calculateDependencies()->getDependencies()['module']);
     $changed = $this->entity->onDependencyRemoval(['module' => ['test_provider2']]);
     $this->assertTrue($changed, 'Calling onDependencyRemoval with an existing third party dependency provider returns TRUE.');
     $changed = $this->entity->onDependencyRemoval(['module' => ['test_provider3']]);
     $this->assertFalse($changed, 'Calling onDependencyRemoval with a non-existing third party dependency provider returns FALSE.');
     $this->assertEquals(array('test_provider'), $this->entity->calculateDependencies()->getDependencies()['module']);
 }
 /**
  * @covers ::calculateDependencies
  *
  * @dataProvider providerCalculateDependenciesWithPluginBags
  */
 public function testCalculateDependenciesWithPluginBags($definition, $expected_dependencies)
 {
     $values = array();
     $this->entity = $this->getMockBuilder('\\Drupal\\Tests\\Core\\Config\\Entity\\Fixtures\\ConfigEntityBaseWithPluginBags')->setConstructorArgs(array($values, $this->entityTypeId))->setMethods(array('getPluginBags'))->getMock();
     // Create a configurable plugin that would add a dependency.
     $instance_id = $this->randomName();
     $instance = new TestConfigurablePlugin(array(), $instance_id, $definition);
     // Create a plugin bag to contain the instance.
     $pluginBag = $this->getMockBuilder('\\Drupal\\Core\\Plugin\\DefaultPluginBag')->disableOriginalConstructor()->setMethods(array('get'))->getMock();
     $pluginBag->expects($this->atLeastOnce())->method('get')->with($instance_id)->will($this->returnValue($instance));
     $pluginBag->addInstanceId($instance_id);
     // Return the mocked plugin bag.
     $this->entity->expects($this->once())->method('getPluginBags')->will($this->returnValue(array($pluginBag)));
     $this->assertEquals($expected_dependencies, $this->entity->calculateDependencies());
 }
예제 #9
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     $this->addDependency('config', $this->getPage()->getConfigDependencyName());
     foreach ($this->getSelectionConditions() as $instance) {
         $this->calculatePluginDependencies($instance);
     }
     return $this->getDependencies();
 }
예제 #10
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     foreach ($this->test_dependencies as $type => $deps) {
         foreach ($deps as $dep) {
             $this->addDependency($type, $dep);
         }
     }
 }
예제 #11
0
파일: Editor.php 프로젝트: nstielau/drops-8
 /**
  * {@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;
 }
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     // Create dependency on the bundle.
     $entity_type = \Drupal::entityManager()->getDefinition($this->target_entity_type_id);
     $bundle_config_dependency = $entity_type->getBundleConfigDependency($this->target_bundle);
     $this->addDependency($bundle_config_dependency['type'], $bundle_config_dependency['name']);
     return $this;
 }
예제 #13
0
 /**
  * Retrieves data about this index's dependencies.
  *
  * The return value is structured as follows:
  *
  * @code
  * array(
  *   'config' => array(
  *     'CONFIG_DEPENDENCY_KEY' => array(
  *       'always' => array(
  *         'processors' => array(
  *           'PROCESSOR_ID' => $processor,
  *         ),
  *         'datasources' => array(
  *           'DATASOURCE_ID_1' => $datasource_1,
  *           'DATASOURCE_ID_2' => $datasource_2,
  *         ),
  *       ),
  *       'optional' => array(
  *         'index' => array(
  *           'INDEX_ID' => $index,
  *         ),
  *         'tracker' => array(
  *           'TRACKER_ID' => $tracker,
  *         ),
  *       ),
  *     ),
  *   )
  * )
  * @endcode
  *
  * @return object[][][][][]
  *   An associative array containing the index's dependencies. The array is
  *   first keyed by the config dependency type ("module", "config", etc.) and
  *   then by the names of the config dependencies of that type which the index
  *   has. The values are associative arrays with up to two keys, "always" and
  *   "optional", specifying whether the dependency is a hard one by the plugin
  *   (or index) in question or potentially depending on the configuration. The
  *   values on this level are arrays with keys "index", "tracker",
  *   "datasources" and/or "processors" and values arrays of IDs mapped to
  *   their entities/plugins.
  */
 protected function getDependencyData()
 {
     $dependency_data = array();
     // Since calculateDependencies() will work directly on the $dependencies
     // property, we first save its original state and then restore it
     // afterwards.
     $original_dependencies = $this->dependencies;
     parent::calculateDependencies();
     foreach ($this->dependencies as $dependency_type => $list) {
         foreach ($list as $name) {
             $dependency_data[$dependency_type][$name]['always']['index'][$this->id] = $this;
         }
     }
     $this->dependencies = $original_dependencies;
     // The server needs special treatment, since it is a dependency of the index
     // itself, and not one of its plugins.
     if ($this->hasValidServer()) {
         $name = $this->getServerInstance()->getConfigDependencyName();
         $dependency_data['config'][$name]['optional']['index'][$this->id] = $this;
     }
     // All other plugins can be treated uniformly.
     $plugins = $this->getAllPlugins();
     foreach ($plugins as $plugin_type => $type_plugins) {
         foreach ($type_plugins as $plugin_id => $plugin) {
             // Largely copied from
             // \Drupal\Core\Plugin\PluginDependencyTrait::calculatePluginDependencies().
             $definition = $plugin->getPluginDefinition();
             // First, always depend on the module providing the plugin.
             $dependency_data['module'][$definition['provider']]['always'][$plugin_type][$plugin_id] = $plugin;
             // Plugins can declare additional dependencies in their definition.
             if (isset($definition['config_dependencies'])) {
                 foreach ($definition['config_dependencies'] as $dependency_type => $list) {
                     foreach ($list as $name) {
                         $dependency_data[$dependency_type][$name]['always'][$plugin_type][$plugin_id] = $plugin;
                     }
                 }
             }
             // Finally, add the dynamically-calculated dependencies of the plugin.
             foreach ($plugin->calculateDependencies() as $dependency_type => $list) {
                 foreach ($list as $name) {
                     $dependency_data[$dependency_type][$name]['optional'][$plugin_type][$plugin_id] = $plugin;
                 }
             }
         }
     }
     return $dependency_data;
 }
예제 #14
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     // Ensure that the Rules component is dependant on the module that
     // implements the component.
     $this->addDependency('module', $this->module);
     // @todo Handle dependencies of plugins that are provided by various modules
     //   here.
     return $this->dependencies;
 }
예제 #15
0
파일: View.php 프로젝트: shumer/blog
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     // Ensure that the view is dependant on the module that implements the view.
     $this->addDependency('module', $this->module);
     // Ensure that the view is dependent on the module that provides the schema
     // for the base table.
     $schema = $this->drupalGetSchema($this->base_table);
     // @todo Entity base tables are no longer registered in hook_schema(). Once
     //   we automate the views data for entity types add the entity type
     //   type provider as a dependency. See https://drupal.org/node/1740492.
     if ($schema && $this->module != $schema['module']) {
         $this->addDependency('module', $schema['module']);
     }
     $handler_types = array();
     foreach (Views::getHandlerTypes() as $type) {
         $handler_types[] = $type['plural'];
     }
     foreach ($this->get('display') as $display) {
         // Collect all dependencies of all handlers.
         foreach ($handler_types as $handler_type) {
             if (!empty($display['display_options'][$handler_type])) {
                 foreach ($display['display_options'][$handler_type] as $handler) {
                     // Add the provider as dependency.
                     if (isset($handler['provider'])) {
                         $this->addDependency('module', $handler['provider']);
                     }
                     // Add the additional dependencies from the handler configuration.
                     if (!empty($handler['dependencies'])) {
                         $this->addDependencies($handler['dependencies']);
                     }
                 }
             }
         }
         // Collect all dependencies of plugins.
         foreach (Views::getPluginTypes('plugin') as $plugin_type) {
             if (!empty($display['display_options'][$plugin_type]['options']['dependencies'])) {
                 $this->addDependencies($display['display_options'][$plugin_type]['options']['dependencies']);
             }
         }
     }
     return $this->dependencies;
 }
예제 #16
0
파일: Block.php 프로젝트: nsp15/Drupal8
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     $this->addDependency('theme', $this->theme);
     return $this->dependencies;
 }
예제 #17
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     // Ensure the field is dependent on the providing module.
     $this->addDependency('module', $this->getTypeProvider());
     // Ask the field type for any additional storage dependencies.
     // @see \Drupal\Core\Field\FieldItemInterface::calculateStorageDependencies()
     $definition = \Drupal::service('plugin.manager.field.field_type')->getDefinition($this->getType(), FALSE);
     $this->addDependencies($definition['class']::calculateStorageDependencies($this));
     // Ensure the field is dependent on the provider of the entity type.
     $entity_type = \Drupal::entityManager()->getDefinition($this->entity_type);
     $this->addDependency('module', $entity_type->getProvider());
     return $this;
 }
예제 #18
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     // Ensure the field is dependent on the providing module.
     $this->addDependency('module', $this->getTypeProvider());
     // Ensure the field is dependent on the provider of the entity type.
     $entity_type = \Drupal::entityManager()->getDefinition($this->entity_type);
     $this->addDependency('module', $entity_type->getProvider());
     return $this->dependencies;
 }
예제 #19
0
 /**
  * {@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;
 }
예제 #20
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     $entity_type = \Drupal::entityManager()->getDefinition($this->targetEntityType);
     $this->addDependency('module', $entity_type->getProvider());
     $bundle_entity_type_id = $entity_type->getBundleEntityType();
     if ($bundle_entity_type_id != 'bundle') {
         // If the target entity type uses entities to manage its bundles then
         // depend on the bundle entity.
         $bundle_entity = \Drupal::entityManager()->getStorage($bundle_entity_type_id)->load($this->bundle);
         $this->addDependency('config', $bundle_entity->getConfigDependencyName());
     }
     return $this->dependencies;
 }
예제 #21
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     $this->calculatePluginDependencies($this->getSourcePlugin());
     $this->calculatePluginDependencies($this->getDestinationPlugin());
     // Add dependencies on required migration dependencies.
     foreach ($this->getMigrationDependencies()['required'] as $dependency) {
         $this->addDependency('config', $this->getEntityType()->getConfigPrefix() . '.' . $dependency);
     }
     return $this->dependencies;
 }
예제 #22
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     $this->dependencies = array();
     if ($this->sourceType == Breakpoint::SOURCE_TYPE_MODULE) {
         $this->addDependency('module', $this->source);
     } elseif ($this->sourceType == Breakpoint::SOURCE_TYPE_THEME) {
         $this->addDependency('theme', $this->source);
     }
     $breakpoints = $this->getBreakpoints();
     foreach ($breakpoints as $breakpoint) {
         $this->addDependency('entity', $breakpoint->getConfigDependencyName());
     }
     return $this->dependencies;
 }
예제 #23
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     // Add dependencies from the field type plugin. We can not use
     // self::calculatePluginDependencies() because instantiation of a field item
     // plugin requires a parent entity.
     /** @var $field_type_manager \Drupal\Core\Field\FieldTypePluginManagerInterface */
     $field_type_manager = \Drupal::service('plugin.manager.field.field_type');
     $definition = $field_type_manager->getDefinition($this->getType());
     $this->addDependency('module', $definition['provider']);
     // Plugins can declare additional dependencies in their definition.
     if (isset($definition['config_dependencies'])) {
         $this->addDependencies($definition['config_dependencies']);
     }
     // Let the field type plugin specify its own dependencies.
     // @see \Drupal\Core\Field\FieldItemInterface::calculateDependencies()
     $this->addDependencies($definition['class']::calculateDependencies($this));
     // Create dependency on the bundle.
     $bundle_config_dependency = $this->entityManager()->getDefinition($this->entity_type)->getBundleConfigDependency($this->bundle);
     $this->addDependency($bundle_config_dependency['type'], $bundle_config_dependency['name']);
     return $this;
 }
예제 #24
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     $this->calculatePluginDependencies($this->getSourcePlugin());
     $this->calculatePluginDependencies($this->getDestinationPlugin());
     // Add hard dependencies on required migrations.
     $dependencies = $this->getEntityManager()->getStorage($this->entityTypeId)->getVariantIds($this->getMigrationDependencies()['required']);
     foreach ($dependencies as $dependency) {
         $this->addDependency('config', $this->getEntityType()->getConfigPrefix() . '.' . $dependency);
     }
     return $this;
 }
예제 #25
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     if ($this->getPlugin()) {
         $this->addDependency('module', $this->getPlugin()->getPluginDefinition()['provider']);
     }
     return $this;
 }
예제 #26
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     $target_entity_type = $this->entityManager()->getDefinition($this->targetEntityType);
     $bundle_entity_type_id = $target_entity_type->getBundleEntityType();
     if ($bundle_entity_type_id != 'bundle') {
         // If the target entity type uses entities to manage its bundles then
         // depend on the bundle entity.
         if (!($bundle_entity = $this->entityManager()->getStorage($bundle_entity_type_id)->load($this->bundle))) {
             throw new \LogicException(SafeMarkup::format('Missing bundle entity, entity type %type, entity id %bundle.', array('%type' => $bundle_entity_type_id, '%bundle' => $this->bundle)));
         }
         $this->addDependency('config', $bundle_entity->getConfigDependencyName());
     } else {
         // Depend on the provider of the entity type.
         $this->addDependency('module', $target_entity_type->getProvider());
     }
     // If field.module is enabled, add dependencies on 'field_config' entities
     // for both displayed and hidden fields. We intentionally leave out base
     // field overrides, since the field still exists without them.
     if (\Drupal::moduleHandler()->moduleExists('field')) {
         $components = $this->content + $this->hidden;
         $field_definitions = $this->entityManager()->getFieldDefinitions($this->targetEntityType, $this->bundle);
         foreach (array_intersect_key($field_definitions, $components) as $field_name => $field_definition) {
             if ($field_definition instanceof ConfigEntityInterface && $field_definition->getEntityTypeId() == 'field_config') {
                 $this->addDependency('config', $field_definition->getConfigDependencyName());
             }
         }
     }
     // Depend on configured modes.
     if ($this->mode != 'default') {
         $mode_entity = $this->entityManager()->getStorage('entity_' . $this->displayContext . '_mode')->load($target_entity_type->id() . '.' . $this->mode);
         $this->addDependency('config', $mode_entity->getConfigDependencyName());
     }
     return $this->dependencies;
 }
예제 #27
0
파일: Tour.php 프로젝트: 318io/318-io
 /**
  * {@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;
 }
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     $bundle_entity_type_id = $this->entityManager()->getDefinition($this->target_entity_type_id)->getBundleEntityType();
     if ($bundle_entity_type_id != 'bundle') {
         // If the target entity type uses entities to manage its bundles then
         // depend on the bundle entity.
         if (!($bundle_entity = $this->entityManager()->getStorage($bundle_entity_type_id)->load($this->target_bundle))) {
             throw new \LogicException(String::format('Missing bundle entity, entity type %type, entity id %bundle.', array('%type' => $bundle_entity_type_id, '%bundle' => $this->target_bundle)));
         }
         $this->addDependency('config', $bundle_entity->getConfigDependencyName());
     }
     return $this->dependencies;
 }
 /**
  * Overrides ConfigEntityBase::calculateDependencies().
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     // Always add a dependency on the user module.
     $this->addDependency('module', 'user');
     // Add a dependency on an user role in case this protection rule protects
     // an user role.
     $protected_entity = $this->getProtectedEntity();
     if ($protected_entity instanceof ConfigEntityInterface) {
         $this->addDependency('config', $protected_entity->getConfigDependencyName());
     }
     return $this->dependencies;
 }
예제 #30
0
 /**
  * {@inheritdoc}
  */
 public function calculateDependencies()
 {
     parent::calculateDependencies();
     $this->calculatePluginDependencies($this->getAliasType());
     foreach ($this->getSelectionConditions() as $instance) {
         $this->calculatePluginDependencies($instance);
     }
     return $this->getDependencies();
 }