> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Script d’action de base de données Create User et modèles

> Le script Create s’exécute lorsqu’un utilisateur s’inscrit au moyen de Universal Login ou lorsque vous créez un utilisateur au moyen de l’Auth0 Dashboard ou de la Management API.

Le script Create implémente la fonction définie lorsqu’un utilisateur est créé. Nous vous recommandons de nommer cette fonction `create`.

Ce script est facultatif. S’il est activé, lorsqu’un utilisateur s’inscrit au moyen de <Tooltip tip="Universal Login : votre application redirige vers Universal Login, hébergé sur l’Authorization Server d’Auth0, pour vérifier l’identité d’un utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Universal+Login">Universal Login</Tooltip> ou est créé au moyen du <Tooltip tip="Auth0 Dashboard : le principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip> ou de l’Auth0 <Tooltip tip="Auth0 Dashboard : le principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Management+API">Management API</Tooltip>, Auth0 exécute le script pour créer l’enregistrement utilisateur correspondant dans la base de données externe.

Lorsqu’un utilisateur est créé dans Auth0, Auth0 appelle une série de scripts :

1. [Get User](/docs/fr-ca/authenticate/database-connections/custom-db/templates/get-user) : vérifie que l’utilisateur n’existe pas déjà dans Auth0 ou dans la base de données externe.
2. Create : crée l’utilisateur dans la base de données externe.
3. [Login](/docs/fr-ca/authenticate/database-connections/custom-db/templates/login) : vérifie que l’utilisateur a bien été créé.

<div id="create-function">
  ## Fonction Create
</div>

La fonction `create` doit :

* Envoyer les données de profil de l’utilisateur à l’API de la base de données externe.
* Renvoyer une erreur si l’opération de création de l’utilisateur a échoué.

<div id="definition">
  ### Définition
</div>

La fonction `create` accepte deux paramètres et renvoie une fonction de rappel `callback` :

```js theme={null}
create(user, callback): function
```

