plugins/importexport/users/UserXMLParser.inc.php

<?php

import('lib.pkp.classes.xml.XMLParser');

class UserXMLParser {

   var $parser;

   var $usersToImport;

   var $importedUsers;

   var $errors;

   var $pressId;

   function UserXMLParser($pressId) {
      $this->parser = new XMLParser();
      $this->pressId = $pressId;
   }

   function &parseData($file) {
      $roleDao =& DAORegistry::getDAO('RoleDAO');

      $success = true;
      $this->usersToImport = array();
      $tree = $this->parser->parse($file);

      $pressDao =& DAORegistry::getDAO('PressDAO');
      $press =& $pressDao->getById($this->pressId);
      $pressPrimaryLocale = AppLocale::getPrimaryLocale();

      $site =& Request::getSite();
      $siteSupportedLocales = $site->getSupportedLocales();

      if ($tree !== false) {
         foreach ($tree->getChildren() as $user) {
            if ($user->getName() == 'user') {
               // Match user element
               $newUser = new ImportedUser();

               foreach ($user->getChildren() as $attrib) {
                  switch ($attrib->getName()) {
                     case 'username':
                        // Usernames must be lowercase
                        $newUser->setUsername(strtolower($attrib->getValue()));
                        break;
                     case 'password':
                        $newUser->setMustChangePassword($attrib->getAttribute('change') == 'true'?1:0);
                        $encrypted = $attrib->getAttribute('encrypted');
                        if (isset($encrypted) && $encrypted !== 'plaintext') {
                           $ompEncryptionScheme = Config::getVar('security', 'encryption');
                           if ($encrypted != $ompEncryptionScheme) {
                              $this->errors[] = __('plugins.importexport.users.import.encryptionMismatch', array('importHash' => $encrypted, 'ompHash' => $ompEncryptionScheme));
                           }
                           $newUser->setPassword($attrib->getValue());
                        } else {
                           $newUser->setUnencryptedPassword($attrib->getValue());
                        }
                        break;
                     case 'salutation':
                        $newUser->setSalutation($attrib->getValue());
                        break;
                     case 'first_name':
                        $newUser->setFirstName($attrib->getValue());
                        break;
                     case 'middle_name':
                        $newUser->setMiddleName($attrib->getValue());
                        break;
                     case 'last_name':
                        $newUser->setLastName($attrib->getValue());
                        break;
                     case 'initials':
                        $newUser->setInitials($attrib->getValue());
                        break;
                     case 'gender':
                        $newUser->setGender($attrib->getValue());
                        break;
                     case 'affiliation':
                        $locale = $attrib->getAttribute('locale');
                        if (empty($locale)) $locale = $pressPrimaryLocale;
                        $newUser->setAffiliation($attrib->getValue(), $locale);
                        break;
                     case 'email':
                        $newUser->setEmail($attrib->getValue());
                        break;
                     case 'url':
                        $newUser->setUrl($attrib->getValue());
                        break;
                     case 'phone':
                        $newUser->setPhone($attrib->getValue());
                        break;
                     case 'fax':
                        $newUser->setFax($attrib->getValue());
                        break;
                     case 'mailing_address':
                        $newUser->setMailingAddress($attrib->getValue());
                        break;
                     case 'country':
                        $newUser->setCountry($attrib->getValue());
                        break;
                     case 'signature':
                        $locale = $attrib->getAttribute('locale');
                        if (empty($locale)) $locale = $pressPrimaryLocale;
                        $newUser->setSignature($attrib->getValue(), $locale);
                        break;
                     case 'interests':
                        $locale = $attrib->getAttribute('locale');
                        if (empty($locale)) $locale = $pressPrimaryLocale;
                        $newUser->setInterests($attrib->getValue(), $locale);
                        break;
                     case 'gossip':
                        $locale = $attrib->getAttribute('locale');
                        if (empty($locale)) $locale = $pressPrimaryLocale;
                        $newUser->setGossip($attrib->getValue(), $locale);
                        break;
                     case 'biography':
                        $locale = $attrib->getAttribute('locale');
                        if (empty($locale)) $locale = $pressPrimaryLocale;
                        $newUser->setBiography($attrib->getValue(), $locale);
                        break;
                     case 'locales':
                        $locales = array();
                        foreach (explode(':', $attrib->getValue()) as $locale) {
                           if (AppLocale::isLocaleValid($locale) && in_array($locale, $siteSupportedLocales)) {
                              array_push($locales, $locale);
                           }
                        }
                        $newUser->setLocales($locales);
                        break;
                     case 'role':
                        $roleType = $attrib->getAttribute('type');
                        if ($this->validRole($roleType)) {
                           $role = new Role();
                           $role->setRoleId($roleDao->getRoleIdFromPath($roleType));
                           $newUser->addRole($role);
                        }
                        break;
                  }
               }
               array_push($this->usersToImport, $newUser);
            }
         }
      }

      return $this->usersToImport;
   }

