materio-base-d7/sites/all/modules/contrib/users/profile2/profile2.module

<?php

/**
 * @file
 * Support for configurable user profiles.
 */

/**
 * Implements hook_entity_info().
 */
function profile2_entity_info() {
  $return = array(
    'profile2' => array(
      'label' => t('Profile'),
      'plural label' => t('Profiles'),
      'description' => t('Profile2 user profiles.'),
      'entity class' => 'Profile',
      'controller class' => 'EntityAPIController',
      'base table' => 'profile',
      'fieldable' => TRUE,
      'view modes' => array(
        'account' => array(
          'label' => t('User account'),
          'custom settings' => FALSE,
        ),
      ),
      'entity keys' => array(
        'id' => 'pid',
        'bundle' => 'type',
        'label' => 'label',
      ),
      'bundles' => array(),
      'bundle keys' => array(
        'bundle' => 'type',
      ),
      'label callback' => 'entity_class_label',
      'uri callback' => 'entity_class_uri',
      'access callback' => 'profile2_access',
      'module' => 'profile2',
      'metadata controller class' => 'Profile2MetadataController'
    ),
  );

  // Add bundle info but bypass entity_load() as we cannot use it here.
  $types = db_select('profile_type', 'p')
    ->fields('p')
    ->execute()
    ->fetchAllAssoc('type');

  foreach ($types as $type => $info) {
    $return['profile2']['bundles'][$type] = array(
      'label' => $info->label,
      'admin' => array(
        'path' => 'admin/structure/profiles/manage/%profile2_type',
        'real path' => 'admin/structure/profiles/manage/' . $type,
        'bundle argument' => 4,
        'access arguments' => array('administer profiles'),
      ),
    );
  }

  // Support entity cache module.
  if (module_exists('entitycache')) {
    $return['profile2']['field cache'] = FALSE;
    $return['profile2']['entity cache'] = TRUE;
  }

  $return['profile2_type'] = array(
    'label' => t('Profile type'),
    'plural label' => t('Profile types'),
    'description' => t('Profiles types of Profile2 user profiles.'),
    'entity class' => 'ProfileType',
    'controller class' => 'EntityAPIControllerExportable',
    'base table' => 'profile_type',
    'fieldable' => FALSE,
    'bundle of' => 'profile2',
    'exportable' => TRUE,
    'entity keys' => array(
      'id' => 'id',
      'name' => 'type',
      'label' => 'label',
    ),
    'access callback' => 'profile2_type_access',
    'module' => 'profile2',
    // Enable the entity API's admin UI.
    'admin ui' => array(
      'path' => 'admin/structure/profiles',
      'file' => 'profile2.admin.inc',
      'controller class' => 'Profile2TypeUIController',
    ),
  );

  return $return;
}

/**
 * Menu argument loader; Load a profile type by string.
 *
 * @param $type
 *   The machine-readable name of a profile type to load.
 * @return
 *   A profile type array or FALSE if $type does not exist.
 */
function profile2_type_load($type) {
  return profile2_get_types($type);
}

/**
 * Implements hook_menu().
 */
function profile2_menu() {
  $items = array();

  // Define page which provides form to generate profiles using
  // Devel generate module.
  if (module_exists('devel_generate')) {
    $items['admin/config/development/generate/profile2'] = array(
      'title' => 'Generate profiles',
      'description' => 'Generate a given number of profiles for users. Optionally override current user profiles.',
      'access arguments' => array('administer profiles'),
      'page callback' => 'drupal_get_form',
      'page arguments' => array('profile2_generate_form'),
      'file' => 'profile2.devel.inc',
    );
  }

  $items['user/%profile2_by_uid/%/delete'] = array(
    'title' => 'Delete',
    'description' => 'Delete Profile of User.',
    'type' => MENU_NORMAL_ITEM,
    'page callback' => 'drupal_get_form',
    'page arguments' => array('profile2_delete_confirm_form', 1),
    'load arguments' => array(2),
    'access callback' => 'profile2_access',
    'access arguments' => array('delete', 1),
    'file' => 'profile2.delete.inc',
  );
  return $items;
}

/**
 * Implements hook_permission().
 */