| Paramètre  | Description                                                                                                                      |
| ---------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `user`     | Objet. Contient les [données du profil utilisateur](#user-object-parameter) provenant du processus de création de l’utilisateur. |
| `callback` | Fonction. Utilisée pour transmettre les données d’erreur dans le pipeline.                                                       |

Voici un pseudo-exemple en JavaScript montrant comment vous pourriez implémenter la fonction `create` :

```javascript lines expandable theme={null}
function create(user, callback) {
  // Envoyer les données du profil utilisateur à l'API de base de données externe
  let hashedPassword = hash(user.password);

  let options = {
    url: "https://example.com/api/create",
    body: {
      email: user.email,
      username: user.username,
      password: hashedPassword
    }
  };

  send(options, err => {
    // Retourner une erreur dans le callback si l'utilisateur existe déjà
    if (err && err.id === "USER_ALREADY_EXISTS") {
      return callback(new ValidationError("user_exists", "My custom error message."));
    } else if (err) {
      // Retourner une erreur dans le callback si une erreur s'est produite
      return callback(new Error("My custom error message."));
    }

    // Retourner la valeur `null` dans le callback si l'opération de création de l'utilisateur a réussi
    return callback(null);
  });
}
```

<div id="encryption">
  ### Chiffrement
</div>

Hachez la valeur du mot de passe à l’aide d’une bibliothèque de hachage cryptographique comme `bcrypt` afin d’éviter toute fuite de données potentielle. Évitez de consigner, de stocker ou de transmettre le mot de passe sous une forme non chiffrée.

Par exemple :

```js theme={null}
bcrypt.hash(password, 10, function (err, hash) {
    if (err) {
        return callback(err);
    } else {
        // Retourner le mot de passe haché
    }
});
```

<div id="callback-function">
  ## Fonction de rappel
</div>

La fonction `callback` prend un paramètre et retourne une fonction.

<div id="definition">
  ### Définition
</div>

```js theme={null}
callback(error): function
```

| Paramètre | Type  | Obligatoire | Description                    |
| --------- | ----- | ----------- | ------------------------------ |
| `error`   | Objet | Obligatoire | Contient des données d’erreur. |

<div id="validationerror-type-object">
  ### Objet de type ValidationError
</div>

L’objet de type d’erreur personnalisé `ValidationError` vous permet de transmettre des données qui seront affichées dans vos [journaux du tenant](/docs/fr-ca/deploy-monitor/logs).

Le constructeur `ValidationError` accepte jusqu’à deux paramètres :

```js theme={null}
new ValidationError(errorCode[, message]): ValidationError
```

| Paramètre   | Description                                                  |
| ----------- | ------------------------------------------------------------ |
| `errorCode` | (Obligatoire) String. Indique le type d’erreur.              |
| `message`   | (Facultatif) String. Contient des informations sur l’erreur. |

<div id="return-a-success">
  ### Renvoyer une réussite
</div>

Si la création de l’utilisateur a réussi, appelez la fonction de rappel `callback` et transmettez la valeur `null` au paramètre `error` :

```js theme={null}
return callback(null);
```

<div id="return-an-error">
  ### Renvoyer une erreur
</div>

Si une erreur survient, appelez la fonction de rappel et transmettez-lui les renseignements pertinents sur l’erreur dans le paramètre `error`.

Par exemple, vous pouvez renvoyer une erreur avec la valeur `user_exists` pour le paramètre `errorCode` :

```js wrap lines theme={null}
return callback(new ValidationError("user_exists", "My custom error message."));
```

Si vous le faites, Auth0 enregistre un événement de journal `fs` du tenant.

| Champ de l’événement du journal du tenant | Valeur                               |
| ----------------------------------------- | ------------------------------------ |
| **Code**                                  | `fs`                                 |
| **Événement**                             | Échec de l’inscription               |
| **Description**                           | `Mon message d’erreur personnalisé.` |

<div id="user-object-parameter">
  ## Paramètre de l’objet `user`
</div>

Le paramètre d’objet `user` contient un ensemble prédéfini de propriétés issues du processus de création de l’utilisateur :

| Propriété       | Description                                                                                                                                                                                                        |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `client_id`     | L’ID client de l’application Auth0 si l’utilisateur s’est inscrit par l’entremise de Universal Login, ou la clé API si l’utilisateur a été créé au moyen de l’Auth0 Dashboard ou de la Management API.             |
| `tenant`        | Le nom du tenant Auth0.                                                                                                                                                                                            |
| `email`         | L’adresse courriel de l’utilisateur.                                                                                                                                                                               |
| `password`      | Le mot de passe de l’utilisateur en texte brut.                                                                                                                                                                    |
| `username`      | Le nom d’utilisateur. Obligatoire seulement si le paramètre [**Requires Username**](/docs/fr-ca/authenticate/database-connections/require-username) est activé pour la connexion de base de données personnalisée. |
| `connection`    | Le nom de la connexion Auth0.                                                                                                                                                                                      |
| `user_metadata` | Contient les propriétés de l’objet `user_metadata` dans le profil Auth0 de l’utilisateur, si cet objet existe.                                                                                                     |
| `app_metadata`  | Contient les propriétés de l’objet `app_metadata` dans le profil Auth0 de l’utilisateur, si cet objet existe.                                                                                                      |

<div id="username-property">
  ### Propriété `username`
</div>

Si le paramètre [Requires Username](/docs/fr-ca/authenticate/database-connections/require-username) est activé pour votre connexion de base de données personnalisée, les scripts [Login](/docs/fr-ca/authenticate/database-connections/custom-db/templates/login) et [Get User](/docs/fr-ca/authenticate/database-connections/custom-db/templates/get-user) doivent prendre en charge la propriété `username` ; vous devriez donc l’enregistrer dans votre base de données externe.

<div id="user-and-app-metadata">
  ### Métadonnées utilisateur et d’application
</div>

Les propriétés `user_metadata` et `app_metadata` n’ont pas besoin d’être stockées dans votre base de données externe. Auth0 stocke automatiquement ces valeurs dans l’enregistrement de profil utilisateur créé en interne.

<div id="custom-sign-up-fields">
  ### Champs personnalisés d’inscription
</div>

Si vous [créez et utilisez des champs personnalisés](/docs/fr-ca/libraries/custom-signup#using-the-api) lors de l’inscription, ils seront inclus dans l’objet `user`. Par exemple :

```json theme={null}
{
    client_id: "8tkMo6n1QkKOazqPcSQd8wU7LzXYibgK",
    tenant: "{yourAuth0Tenant}",
    email: "username@domain.com",
    password: "mySuperSecretPassword123",
    username: "username456",
    user_metadata: {
        "language": "en"
    },
    app_metadata: {
        "plan": "full"
    }
}
```

<div id="language-specific-script-examples">
  ## Exemples de scripts par langage
</div>

Auth0 fournit des exemples de scripts pour les langages/technologies suivants :

<CodeGroup>
  ```javascript JavaScript lines expandable theme={null}
  function create(user, callback) {
    // Ce script doit créer une entrée utilisateur dans votre base de données existante. Il sera
    // exécuté lorsqu'un utilisateur tente de s'inscrire ou lorsqu'un utilisateur est créé
    // via le tableau de bord Auth0 ou l'API Management.
    // Une fois ce script terminé, le script Login sera
    // exécuté immédiatement après, afin de vérifier que l'utilisateur a été créé
    // avec succès.
    //
    // L'objet user contiendra toujours les propriétés suivantes :
    // * email : le courriel de l'utilisateur
    // * password : le mot de passe saisi par l'utilisateur, en clair
    // * tenant : le nom de ce compte Auth0
    // * client_id : l'identifiant client de l'application où l'utilisateur s'est inscrit, ou
    //               la clé API si créé via l'API Management ou le tableau de bord Auth0
    // * connection : le nom de cette connexion de base de données
    //
    // Ce script peut se terminer de trois façons :
    // 1. Un utilisateur a été créé avec succès
    //     callback(null);
    // 2. Cet utilisateur existe déjà dans votre base de données
    //     callback(new ValidationError("user_exists", "my error message"));
    // 3. Une erreur est survenue lors de la tentative d'accès à votre base de données
    //     callback(new Error("my error message"));
    const msg = 'Please implement the Create script for this database connection ' +
      'at https://manage.auth0.com/#/connections/database';
    return callback(new Error(msg));
  }
  ```

  ```javascript ASP.Net MVC3 lines expandable theme={null}
  // Pour ASP.NET Membership Provider (MVC3 - Universal Providers)
  function create(user, callback) {
    const crypto = require('crypto');
    const sqlserver = require('tedious@1.11.0');
    const Connection = sqlserver.Connection;
    const Request = sqlserver.Request;
    const TYPES = sqlserver.TYPES;
    const connection = new Connection({
      userName: 'the username',
      password: 'the password',
      server: 'the server',
      options: {
        database: 'the db name',
        encrypt: true,
        // Required to retrieve userId needed for Membership entity creation
        rowCollectionOnRequestCompletion: true
      }
    });
    const applicationId = 'your-application-id-goes-here';
    /**
     * hashPassword
     *
     * This function creates a hashed version of the password to store in the database.
     *
     * @password  {[string]}      the password entered by the user
     * @return    {[string]}      the hashed password
     */
    function hashPassword(password, salt) {
      // the default implementation uses HMACSHA256 and since Key length is 64
      // and default salt is 16 bytes, Membership will fill the buffer repeating the salt
      const key = Buffer.concat([salt, salt, salt, salt]);
      const hmac = crypto.createHmac('sha256', key);
      hmac.update(Buffer.from(password, 'ucs2'));
      return hmac.digest('base64');
    }
    connection.on('debug', function(text) {
      // if you have connection issues, uncomment this to get more detailed info
      // console.log(text);
    }).on('errorMessage', function(text) {
      // this will show any errors when connecting to the SQL database or with the SQL statements
      console.log(JSON.stringify(text));
    });
    connection.on('connect', function(err) {
      if (err) {
        return callback(err);
      }
      createMembershipUser(user, function(err, user) {
        if (err) return callback(err); // this will return a 500
        if (!user) return callback(); // this will return a 401
        callback(null, user);
      });
    });
    function createMembershipUser(user, callback) {
      const userData = {
        UserName: user.email,
        ApplicationId: applicationId
      };
      const createUser =
        'INSERT INTO Users (UserName, LastActivityDate, ApplicationId, UserId, IsAnonymous) ' +
        'OUTPUT Inserted.UserId ' +
        'VALUES (@UserName, GETDATE(), @ApplicationId, NEWID(), \'false\')';
      const createUserQuery = new Request(createUser, function(err, rowCount, rows) {
        if (err) return callback(err);
        // No records added
        if (rowCount === 0) return callback(null);
        const userId = rows[0][0].value;
        const salt = crypto.randomBytes(16);
        const membershipData = {
          ApplicationId: applicationId,
          Email: user.email,
          Password: hashPassword(user.password, salt),
          PasswordSalt: salt.toString('base64'),
          UserId: userId
        };
        const createMembership =
          'INSERT INTO Memberships (ApplicationId, UserId, Password, PasswordFormat, ' +
          'PasswordSalt, Email, isApproved, isLockedOut, CreateDate, LastLoginDate, ' +
          'LastPasswordChangedDate, LastLockoutDate, FailedPasswordAttemptCount, ' +
          'FailedPasswordAttemptWindowStart, FailedPasswordAnswerAttemptCount, ' +
          'FailedPasswordAnswerAttemptWindowsStart) ' +
          'VALUES ' +
          '(@ApplicationId, @UserId, @Password, 1, @PasswordSalt, ' +
          '@Email, \'false\', \'false\', GETDATE(), GETDATE(), GETDATE(), GETDATE(), 0, 0, 0, 0)';
        const createMembershipQuery = new Request(createMembership, function(err, rowCount) {
          if (err) return callback(err);
          if (rowCount === 0) return callback(null);
          callback(null, rowCount > 0);
        });
        createMembershipQuery.addParameter('ApplicationId', TYPES.VarChar, membershipData.ApplicationId);
        createMembershipQuery.addParameter('Email', TYPES.VarChar, membershipData.Email);
        createMembershipQuery.addParameter('Password', TYPES.VarChar, membershipData.Password);
        createMembershipQuery.addParameter('PasswordSalt', TYPES.VarChar, membershipData.PasswordSalt);
        createMembershipQuery.addParameter('UserId', TYPES.VarChar, membershipData.UserId);
        connection.execSql(createMembershipQuery);
      });
      createUserQuery.addParameter('UserName', TYPES.VarChar, userData.UserName);
      createUserQuery.addParameter('ApplicationId', TYPES.VarChar, userData.ApplicationId);
      connection.execSql(createUserQuery);
    }
  }
  ```

  ```javascript ASP.Net MVC4 lines expandable theme={null}
  // Pour ASP.NET Membership Provider (MVC4 - Simple Membership)
  function create(user, callback) {
    const crypto = require('crypto');
    const sqlserver = require('tedious@1.11.0');
    const Connection = sqlserver.Connection;
    const Request = sqlserver.Request;
    const TYPES = sqlserver.TYPES;
    const connection = new Connection({
      userName: 'the username',
      password: 'the password',
      server: 'the server',
      options: {
        database: 'the db name',
        encrypt: true,
        // Required to retrieve userId needed for Membership entity creation
        rowCollectionOnRequestCompletion: true
      }
    });
    /**
     * hashPassword
     *
     * Cette fonction hache un mot de passe à l’aide de l’algorithme HMAC SHA256.
     *
     * @password    {[string]}    mot de passe à hacher
     * @salt        {[string]}    salt à utiliser dans le processus de hachage
     * @callback    {[function]}  callback à appeler après le hachage du mot de passe
     */
    function hashPassword(password, salt, callback) {
      const iterations = 1000;
      const passwordHashLength = 32;
      crypto.pbkdf2(password, salt, iterations, passwordHashLength, 'sha1', function (err, hashed) {
        if (err) return callback(err);
        const result = Buffer.concat([Buffer.from([0], 1), salt, Buffer.from(hashed, 'binary')]);
        const resultBase64 = result.toString('base64');
        callback(null, resultBase64);
      });
    }
    connection.on('debug', function (text) {
      // si vous avez des problèmes de connexion, décommentez ceci pour obtenir des informations plus détaillées
      // console.log(text);
    }).on('errorMessage', function (text) {
      // ceci affichera toutes les erreurs lors de la connexion à la base de données SQL ou avec les instructions SQL
      console.log(JSON.stringify(text));
    });
    connection.on('connect', function (err) {
      if (err) return callback(err);
      const createUser =
        'INSERT INTO UserProfile (UserName) ' +
        'OUTPUT Inserted.UserId ' +
        'VALUES (@UserName)';
      const createUserQuery = new Request(createUser, function (err, rowCount, rows) {
        if (err || rowCount === 0) return callback(err);
        const userId = rows[0][0].value;
        const salt = crypto.randomBytes(16);
        const createMembership =
          'INSERT INTO webpages_Membership ' +
          '(UserId, CreateDate, IsConfirmed, PasswordFailuresSinceLastSuccess, Password, PasswordSalt) ' +
          'VALUES ' +
          '(@UserId, GETDATE(), \'false\', 0, @Password, \'\')';
        const createMembershipQuery = new Request(createMembership, function (err, rowCount) {
          if (err || rowCount === 0) return callback(err);
          callback(null, rowCount > 0);
        });
        hashPassword(user.password, salt, function (err, hashedPassword) {
          if (err) return callback(err);
          createMembershipQuery.addParameter('Password', TYPES.VarChar, hashedPassword);
          createMembershipQuery.addParameter('PasswordSalt', TYPES.VarChar, salt.toString('base64'));
          createMembershipQuery.addParameter('UserId', TYPES.VarChar, userId);
          connection.execSql(createMembershipQuery);
        });
      });
      createUserQuery.addParameter('UserName', TYPES.VarChar, user.email);
      connection.execSql(createUserQuery);
    });
  }
  ```

  ```javascript MongoDB lines expandable theme={null}
  function create(user, callback) {
    const bcrypt = require('bcrypt');
    const MongoClient = require('mongodb@3.1.4').MongoClient;
    const client = new MongoClient('mongodb://user:pass@mymongoserver.com');
    client.connect(function (err) {
      if (err) return callback(err);
      const db = client.db('db-name');
      const users = db.collection('users');
      users.findOne({ email: user.email }, function (err, withSameMail) {
        if (err || withSameMail) {
          client.close();
          return callback(err || new Error('the user already exists'));
        }
        bcrypt.hash(user.password, 10, function (err, hash) {
          if (err) {
            client.close();
            return callback(err);
          }
          user.password = hash;
          users.insert(user, function (err, inserted) {
            client.close();
            if (err) return callback(err);
            callback(null);
          });
        });
      });
    });
  }
  ```

  ```javascript MySQL lines expandable theme={null}
  function create(user, callback) {
    const mysql = require('mysql');
    const bcrypt = require('bcrypt');
    const connection = mysql({
      host: 'localhost',
      user: 'me',
      password: 'secret',
      database: 'mydb'
    });
    connection.connect();
    const query = 'INSERT INTO users SET ?';
    bcrypt.hash(user.password, 10, function(err, hash) {
      if (err) return callback(err);
      const insert = {
        password: hash,
        email: user.email
      };
      connection.query(query, insert, function(err, results) {
        if (err) return callback(err);
        if (results.length === 0) return callback();
        callback(null);
      });
    });
  }
  ```

  ```javascript PostgreSQL lines expandable theme={null}
  function create(user, callback) {
    //cet exemple utilise la bibliothèque « pg »
    //pour en savoir plus : https://github.com/brianc/node-postgres
    const bcrypt = require('bcrypt');
    const postgres = require('pg');
    const conString = 'postgres://user:pass@localhost/mydb';
    postgres.connect(conString, function (err, client, done) {
      if (err) return callback(err);
      bcrypt.hash(user.password, 10, function (err, hashedPassword) {
        if (err) return callback(err);
        const query = 'INSERT INTO users(email, password) VALUES ($1, $2)';
        client.query(query, [user.email, hashedPassword], function (err, result) {
          // REMARQUE : appelez toujours `done()` ici pour fermer
          // la connexion à la base de données
          done();
          return callback(err);
        });
      });
    });
  }
  ```

  ```javascript SQL Server lines expandable theme={null}
  function create(user, callback) {
    //cet exemple utilise la bibliothèque « tedious »
    //plus d’information ici : http://pekim.github.io/tedious/index.html
    const bcrypt = require('bcrypt');
    const sqlserver = require('tedious@1.11.0');
    const Connection = sqlserver.Connection;
    const Request = sqlserver.Request;
    const TYPES = sqlserver.TYPES;
    const connection = new Connection({
      userName:  'test',
      password:  'test',
      server:    'localhost',
      options:  {
        database: 'mydb'
      }
    });
    const query = 'INSERT INTO dbo.Users SET Email = @Email, Password = @Password';
    connection.on('debug', function(text) {
      console.log(text);
    }).on('errorMessage', function(text) {
      console.log(JSON.stringify(text, null, 2));
    }).on('infoMessage', function(text) {
      console.log(JSON.stringify(text, null, 2));
    });
    connection.on('connect', function (err) {
      if (err) return callback(err);
      const request = new Request(query, function (err, rows) {
        if (err) return callback(err);
        callback(null);
      });
      bcrypt.hash(user.password, 10, function(err, hash) {
        if (err) return callback(err);
        request.addParameter('Email', TYPES.VarChar, user.email);
        request.addParameter('Password', TYPES.VarChar, hash);
        connection.execSql(request);
      });
    });
  }
  ```

  ```javascript Azure SQL Database lines expandable theme={null}
  function create (user, callback) {
    //cet exemple utilise la bibliothèque « tedious »
    //plus d’informations ici : http://pekim.github.io/tedious/index.html
    var Connection = require('tedious@1.11.0').Connection;
    var Request = require('tedious@1.11.0').Request;
    var TYPES = require('tedious@1.11.0').TYPES;
    var bcrypt = require('bcrypt');
    var connection = new Connection({
      userName:  'your-user@your-server-id.database.windows.net',
      password:  'the-password',
      server:    'your-server-id.database.windows.net',
      options:  {
        database: 'mydb',
        encrypt:  true
      }
    });
    var query = "INSERT INTO users (Email, Password) VALUES (@Email, @Password)";
    connection.on('debug', function(text) {
      // Décommentez la ligne suivante pour activer les messages de débogage
      // console.log(text);
    }).on('errorMessage', function(text) {
      console.log(JSON.stringify(text, null, 2));
    }).on('infoMessage', function(text) {
      // Décommentez la ligne suivante pour activer les messages d’information
      // console.log(JSON.stringify(text, null, 2));
    });
    connection.on('connect', function (err) {
      if (err) { return callback(err); }
      var request = new Request(query, function (err, rows) {
        if (err) { return callback(err); }
        console.log('rows: ' + rows);
        callback(null);
      });
      bcrypt.hash(user.password, 10, function (err, hashedPassword) {
        if (err) { return callback(err); }
        request.addParameter('Email', TYPES.VarChar, user.email);
        request.addParameter('Password', TYPES.VarChar, hashedPassword);
        connection.execSql(request);
      });
    });
  }
  ```

  ```javascript Basic Auth request lines theme={null}
  function create(user, callback) {
    const request = require('request');
    request.post({
      url: 'https://myserviceurl.com/users',
      json: user
      //pour plus d’options, consultez :
      //https://github.com/mikeal/request#requestoptions-callback
    }, function(err, response, body) {
      if (err) return callback(err);
      callback(null);
    });
  }
  ```
</CodeGroup>

<div id="troubleshoot">
  ## Résolution des problèmes
</div>

Si vous ne parvenez pas à créer un utilisateur dans votre référentiel d’utilisateurs externe ou dans Auth0 :

1. Vérifiez les instructions `console.log()` dans les [journaux en temps réel d’Actions](/docs/fr-ca/customize/actions/actions-real-time-logs).
2. Repérez l’utilisateur dans votre ancienne base de données et supprimez-le au besoin. Si l’état partiel de l’utilisateur se trouve dans Auth0, utilisez le point de terminaison [Supprimer un utilisateur](https://auth0.com/docs/api/management/v2#!/Users/delete_users_by_id) ou le point de terminaison [Supprimer un utilisateur d’une connexion](https://auth0.com/docs/api/management/v2#!/Connections/delete_users_by_email) de la Management API.
3. Assurez-vous que le **mode d’importation** est désactivé, puis configurez le script Create.