uuid.core.inc in Universally Unique IDentifier 7

Implementation of UUID hooks for all core modules.

@todo Replace all these hook implementations with a generic solution that uses info from hook_entity_field_info() and hook_entity_property_info(). That info should contain info about how UUIDs are mapped.

File

uuid.core.inc

View source

<?php

/**
 * @file
 * Implementation of UUID hooks for all core modules.
 *
 * @todo
 *   Replace all these hook implementations with a generic solution that uses
 *   info from hook_entity_field_info() and hook_entity_property_info(). That
 *   info should contain info about how UUIDs are mapped.
 */

/**
 * @defgroup uuid_property Propery implementations
 * @{
 */

/**
 * Implements hook_entity_uuid_load().
 */
function node_entity_uuid_load(&$entities, $entity_type) {
  if ($entity_type == 'node') {
    entity_property_id_to_uuid($entities, 'user', array(
      'uid',
      'revision_uid',
    ));
    entity_property_id_to_uuid($entities, 'node', 'tnid');
  }
}

/**
 * Implements hook_entity_uuid_presave().
 */
function node_entity_uuid_presave(&$entity, $entity_type) {
  if ($entity_type == 'node') {
    entity_property_uuid_to_id($entity, 'user', array(
      'uid',
      'revision_uid',
    ));
    entity_property_uuid_to_id($entity, 'node', 'tnid');

    // A node always must have an author.
    if (empty($entity->uid)) {
      global $user;
      $entity->uid = $user->uid;
    }
  }
}

/**
 * Implements hook_entity_uuid_save().
 */
function node_entity_uuid_save(&$entity, $entity_type) {

  /*
   * When a node is translated, the source node's tnid is set to it's own nid.
   * When deploying the node for the first time the tnid can't be translated
   * to an nid until after the node has been saved. So if the entity's tnid
   * is still a uuid at this point it needs to be translated to an nid.
   */
  if ($entity_type == 'node' && uuid_is_valid($entity->tnid)) {
    entity_property_uuid_to_id($entity, 'node', 'tnid');
    db_update('node')
      ->fields(array(
      'tnid' => $entity->tnid,
    ))
      ->condition('nid', $entity->nid)
      ->execute();
  }
}

/**
 * Implements hook_entity_uuid_load().
 */
function book_uuid_entities_features_export_entity_alter(&$entity, $entity_type) {
  if ($entity_type == 'node') {
    if (!empty($entity->book)) {
      $entity->book['bid'] = current(entity_get_uuid_by_id($entity_type, array(
        $entity->book['bid'],
      )));
    }
  }
}

/**
 * Implements hook_entity_uuid_presave().
 */
function book_entity_uuid_presave(&$entity, $entity_type) {
  if ($entity_type == 'node') {
    if (!empty($entity->book)) {
      $entity->book['bid'] = current(entity_get_id_by_uuid($entity_type, array(
        $entity->book['bid'],
      )));
      if (!$entity->book['bid']) {
        $entity->book['bid'] = 'new';
      }
    }
  }
}

/**
 * Implements hook_entity_uuid_presave().
 */
function user_entity_uuid_presave(&$entity, $entity_type) {
  if ($entity_type != 'user') {
    return;
  }

  /*
   * We need to ensure new user's passwords are encrypted. The Services module
   * transparently encrypts the password for new users. md5() is used by
   * users who's accounts were migrated from Drupal 6 and who haven't updated
   * their password.
   */
  if (isset($entity->pass) && (!('$S$D' == substr($entity->pass, 0, 4)) || preg_match('/^[a-f0-9]{32}$/', $entity->pass))) {

    // Ensure user's password is hashed.
    $entity->pass = user_hash_password($entity->pass);
  }
  if (empty($entity->picture)) {
    return;
  }
  $uuids = entity_get_id_by_uuid('file', array(
    $entity->picture['uuid'],
  ));
  $fid = current($uuids);
  if (!$entity->is_new) {
    $entity->picture = file_load($fid);
  }
  else {
    $entity->picture = $fid;
  }
}

