# Authentification Microsoft Entra ID

{% hint style="warning" %}
Azure Active Directory (Azure AD) a été renommé **Microsoft Entra ID (ME-ID)**. Bien que la documentation WorkflowGen ait été mise à jour pour refléter ce changement de nom, les paramètres de l'application WorkflowGen font toujours référence à Azure AD (par exemple, connecteur d'annuaire `Azure AD SCIM v2`).

De même, certains éléments de configuration ME-ID dans le portail Azure ont été renommés et / ou déplacés. La documentation WorkflowGen a été mise à jour en conséquence, mais il se peut qu'elle ne soit toujours pas tout à fait exacte à cet égard. Consultez la documentation [Microsoft Entra ID](https://learn.microsoft.com/fr-fr/entra/identity/) pour plus d'informations.
{% endhint %}

## Aperçu

Cette section fournit des instructions sur la façon de configurer l'authentification déléguée WorkflowGen avec l'authentification Microsoft Entra ID (ME-ID) via les fournisseurs **Microsoft Identity Platform v2.0** ou **API endpoint v1**, et vous montrera comment configurer une instance WorkflowGen fonctionnelle qui utilise ME-ID pour authentifier vos utilisateurs.

{% hint style="info" %}
Dans les instructions, remplacez `<url workflowgen>` par le domaine et le chemin de votre instance de WorkflowGen; par exemple, `localhost/wfgen` ou `www.macompagnie.com/wfgen`.
{% endhint %}

## Prérequis

* Assurez-vous d'avoir une copie de WorkflowGen sous licence installée et en fonctionnement sur un serveur Web IIS en mode de connexion sécurisé **HTTPS**.
* Vous devez être un **administrateur WorkflowGen**.
* Assurez-vous d'avoir un **accès administrateur ME-ID** pour pouvoir configurer Azure AD.
* Assurez-vous d'avoir provisionné un utilisateur Azure AD existant que vous pouvez authentifier avec WorkflowGen et que l'utilisateur dispose des permissions d'**administrateur WorkflowGen**. Ceci est important car une fois que vous avez activé l'authentification déléguée avec ME-ID, vous devrez toujours pouvoir gérer l'application Web WorkflowGen.
* Le mode de chiffrement AES et sa clé sont requis pour que l'authentification fonctionne.

## Configuration de Microsoft Entra ID

La configuration de ME-ID se fait en deux parties. D'abord, vous devez enregistrer l'application Web WorkflowGen et la lier à votre instance de WorkflowGen; ensuite, vous devez enregistrer l'API GraphQL de WorkflowGen afin de pouvoir enregistrer d'autres applications personnalisées pour y accéder.

### Étape 1 : Créez une nouvelle inscription d'application pour WorkflowGen

1. Dans le portail Azure, cliquez sur **Inscriptions d'applications** dans la section **Azure Active Directory**.<br>
2. Cliquez sur **Nouvelle inscription** et entrez les propriétés :
   * **Nom :** `WorkflowGen Web app` &#x20;
   * **Types de comptes pris en charge :** `Comptes dans cet annuaire d'organisation uniquement (Default Directory uniquement - Locataire unique)`&#x20;

     ✏️ **Note :** En fonction du contexte, vous devez choisir la bonne option pour votre cas d'utilisation pour la valeur **Types de comptes pris en charge**.
   * **URI de redirection :**&#x20;

     * **Plateforme :** `Web`
     * **Valeur :** `https://<url workflowgen>/auth/callback` &#x20;

     📌 **Exemple :** `https://macompagnie.com/wfgen/auth/callback`<br>
3. Cliquez sur **S'inscrire** en bas de la page.

Vous devriez maintenant voir la page d'aperçu de l'enregistrement de l'application Web WorkflowGen.

### Étape 2 : Générez une clé secrète client pour l'application

Maintenant, vous devez générer une **clé secrète client** à utiliser par le module d'authentification OIDC de WorkflowGen.

1. Cliquez sur **Ajouter un certificat ou un secret**.<br>
2. Dans la section **Secrets client**, cliquez sur **Nouveau secret client**.
   * **Description :** `Mon secret`, ou quelque chose de semblable pour rappeler que ceci est la clé secrète client.
   * **Date d'expiration :** Choisissez **730 jours (24 mois)** ou la période d'expiration souhaitée.<br>
3. Cliquez sur **Ajouter**.<br>
4. La clé secrète client générée automatiquement est maintenant affichée sous la colonne **Valeur**. Copiez la valeur de la clé secrète client et enregistrez-la dans un endroit sûr, car vous ne pourrez plus la récupérer par la suite.

{% hint style="warning" %}
Il n'est plus possible de définir des clés secrètes client pour qu'elles n'expirent jamais. Vous devrez régénérer manuellement une nouvelle clé secrète client tous les deux ans (si l'option **24 mois** a été sélectionnée) avant qu'elle n'expire. Ensuite, mettez à jour la clé secrète client utilisée par l'instance WorkflowGen dans son fichier de configuration Web (clé **`ApplicationSecurityAuthClientSecret`**).
{% endhint %}

