public function Importer::importContent in Default Content for D8 8

Same name and namespace in other branches

1. 2.0.x src/Importer.php \Drupal\default_content\Importer::importContent()

Imports default content from a given module.

Parameters

string $module: The module to create the default content from.

Return value

\Drupal\Core\Entity\EntityInterface[] An array of created entities keyed by their UUIDs.

Overrides ImporterInterface::importContent

File

src/Importer.php, line 117

Class

Importer

A service for handling import of default content.

Namespace

Drupal\default_content

Code

public function importContent($module) {
  $created = [];
  $folder = drupal_get_path('module', $module) . "/content";
  if (file_exists($folder)) {
    $root_user = $this->entityTypeManager
      ->getStorage('user')
      ->load(1);
    $this->accountSwitcher
      ->switchTo($root_user);
    $file_map = [];
    foreach ($this->entityTypeManager
      ->getDefinitions() as $entity_type_id => $entity_type) {
      $reflection = new \ReflectionClass($entity_type
        ->getClass());

      // We are only interested in importing content entities.
      if ($reflection
        ->implementsInterface(ConfigEntityInterface::class)) {
        continue;
      }
      if (!file_exists($folder . '/' . $entity_type_id)) {
        continue;
      }
      $files = $this->scanner
        ->scan($folder . '/' . $entity_type_id);

      // Default content uses drupal.org as domain.
      // @todo Make this use a uri like default-content:.
      $this->linkManager
        ->setLinkDomain($this->linkDomain);

      // Parse all of the files and sort them in order of dependency.
      foreach ($files as $file) {
        $contents = $this
          ->parseFile($file);

        // Decode the file contents.
        $decoded = $this->serializer
          ->decode($contents, 'hal_json');

        // Get the link to this entity.
        $item_uuid = $decoded['uuid'][0]['value'];

        // Throw an exception when this UUID already exists.
        if (isset($file_map[$item_uuid])) {

          // Reset link domain.
          $this->linkManager
            ->setLinkDomain(FALSE);
          throw new \Exception(sprintf('Default content with uuid "%s" exists twice: "%s" "%s"', $item_uuid, $file_map[$item_uuid]->uri, $file->uri));
        }

        // Store the entity type with the file.
        $file->entity_type_id = $entity_type_id;

        // Store the file in the file map.
        $file_map[$item_uuid] = $file;

        // Create a vertex for the graph.
        $vertex = $this
          ->getVertex($item_uuid);
        $this->graph[$vertex->id]['edges'] = [];
        if (empty($decoded['_embedded'])) {

          // No dependencies to resolve.
          continue;
        }

        // Here we need to resolve our dependencies:
        foreach ($decoded['_embedded'] as $embedded) {
          foreach ($embedded as $item) {
            $uuid = $item['uuid'][0]['value'];
            $edge = $this
              ->getVertex($uuid);
            $this->graph[$vertex->id]['edges'][$edge->id] = TRUE;
          }
        }
      }
    }

    // @todo what if no dependencies?
    $sorted = $this
      ->sortTree($this->graph);
    foreach ($sorted as $link => $details) {
      if (!empty($file_map[$link])) {
        $file = $file_map[$link];
        $entity_type_id = $file->entity_type_id;
        $class = $this->entityTypeManager
          ->getDefinition($entity_type_id)
          ->getClass();
        $contents = $this
          ->parseFile($file);
        $entity = $this->serializer
          ->deserialize($contents, $class, 'hal_json', [
          'request_method' => 'POST',
        ]);
        $entity
          ->enforceIsNew(TRUE);

        // Ensure that the entity is not owned by the anonymous user.
        if ($entity instanceof EntityOwnerInterface && empty($entity
          ->getOwnerId())) {
          $entity
            ->setOwner($root_user);
        }
        $entity
          ->save();
        $created[$entity
          ->uuid()] = $entity;
      }
    }
    $this->eventDispatcher
      ->dispatch(DefaultContentEvents::IMPORT, new ImportEvent($created, $module));
    $this->accountSwitcher
      ->switchBack();
  }

  // Reset the tree.
  $this
    ->resetTree();

  // Reset link domain.
  $this->linkManager
    ->setLinkDomain(FALSE);
  return $created;
}