Club Drupal

function entity_features_export_options($a1, $a2 = NULL) {

  // Due to a change in the Features API the first parameter might be a feature

  // object or an entity type, depending on the Features version. This check is

  // for backwards compatibility.

  $entity_type = is_string($a1) ? $a1 : $a2;

; Information added by Drupal.org packaging script on 2014-01-08

version = "7.x-1.3"

datestamp = "1389210813"

        if (empty($property_info['field'])) {

          $extra[$this->entityType][$bundle_name]['display'][$name] = $this->generateExtraFieldInfo($name, $property_info);

        }

      $info['entity keys']['bundle'] => $bundle_name,

/**

 * Page callback for viewing an entity.

 *

 * @param Entity $entity

 *   The entity to be rendered.

 *

 * @return array

 *   A renderable array of the entity in full view mode.

 */

function entity_ui_entity_page_view($entity) {

  module_load_include('inc', 'entity', 'includes/entity.ui');

  return $entity->view('full', NULL, TRUE);

}

/**

 * Gets the page title for the passed operation.

 */

function entity_ui_get_page_title($op, $entity_type, $entity = NULL) {

  module_load_include('inc', 'entity', 'includes/entity.ui');

  $label = entity_label($entity_type, $entity);

  switch ($op) {

    case 'view':

      return $label;

    case 'edit':

      return t('Edit @label', array('@label' => $label));

    case 'clone':

      return t('Clone @label', array('@label' => $label));

    case 'revert':

      return t('Revert @label', array('@label' => $label));

    case 'delete':

      return t('Delete @label', array('@label' => $label));

    case 'export':

      return t('Export @label', array('@label' => $label));

  }

  if (isset($entity)) {

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

  }

  return entity_ui_get_action_title($op, $entity_type, $bundle);

}

 * Determines whether the given user can perform actions on an entity.

 *

 * For create operations, the pattern is to create an entity and then

 * check if the user has create access.

 *

 * @code

 * $node = entity_create('node', array('type' => 'page'));

 * $access = entity_access('create', 'node', $node, $account);

 * @endcode

      if (!isset($entity->{$keys['status']})) {

        $entity->{$keys['status']} = ENTITY_IN_CODE;

      }

      else {

        $entity->{$keys['status']} |= ENTITY_IN_CODE;

      }

  // URI callbacks.

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

    $entity_info['file']['uri callback'] = 'entity_metadata_uri_file';

  }

    // Create node owned by anonymous and test access() method on each of its

    // properties.

    $node = $this->drupalCreateNode(array('type' => 'page', 'uid' => 0));

    $wrapper = entity_metadata_wrapper('node', $node->nid);

    foreach ($wrapper as $name => $property) {

      $property->access('view');

    }

    // Property access of entity references takes entity access into account.

    $node = $this->drupalCreateNode(array('type' => 'article'));

    $wrapper = entity_metadata_wrapper('node', $node);

    $unprivileged_user = $this->drupalCreateUser();

    $privileged_user = $this->drupalCreateUser(array('access user profiles'));

    $this->assertTrue($wrapper->author->access('view', $privileged_user));

    $this->assertFalse($wrapper->author->access('view', $unprivileged_user));

    // Ensure the same works with multiple entity references by testing the

    // $node->field_tags example.

    $privileged_user = $this->drupalCreateUser(array('administer taxonomy'));

    // Terms are view-able with access content, so make sure to remove this

    // permission first.

    user_role_revoke_permissions(DRUPAL_ANONYMOUS_RID, array('access content'));

    $unprivileged_user = drupal_anonymous_user();

    $this->assertTrue($wrapper->field_tags->access('view', $privileged_user), 'Privileged user has access.');

    $this->assertTrue($wrapper->field_tags->access('view', $unprivileged_user), 'Unprivileged user has access.');

    $this->assertTrue($wrapper->field_tags[0]->access('view', $privileged_user), 'Privileged user has access.');

    $this->assertFalse($wrapper->field_tags[0]->access('view', $unprivileged_user), 'Unprivileged user has no access.');

/**

 * Tests basic entity_access() functionality for nodes.

 *

 * This code is a modified version of NodeAccessTestCase.

 *

 * @see NodeAccessTestCase

 */