function profile2_permission() {
  $permissions = array(
    'administer profile types' =>  array(
      'title' => t('Administer profile types'),
      'description' => t('Create and delete fields on user profiles, and set their permissions.'),
    ),
    'administer profiles' =>  array(
      'title' => t('Administer profiles'),
      'description' => t('Edit and view all user profiles.'),
    ),
  );
  // Generate per profile type permissions.
  foreach (profile2_get_types() as $type) {
    $type_name = check_plain($type->type);
    $permissions += array(
      "edit own $type_name profile" => array(
        'title' => t('%type_name: Edit own profile', array('%type_name' => $type->getTranslation('label'))),
      ),
      "edit any $type_name profile" => array(
        'title' => t('%type_name: Edit any profile', array('%type_name' => $type->getTranslation('label'))),
      ),
      "view own $type_name profile" => array(
        'title' => t('%type_name: View own profile', array('%type_name' => $type->getTranslation('label'))),
      ),
      "view any $type_name profile" => array(
        'title' => t('%type_name: View any profile', array('%type_name' => $type->getTranslation('label'))),
      ),
      "delete own $type_name profile" => array(
        'title' => t('%type_name: Delete own profile', array('%type_name' => $type->getTranslation('label'))),
      ),
    );
  }
  return $permissions;
}

/**
 * Gets an array of all profile types, keyed by the type name.
 *
 * @param $type_name
 *   If set, the type with the given name is returned.
 * @return ProfileType[]
 *   Depending whether $type isset, an array of profile types or a single one.
 */
function profile2_get_types($type_name = NULL) {
  $types = entity_load_multiple_by_name('profile2_type', isset($type_name) ? array($type_name) : FALSE);
  return isset($type_name) ? reset($types) : $types;
}

/**
 * Fetch a profile object.
 *
 * @param $pid
 *   Integer specifying the profile id.
 * @param $reset
 *   A boolean indicating that the internal cache should be reset.
 * @return
 *   A fully-loaded $profile object or FALSE if it cannot be loaded.
 *
 * @see profile2_load_multiple()
 */
function profile2_load($pid, $reset = FALSE) {
  $profiles = profile2_load_multiple(array($pid), array(), $reset);
  return reset($profiles);
}

/**
 * Load multiple profiles based on certain conditions.
 *
 * @param $pids
 *   An array of profile IDs.
 * @param $conditions
 *   An array of conditions to match against the {profile} table.
 * @param $reset
 *   A boolean indicating that the internal cache should be reset.
 * @return
 *   An array of profile objects, indexed by pid.
 *
 * @see entity_load()
 * @see profile2_load()
 * @see profile2_load_by_user()
 */
function profile2_load_multiple($pids = array(), $conditions = array(), $reset = FALSE) {
  return entity_load('profile2', $pids, $conditions, $reset);
}

/**
 * Fetch profiles by account.
 *
 * @param $account
 *   The user account to load profiles for, or its uid.
 * @param $type_name
 *   To load a single profile, pass the type name of the profile to load.
 * @return
 *   Either a single profile or an array of profiles keyed by profile type.
 *
 * @see profile2_load_multiple()
 * @see profile2_profile2_delete()
 * @see Profile::save()
 */
function profile2_load_by_user($account, $type_name = NULL) {
  // Use a separate query to determine all profile ids per user and cache them.
  // That way we can look up profiles by id and benefit from the static cache
  // of the entity loader.
  $cache = &drupal_static(__FUNCTION__, array());
  $uid = is_object($account) ? $account->uid : $account;

  if (!isset($cache[$uid])) {
    $cache[$uid] = db_select('profile', 'p')
      ->fields('p', array('type', 'pid'))
      ->condition('uid', $uid)
      ->execute()
      ->fetchAllKeyed();
  }

  if (isset($type_name)) {
    return isset($cache[$uid][$type_name]) ? profile2_load($cache[$uid][$type_name]) : FALSE;
  }

  // Return an array containing profiles keyed by profile type.
  return $cache[$uid] ? array_combine(array_keys($cache[$uid]), profile2_load_multiple($cache[$uid])) : $cache[$uid];
}

/**
 * Implements hook_profile2_delete().
 */
function profile2_profile2_delete($profile) {
  // Clear the static cache from profile2_load_by_user().
  $cache = &drupal_static('profile2_load_by_user', array());
  unset($cache[$profile->uid][$profile->type]);
}

/**
 * Deletes a profile.
 */
function profile2_delete(Profile $profile) {
  $profile->delete();
}

/**
 * Delete multiple profiles.
 *
 * @param $pids
 *   An array of profile IDs.
 */
function profile2_delete_multiple(array $pids) {
  entity_get_controller('profile2')->delete($pids);
}

/**
 * Implements hook_user_delete().
 */
function profile2_user_delete($account) {
  foreach (profile2_load_by_user($account) as $profile) {
    profile2_delete($profile);
  }
}

/**
 * Create a new profile object.
 */
function profile2_create(array $values) {
  return new Profile($values);
}

/**
 * Deprecated. Use profile2_create().
 */
