• Objectifs : appeler une API REST protégée par jeton depuis Power Query ; paramétrer la requête et la transformer en fonction réutilisable ; empaqueter la connexion dans un connecteur personnalisé avec le Power Query SDK ; découvrir l'API REST Power BI.
• Prérequis : maîtrise de Power Query et notions de langage M (partie 2) ; Visual Studio Code pour le connecteur.
• Niveau : avancé.
• Licence requise : aucune pour Power BI Desktop ; actualisation dans le service selon la source (passerelle pour un connecteur personnalisé).

1. Authentification : une requête POST envoie une clé d'API ou un couple identifiant et mot de passe et reçoit un jeton.
2. Appel de l'API : une requête GET transmet le jeton dans l'en-tête Authorization: Bearer <jeton> et reçoit une réponse JSON.
3. Mise en table : la réponse (souvent un champ data contenant une liste d'enregistrements) est convertie en table puis développée.

let
    // ====== Paramètres ======
    AuthBaseUrl = paramAuthBaseURL,
    LoginPath   = paramLoginPath,
    ApiBaseUrl  = paramApiBaseUrl,
    ApiPath     = paramApiPath,
    // Pour obtenir le jeton : adresse et mot de passe...
    Email    = paramEmail,
    Password = paramPassword,
    // ...ou clé d'API. Valeurs fournies par le formateur, jamais en clair dans un fichier diffusé
    APIKey = paramAPIKey,
    // ====== 1) Authentification : POST JSON, réponse JSON contenant le jeton ======
    LoginBody =
        Json.FromValue([
            email = Email,
            password = Password
        ]),
    LoginResponse =
        Json.Document(
            Web.Contents(
                AuthBaseUrl,
                [
                    RelativePath = LoginPath,
                    Headers = [
                        #"Content-Type" = "application/json",
                        #"X-API-Key" = APIKey,
                        Accept = "application/json"
                    ],
                    Content = LoginBody,
                    ManualStatusHandling = {400, 401, 403, 500}
                ]
            )
        ),
    // Adapter le champ selon la réponse réelle : token, access_token...
    Token =
        if Record.HasFields(LoginResponse, "token") then LoginResponse[token]
        else if Record.HasFields(LoginResponse, "access_token") then LoginResponse[access_token]
        else error "Champ token introuvable dans la réponse d'authentification.",
    // ====== 2) Appel de l'API avec le jeton Bearer ======
    WebContent =
        Web.Contents(
            ApiBaseUrl,
            [
                RelativePath = ApiPath,
                Headers = [
                    Authorization = "Bearer " & Token,
                    Accept = "application/json"
                ],
                Timeout = #duration(0, 0, 2, 0),
                ManualStatusHandling = {400, 401, 403, 500}
            ]
        ),
    ApiResponse = Json.Document(WebContent),
    // ====== 3) Mise en table ======
    data1 = ApiResponse[data],
    #"Converti en table" = Table.FromList(data1, Splitter.SplitByNothing(), null, null, ExtraValues.Error)
in
    #"Converti en table"

let
    Source = fctAPI("/api/clients", paramAuthBaseURL, paramLoginPath, paramApiBaseUrl)
in
    Source

section ClientVentes;

// ===========================
//  PUBLISH (entrée dans "Obtenir des données")
// ===========================
[DataSource.Kind="ClientVentes", Publish="ClientVentes.Publish"]
shared ClientVentes.Contents =
    Value.ReplaceType(ClientVentesImpl,
        type function (
            ApiBaseUrl as (type text meta [Documentation.FieldCaption="API Base URL, par ex. https://<votre-api>/functions/v1"]),
            ApiPathClients as (type text meta [Documentation.FieldCaption="Chemin Clients par ex. /api/clients", Publish.Preview.Default="/api/clients"]),
            ApiPathVentes as (type text meta [Documentation.FieldCaption="Chemin Ventes par ex. /api/ventes", Publish.Preview.Default="/api/ventes"]),
            AuthBaseUrl as (type text meta [Documentation.FieldCaption="Auth Base URL, par ex. https://<votre-api>", Publish.Preview.Default="https://<votre-api>"]),
            optional LoginPath as (type text meta [Documentation.FieldCaption="Login/Token Path", Publish.Preview.Default="/api/auth/token-from-key"]),
            optional APIKey as (type text meta [Documentation.FieldCaption="API Key (prioritaire si non vide)"]),
            optional ClientId as (type text meta [Documentation.FieldCaption="Client ID"]),
            optional ClientSecret as (type text meta [Documentation.FieldCaption="Client Secret"]),
            optional Scope as (type text meta [Documentation.FieldCaption="Scope"]),
            optional Email as (type text meta [Documentation.FieldCaption="Email"]),
            optional Password as (type text meta [Documentation.FieldCaption="Password"])
        ) as table
    );

// ===========================
//  IMPL
// ===========================
ClientVentesImpl =
(
    ApiBaseUrl as text,
    ApiPathClients as text,
    ApiPathVentes as text,
    AuthBaseUrl as text,
    optional LoginPath as nullable text,
    optional APIKey as nullable text,
    optional ClientId as nullable text,
    optional ClientSecret as nullable text,
    optional Scope as nullable text,
    optional Email as nullable text,
    optional Password as nullable text
) as table =>
let
    // ---- Defaults (adapter) ----
    _ApiBaseUrl     = ApiBaseUrl,
    _ApiPathClients = ApiPathClients,
    _ApiPathVentes  = ApiPathVentes,
    _AuthBaseUrl    = AuthBaseUrl,
    _LoginPath      = if IsNonEmpty(LoginPath) then LoginPath else "/api/auth/token-from-key",

    // ---- Auth precedence ----
    Headers = GetAuthHeaders(_AuthBaseUrl, _LoginPath, APIKey, ClientId, ClientSecret, Scope, Email, Password),

    // ---- Calls ----
    ClientsJson = CallApiJson(_ApiBaseUrl, _ApiPathClients, Headers),
    VentesJson  = CallApiJson(_ApiBaseUrl, _ApiPathVentes,  Headers),

    ClientsData = GetDataArray(ClientsJson),
    VentesData  = GetDataArray(VentesJson),

    TblClients  = Table.FromList(ClientsData, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
    TblClients2 =
        if Table.RowCount(TblClients) > 0 and Value.Is(TblClients{0}[Column1], type record)
        then Table.ExpandRecordColumn(TblClients, "Column1", Record.FieldNames(TblClients{0}[Column1]))
        else TblClients,

    TblVentes   = Table.FromList(VentesData, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
    TblVentes2  =
        if Table.RowCount(TblVentes) > 0 and Value.Is(TblVentes{0}[Column1], type record)
        then Table.ExpandRecordColumn(TblVentes, "Column1", Record.FieldNames(TblVentes{0}[Column1]))
        else TblVentes,

    // ---- Navigation table (Clients & Ventes) ----
    Nav = #table(
        type table [Name = text, Data = any, ItemKind = text, ItemName = text, IsLeaf = logical],
        {
            {"Clients", TblClients2, "Table", "Table", true},
            {"Ventes",  TblVentes2,  "Table", "Table", true}
        }
    )
    //Nav2 = Table.ToNavigationTable(Nav, {"Name"}, "Name", "Data", "ItemKind", "ItemName", "IsLeaf")
in
    Nav;

// ===========================
//  AUTH HELPERS
// ===========================
GetAuthHeaders =
(
    AuthBaseUrl as text,
    LoginPath as text,
    APIKey as nullable text,
    ClientId as nullable text,
    ClientSecret as nullable text,
    Scope as nullable text,
    Email as nullable text,
    Password as nullable text
) as record =>
let
    HasApiKey     = IsNonEmpty(APIKey),
    HasClientCred = IsNonEmpty(ClientId) and IsNonEmpty(ClientSecret),
    HasUserPass   = IsNonEmpty(Email) and IsNonEmpty(Password),

    Result =
        if HasApiKey then
            // Mode 1 : APIKey uniquement (prioritaire)
            [Accept="application/json", #"X-API-Key"=Text.From(APIKey)]
        else if HasClientCred then
            // Mode 2 : Client credentials -> token -> Bearer
            let
                Token = GetToken_ClientCredentials(AuthBaseUrl, LoginPath, Text.From(ClientId), Text.From(ClientSecret), Scope),
                TokenType = "Bearer"
            in
                [Accept="application/json", Authorization = TokenType & " " & Token]
        else if HasUserPass then
            // Mode 3 : Email/Password -> token -> Bearer
            let
                Token = GetToken_EmailPassword(AuthBaseUrl, LoginPath, Text.From(Email), Text.From(Password)),
                TokenType = "Bearer"
            in
                [Accept="application/json", Authorization = TokenType & " " & Token]
        else
            error "Aucune auth valide : renseigner APIKey, ou ClientId+ClientSecret, ou Email+Password."
in
    Result;

GetToken_ClientCredentials =
(AuthBaseUrl as text, LoginPath as text, ClientId as text, ClientSecret as text, Scope as nullable text) as text =>
let
    BodyText =
        Uri.BuildQueryString([
            grant_type    = "client_credentials",
            client_id     = ClientId,
            client_secret = ClientSecret,
            scope         = if Scope = null then "" else Text.From(Scope)
        ]),
    Resp =
        Json.Document(
            Web.Contents(
                AuthBaseUrl,
                [
                    RelativePath = LoginPath,
                    Headers = [
                        #"Content-Type" = "application/x-www-form-urlencoded",
                        Accept          = "application/json"
                    ],
                    Content = Text.ToBinary(BodyText),
                    ManualStatusHandling = {400,401,403,500}
                ]
            )
        ),
    Tok =
        if Record.HasFields(Resp, "access_token") then Text.From(Resp[access_token])
        else if Record.HasFields(Resp, "token") then Text.From(Resp[token])
        else error "Token introuvable (client_credentials)."
in
    Tok;

GetToken_EmailPassword =
(AuthBaseUrl as text, LoginPath as text, Email as text, Password as text) as text =>
let
    LoginBody = Json.FromValue([ email = Email, password = Password ]),
    Resp =
        Json.Document(
            Web.Contents(
                AuthBaseUrl,
                [
                    RelativePath = LoginPath,
                    Headers = [
                        #"Content-Type" = "application/json",
                        Accept          = "application/json"
                    ],
                    Content = LoginBody,
                    ManualStatusHandling = {400,401,403,500}
                ]
            )
        ),
    Tok =
        if Record.HasFields(Resp, "token") then Text.From(Resp[token])
        else if Record.HasFields(Resp, "access_token") then Text.From(Resp[access_token])
        else if Record.HasFields(Resp, "data") and Record.HasFields(Resp[data], "token") then Text.From(Resp[data][token])
        else error "Token introuvable (email/password)."
in
    Tok;

// ===========================
//  API HELPERS
// ===========================
CallApiJson =
(ApiBaseUrl as text, ApiPath as text, Headers as record) as any =>
let
    Bin =
        Web.Contents(
            ApiBaseUrl,
            [
                RelativePath = ApiPath,
                Headers = Headers,
                Timeout = #duration(0,0,2,0),
                ManualStatusHandling = {400,401,403,500}
            ]
        ),
    J = Json.Document(Bin)
in
    J;

GetDataArray = (ApiResponse as any) as list =>
    if Value.Is(ApiResponse, type record) and Record.HasFields(ApiResponse, "data") and Value.Is(ApiResponse[data], type list)
    then ApiResponse[data]
    else if Value.Is(ApiResponse, type list)
    then ApiResponse
    else {};

IsNonEmpty = (v as any) as logical =>
    v <> null and Text.Trim(Text.From(v)) <> "";

// ===========================
//  KIND / PUBLISH METADATA
// ===========================
ClientVentes = [
    TestConnection = (dataSourcePath) => { "ClientVentes.Contents", dataSourcePath },
    Authentication = [
        Anonymous = []   // Les secrets sont passés en paramètres dans cette version (APIKey/ClientId/Email...)
    ],
    Label = "Client & Ventes",
    SupportsEncryption = true
];

ClientVentes.Publish = [
    Beta = true,
    Category = "Other",
    ButtonText = { "Client & Ventes", "Connexion à l'API Client & Ventes" },
    SourceImage = ClientVentes.Icons,
    SourceTypeImage = ClientVentes.Icons,
    LearnMoreUrl = "https://<adresse-de-la-documentation-du-connecteur>",
    SupportsDirectQuery = false
];

ClientVentes.Icons = [
    Icon16 = { Extension.Contents("ClientVentes16.png"), Extension.Contents("ClientVentes20.png"), Extension.Contents("ClientVentes24.png"), Extension.Contents("ClientVentes32.png") },
    Icon32 = { Extension.Contents("ClientVentes32.png"), Extension.Contents("ClientVentes40.png"), Extension.Contents("ClientVentes48.png"), Extension.Contents("ClientVentes64.png") }
];

POST https://api.powerbi.com/v1.0/myorg/groups/{groupId}/datasets/{datasetId}/refreshes
Authorization: Bearer <jeton>
Content-Type: application/json

{ "notifyOption": "MailOnFailure" }

• Les requêtes POST de Web.Contents ne fonctionnent qu'avec des informations d'identification anonymes.
• ManualStatusHandling permet de lire le corps d'une réponse d'erreur au lieu d'un échec immédiat : testez le code de retour avec Value.Metadata(WebContent)[Response.Status].
• Le délai d'attente par défaut de Web.Contents est de 100 secondes ; l'option Timeout le modifie.
• Gérez la pagination de l'API (paramètres offset et limit, ou lien vers la page suivante) avec une fonction récursive ou List.Generate (page Techniques avancées en M, partie 2).
• Un connecteur personnalisé s'actualise dans le service via une passerelle de données locale sur laquelle il est installé.
• Ne publiez jamais un fichier, une page ou un dépôt contenant une clé ou un mot de passe ; si cela arrive, révoquez la clé immédiatement.

• Web.Contents + RelativePath : une URL de base fixe pour que le service accepte l'actualisation.
• Authentification, appel avec le jeton Bearer, mise en table : trois étapes.
• Aucun secret en clair dans un fichier diffusé : authentification déclarée dans le connecteur, ou option ApiKeyName.
• Power Query SDK dans VS Code : projet, test, génération du .mez.

• Web.Contents. Source
• Actualisation et sources de données dynamiques. Source
• Vue d'ensemble du Power Query SDK. Source
• Gestion de l'authentification dans un connecteur. Source
• Extensibilité des connecteurs dans Power BI. Source
• API REST Power BI. Source