### Étape 3 : Ajoutez un URI de redirection

Pour que la communication entre WorkflowGen et ME-ID fonctionne, vous devez ajouter un autre URI de redirection autorisé à l'application Web `WorkflowGen Web app` enregistrée.

1. Cliquez sur **Authentification**.<br>

2. Dans la section **URI de redirection**, cliquez sur **Ajouter l'URI**.<br>

3. Entrez les informations suivantes :

   * **URI de redirection :** `https://<url workflowgen>/auth/logout/return` \
     📌 **Exemple :** `https://macompagnie.com/wfgen/auth/logout/return`\
     ✏️ **Note :** Vous devriez également voir`https://<url workflowgen>/auth/callback` dans cette liste.

4. Cliquez sur **Enregistrer** en haut de la section.

### Étape 4 : Créez une nouvelle inscription d'application pour l'API GraphQL de WorkflowGen

{% hint style="info" %}
Si vous n'avez pas besoin de l'accès à l'API WorkflowGen GraphQL, vous pouvez ignorer l'enregistrement et la configuration de cette application dans Azure (**étapes 4 à 6**). Dans ce cas, poursuivez complètement la procédure de configuration depuis la section [Vérifiez les inscriptions](#verifiez-les-inscriptions) jusqu'à la section [Configuration de WorkflowGen](#configuration-de-workflowgen). Enfin, suivez la configuration dans la section [Configuration de l'authentification sans l'API GraphQL](#configuration-de-lauthentification-sans-lapi-graphql).
{% endhint %}

Pour exposer l'API GraphQL, vous devez ajouter une nouvelle application qui la représentera. Pour ce faire :

1. Dans le portail Azure, cliquez sur **Inscriptions d'applications** dans la section **Services Azure**.<br>
2. Cliquez sur **Nouvelle inscription** et renseignez le formulaire des propriétés :
   * **Nom :** `WorkflowGen GraphQL API`
   * **Types de comptes pris en charge :** `Comptes dans cet annuaire d'organisation uniquement (Default Directory uniquement - Locataire unique)`<br>
3. Cliquez sur **S'inscrire** en bas de la page.

Vous avez maintenant correctement enregistré l'application `WorkflowGen GraphQL API` dans Azure AD.

### Étape 5 : Exposez l'API dans l'inscription d'application de l'API WorkflowGen GraphQL

1. Cliquez sur **Exposer une API**.<br>

2. À droite de **URI ID d'application**, cliquez sur **Définir** et entrez l'URI `https://<url workflowgen>/graphql`.\
   📌 **Exemple :** `https://macompagnie.com/wfgen/graphql`<br>

3. Cliquez sur **Enregistrer**.<br>

4. Cliquez sur **Ajouter une étendue** et entrez les informations suivantes :
   * **Nom de l'étendue :** `defaut`
   * **Qui peut accepter ? :** `Administrateurs et utilisateurs`
   * **Nom d'affichage du consentement administrateur :** `Accès par défaut à l'API WorkflowGen GraphQL`
   * **Description du consentement administrateur** **:** `Permet à l'application d'accéder à l'API WorkflowGen GraphQL.`
   * **Nom d'affichage du consentement de l'utilisateur :** `Accès par défaut à l'API WorkflowGen GraphQL`&#x20;
   * **Description du consentement de l'utilisateur :** `Permet à l'application d'accéder à l'API WorkflowGen GraphQL`

5. Cliquez sur **Ajouter une étendue**.

{% hint style="warning" %}
Depuis octobre 2021, Azure AD nécessite l'utilisation d'un schéma par défaut ou d'un domaine vérifié pour l'URL AppId sur l'application à locataire unique (voir la documentation Microsoft [ici](https://learn.microsoft.com/fr-fr/azure/active-directory/develop/reference-breaking-changes#appid-uri-in-single-tenant-applications-will-require-use-of-default-scheme-or-verified-domains) pour plus d'informations).

La documentation Microsoft sur la façon d'ajouter et de vérifier un domaine personnalisé est disponible [ici](https://learn.microsoft.com/fr-fr/azure/active-directory/enterprise-users/domains-manage).
{% endhint %}

### Étape 6 : Accordez à WorkflowGen l'accès à l'API WorkflowGen GraphQL

1. Dans la page d'inscription de l'application `WorkflowGen Web app`, cliquez sur **Autorisations de l'API**.<br>
2. Cliquez sur **Ajouter une autorisation**, puis sélectionnez l'onglet **Mes API**.<br>
3. Cliquez sur l'application `WorkflowGen GraphQL API` dans la liste.<br>
4. Cliquez sur **Autorisations déléguées** et cochez `defaut` dans la colonne **Autorisation**.<br>
5. Cliquez sur **Ajouter des autorisations**.<br>
6. Dans la page **API autorisées**, cliquez sur **Accorder un consentement d'administrateur pour \<votre nom de locataire>**, puis cliquez sur **Oui**.

### Vérifiez les inscriptions

Vous devriez maintenant avoir toutes les informations dont vous aurez besoin pour configurer WorkflowGen pour déléguer l'authentification à ME-ID. Voici un résumé :

* Un **ID client**. Ceci est l'ID d'application (client) de l'inscription de l'application `WorkflowGen Web app` dans Azure AD. Vous pouvez le trouver sur sa page d'aperçu.
* Une **clé secrète client**. Ceci est la clé secrète client précédemment générée à l'**étape 2** pour l'application WorkflowGen Web app.
* Une **audience**. Ceci est la propriété `Application ID URI` (p.ex. : `https://<url workflowgen>/graphql`) dans la section **Exposer une API** de l'inscription de l'application `WorkflowGen GraphQL API`.
* Le **point de terminaison des métadonnées**. Cette URL est liée à votre annuaire ME-ID. Pour la trouver :
  1. Accédez à la page **Vue d'ensemble** et copiez la valeur `ID de locataire`.
  2. L'URL du point de terminaison des métadonnées est créée en remplaçant `<Tenant ID>` par votre ID de locataire comme suit :

     \
     **Pour Microsoft Identity Platform v2.0 (recommandé) :**

     ```
     https://login.microsoftonline.com/<Tenant ID>/v2.0/.well-known/openid-configuration
     ```

     \
     **Pour Azure v1 :**

     ```
     https://login.microsoftonline.com/<Tenant ID>/.well-known/openid-configuration
     ```

Vous devriez maintenant avoir toutes les informations requises pour lier votre instance de WorkflowGen à ME-ID.

## Configuration de WorkflowGen

Vous devez maintenant configurer WorkflowGen pour déléguer l'authentification à ME-ID.

### Étape 1 : Ajoutez les valeurs Microsoft Entra ID au `web.config` de WorkflowGen

1. Ouvrez le fichier `web.config` de WorkflowGen et ajoutez et / ou mettez à jour les propriétés suivantes sous `<appSettings>`:\
   \
   **Pour Microsoft Identity Platform v2.0 (recommandé) :**

   ```markup
   <!-- Microsoft Identity Platform v2 -->
   <add key="ApplicationSecurityAuthProvider" value="ms-identity-v2"/>
   <add key="ApplicationSecurityAuthClientId" value="<CLIENT ID>" />
   <add key="ApplicationSecurityAuthClientSecret" value="<CLIENT SECRET>" />
   <add key="ApplicationSecurityAuthMetadataUrl" value="<METADATA URL>" />
   <add key="ApplicationSecurityAuthAppIdClaim" value="appid" />
   <add key="ApplicationSecurityAuthUsernameClaim" value="preferred_username" />
   <add key="ApplicationSecurityAuthClockTolerance" value="60" />
   <add key="ApplicationSecurityAuthSessionRefreshEnableIFrame" value="Y"/>
   <add key="ApplicationSecurityAuthAccessTokenUsernameClaim" value="upn" />
   <add key="ApplicationSecurityAuthAdditionalScopes" value="https://<url workflowgen>/graphql/default" />
   ```

   \
   **Pour Azure v1 :**

   ```markup
   <!-- Azure v1 auth -->
   <add key="ApplicationSecurityAuthProvider" value="azure-v1"/>
   <add key="ApplicationSecurityAuthClientId" value="<CLIENT ID>" />
   <add key="ApplicationSecurityAuthClientSecret" value="<CLIENT SECRET>" />
   <add key="ApplicationSecurityAuthMetadataUrl" value="<METADATA URL>" />
   <add key="ApplicationSecurityAuthAppIdClaim" value="appid" />
   <add key="ApplicationSecurityAuthUsernameClaim" value="upn" />
   <add key="ApplicationSecurityAuthClockTolerance" value="60" />
   <add key="ApplicationSecurityAuthSessionRefreshEnableIFrame" value="Y"/>
   <add key="ApplicationSecurityAuthCheckSessionUrl" value="<CHECK SESSION URL>" />
   ```

   \
   ✏️ **Note :** Check session iFrame (p.ex. `ApplicationSecurityAuthCheckSessionUrl`) n'est pas supporté dans **Microsoft Identity Platform v2.0**.<br>
2. Remplacez `<CLIENT ID>` par l'ID d'application (client) `WorkflowGen Web app` de ME-ID.<br>
3. Remplacez `<CLIENT SECRET>` par la clé secrète générée par l'inscription de l'application `WorkflowGen Web app` de ME-ID.<br>
4. Remplacez `<METADATA URL>` par l'URL du point de terminaison de métadonnées que vous avez créée précédemment à partir de la valeur `Tenant ID` de votre ME-ID.<br>
5. Pour **Microsoft Identity Platform v2.0**, remplacez `<url workflowgen>` par votre URL WorkflowGen dans la valeur de la clé **`ApplicationSecurityAuthAdditionalScopes`** (p.ex. :  `https://macompagnie.com/wfgen/graphql/default`) si vous avez configuré l'enregistrement de l'application `WorkflowGen GraphQL API` (**étapes 4 à 6**). Sinon, supprimez complètement la clé **`ApplicationSecurityAuthAdditionalScopes`**.<br>
6. Pour **Azure v1**, remplacez  `<CHECK SESSION URL>` (qui est généralement  `https://login.microsoftonline.com/<Tenant ID>/oauth2/checksession`) par la valeur de la propriété `check_session_iframe` du point de terminaison de métadonnées. Pour ce faire, vous devrez envoyer une requête HTTP GET à l'URL de votre point de terminaison de métadonnées (p.ex. : `https://login.microsoftonline.com/<Tenant ID>/.well-known/openid-configuration`), puis copier et coller la valeur. Voir les exemples ci-dessous sur la façon de demander le point de terminaison de métadonnées.<br>

   **Exemple de requête Linux / macOS :**

   ```
   curl "<METADATA URL>" | python -m json.tool
   ```

   \
   ✏️ **Note :** Enlevez `| python -m json.tool` si vous n'avez pas Python; ceci est pour l'impression automatique (« pretty printing »).<br>

   **Exemple de requête Windows PowerShell :**

   ```
   Invoke-RestMethod -Uri "<METADATA URL>" -Method GET | ConvertTo-JSON
   ```

**Tableau des options `web.config`**

| **Option**                                          | **Description**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ApplicationSecurityAuthProvider`                   | Le nom du fournisseur d'identité supporté par WorkflowGen. À présent, seulement Microsoft Entra ID, Microsoft Identity Platform v2.0, Auth0, AD FS et Okta sont supportés. Valeur : `azure-v1`, `ms-identity-v2`,`auth0`, `adfs`, ou `okta`                                                                                                                                                                                                                                                                                                                                                                                                     |
| `ApplicationSecurityAuthClientId`                   | Chaque fournisseur d'identité génère un code qui identifie uniquement votre application. Dans ce cas, cette valeur est le code qui identifie uniquement l'application Web WorkflowGen dans ME-ID, Auth0, AD FS ou Okta.                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `ApplicationSecurityAuthClientSecret`               | Comme pour l'ID client, cette valeur est aussi générée par le fournisseur d'identité, mais est plutôt comme un mot de passe d'utilisateur. Il est important de le garder secret parce qu'un logiciel malveillant ayant accès pourrait agir au nom de l'application. Cette valeur doit être générée explicitement dans ME-ID.                                                                                                                                                                                                                                                                                                                    |
| `ApplicationSecurityAuthMetadataUrl`                | Le point de terminaison fourni par le fournisseur d'identité qui supporte le standard [OpenID Connect Discovery](https://openid.net/specs/openid-connect-discovery-1_0.html). Il permet à WorkflowGen de récupérer des informations publiques sur votre domaine ME-ID, sans lequel vous devrez effectuer beaucoup plus de configurations dans le fichier `web.config`. Notez que l'URL du point de terminaison des métadonnées est différente pour **Microsoft Identity Platform v2.0** et **Azure v1**.                                                                                                                                        |
| `ApplicationSecurityAuthAppIdClaim`                 | <p>Le nom de la revendication contenu dans le jeton d'accès obtenu du fournisseur d'identité qui identifie uniquement un client non-interactif. Il est utilisé seulement si vous avez une application machine-à-machine qui doit accéder à l'API GraphQL. Pour le configurer, voir la section <a href="https://github.com/advantys/workflowgen-doc-technical-fr/tree/e4f86be3cef758d0fa81717ff307ab45f059615d/int%C3%A9gration-azure.md#configuration-azure-ad-apps-monopages">Configuration de Microsoft Entra ID pour les applications monopage</a>. <br><br>✏️ <strong>Note :</strong> Il est recommandé de garder la valeur par défaut.</p> |
| `ApplicationSecurityAuthUsernameClaim`              | <p>Le nom de la revendication contenue dans le jeton d'accès qui identifie l'utilisateur dans WorkflowGen. Il est utilisé par WorkflowGen pour générer un jeton de session ainsi que par l'API GraphQL en récupérant un jeton d'accès.<br><br>✏️ <strong>Note :</strong> Il est recommandé de garder la valeur par défaut.</p>                                                                                                                                                                                                                                                                                                                  |
| `ApplicationSecurityAuthAccessTokenUsernameClaim`   | <p>Cette valeur est utilisée par l'API GraphQL lors de la réception d'un jeton d'accès.</p><p></p><p>✏️ <strong>Note :</strong> Il est recommandé de garder la valeur par défaut.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `ApplicationSecurityAuthClockTolerance`             | <p>Cette valeur est utilisée lors de la vérification d'un jeton dans WorkflowGen. Il est essentiellement pour gérer des différences mineures entre les horloges des serveurs.<br><br>✏️ <strong>Note :</strong> Il est recommandé de garder la valeur par défaut.</p>                                                                                                                                                                                                                                                                                                                                                                           |
| `ApplicationSecurityAuthSessionRefreshEnableIFrame` | <p>Lorsqu'elle est activée (<code>Y</code>), cette option active la fonctionnalité d'auto-rafraîchissement de session à l'aide d'un <code>\<iframe></code> invisible. Cela permet aux utilisateurs d'entrer leurs mots de passe moins souvent en actualisant leur session en arrière-plan pendant qu'ils travaillent.</p><p> </p><p>✏️ <strong>Note :</strong> Cette option est uniquement disponible lorsque WorkflowGen est configuré avec l'authentification OIDC.</p>                                                                                                                                                                       |

WorkflowGen devrait maintenant être lié à votre ME-ID. La dernière chose qui reste à faire est de configurer quelques options supplémentaires afin de terminer le « câblage interne » de WorkflowGen afin qu'il puisse déléguer son authentification.

### Étape 2 : Ajoutez des valeurs de sécurité pour la génération de session

WorkflowGen utilise un jeton de session interne pour gérer la session utilisateur et identifier l'utilisateur actuel pour toutes les requêtes HTTP adressées à l'application Web une fois que l'utilisateur s'est connecté à ME-ID. Pour générer un jeton de session, vous devez ajouter quelques paramètres supplémentaires au fichier `web.config`.

1. Ouvrez le fichier `web.config` de WorkflowGen et ajoutez et / ou mettez à jour la propriété suivante sous `<appSettings>` :

   ```markup
    <!-- Auth -->
    <add key="ApplicationSecurityAuthSessionTokenSigningSecret" value="<SECRET>" />
   ```
2. Remplacez `<SECRET>` par une valeur personnalisée qui ne peut pas être devinée, telle qu'un **UUID** ou un **mot de passe complexe**.

Le secret ne sera accessible qu'à l'intérieur de votre instance de WorkflowGen, donc lors de la génération d'un jeton de session, WorkflowGen le signera avec ce secret afin de vérifier la validité de tous les jetons de session qui lui sont transmis.

### Étape 3 : Activez le module de délégation d'authentification

Vous devez maintenant activer la délégation en remplaçant le système d'authentification dans IIS et faire pointer les modules de WorkflowGen au module d'authentification correct.

#### **Configurez IIS**

1. Dans **Gestionnaire IIS**, cliquez sur le site Web WorkflowGen dans l'arborescence.<br>
2. Cliquez sur le bouton **Authentification**.<br>
3. Activez **Authentification anonyme** et **désactivez** toutes les autres authentifications.<br>
4. Répétez ces étapes pour toutes les sous-applications.

#### Ajouter des propriétés aux fichiers `web.config` des sous-applications

Certaines sous-applications doivent faire vérifier leur authentification par le module d'authentification spécial `Advantys.Security.JWTAuthenticationModule` WorkflowGen, mais certaines autres sous-applications (telles que `/wfgen/auth`, `/wfgen/hooks` et `/wfgen/scim`) ne devraient pas le faire car elles sont publics ou ne font pas partie du système d'authentification global.

1. Ajoutez la propriété suivante au fichier `web.config` de WorkflowGen :

   ```markup
   <configuration>
    <system.webServer>
        <modules>
            <add name="ApplicationSecurityAuthenticationModule" type="Advantys.Security.Http.JWTAuthenticationModule" />
        </modules>
    </system.webServer>
   </configuration>
   ```
2. Si vous avez développé des formulaires Web personnalisés avec leurs propres dossiers `\bin`, vous devez copier les assemblies .NET et les bibliothèques de dépendances suivants de `\wfgen\bin` dans le dossier `\bin` de chaque formulaire Web personnalisé (`\wfgen\wfapps\webforms\bin`) :<br>
   * `Advantys.My.dll`
   * `Advantys.Security.dll`
   * `Newtonsoft.Json.dll`
   * `jose-jwt.dll`

{% hint style="warning" %}
Si vous avez sauté les étapes de la section d'[inscription de l'application API WorkflowGen GraphQL](#etape-4-creez-une-nouvelle-inscription-dapplication-pour-lapi-graphql-de-workflowgen) plus tôt, il est nécessaire d'appliquer la configuration dans la section [Configuration de l'authentification sans l'API GraphQL](#configuration-de-lauthentification-sans-lapi-graphql).
{% endhint %}

{% hint style="success" %}
Vous devriez maintenant avoir une instance de WorkflowGen en fonctionnement avec l'authentification déléguée à Microsoft Entra ID via le protocole OpenID Connect. Assurez-vous d'avoir approvisionné vos utilisateurs à WorkflowGen afin qu'ils puissent accéder à WorkflowGen.
{% endhint %}

## Appel des APIs tierces avec le jeton d'accès

{% hint style="info" %}

* Cette méthode n'est supportée qu'avec le fournisseur **Microsoft Identity Platform v2.0** (p.ex. : `ms-identity-v2`).
* Vos APIs tierces doivent supporter un jeton d'accès (JWT) pour l'authentification et être en mesure de valider l'utilisateur en vérifiant le contenu du jeton d'accès.
  {% endhint %}

{% hint style="warning" %}
Cette configuration présente quelques inconvénients. Par exemple, l'application mobile [WorkflowGen Plus v2](https://docs.workflowgen.com/azure-fr/8.2/configuration-dazure-active-directory-pour-les-applications-mobiles) **ne sera pas compatible** avec cette configuration.
{% endhint %}

Par défaut, le seul destinataire du jeton d'accès est l'application `WorkflowGen GraphQL API`. Cela signifie que le jeton d'accès ne peut être utilisé que pour envoyer des requêtes à l'API GraphQL uniquement. Afin d'utiliser le même jeton d'accès pour appeler vos propres APIs à partir de WorkflowGen (par exemple, des formulaires Web), vous devrez effectuer les étapes suivantes dans votre portail Azure, puis modifier le fichier `web.config` de WorkflowGen.

### Dans votre portail Azure :

#### Étape 1 : Ajoutez une nouvelle inscription d'application qui représente toutes vos APIs

1. Dans le portail Azure, cliquez sur **Inscriptions d'applications** dans la section **Services Azure**.<br>
2. Cliquez sur **Nouvelle inscription** et renseignez le formulaire des propriétés :
   * **Nom :** `Mes API` &#x20;
   * **Types de comptes pris en charge :** `Comptes dans cet annuaire d'organisation uniquement (Locataire unique)`\
     ✏️ **Note :** Selon le contexte, vous devez choisir la bonne option pour votre cas d'utilisation pour la valeur **Types de comptes pris en charge**.
   * **URI de redirection** : Laissez ce champ vide<br>
3. Cliquez sur **S'inscrire** en bas de la page.

#### Étape 2 : Exposez vos APIs dans l'inscription

1. Cliquez sur **Exposer une API**.<br>

2. À droite de **URI ID d'application**, cliquez sur **Définir** et entrez l'URI `api://mes-api`.<br>

3. Cliquez sur **Enregistrer**.<br>

4. Cliquez sur **Ajouter une étendue** et entrez les informations suivantes :
   * **Nom de l'étendue :** `wfgen-graphql-full-access`
   * **Qui peut accepter ? :** `Administrateurs et utilisateurs`
   * **Nom d'affichage du consentement administrateur :** `Accès complet à l'API WorkflowGen GraphQL`
   * **Description du consentement administrateur :** `Permet à l'application d'accéder à l'API WorkflowGen GraphQL.`
   * **Nom d'affichage du consentement de l'utilisateur :**  `Accès complet à l'API WorkflowGen GraphQL`
   * **Description du consentement de l'utilisateur :** `Allows the application to get access to WorkflowGen GraphQL API.`

5. Cliquez sur **Ajouter une étendue**. <br>

6. Ajoutez toute autre étendue qui semble nécessaire pour vos autres APIs.

#### Étape 3 : Ajoutez un rôle d'application

1. Cliquez sur **Manifeste**.<br>
2. Recherchez la propriété JSON `appRoles` et ajoutez l'objet JSON suivant au tableau JSON :

   ```javascript
   {
     "allowedMemberTypes": [
       "Application"
     ],
     "description": "Allows the application to get access to WorkflowGen GraphQL API.",
     "displayName": "wfgen-graphql-full-access-role",
     "id": "<NEW ID>",
     "isEnabled": true,
     "lang": null,
     "origin": "Application",
     "value": "wfgen-graphql-full-access-role"
   }
   ```

   \
   ✏️ **Note :** Remplacez`<NEW ID>` par la valeur générée par la commande PowerShell`[guid]::NewGuid().ToString()` ou utilisez n'importe quel générateur de GUID.<br>
3. Cliquez sur **Enregistrer**.

#### Étape 4 : Accordez à WorkflowGen l'accès à l'application `Mes API`

1. Dans la page d'inscription de l'application `WorkflowGen Web app`, cliquez sur **API autorisées**.<br>
2. Dans la section **Autorisations configurées**, cliquez sur **Ajouter une autorisation**.<br>
3. Cliquez sur **Mes API**, puis choisissez l'application `Mes API` dans la liste.<br>
4. Cliquez sur **Autorisations déléguées** et cochez `wfgen-graphql-full-access` dans la colonne **Autorisation**.<br>
5. Cliquez sur **Ajouter des autorisations**. <br>
6. Dans la page **API autorisées**, cliquez sur **Accorder un consentement d'administrateur pour \<votre nom de locataire>**, puis cliquez sur **Yes**.

#### Étape 5 (facultatif) : Accordez à vos applications automatisées dans Azure (flux d'informations d'identification client) l'accès à l'application `Mes API`

Pour chacune de vos applications automatisées dans Azure (par exemple, un script côté serveur, un service en arrière-plan ou une application) qui nécessite un accès à l'application `Mes API`, procédez comme suit :

1. Accédez à la page d'inscription de l'application, puis cliquez sur **API autorisées**.<br>
2. Dans la section **Autorisations configurées**, cliquez sur **Ajouter une autorisation**.<br>
3. Cliquez sur **Mes API**, puis sélectionnez l'application `Mes API` dans la liste.<br>
4. Cliquez sur **Autorisations de l'application** et cochez `wfgen-graphql-full-access-role` dans la colonne **Autorisation**.<br>
5. Cliquez sur **Ajouter des autorisations**.<br>
6. Dans la page **API autorisées**, cliquez sur **Accorder un consentement d'administrateur pour \<votre nom de locataire>**, puis cliquez sur **Oui**.

### Dans le fichier `web.config` de WorkflowGen :

Ouvrez le fichier `web.config` de WorkflowGen, ajoutez et / ou mettez à jour les paramètres d'application suivants, puis enregistrez le fichier :

```markup
<add key="ApplicationSecurityAuthAudience" value="api://my-apis"/>
<add key="ApplicationSecurityAuthAdditionalScopes" value="api://my-apis/wfgen-graphql-full-access" />
<add key="ApplicationSecurityAuthGraphQLScope" value="wfgen-graphql-full-access" />
<add key="ApplicationSecurityAuthGraphQLAppRole" value="wfgen-graphql-full-access-role" />
```

{% hint style="info" %}
Vous devez également définir des portées supplémentaires dans la clé **`ApplicationSecurityAuthAdditionalScopes`** qui font référence aux autres APIs que vous avez définies à l'**étape 2** des étapes du portail Azure ci-dessus. Les portées doivent être séparées par une virgule.
{% endhint %}

### Assistant de jeton d'accès des formulaires Web .NET

La classe `WorkflowPage` de la bibliothèque `WorkflowGen.My` fournit une méthode publique `CurrentUserAccessToken` pour récupérer facilement le jeton d'accès partagé de l'utilisateur actuel qui peut être utilisé pour interroger l'API GraphQL et vos APIs tierces. Voir l'extrait de code ci-dessous.

```csharp
protected void Page_Load(object sender, EventArgs e)
{
    base.Page_Load(sender, e);

    string accessToken = this.CurrentUserAccessToken();

    // Use accessToken to query GraphQL API or your third-party APIs...
}
```

## Informations supplémentaires

## Support des services SOAP

WorkflowGen supporte seulement les requêtes à l'API SOAP en utilisant les méthodes d'authentification classiques. Si vous devez toujours utiliser cette API, vous devez effectuer quelques étapes additionnelles pour la configurer correctement. Pour ce faire :

1. Créez un nouvel annuaire WorkflowGen (utilisateurs et groupes) séparé pour les utilisateurs de l'API SOAP.<br>
2. Approvisionnez-le avec des utilisateurs et des groupes au besoin.<br>
3. Dans **Gestionnaire IIS**, cochez la méthode d'authentification **De base** pour l'application `\wfgen\ws`.<br>
4. Dans le fichier `web.config` (situé dans  `\Inetpub\wwwroot\wfgen`), ajoutez le suivant sous  `<location path="ws" inheritInChildApplications="false">`  : <br>

   ```markup
   <system.webServer>
       <modules>
           <remove name="ApplicationSecurityAuthenticationModule" />
       </modules>
   </system.webServer>
   ```

### À propos de la gestion de session

Microsoft Entra ID supporte la [Gestion de session Open ID Connect](https://openid.net/specs/openid-connect-session-1_0.html), un standard de « extension draft », en plus du standard principal de OpenID Connect. Ce standard définit les règles pour gérer la session SSO du fournisseur depuis le client. Par exemple, si un utilisateur se déconnecte de sa session ME-ID depuis n'importe quel appareil, un client Web régulier recevra un message qui lui permettra d'enlever la session locale de cet utilisateur. WorkflowGen supporte cette fonctionnalité quand l'authentification déléguée est activée avec ME-ID.

### Options configurables

{% hint style="info" %}
Pour obtenir une liste complète des options configurables, consultez l'annexe [Paramètres de configuration Web et d'application](https://docs.advantys.com/workflowgen-guide-technique/v/8.0.0/annexe-parametres-de-configuration-web-et-dapplication) dans le [Guide technique WorkflowGen](https://docs.advantys.com/workflowgen-guide-technique/v/8.0.0/).
{% endhint %}

Le tableau ci-dessous liste toutes les options configurables dans WorkflowGen que vous pouvez utiliser pour personnaliser votre expérience d'authentification; elles se trouvent dans le fichier `web.config` de WorkflowGen.

| **Option**                                    | **Description**                                                                                                                                                                                                                                                                                                                       |
| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ApplicationSecurityAuthSessionTokenCookie`   | <p>Le nom du cookie de session généré par le module d'authentification. Valeur par défaut : <code>wfgen\_token</code><br><br>✏️ <strong>Note :</strong> Ceci est utile quand vous avez de multiples instances de WorkflowGen en fonctionnement auxquelles vous voulez accéder lorsque vous y êtes authentifié en même temps.</p>      |
| `ApplicationSecurityAuthSessionTimeOut`       | La durée de la session en secondes. Sa valeur par défaut est le temps d'expiration du jeton d'ID reçu du fournisseur. Valeur par défaut : la valeur d'expiration (« exp value » du jeton ME-ID                                                                                                                                        |
| `ApplicationSecurityAuthMobileSessionTimeOut` | La durée de la session en secondes lorsqu'elle est demandée par des appareils mobiles sur le point de terminaison de jeton. Valeur par défaut : 7200 secondes                                                                                                                                                                         |
| `ApplicationSecurityAuthAudience`             | Le destinataire prévu du jeton d'accès (par exemple, l'API cible). Valeur par défaut :`https://<url workflowgen>/graphql`                                                                                                                                                                                                             |
| `ApplicationSecurityAuthAdditionalScopes`     | <p>Portées supplémentaires à ajouter à la demande d'authentification. Elles apparaîtront dans le contenu du jeton d'accès.</p><p></p><p>✏️ <strong>Note :</strong> Les portées <code>openid</code>, <code>profile</code> et <code>email</code> sont toujours dans la requête.</p>                                                     |
| `ApplicationSecurityAuthGraphQLScope`         | Valeur de la portée GraphQL personnalisée à vérifier lors de la validation des portées autorisées dans le jeton d'accès renvoyé par le fournisseur OIDC.                                                                                                                                                                              |
| `ApplicationSecurityAuthGraphQLAppRole`       | <p>Valeur de rôle d'application GraphQL personnalisée qui sera vérifiée lors de la validation des rôles dans le jeton d'accès renvoyé par le fournisseur OIDC dans un flux d'informations d'identification client.</p><p></p><p>✏️ <strong>Note :</strong> Disponible uniquement pour le fournisseur <code>ms-identity-v2</code>.</p> |

## Limitations courantes

Si le portail utilisateur ou le module d'administration de WorkflowGen est affiché sans le menu d'en-tête principal, cette fonctionnalité ne fonctionnera pas. Par exemple, ce scénario pourrait se produire lorsque la page d'accueil du portail ou un formulaire de suivi de demande est affiché dans une iFrame dans une solution externe.

## Configuration de l'authentification sans l'API GraphQL

Si, pour une raison quelconque, vous ne pouvez pas enregistrer l'application `WorkflowGen GraphQL API` et que vous n'avez pas besoin de l'authentification API GraphQL configurée avec le fournisseur, vous pouvez éviter de créer l'enregistrement et configurer WorkflowGen avec l'**API Microsoft Graph**, qui est incluse par défaut dans toutes les inscriptions d'applications. Pour ce faire, il vous suffit de modifier certaines options de configuration dans le fichier `web.config` :

```markup
<configuration>
    <appSettings>
        <add key="ApplicationSecurityAuthAudience" value="https://graph.microsoft.com"/>
        <add key="ApplicationSecurityAuthDecodeAccessToken" value="N"/>
    </appSettings>
</configuration>
```

1. Remplacez la clé `ApplicationSecurityAuthAudience` par **l'URL de l'API Microsoft Graph**, par exemple `https://graph.microsoft.com`.<br>
2. Définissez l'option `ApplicationSecurityAuthDecodeAccessToken` sur `N`.

{% hint style="warning" %}

* Gardez à l'esprit qu'en définissant `ApplicationSecurityAuthDecodeAccessToken=N`, la date d'expiration du jeton de session généré par WorkflowGen sera basée sur celle du jeton ID.
* Vous ne pourrez pas utiliser le jeton d'accès reçu de ME-ID pour interroger l'API GraphQL. Ce jeton d'accès vous donnera accès à l'API Microsoft Graph et à rien d'autre. Pour interroger l'API GraphQL, vous devrez configurer son authentification avec une autre méthode, comme l'authentification de base.
  {% endhint %}