function profile_create(array $values) {
  return new Profile($values);
}

/**
 * Saves a profile to the database.
 *
 * @param $profile
 *   The profile object.
 */
function profile2_save(Profile $profile) {
  return $profile->save();
}

/**
 * Saves a profile type to the db.
 */
function profile2_type_save(ProfileType $type) {
  $type->save();
}

/**
 * Deletes a profile type from.
 */
function profile2_type_delete(ProfileType $type) {
  $type->delete();
}

/**
 * Implements hook_profile2_type_insert().
 */
function profile2_profile2_type_insert(ProfileType $type) {
  // Do not directly issue menu rebuilds here to avoid potentially multiple
  // rebuilds. Instead, let menu_get_item() issue the rebuild on the next page.
  variable_set('menu_rebuild_needed', TRUE);
}

/**
 * Implements hook_profile2_type_update().
 */
function profile2_profile2_type_update(ProfileType $type) {
  // @see profile2_profile2_type_insert()
  variable_set('menu_rebuild_needed', TRUE);
}

/**
 * Implements hook_profile2_type_delete()
 */
function profile2_profile2_type_delete(ProfileType $type) {
  // Delete all profiles of this type but only if this is not a revert.
  if (!$type->hasStatus(ENTITY_IN_CODE)) {
    $pids = array_keys(profile2_load_multiple(FALSE, array('type' => $type->type)));
    if ($pids) {
      profile2_delete_multiple($pids);
    }
    // @see profile2_profile2_type_insert()
    variable_set('menu_rebuild_needed', TRUE);
  }
}

/**
 * Implements hook_user_view().
 */
function profile2_user_view($account, $view_mode, $langcode) {
  foreach (profile2_get_types() as $type => $profile_type) {
    if ($profile_type->userView && $profile = profile2_load_by_user($account, $type)) {
      if (profile2_access('view', $profile)) {
        $account->content['profile_' . $type] = array(
          '#type' => 'user_profile_category',
          '#title' => $profile_type->getTranslation('label'),
          '#prefix' => '<a id="profile-' . $profile->type . '"></a>',
        );
        $account->content['profile_' . $type]['view'] = $profile->view($view_mode);
      }
    }
  }
}

/**
 * Implements hook_form_FORM_ID_alter() for the user edit form.
 *
 * @see profile2_form_validate_handler
 * @see profile2_form_submit_handler
 */
function profile2_form_user_profile_form_alter(&$form, &$form_state) {
  global $user;
  if (($type = profile2_get_types($form['#user_category'])) && $type->userCategory) {
    if (empty($form_state['profiles'])) {
      $profile = profile2_load_by_user($form['#user'], $form['#user_category']);
      if (empty($profile)) {
        $profile = profile2_create(array('type' => $form['#user_category'], 'uid' => $form['#user']->uid));
        $profile->is_new = TRUE;
      }
      $form_state['profiles'][$profile->type] = $profile;

      if (user_access('administer profiles') && $user->uid != $profile->uid) {
        $str_button_value = t('Delete profile');
      }
      elseif (user_access("delete own $profile->type profile") && $user->uid === $profile->uid) {
        $str_button_value = t('Delete this profile');
      }
    }
    if (empty($profile->is_new) && !empty($str_button_value)) {
      $form['actions']['delete'] = array(
        '#type' => 'submit',
        '#value' => $str_button_value,
        '#weight' => 45,
        '#limit_validation_errors' => array(),
        '#submit' => array('profile2_form_submit_own_delete')
      );
    }
    profile2_attach_form($form, $form_state);
  }
}

/**
 * Profile form submit handler for the delete button.
 */
function profile2_form_submit_own_delete($form, &$form_state) {
  $profile = $form_state['profiles'][$form['#user_category']];
  if (isset($profile) && is_object($profile)) {
    $form_state['redirect'] = 'user/' . $profile->uid . '/' . $form['#user_category'] . '/delete';
  }
}

/**
 * Implements hook_form_FORM_ID_alter() for the registration form.
 */
function profile2_form_user_register_form_alter(&$form, &$form_state) {
  foreach (profile2_get_types() as $type_name => $profile_type) {
    if (!empty($profile_type->data['registration'])) {
      if (empty($form_state['profiles'][$type_name])) {
        $form_state['profiles'][$type_name] = profile2_create(array('type' => $type_name));
      }
    }
  }

  // If we have profiles to attach to the registration form - then do it.
  if (!empty($form_state['profiles'])) {
    profile2_attach_form($form, $form_state);

    // Wrap each profile form in a fieldset.
    foreach ($form_state['profiles'] as $type_name => $profile_type) {
      $form['profile_' . $type_name] += array(
        '#type' => 'fieldset',
        '#title' => check_plain($profile_type->getTranslation('label')),
      );
    }
  }
}

