Club Drupal

 * Automatic UUID generation:

   UUIDs will be generated for all core entities. An API is provided for other

   modules to enable support for custom entities.

 * UUID API for entities, properties and fields:

   With this unified API you can load entities with entity_uuid_load() so that

   all supported properties and fields are made with UUID references. You can

 */

/**

 */

$plugin = array(

  'title' => t("Entity: UUID"),

);

/**

 */

function uuid_entity_uuid_get_child($plugin, $parent, $child) {

  $plugins = uuid_entity_uuid_get_children($plugin, $parent);

}

/**

 */

function uuid_entity_uuid_get_children($original_plugin, $parent) {

  $entities = entity_get_info();

    // Get the keys for local ID and UUID.

    $uuid_key = $info['entity keys']['uuid'];

    $uuid_entities = entity_uuid_load($entity_type, array($entity->{$uuid_key}));

    return kdevel_print_object(reset($uuid_entities), '$' . $entity_type . '->');

  }

  else {

    return t("This entity doesn't support UUID.");

}

/**

 */

function hook_entity_uuid_load(&$entities, $entity_type) {

}

/**

 */

function hook_field_uuid_load($entity_type, $entity, $field, $instance, $langcode, &$items) {

}

/**

 */

function hook_entity_uuid_presave(&$entity, $entity_type) {

}

/**

 */

function hook_field_uuid_presave($entity_type, $entity, $field, $instance, $langcode, &$items) {

}

/**

 */

function hook_entity_uuid_save($entity, $entity_type) {

/**

 * Let modules act when an entity is deleted.

 */

function hook_entity_uuid_delete($entity, $entity_type) {

}

/**

 */

function hook_uuid_menu_path_to_uri_alter($path, &$uri) {

}

/**

 */

function hook_uuid_menu_uri_to_path(&$path, $uri) {

  if ($entity_type == 'node') {

    entity_property_uuid_to_id($entity, 'user', array('uid', 'revision_uid'));

    entity_property_uuid_to_id($entity, 'node', 'tnid');

  }

}

 * Implements hook_entity_uuid_save().

 */

function node_entity_uuid_save(&$entity, $entity_type) {

  if ($entity_type == 'node' && uuid_is_valid($entity->tnid)) {

    entity_property_uuid_to_id($entity, 'node', 'tnid');

    db_update('node')

 * Implements hook_entity_uuid_presave().

 */

function user_entity_uuid_presave(&$entity, $entity_type) {

  }

}

      break;

    case 'comment':

      entity_property_uuid_to_id($entity, 'user', array('uid', 'u_uid'));

      entity_property_uuid_to_id($entity, 'node', 'nid');

      break;

 */

function file_entity_uuid_presave(&$entity, $entity_type) {

  if ($entity_type == 'file') {

    entity_property_uuid_to_id($entity, 'user', 'uid');

    // Write the new file to the local filesystem.

      // 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);

      }

      $directory = drupal_dirname($uri);

    }

  }

}

 * Implements hook_entity_uuid_load().

 */

function field_entity_uuid_load(&$entities, $entity_type) {

    list(, , $bundle_name) = entity_extract_ids($entity_type, $entity);

    $instances = field_info_instances($entity_type, $bundle_name);

/**

 * 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) {

/**

 * 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) {

 * Implements hook_uuid_entities_features_export_entity_alter().

 */

function node_uuid_entities_features_export_entity_alter(&$entity, $entity_type) {

    }

  }

}

/**

 */

function user_uuid_entities_features_export_entity_alter(&$entity, $entity_type) {

    }

  }

}

 */

/**

 */

function uuid_drush_command() {

  $items = array();

}

/**

 */

function uuid_drush_help($section) {

  switch ($section) {

class UuidEntityException extends Exception {}

/**

 *

 * @see uuid_entity_info()

 * @see uuid_schema_alter()

 */

function uuid_entity_property_info_alter(&$info) {

  foreach (entity_get_info() as $entity_type => $entity_info) {

      && !empty($entity_info['entity keys']['uuid'])

      && empty($info[$entity_type]['properties'][$entity_info['entity keys']['uuid']])) {

      $info[$entity_type]['properties'][$entity_info['entity keys']['uuid']] = array(

        'description' => t('The universally unique ID.'),

        'schema field' => $entity_info['entity keys']['uuid'],

      );

        && empty($info[$entity_type]['properties'][$entity_info['entity keys']['revision uuid']])) {

        $info[$entity_type]['properties'][$entity_info['entity keys']['revision uuid']] = array(

          'label' => t('Revision UUID'),

    }

  }

  else {

  }

}

    return entity_delete($entity_type, $id);

  }

  else {

  }

}

 * @todo

 *   Limit the query.

 *

 *   The entity type we should be dealing with.

 *   is TRUE this should be revision UUIDs instead.

 *   If TRUE the revision IDs is returned instead.

 *   IDs and UUIDs are returned instead.

 */

