public function MigrateDestinationNode::import in Migrate 7.2

Same name and namespace in other branches

1. 6.2 plugins/destinations/node.inc \MigrateDestinationNode::import()

Import a single node.

Parameters

$node: Node object to build. Prefilled with any fields mapped in the Migration.

$row: Raw source data object - passed through to prepare/complete handlers.

Return value

array Array of key fields (nid only in this case) of the node that was saved if successful. FALSE on failure.

Overrides MigrateDestination::import

1 call to MigrateDestinationNode::import()

MigrateDestinationNodeRevision::import in plugins/destinations/node.inc

Overridden import method.

1 method overrides MigrateDestinationNode::import()

MigrateDestinationNodeRevision::import in plugins/destinations/node.inc

Overridden import method.

File

plugins/destinations/node.inc, line 133

Support for node destinations.

Class

MigrateDestinationNode

Destination class implementing migration into nodes.

Code

public function import(stdClass $node, stdClass $row) {

  // Updating previously-migrated content?
  $migration = Migration::currentMigration();
  if (isset($row->migrate_map_destid1) && !$this->bypassDestIdCheck) {

    // Make sure is_new is off
    $node->is_new = FALSE;
    if (isset($node->nid)) {
      if ($node->nid != $row->migrate_map_destid1) {
        throw new MigrateException(t("Incoming nid !nid and map destination nid !destid1 don't match", array(
          '!nid' => $node->nid,
          '!destid1' => $row->migrate_map_destid1,
        )));
      }
    }
    else {
      $node->nid = $row->migrate_map_destid1;
    }

    // Get the existing vid, tnid so updates don't generate notices
    $values = db_select('node', 'n')
      ->fields('n', array(
      'vid',
      'tnid',
    ))
      ->condition('nid', $node->nid)
      ->execute()
      ->fetchAssoc();
    if (empty($values)) {
      throw new MigrateException(t("Incoming node ID !nid no longer exists", array(
        '!nid' => $node->nid,
      )));
    }
    $node->vid = $values['vid'];
    if (empty($node->tnid)) {
      $node->tnid = $values['tnid'];
    }
  }
  if ($migration
    ->getSystemOfRecord() == Migration::DESTINATION) {
    if (!isset($node->nid)) {
      throw new MigrateException(t('System-of-record is DESTINATION, but no destination nid provided'));
    }
    $old_node = node_load($node->nid);
    if (empty($old_node)) {
      throw new MigrateException(t('System-of-record is DESTINATION, but node !nid does not exist', array(
        '!nid' => $node->nid,
      )));
    }
    if (!isset($node->created)) {
      $node->created = $old_node->created;
    }
    if (!isset($node->vid)) {
      $node->vid = $old_node->vid;
    }
    if (!isset($node->status)) {
      $node->status = $old_node->status;
    }
    if (!isset($node->uid)) {
      $node->uid = $old_node->uid;
    }
  }
  if (!isset($node->type)) {

    // Default the type to our designated destination bundle (by doing this
    // conditionally, we permit some flexibility in terms of implementing
    // migrations which can affect more than one type).
    $node->type = $this->bundle;
  }

  // Set some required properties.
  if ($migration
    ->getSystemOfRecord() == Migration::SOURCE) {
    if (empty($node->language)) {
      $node->language = $this->language;
    }

    // Apply defaults, allow standard node prepare hooks to fire.
    // node_object_prepare() will blow these away, so save them here and
    // stuff them in later if need be.
    if (isset($node->created)) {
      $created = MigrationBase::timestamp($node->created);
    }
    else {

      // To keep node_object_prepare() from choking
      $node->created = REQUEST_TIME;
    }
    if (isset($node->changed)) {
      $changed = MigrationBase::timestamp($node->changed);
    }
    if (isset($node->uid)) {
      $uid = $node->uid;
    }
    if (isset($node->revision)) {
      $revision = $node->revision;
    }
    node_object_prepare($node);
    if (isset($created)) {
      $node->created = $created;
    }

    // No point to resetting $node->changed here, node_save() will overwrite it
    if (isset($uid)) {
      $node->uid = $uid;
    }
    if (isset($revision)) {
      $node->revision = $revision;
    }
  }

  // Invoke migration prepare handlers
  $this
    ->prepare($node, $row);
  if (!isset($node->revision)) {
    $node->revision = 0;

    // Saves disk space and writes. Can be overridden.
  }

  // Trying to update an existing node
  if ($migration
    ->getSystemOfRecord() == Migration::DESTINATION) {

    // Incoming data overrides existing data, so only copy non-existent fields
    foreach ($old_node as $field => $value) {

      // An explicit NULL in the source data means to wipe to old value (i.e.,
      // don't copy it over from $old_node)
      if (property_exists($node, $field) && $node->{$field} === NULL) {

        // Ignore this field
      }
      elseif (!isset($node->{$field})) {
        $node->{$field} = $old_node->{$field};
      }
    }
  }
  if (isset($node->nid) && !(isset($node->is_new) && $node->is_new)) {
    $updating = TRUE;
  }
  else {
    $updating = FALSE;
  }

  // Make sure that if is_new is not TRUE, it is not present.
  if (isset($node->is_new) && empty($node->is_new)) {
    unset($node->is_new);
  }

  // Validate field data prior to saving.
  MigrateDestinationEntity::fieldAttachValidate('node', $node);
  migrate_instrument_start('node_save');
  node_save($node);
  migrate_instrument_stop('node_save');
  if (isset($node->nid)) {
    if ($updating) {
      $this->numUpdated++;
    }
    else {
      $this->numCreated++;
    }

    // Unfortunately, http://drupal.org/node/722688 was not accepted, so fix
    // the changed timestamp
    if (isset($changed)) {
      db_update('node')
        ->fields(array(
        'changed' => $changed,
      ))
        ->condition('nid', $node->nid)
        ->execute();
      $node->changed = $changed;
    }

    // Potentially fix uid and timestamp in node_revisions.
    $query = db_update('node_revision')
      ->condition('vid', $node->vid);
    if (isset($changed)) {
      $fields['timestamp'] = $changed;
    }
    $revision_uid = isset($node->revision_uid) ? $node->revision_uid : $node->uid;
    if ($revision_uid != $GLOBALS['user']->uid) {
      $fields['uid'] = $revision_uid;
    }
    if (!empty($fields)) {

      // We actually have something to update.
      $query
        ->fields($fields);
      $query
        ->execute();
      if (isset($changed)) {
        $node->timestamp = $changed;
      }
    }
    $return = array(
      $node->nid,
    );
  }
  else {
    $return = FALSE;
  }
  $this
    ->complete($node, $row);
  return $return;
}