/**
 * Attaches the profile forms of the profiles set in
 * $form_state['profiles'].
 *
 * Modules may alter the profile2 entity form regardless to which form it is
 * attached by making use of hook_form_profile2_form_alter().
 *
 * @param $form
 *   The form to which to attach the profile2 form. For each profile the form
 *   is added to @code $form['profile_' . $profile->type] @endcode. This helper
 *   also adds in a validation and a submit handler caring for the attached
 *   profile forms.
 *
 * @see hook_form_profile2_form_alter()
 * @see profile2_form_validate_handler()
 * @see profile2_form_submit_handler()
 */
function profile2_attach_form(&$form, &$form_state) {
  foreach ($form_state['profiles'] as $type => $profile) {
    $form['profile_' . $profile->type]['#tree'] = TRUE;
    $form['profile_' . $profile->type]['#parents'] = array('profile_' . $profile->type);
    field_attach_form('profile2', $profile, $form['profile_' . $profile->type], $form_state);

    if (user_access('administer profile types')) {
      if (count(field_info_instances('profile2', $profile->type)) == 0) {
        $form['profile_' . $profile->type]['message'] = array(
          '#markup' => t('No fields have been associated with this profile type. Go to the <a href="!url">Profile types</a> page to add some fields.', array('!url' => url('admin/structure/profiles'))),
        );
      }
    }

    // Make sure we don't have duplicate pre render callbacks.
    $form['profile_' . $profile->type]['#pre_render'] = array_unique($form['profile_' . $profile->type]['#pre_render']);

    // Provide a central place for modules to alter the profile forms, but
    // skip that in case the caller cares about invoking the hooks.
    // @see profile2_form().
    if (!isset($form_state['profile2_skip_hook'])) {
      $hooks[] = 'form_profile2_edit_' . $type . '_form';
      $hooks[] = 'form_profile2_form';
      drupal_alter($hooks, $form, $form_state);
    }
  }
  $form['#validate'][] = 'profile2_form_validate_handler';

  // Default name of user registry form callback.
  $register_submit_callback = 'user_register_submit';

  // LoginToBoggan module replaces default user_register_submit() callback
  // with his own. So if this module enabled we need to track his callback
  // instead one that comes from the User module.
  if (module_exists('logintoboggan')) {
    $register_submit_callback = 'logintoboggan_user_register_submit';
  }

  // Search for key of user register submit callback.
  if (!empty($form['#submit']) && is_array($form['#submit'])) {
    $submit_key = array_search($register_submit_callback, $form['#submit']);
  }

  // Add these hooks only when needed, and ensure they are not added twice.
  if (isset($submit_key) && $submit_key !== FALSE && !in_array('profile2_form_before_user_register_submit_handler', $form['#submit'])) {

    // Insert submit callback right before the user register submit callback.
    // Needs for disabling email notification during user registration.
    array_splice($form['#submit'], $submit_key, 0, array('profile2_form_before_user_register_submit_handler'));

    // Add a submit callback right after the user register submit callback.
    // This is needed for creation of a new user profile.
    array_splice($form['#submit'], $submit_key + 2, 0, array('profile2_form_submit_handler'));

    // Insert submit handler right after the creation of new user profile.
    // This is needed for sending email which was blocked during registration.
    array_splice($form['#submit'], $submit_key + 3, 0, array('profile2_form_after_user_register_submit_handler'));
  }
  else {
    // Fallback if some contrib module removes user register submit callback
    // from form submit functions.
    $form['#submit'][] = 'profile2_form_submit_handler';
  }
}

/**
 * Validation handler for the profile form.
 *
 * @see profile2_attach_form()
 */
function profile2_form_validate_handler(&$form, &$form_state) {
  foreach ($form_state['profiles'] as $type => $profile) {
    if (isset($form_state['values']['profile_' . $profile->type])) {
      // @see entity_form_field_validate()
      $pseudo_entity = (object) $form_state['values']['profile_' . $profile->type];
      $pseudo_entity->type = $type;
      field_attach_form_validate('profile2', $pseudo_entity, $form['profile_' . $profile->type], $form_state);
    }
  }
}

/**
 * User registration form submit handler
 * that executes right before user_register_submit().
 *
 * In generally, this callback disables the notification emails
 * during the execution of user_register_submit() callback.
 * The reason for this - we want to support profile2 tokens
 * in emails during registration, and there is no another
 * proper way to do this. See https://drupal.org/node/1097684.
 *
 * @see profile2_form_after_user_register_submit_handler()
 * @see user_register_submit()
 * @see profile2_attach_form()
 */
