Définir le comportement de l’organisation

Lorsque vous représentez votre application dans Auth0, vous pouvez spécifier les types d’utilisateurs que l’application doit prendre en charge. Certaines applications permettent aux individus de se connecter avec des comptes personnels, tandis que d’autres sont destinées à être utilisées par les membres des organizations. Certains devraient prendre en charge les deux. Ceci est connu sous le nom de comportement d’organisation et peut être défini pour chaque application à laquelle vous vous connectez à Auth0.

Par exemple, votre application pourrait avoir :

Une page de destination marketing générique qui a un bouton Se connecter qui amène vos utilisateurs au flux de connexion Auth0 sans organisation.
Une URL séparée pour chacun de vos clients B2B (par exemple, les utilisateurs d’Acme accèdent à acme.yourcompany.com) qui redirige les utilisateurs vers Auth0 avec une organisation, afin que vos utilisateurs voient le bouton de connexion SSO d’Acme.

Vous pouvez définir le comportement de l’organisation pour autoriser l’un ou l’autre de ces scénarios. Vous pouvez également configurer le comportement de l’organisation pour que, si votre application nécessite la spécification d’une organisation, mais que l’utilisateur est accidentellement redirigé vers Auth0 sans qu’une organisation ne soit définie, une invite s’affiche, lui permettant de saisir le nom de son organisation.

Vous pouvez définir le comportement de l’organisation à l’aide du Auth0 Dashboard ou du Management API.

Auth0 Dashboard

Pour définir le comportement de l’organisation à partir d’Auth0 Dashboard :

Accédez à Auth0 Dashboard > > Applications, et sélectionnez l’application pour laquelle vous souhaitez configurer les Organizations.

Sélectionnez Organizations afficher et configurer les paramètres appropriés :

Champ	Description	Mappage API
Type d’utilisateurs	Détermine la catégorie d’utilisateurs qui peuvent se connecter à votre application. Les options comprennent : Personnes : Les utilisateurs peuvent s’inscrire avec un compte personnel et se connecter directement à votre application. Les utilisateurs individuels ne peuvent pas se connecter à l’aide d’une organisation. Utilisateurs professionnels : Les utilisateurs doivent être membres d’une organisation pour se connecter. Lorsque vous sélectionnez cette option, vous devez indiquer une organisation lorsque vous redirigez les utilisateurs vers le point de terminaison `/authorize` ou définir votre Flux de connexion à Invite pour organisation. Les deux : Les utilisateurs peuvent se connecter en tant que membre de l’organisation ou s’inscrire avec un compte personnel.	Type d’utilisateurs correspond à `organization_usage` Options : Personnes correspond à `deny` Utilisateurs professionnels correspond à `require` Les deux correspondent à `allow`
Flux de connexion	Détermine l’invite de connexion initiale présentée aux utilisateurs lorsqu’ils accèdent à votre application. Vous ne pouvez configurer ce champ que si le type d’utilisateurs est défini sur Utilisateurs professionnels ou les deux. Les options comprennent : Invite d’identifiants : Les utilisateurs sont d’abord invités à fournir leurs identifiants de connexion. Après la connexion, les utilisateurs peuvent sélectionner leur organisation. Invite pour organisation : Les utilisateurs sont d’abord invités à sélectionner leur organisation. Ensuite, ils peuvent fournir leurs identifiants pour se connecter. Vous ne pouvez utiliser cette option que si vous définissez Type d’utilisateurs sur Utilisateurs professionnels. Aucune invite : Auth0 ne dicte pas quelle invite de connexion est donnée aux utilisateurs. Au lieu de cela, votre application est responsable d’envoyer les paramètres requis à Auth0 pour afficher l’invite appropriée.	Flux de connexion correspond à `organization_require_behavior` Options : Invite d’identifiants correspond à `post_login_prompt` Invite pour organisation correspond à `pre_login_prompt` Aucune invite correspond à `no_prompt`

Sélectionnez Enregistrer les modifications.

Management API

