> ## 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écouvrez comment utiliser plusieurs domaines personnalisés avec Actions d’Auth0 pour mettre en place une logique d’authentification propre à chaque domaine.

# Intégration d’Actions avec plusieurs domaines personnalisés

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****MASKED*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

Les [Actions Auth0](/fr-CA/docs/customize/actions) vous permettent de personnaliser l’authentification à l’aide de code personnalisé. Lorsque vous utilisez [plusieurs domaines personnalisés](/fr-CA/docs/customize/custom-domains/multiple-custom-domains), vous pouvez accéder aux informations sur le domaine personnalisé dans vos Actions afin d’implémenter une logique propre au domaine, de diriger les utilisateurs vers des organisations, d’appliquer des politiques d’accès et de personnaliser les notifications.

<div id="accessing-custom-domain-information">
  ## Accès aux informations du domaine personnalisé
</div>

Les Actions permettent d’accéder aux informations du domaine personnalisé au moyen de l’objet `event.custom_domain`. Cet objet contient le nom de domaine ainsi que toutes les métadonnées configurées pour ce domaine.

<div id="available-triggers">
  ### Déclencheurs disponibles
</div>

L’objet `event.custom_domain` est disponible dans les déclencheurs d’Action suivants :

| Déclencheur                                       | Référence de l’objet d’événement                                                                                                                                                    |
| ------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Échange d’identifiants                            | [Objet d’événement](/fr-CA/docs/customize/actions/explore-triggers/machine-to-machine-trigger/credentials-exchange-event-object)                                                    |
| Fournisseur de courriel personnalisé              | [Objet d’événement](/fr-CA/docs/customize/email/smtp-email-providers/custom/action-triggers-custom-email-provider-event-object)                                                     |
| Fournisseur de téléphonie personnalisé            | [Objet d’événement](/fr-CA/docs/customize/phone-messages/configure-phone-messaging-providers/configure-a-custom-phone-provider/actions-triggers-custom-phone-provider-event-object) |
| Après la connexion                                | [Objet d’événement](/fr-CA/docs/customize/actions/explore-triggers/signup-and-login-triggers/login-trigger/post-login-event-object)                                                 |
| Après l’inscription de l’utilisateur              | [Objet d’événement](/fr-CA/docs/customize/actions/explore-triggers/signup-and-login-triggers/post-user-registration-trigger/post-user-registration-event-object)                    |
| Après le changement de mot de passe               | [Objet d’événement](/fr-CA/docs/customize/actions/explore-triggers/password-reset-triggers/post-change-password-trigger/post-change-password-event-object)                          |
| Avant l’inscription de l’utilisateur              | [Objet d’événement](/fr-CA/docs/customize/actions/explore-triggers/signup-and-login-triggers/pre-user-registration-trigger/pre-user-registration-event-object)                      |
| Après le défi de réinitialisation du mot de passe | [Objet d’événement](/fr-CA/docs/customize/actions/explore-triggers/password-reset-triggers/post-challenge-trigger/post-challenge-event-object)                                      |

<Note>
  L’objet `event.custom_domain` est uniquement disponible dans les déclencheurs où la requête provient d’un contexte de domaine personnalisé. Si aucun domaine personnalisé n’est utilisé, cette propriété aura la valeur `undefined`.
</Note>

<div id="event-object-structure">
  ### Structure de l’objet d’événement
</div>

Avec le domaine `login.example.com` configuré avec les métadonnées du domaine :

| Clé         | Valeur                    |
| ----------- | ------------------------- |
| allow\_list | example1.com,example2.com |

```javascript theme={null}
exports.onExecutePostLogin = async (event, api) => {
  console.log(event.custom_domain);
};
```

Afficherait dans la console :

```json theme={null}
{
  "domain": "login.example.com",
  "domain_metadata": {
    "allow_list": "example1.com,example2.com"
  }
}
```

<div id="common-use-cases">
  ## Cas d’usage courants
</div>

<div id="conditional-logic-by-domain">
  ### Logique conditionnelle selon le domaine
</div>

Appliquez différentes règles selon qu’un domaine personnalisé ou un domaine canonique est utilisé :

```javascript theme={null}
exports.onExecutePostLogin = async (event, api) => {
  const domain = event.custom_domain?.domain;

  if (
    domain === undefined ||
    domain.includes('.auth0.com') || // Nuage public
    domain.includes('.auth0app.com') // Nuage privé
  ) {
    return api.access.deny('Please use the custom domain to log in.');
  }
};
```

<div id="email-domain-based-access-control">
  ### Contrôle d’accès basé sur le domaine du courriel
</div>

Appliquez des politiques d’accès propres à chaque domaine de courriel à l’aide de métadonnées de domaine personnalisées :

```javascript theme={null}
const getEmailDomain = (email) => {
  if (!email || typeof email !== 'string') {
    return null;
  }

  const parts = email.split('@');
  
  // S'assurer qu'il y a exactement un '@' (ou du moins qu'un domaine existe)
  // gère les cas comme "invalid-email" ou "user@"
  if (parts.length < 2 || !parts[1]) {
    return null;
  }

  return parts[1].toLowerCase().trim();
}

exports.onExecutePreUserRegistration = async (event, api) => {
  const domain = event.custom_domain?.domain;

  if (domain === undefined) {
    return api.access.deny(
      'access_denied',
      `Access denied - Users cannot access without custom domain.`
    );
  }

  const email = event.user.email;
  
  if (email === undefined) {
    return api.access.deny(
      'access_denied',
      `Access denied - Users cannot access without email.`
    );
  }

  const domainAllowList = event.custom_domain?.domain_metadata?.allow_list?.split(',') || [];
  const emailDomain = getEmailDomain(email);

  if (domainAllowList.includes(emailDomain) === false) {
    return api.access.deny(
      'access_denied',
      `Access denied - Users from ${emailDomain} cannot access ${domain}.`
    );
  }
};
```