   function importUsers($sendNotify = false, $continueOnError = false) {
      $success = true;
      $this->importedUsers = array();
      $this->errors = array();
      $pressDao =& DAORegistry::getDAO('PressDAO');
      $press =& $pressDao->getById($this->pressId);

      $userDao =& DAORegistry::getDAO('UserDAO');
      $roleDao =& DAORegistry::getDAO('RoleDAO');

      if ($sendNotify) {
         // Set up mail template to send to added users
         import('classes.mail.MailTemplate');
         $mail = new MailTemplate('USER_REGISTER');

         $mail->setFrom($press->getSetting('contactEmail'), $press->getSetting('contactName'));
      }

      for ($i=0, $count=count($this->usersToImport); $i < $count; $i++) {
         $user =& $this->usersToImport[$i];
         // If the email address already exists in the system,
         // then assign the user the username associated with that email address.
         if ($user->getEmail() != null) {
            $emailExists = $userDao->getUserByEmail($user->getEmail(), true);
            if ($emailExists != null) {
               $user->setUsername($emailExists->getUsername());
            }
         }
         if ($user->getUsername() == null) {
            $newUsername = true;
            $this->generateUsername($user);
         } else {
            $newUsername = false;
         }
         if ($user->getUnencryptedPassword() != null) {
            $user->setPassword(Validation::encryptCredentials($user->getUsername(), $user->getUnencryptedPassword()));
         } else if ($user->getPassword() == null) {
            $this->generatePassword($user);
         }

         if (!$newUsername) {
            // Check if user already exists
            $userExists = $userDao->getByUsername($user->getUsername(), true);
            if ($userExists != null) {
               $user->setId($userExists->getId());
            }
         } else {
            $userExists = false;
         }

         if ($newUsername || !$userExists) {
            // Create new user account
            // If the user's username was specified in the data file and
            // the username already exists, only the new roles are added for that user
            if (!$userDao->insertUser($user)) {
               // Failed to add user!
               $this->errors[] = sprintf('%s: %s (%s)',
                  __('manager.people.importUsers.failedToImportUser'),
                  $user->getFullName(), $user->getUsername());

               if ($continueOnError) {
                  // Skip to next user
                  $success = false;
                  continue;
               } else {
                  return false;
               }
            }
         }

         // Enroll user in specified roles
         // If the user is already enrolled in a role, that role is skipped

         $userGroupDao =& DAORegistry::getDAO('UserGroupDAO');

         foreach ($user->getRoles() as $role) {
            $userGroupIds =& $userGroupDao->getUserGroupIdsByRoleId($role->getRoleId(), $press->getId());
            foreach ($userGroupIds as $userGroupId) {
               if (!$userGroupDao->userInGroup($user->getId(), $userGroupId)) {
                  if (!$userGroupDao->assignUserToGroup($user->getId(), $userGroupId, $press->getId())) {
                     // Failed to add role!
                     $this->errors[] = sprintf('%s: %s - %s (%s)',
                        __('manager.people.importUsers.failedToImportRole'),
                        $role->getRoleName(),
                        $user->getFullName(), $user->getUsername());

                     if ($continueOnError) {
                        // Continue to insert other roles for this user
                        $success = false;
                        continue;
                     } else {
                        return false;
                     }
                  }
               }
            }
         }

         if ($sendNotify && !$userExists) {
            // Send email notification to user as if user just registered themselves
            $mail->addRecipient($user->getEmail(), $user->getFullName());
            $mail->sendWithParams(array(
               'pressName' => $press->getTitle($press->getPrimaryLocale()),
               'username' => $user->getUsername(),
               'password' => $user->getUnencryptedPassword() ==  null ? '-' : $user->getUnencryptedPassword(),
               'userFullName' => $user->getFullName()
            ));
            $mail->clearRecipients();
         }

         array_push($this->importedUsers, $user);
      }

      return $success;
   }

   function &getUsersToImport() {
      return $this->usersToImport;
   }

   function setUsersToImport($users) {
      $this->usersToImport = $users;
   }

   function &getImportedUsers() {
      return $this->importedUsers;
   }

   function &getErrors() {
      return $this->errors;
   }

   function validRole($roleType) {
      return isset($roleType) && in_array($roleType, array('manager', 'editor', 'seriesEditor', 'productionEditor', 'reviewer', 'copyeditor', 'proofreader', 'author', 'reader'));
   }

   function generateUsername(&$user) {
      $userDao =& DAORegistry::getDAO('UserDAO');
      $baseUsername = String::regexp_replace('/[^A-Z0-9]/i', '', $user->getLastName());
      if (empty($baseUsername)) {
         $baseUsername = String::regexp_replace('/[^A-Z0-9]/i', '', $user->getFirstName());
      }
      if (empty($username)) {
         // Default username if we can't use the user's last or first name
         $baseUsername = 'user';
      }

      for ($username = $baseUsername, $i=1; $userDao->userExistsByUsername($username, true); $i++) {
         $username = $baseUsername . $i;
      }
      $user->setUsername($username);
   }

   function generatePassword(&$user) {
      $password = Validation::generatePassword();
      $user->setUnencryptedPassword($password);
      $user->setPassword(Validation::encryptCredentials($user->getUsername(), $password));
   }

}


import('classes.user.User');
class ImportedUser extends User {

   var $roles;

   function ImportedUser() {
      $this->roles = array();
      parent::User();
   }

   function setUnencryptedPassword($unencryptedPassword) {
      $this->setData('unencryptedPassword', $unencryptedPassword);
   }

   function getUnencryptedPassword() {
      return $this->getData('unencryptedPassword');
   }

   function addRole(&$role) {
      array_push($this->roles, $role);
   }

   function &getRoles() {
      return $this->roles;
   }

}

?>