term.inc in Migrate 6.2

Support for taxonomy term destinations.

File

plugins/destinations/term.inc

<?php

/**
 * @file
 * Support for taxonomy term destinations.
 */

// TODO:
// Make sure this works with updates, explicit destination keys
// taxonomy_term_save() is doing a cache_clear_all and an automatic insertion for parent.

/**
 * Destination class implementing migration into terms.
 */
class MigrateDestinationTerm extends MigrateDestinationEntity {
  public static function getKeySchema() {
    return array(
      'tid' => array(
        'type' => 'int',
        'unsigned' => TRUE,
        'description' => 'ID of destination term',
      ),
    );
  }

  /**
   * Return an options array for term destinations.
   *
   * @param string $language
   *  Default language for terms created via this destination class.
   * @param string $text_format
   *  Default text format for terms created via this destination class.
   */
  public static function options($language, $text_format) {
    return compact('language', 'text_format');
  }

  /**
   * Basic initialization
   *
   * @param array $options
   *  Options applied to terms.
   */
  public function __construct($bundle, array $options = array()) {
    parent::__construct('taxonomy_term', $bundle, $options);
  }

  /**
   * Returns a list of fields available to be mapped for this vocabulary (bundle)
   *
   * @return array
   *  Keys: machine names of the fields (to be passed to addFieldMapping)
   *  Values: Human-friendly descriptions of the fields.
   */
  public function fields() {
    $fields = array();

    // First the core (taxonomy_term_data table) properties
    $fields['tid'] = t('Term: <a href="@doc">Existing term ID</a>', array(
      '@doc' => 'http://drupal.org/node/1349702#tid',
    ));
    $fields['name'] = t('Term: <a href="@doc">Name</a>', array(
      '@doc' => 'http://drupal.org/node/1349702#name',
    ));
    $fields['description'] = t('Term: <a href="@doc">Description</a>', array(
      '@doc' => 'http://drupal.org/node/1349702#description',
    ));
    $fields['parent'] = t('Term: <a href="@doc">Parent (by Drupal term ID)</a>', array(
      '@doc' => 'http://drupal.org/node/1349702#parent',
    ));

    // TODO: Remove parent_name, implement via arguments
    $fields['parent_name'] = t('Term: <a href="@doc">Parent (by name)</a>', array(
      '@doc' => 'http://drupal.org/node/1349702#parent_name',
    ));
    $fields['format'] = t('Term: <a href="@doc">Format</a>', array(
      '@doc' => 'http://drupal.org/node/1349702#format',
    ));
    $fields['weight'] = t('Term: <a href="@doc">Weight</a>', array(
      '@doc' => 'http://drupal.org/node/1349702#weight',
    ));

    // Then add in anything provided by handlers
    $fields += migrate_handler_invoke_all('taxonomy_term', 'fields', $this->entityType, $this->bundle);
    return $fields;
  }

  /**
   * Delete a migrated term
   *
   * @param $ids
   *  Array of fields representing the key (in this case, just tid).
   */
  public function rollback(array $key) {
    $tid = reset($key);
    migrate_instrument_start('taxonomy_term_delete');
    $this
      ->prepareRollback($tid);
    $result = (bool) taxonomy_del_term($tid);
    $this
      ->completeRollback($tid);
    migrate_instrument_stop('taxonomy_term_delete');
    return $result == SAVED_DELETED;
  }

  /**
   * Import a single term.
   *
   * @param $term
   *  Term object to build. Prefilled with any fields mapped in the Migration.
   * @param $row
   *  Raw source data object - passed through to prepare/complete handlers.
   * @return array
   *  Array of key fields (tid only in this case) of the term that was saved if
   *  successful. FALSE on failure.
   */
  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;
  }

}

/**
 * Handler to process term assignments for nodes
 */
class MigrateTermNodeHandler extends MigrateDestinationHandler {
  public function __construct() {
    $this
      ->registerTypes(array(
      'node',
    ));
  }
  public function prepare(stdClass $node, stdClass $row) {

    // Identify vocabularies for this node type
    $vocabs = taxonomy_get_vocabularies($node->type);
    foreach ($vocabs as $vid => $vocab) {
      $vocab_name = $vocab->name;
      if (isset($node->{$vocab_name})) {
        $vocab_values = $node->{$vocab_name};
        if (!is_array($vocab_values)) {
          $vocab_values = array(
            $vocab_values,
          );
        }
        $by_tid = FALSE;
        if (isset($vocab_values['arguments']['source_type'])) {
          if ($vocab_values['arguments']['source_type'] == 'tid') {
            $by_tid = TRUE;
          }
        }
        unset($vocab_values['arguments']);
        foreach ($vocab_values as $term_value) {
          if ($by_tid) {
            $node->taxonomy[$term_value] = $term_value;
          }
          else {
            foreach (taxonomy_get_term_by_name($term_value) as $term) {
              if ($term->vid == $vid) {
                $node->taxonomy[$term->tid] = $term->tid;
              }
            }
          }
        }
      }
    }
  }

  /*
   * @param
   *   Can be 'tid'. Otherwise, 'name' is assumed.
   */
  static function arguments($source_type = NULL) {
    return get_defined_vars();
  }
  public function fields($entity_type, $bundle) {
    $fields = array();
    $vocabs = taxonomy_get_vocabularies($bundle);
    foreach ($vocabs as $vid => $vocab) {
      $vocab_name = $vocab->name;
      $fields[$vocab_name] = $vocab_name;
    }
    return $fields;
  }

}

Classes

Name	Description
MigrateDestinationTerm	Destination class implementing migration into terms.
MigrateTermNodeHandler	Handler to process term assignments for nodes