<div id="application-metadata-based-access-control">
  ### Contrôle d’accès fondé sur les métadonnées de l’application
</div>

Appliquez des politiques d’accès pour les groupes d’applications et de domaines à l’aide des métadonnées d’application et de domaine :

```javascript theme={null}
exports.onExecuteCredentialsExchange = async (event, api) => {
  const domain = event.custom_domain?.domain;
  
  if (
    domain === undefined ||
    domain.includes(event.tenant.id)
  ) {
    return; // Ignorer pour le domaine canonique
  }

  const applicationGroup = new Set(event.client.metadata?.domain_group?.split(',') || []);
  const domainGroup = event.custom_domain?.domain_metadata?.domain_group?.split(',') || [];
  const intersection = domainGroup.filter(x => applicationGroup.has(x));

  if (intersection.length === 0) {
    return api.access.deny(
      'invalid_request',
      `Access denied - Cannot get access from application ${event.client.name} and ${domain}.`
    );
  }
};
```

<div id="connection-metadata-based-access-control">
  ### Contrôle d’accès basé sur les métadonnées de la connexion
</div>

Appliquez des politiques d’accès aux groupes de connexions et de domaines à l’aide des métadonnées de connexion et de domaine :

```javascript theme={null}
exports.onExecutePostLogin = async (event, api) => {
  const domain = event.custom_domain?.domain;

  if (domain === undefined) {
    return api.access.deny(
      `Access denied - Users cannot access without custom domain.`
    );
  }

  const connectionGroup = new Set(event.connection.metadata?.domain_group?.split(',') || []);
  const domainGroup = event.custom_domain?.domain_metadata?.domain_group?.split(',') || [];
  const intersection = domainGroup.filter(x => connectionGroup.has(x));

  if (intersection.length === 0) {
    return api.access.deny(
      `Access denied - Users cannot access connection ${event.connection.name} from ${domain}.`
    );
  }
};
```

<div id="organization-metadata-based-access-control">
  ### Contrôle d’accès basé sur les métadonnées de l’organisation
</div>

Appliquez des politiques d’accès aux groupes d’organisation et de domaine à l’aide des métadonnées de l’organisation et du domaine :

```javascript theme={null}
exports.onExecutePostLogin = async (event, api) => {
  const organization = event.organization;

  if (organization === undefined) {
    return; // Ignorer pour l'authentification hors organisation
  }

  const domain = event.custom_domain?.domain;

  if (domain === undefined) {
    return api.access.deny(
      `Access denied - Users cannot access without custom domain.`
    );
  }

  const organizationGroup = new Set(organization.metadata?.domain_group?.split(',') || []);
  const domainGroup = event.custom_domain?.domain_metadata?.domain_group?.split(',') || [];  
  const intersection = domainGroup.filter(x => organizationGroup.has(x));

  if (intersection.length === 0) {
    return api.access.deny(
      `Access denied - Users cannot access organization ${organization.name} from ${domain}.`
    );
  }
};
```

<div id="region-based-requests">
  ### Requêtes selon la région
</div>

Faites des requêtes à des services externes propres à une région en fonction des métadonnées du domaine personnalisé :

```javascript theme={null}
exports.onExecuteCustomEmailProvider = async (event, api) => {
  const regionServiceEndpoint = event.custom_domain?.domain_metadata?.region_service_endpoint;

  if (regionServiceEndpoint === undefined) {
    return api.notification.drop(`Missing regional service endpoint configuration at custom domain.`);
  }

  const notification = event.notification;
  const messageBody = {
    body: notification.html
  };

  try {
    await fetch(regionServiceEndpoint, {
      method: 'POST',
      headers: {
        'X-API-Key': event.secrets.API_KEY,
      },
      body: JSON.stringify(messageBody),
    });
  } catch (err) {
    api.notification.drop('External service failure');
  }
};
```

<div id="learn-more">
  ## En savoir plus
</div>

<div id="actions-documentation">
  ### Documentation des Actions
</div>

* [Présentation des Actions Auth0](/fr-CA/docs/customize/actions)
* [Explorer les déclencheurs d’Action](/fr-CA/docs/customize/actions/explore-triggers)
* [Limites des Actions](/fr-CA/docs/customize/actions/limitations)

<div id="event-object-references">
  ### Références des objets d’événement
</div>

* [Objet d’événement Post-Login](/fr-CA/docs/customize/actions/explore-triggers/signup-and-login-triggers/login-trigger/post-login-event-object)
* [Objet d’événement Pre-User Registration](/fr-CA/docs/customize/actions/explore-triggers/signup-and-login-triggers/pre-user-registration-trigger/pre-user-registration-event-object)
* [Objet d’événement du fournisseur de courriel personnalisé](/fr-CA/docs/customize/email/smtp-email-providers/custom/action-triggers-custom-email-provider-event-object)
* [Objet d’événement du fournisseur de téléphonie personnalisé](/fr-CA/docs/customize/phone-messages/configure-phone-messaging-providers/configure-a-custom-phone-provider/actions-triggers-custom-phone-provider-event-object)

<div id="related-topics">
  ### Sujets connexes
</div>

* [Domaines personnalisés multiples](/fr-CA/docs/customize/custom-domains/multiple-custom-domains)
* [Organisations](/fr-CA/docs/manage-users/organizations)
* [Fournisseurs de courriel personnalisés](/fr-CA/docs/customize/email/smtp-email-providers/custom)