public function MigrateDestinationTerm::import in Migrate 6.2

Same name and namespace in other branches

1. 7.2 plugins/destinations/term.inc \MigrateDestinationTerm::import()

Import a single term.

Parameters

$term: Term 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 (tid only in this case) of the term that was saved if successful. FALSE on failure.

Overrides MigrateDestination::import

File

plugins/destinations/term.inc, line 108

Support for taxonomy term destinations.

Class

MigrateDestinationTerm

Destination class implementing migration into terms.

Code

public function import(stdClass $term, stdClass $row) {
  $migration = Migration::currentMigration();

  // Updating previously-migrated content?
  if (isset($row->migrate_map_destid1)) {
    $term->tid = $row->migrate_map_destid1;
    if (isset($term->tid)) {
      if ($term->tid != $row->migrate_map_destid1) {
        throw new MigrateException(t("Incoming tid !tid and map destination nid !destid1 don't match", array(
          '!tid' => $term->tid,
          '!destid1' => $row->migrate_map_destid1,
        )));
      }
    }
    else {
      $term->tid = $row->migrate_map_destid1;
    }
  }
  if ($migration
    ->getSystemOfRecord() == Migration::DESTINATION) {
    if (!isset($term->tid)) {
      throw new MigrateException(t('System-of-record is DESTINATION, but no destination tid provided'));
    }
    $rawterm = $term;
    $this
      ->prepare($term, $row);
    $old_term = taxonomy_term_load($term->tid);
    if (empty($old_term)) {
      throw new MigrateException(t('System-of-record is DESTINATION, but term !tid does not exist', array(
        '!tid' => $term->tid,
      )));
    }
    foreach ($rawterm as $field => $value) {
      $old_term->{$field} = $term->{$field};
    }
    $parents = taxonomy_get_parents($term->tid);
    if ($parents) {
      $parent = array_pop($parents);
      $old_term->parent = $parent->tid;
    }
    else {
      $old_term->parent = 0;
    }
    $term = $old_term;
  }
  else {

    // Default to bundle if no vocabulary machine name provided
    if (!isset($term->vocabulary_machine_name)) {
      $term->vocabulary_machine_name = $this->bundle;
    }

    // vid is required
    if (empty($term->vid)) {
      static $vocab_map = array();
      if (!isset($vocab_map[$term->vocabulary_machine_name])) {
        $vid = db_select('vocabulary', 'v')
          ->fields('v', array(
          'vid',
        ))
          ->condition('name', $term->vocabulary_machine_name)
          ->execute()
          ->fetchField();
        if ($vid) {
          $vocab_map[$term->vocabulary_machine_name] = $vid;
        }
        else {
          $migration
            ->saveMessage(t('No vocabulary found with machine_name !name', array(
            '!name' => $term->vocabulary_machine_name,
          )));
          return FALSE;
        }
      }
      $term->vid = $vocab_map[$term->vocabulary_machine_name];
    }

    // Look up parent name if provided
    if (isset($term->parent_name)) {

      // Look for the name in the same vocabulary.
      // Note that hierarchies may have multiples of the same name...
      $terms = taxonomy_get_term_by_name(trim($term->parent_name));
      foreach ($terms as $candidate) {
        if ($candidate->vid == $term->vid) {
          $term->parent = $candidate->tid;
          break;
        }
      }
      unset($term->parent_name);
    }
    if (empty($term->parent)) {
      $term->parent = 0;
    }
    if (is_array($term->parent) && isset($term->parent['arguments'])) {

      // Unset arguments here to avoid duplicate entries in the
      // term_hierarchy table.
      unset($term->parent['arguments']);
    }
    if (!isset($term->format)) {
      $term->format = $this->textFormat;
    }
    $this
      ->prepare($term, $row);

    // See if the term, with the same parentage, already exists - if so,
    // load it
    $candidates = taxonomy_get_term_by_name(trim($term->name));
    foreach ($candidates as $candidate) {
      if ($candidate->vid != $term->vid) {
        continue;
      }
      $parents = taxonomy_get_parents($candidate->tid);

      // We need to set up $parents as a simple array of tids
      if (empty($parents)) {
        $parents = array(
          0,
        );
      }
      else {

        // Parents array is tid => term object, make into list of tids
        $new_parents = array();
        foreach ($parents as $parent) {
          $new_parents[] = $parent->tid;
        }
        $parents = $new_parents;
      }
      if (in_array($term->parent, $parents)) {

        // We've found a matching term, we'll use that
        $candidate->parent = $term->parent;
        $term = $candidate;
        break;
      }
    }
  }

  // Trying to update an existing term
  if ($migration
    ->getSystemOfRecord() == Migration::DESTINATION) {
    $existing_term = taxonomy_term_load($term->tid);
    if ($existing_term) {

      // Incoming data overrides existing data, so only copy non-existent fields
      foreach ($existing_term as $field => $value) {
        if (!isset($term->{$field})) {
          $term->{$field} = $existing_term->{$field};
        }
      }
    }
  }
  if (isset($term->tid)) {
    $updating = TRUE;
  }
  else {
    $updating = FALSE;
  }
  migrate_instrument_start('taxonomy_term_save');
  $term = (array) $term;
  $status = taxonomy_save_term($term);
  $term = (object) $term;
  migrate_instrument_stop('taxonomy_term_save');
  $this
    ->complete($term, $row);
  if (isset($term->tid)) {
    if ($updating) {
      $this->numUpdated++;
    }
    else {
      $this->numCreated++;
    }
    $return = array(
      $term->tid,
    );
  }
  else {
    $return = FALSE;
  }
  return $return;
}