class MigrateDestinationTerm in Migrate 6.2

Same name and namespace in other branches

7.2 plugins/destinations/term.inc \MigrateDestinationTerm

Destination class implementing migration into terms.

Hierarchy

class \MigrateDestination
- class \MigrateDestinationEntity
  - class \MigrateDestinationTerm

Expanded class hierarchy of MigrateDestinationTerm

File

plugins/destinations/term.inc, line 15: Support for taxonomy term destinations.

View source

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;
  }

}

Members

Name	Modifiers	Type	Description
MigrateDestination::$numCreated	protected	property	Maintain stats on the number of destination objects created or updated.
MigrateDestination::$numUpdated	protected	property
MigrateDestination::getCreated	public	function
MigrateDestination::getUpdated	public	function
MigrateDestination::resetStats	public	function	Reset numCreated and numUpdated back to 0.
MigrateDestinationEntity::$bundle	protected	property	The bundle (node type, vocabulary, etc.) of the destination.
MigrateDestinationEntity::$entityType	protected	property	The entity type (node, user, taxonomy_term, etc.) of the destination.
MigrateDestinationEntity::$language	protected	property	Default language for text fields in this destination.
MigrateDestinationEntity::$textFormat	protected	property	Default input format for text fields in this destination.
MigrateDestinationEntity::complete	public	function	Give handlers a shot at modifying the object (or taking additional action) after saving it.
MigrateDestinationEntity::completeRollback	public	function	Give handlers a shot at cleaning up after an entity has been rolled back.
MigrateDestinationEntity::getBundle	public	function
MigrateDestinationEntity::getEntityType	public	function
MigrateDestinationEntity::getLanguage	public	function
MigrateDestinationEntity::getTextFormat	public	function
MigrateDestinationEntity::prepare	public	function	Give handlers a shot at modifying the object before saving it.
MigrateDestinationEntity::prepareRollback	public	function	Give handlers a shot at cleaning up before an entity has been rolled back.
MigrateDestinationEntity::__toString	public	function	Derived classes must implement __toString(). Overrides MigrateDestination::__toString
MigrateDestinationTerm::fields	public	function	Returns a list of fields available to be mapped for this vocabulary (bundle) Overrides MigrateDestination::fields
MigrateDestinationTerm::getKeySchema	public static	function
MigrateDestinationTerm::import	public	function	Import a single term. Overrides MigrateDestination::import
MigrateDestinationTerm::options	public static	function	Return an options array for term destinations.
MigrateDestinationTerm::rollback	public	function	Delete a migrated term
MigrateDestinationTerm::__construct	public	function	Basic initialization Overrides MigrateDestinationEntity::__construct

You are here

class MigrateDestinationTerm in Migrate 6.2

Hierarchy

File

Members

API Navigation