using Auth0.ManagementApi;
using System.Threading.Tasks;
using System.Collections.Generic;

public partial class Examples
{
    public async Task Example() {
        var client = new ManagementApiClient(
            token: "<token>",
            clientOptions: new ClientOptions { BaseUrl = "https://{YOUR_DOMAIN}/api/v2" }
        );

        await client.Connections.ListAsync(
            new ListConnectionsQueryParameters {
                From = "from",
                Take = 1,
                Strategy = new List<ConnectionStrategyEnum>(){
                    ConnectionStrategyEnum.Ad,
                }
                ,
                Name = "name",
                Fields = "fields",
                IncludeFields = true
            }
        );
    }

}

package example

import (
    context "context"

    management "github.com/auth0/go-auth0/v3/management"
    client "github.com/auth0/go-auth0/v3/management/client"
    option "github.com/auth0/go-auth0/v3/management/option"
)

func do() {
    mgmt, err := client.New(
        "{YOUR_DOMAIN}",
        option.WithToken(
            "<token>",
        ),
    )
    if err != nil {
        return
    }
    request := &management.ListConnectionsQueryParameters{
        From: management.String(
            "from",
        ),
        Take: management.Int(
            1,
        ),
        Name: management.String(
            "name",
        ),
        Fields: management.String(
            "fields",
        ),
        IncludeFields: management.Bool(
            true,
        ),
    }
    mgmt.Connections.List(
        context.TODO(),
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.types.ConnectionStrategyEnum;
import com.auth0.client.mgmt.types.ListConnectionsQueryParameters;
import java.util.Arrays;

public class Example {
    public static void main(String[] args) {
        ManagementApi client = ManagementApi
            .builder()
            .domain("{YOUR_DOMAIN}")
            .token("<token>")
            .build();

        client.connections().list(
            ListConnectionsQueryParameters
                .builder()
                .strategy(
                    Arrays.asList(ConnectionStrategyEnum.AD)
                )
                .from("from")
                .take(1)
                .name("name")
                .fields("fields")
                .includeFields(true)
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\Connections\Requests\ListConnectionsQueryParameters;
use Auth0\SDK\API\Management\Types\ConnectionStrategyEnum;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->connections->list(
    new ListConnectionsQueryParameters([
        'from' => 'from',
        'take' => 1,
        'strategy' => [
            ConnectionStrategyEnum::Ad->value,
        ],
        'name' => 'name',
        'fields' => 'fields',
        'includeFields' => true,
    ]),
);

from auth0.management import ManagementClient

client = ManagementClient(
    domain="{YOUR_DOMAIN}",
    token="<token>",
)

client.connections.list(
    from="from",
    take=1,
    strategy=[
        "ad"
    ],
    name="name",
    fields="fields",
    include_fields=True,
)

require "auth0"

client = Auth0::Management.new(token: "<token>", base_url: "https://{YOUR_DOMAIN}/api/v2")

client.connections.list(
  from: "from",
  take: 1,
  strategy: ["ad"],
  name: "name",
  fields: "fields",
  include_fields: true
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.connections.list({
        from: "from",
        take: 1,
        name: "name",
        fields: "fields",
        includeFields: true,
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.connections.list({
        from: "from",
        take: 1,
        name: "name",
        fields: "fields",
        includeFields: true,
    });
}
main();

[
  {
    "authentication": {
      "active": true
    },
    "connected_accounts": {
      "active": true,
      "allow_missing_user_id": true,
      "cross_app_access": true
    },
    "cross_app_access_requesting_app": {
      "active": true
    },
    "cross_app_access_resource_app": {},
    "display_name": "<string>",
    "id": "con_0000000000000001",
    "is_domain_connection": true,
    "metadata": {},
    "name": "My connection",
    "options": {},
    "realms": [
      "<string>"
    ],
    "show_as_button": true,
    "strategy": "auth0"
  }
]

Obtenir les connexions

Récupère la liste détaillée de toutes les connexions correspondant à la stratégie spécifiée. Si aucune stratégie n’est fournie, toutes les connexions de votre tenant sont récupérées. Cette action peut accepter une liste de champs à inclure dans la liste de connexions obtenue ou à en exclure.

Cet endpoint prend en charge deux types de pagination :

Pagination par décalage
Pagination par checkpoint

La pagination par checkpoint doit être utilisée si vous devez récupérer plus de 1000 connexions.

Pagination par checkpoint

Pour effectuer une recherche par checkpoint, utilisez les paramètres suivants :

from : ID facultatif à partir duquel commencer la sélection.
take : Le nombre total d’entrées à récupérer lors de l’utilisation du paramètre from. La valeur par défaut est de 50.

Remarque : La première fois que vous appelez cet endpoint à l’aide de la pagination par checkpoint, omettez le paramètre from. S’il y a d’autres résultats, une valeur next est incluse dans la réponse. Vous pouvez l’utiliser pour les appels d’API suivants. Lorsque next n’est plus inclus dans la réponse, il ne reste plus d’autres pages.

GET

https://{tenantDomain}/api/v2

connections

using Auth0.ManagementApi;
using System.Threading.Tasks;
using System.Collections.Generic;

public partial class Examples
{
    public async Task Example() {
        var client = new ManagementApiClient(
            token: "<token>",
            clientOptions: new ClientOptions { BaseUrl = "https://{YOUR_DOMAIN}/api/v2" }
        );

        await client.Connections.ListAsync(
            new ListConnectionsQueryParameters {
                From = "from",
                Take = 1,
                Strategy = new List<ConnectionStrategyEnum>(){
                    ConnectionStrategyEnum.Ad,
                }
                ,
                Name = "name",
                Fields = "fields",
                IncludeFields = true
            }
        );
    }

}

package example

import (
    context "context"

    management "github.com/auth0/go-auth0/v3/management"
    client "github.com/auth0/go-auth0/v3/management/client"
    option "github.com/auth0/go-auth0/v3/management/option"
)

func do() {
    mgmt, err := client.New(
        "{YOUR_DOMAIN}",
        option.WithToken(
            "<token>",
        ),
    )
    if err != nil {
        return
    }
    request := &management.ListConnectionsQueryParameters{
        From: management.String(
            "from",
        ),
        Take: management.Int(
            1,
        ),
        Name: management.String(
            "name",
        ),
        Fields: management.String(
            "fields",
        ),
        IncludeFields: management.Bool(
            true,
        ),
    }
    mgmt.Connections.List(
        context.TODO(),
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.types.ConnectionStrategyEnum;
import com.auth0.client.mgmt.types.ListConnectionsQueryParameters;
import java.util.Arrays;

public class Example {
    public static void main(String[] args) {
        ManagementApi client = ManagementApi
            .builder()
            .domain("{YOUR_DOMAIN}")
            .token("<token>")
            .build();

        client.connections().list(
            ListConnectionsQueryParameters
                .builder()
                .strategy(
                    Arrays.asList(ConnectionStrategyEnum.AD)
                )
                .from("from")
                .take(1)
                .name("name")
                .fields("fields")
                .includeFields(true)
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\Connections\Requests\ListConnectionsQueryParameters;
use Auth0\SDK\API\Management\Types\ConnectionStrategyEnum;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->connections->list(
    new ListConnectionsQueryParameters([
        'from' => 'from',
        'take' => 1,
        'strategy' => [
            ConnectionStrategyEnum::Ad->value,
        ],
        'name' => 'name',
        'fields' => 'fields',
        'includeFields' => true,
    ]),
);

from auth0.management import ManagementClient

client = ManagementClient(
    domain="{YOUR_DOMAIN}",
    token="<token>",
)

client.connections.list(
    from="from",
    take=1,
    strategy=[
        "ad"
    ],
    name="name",
    fields="fields",
    include_fields=True,
)

require "auth0"

client = Auth0::Management.new(token: "<token>", base_url: "https://{YOUR_DOMAIN}/api/v2")

client.connections.list(
  from: "from",
  take: 1,
  strategy: ["ad"],
  name: "name",
  fields: "fields",
  include_fields: true
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.connections.list({
        from: "from",
        take: 1,
        name: "name",
        fields: "fields",
        includeFields: true,
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.connections.list({
        from: "from",
        take: 1,
        name: "name",
        fields: "fields",
        includeFields: true,
    });
}
main();

[
  {
    "authentication": {
      "active": true
    },
    "connected_accounts": {
      "active": true,
      "allow_missing_user_id": true,
      "cross_app_access": true
    },
    "cross_app_access_requesting_app": {
      "active": true
    },
    "cross_app_access_resource_app": {},
    "display_name": "<string>",
    "id": "con_0000000000000001",
    "is_domain_connection": true,
    "metadata": {},
    "name": "My connection",
    "options": {},
    "realms": [
      "<string>"
    ],
    "show_as_button": true,
    "strategy": "auth0"
  }
]

Autorisations

Authorization

string

header

requis

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Paramètres de requête

per_page

integer

Le nombre d’entrées par page. La valeur par défaut est de 100 si elle n’est pas fournie.

Plage requise: 1 <= x <= 100

page

integer

Le numéro de la page. Indexation à partir de zéro.

Plage requise: x >= 0

include_totals

boolean

true si un résumé de la requête doit être inclus dans le résultat, false sinon. N’est pas renvoyé lors de l’utilisation de la pagination par checkpoint. La valeur par défaut est false.

from

string

ID facultatif à partir duquel commencer la sélection.

take

integer

Nombre de résultats par page. La valeur par défaut est de 50.

Plage requise: 1 <= x <= 100

strategy

enum<string>[]

Indiquez des stratégies pour récupérer uniquement les connexions qui les utilisent.

Options disponibles:

ad,

adfs,

amazon,

apple,

dropbox,

bitbucket,

auth0-oidc,

auth0,

baidu,

bitly,

box,

custom,

daccount,

dwolla,

email,

evernote-sandbox,

evernote,

exact,

facebook,

fitbit,

github,

google-apps,

google-oauth2,

instagram,

ip,

line,

linkedin,

oauth1,

oauth2,

office365,

oidc,

okta,

paypal,

paypal-sandbox,

pingfederate,

planningcenter,

salesforce-community,

salesforce-sandbox,

salesforce,

samlp,

sharepoint,

shopify,

shop,

sms,

soundcloud,

thirtysevensignals,

twitter,

untappd,

vkontakte,

waad,

weibo,

windowslive,

wordpress,

yahoo,

yandex,

auth0-adldap

name

string

Indiquez le nom de la connexion à récupérer.

fields

string

Liste de champs séparés par des virgules à inclure ou à exclure du résultat (selon include_fields); laissez vide pour récupérer tous les champs.

include_fields

boolean

true si les champs indiqués doivent être inclus dans le résultat, false sinon (la valeur par défaut est true)

Réponse

Les connexions ont été récupérées.

Option 1 · object[]
Option 2 · object
Option 3 · object

authentication

object

Configure l’objectif d’une connexion à utiliser pour l’authentification pendant la connexion.

Show child attributes

connected_accounts

object

Configurer l’usage d’une connexion pour les comptes connectés et Token Vault.

Show child attributes

cross_app_access_requesting_app

object

Configurez la connexion à utiliser comme application demandeuse pour Cross App Access.

Show child attributes

cross_app_access_resource_app

object

Paramètres de l’application de ressources Cross App Access qui s’appliquent à cette connexion.

Show child attributes

display_name

string

Nom de la connexion utilisé dans l’écran de connexion

string

défaut:con_0000000000000001

L’identifiant de la connexion

is_domain_connection

boolean

True si la connexion est au domain level

metadata

object

Métadonnées associées à la connexion sous la forme d’un objet avec des valeurs de chaîne (max. 255 caractères). Un maximum de 10 propriétés de métadonnées est autorisé.

Show child attributes

name

string

défaut:My connection

Le nom de la connexion

options

object

Pour renvoyer les options dans la réponse, le scope read:connections_options doit être présent

realms

string<connection-realm>[]

Définit les realms pour lesquels la connexion sera utilisée (c.-à-d. les domaines de courriel). Si le array est vide ou si la propriété n’est pas précisée, le nom de la connexion sera ajouté comme realm.

Le realm auquel cette connexion appartient

show_as_button

boolean

Active l’affichage d’un bouton pour la connexion sur la login page (nouvelle expérience seulement). Si false, elle ne pourra être utilisée que par HRD.

strategy

string

défaut:auth0

Le type de la connexion, lié au fournisseur d’identité