class EntityMetadataNodeAccessTestCase extends EntityWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Entity Metadata Node Access',

      'description' => 'Test entity_access() for nodes',

      'group' => 'Entity API',

    );

  }

  /**

   * Asserts node_access() correctly grants or denies access.

   */

  function assertNodeMetadataAccess($ops, $node, $account) {

    foreach ($ops as $op => $result) {

      $msg = t("entity_access() returns @result with operation '@op'.", array('@result' => $result ? 'TRUE' : 'FALSE', '@op' => $op));

      $access = entity_access($op, 'node', $node, $account);

      $this->assertEqual($result, $access, $msg);

    }

  }

  function setUp() {

    parent::setUp('entity', 'node');

    // Clear permissions for authenticated users.

    db_delete('role_permission')

      ->condition('rid', DRUPAL_AUTHENTICATED_RID)

      ->execute();

  }

  /**

   * Runs basic tests for entity_access() function.

   */

  function testNodeMetadataAccess() {

    // Author user.

    $node_author_account = $this->drupalCreateUser(array());

    // Make a node object.

    $settings = array(

      'uid' => $node_author_account->uid,

      'type' => 'page',

      'title' => 'Node ' . $this->randomName(32),

    );

    $node = $this->drupalCreateNode($settings);

    // Ensures user without 'access content' permission can do nothing.

    $web_user1 = $this->drupalCreateUser(array('create page content', 'edit any page content', 'delete any page content'));

    $this->assertNodeMetadataAccess(array('create' => FALSE, 'view' => FALSE, 'update' => FALSE, 'delete' => FALSE), $node, $web_user1);

    // Ensures user with 'bypass node access' permission can do everything.

    $web_user2 = $this->drupalCreateUser(array('bypass node access'));

    $this->assertNodeMetadataAccess(array('create' => TRUE, 'view' => TRUE, 'update' => TRUE, 'delete' => TRUE), $node, $web_user2);

    // User cannot 'view own unpublished content'.

    $web_user3 = $this->drupalCreateUser(array('access content'));

    // Create an unpublished node.

    $settings = array('type' => 'page', 'status' => 0, 'uid' => $web_user3->uid);

    $node_unpublished = $this->drupalCreateNode($settings);

    $this->assertNodeMetadataAccess(array('view' => FALSE), $node_unpublished, $web_user3);

    // User cannot create content without permission.

    $this->assertNodeMetadataAccess(array('create' => FALSE), $node, $web_user3);

    // User can 'view own unpublished content', but another user cannot.

    $web_user4 = $this->drupalCreateUser(array('access content', 'view own unpublished content'));

    $web_user5 = $this->drupalCreateUser(array('access content', 'view own unpublished content'));

    $node4 = $this->drupalCreateNode(array('status' => 0, 'uid' => $web_user4->uid));

    $this->assertNodeMetadataAccess(array('view' => TRUE, 'update' => FALSE), $node4, $web_user4);

    $this->assertNodeMetadataAccess(array('view' => FALSE), $node4, $web_user5);

    // Tests the default access provided for a published node.

    $node5 = $this->drupalCreateNode();

    $this->assertNodeMetadataAccess(array('view' => TRUE, 'update' => FALSE, 'delete' => FALSE, 'create' => FALSE), $node5, $web_user3);

  }

}

/**

 * Test user permissions for node creation.

 */

class EntityMetadataNodeCreateAccessTestCase extends EntityWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Entity Metadata Node Create Access',

      'description' => 'Test entity_access() for nodes',

      'group' => 'Entity API',

    );

  }

  function setUp() {

    parent::setUp('entity', 'node');

  }

  /**

   * Addresses the special case of 'create' access for nodes.

   */

  public function testNodeMetadataCreateAccess() {

    // Create some users. One with super-powers, one with create perms,

    // and one with no perms, and a different one to author the node.

    $admin_account = $this->drupalCreateUser(array(

      'bypass node access',

    ));

    $creator_account = $this->drupalCreateUser(array(

      'create page content',

    ));

    $auth_only_account = $this->drupalCreateUser(array());

    $node_author_account = $this->drupalCreateUser(array());

    // Make a node object with Entity API (contrib)

    $settings = array(

      'uid' => $node_author_account->uid,

      'type' => 'page',

      'title' => $this->randomName(32),

      'body' => array(LANGUAGE_NONE => array(array($this->randomName(64)))),

    );

    $node = entity_create('node', $settings);

    // Test the populated wrapper.

    $wrapper = entity_metadata_wrapper('node', $node);

    $this->assertTrue($wrapper->entityAccess('create', $admin_account), 'Create access allowed for ADMIN, for populated wrapper.');

    $this->assertTrue($wrapper->entityAccess('create', $creator_account), 'Create access allowed for CREATOR, for populated wrapper.');

    $this->assertFalse($wrapper->entityAccess('create', $auth_only_account), 'Create access denied for USER, for populated wrapper.');

    // Test entity_acces().

    $this->assertTrue(entity_access('create', 'node', $node, $admin_account), 'Create access allowed for ADMIN, for entity_access().');

    $this->assertTrue(entity_access('create', 'node', $node, $creator_account), 'Create access allowed for CREATOR, for entity_access().');

    $this->assertFalse(entity_access('create', 'node', $node, $auth_only_account), 'Create access denied for USER, for entity_access().');

  }

}

