> ## 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.
> Décrit comment tester vos connexions de base de données personnalisées dans le tableau de bord Auth0.
# Tester les connexions de base de données personnalisées
Si vous utilisez la structure de base de données hébergée par Auth0 pour stocker vos utilisateurs, vous pouvez tester la connexion en authentifiant des utilisateurs dans le même tenant ou dans un tenant distinct.
## Tester lorsque l’importation des utilisateurs vers Auth0 est activée
Lorsque l’importation des utilisateurs est activée, les utilisateurs sont migrés progressivement de votre répertoire d’utilisateurs externe vers le répertoire d’utilisateurs d’Auth0. Pendant ce processus, les utilisateurs seront authentifiés auprès du répertoire externe la première fois qu’ils ouvriront une session avec succès. Toutes les tentatives de connexion suivantes seront effectuées auprès du répertoire d’utilisateurs d’Auth0. Pour en savoir plus, consultez la section sur les migrations automatiques dans [Import and Export Users](/fr-CA/docs/manage-users/user-migration).
### Créer un tenant et une application de test
1. Utilisez le tableau de bord Auth0 pour [créer un nouveau tenant](/fr-CA/docs/get-started/auth0-overview/create-tenants).
2. Accédez à [Applications > Applications](https://manage.auth0.com/#/applications/applications) et créez une application [Machine-to-Machine](https://manage.auth0.com/#/applications/applications/create).
Vous devez prendre en note le **Client ID** et le **Client Secret** lorsque vous créez les scripts de base de données personnalisés. Vous devez également prendre en note le **Client ID** pour activer les scopes dans l’API de gestion.
3. Activez à la fois les types d’autorisation **Password** et **Client Credential** pour cette application (les deux doivent être activés pour ce test).
4. Pour autoriser votre application, accédez à [Applications > APIs](https://manage.auth0.com/#/apis).
5. Sélectionnez **API de gestion**.
6. Sous l’onglet **Machine-to-Machine Applications**, utilisez le bouton bascule pour autoriser votre application de test.
7. Sélectionnez le menu déroulant pour activer les scopes suivants de l’API de gestion Auth0 :
* `read:users`
* `update:users`
* `delete:users`
* `create:users`
* `read:users_app_metadata`
* `update:users_app_metadata`
* `create:users_app_metadata`
### Créer des connexions de base de données de test
Après avoir créé un tenant et une application dans le Dashboard, créez une connexion de base de données source et une connexion de base de données cible.
1. Accédez à [Authentication > Database](https://manage.auth0.com/#/connections/database) pour créer une nouvelle connexion de base de données qui servira de source.
2. Donnez un nom à votre connexion source de test, activez **Requires Username**, puis sélectionnez **Create**.
Vous pouvez créer des utilisateurs pour vos tests en accédant à [User Management > Users](https://manage.auth0.com/#/users). Après avoir sélectionné **Create** **Users** et rempli les champs requis, sélectionnez la base de données source dans le champ **Connection**.
3. Créez une deuxième base de données qui servira de cible avec la même configuration qu’à l’étape 2.
Vous pouvez définir la **Password Policy** sur **Non-empty password required** dans les bases de données source et cible afin d’utiliser des mots de passe simples dans vos tests.
4. Dans votre base de données cible, passez à la vue **Custom Database** et activez **Use my own database**.
Si vous voulez faire des tests avec Organizations et vos bases de données personnalisées, activez **Context object in database scripts**.
5. Passez à la vue **Settings** et activez **Import Users to Auth0**.
6. Passez à la vue **Custom Database**, puis repérez la section **Database settings**. Ajoutez les renseignements suivants à partir de votre base de données source créée à l’étape 1 :
| Key | Value |
| ----------------- | ------------------------------------------------------------------------- |
| `client_id` | ID client de l’application que vous avez créée. |
| `client_secret` | Secret client de l’application que vous avez créée. |
| `auth0_domain` | Le nom de votre tenant dans le domaine Auth0 : `yourTenant.us.auth0.com`. |
| `source_database` | Nom de la connexion source. |
7. Mettez à jour les scripts d’action de base de données [Login](/fr-CA/docs/authenticate/database-connections/custom-db/test-custom-database-connections#login) et [Get User](/fr-CA/docs/authenticate/database-connections/custom-db/test-custom-database-connections#get-user) dans votre base de données cible. Pour en savoir plus sur les pratiques exemplaires pour l’utilisation des scripts d’action de base de données, consultez [Custom Database Connection and Action Scripts Best Practices](/fr-CA/docs/authenticate/database-connections/custom-db/custom-database-connections-scripts).
8. Sélectionnez **Save and Try** pour chaque script. Vous devriez surveiller la sortie `console.log` dans les journaux en temps réel d’Actions. Pour en savoir plus, consultez [Actions Real-time Logs](/fr-CA/docs/customize/actions/actions-real-time-logs).
9. Sélectionnez **Try Connection** pour tester la connexion en direct.
## Tester sans activer Import Users
1. Répétez les étapes de [Créer un locataire et une application de test](/fr-CA/docs/authenticate/database-connections/custom-db/test-custom-database-connections#create-a-test-tenant-and-application).
2. Créez une connexion à une base de données de test.
3. Assurez-vous que l’option **Import Users to Auth0** est désactivée dans les paramètres de votre base de données source. Les utilisateurs s’authentifieront auprès du répertoire d’utilisateurs externe à chaque tentative de connexion.
4. Mettez à jour tous les scripts d’action de la base de données à l’aide des exemples ci-dessous.
### Script Get User
Le script [Get User](/fr-CA/docs/authenticate/database-connections/custom-db/templates/get-user) implémente une fonction exécutable qui détermine l’état actuel d’un utilisateur.
Lorsque **Import Users to Auth0** est activé, le script Get User s’exécute lorsqu’un utilisateur tente de s’inscrire pour vérifier si cet utilisateur existe déjà dans le répertoire d’utilisateurs externe.
Le script Get User s’exécute aussi lorsqu’un utilisateur tente de :
* Modifier l’adresse courriel d’un utilisateur ([Change Email](/fr-CA/docs/authenticate/database-connections/custom-db/templates/change-email) script)
* Se connecter ([Login](/fr-CA/docs/authenticate/database-connections/custom-db/templates/login) script)
* Modifier le mot de passe d’un utilisateur ([Change Password](/fr-CA/docs/authenticate/database-connections/custom-db/templates/change-password) script)
Lorsque **Import Users to Auth0** est désactivé, le script Get User s’exécute lorsqu’un utilisateur tente de s’inscrire pour vérifier si cet utilisateur existe déjà dans le répertoire d’utilisateurs externe. Si l’utilisateur existe déjà dans le répertoire d’utilisateurs externe, le script Create ne sera pas exécuté.
Le script Get User s’exécute aussi lorsqu’un utilisateur tente de :
* Créer un utilisateur ([Create](/fr-CA/docs/authenticate/database-connections/custom-db/templates/create) script)
* Modifier l’adresse courriel d’un utilisateur ([Change Email](/fr-CA/docs/authenticate/database-connections/custom-db/templates/change-email) script)
* Modifier le mot de passe d’un utilisateur ([Change Password](/fr-CA/docs/authenticate/database-connections/custom-db/templates/change-password) script)
#### Exemple
```js lines expandable theme={null}
async function getUser(user, context, callback) {
log(`Script started.`);
log(`Requesting an Access Token from "${configuration.auth0_domain}".`);
let accessToken = await getAccessToken();
accessToken = accessToken.access_token;
if (!accessToken) return log(`Failed to get an Access Token from "${configuration.auth0_domain}".`, true);
log(`The Access Token is available. Searching for user "${user}" in "${configuration.source_database}"`);
user = user.toLowerCase();
const searchQuery = encodeURI(`identities.connection:"${configuration.source_database}"+AND+(email:${user} OR username:${user})`);
var options = {
method: `GET`,
url: `https://${configuration.auth0_domain}/api/v2/users?q=${searchQuery}`,
headers: {
Authorization: `Bearer ${accessToken}`,
}
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
let search_results = JSON.parse(response.body);
let profile = null;
if (search_results.length > 0) {
log(`A user "${user}" is FOUND in "${configuration.source_database}" database.`);
profile = {
user_id: search_results[0].user_id.toString(),
nickname: search_results[0].nickname,
username: search_results[0].username,
email: search_results[0].email
};
} else {
log(`A user "${user}" is NOT FOUND in "${configuration.source_database}" database.`);
}
log(`Script completed!`);
return callback(null, profile);
});
/* -- OBTENIR UN JETON D'ACCÈS VIA LES IDENTIFIANTS CLIENT -- */
async function getAccessToken() {
var options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: {
"Content-Type": `application/x-www-form-urlencoded`,
},
form: {
grant_type: `client_credentials`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
audience: `https://${configuration.auth0_domain}/api/v2/`
},
json: true
};
return new Promise(function (resolve) {
request(options, function (error, response) {
resolve(error || response.body);
});
});
}
/* -- JOURNALISATION -- */
function log(message, error = false) {
const script_name = `GET USER`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
### Script de connexion
Le script [Login](/fr-CA/docs/authenticate/database-connections/custom-db/templates/login) implémente une fonction exécutable qui authentifie un utilisateur lorsqu’il ouvre une session. Si l’utilisateur existe dans la base de données cible (Auth0), il l’authentifie à l’aide de cet enregistrement. Sinon, il authentifie l’utilisateur à l’aide de son enregistrement dans la base de données source (externe).
#### Exemple
```javascript lines expandable theme={null}
function login(usernameOrEmail, password, context, callback) {
log(`Script started.`);
const jwt = require('jsonwebtoken');
const options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: { "Content-Type": `application/x-www-form-urlencoded` },
json: true,
form: {
grant_type: `http://auth0.com/oauth/grant-type/password-realm`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
username: usernameOrEmail,
password: password,
realm: `${configuration.source_database}`
}
};
request(options, function (error, response, body) {
log(`Attempting to authenticate a user "${usernameOrEmail}" against "${configuration.source_database}" database in "${configuration.auth0_domain}" tenant.`);
if (error) return log(`Cannot connect to "${configuration.auth0_domain}" database.`, true);
if (response.statusCode !== 200) {
console.log(`LOGIN: (ERROR) ${response.body.error_description}`);
return callback(new WrongUsernameOrPasswordError(usernameOrEmail, `LOGIN: (ERROR) ${response.body.error_description}`));
}
log(`Successfuly authenticated user "${usernameOrEmail}" against "${configuration.source_database}" database in "${configuration.auth0_domain}" tenant.`);
const decoded_id_token = jwt.decode(body.id_token);
const profile = {
user_id: decoded_id_token.sub,
nickname: decoded_id_token.nickname,
username: decoded_id_token.username,
email: decoded_id_token.email
};
log(`Script completed.`);
return callback(null, profile);
});
/* -- JOURNALISATION -- */
function log(message, error = false) {
const script_name = `LOGIN`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
### Script de création
Le [script de création](/fr-CA/docs/authenticate/database-connections/custom-db/templates/create) contient une fonction exécutable qui crée un enregistrement utilisateur correspondant dans la base de données externe lorsqu’un utilisateur s’inscrit au moyen de Universal Login, ou est créé dans le tableau de bord Auth0 ou à l’aide de l’API de gestion d’Auth0.
#### Exemple
```js lines expandable theme={null}
async function create(user, context, callback) {
log(`Script started.`);
log(`Requesting an Access Token from "${configuration.auth0_domain}".`);
let accessToken = await getAccessToken();
if (!accessToken.access_token) return log(`Failed to get an Access Token from "${configuration.auth0_domain}".`, true);
accessToken = accessToken.access_token;
log(`The Access Token is available. Attempting to create a user "${user.email}" in "${configuration.source_database}"`);
const options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/api/v2/users`,
headers: {
Authorization: `Bearer ${accessToken}`,
"Content-Type": `application/x-www-form-urlencoded`
},
form: {
connection: configuration.source_database,
email: user.email,
password: user.password,
username: user.username
},
json: true
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
switch (response.statusCode) {
case 201:
log(`The user "${user.email}" is successfuly created in "${configuration.source_database}" database.`);
return callback(null);
case 409:
return callback(new ValidationError(`user_exists`, `The user already exists in "${configuration.source_database}" database.`));
default:
return log(`Failed to create a user "${user.email}" in "${configuration.source_database}" database. Error: "${response.statusCode}, ${response.body.message}"`, true);
}
});
/* -- OBTENIR UN JETON D'ACCÈS VIA L'IDENTIFIANT CLIENT -- */
async function getAccessToken() {
var options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: {
"Content-Type": `application/x-www-form-urlencoded`,
},
form: {
grant_type: `client_credentials`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
audience: `https://${configuration.auth0_domain}/api/v2/`
},
json: true
};
return new Promise(function (resolve) {
request(options, function (error, response) {
resolve(error || response.body);
});
});
}
/* -- JOURNALISATION -- */
function log(message, error = false) {
const script_name = `CREATE`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
### Script de suppression
Le [script de suppression](/fr-CA/docs/authenticate/database-connections/custom-db/templates/delete) exécute une fonction qui supprime un utilisateur d’Auth0 et de la base de données externe en une seule opération lorsque l’utilisateur est supprimé dans le tableau de bord Auth0 ou à l’aide de l’API de gestion Auth0.
#### Exemple
```js lines expandable theme={null}
async function deleteUser(user, context, callback) {
log(`Script started.`);
log(`Requesting an Access Token from "${configuration.auth0_domain}".`);
let accessToken = await getAccessToken();
if (!accessToken.access_token) return log(`Failed to get an Access Token from "${configuration.auth0_domain}".`, true);
accessToken = accessToken.access_token;
log(`The Access Token is available. Attempting to delete a user "${user}" from "${configuration.source_database}"`);
const options = {
method: `DELETE`,
url: `https://${configuration.auth0_domain}/api/v2/users/${user}`,
headers: {
Authorization: `Bearer ${accessToken}`,
"Content-Type": `application/x-www-form-urlencoded`
},
json: true
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
switch (response.statusCode) {
case 204:
log(`The user "${user}" is successfuly deleted from "${configuration.source_database}" database.`);
return callback(null);
default:
return log(`Failed to delete a user "${user}" from "${configuration.source_database}" database. Error: "${response.statusCode}, ${response.body.message}"`, true);
}
});
/* -- OBTENIR UN JETON D'ACCÈS VIA L'IDENTIFIANT CLIENT -- */
async function getAccessToken() {
var options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: {
"Content-Type": `application/x-www-form-urlencoded`,
},
form: {
grant_type: `client_credentials`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
audience: `https://${configuration.auth0_domain}/api/v2/`
},
json: true
};
return new Promise(function (resolve) {
request(options, function (error, response) {
resolve(error || response.body);
});
});
}
/* -- JOURNALISATION -- */
function log(message, error = false) {
const script_name = `DELETE`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
### Script de vérification
Le [script de vérification](/fr-CA/docs/authenticate/database-connections/custom-db/templates/verify) implémente une fonction exécutable qui met à jour l’état de vérification de l’adresse courriel d’un utilisateur dans la base de données externe lorsque l’utilisateur clique sur le lien dans le courriel de vérification envoyé par Auth0.
#### Exemple
```js lines expandable theme={null}
async function verify(user, context, callback) {
log(`Script started.`);
log(`Requesting an Access Token from "${configuration.auth0_domain}".`);
let accessToken = await getAccessToken();
if (!accessToken.access_token) return log(`Failed to get an Access Token from "${configuration.auth0_domain}".`, true);
accessToken = accessToken.access_token;
log(`The Access Token is available. Searching for user "${user}" in "${configuration.source_database}"`);
user = user.toLowerCase();
const searchQuery = encodeURI(`identities.connection:"${configuration.source_database}"+AND+(email:${user} OR username:${user})`);
var options = {
method: `GET`,
url: `https://${configuration.auth0_domain}/api/v2/users?q=${searchQuery}`,
headers: {
Authorization: `Bearer ${accessToken}`,
}
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
let search_results = JSON.parse(response.body);
if (search_results.length > 0) {
log(`A user "${user}" is found in "${configuration.source_database}" database.`);
const user_id = search_results[0].user_id.toString();
log(`Attempting to mark user "${user_id}" as verified in "${configuration.source_database}" database`);
const options = {
method: `PATCH`,
url: `https://${configuration.auth0_domain}/api/v2/users/${user_id}`,
headers: {
Authorization: `Bearer ${accessToken}`,
"Content-Type": `application/x-www-form-urlencoded`
},
form: {
email_verified: true,
},
json: true
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
switch (response.statusCode) {
case 200:
log(`The user "${user}" is marked as verified in "${configuration.source_database}" database.`);
return callback(null, true);
default:
return log(`Failed to mark a user "${user}" as verified in "${configuration.source_database}" database. Error: "${response.statusCode}, ${response.body.message}"`, true);
}
});
} else {
log(`A user "${user}" is not found in "${configuration.source_database}" database. Unable to verify.`, true);
}
});
/* -- OBTENIR UN JETON D'ACCÈS VIA L'IDENTIFIANT CLIENT -- */
async function getAccessToken() {
var options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: {
"Content-Type": `application/x-www-form-urlencoded`,
},
form: {
grant_type: `client_credentials`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
audience: `https://${configuration.auth0_domain}/api/v2/`
},
json: true
};
return new Promise(function (resolve) {
request(options, function (error, response) {
resolve(error || response.body);
});
});
}
/* -- JOURNALISATION -- */
function log(message, error = false) {
const script_name = `VERIFY`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
### Script de changement de mot de passe
Le [script de changement de mot de passe](/fr-CA/docs/authenticate/database-connections/custom-db/templates/change-password) implémente une fonction exécutable qui met à jour le mot de passe d’un utilisateur dans la base de données externe lorsqu’un processus de changement de mot de passe est lancé depuis le tableau de bord Auth0 ou l’API de gestion Auth0.
#### Exemple
```js lines expandable theme={null}
async function changePassword(user, newPassword, context, callback) {
log(`Script started.`);
log(`Requesting an Access Token from "${configuration.auth0_domain}".`);
let accessToken = await getAccessToken();
if (!accessToken.access_token) return log(`Failed to get an Access Token from "${configuration.auth0_domain}".`, true);
accessToken = accessToken.access_token;
log(`The Access Token is available. Searching for user "${user}" in "${configuration.source_database}" database.`);
user = user.toLowerCase();
const searchQuery = encodeURI(`identities.connection:"${configuration.source_database}"+AND+(email:${user} OR username:${user})`);
var options = {
method: `GET`,
url: `https://${configuration.auth0_domain}/api/v2/users?q=${searchQuery}`,
headers: {
Authorization: `Bearer ${accessToken}`,
}
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
let search_results = JSON.parse(response.body);
if (search_results.length > 0) {
log(`A user "${user}" is found in "${configuration.source_database}" database.`);
const user_id = search_results[0].user_id.toString();
log(`Attempting to change password for user "${user_id}" in "${configuration.source_database}" database.`);
const options = {
method: `PATCH`,
url: `https://${configuration.auth0_domain}/api/v2/users/${user_id}`,
headers: {
Authorization: `Bearer ${accessToken}`,
"Content-Type": `application/x-www-form-urlencoded`
},
form: {
password: newPassword,
},
json: true
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
switch (response.statusCode) {
case 200:
log(`The user "${user}" password successfully changed in "${configuration.source_database}" database.`);
return callback(null, true);
default:
return log(`Failed to change password for "${user}" in "${configuration.source_database}" database. Error: "${response.statusCode}, ${response.body.message}"`, true);
}
});
} else {
log(`A user "${user}" is not found in "${configuration.source_database}" database. Unable to change password.`, true);
}
});
/* -- OBTENIR UN JETON D'ACCÈS VIA L'IDENTIFIANT CLIENT -- */
async function getAccessToken() {
var options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: {
"Content-Type": `application/x-www-form-urlencoded`,
},
form: {
grant_type: `client_credentials`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
audience: `https://${configuration.auth0_domain}/api/v2/`
},
json: true
};
return new Promise(function (resolve) {
request(options, function (error, response) {
resolve(error || response.body);
});
});
}
/* -- JOURNALISATION -- */
function log(message, error = false) {
const script_name = `CHANGE PASSWORD`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
### Script Change Email
Le script [Change Email](/fr-CA/docs/authenticate/database-connections/custom-db/templates/change-email) exécute une fonction qui met à jour l’adresse courriel d’un utilisateur lorsque celui-ci modifie son adresse courriel ou que l’état de vérification de celle-ci change.
Ce script n’est pas disponible dans le tableau de bord Auth0. Vous devez appeler le point de terminaison [Update a connection](https://auth0.com/docs/api/management/v2/connections/patch-connections-by-id) de l’API de gestion et fournir la propriété `options.customScripts.change_email`.
#### Exemple
```js lines expandable theme={null}
async function changeEmail(user, newEmail, verified, callback) {
log(`Script started.`);
log(`Requesting an Access Token from "${configuration.auth0_domain}".`);
let accessToken = await getAccessToken();
if (!accessToken.access_token) return log(`Failed to get an Access Token from "${configuration.auth0_domain}".`, true);
accessToken = accessToken.access_token;
log(`The Access Token is available. Searching for user "${user}" in "${configuration.source_database}" database.`);
user = user.toLowerCase();
const searchQuery = encodeURI(`identities.connection:"${configuration.source_database}"+AND+(email:${user} OR username:${user})`);
var options = {
method: `GET`,
url: `https://${configuration.auth0_domain}/api/v2/users?q=${searchQuery}`,
headers: {
Authorization: `Bearer ${accessToken}`,
}
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
let search_results = JSON.parse(response.body);
if (search_results.length > 0) {
log(`A user "${user}" is found in "${configuration.source_database}" database.`);
const user_id = search_results[0].user_id.toString();
log(`Attempting to change email / verified status for user "${user_id}" in "${configuration.source_database}" database.`);
const options = {
method: `PATCH`,
url: `https://${configuration.auth0_domain}/api/v2/users/${user_id}`,
headers: {
Authorization: `Bearer ${accessToken}`,
"Content-Type": `application/x-www-form-urlencoded`
},
form: {
email: newEmail,
email_verified: verified || false
},
json: true
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
switch (response.statusCode) {
case 200:
log(`The user "${user}" email / verified status successfully changed in "${configuration.source_database}" database.`);
return callback(null, true);
default:
return log(`Failed to change email / verified status for "${user}" in "${configuration.source_database}" database. Error: "${response.statusCode}, ${response.body.message}"`, true);
}
});
} else {
log(`A user "${user}" is not found in "${configuration.source_database}" database. Unable to change email / verified status.`, true);
}
});
/* -- OBTENIR UN JETON D'ACCÈS VIA L'IDENTIFIANT CLIENT -- */
async function getAccessToken() {
var options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: {
"Content-Type": `application/x-www-form-urlencoded`,
},
form: {
grant_type: `client_credentials`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
audience: `https://${configuration.auth0_domain}/api/v2/`
},
json: true
};
return new Promise(function (resolve) {
request(options, function (error, response) {
resolve(error || response.body);
});
});
}
/* -- JOURNALISATION -- */
function log(message, error = false) {
const script_name = `CHANGE EMAIL`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
## Pour en savoir plus
* [Niveau de robustesse des mots de passe dans les connexions de base de données Auth0](/fr-CA/docs/authenticate/database-connections/password-strength)
* [Pratiques exemplaires pour l’environnement des scripts d’action des bases de données personnalisées](/fr-CA/docs/authenticate/database-connections/custom-db/custom-database-connections-scripts/environment)
* [Options de mot de passe dans les connexions de base de données Auth0](/fr-CA/docs/authenticate/database-connections/password-options)
* [Configurer la connexion du fournisseur d’identité pour les mises à jour du profil d’utilisateur](/fr-CA/docs/manage-users/user-accounts/user-profiles/configure-connection-sync-with-auth0)
* [Pratiques exemplaires pour les paramètres de connexion](/fr-CA/docs/authenticate/connection-settings-best-practices)
* [Créer des connexions à des bases de données personnalisées](/fr-CA/docs/authenticate/database-connections/custom-db/create-db-connection)