web-dev-qa-db-fra.com

Comment créer un nouveau compte utilisateur Joomla à partir d'un script?

Nous créons une API XML pour Joomla qui permet aux sites partenaires de créer de nouveaux comptes pour leurs utilisateurs sur notre site Web.

Nous avons créé un script autonome PHP qui traite et valide la demande d'API, mais nous devons maintenant créer les nouveaux comptes. Au départ, nous pensions faire un appel CURL pour soumettre le formulaire d’inscription, mais nous nous sommes rendu compte que le jeton utilisateur posait un problème. Existe-t-il un autre moyen simple de créer un compte utilisateur sans entrer dans les entrailles de Joomla? Si nous devons subir une intervention chirurgicale, quelle est la meilleure façon de l'aborder?

phpjoomlajoomla1.5
19
user77413

Vous devez utiliser les classes internes de Joomla, comme JUser, car il existe beaucoup de logique interne telle que le salage du mot de passe. Créez un script personnalisé qui utilise les valeurs de la demande d'API et enregistre les utilisateurs dans la base de données à l'aide des méthodes de Joomla User Classes.

Deux façons d’ajouter des utilisateurs de joomla à l’aide de votre code personnalisé est un merveilleux tutoriel. L'approche fonctionne . J'ai utilisé cette approche dans certains projets. 

Si vous devez accéder à Joomla Framework outside Joomla, vérifiez cette ressource à la place .

16
GmonC

