Assigner un groupe client par défaut à l'inscription PrestaShop

Le problème : le groupe par défaut ignoré à la création du compte

Lorsqu'on développe un formulaire d'inscription personnalisé sur PrestaShop — par exemple pour permettre au client de choisir son profil (professionnel, revendeur, particulier) — on se heurte souvent à un comportement contre-intuitif : la propriété id_default_group du client n'est pas prise en compte si elle est définie après l'appel à $customer->add().

C'est un piège classique lié à l'ordre d'exécution des méthodes de l'ObjectModel PrestaShop.

Pourquoi ça ne fonctionne pas après `add()`

La méthode add() de la classe Customer persiste l'objet en base de données au moment de l'appel. Toute modification de propriété effectuée après add() reste uniquement en mémoire — elle n'est jamais enregistrée en base, sauf si vous appelez ensuite update().

Voici le code incorrect que l'on rencontre fréquemment :

$customer = new Customer();
$customer->email = $mail;
$customer->firstname = $firstname;
$customer->lastname = $lastname;
$customer->passwd = $passwd;
$customer->active = 1;
$customer->add(); // ← INSERT en base ici

$customer->id_default_group = $group; // ❌ Trop tard, déjà en base

La solution est simple : définir id_default_group avant add(), et ne pas oublier le cast (int) pour sécuriser la valeur.

Solution complète et sécurisée

Voici une implémentation robuste, adaptée à PrestaShop 1.6 jusqu'à 8.x :

/**
 * Crée un compte client et l'assigne à un groupe spécifique.
 *
 * @param string $firstname
 * @param string $lastname
 * @param string $email
 * @param string $password
 * @param int    $groupId   ID du groupe par défaut souhaité
 * @return Customer|false
 */
public static function registerAccount($firstname, $lastname, $email, $password, $groupId)
{
    // Vérifier que le groupe existe
    if (!Group::getGroup((int) $groupId)) {
        return false;
    }

    // Vérifier que l'email n'est pas déjà utilisé
    if (Customer::customerExists($email)) {
        return false;
    }

    $customer = new Customer();
    $customer->firstname = pSQL($firstname);
    $customer->lastname  = pSQL($lastname);
    $customer->email     = pSQL($email);
    $customer->active    = 1;
    $customer->newsletter = 0;

    // ✅ Définir le groupe par défaut AVANT add()
    $customer->id_default_group = (int) $groupId;

    // Hashage du mot de passe (adapté à la version)
    if (version_compare(_PS_VERSION_, '1.7', '>=')) {
        // PrestaShop 1.7+ / 8.x : bcrypt via password_hash
        $customer->passwd = Tools::hash($password);
    } else {
        // PrestaShop 1.6 : MD5 avec salt (déprécié)
        $customer->passwd = md5(_COOKIE_KEY_ . $password);
    }

    if (!$customer->add()) {
        return false;
    }

    // Nettoyer les groupes par défaut puis assigner les bons
    $customer->cleanGroups();
    $customer->addGroups([
        (int) Configuration::get('PS_CUSTOMER_GROUP'), // Groupe "Client" standard
        (int) $groupId,
    ]);

    return $customer;
}

Points clés de cette implémentation

1. **`id_default_group` avant `add()`** : c'est le cœur de la solution. La propriété doit être définie avant la persistance en base.
1. **Cast `(int)`** : toujours caster `$groupId` en entier pour éviter les injections SQL et les comportements inattendus.
1. **`cleanGroups()` puis `addGroups()`** : cette combinaison est indispensable. `cleanGroups()` supprime toutes les associations existantes dans `ps_customer_group`, puis `addGroups()` réécrit proprement les appartenances. Sans `cleanGroups()`, le client peut se retrouver avec des groupes fantômes.
1. **Validation en amont** : on vérifie que le groupe existe et que l'email n'est pas déjà pris avant de créer quoi que ce soit.

Connexion automatique après inscription

Si votre formulaire doit connecter le client immédiatement après la création de son compte, voici la méthode propre :

// Après $customer->add() réussi
$context = Context::getContext();
$context->customer = $customer;
$context->cookie->id_customer = (int) $customer->id;
$context->cookie->customer_lastname = $customer->lastname;
$context->cookie->customer_firstname = $customer->firstname;
$context->cookie->passwd = $customer->passwd;
$context->cookie->logged = 1;
$context->cookie->email = $customer->email;
$context->cookie->is_guest = 0;

// Mettre à jour le panier si nécessaire
if ($context->cart->id) {
    $context->cart->id_customer = (int) $customer->id;
    $context->cart->update();
}

// Déclencher le hook pour les modules tiers
Hook::exec('actionAuthentication', ['customer' => $customer]);

Attention : ne manipulez jamais directement les cookies avec __set() sans définir aussi $context->customer. Certains modules et contrôleurs vérifient l'objet Customer du contexte, pas uniquement le cookie.

Hashage du mot de passe : l'évolution entre versions

Le hashage MD5 utilisé dans PrestaShop 1.6 est cryptographiquement obsolète. Voici l'évolution :

VersionMéthodeSécurité 1.6.x`md5(_COOKIE_KEY_ . $password)`❌ Faible 1.7.x`password_hash()` via `Tools::hash()`✅ Bcrypt 8.x`password_hash()` via Symfony✅ Bcrypt

Si vous migrez du code depuis PrestaShop 1.6, remplacez systématiquement le hashage MD5 par Tools::hash() ou par les méthodes natives de la classe Customer en 8.x.

Alternative propre en PrestaShop 8.x : utiliser les hooks

Plutôt que de créer une classe statique personnalisée, PrestaShop 8.x permet d'intercepter la création de compte via le hook actionCustomerAccountAdd :

public function hookActionCustomerAccountAdd(array $params)
{
    /** @var Customer $customer */
    $customer = $params['newCustomer'];

    // Lire le groupe souhaité depuis un champ personnalisé du formulaire
    $groupId = (int) Tools::getValue('customer_group');

    if ($groupId && Group::getGroup($groupId)) {
        $customer->id_default_group = $groupId;
        $customer->update();
        $customer->cleanGroups();
        $customer->addGroups([
            (int) Configuration::get('PS_CUSTOMER_GROUP'),
            $groupId,
        ]);
    }
}

Cette approche est plus maintenable car elle ne modifie pas le flux d'inscription natif et reste compatible avec les mises à jour de PrestaShop.

Erreurs fréquentes à éviter

• **Oublier `cleanGroups()`** : le client se retrouve membre de groupes non souhaités hérités de la configuration par défaut.
• **Ne pas caster en `(int)`** : risque d'injection ou de valeur vide qui assigne le groupe 0 (inexistant).
• **Confondre `id_default_group` et `addGroups()`** : le premier définit le groupe principal (utilisé pour le calcul des prix), le second gère les appartenances multiples. Les deux sont nécessaires.
• **Modifier `id_default_group` après `add()` sans appeler `update()`** : la modification reste en mémoire PHP et n'est jamais persistée.