/**

 * Tests user permissions for node revisions.

 *

 * Based almost entirely on NodeRevisionPermissionsTestCase.

 */

class EntityMetadataNodeRevisionAccessTestCase extends DrupalWebTestCase {

  protected $node_revisions = array();

  protected $accounts = array();

  // Map revision permission names to node revision access ops.

  protected $map = array(

    'view' => 'view revisions',

    'update' => 'revert revisions',

    'delete' => 'delete revisions',

  );

  public static function getInfo() {

    return array(

      'name' => 'Entity Metadata Node Revision Access',

      'description' => 'Tests user permissions for node revision operations.',

      'group' => 'Entity API',

    );

  }

  function setUp() {

    parent::setUp('entity', 'node');

    // Create a node with several revisions.

    $node = $this->drupalCreateNode();

    $this->node_revisions[] = $node;

    for ($i = 0; $i < 3; $i++) {

      // Create a revision for the same nid and settings with a random log.

      $revision = node_load($node->nid);

      $revision->revision = 1;

      $revision->log = $this->randomName(32);

      node_save($revision);

      $this->node_revisions[] = node_load($revision->nid);

    }

    // Create three users, one with each revision permission.

    foreach ($this->map as $op => $permission) {

      // Create the user.

      $account = $this->drupalCreateUser(

        array(

          'access content',

          'edit any page content',

          'delete any page content',

          $permission,

        )

      );

      $account->op = $op;

      $this->accounts[] = $account;

    }

    // Create an admin account (returns TRUE for all revision permissions).

    $admin_account = $this->drupalCreateUser(array('access content', 'administer nodes'));

    $admin_account->is_admin = TRUE;

    $this->accounts['admin'] = $admin_account;

    // Create a normal account (returns FALSE for all revision permissions).

    $normal_account = $this->drupalCreateUser();

    $normal_account->op = FALSE;

    $this->accounts[] = $normal_account;

  }

  /**

   * Tests the entity_access() function for revisions.

   */