Basé sur la réponse de waitinforatrain, qui ne fonctionne pas correctement pour les utilisateurs connectés (réellement dangereux si vous l'utilisez dans le back-end), je l'ai un peu modifié et le voilà, totalement fonctionnel pour moi. Notez que ceci concerne Joomla 2.5.6, alors que ce fil était à l'origine pour 1.5, d'où les réponses ci-dessus:

 function addJoomlaUser($name, $username, $password, $email) {
    jimport('joomla.user.helper');

    $data = array(
        "name"=>$name,
        "username"=>$username,
        "password"=>$password,
        "password2"=>$password,
        "email"=>$email,
        "block"=>0,
        "groups"=>array("1","2")
    );

    $user = new JUser;
    //Write to database
    if(!$user->bind($data)) {
        throw new Exception("Could not bind data. Error: " . $user->getError());
    }
    if (!$user->save()) {
        throw new Exception("Could not save user. Error: " . $user->getError());
    }

    return $user->id;
 }
10
mavrosxristoforos

Allez simplement à la page de documentation: http://docs.joomla.org/JUser

Également concurrencé un échantillon d'une page pour enregistrer de nouveaux utilisateurs dans Joomla

<?php 

function register_user ($email, $password){ 

 $firstname = $email; // generate $firstname
 $lastname = ''; // generate $lastname
 $username = $email; // username is the same as email


 /*
 I handle this code as if it is a snippet of a method or function!!

 First set up some variables/objects     */

 // get the ACL
 $acl =& JFactory::getACL();

 /* get the com_user params */

 jimport('joomla.application.component.helper'); // include libraries/application/component/helper.php
 $usersParams = &JComponentHelper::getParams( 'com_users' ); // load the Params

 // "generate" a new JUser Object
 $user = JFactory::getUser(0); // it's important to set the "0" otherwise your admin user information will be loaded

 $data = array(); // array for all user settings

 // get the default usertype
 $usertype = $usersParams->get( 'new_usertype' );
 if (!$usertype) {
     $usertype = 'Registered';
 }

 // set up the "main" user information

 //original logic of name creation
 //$data['name'] = $firstname.' '.$lastname; // add first- and lastname
 $data['name'] = $firstname.$lastname; // add first- and lastname

 $data['username'] = $username; // add username
 $data['email'] = $email; // add email
 $data['gid'] = $acl->get_group_id( '', $usertype, 'ARO' );  // generate the gid from the usertype

 /* no need to add the usertype, it will be generated automaticaly from the gid */

 $data['password'] = $password; // set the password
 $data['password2'] = $password; // confirm the password
 $data['sendEmail'] = 1; // should the user receive system mails?

 /* Now we can decide, if the user will need an activation */

 $useractivation = $usersParams->get( 'useractivation' ); // in this example, we load the config-setting
 if ($useractivation == 1) { // yeah we want an activation

     jimport('joomla.user.helper'); // include libraries/user/helper.php
     $data['block'] = 1; // block the User
     $data['activation'] =JUtility::getHash( JUserHelper::genRandomPassword() ); // set activation hash (don't forget to send an activation email)

 }
 else { // no we need no activation

     $data['block'] = 1; // don't block the user

 }

 if (!$user->bind($data)) { // now bind the data to the JUser Object, if it not works....

     JError::raiseWarning('', JText::_( $user->getError())); // ...raise an Warning
     return false; // if you're in a method/function return false

 }

 if (!$user->save()) { // if the user is NOT saved...

     JError::raiseWarning('', JText::_( $user->getError())); // ...raise an Warning
     return false; // if you're in a method/function return false

 }

 return $user; // else return the new JUser object

 }

 $email = JRequest::getVar('email');
 $password = JRequest::getVar('password');

 //echo 'User registration...'.'<br/>';
 register_user($email, $password);
 //echo '<br/>'.'User registration is completed'.'<br/>';
?>

S'il vous plaît noter que pour l'enregistrement utilisé seulement email et mot de passe.

L'échantillon d'appel: Localhost/joomla/[email protected]&password=pass Ou créez simplement un formulaire simple avec les paramètres appropriés

7
molo

Testé et en cours d'exécution 2.5.

function addJoomlaUser($name, $username, $password, $email) {
        $data = array(
            "name"=>$name, 
            "username"=>$username, 
            "password"=>$password,
            "password2"=>$password,
            "email"=>$email
        );

        $user = clone(JFactory::getUser());
        //Write to database
        if(!$user->bind($data)) {
            throw new Exception("Could not bind data. Error: " . $user->getError());
        }
        if (!$user->save()) {
            throw new Exception("Could not save user. Error: " . $user->getError());
        }

        return $user->id;
}

Si vous êtes en dehors de l'environnement Joomla, vous devrez le faire d'abord, ou si vous n'écrivez pas un composant, utilisez celui qui se trouve dans le lien de la réponse de @ GMonC.

<?php
if (! defined('_JEXEC'))
    define('_JEXEC', 1);
$DS=DIRECTORY_SEPARATOR;
define('DS', $DS);

//Get component path
preg_match("/\\{$DS}components\\{$DS}com_.*?\\{$DS}/", __FILE__, $matches, PREG_OFFSET_CAPTURE);
$component_path = substr(__FILE__, 0, strlen($matches[0][0]) + $matches[0][1]);
define('JPATH_COMPONENT', $component_path);

define('JPATH_BASE', substr(__FILE__, 0, strpos(__FILE__, DS.'components'.DS) ));
require_once ( JPATH_BASE .DS.'includes'.DS.'defines.php' );
require_once JPATH_BASE .DS.'includes'.DS.'framework.php';
jimport( 'joomla.environment.request' );
$mainframe =& JFactory::getApplication('site');
$mainframe->initialise();

J'utilise ceci pour les tests unitaires de mon composant.

2
bcoughlan

http://joomlaportal.ru/content/view/1381/68/

INSERT INTO jos_users( `name`, `username`, `password`, `email`, `usertype`, `gid` )
VALUES( 'Иванов Иван', 'ivanov', md5('12345'), '[email protected]', 'Registered', 18 );

INSERT INTO jos_core_acl_aro( `section_value`, `value` )
VALUES ( 'users', LAST_INSERT_ID() );

INSERT INTO jos_core_acl_groups_aro_map( `group_id`, `aro_id` )
VALUES ( 18, LAST_INSERT_ID() );
2
faleev

Dans mon cas (Joomla 3.4.3), l'utilisateur a été ajouté à la session. Il existait donc un comportement erroné lors de la tentative d'activation du compte.

Ajoutez simplement cette ligne, après $ user-> save ():

JFactory :: getSession () -> clear ('utilisateur', "défaut");

Cela supprimera l'utilisateur nouvellement créé de la session.

1
Rob

Mise à jour: oh, je ne vois pas que vous vouliez 1.5 mais vous pouvez faire la même chose mais avec l'API 1.5 à la place.

C’est une partie de quelque chose que j’utilisais autrefois, mais vous auriez plutôt besoin d’utiliser le groupe par défaut jusqu’à ce qu’un problème lié à l’utilisation de JUserHelper à partir de la ligne de commande soit résolu ou qu’il s’agisse d’une application Web.

<?php
/**
 *
 * @copyright  Copyright (C) 2005 - 2012 Open Source Matters, Inc. All rights reserved.
 * @license    GNU General Public License version 2 or later; see LICENSE.txt
 */

if (!defined('_JEXEC'))
{
    // Initialize Joomla framework
    define('_JEXEC', 1);
}

@ini_set('zend.ze1_compatibility_mode', '0');
error_reporting(E_ALL);
ini_set('display_errors', 1);

// Load system defines
if (file_exists(dirname(__DIR__) . '/defines.php'))
{
    require_once dirname(__DIR__) . '/defines.php';
}

if (!defined('JPATH_BASE'))
{
    define('JPATH_BASE', dirname(__DIR__));
}

if (!defined('_JDEFINES'))
{
    require_once JPATH_BASE . '/includes/defines.php';
}

// Get the framework.
require_once JPATH_LIBRARIES . '/import.php';


/**
 * Add user
 *
 * @package  Joomla.Shell
 *
 * @since    1.0
 */
class Adduser extends JApplicationCli
{
    /**
     * Entry point for the script
     *
     * @return  void
     *
     * @since   1.0
     */
    public function doExecute()
    {
        // username, name, email, groups are required values.
        // password is optional
        // Groups is the array of groups

        // Long args
        $username = $this->input->get('username', null,'STRING');
        $name = $this->input->get('name');
        $email = $this->input->get('email', '', 'EMAIL');
        $groups = $this->input->get('groups', null, 'STRING');

        // Short args
        if (!$username)
        {
            $username = $this->input->get('u', null, 'STRING');
        }
        if (!$name)
        {
            $name = $this->input->get('n');
        }
        if (!$email)
        {
            $email = $this->input->get('e', null, 'EMAIL');
        }
        if (!$groups)
        {
            $groups = $this->input->get('g', null, 'STRING');
        }

        $user = new JUser();

        $array = array();
        $array['username'] = $username;
        $array['name'] = $name;
        $array['email'] = $email;

        $user->bind($array);
        $user->save();

        $grouparray = explode(',', $groups);
        JUserHelper::setUserGroups($user->id, $grouparray);
        foreach ($grouparray as $groupId)
        {
            JUserHelper::addUserToGroup($user->id, $groupId);
        }

        $this->out('User Created');

        $this->out();
    }

}

if (!defined('JSHELL'))
{
    JApplicationCli::getInstance('Adduser')->execute();
}
1
Elin

Une autre solution intelligente consiste à utiliser la méthode de classe /component/com_users/models/registration.php appelée register car elle s’occupe vraiment de tout.

D'abord, vous ajoutez ces méthodes à votre classe d'assistance

/**
*   Get any component's model
**/
public static function getModel($name, $path = JPATH_COMPONENT_ADMINISTRATOR, $component = 'yourcomponentname')
{
    // load some joomla helpers
    JLoader::import('joomla.application.component.model'); 
    // load the model file
    JLoader::import( $name, $path . '/models' );
    // return instance
    return JModelLegacy::getInstance( $name, $component.'Model' );
}   

/**
*   Random Key
*
*   @returns a string
**/
public static function randomkey($size)
{
    $bag = "abcefghijknopqrstuwxyzABCDDEFGHIJKLLMMNOPQRSTUVVWXYZabcddefghijkllmmnopqrstuvvwxyzABCEFGHIJKNOPQRSTUWXYZ";
    $key = array();
    $bagsize = strlen($bag) - 1;
    for ($i = 0; $i < $size; $i++)
    {
        $get = Rand(0, $bagsize);
        $key[] = $bag[$get];
    }
    return implode($key);
}

Ensuite, vous ajoutez également la méthode suivante de création d'utilisateur à votre classe d'assistance de composant.

/**
* Greate user and update given table
*/
public static function createUser($new)
{
    // load the user component language files if there is an error
    $lang = JFactory::getLanguage();
    $extension = 'com_users';
    $base_dir = JPATH_SITE;
    $language_tag = 'en-GB';
    $reload = true;
    $lang->load($extension, $base_dir, $language_tag, $reload);
    // load the user regestration model
    $model = self::getModel('registration', JPATH_ROOT. '/components/com_users', 'Users');
    // set password
    $password = self::randomkey(8);
    // linup new user data
    $data = array(
        'username' => $new['username'],
        'name' => $new['name'],
        'email1' => $new['email'],
        'password1' => $password, // First password field
        'password2' => $password, // Confirm password field
        'block' => 0 );
    // register the new user
    $userId = $model->register($data);
    // if user is created
    if ($userId > 0)
    {
        return $userId;
    }
    return $model->getError();
}

Ensuite, n'importe où dans votre composant, vous pouvez créer un utilisateur comme celui-ci.

// setup new user array
$newUser = array(
    'username' => $validData['username'], 
    'name' => $validData['name'], 
    'email' => $validData['email']
    );
$userId = yourcomponentnameHelper::createUser($newUser); 
if (!is_int($userId))
{
    $this->setMessage($userId, 'error');
}

En procédant de cette manière, vous éviterez tout problème de gestion des courriers électroniques à envoyer car les paramètres par défaut du système seront automatiquement utilisés. J'espère que ça aide quelqu'un :)