Effectuez une requête PATCH au point de terminaison Mettre à jour un client. Veillez à remplacer les valeurs fictives client_id, mgmt_api_access_token, organization_usage, et organization_require_behavior par votre ID client, votre jeton d’accès du Management API, l’option d’utilisation de l’organisation et l’option de comportement de l’organisation, respectivement.

cURL
C#
Go
Java
Node.JS
Obj-C
...

curl --request PATCH \
  --url 'https://{yourDomain}/api/v2/clients/CLIENT_ID' \
  --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
  --header 'cache-control: no-cache' \
  --header 'content-type: application/json' \
  --data '{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }'

Was this helpful?

var client = new RestClient("https://{yourDomain}/api/v2/clients/CLIENT_ID");
var request = new RestRequest(Method.PATCH);
request.AddHeader("content-type", "application/json");
request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
request.AddHeader("cache-control", "no-cache");
request.AddParameter("application/json", "{ \"organization_usage\": \"ORG_USAGE\", \"organization_require_behavior\": \"ORG_REQUIRE_BEHAVIOR\" }", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

Was this helpful?

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "https://{yourDomain}/api/v2/clients/CLIENT_ID"

	payload := strings.NewReader("{ \"organization_usage\": \"ORG_USAGE\", \"organization_require_behavior\": \"ORG_REQUIRE_BEHAVIOR\" }")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("content-type", "application/json")
	req.Header.Add("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
	req.Header.Add("cache-control", "no-cache")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Was this helpful?

HttpResponse<String> response = Unirest.patch("https://{yourDomain}/api/v2/clients/CLIENT_ID")
  .header("content-type", "application/json")
  .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
  .header("cache-control", "no-cache")
  .body("{ \"organization_usage\": \"ORG_USAGE\", \"organization_require_behavior\": \"ORG_REQUIRE_BEHAVIOR\" }")
  .asString();

Was this helpful?

var axios = require("axios").default;

var options = {
  method: 'PATCH',
  url: 'https://{yourDomain}/api/v2/clients/CLIENT_ID',
  headers: {
    'content-type': 'application/json',
    authorization: 'Bearer MGMT_API_ACCESS_TOKEN',
    'cache-control': 'no-cache'
  },
  data: {
    organization_usage: 'ORG_USAGE',
    organization_require_behavior: 'ORG_REQUIRE_BEHAVIOR'
  }
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});

Was this helpful?

#import <Foundation/Foundation.h>

NSDictionary *headers = @{ @"content-type": @"application/json",
                           @"authorization": @"Bearer MGMT_API_ACCESS_TOKEN",
                           @"cache-control": @"no-cache" };
NSDictionary *parameters = @{ @"organization_usage": @"ORG_USAGE",
                              @"organization_require_behavior": @"ORG_REQUIRE_BEHAVIOR" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://{yourDomain}/api/v2/clients/CLIENT_ID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

Was this helpful?

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://{yourDomain}/api/v2/clients/CLIENT_ID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "{ \"organization_usage\": \"ORG_USAGE\", \"organization_require_behavior\": \"ORG_REQUIRE_BEHAVIOR\" }",
  CURLOPT_HTTPHEADER => [
    "authorization: Bearer MGMT_API_ACCESS_TOKEN",
    "cache-control: no-cache",
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

Was this helpful?

import http.client

conn = http.client.HTTPSConnection("")

payload = "{ \"organization_usage\": \"ORG_USAGE\", \"organization_require_behavior\": \"ORG_REQUIRE_BEHAVIOR\" }"

headers = {
    'content-type': "application/json",
    'authorization': "Bearer MGMT_API_ACCESS_TOKEN",
    'cache-control': "no-cache"
    }

conn.request("PATCH", "/{yourDomain}/api/v2/clients/CLIENT_ID", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

Was this helpful?

require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://{yourDomain}/api/v2/clients/CLIENT_ID")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
request["cache-control"] = 'no-cache'
request.body = "{ \"organization_usage\": \"ORG_USAGE\", \"organization_require_behavior\": \"ORG_REQUIRE_BEHAVIOR\" }"

response = http.request(request)
puts response.read_body

Was this helpful?

import Foundation

let headers = [
  "content-type": "application/json",
  "authorization": "Bearer MGMT_API_ACCESS_TOKEN",
  "cache-control": "no-cache"
]
let parameters = [
  "organization_usage": "ORG_USAGE",
  "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://{yourDomain}/api/v2/clients/CLIENT_ID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

Was this helpful?

Valeur	Description
`CLIENT_ID`	Identifiant de l’application pour laquelle vous voulez ajouter le comportement d’organisation.
`MGMT_API_ACCESS_TOKEN`	Jetons d’accès pour Management API avec la permission `update:clients`.
`ORGANIZATION_USAGE`	Indique si votre application peut prendre en charge les utilisateurs se connectant à une organisation. Options possibles : `deny`: (Par défaut) Les utilisateurs ne peuvent pas se connecter à l’aide d’une organisation. `allow`: Les utilisateurs peuvent se connecter avec ou sans organisation. Si cette option est sélectionnée, vous devez indiquer une organisation lorsque vous redirigez les utilisateurs vers le point de terminaison `/authorize`. `require`: Les utilisateurs doivent se connecter à l’aide d’une organisation. Si cette option est sélectionnée, vous devez soit indiquer une organisation lorsque vous redirigez les utilisateurs vers le point de terminaison `/authorize`, soit définir `organization_require_behavior` sur `pre_login_prompt` pour autoriser les utilisateurs à choisir une organisation avant de se connecter.
`ORGANIZATION_REQUIRE_BEHAVIOR`	Détermine le flux de connexion présenté aux utilisateurs accédant à votre application. S’applique uniquement si `organization_usage` est définie sur `require` ou `allow`. Options possibles: `no_prompt`: (Par défaut) Pas d’invite. Les demandes sans paramètre d’organisation valide sont rejetées. `pre_login_prompt`: Demande aux utilisateurs de sélectionner une organisation avant de pouvoir se connecter. Vous ne pouvez utiliser cette option que si `organization_usage` est définie sur `require`. `post_login_prompt`: Demande aux utilisateurs de se connecter avec leurs identifiants. Après connexion, demande aux utilisateurs de sélectionner leur organisation.

Codes d’état des réponses

Les codes d’état de réponse possibles sont les suivants :

Code d’état	Code d’erreur	Message	Cause
`200`		Client mis à jour avec succès.
`400`	`invalid_uri`	URI de demande non valide. Le message variera en fonction de la cause.	Le chemin n’est pas valide.
`400`	`invalid_body`	Corps de la demande non valide. Le message variera en fonction de la cause.	La charge utile de la demande n’est pas valide.
`401`		Jeton non valide.
`401`		Le client n’est pas global.
`401`		Signature non valide reçue pour la validation du jeton Web JSON.
`403`	`insufficient_scope`	Permission insuffisante; on s’attend à l’un des éléments suivants : `update:clients`.	Tentative de lecture/écriture d’un champ qui n’est pas autorisé avec les permissions de jeton du porteur fourni.
`403`	`insufficient_scope`	Certains champs ne peuvent pas être mis à jour avec les autorisations accordées par les permissions du jeton porteur. Le message variera en fonction des champs et des permissions.	Tentative de lecture/écriture d’un champ qui n’est pas autorisé avec les permissions de jeton du porteur fourni.
`403`	`operation_not_supported`	Le compte n’est pas autorisé à effectuer cette opération.	Le compte n’est pas autorisé à effectuer cette opération.
`404`	`inexistent_client`	Client non trouvé.	Ressource inexistante. L’application spécifiée n’existe pas.
`429`		Trop de demandes. Vérifiez les en-têtes X-RateLimit-Limit, X-RateLimit-Remaining et X-RateLimit-Reset.

Gérer les utilisateurs

Définir le comportement de l’organisation

Auth0 Dashboard

Management API

Codes d’état des réponses