/drupal7/sites/all/modules/ldap/ldap_user/LdapUserConf.class.php - Diff - Club Drupal - Forge Centrale Marseille

Révision 32700c57

Ajouté par Assos Assos il y a environ 5 ans

ID 32700c5792ed296e7e0724a8ebc85dee3f731d53
Parent bd0d4c5c
Enfant fbb66ca6

Weekly update of contrib modules

     /**
      * @file
      * This class represents a ldap_user module's configuration
      * It is extended by LdapUserConfAdmin for configuration and other admin functions
      * It is extended by LdapUserConfAdmin for configuration and other admin functions.
      */
     require_once('ldap_user.module');
     require_once 'ldap_user.module';
     /**
+     *
      */
     class LdapUserConf {
       /**
        * server providing Drupal account provisioning
        * Server providing Drupal account provisioning.
+       *
        * @var string
+       *
-...
       public $drupalAcctProvisionServer = LDAP_USER_NO_SERVER_SID;
       /**
        * server providing LDAP entry provisioning
        * Server providing LDAP entry provisioning.
+       *
        * @var string
+       *
-...
+       *
        * @var array
        */
       public $provisionSidFromDirection = array(
       public $provisionSidFromDirection = [
         LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER => LDAP_USER_NO_SERVER_SID,
         LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY => LDAP_USER_NO_SERVER_SID,
       );
       ];
       /**
        * Array of events that trigger provisioning of Drupal Accounts
        * Valid constants are:
        *   LDAP_USER_DRUPAL_USER_PROV_ON_AUTHENTICATE
        *   LDAP_USER_DRUPAL_USER_PROV_ON_USER_UPDATE_CREATE
        *   LDAP_USER_DRUPAL_USER_PROV_ON_ALLOW_MANUAL_CREATE
        *   LDAP_USER_DRUPAL_USER_PROV_ON_ALLOW_MANUAL_CREATE.
+       *
        * @var array
        */
       public $drupalAcctProvisionTriggers = array(LDAP_USER_DRUPAL_USER_PROV_ON_AUTHENTICATE, LDAP_USER_DRUPAL_USER_PROV_ON_USER_UPDATE_CREATE, LDAP_USER_DRUPAL_USER_PROV_ON_ALLOW_MANUAL_CREATE);
       public $drupalAcctProvisionTriggers = [LDAP_USER_DRUPAL_USER_PROV_ON_AUTHENTICATE, LDAP_USER_DRUPAL_USER_PROV_ON_USER_UPDATE_CREATE, LDAP_USER_DRUPAL_USER_PROV_ON_ALLOW_MANUAL_CREATE];
       /**
        * Array of events that trigger provisioning of LDAP Entries
        * Valid constants are:
        *   LDAP_USER_LDAP_ENTRY_PROV_ON_USER_UPDATE_CREATE
        *   LDAP_USER_LDAP_ENTRY_PROV_ON_AUTHENTICATE
        *   LDAP_USER_LDAP_ENTRY_DELETE_ON_USER_DELETE
        *   LDAP_USER_LDAP_ENTRY_DELETE_ON_USER_DELETE.
+       *
        * @var array
        */
       public $ldapEntryProvisionTriggers = array();
       public $ldapEntryProvisionTriggers = [];
       /**
        * server providing LDAP entry provisioning
        * Server providing LDAP entry provisioning.
+       *
        * @var string
+       *
-...
       public $accountsWithSameEmail = LDAP_USER_ACCOUNTS_WITH_SAME_EMAIL_DISABLED;
       /**
        * drupal account creation model
        * Drupal account creation model.
+       *
        * @var int
        *   LDAP_USER_ACCT_CREATION_LDAP_BEHAVIOR   /admin/config/people/accounts/settings do not affect "LDAP Associated" Drupal accounts.
-...
       public $acctCreation = LDAP_USER_ACCT_CREATION_LDAP_BEHAVIOR_DEFAULT;
       /**
        * has current object been saved to the database?
+       *
        * @var boolean
        * Has current object been saved to the database?
+       *
        * @var bool
        */
       public $inDatabase = FALSE;
       /**
        * what to do when an ldap provisioned username conflicts with existing drupal user?
        * What to do when an ldap provisioned username conflicts with existing drupal user?
+       *
        * @var int
        *   LDAP_USER_CONFLICT_LOG - log the conflict
        *   LDAP_USER_CONFLICT_RESOLVE - LDAP associate the existing drupal user
+       *
        */
       public $manualAccountConflict = LDAP_USER_MANUAL_ACCT_CONFLICT_REJECT;
       public $setsLdapPassword = TRUE; // @todo default to FALSE and check for mapping to set to true
       /**
        * @todo default to FALSE and check for mapping to set to true
        */
       public $setsLdapPassword = TRUE;
       public $loginConflictResolve = FALSE;
       public $disableAdminPasswordField = FALSE;
       /**
        * array of field synch mappings provided by all modules (via hook_ldap_user_attrs_list_alter())
        * Array of field synch mappings provided by all modules (via hook_ldap_user_attrs_list_alter())
        * array of the form: array(
        * LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER | LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY => array(
        *   <server_id> => array(
-...
        *    )
        *  )
        */
       public $synchMapping = NULL; // array of field synching directions for each operation.  should include ldapUserSynchMappings
       // keyed on direction => property, ldap, or field token such as '[field.field_lname] with brackets in them.
       /**
       * synch mappings configured in ldap user module (not in other modules)
       *   array of the form: array(
         LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER | LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY => array(
           'sid' => <server_id> (redundant)
           'ldap_attr' => e.g. [sn]
           'user_attr'  => e.g. [field.field_user_lname] (when this value is set to 'user_tokens', 'user_tokens' value is used.)
           'user_tokens' => e.g. [field.field_user_lname], [field.field_user_fname]
           'convert' => 1|0 boolean indicating need to covert from binary
           'direction' => LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER | LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY (redundant)
           'config_module' => 'ldap_user'
           'prov_module' => 'ldap_user'
           'enabled' => 1|0 boolean
            prov_events' => array( of LDAP_USER_EVENT_* constants indicating during which synch actions field should be synched)
               - four permutations available
                  to ldap:   LDAP_USER_EVENT_CREATE_LDAP_ENTRY,  LDAP_USER_EVENT_SYNCH_TO_LDAP_ENTRY,
                  to drupal: LDAP_USER_EVENT_CREATE_DRUPAL_USER, LDAP_USER_EVENT_SYNCH_TO_DRUPAL_USER
+          )
+        )
+      )
       */
       public $ldapUserSynchMappings = NULL;  //
       // keyed on property, ldap, or field token such as '[field.field_lname] with brackets in them.
        * Array of field synching directions for each operation.  should include ldapUserSynchMappings.
        */
       public $synchMapping = NULL;
       // Keyed on direction => property, ldap, or field token such as '[field.field_lname] with brackets in them.
       /**
        * Synch mappings configured in ldap user module (not in other modules)
        *   array of the form: array(
        * LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER | LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY => array(
        * 'sid' => <server_id> (redundant)
        * 'ldap_attr' => e.g. [sn]
        * 'user_attr'  => e.g. [field.field_user_lname] (when this value is set to 'user_tokens', 'user_tokens' value is used.)
        * 'user_tokens' => e.g. [field.field_user_lname], [field.field_user_fname]
        * 'convert' => 1|0 boolean indicating need to covert from binary
        * 'direction' => LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER | LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY (redundant)
        * 'config_module' => 'ldap_user'
        * 'prov_module' => 'ldap_user'
        * 'enabled' => 1|0 boolean
        * prov_events' => array( of LDAP_USER_EVENT_* constants indicating during which synch actions field should be synched)
        * - four permutations available
        * to ldap:   LDAP_USER_EVENT_CREATE_LDAP_ENTRY,  LDAP_USER_EVENT_SYNCH_TO_LDAP_ENTRY,
        * to drupal: LDAP_USER_EVENT_CREATE_DRUPAL_USER, LDAP_USER_EVENT_SYNCH_TO_DRUPAL_USER
        * )
        * )
        * )
        */
       public $ldapUserSynchMappings = NULL;
       /**
        * Keyed on property, ldap, or field token such as '[field.field_lname] with brackets in them.
        */
       public $detailedWatchdog = FALSE;
       public $provisionsDrupalAccountsFromLdap = FALSE;
       public $provisionsLdapEntriesFromDrupalUsers = FALSE;
       // what should be done with ldap provisioned accounts that no longer have associated drupal accounts.
       /**
        * What should be done with ldap provisioned accounts that no longer have associated drupal accounts.
        */
       public $orphanedDrupalAcctBehavior = 'ldap_user_orphan_email';
        /** options are partially derived from user module account cancel options:
+        *
         'ldap_user_orphan_do_not_check' => Do not check for orphaned Drupal accounts.)
         'ldap_user_orphan_email' => Perform no action, but email list of orphaned accounts. (All the other options will send email summaries also.)
         'user_cancel_block' => Disable the account and keep its content.
         'user_cancel_block_unpublish' => Disable the account and unpublish its content.
         'user_cancel_reassign' => Delete the account and make its content belong to the Anonymous user.
         'user_cancel_delete' => Delete the account and its content.
         */
       /**
        * Options are partially derived from user module account cancel options:.
+       *
        * 'ldap_user_orphan_do_not_check' => Do not check for orphaned Drupal accounts.)
        * 'ldap_user_orphan_email' => Perform no action, but email list of orphaned accounts. (All the other options will send email summaries also.)
        * 'user_cancel_block' => Disable the account and keep its content.
        * 'user_cancel_block_unpublish' => Disable the account and unpublish its content.
        * 'user_cancel_reassign' => Delete the account and make its content belong to the Anonymous user.
        * 'user_cancel_delete' => Delete the account and its content.
        */
       public $orphanedCheckQty = 100;
     // public $wsKey = NULL;
     //  public $wsEnabled = 0;
     //  public $wsUserIps = array();
       public $provisionsLdapEvents = array();
       public $provisionsDrupalEvents = array();
       public $provisionsLdapEvents = [];
       public $provisionsDrupalEvents = [];
       public $saveable = array(
       public $saveable = [
         'drupalAcctProvisionServer',
         'ldapEntryProvisionServer',
         'drupalAcctProvisionTriggers',
-...
         'acctCreation',
         'ldapUserSynchMappings',
         'disableAdminPasswordField',
       );
     // 'wsKey','wsEnabled','wsUserIps',
       function __construct() {
       ];
       /**
+       *
        */
       public function __construct() {
         $this->load();
         $this->provisionSidFromDirection[LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER] = $this->drupalAcctProvisionServer;
         $this->provisionSidFromDirection[LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY] = $this->ldapEntryProvisionServer;
         $this->provisionsLdapEvents = array(
         $this->provisionsLdapEvents = [
           LDAP_USER_EVENT_CREATE_LDAP_ENTRY => t('On LDAP Entry Creation'),
           LDAP_USER_EVENT_SYNCH_TO_LDAP_ENTRY => t('On Synch to LDAP Entry'),
           );
         ];
         $this->provisionsDrupalEvents = array(
         $this->provisionsDrupalEvents = [
           LDAP_USER_EVENT_CREATE_DRUPAL_USER => t('On Drupal User Creation'),
           LDAP_USER_EVENT_SYNCH_TO_DRUPAL_USER => t('On Synch to Drupal User'),
           );
         ];
         $this->provisionsDrupalAccountsFromLdap = (
           $this->drupalAcctProvisionServer &&
-...
         $this->detailedWatchdog = variable_get('ldap_help_watchdog_detail', 0);
+      }
       function load() {
       /**
+       *
        */
       public function load() {
         if ($saved = variable_get("ldap_user_conf", FALSE)) {
           $this->inDatabase = TRUE;
-...
           $this->inDatabase = FALSE;
           // By default this variable should be 0 if the "sharedemail" module
           // is not enabled, or 1 if the module is.
           $this->accountsWithSameEmail = (int)module_exists('sharedemail');
           $this->accountsWithSameEmail = (int) module_exists('sharedemail');
+        }
         // determine account creation configuration
         // Determine account creation configuration.
         $user_register = variable_get('user_register', USER_REGISTER_VISITORS_ADMINISTRATIVE_APPROVAL);
         if ($this->acctCreation == LDAP_USER_ACCT_CREATION_LDAP_BEHAVIOR_DEFAULT || $user_register == USER_REGISTER_VISITORS) {
           $this->createLDAPAccounts = TRUE;
-...
+      }
       /**
        * Destructor Method
        * Destructor Method.
        */
       function __destruct() { }
       public function __destruct() {}
       /**
        * Util to fetch mappings for a given direction
        * Util to fetch mappings for a given direction.
+       *
        * @param string $sid
        *   The server id
        * @param string $direction LDAP_USER_PROV_DIRECTION_* constant
        *   The server id.
        * @param string $direction
        *   LDAP_USER_PROV_DIRECTION_* constant.
        * @param array $prov_events
+       *
        * @return array/bool
        * @return arraybool
        *   Array of mappings (may be empty array)
       */
        */
       public function getSynchMappings($direction = LDAP_USER_PROV_DIRECTION_ALL, $prov_events = NULL) {
         if (!$prov_events) {
           $prov_events = ldap_user_all_events();
+        }
         $mappings = array();
         $mappings = [];
         if ($direction == LDAP_USER_PROV_DIRECTION_ALL) {
           $directions = array(LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER, LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY);
           $directions = [LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER, LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY];
+        }
         else {
           $directions = array($direction);
           $directions = [$direction];
+        }
         foreach ($directions as $direction) {
           if (!empty($this->ldapUserSynchMappings[$direction])) {
-...
         return $mappings;
+      }
       /**
+       *
        */
       public function isDrupalAcctProvisionServer($sid) {
         if (!$sid || !$this->drupalAcctProvisionServer) {
           return FALSE;
-...
+        }
+      }
       /**
+       *
        */
       public function isLdapEntryProvisionServer($sid) {
         if (!$sid || !$this->ldapEntryProvisionServer) {
           return FALSE;
-...
       /**
        * Util to fetch attributes required for this user conf, not other modules.
+       *
        * @param enum $direction LDAP_USER_PROV_DIRECTION_* constants
        * @param enum $direction
        *   LDAP_USER_PROV_DIRECTION_* constants.
        * @param string $ldap_context
+       *
       */
        */
       public function getLdapUserRequiredAttributes($direction = LDAP_USER_PROV_DIRECTION_ALL, $ldap_context = NULL) {
         $attributes_map = array();
         $required_attributes = array();
         $attributes_map = [];
         $required_attributes = [];
         if ($this->drupalAcctProvisionServer) {
           $prov_events = $this->ldapContextToProvEvents($ldap_context);
           $attributes_map = $this->getSynchMappings($direction, $prov_events);
           $required_attributes = array();
           $required_attributes = [];
           foreach ($attributes_map as $detail) {
             if (count(array_intersect($prov_events, $detail['prov_events']))) {
               // Add the attribute to our array.
-...
         return $required_attributes;
+      }
     /**
      * converts the more general ldap_context string to its associated ldap user event
      */
       /**
        * Converts the more general ldap_context string to its associated ldap user event.
        */
       public function ldapContextToProvEvents($ldap_context = NULL) {
         switch ($ldap_context) {
           case 'ldap_user_prov_to_drupal':
             $result = array(LDAP_USER_EVENT_SYNCH_TO_DRUPAL_USER, LDAP_USER_EVENT_CREATE_DRUPAL_USER, LDAP_USER_EVENT_LDAP_ASSOCIATE_DRUPAL_ACCT);
             $result = [LDAP_USER_EVENT_SYNCH_TO_DRUPAL_USER, LDAP_USER_EVENT_CREATE_DRUPAL_USER, LDAP_USER_EVENT_LDAP_ASSOCIATE_DRUPAL_ACCT];
             break;
           case 'ldap_user_prov_to_ldap':
             $result = array(LDAP_USER_EVENT_SYNCH_TO_LDAP_ENTRY, LDAP_USER_EVENT_CREATE_LDAP_ENTRY);
             $result = [LDAP_USER_EVENT_SYNCH_TO_LDAP_ENTRY, LDAP_USER_EVENT_CREATE_LDAP_ENTRY];
             break;
           default:
-...
+      }
     /**
      * converts the more general ldap_context string to its associated ldap user prov direction
      */
       /**
        * Converts the more general ldap_context string to its associated ldap user prov direction.
        */
       public function ldapContextToProvDirection($ldap_context = NULL) {
         switch ($ldap_context) {
-...
             $result = LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY;
             break;
           // provisioning is can hapen in both directions in most contexts
           // Provisioning is can hapen in both directions in most contexts.
           case 'ldap_user_insert_drupal_user':
           case 'ldap_user_update_drupal_user':
           case 'ldap_authentication_authenticate':
-...
+      }
       /**
         derive mapping array from ldap user configuration and other configurations.
         if this becomes a resource hungry function should be moved to ldap_user functions
         and stored with static variable. should be cached also.
         this should be cached and modules implementing ldap_user_synch_mapping_alter
         should know when to invalidate cache.
        * Derive mapping array from ldap user configuration and other configurations.
        * if this becomes a resource hungry function should be moved to ldap_user functions
        * and stored with static variable. should be cached also.
+       *
        * This should be cached and modules implementing ldap_user_synch_mapping_alter
        * should know when to invalidate cache.
        */
       /**
        * @todo change default to false after development
        */
       public function setSynchMapping($reset = TRUE) {
       function setSynchMapping($reset = TRUE) {  // @todo change default to false after development
         $synch_mapping_cache = cache_get('ldap_user_synch_mapping');
         if (!$reset && $synch_mapping_cache) {
           $this->synchMapping = $synch_mapping_cache->data;
+        }
         else {
           $available_user_attrs = array();
           foreach (array(LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER, LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY) as $direction) {
           $available_user_attrs = [];
           foreach ([LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER, LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY] as $direction) {
             $sid = $this->provisionSidFromDirection[$direction];
             $available_user_attrs[$direction] = array();
             $available_user_attrs[$direction] = [];
             $ldap_server = ($sid) ? ldap_servers_get_servers($sid, NULL, TRUE) : FALSE;
             $params = array(
             $params = [
               'ldap_server' => $ldap_server,
               'ldap_user_conf' => $this,
               'direction' => $direction,
             );
             ];
             drupal_alter('ldap_user_attrs_list', $available_user_attrs[$direction], $params);
+          }
-...
+      }
       /**
        * given a $prov_event determine if ldap user configuration supports it.
        *   this is overall, not per field synching configuration
        * Given a $prov_event determine if ldap user configuration supports it.
        *   this is overall, not per field synching configuration.
+       *
        * @param enum $direction LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER or LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY
        * @param enum $direction
        *   LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER or LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY.
+       *
        * @param enum $prov_event
        *   LDAP_USER_EVENT_SYNCH_TO_DRUPAL_USER, LDAP_USER_EVENT_CREATE_DRUPAL_USER
        *   LDAP_USER_EVENT_SYNCH_TO_LDAP_ENTRY LDAP_USER_EVENT_CREATE_LDAP_ENTRY
        *   LDAP_USER_EVENT_LDAP_ASSOCIATE_DRUPAL_ACCT
        *   LDAP_USER_EVENT_ALL
        *   LDAP_USER_EVENT_ALL.
+       *
        * @param enum $action
        *   'synch', 'provision', 'delete_ldap_entry', 'delete_drupal_entry', 'cancel_drupal_entry'.
+       *
        * @param enum $action 'synch', 'provision', 'delete_ldap_entry', 'delete_drupal_entry', 'cancel_drupal_entry'
        * @return boolean
        * @return bool
        */
       public function provisionEnabled($direction, $provision_trigger) {
         $result = FALSE;
-...
         return $result;
+      }
      /**
        * given a drupal account, provision an ldap entry if none exists.  if one exists do nothing
       /**
        * Given a drupal account, provision an ldap entry if none exists.  if one exists do nothing.
+       *
        * @param object $account drupal account object with minimum of name property
        * @param array $ldap_user as prepopulated ldap entry.  usually not provided
        * @param object $account
        *   drupal account object with minimum of name property.
        * @param array $ldap_user
        *   as prepopulated ldap entry.  usually not provided.
+       *
        * @return array of form:
        *     array('status' => 'success', 'fail', or 'conflict'),
        *   array('status' => 'success', 'fail', or 'conflict'),
        *     array('ldap_server' => ldap server object),
        *     array('proposed' => proposed ldap entry),
        *     array('existing' => existing ldap entry),
        *     array('description' = > blah blah)
+       *
        */
       public function provisionLdapEntry($account, $ldap_user = NULL, $test_query = FALSE) {
         $watchdog_tokens = array();
         $result = array(
         $watchdog_tokens = [];
         $result = [
           'status' => NULL,
           'ldap_server' => NULL,
           'proposed' => NULL,
           'existing' => NULL,
           'description' => NULL,
         );
         ];
         if (is_scalar($account)) {
           $username = $account;
-...
         if (is_object($account) && property_exists($account, 'uid') && $account->uid == 1) {
           $result['status'] = 'fail';
           $result['error_description'] = 'can not provision drupal user 1';
           return $result; // do not provision or synch user 1
           // Do not provision or synch user 1.
           return $result;
+        }
         if ($account == FALSE || $account->uid == 0) {
-...
+        }
         $ldap_server = ldap_servers_get_servers($this->ldapEntryProvisionServer, NULL, TRUE);
         $params = array(
         $params = [
           'direction' => LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY,
           'prov_events' => array(LDAP_USER_EVENT_CREATE_LDAP_ENTRY),
           'prov_events' => [LDAP_USER_EVENT_CREATE_LDAP_ENTRY],
           'module' => 'ldap_user',
           'function' => 'provisionLdapEntry',
           'include_count' => FALSE,
         );
         ];
         list($proposed_ldap_entry, $error) = $this->drupalUserToLdapEntry($account, $ldap_server, $params, $ldap_user);
         $proposed_dn = (is_array($proposed_ldap_entry) && isset($proposed_ldap_entry['dn']) && $proposed_ldap_entry['dn']) ? $proposed_ldap_entry['dn'] : NULL;
-...
           $result['ldap_server'] = $ldap_server;
+        }
         else {
           // stick $proposed_ldap_entry in $ldap_entries array for drupal_alter call
           $ldap_entries = array($proposed_dn_lcase => $proposed_ldap_entry);
           $context = array(
           // Stick $proposed_ldap_entry in $ldap_entries array for drupal_alter call.
           $ldap_entries = [$proposed_dn_lcase => $proposed_ldap_entry];
           $context = [
             'action' => 'add',
             'corresponding_drupal_data' => array($proposed_dn_lcase => $account),
             'corresponding_drupal_data' => [$proposed_dn_lcase => $account],
             'corresponding_drupal_data_type' => 'user',
           );
           ];
           drupal_alter('ldap_entry_pre_provision', $ldap_entries, $ldap_server, $context);
           // remove altered $proposed_ldap_entry from $ldap_entries array
           // Remove altered $proposed_ldap_entry from $ldap_entries array.
           $proposed_ldap_entry = $ldap_entries[$proposed_dn_lcase];
           $ldap_entry_created = $ldap_server->createLdapEntry($proposed_ldap_entry, $proposed_dn);
-...
             $result['created'] = $ldap_entry_created;
             $result['ldap_server'] = $ldap_server;
             // need to store <sid>|<dn> in ldap_user_prov_entries field, which may contain more than one
             // Need to store <sid>|<dn> in ldap_user_prov_entries field, which may contain more than one.
             $ldap_user_prov_entry = $ldap_server->sid . '|' . $proposed_ldap_entry['dn'];
             if (!isset($user_entity->ldap_user_prov_entries[LANGUAGE_NONE])) {
               $user_entity->ldap_user_prov_entries = array(LANGUAGE_NONE => array());
               $user_entity->ldap_user_prov_entries = [LANGUAGE_NONE => []];
+            }
             $ldap_user_prov_entry_exists = FALSE;
             foreach ($user_entity->ldap_user_prov_entries[LANGUAGE_NONE] as $i => $field_value_instance) {
-...
+              }
+            }
             if (!$ldap_user_prov_entry_exists) {
               $user_entity->ldap_user_prov_entries[LANGUAGE_NONE][] = array(
               $user_entity->ldap_user_prov_entries[LANGUAGE_NONE][] = [
                 'value' => $ldap_user_prov_entry,
               );
               ];
               // Save the field without calling user_save()
               field_attach_presave('user', $user_entity);
-...
+          }
+        }
         $tokens = array(
         $tokens = [
           '%dn' => isset($result['proposed']['dn']) ? $result['proposed']['dn'] : NULL,
           '%sid' => (isset($result['ldap_server']) && $result['ldap_server']) ? $result['ldap_server']->sid : 0,
           '%username' => @$account->name,
           '%uid' => @$account->uid,
           '%description' => @$result['description'],
         );
         ];
         if (!$test_query && isset($result['status'])) {
           if ($result['status'] == 'success') {
             if ($this->detailedWatchdog) {
-...
         return $result;
+      }
       /**
        * given a drupal account, synch to related ldap entry
        * Given a drupal account, synch to related ldap entry.
+       *
        * @param drupal user object $account.  Drupal user object
        * @param array $user_edit.  Edit array for user_save.  generally null unless user account is being created or modified in same synching
        * @param array $ldap_user.  current ldap data of user. @see README.developers.txt for structure
        * @param drupal user object $account
        *   Drupal user object.
        * @param array $user_edit
        *   Edit array for user_save.  generally null unless user account is being created or modified in same synching.
        * @param array $ldap_user
        *   current ldap data of user. @see README.developers.txt for structure.
+       *
        * @return TRUE on success or FALSE on fail.
        */
       public function synchToLdapEntry($account, $user_edit = NULL, $ldap_user =  array(), $test_query = FALSE) {
       public function synchToLdapEntry($account, $user_edit = NULL, $ldap_user = [], $test_query = FALSE) {
         if (is_object($account) && property_exists($account, 'uid') && $account->uid == 1) {
           return FALSE; // do not provision or synch user 1
           // Do not provision or synch user 1.
           return FALSE;
+        }
         $watchdog_tokens = array();
         $watchdog_tokens = [];
         $result = FALSE;
         $proposed_ldap_entry = FALSE;
         if ($this->ldapEntryProvisionServer) {
           $ldap_server = ldap_servers_get_servers($this->ldapEntryProvisionServer, NULL, TRUE);
           $params = array(
           $params = [
             'direction' => LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY,
             'prov_events' => array(LDAP_USER_EVENT_SYNCH_TO_LDAP_ENTRY),
             'prov_events' => [LDAP_USER_EVENT_SYNCH_TO_LDAP_ENTRY],
             'module' => 'ldap_user',
             'function' => 'synchToLdapEntry',
             'include_count' => FALSE,
           );
           ];
           list($proposed_ldap_entry, $error) = $this->drupalUserToLdapEntry($account, $ldap_server, $params, $ldap_user);
           if ($error != LDAP_USER_PROV_RESULT_NO_ERROR) {
-...
+          }
           elseif (is_array($proposed_ldap_entry) && isset($proposed_ldap_entry['dn'])) {
             $existing_ldap_entry = $ldap_server->dnExists($proposed_ldap_entry['dn'], 'ldap_entry');
             $attributes = array(); // this array represents attributes to be modified; not comprehensive list of attributes
             // This array represents attributes to be modified; not comprehensive list of attributes.
             $attributes = [];
             foreach ($proposed_ldap_entry as $attr_name => $attr_values) {
               if ($attr_name != 'dn') {
                 if (isset($attr_values['count'])) {
-...
             if ($test_query) {
               $proposed_ldap_entry = $attributes;
               $result = array(
               $result = [
                 'proposed' => $proposed_ldap_entry,
                 'server' => $ldap_server,
               );
               ];
+            }
             else {
               // stick $proposed_ldap_entry in $ldap_entries array for drupal_alter call
               // Stick $proposed_ldap_entry in $ldap_entries array for drupal_alter call.
               $proposed_dn_lcase = drupal_strtolower($proposed_ldap_entry['dn']);
               $ldap_entries = array($proposed_dn_lcase => $attributes);
               $context = array(
               $ldap_entries = [$proposed_dn_lcase => $attributes];
               $context = [
                 'action' => 'update',
                 'corresponding_drupal_data' => array($proposed_dn_lcase => $attributes),
                 'corresponding_drupal_data' => [$proposed_dn_lcase => $attributes],
                 'corresponding_drupal_data_type' => 'user',
               );
               ];
               drupal_alter('ldap_entry_pre_provision', $ldap_entries, $ldap_server, $context);
               // remove altered $proposed_ldap_entry from $ldap_entries array
               // Remove altered $proposed_ldap_entry from $ldap_entries array.
               $attributes = $ldap_entries[$proposed_dn_lcase];
               $result = $ldap_server->modifyLdapEntry($proposed_ldap_entry['dn'], $attributes);
               if ($result) { // success
               // Success.
               if ($result) {
                 module_invoke_all('ldap_entry_post_provision', $ldap_entries, $ldap_server, $context);
+              }
+            }
+          }
           else { // failed to get acceptable proposed ldap entry
           // Failed to get acceptable proposed ldap entry.
           else {
             $result = FALSE;
+          }
+        }
         $tokens = array(
         $tokens = [
           '%dn' => isset($proposed_ldap_entry['dn']) ? $proposed_ldap_entry['dn'] : NULL,
           '%sid' => $this->ldapEntryProvisionServer,
           '%username' => $account->name,
           '%uid' => ($test_query || !property_exists($account, 'uid')) ? '' : $account->uid,
         );
         ];
         if ($result) {
           watchdog('ldap_user', 'LDAP entry on server %sid synched dn=%dn. username=%username, uid=%uid', $tokens, WATCHDOG_INFO);
-...
+      }
       /**
        * given a drupal account, query ldap and get all user fields and create user account
        * Given a drupal account, query ldap and get all user fields and create user account.
+       *
        * @param array $account drupal account array with minimum of name
        * @param array $user_edit drupal edit array in form user_save($account, $user_edit) would take,
        *   generally empty unless overriding synchToDrupalAccount derived values
        * @param array $ldap_user as user's ldap entry.  passed to avoid requerying ldap in cases where already present
        * @param boolean $save indicating if drupal user should be saved.  generally depends on where function is called from.
        * @param array $account
        *   drupal account array with minimum of name.
        * @param array $user_edit
        *   drupal edit array in form user_save($account, $user_edit) would take,
        *   generally empty unless overriding synchToDrupalAccount derived values.
        * @param array $ldap_user
        *   as user's ldap entry.  passed to avoid requerying ldap in cases where already present.
        * @param bool $save
        *   indicating if drupal user should be saved.  generally depends on where function is called from.
+       *
        * @return result of user_save() function is $save is true, otherwise return TRUE
        * @return bool|object
        *   Result of user_save() function is $save is true, otherwise return TRUE
        *   $user_edit data returned by reference
+       *
        */
       public function synchToDrupalAccount($drupal_user, &$user_edit, $prov_event = LDAP_USER_EVENT_SYNCH_TO_DRUPAL_USER, $ldap_user = NULL, $save = FALSE) {
         $debug = array(
         $debug = [
           'account' => $drupal_user,
           'user_edit' => $user_edit,
           'ldap_user' => $ldap_user,
         );
         ];
         if (
             (!$ldap_user  && !isset($drupal_user->name)) ||
             (!$drupal_user && $save) ||
             ($ldap_user && !isset($ldap_user['sid']))
         ) {
            // should throw watchdog error also
           // Should throw watchdog error also.
           return FALSE;
+        }
-...
         if ($this->drupalAcctProvisionServer) {
           $ldap_server = ldap_servers_get_servers($this->drupalAcctProvisionServer, NULL, TRUE);
           $this->entryToUserEdit($ldap_user, $user_edit, $ldap_server, LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER, array($prov_event));
           $this->entryToUserEdit($ldap_user, $user_edit, $ldap_server, LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER, [$prov_event]);
+        }
         if ($save) {
-...
+        }
+      }
       /**
        * given a drupal account, delete user account
        * Given a drupal account, delete user account.
+       *
        * @param string $username
        *   drupal account name.
+       *
        * @param string $username drupal account name
        * @return TRUE or FALSE.  FALSE indicates failed or action not enabled in ldap user configuration
        */
       public function deleteDrupalAccount($username) {
-...
+      }
       /**
        * given a drupal account, find the related ldap entry.
        * Given a drupal account, find the related ldap entry.
+       *
        * @param drupal user object $account
+       *
-...
         if (!$prov_events) {
           $prov_events = ldap_user_all_events();
+        }
         $sid = $this->ldapEntryProvisionServer; //
         $sid = $this->ldapEntryProvisionServer;
         if (!$sid) {
           return FALSE;
+        }
         // $user_entity->ldap_user_prov_entries,
         // $user_entity->ldap_user_prov_entries,.
         $ldap_server = ldap_servers_get_servers($sid, NULL, TRUE);
         $params = array(
         $params = [
           'direction' => LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY,
           'prov_events' => $prov_events,
           'module' => 'ldap_user',
           'function' => 'getProvisionRelatedLdapEntry',
           'include_count' => FALSE,
           );
         ];
         list($proposed_ldap_entry, $error) = $this->drupalUserToLdapEntry($account, $ldap_server, $params);
         if (!(is_array($proposed_ldap_entry) && isset($proposed_ldap_entry['dn']) && $proposed_ldap_entry['dn'])) {
           return FALSE;
+        }
         $ldap_entry = $ldap_server->dnExists($proposed_ldap_entry['dn'], 'ldap_entry', array());
         $ldap_entry = $ldap_server->dnExists($proposed_ldap_entry['dn'], 'ldap_entry', []);
         return $ldap_entry;
+      }
       /**
        * given a drupal account, delete ldap entry that was provisioned based on it
        * Given a drupal account, delete ldap entry that was provisioned based on it
        *   normally this will be 0 or 1 entry, but the ldap_user_provisioned_ldap_entries
        *   field attached to the user entity track each ldap entry provisioned
        *   field attached to the user entity track each ldap entry provisioned.
+       *
        * @param object $account
        *   drupal account.
+       *
        * @param object $account drupal account
        * @return TRUE or FALSE.  FALSE indicates failed or action not enabled in ldap user configuration
        */
       public function deleteProvisionedLdapEntries($account) {
         // determine server that is associated with user
         // Determine server that is associated with user.
         $boolean_result = FALSE;
         if (isset($account->ldap_user_prov_entries[LANGUAGE_NONE][0])) {
           foreach ($account->ldap_user_prov_entries[LANGUAGE_NONE] as $i => $field_instance) {
-...
               $ldap_server = ldap_servers_get_servers($sid, NULL, TRUE);
               if (is_object($ldap_server) && $dn) {
                 $boolean_result = $ldap_server->delete($dn);
                 $tokens = array('%sid' => $sid, '%dn' => $dn, '%username' => $account->name, '%uid' => $account->uid);
                 $tokens = ['%sid' => $sid, '%dn' => $dn, '%username' => $account->name, '%uid' => $account->uid];
                 if ($boolean_result) {
                   watchdog('ldap_user', 'LDAP entry on server %sid deleted dn=%dn. username=%username, uid=%uid', $tokens, WATCHDOG_INFO);
+                }
-...
+      }
     /**
       *  populate ldap entry array for provisioning
+      *
       * @param array $account drupal account
       * @param object $ldap_server
       * @param array $ldap_user ldap entry of user, returned by reference
       * @param array $params with the following key values:
       *    'ldap_context' =>
            'module' => module calling function, e.g. 'ldap_user'
            'function' => function calling function, e.g. 'provisionLdapEntry'
            'include_count' => should 'count' array key be included
            'direction' => LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY || LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER
+      *
       * @return array(ldap entry, $result) in ldap extension array format.!THIS IS NOT THE ACTUAL LDAP ENTRY
       */
       function drupalUserToLdapEntry($account, $ldap_server, $params, $ldap_user_entry = NULL) {
       /**
        * Populate ldap entry array for provisioning.
+       *
        * @param array $account
        *   drupal account.
        * @param \LdapServer $ldap_server
        * @param array $ldap_user
        *   ldap entry of user, returned by reference.
        * @param array $params
        *   with the following key values:
        *   'ldap_context' =>
        *   'module' => module calling function, e.g. 'ldap_user'
        *   'function' => function calling function, e.g. 'provisionLdapEntry'
        *   'include_count' => should 'count' array key be included
        *   'direction' => LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY || LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER.
+       *
        * @return array(ldap entry, $result) in ldap extension array format.!THIS IS NOT THE ACTUAL LDAP ENTRY
        */
       public function drupalUserToLdapEntry($account, $ldap_server, $params, $ldap_user_entry = NULL) {
         $provision = (isset($params['function']) && $params['function'] == 'provisionLdapEntry');
         $result = LDAP_USER_PROV_RESULT_NO_ERROR;
         if (!$ldap_user_entry) {
           $ldap_user_entry = array();
           $ldap_user_entry = [];
+        }
         if (!is_object($account) || !is_object($ldap_server)) {
           return array(NULL, LDAP_USER_PROV_RESULT_BAD_PARAMS);
           return [NULL, LDAP_USER_PROV_RESULT_BAD_PARAMS];
+        }
         $watchdog_tokens = array(
         $watchdog_tokens = [
           '%drupal_username' => $account->name,
         );
         ];
         $include_count = (isset($params['include_count']) && $params['include_count']);
         $direction = isset($params['direction']) ? $params['direction'] : LDAP_USER_PROV_DIRECTION_ALL;
-...
         $mappings = $this->getSynchMappings($direction, $prov_events);
         foreach ($mappings as $field_key => $field_detail) {
           list($ldap_attr_name, $ordinal, $conversion) = ldap_servers_token_extract_parts($field_key, TRUE);  //trim($field_key, '[]');
           list($ldap_attr_name, $ordinal, $conversion) = ldap_servers_token_extract_parts($field_key, TRUE);
           $ordinal = (!$ordinal) ? 0 : $ordinal;
           if ($ldap_user_entry && isset($ldap_user_entry[$ldap_attr_name]) && is_array($ldap_user_entry[$ldap_attr_name]) && isset($ldap_user_entry[$ldap_attr_name][$ordinal]) ) {
             continue; // don't override values passed in;
           if ($ldap_user_entry && isset($ldap_user_entry[$ldap_attr_name]) && is_array($ldap_user_entry[$ldap_attr_name]) && isset($ldap_user_entry[$ldap_attr_name][$ordinal])) {
             // don't override values passed in.
             continue;
+          }
           $synched = $this->isSynched($field_key, $params['prov_events'], LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY);
-...
             $token = ($field_detail['user_attr'] == 'user_tokens') ? $field_detail['user_tokens'] : $field_detail['user_attr'];
             $value = ldap_servers_token_replace($account, $token, 'user_account');
             if (substr($token, 0, 10) == '[password.' && (!$value || $value == $token)) { // deal with empty/unresolved password
             // Deal with empty/unresolved password.
             if (substr($token, 0, 10) == '[password.' && (!$value || $value == $token)) {
               if (!$provision) {
                 continue; //don't overwrite password on synch if no value provided
                 // don't overwrite password on synch if no value provided.
                 continue;
+              }
+            }
-...
+            }
             elseif ($value) {
               if (!isset($ldap_user_entry[$ldap_attr_name]) || !is_array($ldap_user_entry[$ldap_attr_name])) {
                 $ldap_user_entry[$ldap_attr_name] = array();
                 $ldap_user_entry[$ldap_attr_name] = [];
+              }
               $ldap_user_entry[$ldap_attr_name][$ordinal] = $value;
               if ($include_count) {
-...
         $params['account'] = $account;
         drupal_alter('ldap_entry', $ldap_user_entry, $params);
         return array($ldap_user_entry, $result);
         return [$ldap_user_entry, $result];
+      }
        /**
        * given a drupal account, query ldap and get all user fields and save user account
       /**
        * Given a drupal account, query ldap and get all user fields and save user account
        * (note: parameters are in odd order to match synchDrupalAccount handle)
+       *
        * @param array $account drupal account object or null
        * @param array $user_edit drupal edit array in form user_save($account, $user_edit) would take.
        * @param array $ldap_user as user's ldap entry.  passed to avoid requerying ldap in cases where already present
        * @param boolean $save indicating if drupal user should be saved.  generally depends on where function is called from and if the
        * @param array $account
        *   drupal account object or null.
        * @param array $user_edit
        *   drupal edit array in form user_save($account, $user_edit) would take.
        * @param array $ldap_user
        *   as user's ldap entry.  passed to avoid requerying ldap in cases where already present.
        * @param bool $save
        *   indicating if drupal user should be saved.  generally depends on where function is called from and if the.
+       *
        * @return result of user_save() function is $save is true, otherwise return TRUE on success or FALSE on any problem
        *   $user_edit data returned by reference
        * @return bool
        *   Resultof user_save() function is $save is true, otherwise return TRUE on
        *   success or FALSE on any problem
+       *
        *   $user_edit data returned by reference
        */
       public function provisionDrupalAccount($account = FALSE, &$user_edit, $ldap_user = NULL, $save = TRUE) {
         $watchdog_tokens = array();
         $watchdog_tokens = [];
         /**
          * @todo
          * -- add error catching for conflicts, conflicts should be checked before calling this function.
-...
           $user_edit['name'] = $account->name;
           $watchdog_tokens['%username'] = $user_edit['name'];
+        }
         //When using the multi-domain last authentication option
         //$ldap_server breaks beacause $this->drupalAcctProvisionServer is set on LDAP_USER_AUTH_SERVER_SID
         //So we need to check it's not the case before using ldap_servers_get_servers
         // When using the multi-domain last authentication option
         // $ldap_server breaks beacause $this->drupalAcctProvisionServer is set on LDAP_USER_AUTH_SERVER_SID
         // So we need to check it's not the case before using ldap_servers_get_servers.
         if ($this->drupalAcctProvisionServer && $this->drupalAcctProvisionServer != LDAP_USER_AUTH_SERVER_SID) {
           $ldap_server = ldap_servers_get_servers($this->drupalAcctProvisionServer, 'enabled', TRUE);  // $ldap_user['sid']
           /** @var \LdapServer $ldap_server */
           // $ldap_user['sid'].
           $ldap_server = ldap_servers_get_servers($this->drupalAcctProvisionServer, 'enabled', TRUE);
           $params = array(
           $params = [
             'account' => $account,
             'user_edit' => $user_edit,
             'prov_event' => LDAP_USER_EVENT_CREATE_DRUPAL_USER,
             'module' => 'ldap_user',
             'function' => 'provisionDrupalAccount',
             'direction' => LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER,
           );
           ];
           drupal_alter('ldap_entry', $ldap_user, $params);
           // look for existing drupal account with same puid.  if so update username and attempt to synch in current context
           // Look for existing drupal account with same puid.  if so update username and attempt to synch in current context.
           $puid = $ldap_server->userPuidFromLdapEntry($ldap_user['attr']);
           $account2 = ($puid) ? $ldap_server->userUserEntityFromPuid($puid) : FALSE;
           if ($account2) { // synch drupal account, since drupal account exists
             // 1. correct username and authmap
             $this->entryToUserEdit($ldap_user, $user_edit, $ldap_server, LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER, array(LDAP_USER_EVENT_SYNCH_TO_DRUPAL_USER));
             $account = user_save($account2, $user_edit, 'ldap_user');
             user_set_authmaps($account, array("authname_ldap_user" => $user_edit['name']));
             // 2. attempt synch if appropriate for current context
           $existing_account_from_puid = ($puid) ? $ldap_server->userUserEntityFromPuid($puid) : FALSE;
           // Synch drupal account, since drupal account exists.
           if ($existing_account_from_puid) {
             // 1. correct username and authmap.
             $this->entryToUserEdit($ldap_user, $user_edit, $ldap_server, LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER, [LDAP_USER_EVENT_SYNCH_TO_DRUPAL_USER]);
             $account = user_save($existing_account_from_puid, $user_edit, 'ldap_user');
             user_set_authmaps($account, ["authname_ldap_user" => $user_edit['name']]);
             // 2. attempt synch if appropriate for current context.
             if ($account) {
               $account = $this->synchToDrupalAccount($account, $user_edit, LDAP_USER_EVENT_SYNCH_TO_DRUPAL_USER, $ldap_user, TRUE);
+            }
             return $account;
+          }
           else { // create drupal account
             $this->entryToUserEdit($ldap_user, $user_edit, $ldap_server, LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER, array(LDAP_USER_EVENT_CREATE_DRUPAL_USER));
           // Create drupal account.
           else {
             $this->entryToUserEdit($ldap_user, $user_edit, $ldap_server, LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER, [LDAP_USER_EVENT_CREATE_DRUPAL_USER]);
             if ($save) {
               $watchdog_tokens = array('%drupal_username' => $user_edit['name']);
               $watchdog_tokens = ['%drupal_username' => $user_edit['name']];
               if (empty($user_edit['name'])) {
                 drupal_set_message(t('User account creation failed because of invalid, empty derived Drupal username.'), 'error');
                 watchdog('ldap_user',
-...
                 );
                 return FALSE;
+              }
               if(($this->accountsWithSameEmail == LDAP_USER_ACCOUNTS_WITH_SAME_EMAIL_DISABLED) && ($account_with_same_email = user_load_by_mail($user_edit['mail']))) {
               if (($this->accountsWithSameEmail == LDAP_USER_ACCOUNTS_WITH_SAME_EMAIL_DISABLED) && ($account_with_same_email = user_load_by_mail($user_edit['mail']))) {
                 $watchdog_tokens['%email'] = $user_edit['mail'];
                 $watchdog_tokens['%duplicate_name'] = $account_with_same_email->name;
                 watchdog('ldap_user', 'LDAP user %drupal_username has email address
-...
                 drupal_set_message(t('User account creation failed because of system problems.'), 'error');
+              }
               else {
                 user_set_authmaps($account, array('authname_ldap_user' => $account->name));
                 user_set_authmaps($account, ['authname_ldap_user' => $account->name]);
                 ldap_user_ldap_provision_semaphore('drupal_created', 'set', $account->name);
+              }
               return $account;
-...
+      }
       /**
        * set ldap associations of a drupal account by altering user fields
        * Set ldap associations of a drupal account by altering user fields.
+       *
        * @param string $drupal_username
+       *
        * @return boolean TRUE on success, FALSE on error or failure because of invalid user or ldap accounts
+       *
        * @return bool
        *   TRUE on success, FALSE on error or failure because of invalid user or ldap accounts
        */
       function ldapAssociateDrupalAccount($drupal_username) {
       public function ldapAssociateDrupalAccount($drupal_username) {
         if ($this->drupalAcctProvisionServer) {
           $prov_events = array(LDAP_USER_EVENT_LDAP_ASSOCIATE_DRUPAL_ACCT);
           $ldap_server = ldap_servers_get_servers($this->drupalAcctProvisionServer, 'enabled', TRUE);  // $ldap_user['sid']
           $prov_events = [LDAP_USER_EVENT_LDAP_ASSOCIATE_DRUPAL_ACCT];
           // $ldap_user['sid'].
           $ldap_server = ldap_servers_get_servers($this->drupalAcctProvisionServer, 'enabled', TRUE);
           $account = user_load_by_name($drupal_username);
           $ldap_user = ldap_servers_get_user_ldap_data($drupal_username, $this->drupalAcctProvisionServer, 'ldap_user_prov_to_drupal');
           if (!$account) {
             watchdog(
               'ldap_user',
               'Failed to LDAP associate drupal account %drupal_username because account not found',
               array('%drupal_username' => $drupal_username),
               ['%drupal_username' => $drupal_username],
               WATCHDOG_ERROR
             );
             return FALSE;
-...
             watchdog(
               'ldap_user',
               'Failed to LDAP associate drupal account %drupal_username because corresponding LDAP entry not found',
               array('%drupal_username' => $drupal_username),
               ['%drupal_username' => $drupal_username],
               WATCHDOG_ERROR
             );
             return FALSE;
+          }
           else {
             $user_edit = array();
             $user_edit['data']['ldap_user']['init'] = array(
             $user_edit = [];
             $user_edit['data']['ldap_user']['init'] = [
               'sid'  => $ldap_user['sid'],
               'dn'   => $ldap_user['dn'],
               'mail'   => $account->mail,
             );
             ];
             $ldap_user_puid = $ldap_server->userPuidFromLdapEntry($ldap_user['attr']);
             if ($ldap_user_puid) {
               $user_edit['ldap_user_puid'][LANGUAGE_NONE][0]['value'] = $ldap_user_puid; //
               $user_edit['ldap_user_puid'][LANGUAGE_NONE][0]['value'] = $ldap_user_puid;
+            }
             $user_edit['ldap_user_puid_property'][LANGUAGE_NONE][0]['value'] = $ldap_server->unique_persistent_attr;
             $user_edit['ldap_user_puid_sid'][LANGUAGE_NONE][0]['value'] = $ldap_server->sid;
             $user_edit['ldap_user_current_dn'][LANGUAGE_NONE][0]['value'] = $ldap_user['dn'];
             $account = user_save($account, $user_edit, 'ldap_user');
             return (boolean)$account;
             return (boolean) $account;
+          }
+        }
         else {
-...
+        }
+      }
       /** populate $user edit array (used in hook_user_save, hook_user_update, etc)
        * ... should not assume all attribues are present in ldap entry
       /**
        * Populate $user edit array (used in hook_user_save, hook_user_update, etc)
        * ... should not assume all attribues are present in ldap entry.
+       *
        * @param array ldap entry $ldap_user
        * @param array $edit see hook_user_save, hook_user_update, etc
        * @param object $ldap_server
        * @param enum $direction
        * @param $ldap_user
        * @param array $edit
        *   see hook_user_save, hook_user_update, etc.
        * @param \LdapServer $ldap_server
        * @param int $direction
        * @param array $prov_events
+       *
        */
       public function entryToUserEdit($ldap_user, &$edit, $ldap_server, $direction = LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER, $prov_events = NULL) {
       function entryToUserEdit($ldap_user, &$edit, $ldap_server, $direction = LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER, $prov_events = NULL) {
         // need array of user fields and which direction and when they should be synched.
         // Need array of user fields and which direction and when they should be synched.
         if (!$prov_events) {
           $prov_events = ldap_user_all_events();
+        }
-...
           $edit['mail'] = isset($edit['mail']) ? $edit['mail'] : $ldap_user['mail'];
           if (!isset($edit['pass'])) {
             $edit['pass'] = user_password(20);
             watchdog('ldap_user', '20 character random password generated for the %username account that has been created.', array('%username' => $drupal_username), WATCHDOG_INFO);
             watchdog('ldap_user', '20 character random password generated for the %username account that has been created.', ['%username' => $drupal_username], WATCHDOG_INFO);
+          }
           $edit['init'] = isset($edit['init']) ? $edit['init'] : $edit['mail'];
           $edit['status'] = isset($edit['status']) ? $edit['status'] : 1;
           $edit['signature'] = isset($edit['signature']) ? $edit['signature'] : '';
           $edit['data']['ldap_user']['init'] = array(
           $edit['data']['ldap_user']['init'] = [
             'sid'  => $ldap_user['sid'],
             'dn'   => $ldap_user['dn'],
             'mail' => $edit['mail'],
           );
           ];
+        }
         /*
-...
          * when syncing the profile.
          */
         if ($direction == LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER && in_array(LDAP_USER_EVENT_SYNCH_TO_DRUPAL_USER, $prov_events)) {
            $edit['data']['ldap_user']['init'] = array(
           $edit['data']['ldap_user']['init'] = [
             'sid'  => $ldap_user['sid'],
             'dn'   => $ldap_user['dn'],
             'mail' => isset($edit['mail']) && !empty($edit['mail']) ? $edit['mail'] : $ldap_user['mail'],
           );
           ];
+        }
         if ($this->isSynched('[property.picture]', $prov_events, $direction)) {
-...
           if ($picture) {
             if (in_array(LDAP_USER_EVENT_CREATE_DRUPAL_USER, $prov_events)) {
               $edit['picture'] = $picture->fid;
             } else {
+            }
             else {
               $edit['picture'] = $picture;
+            }
             $edit['data']['ldap_user']['init']['thumb5md'] = $picture->md5Sum;
-...
         if ($this->isSynched('[field.ldap_user_puid]', $prov_events, $direction)) {
           $ldap_user_puid = $ldap_server->userPuidFromLdapEntry($ldap_user['attr']);
           if ($ldap_user_puid) {
             $edit['ldap_user_puid'][LANGUAGE_NONE][0]['value'] = $ldap_user_puid; //
             $edit['ldap_user_puid'][LANGUAGE_NONE][0]['value'] = $ldap_user_puid;
+          }
+        }
         if ($this->isSynched('[field.ldap_user_puid_property]', $prov_events, $direction)) {
-...
         // Get any additional mappings.
         $mappings = $this->getSynchMappings($direction, $prov_events);
          // Loop over the mappings.
         // Loop over the mappings.
         foreach ($mappings as $user_attr_key => $field_detail) {
            // Make sure this mapping is relevant to the sync context.
           // Make sure this mapping is relevant to the sync context.
           if (!$this->isSynched($user_attr_key, $prov_events, $direction)) {
             continue;
+          }
            /**
           /**
             * if "convert from binary is selected" and no particular method is in token,
             * default to ldap_servers_binary() function
             */
-...
           $value = ldap_servers_token_replace($ldap_user['attr'], $field_detail['ldap_attr'], 'ldap_entry');
           list($value_type, $value_name, $value_instance) = ldap_servers_parse_user_attr_name($user_attr_key);
           // $value_instance not used, may have future use case
           // $value_instance not used, may have future use case.
           // Are we dealing with a field?
           if ($value_type == 'field') {
             // Field api field - first we get the field.
-...
             // Then the columns for the field in the schema.
             $columns = array_keys($field['columns']);
             // Then we convert the value into an array if it's scalar.
             $values = $field['cardinality'] == 1 ? array($value) : (array) $value;
             $values = $field['cardinality'] == 1 ? [$value] : (array) $value;
             $items = array();
             $items = [];
             // Loop over the values and set them in our $items array.
             foreach ($values as $delta => $value) {
               if (isset($value)) {
-...
+        }
         // Allow other modules to have a say.
         drupal_alter('ldap_user_edit_user', $edit, $ldap_user, $ldap_server, $prov_events);
         if (isset($edit['name']) && $edit['name'] == '') {  // don't let empty 'name' value pass for user
         // don't let empty 'name' value pass for user.
         if (isset($edit['name']) && $edit['name'] == '') {
           unset($edit['name']);
+        }
+      }
       /**
        * given configuration of synching, determine is a given synch should occur
        * Given configuration of synching, determine is a given synch should occur.
+       *
        * @param string $attr_token e.g. [property.mail], [field.ldap_user_puid_property]
        * @param object $ldap_server
        * @param array $prov_events e.g. array(LDAP_USER_EVENT_CREATE_DRUPAL_USER).  typically array with 1 element
        * @param scalar $direction LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER or LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY
        * @param string $attr_token
        *   e.g. [property.mail], [field.ldap_user_puid_property].
        * @param array $prov_events
        *   e.g. array(LDAP_USER_EVENT_CREATE_DRUPAL_USER).  typically array with 1
        *   element.
        * @param scalar $direction
        *   LDAP_USER_PROV_DIRECTION_TO_DRUPAL_USER or
        *   LDAP_USER_PROV_DIRECTION_TO_LDAP_ENTRY.
+       *
        * @return bool
        */
       public function isSynched($attr_token, $prov_events, $direction) {
         $result = (boolean)(
         $result = (boolean) (
           isset($this->synchMapping[$direction][$attr_token]['prov_events']) &&
           count(array_intersect($prov_events, $this->synchMapping[$direction][$attr_token]['prov_events']))
         );

Formats disponibles : Unified diff

Projet

Général

Profil

Club Drupal

Révision 32700c57

Ajouté par Assos Assos il y a environ 5 ans