function entity_get_id_by_uuid($entity_type, $uuids, $revision = FALSE) {

  $result = db_select($table, 't')

    ->fields('t', array($uuid_key, $id_key))

    ->condition($uuid_key, array_values($uuids), 'IN')

  $cache = &drupal_static('entity_uuid_id_cache', array());

  $cache[$entity_type][(int) $revision] += $result;

  return $result + $cached_ids;

 * @todo

 *   Limit the query.

 *

 *   The entity type we should be dealing with.

 *   is TRUE this should be revision IDs instead.

 *   If TRUE the revision UUIDs is returned instead.

 *   IDs and UUIDs are returned instead.

 */

function entity_get_uuid_by_id($entity_type, $ids, $revision = FALSE) {

    ->execute()

    ->fetchAllKeyed();

  $cache = &drupal_static('entity_uuid_id_cache', array());

  return $result + $cached_ids;

}

 * @todo

 *   Add tests for this function.

 *

 *   entity object or a field items array.

 *   The type of entity that all $properties refers to.

 *   An array of properties that should be changed. All properties must refer to

 *   the same type of entity (the one referenced in $entity_type).

 */

 * @todo

 *   Add tests for this function.

 *

 *   entity object or a field items array.

 *   The type of entity that all $properties refers to.

 *   An array of properties that should be changed. All properties must refer to

 *   the same type of entity (the one referenced in $entity_type).

 */

      }

      // We unset some common timestamp properties, since those will change and

      // constantly leave the feature overidden.

      foreach ($keys as $key) {

        if (isset($entity->{$key})) {

          unset($entity->{$key});

      }

      uuid_entities_features_clean($entity);

      if (is_object($entity) && method_exists($entity, 'export')) {

        $entity = get_object_vars($entity);

      }

/**

 * Pattern for detecting a valid UUID.

 */

/**

 * Generates an universally unique identifier.

 * universally unique identifiers. If that doesn't exist, then it falls back on

 * PHP for generating that.

 *

 *   An UUID, made up of 32 hex digits and 4 hyphens.

 */

function uuid_generate() {

  return $callback();

}

/**

 * Generate all missing UUIDs.

 */

 *   The type of entity being used.

 *

 * @return string

 */

function uuid_entity_uuid_uri($entity, $entity_type) {

  $entity_info = entity_get_info($entity_type);

/**

 * Converts an ID URI string to an entity data array.

 *

 * @param string $uri

 *

 * @return array

 */

function uuid_id_uri_to_data($uri) {

  $parts = explode('/', $uri);

 * Converts a URI array to entity data array.

 *

 * @param array $uri

 *

 * @return array

 */

function uuid_id_uri_array_to_data($uri) {

  $data = array(

/**

 * Converts a UUID URI string to an entity data array.

 *

 * @param string $uri

 *

 * @return array

 */

function uuid_uri_to_data($uri, $strip_uuid = TRUE) {

  return uuid_uri_array_to_data(explode('/', $uri));

 * Converts a URI array to entity data array.

 *

 * @param array $uri

 *

 * @return array

 */

function uuid_uri_array_to_data($uri, $strip_uuid = TRUE) {

  if ($strip_uuid) {

  $data = array(

    'request' => $uri,

  );

  drupal_alter('uuid_uri_data', $data);

  );

}

if (!function_exists('uuid_is_valid')) {

  /**

   * Check that a string appears to be in the format of a UUID.

   *

   *

   */

  function uuid_is_valid($uuid) {

    return preg_match('/^' . UUID_PATTERN . '$/', $uuid);

  }

}

dependencies[] = node

dependencies[] = user

core = "7.x"

project = "uuid"

/**

 * Implements hook_schema_alter().

 */

    }

  }

}

}

/**

 *

 */

function _uuid_install_uuid_fields() {

  $field = uuid_schema_field_definition();

    if (!db_field_exists($info['base table'], $info['entity keys']['uuid'])) {

      db_add_field($info['base table'], $info['entity keys']['uuid'], $field);

      db_add_index($info['base table'], $info['entity keys']['uuid'], array($info['entity keys']['uuid']));

 * Implements hook_uninstall().

 */

function uuid_uninstall() {

    if (db_field_exists($info['base table'], $info['entity keys']['uuid'])) {

      db_drop_field($info['base table'], $info['entity keys']['uuid']);

      db_drop_index($info['base table'], $info['entity keys']['uuid']);

}

/**

 */

function uuid_update_6002() {

  $ret = array();

}

/**

 */

function uuid_update_6004() {

  $ret = array();

}

/**

 * Modify existing uuid_node_revisions table to support revision deletion, and

 * add in as much legacy data as possible.

 */

}

/**

 */

function uuid_update_7101() {

  drupal_flush_all_caches();

}

/**

 *

 * Note that update 7102 calls _uuid_install_uuid_fields(), which is an

 * idempotent function.  If _uuid_install_uuid_fields() is changed at some

 * will have run update 7102, and some will not.  A new uuid_update_7103()

 * function would would therefore be necessary to update all users to

 * the latest schema.  At the same time, uuid_update_7102() could become

 */

function uuid_update_7102() {

  // If the user have disabled the UUID module during upgrade (as UPGRADE.txt

}

/**

 * Modify the labels of all example entities created by the now removed

 */

function uuid_update_7103() {

  // These are UUIDs of all the example entities that might exist after having

      '7cf875e6-dc15-4404-f190-5a7c3e91d14c',

    ),

  );

  if (isset($info['taxonomy_term'])) {

    $uuids['taxonomy_term'] = array(

      'bcb92ce8-2236-e264-65c8-0c163ae716d1',

    'title' => 'UUID redirector',

    'description' => 'Redirects requests for UUID URIs to the referenced entity.',

    'page callback' => 'uuid_redirector',

    'access callback' => TRUE,

    'type' => MENU_CALLBACK,

  );

    'page callback' => 'drupal_get_form',

    'page arguments' => array('uuid_admin_form'),

    'access arguments' => array('administer uuid'),

    'file' => 'uuid.admin.inc',

  );

  return array_fill_keys($hook_names, array('group' => 'uuid'));

}

/**

 * Implements hook_views_api().

 */

 * Implements hook_uuid_sync().

 */

function uuid_uuid_sync() {

    if (isset($info['uuid']) && $info['uuid'] == TRUE && !empty($info['entity keys']['uuid'])) {

      _uuid_sync_table($info['base table'], $info['entity keys']['id'], $info['entity keys']['uuid']);

      if (!empty($info['entity keys']['revision uuid'])) {

  drupal_goto($uri['path'], $uri['options'], 301);

}

 */

/**

 */

  /**

   * Helper function that asserts a UUID.

   */

    $this->assertTrue(uuid_is_valid($uuid), $message);

  }

}

/**

  /**

   * {@inheritdoc}

   */

  }

  /**

   * Tests uuid function calls.

   */

    // This is a valid UUID, we know that.

    $valid_uuid = '0ab26e6b-f074-4e44-9da6-1205fa0e9761';

    // Test the uuid_is_valid() function.

    // The default generator is 'php'.

    $uuid = uuid_generate();

    // Test the 'mysql' generator.

    variable_set('uuid_generator', 'mysql');

    drupal_static_reset('uuid_generate');

    $uuid = uuid_generate();

  }

}