function profile2_form_before_user_register_submit_handler(&$form, &$form_state) {
  global $conf;

  // List of available operations during the registration.
  $register_ops = array('register_admin_created', 'register_no_approval_required', 'register_pending_approval');

  // We also have to track if we change a variables, because
  // later we have to restore them.
  $changed_ops = &drupal_static('profile2_register_changed_operations', array());
  foreach ($register_ops as $op) {

    // Save variable value.
    if (isset($conf['user_mail_' . $op . '_notify'])) {
      $changed_ops['user_mail_' . $op . '_notify'] = $conf['user_mail_' . $op . '_notify'];
    }

    // Temporary disable the notification about registration.
    $conf['user_mail_' . $op . '_notify'] = FALSE;
  }
}

/**
 * User registration form submit handler
 * that executes right after user_register_submit().
 *
 * This callback sends delayed email notification to a user
 * about his registration. See https://drupal.org/node/1097684.
 *
 * @see profile2_form_prepare_user_register_submit_handler()
 * @see user_register_submit()
 * @see profile2_attach_form()
 */
function profile2_form_after_user_register_submit_handler(&$form, &$form_state) {
  global $conf;

  // List of registration operations that where
  // notification values were changed.
  $changed_ops = &drupal_static('profile2_register_changed_operations', array());

  // List of available operations during the registration.
  $register_ops = array('register_admin_created', 'register_no_approval_required', 'register_pending_approval');
  foreach ($register_ops as $op) {

    // If we changed the notification value in
    // profile2_form_before_user_register_submit_handler() then change it back.
    if (isset($changed_ops['user_mail_' . $op . '_notify'])) {
      $conf['user_mail_' . $op . '_notify'] = $changed_ops['user_mail_' . $op . '_notify'];
    }
    // Otherwise just remove this value from a global variables array.
    else {
      unset($conf['user_mail_' . $op . '_notify']);
    }
  }

  // Get the values that we need to define which notification
  // should be sent to the user. Generally this is a trimmed version
  // of user_register_submit() callback.
  $admin = !empty($form_state['values']['administer_users']);
  $account = $form_state['user'];
  $notify = !empty($form_state['values']['notify']);

  if ($admin && !$notify) {
    // If admin has created a new account and decided to don't notify a user -
    // then just do nothing.
  }
  elseif (!$admin && !variable_get('user_email_verification', TRUE) && $account->status) {
    _user_mail_notify('register_no_approval_required', $account);
  }
  // No administrator approval required.
  elseif ($account->status || $notify) {
    $op = $notify ? 'register_admin_created' : 'register_no_approval_required';
    _user_mail_notify($op, $account);
  }
  // Administrator approval required.
  elseif (!$admin) {
    _user_mail_notify('register_pending_approval', $account);
  }
}

/**
 * Submit handler that builds and saves all profiles in the form.
 *
 * @see profile2_attach_form()
 */
function profile2_form_submit_handler(&$form, &$form_state) {
  profile2_form_submit_build_profile($form, $form_state);
  // This is needed as some submit callbacks like user_register_submit() rely on
  // clean form values.
  profile2_form_submit_cleanup($form, $form_state);

  foreach ($form_state['profiles'] as $type => $profile) {
    // During registration set the uid field of the newly created user.
    if (empty($profile->uid) && isset($form_state['user']->uid)) {
      $profile->uid = $form_state['user']->uid;
    }
    profile2_save($profile);
  }
}

/**
 * Submit builder. Extracts the form values and updates the profile entities.
 *
 * @see profile2_attach_form()
 */
function profile2_form_submit_build_profile(&$form, &$form_state) {
  foreach ($form_state['profiles'] as $type => $profile) {
    // @see entity_form_submit_build_entity()
    if (isset($form['profile_' . $type]['#entity_builders'])) {
      foreach ($form['profile_' . $type]['#entity_builders'] as $function) {
        $function('profile2', $profile, $form['profile_' . $type], $form_state);
      }
    }
    field_attach_submit('profile2', $profile, $form['profile_' . $type], $form_state);
  }
}

/**
 * Cleans up the form values as the user modules relies on clean values.
 *
 * @see profile2_attach_form()
 */
function profile2_form_submit_cleanup(&$form, &$form_state) {
  foreach ($form_state['profiles'] as $type => $profile) {
    unset($form_state['values']['profile_' . $type]);
  }
}

/**
 * Implements hook_user_categories().
 */
