Club Drupal

  public $allowConsumerObjectCreation = FALSE;

  public $defaultMembershipRid;

  public $anonymousRid;

    'onlyApplyToLdapAuthenticated' => TRUE,

    'useMappingsAsFilter' => TRUE,

    'synchOnLogon' => TRUE,

    'revokeLdapProvisioned' => TRUE,

    'regrantLdapProvisioned' => TRUE,

    'createConsumers' => TRUE,

  /**

   *

   */

  public function __construct($consumer_type) {

    $this->defaultMembershipRid = NULL;

    $this->anonymousRid = NULL;

    $params = ldap_authorization_og_ldap_authorization_consumer();

   */

  public function og2ConsumerIdParts($consumer_id) {

    if (!is_scalar($consumer_id)) {

    }

    $parts = explode(':', $consumer_id);

  }

  /**

   * @see LdapAuthorizationConsumerAbstract::normalizeMappings

   */

  public function normalizeMappings($mappings) {

    $group_entity_types = og_get_all_group_bundle();

    foreach ($mappings as $i => $mapping) {

      $from = $mapping[0];

      $to = $mapping[1];

      $to_parts = explode('(raw: ', $to);

      $user_entered = $to_parts[0];

        'from' => $from,

        'user_entered' => $user_entered,

        'valid' => TRUE,

        'error_message' => '',

      // Has simplified and normalized part in (). update normalized part as validation.

      if (count($to_parts) == 2) {

        $role = (count($to_simplified_parts) < 3) ? OG_AUTHENTICATED_ROLE : $to_simplified_parts[2];

        $group_name = (count($to_simplified_parts) == 1) ? $to_simplified_parts[0] : $to_simplified_parts[1];

        list($group_entity, $group_entity_id) = ldap_authorization_og2_get_group_from_name($entity_type, $group_name);

      }

      // May be simplified or normalized, but not both.

      else {

        list($group_entity, $group_entity_id) = ldap_authorization_og2_get_group_from_name($entity_type, $group_name_or_entity_id);

        // If load by name works, $group_name_or_entity_id is group title.

        if ($group_entity) {

        }

        else {

          $to_simplified = FALSE;

        $new_mapping['normalized'] = FALSE;

        $new_mapping['simplified'] = FALSE;

        $new_mapping['valid'] = FALSE;

      }

      else {

        $role_id = is_numeric($role) ? $role : ldap_authorization_og2_rid_from_role_name($entity_type, $group_entity->type, $group_entity_id, $role);

        $roles = og_roles($entity_type, isset($group_entity->type) ? $group_entity->type : NULL, 0, FALSE, TRUE);

        $role_name = is_numeric($role) ? $roles[$role] : $role;

        $to_simplified = ($to_simplified) ? $to_simplified . ':' . $role_name : $to_normalized;

        $new_mapping['normalized'] = $to_normalized;

        $new_mapping['simplified'] = $to_simplified;

  public function populateConsumersFromConsumerIds(&$consumers, $create_missing_consumers = FALSE) {

    // Generate a query for all og groups of interest.

    foreach ($consumers as $consumer_id => $consumer) {

      list($entity_type, $gid, $rid) = explode(':', $consumer_id);

      $gids[$entity_type][] = $gid;

    og_membership_invalidate_cache();

    if ($consumers) {

      foreach ($consumers as $i => $consumer_id) {

        list($entity_type, $gid, $rid) = $this->og2ConsumerIdParts($consumer_id);

        $gids_to_clear_cache[$gid] = $gid;

  protected function grantsAndRevokes($op, &$user, &$user_auth_data, $consumers, &$ldap_entry = NULL, $user_save = TRUE) {

    if (!is_array($user_auth_data)) {

    }

    $detailed_watchdog_log = variable_get('ldap_help_watchdog_detail', 0);

    $this->sortConsumerIds($op, $consumers);

    $watchdog_tokens['%username'] = $user->name;

    $watchdog_tokens['%action'] = $op;

    $watchdog_tokens['%user_save'] = $user_save;

     * step #1:  generate $og_actions = array of form $og_actions['revokes'|'grants'][$gid] = $rid

     *  based on all consumer ids granted and revokes

     */

    $consumer_ids_log = "";

    $log = "";

        if ($user_has_authorization && !$user_has_authorization_recorded) {

          // Grant case 1: authorization id already exists for user, but is not ldap provisioned.  mark as ldap provisioned, but don't regrant.

          $results[$consumer_id] = TRUE;

            'date_granted' => time(),

            'consumer_id_mixed_case' => $consumer_id,

          $log .= "grant case 1: authorization id already exists for user, but is not ldap provisioned.  mark as ldap provisioned, but don't regrant";

          $log .= $consumer_id;

        }

    $this->og2Grants($og_actions, $user, $user_auth_data);

    $this->og2Revokes($og_actions, $user, $user_auth_data);

    $user_edit['data']['ldap_authorizations'][$this->consumerType] = $user_auth_data;

    // Force a reload of the user object, since changes made through the grant-

    // and revoke-functions above might have changed og-related field data.

        $all_group_rids = array_keys($all_group_roles);

        // Users current rids w/authen or anon roles returned.

        $users_group_rids = array_keys(og_get_user_roles($group_entity_type, $gid, $user->uid, TRUE));

        // Rids to be added without anonymous rid.

        // If adding OG_AUTHENTICATED_ROLE or any other role and does not currently have OG_AUTHENTICATED_ROLE, group.

        if (!in_array($authenticated_rid, $users_group_rids) && count($new_rids) > 0) {

            'entity_type' => 'user',

            'entity' => $user->uid,

            'field_name' => FALSE,

            'state' => OG_STATE_ACTIVE,

          $og_membership = og_group($group_entity_type, $gid, $values);

            'date_granted' => time(),

            'consumer_id_mixed_case' => $consumer_id,

          // Granted on membership creation.

        }

        foreach ($new_rids as $i => $rid) {

        }

        foreach ($granting_rids as $i => $rid) {

          // Attribute to ldap regardless of if is being granted.

            'date_granted' => time(),

            'consumer_id_mixed_case' => $consumer_id,

        }

      }

    }

          // Unattribute to ldap even if user does not currently have role.

          unset($user_auth_data[ldap_authorization_og_authorization_id($gid, $rid, $group_entity_type)]);

        }

        if (in_array($authenticated_rid, $revoking_rids) || count($remaining_rids) == 0) {

          $entity = og_ungroup($group_entity_type, $gid, 'user', $user->uid);

          $result = (boolean) ($entity);

    static $users;

    if (!is_array($users)) {

      // No cache exists, create static array.

    }

    elseif ($reset && isset($users[$user->uid])) {

      // Clear users cache.

      return $users[$user->uid];

    }

    $memberships = og_get_entity_groups('user', $user_entities[$user->uid]);

    foreach ($memberships as $entity_type => $entity_memberships) {

      foreach ($entity_memberships as $og_membership_id => $gid) {

   * @see ldapAuthorizationConsumerAbstract::convertToFriendlyAuthorizationIds

   */

  public function convertToFriendlyAuthorizationIds($authorizations) {

    foreach ($authorizations as $authorization_id => $authorization) {

      $authorization_ids_friendly[] = $authorization['name'] . '  (' . $authorization_id . ')';

    }

     *

     */

    if (!$pass) {

        '!from' => $mapping['from'],

        '!user_entered' => $mapping['user_entered'],

        '!error' => $mapping['error_message'],

      $message_text = '<code>"' . t('!map_to|!user_entered', $tokens) . '"</code> ' . t('has the following error: !error.', $tokens);

    }

  }

  /**

     */

    $og_fields = field_info_field(OG_GROUP_FIELD);

    $role_name = OG_AUTHENTICATED_ROLE;

    if (!empty($og_fields['bundles'])) {

      }

    }

      'rows' => $rows,

    $table = theme('table', $variables);

    $link = l(t('admin/config/people/ldap/authorization/test/og_group'), 'admin/config/people/ldap/authorization/test/og_group');