/**

  /**

   * {@inheritdoc}

   */

  }

  /**

   * Tests Entity API's UUID functions.

   */

    // Create some entities that we will work with.

    $user = $this->drupalCreateUser();

    $node = $this->drupalCreateNode(array('title' => 'original title', 'uid' => $user->uid));

    $vuuids = entity_get_uuid_by_id('node', array($node->vid), TRUE);

    $this->assertTrue(in_array($node->vuuid, $vuuids), 'Lookup of entity revision UUID works.');

  }

}

/**

  /**

   * {@inheritdoc}

   */

    // Some tests depends on the optional Entity API module.

    if (module_exists('entity')) {

    }

  }

  /**

   * Test CRUD on users with UUID functions.

   */

    $user = $this->drupalCreateUser();

    // Test updating user.

    $user_test = clone $user;

      $this->assertFalse($user_test, 'Deleting user with UUID worked.');

    }

  }

}

/**

  /**

   * {@inheritdoc}

   */

    // Some tests depends on the optional Entity API module.

    if (module_exists('entity')) {

    }

  }

  /**

   * @todo

   *   Break out into multiple test methods to loosen coupling between tests.

   */

    // Create some entities that we will work with.

    $user = $this->drupalCreateUser();

    $node = $this->drupalCreateNode(array('title' => 'original title', 'uid' => $user->uid));

    // Test node update, without creating new revision.

    $node_test = clone $node;

    $node_test = node_load($node->nid, FALSE, TRUE);

    $this->assertEqual($node_test->uuid, $node->uuid, 'Node UUID was intact after updating, when creating new revision.');

    $this->assertNotEqual($node_test->vuuid, $node->vuuid, 'A new node revision UUID was generated, when creating new revision.');

    // Test entity_uuid_load().

    // Save some variables that we will test against.

      $this->assertEqual($node_test->title, 'newer title', 'Saving node with UUID mapped to correct node, when creating new revision.');

      $this->assertEqual($node_test->uuid, $node->uuid, 'Node UUID was intact after saving with UUID, when creating new revision.');

      $this->assertNotEqual($node_test->vuuid, $node->vuuid, 'A new node revison UUID was generated after saving with UUID, when creating new revision.');

      $this->assertEqual($node_test->uid, $node->uid, "Node property 'uid' was intact after saving with UUID, when creating new revision.");

      // Test the same thing again, but now triggering a new revision from a

      $node_test = reset($nodes);

      // Store the current local revision ID to test with later.

      $vid_old1 = $node_test->vid;

      // Simulate this node coming from a remote environment by generating

      // IDs that won't match. Only the UUID match at this point.

      $node_test->uuid_services = TRUE;

      $vuuid_test = uuid_generate();

      $node_test->nid = $nid_test;

      $node_test->vid = $vid_test;

      $this->assertFalse($node_test, 'Deleting node with UUID worked.');

    }

  }

}

