> ## Documentation Index
> Fetch the complete documentation index at: https://docs-dev-actions-triggers-prototype.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Tester les connexions de bases de données personnalisées
> Cet article explique comment tester les connexions de bases de données personnalisées dans Auth0 Dashboard.
Si vous utilisez la structure de la base de données hébergée par Auth0 pour stocker vos utilisateurs, vous pouvez tester la connexion en authentifiant les utilisateurs auprès du même locataire ou d’un locataire distinct.
## Test avec l’importation d’utilisateurs vers Auth0 activée
Lorsque l’importation d’utilisateurs est activée, les utilisateurs sont progressivement transférés du magasin d’utilisateurs externe vers le magasin d’utilisateurs d’Auth0. Au cours de ce processus, les utilisateurs seront authentifiés par rapport au magasin externe la première fois qu’ils se connecteront. Toutes les autres tentatives de connexion seront exécutées par rapport au magasin d’utilisateurs d’Auth0. Pour en savoir plus sur les migrations automatiques, consultez la section [Importer et exporter des utilisateurs](/docs/fr-ca/manage-users/user-migration).
### Créer un locataire et une application de test
1. Utilisez Auth0 Dashboard pour [créer un nouveau locataire](/docs/fr-ca/get-started/auth0-overview/create-tenants).
2. Rendez-vous à [Applications > Applications](https://manage.auth0.com/#/applications/applications) et créez une application de [communication entre machines](https://manage.auth0.com/#/applications/applications/create).
Vous devez relever l’**ID client** et le **Secret du client** lorsque vous créez les scripts de base de données personnalisés. Vous devez relever l’**ID client** pour activer les permissions dans Management API.
3. Sous l’onglet Grant Types (Types d’autorisations) cochez **Password** (Mot de passe) et **Client Credentials** (Identifiants du client) pour cette application (les deux autorisations doivent être activées dans le cadre de ce test).
4. Pour autoriser votre application, allez à [Applications > API](https://manage.auth0.com/#/apis).
5. Sélectionnez **Management API**.
6. Sous l’onglet **Machine-to-Machine Applications** (Applications de communication entre machines), utilisez le bouton a bascule pour autoriser votre application test.
7. Sélectionnez le menu déroulant pour autoriser les permissions de Auth0 Management API suivantes :
* `read:users`
* `update:clients`
* `delete:user`
* `create User`
* `read:users_app_metadata`
* `update:users_app_metadata`
* `create:users_app_metadata`
### Créer des connexions de base de données
Une fois que vous avez créé un locataire et une application dans Auth0 Dashboard, créez une connexion de base de données source et de base de données cible.
1. Allez à [Authentication (Authentification) > Database (Base de données)](https://manage.auth0.com/#/connections/database) pour créer une nouvelle connexion de base de données, en la définissant comme source.
2. Nommez votre connexion test à cette source, activez l’option **Requires Username** (Nécessite un nom d’utilisateur), et cliquez sur **Create** (Créer).
Vous pouvez créer des utilisateurs à utiliser dans votre test en naviguant vers [Gestion des utilisateurs > Utilisateurs](https://manage.auth0.com/#/users). Une fois que vous avez sélectionné **CréerUtilisateurs** et que vous avez renseigné les champs nécessaires, sélectionnez la base de données source dans le champ **Connexion**.
3. Créez une deuxième base de donnée en tant que cible avec la même configuration qu’à l’étape 2.
Vous pouvez définir la **Politique relative aux mots de passe** sur **Mot de passe non vide requis** dans les bases de données cible et source afin de pouvoir utiliser des mots de passe simples dans vos tests.
4. Dans votre base de données cible, allez dans l’onglet **Custom Database (Base de données personnalisée)**, puis activez **Use my own database (Utiliser ma propre base de données)**.
Si vous souhaitez tester l’utilisation des organisations avec vos bases de données personnalisées, activez **Objet contextuel dans les scripts de base de données**.
5. Dans l’onglet **Settings** (Paramètres), activez **Import Users to Auth0** (Importer des utilisateurs dans Auth0).
6. Passez à l’onglet **Custom Database (Base de données personnalisée)**, puis localisez la section **Database settings** (Paramètres de la base de données). Ajoutez les informations suivantes de votre base de données source créée à l’étape 1 :
| Clé | Valeur |
| ----------------- | ------------------------------------------------------------------------- |
| `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` | Votre nom de locataire dans le domaine Auth0 : `yourTenant.us.auth0.com`. |
| `source_database` | Nom de la connexion source. |
7. Mettez à jour les scripts d’action [Se connecter](/docs/fr-ca/authenticate/database-connections/test-custom-db#login) et [Obtenir l’utilisateur](/docs/fr-ca/authenticate/database-connections/test-custom-db#get-user) dans votre base de données cible. Pour en savoir plus sur les meilleures pratiques en matière d’utilisation des scripts d’action des bases de données, consultez [Connexion de bases de données personnalisées et meilleures pratiques en matière de scripts d’actions](/docs/fr-ca/authenticate/database-connections/custom-db/custom-database-connections-scripts).
8. Sélectionnez **Save and Try** (Enregistrer et essayer) pour chaque script. Vous devez surveiller la sortie `console.log` Actions Real-time Logs. Pour en savoir plus, consultez [Journaux d'actions en temps réel](/docs/fr-ca/customize/actions/actions-real-time-logs).
9. Sélectionnez **Try Connection** (Tester la connexion) pour tester la connexion en temps réel
## Test sans importation des utilisateurs
1. Recommencez les étapes décrites dans la section [Créer un locataire et une application de test](https://www.auth0.com/docs/authenticate/database-connections/test-custom-db#create-a-test-tenant-and-application).
2. Création d’une connexion de base de données de test
3. Assurez-vous que **l’importation d’utilisateurs dans Auth0** est désactivée dans les paramètres de votre base de données source. Les utilisateurs s’authentifient auprès du magasin d’utilisateurs externe à chaque tentative de connexion.
4. Mettez à jour tous les scripts d’Actions de base de données à l’aide des exemples ci-dessous.
### Script Get User (Obtenir l’utilisateur)
Le script [Obtenir l’utilisateur](/docs/fr-ca/authenticate/database-connections/custom-db/templates/get-user) permet de mettre en œuvre une fonction qui détermine l’état actuel d’un utilisateur.
Lorsque l’option **Import Users to Auth0 (Importation des utilisateurs dans Auth0)** est activée, le script Get User (Obtenir l’utilisateur) s’exécute quand un utilisateur essaie de s’inscrire afin de vérifier si ce dernier existe déjà dans le magasin d’utilisateurs externe.
Le script Get User (Obtenir l’utilisateur) s’exécute également lorsqu’un utilisateur essaie de :
* Modifier l’adresse courriel d’un utilisateur (script [de modification de courriel)](/docs/fr-ca/authenticate/database-connections/custom-db/templates/change-email)
* Se connecter (script [de connexion](/docs/fr-ca/authenticate/database-connections/custom-db/templates/login))
* Modifier son mot de passe (script [de modification de mot de passe](/docs/fr-ca/authenticate/database-connections/custom-db/templates/change-password))
Lorsque l’option **Import Users to Auth0 (Importation des utilisateurs dans Auth0)** est désactivée, le script Get User (Obtenir l’utilisateur) s’exécute quand un utilisateur essaie de s’inscrire afin de vérifier si ce dernier existe déjà dans le magasin d’utilisateurs externe. Si un utilisateur existe déjà dans le magasin d’utilisateurs externe, le script Create (Créer) ne sera pas exécuté.
Le script Get User (Obtenir l’utilisateur) s’exécute également lorsqu’un utilisateur essaie de :
* Créer un utilisateur (script [de création](/docs/fr-ca/authenticate/database-connections/custom-db/templates/create))
* Modifier l’adresse courriel d’un utilisateur (script [de modification de courriel](/docs/fr-ca/authenticate/database-connections/custom-db/templates/change-email))
* Modifier le mot de passe d’un utilisateur (script [de modification de mot de passe](/docs/fr-ca/authenticate/database-connections/custom-db/templates/change-password))
#### Exemple
```javascript lines 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);
});
/* -- GET ACCESS TOKEN VIA CLIENT CREDENTIALS -- */
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);
});
});
}
/* -- LOGGING -- */
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 Login (Se connecter)
Le script de [connexion](/docs/fr-ca/authenticate/database-connections/custom-db/templates/login) met en œuvre une fonction exécutable qui authentifie un utilisateur lorsqu’il se connecte. S’il existe dans la base de données cible (Auth0), il est identifié à l’aide de cet enregistrement. Sinon, il est authentifié à l’aide de son enregistrement dans la base de données source (externe).
#### Exemple
```javascript lines 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);
});
/* -- LOGGING -- */
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 Create (Créer)
Le script de [création](/docs/fr-ca/authenticate/database-connections/custom-db/templates/create) met en œuvreune fonction exécutable qui crée un enregistrement utilisateur correspondant dans la base de données externe lorsqu’un utilisateur s’inscrit au moyen d’une connexion universelle, ou est créé dans Auth0 Dashboard ou à l’aide d’Auth0 Management API.
#### Exemple
```javascript lines 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);
}
});
/* -- GET ACCESS TOKEN VIA CLIENT CREDENTIALS -- */
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);
});
});
}
/* -- LOGGING -- */
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 Delete (Supprimer)
Le script de [suppression](/docs/fr-ca/authenticate/database-connections/custom-db/templates/delete) met en œuvre une fonction exécutable qui supprime un utilisateur de la base de données externe et d’Auth0 lors de la même opération lorsque celui-ci est retiré d’Auth0 Dashboard ou à l’aide d’Auth0 Management API.
#### Exemple
```javascript lines 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);
}
});
/* -- GET ACCESS TOKEN VIA CLIENT CREDENTIALS -- */
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);
});
});
}
/* -- LOGGING -- */
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 Verify (Vérifier)
Le script de [vérification](/docs/fr-ca/authenticate/database-connections/custom-db/templates/verify) met en œuvre une fonction exécutable qui indique l’état de vérification de l’adresse courriel d’un utilisateur dans la base de données externe lorsqu’un utilisateur clique sur le lien dans le courriel de vérification envoyé par Auth0.
#### Exemple
```javascript lines 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);
}
});
/* -- GET ACCESS TOKEN VIA CLIENT CREDENTIALS -- */
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);
});
});
}
/* -- LOGGING -- */
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 Change Password (Modifier le mot de passe)
Le script de [modification du mot de passe](/docs/fr-ca/authenticate/database-connections/custom-db/templates/change-password) met en œuvre une fonction exécutable qui met à jour le mot de passe d’un utilisateur dans la base de données externe lorsqu’un flux de production de modification de mot de passe est lancé à partir d’Auth0 Dashboard ou d’Auth0 Management API.
#### Exemple
```javascript lines 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);
}
});
/* -- GET ACCESS TOKEN VIA CLIENT CREDENTIALS -- */
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);
});
});
}
/* -- LOGGING -- */
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 (Modifier le courriel)
Le script de [modification du courriel](/docs/fr-ca/authenticate/database-connections/custom-db/templates/change-email) met en œuvre une fonction exécutable qui met à jour l’adresse courriel d’un utilisateur lorsque celui-ci la change ou modifie son état de vérification.
Ce script n’est pas disponible dans Auth0 Dashboard Vous devez appeler le point de terminaison [Update a connection (Mettre à jour une connexion)](/docs/fr-ca/api/management/v2/connections/patch-connections-by-id) de Management API et fournir la propriété `options.customScripts.change_email`.
#### Exemple
```javascript lines 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);
}
});
/* -- GET ACCESS TOKEN VIA CLIENT CREDENTIALS -- */
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);
});
});
}
/* -- LOGGING -- */
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));
}
}
```
## En savoir plus
* [Password Strength in Auth0 Database Connections](/docs/fr-ca/authenticate/database-connections/password-strength)
* [Meilleures pratiques en matière d’environnement des scripts d’action des bases de données personnalisées](/docs/fr-ca/authenticate/database-connections/custom-db/custom-database-connections-scripts/environment)
* [Password Options in Auth0 Database Connections](/docs/fr-ca/authenticate/database-connections/password-options)
* [Configurer la connexion du fournisseur d’identité pour les mises à jour du profil utilisateur](/docs/fr-ca/manage-users/user-accounts/user-profiles/configure-connection-sync-with-auth0)
* [Meilleures pratiques des paramètres de connexion](/docs/fr-ca/authenticate/connection-settings-best-practices)
* [Créer des connexions de base de données personnalisée](/docs/fr-ca/authenticate/database-connections/custom-db/create-db-connection)