  function testNodeRevisionAccess() {

    // $node_revisions[1] won't be the latest revision.

    $revision = $this->node_revisions[1];

    $parameters = array(

      'op' => array_keys($this->map),

      'account' => $this->accounts,

    );

    $permutations = $this->generatePermutations($parameters);

    $entity_type = 'node';

    foreach ($permutations as $case) {

      if (!empty($case['account']->is_admin) || $case['op'] == $case['account']->op) {

        $access = entity_access($case['op'], $entity_type, $revision, $case['account']);

        $this->assertTrue($access, "{$this->map[$case['op']]} granted on $entity_type.");

      }

      else {

        $access = entity_access($case['op'], $entity_type, $revision, $case['account']);

        $this->assertFalse($access, "{$this->map[$case['op']]} NOT granted on $entity_type.");

      }

    }

  }

}

    $node = $this->drupalCreateNode(array('title' => $title, 'type' => 'book', 'book' => array('bid' => 'new')));

    $book = array('bid' => $node->nid, 'plid' => $node->book['mlid']);

    $node2 = $this->drupalCreateNode(array('type' => 'book', 'book' => $book));

    $this->assertEqual($title, $wrapper->book->title->value(), "Book title returned.");

    $this->assertEqual(array($node->nid), $wrapper->book_ancestors->value(array('identifier' => TRUE)), "Book ancestors returned.");

    $this->assertException($wrapper, 'book_ancestors');

    $author = $this->drupalCreateUser(array('access comments', 'post comments', 'edit own comments'));

      'uid' => $author->uid,

    // Test comment entity access.

    $admin_user = $this->drupalCreateUser(array('access comments', 'administer comments'));

    // Also grant access to view user accounts to test the comment author

    // property.

    $unprivileged_user = $this->drupalCreateUser(array('access comments', 'access user profiles'));

    // Published comments can be viewed and edited by the author.

    $this->assertTrue($wrapper->access('view', $author), 'Comment author is allowed to view the published comment.');

    $this->assertTrue($wrapper->access('edit', $author), 'Comment author is allowed to edit the published comment.');

    // We cannot use $wrapper->access('delete') here because it only understands

    // view and edit.

    $this->assertFalse(entity_access('delete', 'comment', $comment, $author), 'Comment author is not allowed to delete the published comment.');

    // Administrators can do anything with published comments.

    $this->assertTrue($wrapper->access('view', $admin_user), 'Comment administrator is allowed to view the published comment.');

    $this->assertTrue($wrapper->access('edit', $admin_user), 'Comment administrator is allowed to edit the published comment.');

    $this->assertTrue(entity_access('delete', 'comment', $comment, $admin_user), 'Comment administrator is allowed to delete the published comment.');

    // Unpriviledged users can only view the published comment.

    $this->assertTrue($wrapper->access('view', $unprivileged_user), 'Unprivileged user is allowed to view the published comment.');

    $this->assertFalse($wrapper->access('edit', $unprivileged_user), 'Unprivileged user is not allowed to edit the published comment.');

    $this->assertFalse(entity_access('delete', 'comment', $comment, $unprivileged_user), 'Unprivileged user is not allowed to delete the published comment.');

    // Test property view access.

    $view_access = array('name', 'homepage', 'subject', 'created', 'author', 'node', 'parent', 'url', 'edit_url');

    foreach ($view_access as $property_name) {

      $this->assertTrue($wrapper->{$property_name}->access('view', $unprivileged_user), "Unpriviledged user can view the $property_name property.");

    }

    $view_denied = array('hostname', 'mail', 'status');

    foreach ($view_denied as $property_name) {

      $this->assertFalse($wrapper->{$property_name}->access('view', $unprivileged_user), "Unpriviledged user can not view the $property_name property.");

      $this->assertTrue($wrapper->{$property_name}->access('view', $admin_user), "Admin user can view the $property_name property.");

    }

    // The author is allowed to edit the comment subject if they have the

    // 'edit own comments' permission.

    $this->assertTrue($wrapper->subject->access('edit', $author), "Author can edit the subject property.");

    $this->assertFalse($wrapper->subject->access('edit', $unprivileged_user), "Unpriviledged user cannot edit the subject property.");

    $this->assertTrue($wrapper->subject->access('edit', $admin_user), "Admin user can edit the subject property.");

    $edit_denied = array('hostname', 'mail', 'status', 'name', 'homepage', 'created', 'parent', 'node', 'author');

    foreach ($edit_denied as $property_name) {

      $this->assertFalse($wrapper->{$property_name}->access('edit', $author), "Author cannot edit the $property_name property.");

      $this->assertTrue($wrapper->{$property_name}->access('edit', $admin_user), "Admin user can edit the $property_name property.");

    }

    // Test access to unpublished comments.

    $comment->status = COMMENT_NOT_PUBLISHED;

    comment_save($comment);

    // Unpublished comments cannot be accessed by the author.

    $this->assertFalse($wrapper->access('view', $author), 'Comment author is not allowed to view the unpublished comment.');

    $this->assertFalse($wrapper->access('edit', $author), 'Comment author is not allowed to edit the unpublished comment.');

    $this->assertFalse(entity_access('delete', 'comment', $comment, $author), 'Comment author is not allowed to delete the unpublished comment.');

    // Administrators can do anything with unpublished comments.

    $this->assertTrue($wrapper->access('view', $admin_user), 'Comment administrator is allowed to view the unpublished comment.');

    $this->assertTrue($wrapper->access('edit', $admin_user), 'Comment administrator is allowed to edit the unpublished comment.');

    $this->assertTrue(entity_access('delete', 'comment', $comment, $admin_user), 'Comment administrator is allowed to delete the unpublished comment.');

    // Unpriviledged users cannot access unpublished comments.

    $this->assertFalse($wrapper->access('view', $unprivileged_user), 'Unprivileged user is not allowed to view the unpublished comment.');

    $this->assertFalse($wrapper->access('edit', $unprivileged_user), 'Unprivileged user is not allowed to edit the unpublished comment.');

    $this->assertFalse(entity_access('delete', 'comment', $comment, $unprivileged_user), 'Unprivileged user is not allowed to delete the unpublished comment.');

      if ($key != 'book' && $key != 'book_ancestors' && $key != 'source' && $key != 'last_view') {

    $this->assertException($wrapper, 'book_ancestors');

    // Test statistics module integration access.

    $unpriviledged_user = $this->drupalCreateUser(array('access content'));

    $this->assertTrue($wrapper->access('view', $unpriviledged_user), 'Unpriviledged user can view the node.');

    $this->assertFalse($wrapper->access('edit', $unpriviledged_user), 'Unpriviledged user can not edit the node.');

    $count_access_user = $this->drupalCreateUser(array('view post access counter'));

    $admin_user = $this->drupalCreateUser(array('access content', 'view post access counter', 'access statistics'));

    $this->assertFalse($wrapper->views->access('view', $unpriviledged_user), "Unpriviledged user cannot view the statistics counter property.");

    $this->assertTrue($wrapper->views->access('view', $count_access_user), "Count access user can view the statistics counter property.");

    $this->assertTrue($wrapper->views->access('view', $admin_user), "Admin user can view the statistics counter property.");

    $admin_properties = array('day_views', 'last_view');

    foreach ($admin_properties as $property_name) {

      $this->assertFalse($wrapper->{$property_name}->access('view', $unpriviledged_user), "Unpriviledged user cannot view the $property_name property.");

      $this->assertFalse($wrapper->{$property_name}->access('view', $count_access_user), "Count access user cannot view the $property_name property.");

      $this->assertTrue($wrapper->{$property_name}->access('view', $admin_user), "Admin user can view the $property_name property.");

    }

    $account = $this->drupalCreateUser(array('access user profiles', 'change own username'));

    // Test property view access.

    $unpriviledged_user = $this->drupalCreateUser(array('access user profiles'));

    $admin_user = $this->drupalCreateUser(array('administer users'));

    $this->assertTrue($wrapper->access('view', $unpriviledged_user), 'Unpriviledged account can view the user.');

    $this->assertFalse($wrapper->access('edit', $unpriviledged_user), 'Unpriviledged account can not edit the user.');

    $view_access = array('name', 'url', 'edit_url', 'created');

    foreach ($view_access as $property_name) {

      $this->assertTrue($wrapper->{$property_name}->access('view', $unpriviledged_user), "Unpriviledged user can view the $property_name property.");

    }

    $view_denied = array('mail', 'last_access', 'last_login', 'roles', 'status', 'theme');

    foreach ($view_denied as $property_name) {

      $this->assertFalse($wrapper->{$property_name}->access('view', $unpriviledged_user), "Unpriviledged user can not view the $property_name property.");

      $this->assertTrue($wrapper->{$property_name}->access('view', $admin_user), "Admin user can view the $property_name property.");

    }

    // Test property edit access.

    $edit_own_allowed = array('name', 'mail');

    foreach ($edit_own_allowed as $property_name) {

      $this->assertTrue($wrapper->{$property_name}->access('edit', $account), "Account owner can edit the $property_name property.");

    }

    $this->assertTrue($wrapper->roles->access('view', $account), "Account owner can view their own roles.");

    $edit_denied = array('last_access', 'last_login', 'created', 'roles', 'status', 'theme');

    foreach ($edit_denied as $property_name) {

      $this->assertFalse($wrapper->{$property_name}->access('edit', $account), "Account owner cannot edit the $property_name property.");

      $this->assertTrue($wrapper->{$property_name}->access('edit', $admin_user), "Admin user can edit the $property_name property.");

    }

; Information added by Drupal.org packaging script on 2014-01-08

version = "7.x-1.3"

datestamp = "1389210813"

  if (is_array($data) || (is_object($data) && $data instanceof ArrayAccess)) {

    return is_numeric($data[$name]) ? $data[$name] : strtotime($data[$name], REQUEST_TIME);

  }

  elseif (is_object($data)) {

    return is_numeric($data->$name) ? $data->$name : strtotime($data->$name, REQUEST_TIME);

  }

      'setter callback' => 'entity_property_verbatim_set',

      'setter permissions' => 'administer filters',

    // If a property should be edited and this is part of an entity, make sure

    // the user has update access for this entity.

  /**

   * {@inheritdoc}

   *

   * Note that this method checks property access, but can be used for checking

   * entity access *only* if the wrapper is not a property (i.e. has no parent

   * wrapper).

   * To be safe, better use EntityDrupalWrapper::entityAccess() for checking

   * entity access.

   */

  public function access($op, $account = NULL) {

    if (!empty($this->info['parent'])) {

      // If this is a property, make sure the user is able to view the

      // currently referenced entity also.

      return $this->entityAccess('view', $account) && parent::access($op, $account);

    }

    else {

      // This is not a property, so fallback on entity access.

      return $this->entityAccess($op == 'edit' ? 'update' : 'view', $account);

    }

  }

  $properties['book_ancestors'] = array(

    'label' => t("Book ancestors"),

    'type' => 'list<node>',

    'computed' => TRUE,

    'description' => t("If part of a book, a list of all book pages upwards in the book hierarchy."),

    'getter callback' => 'entity_metadata_book_get_properties',

  );

}

  switch ($name) {

    case 'book':

      return $node->book['bid'];

    case 'book_ancestors':

      $ancestors = array();

      while (!empty($node->book['plid'])) {

        $link = book_link_load($node->book['plid']);

        array_unshift($ancestors, $link['nid']);

        $node = node_load($link['nid']);

      }

      return $ancestors;

  }

    case 'author':

      return !empty($node->uid) ? $node->uid : drupal_anonymous_user();