function profile2_user_categories() {
  $data = array();
  foreach (profile2_get_types() as $type => $info) {
    if ($info->userCategory) {
      $data[] = array(
        'name' => $type,
        'title' => $info->getTranslation('label'),
        // Add an offset so a weight of 0 appears right of the account category.
        'weight' => $info->weight + 3,
        'access callback' => 'profile2_category_access',
        'access arguments' => array(1, $type)
      );
    }
  }
  return $data;
}

/**
 * Menu item access callback - check if a user has access to a profile category.
 */
function profile2_category_access($account, $type_name) {
  // As there might be no profile yet, create a new object for being able to run
  // a proper access check.
  $profile = profile2_create(array('type' => $type_name, 'uid' => $account->uid));
  return ($account->uid > 0 && $profile->type()->userCategory && profile2_access('edit', $profile));
}

/**
 * Determines whether the given user has access to a profile.
 *
 * @param $op
 *   The operation being performed. One of 'view', 'update', 'create', 'delete'
 *   or just 'edit' (being the same as 'create' or 'update').
 * @param $profile
 *   (optional) A profile to check access for. If nothing is given, access for
 *   all profiles is determined.
 * @param $account
 *   The user to check for. Leave it to NULL to check for the global user.
 * @return boolean
 *   Whether access is allowed or not.
 *
 * @see hook_profile2_access()
 * @see profile2_profile2_access()
 */
function profile2_access($op, $profile = NULL, $account = NULL) {

  // Check if profile user has current profile available by role.
  if (isset($profile->type)) {
    $profile_type = profile2_type_load($profile->type);
    if (!empty($profile_type) && !empty($profile_type->data['roles']) && isset($profile->uid)) {
      $profile_user = user_load($profile->uid);
      $profile_roles = array_keys($profile_type->data['roles']);
      $user_roles = array_keys($profile_user->roles);
      $matches = array_intersect($profile_roles, $user_roles);
      if (empty($matches)) {
        return FALSE;
      }
    }
  }

  // With access to all profiles there is no need to check further.
  if (user_access('administer profiles', $account)) {
    return TRUE;
  }

  if ($op == 'create' || $op == 'update') {
    $op = 'edit';
  }
  // Allow modules to grant / deny access.
  $access = module_invoke_all('profile2_access', $op, $profile, $account);

  // Only grant access if at least one module granted access and no one denied
  // access.
  if (in_array(FALSE, $access, TRUE)) {
    return FALSE;
  }
  elseif (in_array(TRUE, $access, TRUE)) {
    return TRUE;
  }
  return FALSE;
}

/**
 * Implements hook_profile2_access().
 */
function profile2_profile2_access($op, $profile = NULL, $account = NULL) {
  if (isset($profile) && ($type_name = $profile->type)) {
    if (user_access("$op any $type_name profile", $account)) {
      return TRUE;
    }
    $account = isset($account) ? $account : $GLOBALS['user'];
    if (isset($profile->uid) && $profile->uid == $account->uid && user_access("$op own $type_name profile", $account)) {
      return TRUE;
    }
  }
  // Do not explicitly deny access so others may still grant access.
}

/**
 * Access callback for the entity API.
 */
function profile2_type_access($op, $type = NULL, $account = NULL) {
  return user_access('administer profile types', $account);
}

/**
 * Implements hook_theme().
 */
function profile2_theme() {
  return array(
    'profile2' => array(
      'render element' => 'elements',
      'template' => 'profile2',
    ),
  );
}

/**
 * The class used for profile entities.
 */
class Profile extends Entity {

  /**
   * The profile id.
   *
   * @var integer
   */
  public $pid;

  /**
   * The name of the profile type.
   *
   * @var string
   */
  public $type;

  /**
   * The profile label.
   *
   * @var string
   */
  public $label;

  /**
   * The user id of the profile owner.
   *
   * @var integer
   */
  public $uid;

  /**
   * The Unix timestamp when the profile was created.
   *
   * @var integer
   */
  public $created;

  /**
   * The Unix timestamp when the profile was most recently saved.
   *
   * @var integer
   */
  public $changed;


  public function __construct($values = array()) {
    if (isset($values['user'])) {
      $this->setUser($values['user']);
      unset($values['user']);
    }
    if (isset($values['type']) && is_object($values['type'])) {
      $values['type'] = $values['type']->type;
    }
    if (!isset($values['label']) && isset($values['type']) && $type = profile2_get_types($values['type'])) {
      // Initialize the label with the type label, so newly created profiles
      // have that as interim label.
      $values['label'] = $type->label;
    }
    parent::__construct($values, 'profile2');
  }

  /**
   * Returns the user owning this profile.
   */
  public function user() {
    return user_load($this->uid);
  }

  /**
   * Sets a new user owning this profile.
   *
   * @param $account
   *   The user account object or the user account id (uid).
   */
  public function setUser($account) {
    $this->uid = is_object($account) ? $account->uid : $account;
  }

  /**
   * Gets the associated profile type object.
   *
   * @return ProfileType
   */
  public function type() {
    return profile2_get_types($this->type);
  }

  /**
   * Returns the full url() for the profile.
   */
  public function url() {
    $uri = $this->uri();
    return url($uri['path'], $uri);
  }

  /**
   * Returns the drupal path to this profile.
   */
  public function path() {
    $uri = $this->uri();
    return $uri['path'];
  }

  public function defaultUri() {
    return array(
      'path' => 'user/' . $this->uid,
      'options' => array('fragment' => 'profile-' . $this->type),
    );
  }

  public function defaultLabel() {
    // Return a label that combines the type name and user name, translatable.
    return t('@type profile for @user', array(
      '@type' => profile2_get_types($this->type)->getTranslation('label'),
      '@user' => format_username($this->user()),
    ));
  }

  public function buildContent($view_mode = 'full', $langcode = NULL) {
    $content = array();
    // Assume newly create objects are still empty.
    if (!empty($this->is_new)) {
      $content['empty']['#markup'] = '<em class="profile2-no-data">' . t('There is no profile data yet.') . '</em>';
    }
    return entity_get_controller($this->entityType)->buildContent($this, $view_mode, $langcode, $content);
  }

  public function save() {
    // Don't create a new profile if the user already have one of the same type.
    $existing_profile = profile2_load_by_user($this->uid, $this->type);
    if (empty($this->pid) && !empty($existing_profile)) {
      watchdog('profile2_create', serialize(array(
        'message' => 'Profile already exists',
        'uid' => $this->uid,
        'type' => $this->type,
        'path' => current_path(),
        'logged_in_user' => $GLOBALS['user']->uid,
      )), array(), WATCHDOG_WARNING);
      return;
    }

    // Care about setting created and changed values. But do not automatically
    // set a created values for already existing profiles.
    if (empty($this->created) && (!empty($this->is_new) || !$this->pid)) {
      $this->created = REQUEST_TIME;
    }
    $this->changed = REQUEST_TIME;

    // Clear the static cache from profile2_load_by_user() before saving, so
    // that profiles are correctly loaded in insert/update hooks.
    $cache = &drupal_static('profile2_load_by_user', array());
    unset($cache[$this->uid]);

    return parent::save();
  }
}

/**
 * Use a separate class for profile types so we can specify some defaults
 * modules may alter.
 */
class ProfileType extends Entity {

  /**
   * Whether the profile type appears in the user categories.
   */
  public $userCategory = TRUE;

  /**
   * Whether the profile is displayed on the user account page.
   */
  public $userView = TRUE;

  public $type;
  public $label;
  public $weight = 0;

  public function __construct($values = array()) {
    parent::__construct($values, 'profile2_type');
  }

  /**
   * Returns whether the profile type is locked, thus may not be deleted or renamed.
   *
   * Profile types provided in code are automatically treated as locked, as well
   * as any fixed profile type.
   */
  public function isLocked() {
    return isset($this->status) && empty($this->is_new) && (($this->status & ENTITY_IN_CODE) || ($this->status & ENTITY_FIXED));
  }

  /**
   * Overridden, to introduce the method for old entity API versions (BC).
   *
   * @todo Remove once we bump the required entity API version.
   */
  public function getTranslation($property, $langcode = NULL) {
    if (module_exists('profile2_i18n')) {
      return parent::getTranslation($property, $langcode);
    }
    return $this->$property;
  }

  /**
   * Overrides Entity::save().
   */
  public function save() {
    parent::save();
    // Clear field info caches such that any changes to extra fields get
    // reflected.
    field_info_cache_clear();
  }
}

/**
 * View a profile.
 *
 * @see Profile::view()
 */
function profile2_view($profile, $view_mode = 'full', $langcode = NULL, $page = NULL) {
  return $profile->view($view_mode, $langcode, $page);
}

/**
 * Implements hook_form_FORMID_alter().
 *
 * Adds a checkbox for controlling field view access to fields added to
 * profiles.
 */
function profile2_form_field_ui_field_edit_form_alter(&$form, &$form_state) {
  if (!empty($form['instance']['entity_type']['#value']) && $form['instance']['entity_type']['#value'] == 'profile2') {
    $form['field']['settings']['profile2_private'] = array(
      '#type' => 'checkbox',
      '#title' => t('Make the content of this field private.'),
      '#default_value' => !empty($form['#field']['settings']['profile2_private']),
      '#description' => t('If checked, the content of this field is only shown to the profile owner and administrators.'),
    );
  }
  else {
    // Add the value to the form so it isn't lost.
    $form['field']['settings']['profile2_private'] = array(
      '#type' => 'value',
      '#value' => !empty($form['#field']['settings']['profile2_private']),
    );
  }
}