1
Llewellyn

J'ai fait un appel ajax et ensuite juste passé les variables à ce script et cela a fonctionné pour moi. 

define('_JEXEC', 1);
define('JPATH_BASE', __DIR__);
define('DS', DIRECTORY_SEPARATOR);

/* Required Files */
require_once(JPATH_BASE . DS . 'includes' . DS . 'defines.php');
require_once(JPATH_BASE . DS . 'includes' . DS . 'framework.php');
$app = JFactory::getApplication('site');
$app->initialise();

require_once(JPATH_BASE . DS . 'components' . DS . 'com_users' . DS . 'models' . DS . 'registration.php');

$model = new UsersModelRegistration();

jimport('joomla.mail.helper');
jimport('joomla.user.helper');
$language = JFactory::getLanguage();
$language->load('com_users', JPATH_SITE);
$type       = 0;
$username   = JRequest::getVar('username');
$password   = JRequest::getVar('password');
$name       = JRequest::getVar('name');
$mobile     = JRequest::getVar('mobile');
$email      = JRequest::getVar('email');
$alias      = strtr($name, array(' ' => '-'));
$sendEmail  = 1;
$activation = 0;

$data       = array('username'   => $username,
            'name'       => $name,
            'email1'     => $email,
            'password1'  => $password, // First password field
            'password2'  => $password, // Confirm password field
            'sendEmail'  => $sendEmail,
            'activation' => $activation,
            'block'      => "0", 
            'mobile'     => $mobile,
            'groups'     => array("2", "10"));
$response   = $model->register($data);

echo $data['name'] . " saved!";
$model->register($data);

Seul l'utilisateur n'est pas activé automatiquement. Je passe 'block' => "0" pour l'activer mais cela ne fonctionne pas: ( Mais le reste du code fonctionne correctement.

0
Joomler

Cela ne fonctionnera pas dans joomla 1.6 car les ACL sont gérés d'une autre manière ... En fin de compte, c'est encore plus simple, vous devez obligatoirement ajouter une entrée dans la table "jos_user_usergroup_map" (puis "jos_users" table) pour déclarer au moins un groupe pour chaque utilisateur ...

0
luciomonter

il y a un module appelé "module de connexion", vous pouvez utiliser ce module et l'afficher dans l'un des menus. dans lequel vous obtiendrez un lien comme "nouvel utilisateur?" ou "créer un compte" il suffit de cliquer dessus, vous obtiendrez une page d'inscription avec validation .. il ne s'agit que d'un processus en 3 étapes pour utiliser la page d'inscription ... il peut être utile d'obtenir des résultats plus rapidement !! .. thanx

0
Denish