/**

 * Access callback for restricted node statistics properties.

 */

function entity_metadata_statistics_properties_access($op, $property, $entity = NULL, $account = NULL) {

  if ($property == 'views' && user_access('view post access counter', $account)) {

    return TRUE;

  }

  return user_access('access statistics', $account);

}

 *

 * @see entity_access()

 *

 * @param $op

 *   The operation being performed. One of 'view', 'update', 'create' or

 *   'delete'.

 * @param $node

 *   A node to check access for. Must be a node object. Must have nid,

 *   except in the case of 'create' operations.

 * @param $account

 *   The user to check for. Leave it to NULL to check for the global user.

 *

 * @throws EntityMalformedException

 *

 * @return boolean

 *   TRUE if access is allowed, FALSE otherwise.

  // First deal with the case where a $node is provided.

    if ($op == 'create') {

      if (isset($node->type)) {

        return node_access($op, $node->type, $account);

      }

      else {

        throw new EntityMalformedException('Permission to create a node was requested but no node type was given.');

      }

    }

    if ($node->vid !== $default_revision->vid) {

      return _node_revision_access($node, $op, $account);

  // No node is provided. Check for access to all nodes.

  if (user_access('bypass node access', $account)) {

    return TRUE;

  }

  if ($op == 'view' && node_access_view_all_nodes($account)) {

  // Comment administrators are allowed to perform all operations on all

  // comments.

  if (user_access('administer comments', $account)) {

    return TRUE;

  }

  // Unpublished comments can never be accessed by non-admins.

  if (isset($entity->status) && $entity->status == COMMENT_NOT_PUBLISHED) {

    return FALSE;

  }

      return $account->uid && $account->uid == $entity->uid && user_access('edit own comments', $account);

  if (user_access('access comments', $account) && $op == 'view') {

/**

 * Access callback for restricted comment properties.

 */

function entity_metadata_comment_properties_access($op, $property, $entity = NULL, $account = NULL) {

  return user_access('administer comments', $account);

}

function entity_metadata_form_taxonomy_vocabulary($vocab) {

  $form_state['build_info']['args'] = array($vocab);

  return drupal_build_form('taxonomy_form_vocabulary', $form_state);

/**

 * Implements entity_uri() callback for file entities.

 */

function entity_metadata_uri_file($file) {

  return array(

    'path' => file_create_url($file->uri),

  );

}

    'access callback' => 'entity_metadata_comment_properties_access',

    'access callback' => 'entity_metadata_comment_properties_access',

    'setter permission' => 'administer comments',

    'access callback' => 'entity_metadata_comment_properties_access',

    'getter callback' => 'entity_metadata_node_get_properties',

    'access callback' => 'entity_metadata_statistics_properties_access',

    'access callback' => 'entity_metadata_statistics_properties_access',

    'access callback' => 'entity_metadata_statistics_properties_access',

    'access callback' => 'entity_metadata_user_properties_access',

    'access callback' => 'entity_metadata_user_properties_access',

    'setter permission' => 'administer users',

    'access callback' => 'entity_metadata_user_properties_access',

; Information added by Drupal.org packaging script on 2014-01-08

version = "7.x-1.3"

datestamp = "1389210813"

; Information added by Drupal.org packaging script on 2014-01-08

version = "7.x-1.3"

datestamp = "1389210813"

  // Special handling for anonymous user.

  if ($node->entity['type'] === 'user' && empty($node->entity['id'])) {

    return entity_metadata_wrapper('user', drupal_anonymous_user());

  }

  else {

    return entity_metadata_wrapper($node->entity['type'], $node->entity['id']);

  }

; Information added by Drupal.org packaging script on 2014-01-08

version = "7.x-1.3"

datestamp = "1389210813"

      list($handler->entity_type, $handler->wrappers) = $handler->query->get_result_wrappers($values, NULL, $handler->real_field);

      list($handler->entity_type, $entities) = $handler->query->get_result_entities($values, NULL, $handler->real_field);

      $relationships = array();

      // Collect all relationships, keyed by alias.

      foreach ($view->relationship as $key => $relationship) {

        $key = $relationship->alias ? $relationship->alias : $key;

        $relationships[$key] = $relationship;

      }

      while (!empty($current_handler->relationship) && !empty($relationships[$current_handler->relationship])) {

        $current_handler = $relationships[$current_handler->relationship];

   * @see LdapServer->sid()

   * @see LdapServer->sid()

  /**

   * Email default handling option

   * 

   * This affects how email addresses that are empty are handled by 

   * the authentication process.

   * 

   *   LDAP_AUTHENTICATION_EMAIL_TEMPLATE_NONE -- leaves the email empty

   *   LDAP_AUTHENTICATION_EMAIL_TEMPLATE_IF_EMPTY (default) -- if the email is empty, it will be replaced

   *   LDAP_AUTHENTICATION_EMAIL_TEMPLATE_ALWAYS -- always use the template

   * 

   * @var int

   */

  public $emailTemplateHandling = LDAP_AUTHENTICATION_EMAIL_TEMPLATE_DEFAULT;

  /**

   * Email template.

   * 

   * @var string

   */

  public $emailTemplate = LDAP_AUTHENTICATION_DEFAULT_TEMPLATE;

  /**

   * Whether or not to display a notification to the user on login, prompting 

   * them to change their email.

   * 

   * @var boolean

   */

  public $templateUsagePromptUser = LDAP_AUTHENTICATION_TEMPLATE_USAGE_PROMPT_USER_DEFAULT;

  /**

   * Whether or not to avoid updating the email address of the user if the

   * template was used to generate it.

   * 

   * @var boolean

   */

  public $templateUsageNeverUpdate = LDAP_AUTHENTICATION_TEMPLATE_USAGE_NEVER_UPDATE_DEFAULT;

  /**

   * Whether or not to use the email template if there is a user with a different

   * login name but same email address in the system.

   * 

   * @var boolean

   */

  public $templateUsageResolveConflict = LDAP_AUTHENTICATION_TEMPLATE_USAGE_RESOLVE_CONFLICT_DEFAULT;

  /**

   * A PCRE regular expression (minus the delimiter and flags) that will be used

   * if $templateUsagePromptUser is set to true to determine if the email 

   * address is a fake one or not. 

   * 

   * By allowing this to be customized, we let the administrators handle older

   * patterns should they decide to change the existing one, as well as avoiding

   * the complexity of determining a proper regex from the template.

   * 

   * @var string

   */

  public $templateUsagePromptRegex = LDAP_AUTHENTICATION_DEFAULT_TEMPLATE_REGEX;

  /**

   * Controls whether or not we should check on login if the email template was

   * used and redirect the user if needed.

   * 

   * @var boolean

   */

  public $templateUsageRedirectOnLogin = LDAP_AUTHENTICATION_REDIRECT_ON_LOGIN_DEFAULT;

    'emailTemplate',

    'emailTemplateHandling',

    'templateUsagePromptUser',

    'templateUsageNeverUpdate',

    'templateUsageResolveConflict',

    'templateUsagePromptRegex',

    'templateUsageRedirectOnLogin',

    $values['emailTemplateHandlingOptions'] = array(

      LDAP_AUTHENTICATION_EMAIL_TEMPLATE_NONE => t('Never use the template.'),

      LDAP_AUTHENTICATION_EMAIL_TEMPLATE_IF_EMPTY => t('Use the template if no email address was provided by the LDAP server.'),

      LDAP_AUTHENTICATION_EMAIL_TEMPLATE_ALWAYS => t('Always use the template.'),

    );

  public $emailTemplateHandlingDefault = LDAP_AUTHENTICATION_EMAIL_TEMPLATE_DEFAULT;

  public $emailTemplateHandlingOptions;

  public $emailTemplateDefault = LDAP_AUTHENTICATION_DEFAULT_TEMPLATE;

  public $templateUsagePromptUserDefault = LDAP_AUTHENTICATION_TEMPLATE_USAGE_PROMPT_USER_DEFAULT;

  public $templateUsagePromptRegexDefault = LDAP_AUTHENTICATION_DEFAULT_TEMPLATE_REGEX;

  public $templateUsageNeverUpdateDefault = LDAP_AUTHENTICATION_TEMPLATE_USAGE_NEVER_UPDATE_DEFAULT;

    $form['email']['template'] = array(

      '#type' => 'fieldset',

      '#collapsible' => TRUE,

      '#title' => t('Email Templates'),

    );

    $form['email']['template']['emailTemplateHandling'] = array(

      '#type' => 'radios',

      '#title' => t('Email Template Handling'),

      '#required' => 1,

      '#default_value' => $this->emailTemplateHandling,

      '#options' => $this->emailTemplateHandlingOptions

    );

    $form['email']['template']['emailTemplate'] = array(

      '#type' => 'textfield',

      '#title' => t('Email Template'),

      '#required' => 0,

      '#default_value' => $this->emailTemplate,

    );

    $form['email']['template']['templateUsageResolveConflict'] = array(

      '#type' => 'checkbox',

      '#title' => t('If a Drupal account already exists with the same email, but different account name, use the email template instead of the LDAP email.'),

      '#default_value' => $this->templateUsageResolveConflict,

    );

    $form['email']['template']['templateUsageNeverUpdate'] = array(

      '#type' => 'checkbox',

      '#title' => t('Ignore the Email Update settings and never update the stored email if the template is used.'),

      '#default_value' => $this->templateUsageNeverUpdate,

    );

    $form['email']['prompts'] = array(

      '#type' => 'fieldset',

      '#collapsible' => TRUE,

      '#title' => t('User Email Prompt'),

      '#description' => t('These settings allow the user to fill in their email address after logging in if the template was used to generate their email address.'),      

    );

    $form['email']['prompts']['templateUsagePromptUser'] = array(

      '#type' => 'checkbox',

      '#title' => t('Prompt user for email on every page load.'),

      '#default_value' => $this->templateUsagePromptUser,

    );

    $form['email']['prompts']['templateUsageRedirectOnLogin'] = array(

      '#type' => 'checkbox',

      '#title' => t('Redirect the user to the form after logging in.'),

      '#default_value' => $this->templateUsageRedirectOnLogin,

    );

    $form['email']['prompts']['templateUsagePromptRegex'] = array(

      '#type' => 'textfield',

      '#default_value' => $this->templateUsagePromptRegex,

      '#title' => t('Template Regex'),

      '#description' => t('This regex will be used to determine if the template was used to create an account.'),

    );

    $this->emailTemplateHandling = ($values['emailTemplateHandling']) ? (int) $values['emailTemplateHandling'] : NULL;

    $this->emailTemplate = ($values['emailTemplate']) ? $values['emailTemplate'] : '';

    $this->templateUsagePromptUser = ($values['templateUsagePromptUser']) ? 1 : 0;

    $this->templateUsageResolveConflict = ($values['templateUsageResolveConflict']) ? 1 : 0;

    $this->templateUsagePromptRegex = ($values['templateUsagePromptRegex']) ? $values['templateUsagePromptRegex'] : '';

    $this->templateUsageRedirectOnLogin = ($values['templateUsageRedirectOnLogin']) ? 1 : 0;

    $this->templateUsageNeverUpdate = ($values['templateUsageNeverUpdate']) ? 1 : 0;

    if ($auth_conf->templateUsageRedirectOnLogin) {

      $form['#submit'][] = 'ldap_authentication_check_for_email_template';

    }

/**

 * Replaces the email address in $ldap_user with one from the template in

 * $auth_conf.

 * 

 * @param array $ldap_user

 *   LDAP user entry

 * @param LdapAuthenticationConf $auth_conf

 *   LDAP authentication configuration class.

 */

function _ldap_authentication_replace_user_email(&$ldap_user, $auth_conf, $tokens) {

  // fallback template in case one was not specified.

  $template = '@username@localhost';

  if (!empty($auth_conf->emailTemplate)) {

    $template = $auth_conf->emailTemplate;

  }

  $ldap_user['mail'] = format_string($template, $tokens);

}

  // @todo maybe we can add more tokens?

  $email_template_tokens = array(

    '@username' => $drupal_accountname,

  );

  $email_template_used = FALSE;

  /**

   * Ensures that we respect the email template handling settings.

   */

  if (!empty($auth_conf->emailTemplate)) {

    switch ($auth_conf->emailTemplateHandling) {

      case LDAP_AUTHENTICATION_EMAIL_TEMPLATE_IF_EMPTY:

        if (!empty($ldap_user['mail'])) {

          break;

        }

        // deliberate fallthrough

      case LDAP_AUTHENTICATION_EMAIL_TEMPLATE_ALWAYS: