PHP Term::loadMultiple方法代码示例

 /**
  * Create a vocabulary and some taxonomy terms, ensuring they're loaded
  * correctly using entity_load_multiple().
  */
 function testTaxonomyTermMultipleLoad()
 {
     // Create a vocabulary.
     $vocabulary = $this->createVocabulary();
     // Create five terms in the vocabulary.
     $i = 0;
     while ($i < 5) {
         $i++;
         $this->createTerm($vocabulary);
     }
     // Load the terms from the vocabulary.
     $terms = entity_load_multiple_by_properties('taxonomy_term', array('vid' => $vocabulary->id()));
     $count = count($terms);
     $this->assertEqual($count, 5, format_string('Correct number of terms were loaded. @count terms.', array('@count' => $count)));
     // Load the same terms again by tid.
     $terms2 = Term::loadMultiple(array_keys($terms));
     $this->assertEqual($count, count($terms2), 'Five terms were loaded by tid.');
     $this->assertEqual($terms, $terms2, 'Both arrays contain the same terms.');
     // Remove one term from the array, then delete it.
     $deleted = array_shift($terms2);
     $deleted->delete();
     $deleted_term = Term::load($deleted->id());
     $this->assertFalse($deleted_term);
     // Load terms from the vocabulary by vid.
     $terms3 = entity_load_multiple_by_properties('taxonomy_term', array('vid' => $vocabulary->id()));
     $this->assertEqual(count($terms3), 4, 'Correct number of terms were loaded.');
     $this->assertFalse(isset($terms3[$deleted->id()]));
     // Create a single term and load it by name.
     $term = $this->createTerm($vocabulary);
     $loaded_terms = entity_load_multiple_by_properties('taxonomy_term', array('name' => $term->getName()));
     $this->assertEqual(count($loaded_terms), 1, 'One term was loaded.');
     $loaded_term = reset($loaded_terms);
     $this->assertEqual($term->id(), $loaded_term->id(), 'Term loaded by name successfully.');
 }

 /**
  * Tests the Drupal 6 taxonomy term to Drupal 8 migration.
  */
 public function testTaxonomyTerms()
 {
     $expected_results = array('1' => array('source_vid' => 1, 'vid' => 'vocabulary_1_i_0_', 'weight' => 0, 'parent' => array(0)), '2' => array('source_vid' => 2, 'vid' => 'vocabulary_2_i_1_', 'weight' => 3, 'parent' => array(0)), '3' => array('source_vid' => 2, 'vid' => 'vocabulary_2_i_1_', 'weight' => 4, 'parent' => array(2)), '4' => array('source_vid' => 3, 'vid' => 'vocabulary_3_i_2_', 'weight' => 6, 'parent' => array(0)), '5' => array('source_vid' => 3, 'vid' => 'vocabulary_3_i_2_', 'weight' => 7, 'parent' => array(4)), '6' => array('source_vid' => 3, 'vid' => 'vocabulary_3_i_2_', 'weight' => 8, 'parent' => array(4, 5)));
     $terms = Term::loadMultiple(array_keys($expected_results));
     // Find each term in the tree.
     $storage = \Drupal::entityTypeManager()->getStorage('taxonomy_term');
     $vids = array_unique(array_column($expected_results, 'vid'));
     $tree_terms = [];
     foreach ($vids as $vid) {
         foreach ($storage->loadTree($vid) as $term) {
             $tree_terms[$term->tid] = $term;
         }
     }
     foreach ($expected_results as $tid => $values) {
         /** @var Term $term */
         $term = $terms[$tid];
         $this->assertIdentical("term {$tid} of vocabulary {$values['source_vid']}", $term->name->value);
         $this->assertIdentical("description of term {$tid} of vocabulary {$values['source_vid']}", $term->description->value);
         $this->assertIdentical($values['vid'], $term->vid->target_id);
         $this->assertIdentical((string) $values['weight'], $term->weight->value);
         if ($values['parent'] === array(0)) {
             $this->assertNull($term->parent->target_id);
         } else {
             $parents = array();
             foreach (\Drupal::entityManager()->getStorage('taxonomy_term')->loadParents($tid) as $parent) {
                 $parents[] = (int) $parent->id();
             }
             $this->assertIdentical($parents, $values['parent']);
         }
         $this->assertArrayHasKey($tid, $tree_terms, "Term {$tid} exists in vocabulary tree");
         $tree_term = $tree_terms[$tid];
         $this->assertEquals($values['parent'], $tree_term->parents, "Term {$tid} has correct parents in vocabulary tree");
     }
 }

 public function titleQuery()
 {
     $titles = array();
     $terms = Term::loadMultiple($this->value);
     foreach ($terms as $term) {
         $titles[] = \Drupal::entityManager()->getTranslationFromContext($term)->label();
     }
     return $titles;
 }

 /**
  * {@inheritdoc}
  */
 public function build()
 {
     $config = $this->getConfiguration();
     if (!isset($config['vocabulary']) || !$config['vocabulary']) {
         return;
     }
     $query = \Drupal::entityQuery('taxonomy_term')->condition('vid', $config['vocabulary']);
     $tids = $query->execute();
     if (!$tids) {
         return;
     }
     $terms = Term::loadMultiple($tids);
     if (!$terms) {
         return;
     }
     return array('#theme' => 'item_list', '#items' => $this->buildTermList($terms));
 }

 /**
  * Tests the Drupal 6 taxonomy term to Drupal 8 migration.
  */
 public function testTaxonomyTerms()
 {
     $expected_results = array('1' => array('source_vid' => 1, 'vid' => 'vocabulary_1_i_0_', 'weight' => 0, 'parent' => array(2)), '2' => array('source_vid' => 2, 'vid' => 'vocabulary_2_i_1_', 'weight' => 3, 'parent' => array(0)), '3' => array('source_vid' => 2, 'vid' => 'vocabulary_2_i_1_', 'weight' => 4, 'parent' => array(2)), '4' => array('source_vid' => 3, 'vid' => 'vocabulary_3_i_2_', 'weight' => 6, 'parent' => array(0)), '5' => array('source_vid' => 3, 'vid' => 'vocabulary_3_i_2_', 'weight' => 7, 'parent' => array(4)), '6' => array('source_vid' => 3, 'vid' => 'vocabulary_3_i_2_', 'weight' => 8, 'parent' => array(4, 5)));
     $terms = Term::loadMultiple(array_keys($expected_results));
     foreach ($expected_results as $tid => $values) {
         /** @var Term $term */
         $term = $terms[$tid];
         $this->assertIdentical($term->name->value, "term {$tid} of vocabulary {$values['source_vid']}");
         $this->assertIdentical($term->description->value, "description of term {$tid} of vocabulary {$values['source_vid']}");
         $this->assertEqual($term->vid->target_id, $values['vid']);
         $this->assertEqual($term->weight->value, $values['weight']);
         if ($values['parent'] === array(0)) {
             $this->assertEqual($term->parent->target_id, 0);
         } else {
             $parents = array();
             foreach (taxonomy_term_load_parents($tid) as $parent) {
                 $parents[] = $parent->id();
             }
             $this->assertEqual($values['parent'], $parents);
         }
     }
 }

 /**
  * Tests the Drupal 6 taxonomy term to Drupal 8 migration.
  */
 public function testTaxonomyTerms()
 {
     $expected_results = array('1' => array('source_vid' => 1, 'vid' => 'vocabulary_1_i_0_', 'weight' => 0, 'parent' => array(0)), '2' => array('source_vid' => 2, 'vid' => 'vocabulary_2_i_1_', 'weight' => 3, 'parent' => array(0)), '3' => array('source_vid' => 2, 'vid' => 'vocabulary_2_i_1_', 'weight' => 4, 'parent' => array(2)), '4' => array('source_vid' => 3, 'vid' => 'vocabulary_3_i_2_', 'weight' => 6, 'parent' => array(0)), '5' => array('source_vid' => 3, 'vid' => 'vocabulary_3_i_2_', 'weight' => 7, 'parent' => array(4)), '6' => array('source_vid' => 3, 'vid' => 'vocabulary_3_i_2_', 'weight' => 8, 'parent' => array(4, 5)));
     $terms = Term::loadMultiple(array_keys($expected_results));
     foreach ($expected_results as $tid => $values) {
         /** @var Term $term */
         $term = $terms[$tid];
         $this->assertIdentical("term {$tid} of vocabulary {$values['source_vid']}", $term->name->value);
         $this->assertIdentical("description of term {$tid} of vocabulary {$values['source_vid']}", $term->description->value);
         $this->assertIdentical($values['vid'], $term->vid->target_id);
         $this->assertIdentical((string) $values['weight'], $term->weight->value);
         if ($values['parent'] === array(0)) {
             $this->assertNull($term->parent->target_id);
         } else {
             $parents = array();
             foreach (\Drupal::entityManager()->getStorage('taxonomy_term')->loadParents($tid) as $parent) {
                 $parents[] = (int) $parent->id();
             }
             $this->assertIdentical($parents, $values['parent']);
         }
     }
 }

 public function adminSummary()
 {
     // set up $this->valueOptions for the parent summary
     $this->valueOptions = array();
     if ($this->value) {
         $this->value = array_filter($this->value);
         $terms = Term::loadMultiple($this->value);
         foreach ($terms as $term) {
             $this->valueOptions[$term->id()] = SafeMarkup::checkPlain(\Drupal::entityManager()->getTranslationFromContext($term)->label());
         }
     }
     return parent::adminSummary();
 }

 /**
  * Tests that a fixed set of modules can be installed and uninstalled.
  */
 public function testInstallUninstall()
 {
     // Get a list of modules to enable.
     $all_modules = system_rebuild_module_data();
     $all_modules = array_filter($all_modules, function ($module) {
         // Filter contrib, hidden, already enabled modules and modules in the
         // Testing package.
         if ($module->origin !== 'core' || !empty($module->info['hidden']) || $module->status == TRUE || $module->info['package'] == 'Testing') {
             return FALSE;
         }
         return TRUE;
     });
     // Install every module possible.
     \Drupal::service('module_installer')->install(array_keys($all_modules));
     $this->assertModules(array_keys($all_modules), TRUE);
     foreach ($all_modules as $module => $info) {
         $this->assertModuleConfig($module);
         $this->assertModuleTablesExist($module);
     }
     // Export active config to sync.
     $this->copyConfig($this->container->get('config.storage'), $this->container->get('config.storage.sync'));
     system_list_reset();
     $this->resetAll();
     // Delete every field on the site so all modules can be uninstalled. For
     // example, if a comment field exists then module becomes required and can
     // not be uninstalled.
     $field_storages = \Drupal::entityManager()->getStorage('field_storage_config')->loadMultiple();
     \Drupal::entityManager()->getStorage('field_storage_config')->delete($field_storages);
     // Purge the data.
     field_purge_batch(1000);
     // Delete all terms.
     $terms = Term::loadMultiple();
     entity_delete_multiple('taxonomy_term', array_keys($terms));
     // Delete all filter formats.
     $filters = FilterFormat::loadMultiple();
     entity_delete_multiple('filter_format', array_keys($filters));
     // Delete any shortcuts so the shortcut module can be uninstalled.
     $shortcuts = Shortcut::loadMultiple();
     entity_delete_multiple('shortcut', array_keys($shortcuts));
     system_list_reset();
     $all_modules = system_rebuild_module_data();
     // Ensure that only core required modules and the install profile can not be uninstalled.
     $validation_reasons = \Drupal::service('module_installer')->validateUninstall(array_keys($all_modules));
     $this->assertEqual(['standard', 'system', 'user'], array_keys($validation_reasons));
     $modules_to_uninstall = array_filter($all_modules, function ($module) use($validation_reasons) {
         // Filter required and not enabled modules.
         if (!empty($module->info['required']) || $module->status == FALSE) {
             return FALSE;
         }
         return TRUE;
     });
     // Can not uninstall config and use admin/config/development/configuration!
     unset($modules_to_uninstall['config']);
     $this->assertTrue(isset($modules_to_uninstall['comment']), 'The comment module will be disabled');
     $this->assertTrue(isset($modules_to_uninstall['file']), 'The File module will be disabled');
     $this->assertTrue(isset($modules_to_uninstall['editor']), 'The Editor module will be disabled');
     // Uninstall all modules that can be uninstalled.
     \Drupal::service('module_installer')->uninstall(array_keys($modules_to_uninstall));
     $this->assertModules(array_keys($modules_to_uninstall), FALSE);
     foreach ($modules_to_uninstall as $module => $info) {
         $this->assertNoModuleConfig($module);
         $this->assertModuleTablesDoNotExist($module);
     }
     // Import the configuration thereby re-installing all the modules.
     $this->drupalPostForm('admin/config/development/configuration', array(), t('Import all'));
     // Modules have been installed that have services.
     $this->rebuildContainer();
     // Check that there are no errors.
     $this->assertIdentical($this->configImporter()->getErrors(), array());
     // Check that all modules that were uninstalled are now reinstalled.
     $this->assertModules(array_keys($modules_to_uninstall), TRUE);
     foreach ($modules_to_uninstall as $module => $info) {
         $this->assertModuleConfig($module);
         $this->assertModuleTablesExist($module);
     }
     // Ensure that we have no configuration changes to import.
     $storage_comparer = new StorageComparer($this->container->get('config.storage.sync'), $this->container->get('config.storage'), $this->container->get('config.manager'));
     $this->assertIdentical($storage_comparer->createChangelist()->getChangelist(), $storage_comparer->getEmptyChangelist());
     // Now we have all configuration imported, test all of them for schema
     // conformance. Ensures all imported default configuration is valid when
     // all modules are enabled.
     $names = $this->container->get('config.storage')->listAll();
     /** @var \Drupal\Core\Config\TypedConfigManagerInterface $typed_config */
     $typed_config = $this->container->get('config.typed');
     foreach ($names as $name) {
         $config = $this->config($name);
         $this->assertConfigSchema($typed_config, $name, $config->get());
     }
 }

 /**
  * @return static[]
  */
 public static function getTipuriCarburant()
 {
     $tip_carburant_ids = \Drupal::entityQuery('taxonomy_term')->condition('vid', 'tip_carburant')->execute();
     $tipuri_carburant = Term::loadMultiple($tip_carburant_ids);
     return $tipuri_carburant;
 }