/**

 */

class UUIDCommentTestCase extends CommentHelperCase {

  /**

   * {@inheritdoc}

   */

    );

  }

  /**

   * Test CRUD on comments with UUID functions.

   */

    // This is sub optimal, but due to how CommentHelperCase::setUp() is

    // constructed we are enforced to do this. So unfortunately this test

    // depends on 'entity' module for now.

    $user = $this->drupalCreateUser();

    $this->drupalLogin($user);

    $node = $this->drupalCreateNode();

    $return = $this->postComment($node, 'Lorem ipsum');

    $comment = comment_load($return->id);

    // Test updating comment.

    $comment_test = clone $comment;

      $this->assertFalse($comment_test, 'Deleting comment with UUID worked.');

    }

  }

}

/**

 */

class UUIDTaxonomyTestCase extends TaxonomyWebTestCase {

  /**

   * {@inheritdoc}

   */

   *

   * A lot of code here is taken from TaxonomyTermTestCase::setUp().

   */

    // Some tests depends on the optional Entity API module.

    if (module_exists('entity')) {

    }

  }

  /**

   * Test CRUD on comments with UUID functions.

   */

    $this->drupalLogin($user);

    // Create a term by tagging a node. We'll use this node later too.

    $vocabulary->vid = 1;

    $term = $this->createTerm($vocabulary);

    // Test updating term.

    $term_test = clone $term;

      $this->assertFalse($term_test, 'Deleting term with UUID worked.');

    }

  }

}

/**

   * @todo

   *   There are something weird around this assertion.

   */

    $this->assertTrue(db_field_exists($table, $column), $message);

  }

  /**

   * Tests creating UUIDs for entities that don't have them.

   */

    // These entities will not have UUID from the start, since the UUID module

    // isn't installed yet.

    $user = $this->drupalCreateUser();

    // Test if UUID was generated for nodes.

    $node_test = node_load($node->nid, FALSE, TRUE);

    // Test if UUID was generated for users.

    $user_test = user_load($user->uid, TRUE);

  }

}

<?php

/**

 * @file

 */

/**

dependencies[] = uuid

core = "7.x"

project = "uuid"

/**

 * @file

 */

/**

 */

function _uuid_path_load_url_aliases(&$entities, $entity_type) {

  $info = entity_get_info($entity_type);

  if (!isset($info['uri callback'])) {

    return;

  }

    $aliases = _uuid_path_url_alias_load($path['path']);

    // Ignore local IDs.

      unset($alias->pid);

      unset($alias->source);

    }

function _uuid_path_save_url_aliases(&$entity, $entity_type) {

  $info = entity_get_info($entity_type);

  if (!isset($info['uri callback'])) {

    return FALSE;

  }

  path_delete(array('source' => $path));

  // Continue if aliases are present.

    return FALSE;

  }

/**