/**
 * Implements hook_field_access().
 */
function profile2_field_access($op, $field, $entity_type, $profile = NULL, $account = NULL) {
  if ($entity_type == 'profile2' && $op == 'view' && isset($profile)) {
    // Check if the profile type is accessible (e.g. applicable to the role).
    if (!profile2_access($op, $profile, $account)) {
      return FALSE;
    }
    // Deny view access, if someone else views a private field.
    if (!empty($field['settings']['profile2_private']) && !user_access('administer profiles', $account)) {
      $account = isset($account) ? $account : $GLOBALS['user'];
      if ($account->uid != $profile->uid) {
        return FALSE;
      }
    }
  }
}

/**
 * Implements hook_field_extra_fields().
 *
 * We need to add pseudo fields for profile types to allow for weight settings
 * when viewing a user or filling in the profile types while registrating.
 */
function profile2_field_extra_fields() {
  $extra = array();
  foreach (profile2_get_types() as $type_name => $type) {
    // Appears on: admin/config/people/accounts/display
    if (!empty($type->userView)) {
      $extra['user']['user']['display']['profile_' . $type_name] = array(
        'label' => t('Profile: @profile', array('@profile' => $type->label)),
        'weight' => $type->weight,
      );
    }
    // Appears on: admin/config/people/accounts/fields
    if (!empty($type->data['registration'])) {
      $extra['user']['user']['form']['profile_' . $type_name] = array(
        'label' => t('Profile: @profile', array('@profile' => $type->label)),
        'description' => t('Appears during registration only.'),
        'weight' => $type->weight,
      );
    }
  }
  return $extra;
}

/**
 * Entity metadata callback to load profiles for the given user account.
 */
function profile2_user_get_properties($account, array $options, $name) {
  // Remove the leading 'profile_' from the property name to get the type name.
  $profile = profile2_load_by_user($account, substr($name, 8));
  return $profile ? $profile : NULL;
}

/**
 * Implements hook_ctools_plugin_directory().
 */
function profile2_ctools_plugin_directory($owner, $plugin_type) {
  if ($owner == 'ctools' && !empty($plugin_type)) {
    return 'plugins/' . $plugin_type;
  }
}

/**
 * Implements hook_preprocess_ctools_context_item_form().
 *
 * When the User context is added, CTools will update the relationship dropdown
 * with ajax. The dropdown is passed through theme_ctools_context_item_form
 * before being passed to ajax_render, so that is our best opportunity to
 * alter it.
 *
 * @see ctools_context_ajax_item_add
 */
function profile2_preprocess_ctools_context_item_form(&$vars) {
  unset($vars['form']['buttons']['relationship']['item']['#options']['entity_from_schema:uid-user-profile2']);
}

/**
 * Determines whether the given user has access to delete a profile.
*/
function profile2_delete_access($uid, $type_name) {
  $profile = profile2_by_uid_load($uid, $type_name);
  return is_object($profile) ? profile2_access('edit', $profile) : FALSE;
}

/**
 * Menu load callback.
 *
 * Returns the profile object for the given user. If there is none yet, a new
 * object is created.
 */
function profile2_by_uid_load($uid, $type_name) {
  if ($uid && is_numeric($uid) && ($account = user_load($uid))) {
    $profile = profile2_load_by_user($account, $type_name);
    if (!$profile) {
      $profile = profile2_create(array('type' => $type_name));
      $profile->setUser($account);
      $profile->is_new = TRUE;
    }
    return $profile;
  }
  return FALSE;
}

/**
 * Implements hook_preprocess_page().
 *
 * Fix the page titles on the profile2 edit tabs.
 * We want the titles to be the full profile label, giving the user name & profile name.
 */
function profile2_preprocess_page(&$vars) {
  // This is true when editing a profile in a tab.
  if (!empty($vars['page']['content']['system_main']['#user_category'])) {
    $ptype = $vars['page']['content']['system_main']['#user_category'];
    if (!empty($vars['page']['content']['system_main']["profile_$ptype"])) {
      $item = $vars['page']['content']['system_main']["profile_$ptype"];
      // If we've found an item, and it has a profile2 entity, display the title.
      if (!empty($item['#entity'])) {
        $vars['title'] = $item['#entity']->label();
      }
    }
  }
}