/**
 * Implements hook_entity_uuid_load().
 */
function comment_entity_uuid_load(&$entities, $entity_type) {
  switch ($entity_type) {
    case 'node':
      entity_property_id_to_uuid($entities, 'user', 'last_comment_uid');
      break;
    case 'comment':
      entity_property_id_to_uuid($entities, 'user', array(
        'uid',
        'u_uid',
      ));
      entity_property_id_to_uuid($entities, 'node', 'nid');
      break;
  }
}

/**
 * Implements hook_entity_uuid_presave().
 */
function comment_entity_uuid_presave(&$entity, $entity_type) {
  switch ($entity_type) {
    case 'node':
      entity_property_uuid_to_id($entity, 'user', 'last_comment_uid');
      break;
    case 'comment':

      // entity_make_entity_local() may have unset cid, add back if necessary.
      if (!isset($entity->cid)) {
        $entity->cid = NULL;
      }
      entity_property_uuid_to_id($entity, 'user', array(
        'uid',
        'u_uid',
      ));
      entity_property_uuid_to_id($entity, 'node', 'nid');
      break;
  }
}

/**
 * Implements hook_entity_uuid_load().
 */
function file_entity_uuid_load(&$entities, $entity_type) {
  if ($entity_type == 'file') {
    entity_property_id_to_uuid($entities, 'user', 'uid');
  }
}

/**
 * Implements hook_entity_uuid_presave().
 */
function file_entity_uuid_presave(&$entity, $entity_type) {
  if ($entity_type == 'file') {

    // entity_make_entity_local() may have unset fid, add back if necessary.
    if (!isset($entity->fid)) {
      $entity->fid = NULL;
    }
    entity_property_uuid_to_id($entity, 'user', 'uid');

    // Write the new file to the local filesystem.
    if (isset($entity->file_contents) && !empty($entity->filesize)) {

      // Don't try to write it if it uses a stream wrapper that isn't writeable
      // (for example, if it is a remotely-hosted video).
      $scheme = file_uri_scheme($entity->uri);
      $wrappers = file_get_stream_wrappers(STREAM_WRAPPERS_WRITE);
      if (empty($wrappers[$scheme])) {
        return;
      }

      // Check for an existing file with the same URI.
      $existing_files = file_load_multiple(array(), array(
        'uri' => $entity->uri,
      ));
      $existing = (object) array(
        'uri' => NULL,
        'uuid' => NULL,
      );
      if (count($existing_files)) {
        $existing = reset($existing_files);
      }

      // If this is a new file and there is an existing file with the same URI,
      // but a different uuid then rename this file.
      if ($entity->is_new && $entity->uri == $existing->uri && $entity->uuid != $existing->uuid) {
        $uri = $entity->uri;
        $replace = FILE_EXISTS_RENAME;
      }
      elseif ($entity->uri == $existing->uri && $entity->uuid != $existing->uuid) {
        $file = file_load($entity->fid);
        $uri = $file->uri;
        $replace = FILE_EXISTS_REPLACE;
      }
      else {
        $uri = $entity->uri;
        $replace = FILE_EXISTS_REPLACE;
      }
      $directory = drupal_dirname($uri);
      if (!empty($directory) && file_prepare_directory($directory, FILE_CREATE_DIRECTORY)) {
        $entity->uri = file_unmanaged_save_data(base64_decode($entity->file_contents), $uri, $replace);
      }
    }
  }
}

/**
 * Implements hook_entity_uuid_load().
 */
function taxonomy_entity_uuid_load(&$entities, $entity_type) {
  if ($entity_type == 'taxonomy_term') {
    foreach ($entities as &$entity) {
      if (isset($entity->parent)) {
        if (!is_array($entity->parent)) {
          $entity->parent = array(
            $entity->parent,
          );
        }
        $uuids = entity_get_uuid_by_id('taxonomy_term', $entity->parent);
        $entity->parent = array_values($uuids);
      }
      unset($entity->vid);
    }
  }
}

/**
 * Implements hook_entity_uuid_presave().
 */
function taxonomy_entity_uuid_presave(&$entity, $entity_type) {
  if ($entity_type == 'taxonomy_term') {
    if (isset($entity->parent)) {
      if (!is_array($entity->parent)) {
        $entity->parent = array(
          $entity->parent,
        );
      }
      $ids = entity_get_id_by_uuid('taxonomy_term', $entity->parent);
      $entity->parent = array_values($ids);
    }
    $vocabulary = taxonomy_vocabulary_machine_name_load($entity->vocabulary_machine_name);
    $entity->vid = $vocabulary->vid;
  }
}

/**
 * Implements hook_entity_uuid_load().
 */
function field_entity_uuid_load(&$entities, $entity_type) {
  foreach ($entities as $entity) {
    list(, , $bundle_name) = entity_extract_ids($entity_type, $entity);
    $instances = field_info_instances($entity_type, $bundle_name);
    foreach ($instances as $field_name => $instance) {
      $field = field_info_field($field_name);
      if (!empty($field) && isset($entity->{$field_name})) {
        foreach ($entity->{$field_name} as $langcode => &$items) {

          // Invoke 'hook_field_uuid_load'. We can't use module_invoke() since
          // that is not passing by reference.
          $function = $field['module'] . '_field_uuid_load';
          if (function_exists($function)) {
            $function($entity_type, $entity, $field, $instance, $langcode, $items);
          }
        }
      }
    }
  }
}

/**
 * Implements hook_entity_uuid_presave().
 */
function field_entity_uuid_presave(&$entity, $entity_type) {
  list(, , $bundle_name) = entity_extract_ids($entity_type, $entity);
  $instances = field_info_instances($entity_type, $bundle_name);
  foreach ($instances as $field_name => $instance) {
    $field = field_info_field($field_name);
    if (!empty($field) && isset($entity->{$field_name})) {
      foreach ($entity->{$field_name} as $langcode => &$items) {

        // Invoke 'hook_field_uuid_load'. We can't use module_invoke() since
        // that is not passing by reference.
        $function = $field['module'] . '_field_uuid_presave';
        if (function_exists($function)) {
          $function($entity_type, $entity, $field, $instance, $langcode, $items);
        }
      }
    }
  }
}

/**
 * @} End of "Property implementations"
 */

/**
 * @defgroup uuid_field Field implementations
 * @{
 */

/**
 * Implements hook_field_uuid_load().
 */
function taxonomy_field_uuid_load($entity_type, $entity, $field, $instance, $langcode, &$items) {
  entity_property_id_to_uuid($items, 'taxonomy_term', 'tid');
}

/**
 * Implements hook_field_uuid_presave().
 */
function taxonomy_field_uuid_presave($entity_type, $entity, $field, $instance, $langcode, &$items) {
  entity_property_uuid_to_id($items, 'taxonomy_term', 'tid');
}

/**
 * Implements hook_field_uuid_load().
 */
function file_field_uuid_load($entity_type, $entity, $field, $instance, $langcode, &$items) {
  entity_property_id_to_uuid($items, 'file', 'fid');
  entity_property_id_to_uuid($items, 'user', 'uid');
}

/**
 * Implements hook_field_uuid_presave().
 */
function file_field_uuid_presave($entity_type, $entity, $field, $instance, $langcode, &$items) {
  entity_property_uuid_to_id($items, 'file', 'fid');
  entity_property_uuid_to_id($items, 'user', 'uid');
}

/**
 * Implements hook_field_uuid_load().
 */
function image_field_uuid_load($entity_type, $entity, $field, $instance, $langcode, &$items) {
  file_field_uuid_load($entity_type, $entity, $field, $instance, $langcode, $items);
}

/**
 * Implements hook_field_uuid_presave().
 */
function image_field_uuid_presave($entity_type, $entity, $field, $instance, $langcode, &$items) {
  file_field_uuid_presave($entity_type, $entity, $field, $instance, $langcode, $items);
}

/**
 * Implements hook_field_uuid_load().
 *
 * Kept here because it is in D8 core.
 */
function entityreference_field_uuid_load($entity_type, $entity, $field, $instance, $langcode, &$items) {

  // TODO: This is not really good, but as of now 'entity_property_id_to_uuid()'
  // can't handle a single $item.
  entity_property_id_to_uuid($items, $field['settings']['target_type'], 'target_id');
}

/**
 * Implements hook_field_uuid_presave().
 *
 * Kept here because it is in D8 core.
 */
function entityreference_field_uuid_presave($entity_type, $entity, $field, $instance, $langcode, &$items) {

  // TODO: This is not really good, but as of now 'entity_property_id_to_uuid()'
  // can't handle a single $item.
  entity_property_uuid_to_id($items, $field['settings']['target_type'], 'target_id');
}

/**
 * @} End of "Field implementations"
 */

/**
 * @defgroup uuid_export Export alterations
 * @{
 */

/**
 * Implements hook_uuid_entities_features_export_entity_alter().
 */
function node_uuid_entities_features_export_entity_alter(&$entity, $entity_type) {
  if ('node' != $entity_type) {
    return;
  }
  $properties = array(
    'data',
    'name',
    'picture',
    'revision_uid',
    'last_comment_timestamp',
  );
  foreach ($properties as $property) {
    if (property_exists($entity, $property)) {
      unset($entity->{$property});
    }
  }
}

/**
 * Implements hook_uuid_entities_features_export_entity_alter().
 */
function user_uuid_entities_features_export_entity_alter(&$entity, $entity_type) {
  if ('user' != $entity_type) {
    return;
  }
  foreach (array(
    'data',
    'access',
    'login',
  ) as $property) {
    if (property_exists($entity, $property)) {
      unset($entity->{$property});
    }
  }
}

/**
 * Implements hook_uuid_entities_features_export_alter().
 */
function file_uuid_entities_features_export_field_alter($entity_type, $entity, $field, $instance, $langcode, &$items) {
  foreach ($items as &$item) {
    if (isset($item['timestamp'])) {
      unset($item['timestamp']);
    }
  }
}

/**
 * @} End of "Export alterations"
 */

Functions

Name	Description
book_entity_uuid_presave	Implements hook_entity_uuid_presave().
book_uuid_entities_features_export_entity_alter	Implements hook_entity_uuid_load().
comment_entity_uuid_load	Implements hook_entity_uuid_load().
comment_entity_uuid_presave	Implements hook_entity_uuid_presave().
entityreference_field_uuid_load	Implements hook_field_uuid_load().
entityreference_field_uuid_presave	Implements hook_field_uuid_presave().
field_entity_uuid_load	Implements hook_entity_uuid_load().
field_entity_uuid_presave	Implements hook_entity_uuid_presave().
file_entity_uuid_load	Implements hook_entity_uuid_load().
file_entity_uuid_presave	Implements hook_entity_uuid_presave().
file_field_uuid_load	Implements hook_field_uuid_load().
file_field_uuid_presave	Implements hook_field_uuid_presave().
file_uuid_entities_features_export_field_alter	Implements hook_uuid_entities_features_export_alter().
image_field_uuid_load	Implements hook_field_uuid_load().
image_field_uuid_presave	Implements hook_field_uuid_presave().
node_entity_uuid_load	Implements hook_entity_uuid_load().
node_entity_uuid_presave	Implements hook_entity_uuid_presave().
node_entity_uuid_save	Implements hook_entity_uuid_save().
node_uuid_entities_features_export_entity_alter	Implements hook_uuid_entities_features_export_entity_alter().
taxonomy_entity_uuid_load	Implements hook_entity_uuid_load().
taxonomy_entity_uuid_presave	Implements hook_entity_uuid_presave().
taxonomy_field_uuid_load	Implements hook_field_uuid_load().
taxonomy_field_uuid_presave	Implements hook_field_uuid_presave().
user_entity_uuid_presave	Implements hook_entity_uuid_presave().
user_uuid_entities_features_export_entity_alter	Implements hook_uuid_entities_features_export_entity_alter().

You are here

uuid.core.inc in Universally Unique IDentifier 7

File

Functions

API Navigation