PHP EntityManagerInterface::getTranslationFromContext方法代码示例

 /**
  * {@inheritdoc}
  */
 public function build(RouteMatchInterface $route_match)
 {
     $breadcrumb = new Breadcrumb();
     $breadcrumb->addLink(Link::createFromRoute($this->t('Home'), '<front>'));
     $term = $route_match->getParameter('taxonomy_term');
     // Breadcrumb needs to have terms cacheable metadata as a cacheable
     // dependency even though it is not shown in the breadcrumb because e.g. its
     // parent might have changed.
     $breadcrumb->addCacheableDependency($term);
     // @todo This overrides any other possible breadcrumb and is a pure
     //   hard-coded presumption. Make this behavior configurable per
     //   vocabulary or term.
     $parents = $this->termStorage->loadAllParents($term->id());
     // Remove current term being accessed.
     array_shift($parents);
     foreach (array_reverse($parents) as $term) {
         $term = $this->entityManager->getTranslationFromContext($term);
         $breadcrumb->addCacheableDependency($term);
         $breadcrumb->addLink(Link::createFromRoute($term->getName(), 'entity.taxonomy_term.canonical', array('taxonomy_term' => $term->id())));
     }
     // This breadcrumb builder is based on a route parameter, and hence it
     // depends on the 'route' cache context.
     $breadcrumb->addCacheContexts(['route']);
     return $breadcrumb;
 }

 /**
  * {@inheritdoc}
  */
 public function getFormLangcode(array &$form_state)
 {
     if (empty($form_state['langcode'])) {
         // Imply a 'view' operation to ensure users edit entities in the same
         // language they are displayed. This allows to keep contextual editing
         // working also for multilingual entities.
         $form_state['langcode'] = $this->entityManager->getTranslationFromContext($this->entity)->language()->id;
     }
     return $form_state['langcode'];
 }

 /**
  * {@inheritdoc}
  */
 public function convert($value, $definition, $name, array $defaults)
 {
     $entity_type_id = $this->getEntityTypeFromDefaults($definition, $name, $defaults);
     if ($storage = $this->entityManager->getStorage($entity_type_id)) {
         $entity = $storage->loadRevision($value);
         // If the entity type is translatable, ensure we return the proper
         // translation object for the current context.
         if ($entity instanceof EntityInterface && $entity instanceof TranslatableInterface) {
             $entity = $this->entityManager->getTranslationFromContext($entity, NULL, array('operation' => 'entity_upcast'));
         }
         return $entity;
     }
 }

 /**
  * {@inheritdoc}
  */
 public function build(RouteMatchInterface $route_match)
 {
     $term = $route_match->getParameter('taxonomy_term');
     // @todo This overrides any other possible breadcrumb and is a pure
     //   hard-coded presumption. Make this behavior configurable per
     //   vocabulary or term.
     $breadcrumb = array();
     while ($parents = $this->termStorage->loadParents($term->id())) {
         $term = array_shift($parents);
         $term = $this->entityManager->getTranslationFromContext($term);
         $breadcrumb[] = Link::createFromRoute($term->getName(), 'entity.taxonomy_term.canonical', array('taxonomy_term' => $term->id()));
     }
     $breadcrumb[] = Link::createFromRoute($this->t('Home'), '<front>');
     $breadcrumb = array_reverse($breadcrumb);
     return $breadcrumb;
 }

 /**
  * Loads the entity associated with this menu link.
  *
  * @return \Drupal\menu_link_content\MenuLinkContentInterface
  *   The menu link content entity.
  *
  * @throws \Drupal\Component\Plugin\Exception\PluginException
  *   If the entity ID and UUID are both invalid or missing.
  */
 protected function getEntity()
 {
     if (empty($this->entity)) {
         $entity = NULL;
         $storage = $this->entityManager->getStorage('menu_link_content');
         if (!empty($this->pluginDefinition['metadata']['entity_id'])) {
             $entity_id = $this->pluginDefinition['metadata']['entity_id'];
             // Make sure the current ID is in the list, since each plugin empties
             // the list after calling loadMultiple(). Note that the list may include
             // multiple IDs added earlier in each plugin's constructor.
             static::$entityIdsToLoad[$entity_id] = $entity_id;
             $entities = $storage->loadMultiple(array_values(static::$entityIdsToLoad));
             $entity = isset($entities[$entity_id]) ? $entities[$entity_id] : NULL;
             static::$entityIdsToLoad = array();
         }
         if (!$entity) {
             // Fallback to the loading by the UUID.
             $uuid = $this->getUuid();
             $loaded_entities = $storage->loadByProperties(array('uuid' => $uuid));
             $entity = reset($loaded_entities);
         }
         if (!$entity) {
             throw new PluginException("Entity not found through the menu link plugin definition and could not fallback on UUID '{$uuid}'");
         }
         // Clone the entity object to avoid tampering with the static cache.
         $this->entity = clone $entity;
         $the_entity = $this->entityManager->getTranslationFromContext($this->entity);
         /** @var \Drupal\menu_link_content\MenuLinkContentInterface $the_entity */
         $this->entity = $the_entity;
         $this->entity->setInsidePlugin();
     }
     return $this->entity;
 }

 /**
  * {@inheritdoc}
  */
 public function build(RouteMatchInterface $route_match)
 {
     $breadcrumb = new Breadcrumb();
     $breadcrumb->addCacheContexts(['route']);
     // Add all parent forums to breadcrumbs.
     /** @var Node $node */
     $node = $route_match->getParameter('node');
     $breadcrumb->addCacheableDependency($node);
     // Add all parent forums to breadcrumbs.
     /** @var \Drupal\Taxonomy\TermInterface $term */
     $term = !empty($node->field_channel) ? $node->field_channel->entity : '';
     $links = [];
     if ($term) {
         $breadcrumb->addCacheableDependency($term);
         $channels = $this->termStorage->loadAllParents($term->id());
         foreach (array_reverse($channels) as $term) {
             $term = $this->entityManager->getTranslationFromContext($term);
             $breadcrumb->addCacheableDependency($term);
             $links[] = Link::createFromRoute($term->getName(), 'entity.taxonomy_term.canonical', array('taxonomy_term' => $term->id()));
         }
     }
     if (!$links || '/' . $links[0]->getUrl()->getInternalPath() != $this->configFactory->get('system.site')->get('page.front')) {
         array_unshift($links, Link::createFromRoute($this->t('Home'), '<front>'));
     }
     return $breadcrumb->setLinks($links);
 }

 /**
  * Returns the entity translation matching the configured row language.
  *
  * @param \Drupal\Core\Entity\EntityInterface $entity
  *   The entity object the field value being processed is attached to.
  * @param \Drupal\views\ResultRow $row
  *   The result row the field value being processed belongs to.
  *
  * @return \Drupal\Core\Entity\FieldableEntityInterface
  *   The entity translation object for the specified row.
  */
 public function getEntityTranslation(EntityInterface $entity, ResultRow $row)
 {
     // We assume the same language should be used for all entity fields
     // belonging to a single row, even if they are attached to different entity
     // types. Below we apply language fallback to ensure a valid value is always
     // picked.
     $langcode = $this->getEntityTranslationRenderer()->getLangcode($row);
     return $this->entityManager->getTranslationFromContext($entity, $langcode);
 }

 /**
  * {@inheritdoc}
  */
 public function getFormLangcode(FormStateInterface $form_state)
 {
     if (!$form_state->has('langcode')) {
         // Imply a 'view' operation to ensure users edit entities in the same
         // language they are displayed. This allows to keep contextual editing
         // working also for multilingual entities.
         $form_state->set('langcode', $this->entityManager->getTranslationFromContext($this->entity)->language()->getId());
     }
     return $form_state->get('langcode');
 }

 /**
  * Provides a page to render a single entity.
  *
  * @param \Drupal\Core\Entity\EntityInterface $_entity
  *   The Entity to be rendered. Note this variable is named $_entity rather
  *   than $entity to prevent collisions with other named placeholders in the
  *   route.
  * @param string $view_mode
  *   (optional) The view mode that should be used to display the entity.
  *   Defaults to 'full'.
  * @param string $langcode
  *   (optional) For which language the entity should be rendered, defaults to
  *   the current content language.
  *
  * @return array
  *   A render array as expected by drupal_render().
  */
 public function view(EntityInterface $_entity, $view_mode = 'full', $langcode = NULL)
 {
     $page = $this->entityManager->getViewBuilder($_entity->getEntityTypeId())->view($_entity, $view_mode, $langcode);
     // If the entity's label is rendered using a field formatter, set the
     // rendered title field formatter as the page title instead of the default
     // plain text title. This allows attributes set on the field to propagate
     // correctly (e.g. RDFa, in-place editing).
     if ($_entity instanceof ContentEntityInterface) {
         $label_field = $_entity->getEntityType()->getKey('label');
         if ($label_field && $_entity->getFieldDefinition($label_field)->getDisplayOptions('view')) {
             // We must render the label field, because rendering the entity may be
             // a cache hit, in which case we can't extract the rendered label field
             // from the $page renderable array.
             $build = $this->entityManager->getTranslationFromContext($_entity)->get($label_field)->view($view_mode);
             $page['#title'] = drupal_render($build, TRUE);
         }
     }
     return $page;
 }

 /**
  * {@inheritdoc}
  */
 public function viewMultiple(array $entities = array(), $view_mode = 'full', $langcode = NULL)
 {
     $build_list = array('#sorted' => TRUE, '#pre_render' => array(array($this, 'buildMultiple')));
     $weight = 0;
     foreach ($entities as $key => $entity) {
         // Ensure that from now on we are dealing with the proper translation
         // object.
         $entity = $this->entityManager->getTranslationFromContext($entity, $langcode);
         // Set build defaults.
         $build_list[$key] = $this->getBuildDefaults($entity, $view_mode);
         $entityType = $this->entityTypeId;
         $this->moduleHandler()->alter(array($entityType . '_build_defaults', 'entity_build_defaults'), $build_list[$key], $entity, $view_mode);
         $build_list[$key]['#weight'] = $weight++;
     }
     return $build_list;
 }

 /**
  * Initializes form language code values.
  *
  * @param \Drupal\Core\Form\FormStateInterface $form_state
  *   The current state of the form.
  */
 protected function initFormLangcodes(FormStateInterface $form_state)
 {
     // Store the entity default language to allow checking whether the form is
     // dealing with the original entity or a translation.
     if (!$form_state->has('entity_default_langcode')) {
         $form_state->set('entity_default_langcode', $this->entity->getUntranslated()->language()->getId());
     }
     // This value might have been explicitly populated to work with a particular
     // entity translation. If not we fall back to the most proper language based
     // on contextual information.
     if (!$form_state->has('langcode')) {
         // Imply a 'view' operation to ensure users edit entities in the same
         // language they are displayed. This allows to keep contextual editing
         // working also for multilingual entities.
         $form_state->set('langcode', $this->entityManager->getTranslationFromContext($this->entity)->language()->getId());
     }
 }

 /**
  * Determines the entity.
  *
  * @param \Drupal\Core\Routing\RouteMatchInterface $route_match
  *   The route match.
  * @param \Drupal\Core\Entity\EntityInterface $_entity
  *   (optional) The entity, set in
  *   \Drupal\Core\Entity\Enhancer\EntityRouteEnhancer.
  *
  * @return \Drupal\Core\Entity\EntityInterface|NULL
  *   The entity, if it is passed in directly or if the first parameter of the
  *   active route is an entity; otherwise, NULL.
  */
 protected function doGetEntity(RouteMatchInterface $route_match, EntityInterface $_entity = NULL)
 {
     if ($_entity) {
         $entity = $_entity;
     } else {
         // Let's look up in the route object for the name of upcasted values.
         foreach ($route_match->getParameters() as $parameter) {
             if ($parameter instanceof EntityInterface) {
                 $entity = $parameter;
                 break;
             }
         }
     }
     if ($entity) {
         return $this->entityManager->getTranslationFromContext($entity);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function getReferenceableEntities($match = NULL, $match_operator = 'CONTAINS', $limit = 0)
 {
     $target_type = $this->configuration['target_type'];
     $query = $this->buildEntityQuery($match, $match_operator);
     if ($limit > 0) {
         $query->range(0, $limit);
     }
     $result = $query->execute();
     if (empty($result)) {
         return array();
     }
     $options = array();
     $entities = $this->entityManager->getStorage($target_type)->loadMultiple($result);
     foreach ($entities as $entity_id => $entity) {
         $bundle = $entity->bundle();
         $options[$bundle][$entity_id] = Html::escape($this->entityManager->getTranslationFromContext($entity)->label());
     }
     return $options;
 }

 /**
  * Return the code of the language the field should be displayed in.
  *
  * @param \Drupal\Core\Entity\EntityInterface $entity
  *   The entity object the field value being processed is attached to.
  * @param \Drupal\views\ResultRow $row
  *   The result row the field value being processed belongs to.
  *
  * @return string
  *   The field language code.
  */
 protected function getFieldLangcode(EntityInterface $entity, ResultRow $row)
 {
     if ($this->getFieldDefinition()->isTranslatable()) {
         // Even if the current field is not attached to the main entity, we use it
         // to determine the field language, as we assume the same language should
         // be used for all values belonging to a single row, when possible. Below
         // we apply language fallback to ensure a valid value is always picked.
         $langcode = $this->getEntityTranslationRenderer()->getLangcode($row);
         // Give the Entity Field API a chance to fallback to a different language
         // (or LanguageInterface::LANGCODE_NOT_SPECIFIED), in case the field has
         // no data for the selected language. FieldItemListInterface::view() does
         // this as well, but since the returned language code is used before
         // calling it, the fallback needs to happen explicitly.
         $langcode = $this->entityManager->getTranslationFromContext($entity, $langcode)->language()->getId();
         return $langcode;
     } else {
         return LanguageInterface::LANGCODE_NOT_SPECIFIED;
     }
 }

 /**
  * Loads Principles Array.
  */
 protected function loadPrinciples()
 {
     $this->principles = array();
     $nids = $this->principleStorage->getPrinciples();
     if ($nids) {
         $principle_links = $this->principleStorage->loadMultiple($nids);
         $nodes = $this->entityManager->getStorage('node')->loadMultiple($nids);
         // @todo: use route name for links, not system path.
         foreach ($principle_links as $link) {
             $nid = $link['nid'];
             if (isset($nodes[$nid]) && $nodes[$nid]->isPublished()) {
                 $entity = $nodes[$nid];
                 $item = array();
                 $item['uuid'] = $entity->uuid();
                 $item['title'] = $this->entityManager->getTranslationFromContext($entity)->label();
                 $item['type'] = $entity->bundle();
                 $item['url'] = $entity->url();
                 //          $link['url_info'] = $nodes[$nid]->urlInfo();
                 $this->principles[$link['nid']] = (object) $item;
             }
         }
     }
 }