Autenticação OAuth 2.0

CLIENT_ID=teste-api
CLIENT_SECRET=pwR8GPipQvifGhSIH7cH07OOCXd2C8Hg

curl -X POST "https://auth-des.flexdoc-apis.com.br/realms/fleximage/protocol/openid-connect/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials" \
  -d "client_id=teste-api" \
  -d "client_secret=pwR8GPipQvifGhSIH7cH07OOCXd2C8Hg"

const axios = require('axios');
const qs = require('qs');

async function getAccessToken() {
  try {
    const response = await axios.post(
      'https://auth-des.flexdoc-apis.com.br/realms/fleximage/protocol/openid-connect/token',
      qs.stringify({
        grant_type: 'client_credentials',
        client_id: 'teste-api',
        client_secret: 'pwR8GPipQvifGhSIH7cH07OOCXd2C8Hg'
      }),
      {
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      }
    );

    const { access_token, expires_in } = response.data;
    console.log('Token obtido com sucesso!');
    console.log('Expira em:', expires_in, 'segundos');

    return access_token;
  } catch (error) {
    console.error('Erro ao obter token:', error.response?.data || error.message);
    throw error;
  }
}

// Uso
getAccessToken().then(token => {
  console.log('Token:', token);
});

import requests
from datetime import datetime, timedelta

def get_access_token():
    """
    Obtém token de acesso OAuth 2.0
    Retorna: (access_token, expiration_time)
    """
    url = "https://auth-des.flexdoc-apis.com.br/realms/fleximage/protocol/openid-connect/token"

    data = {
        'grant_type': 'client_credentials',
        'client_id': 'teste-api',
        'client_secret': 'pwR8GPipQvifGhSIH7cH07OOCXd2C8Hg'
    }

    headers = {
        'Content-Type': 'application/x-www-form-urlencoded'
    }

    try:
        response = requests.post(url, data=data, headers=headers)
        response.raise_for_status()

        token_data = response.json()
        access_token = token_data['access_token']
        expires_in = token_data['expires_in']

        # Calcula horário de expiração
        expiration_time = datetime.now() + timedelta(seconds=expires_in)

        print(f"✓ Token obtido com sucesso!")
        print(f"Expira em: {expiration_time.strftime('%Y-%m-%d %H:%M:%S')}")

        return access_token, expiration_time

    except requests.exceptions.RequestException as e:
        print(f"✗ Erro ao obter token: {e}")
        raise

# Uso
if __name__ == "__main__":
    token, expires_at = get_access_token()
    print(f"\nToken: {token[:50]}...")

import java.net.http.*;
import java.net.*;
import java.time.*;
import com.google.gson.*;

public class FlexdocAuthClient {

    private static final String TOKEN_URL =
        "https://auth-des.flexdoc-apis.com.br/realms/fleximage/protocol/openid-connect/token";
    private static final String CLIENT_ID = "teste-api";
    private static final String CLIENT_SECRET = "pwR8GPipQvifGhSIH7cH07OOCXd2C8Hg";

    public static class TokenResponse {
        public String access_token;
        public String token_type;
        public int expires_in;
        public String scope;
    }

    public static TokenResponse getAccessToken() throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        String body = "grant_type=client_credentials" +
                      "&client_id=" + URLEncoder.encode(CLIENT_ID, "UTF-8") +
                      "&client_secret=" + URLEncoder.encode(CLIENT_SECRET, "UTF-8");

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(TOKEN_URL))
            .header("Content-Type", "application/x-www-form-urlencoded")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() == 200) {
            Gson gson = new Gson();
            TokenResponse tokenResponse = gson.fromJson(
                response.body(),
                TokenResponse.class
            );

            Instant expiresAt = Instant.now().plusSeconds(tokenResponse.expires_in);
            System.out.println("✓ Token obtido com sucesso!");
            System.out.println("Expira em: " + expiresAt);

            return tokenResponse;
        } else {
            throw new RuntimeException("Erro ao obter token: " + response.body());
        }
    }

    public static void main(String[] args) {
        try {
            TokenResponse token = getAccessToken();
            System.out.println("\nToken: " +
                token.access_token.substring(0, 50) + "...");
        } catch (Exception e) {
            System.err.println("Erro: " + e.getMessage());
        }
    }
}

<?php

function getAccessToken() {
    $url = 'https://auth-des.flexdoc-apis.com.br/realms/fleximage/protocol/openid-connect/token';

    $data = [
        'grant_type' => 'client_credentials',
        'client_id' => 'teste-api',
        'client_secret' => 'pwR8GPipQvifGhSIH7cH07OOCXd2C8Hg'
    ];

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($data));
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Content-Type: application/x-www-form-urlencoded'
    ]);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode === 200) {
        $tokenData = json_decode($response, true);
        $expiresAt = date('Y-m-d H:i:s', time() + $tokenData['expires_in']);

        echo "✓ Token obtido com sucesso!\n";
        echo "Expira em: {$expiresAt}\n";

        return $tokenData['access_token'];
    } else {
        throw new Exception("Erro ao obter token: {$response}");
    }
}

// Uso
try {
    $token = getAccessToken();
    echo "\nToken: " . substr($token, 0, 50) . "...\n";
} catch (Exception $e) {
    echo "Erro: " . $e->getMessage() . "\n";
}
?>

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strings"
    "time"
)

type TokenResponse struct {
    AccessToken      string `json:"access_token"`
    TokenType        string `json:"token_type"`
    ExpiresIn        int    `json:"expires_in"`
    RefreshExpiresIn int    `json:"refresh_expires_in"`
    Scope            string `json:"scope"`
}

func getAccessToken() (*TokenResponse, error) {
    tokenURL := "https://auth-des.flexdoc-apis.com.br/realms/fleximage/protocol/openid-connect/token"

    data := url.Values{}
    data.Set("grant_type", "client_credentials")
    data.Set("client_id", "teste-api")
    data.Set("client_secret", "pwR8GPipQvifGhSIH7cH07OOCXd2C8Hg")

    req, err := http.NewRequest("POST", tokenURL, strings.NewReader(data.Encode()))
    if err != nil {
        return nil, err
    }

    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

    client := &http.Client{Timeout: 10 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("erro ao obter token: %s", string(body))
    }

    var tokenResp TokenResponse
    if err := json.Unmarshal(body, &tokenResp); err != nil {
        return nil, err
    }

    expiresAt := time.Now().Add(time.Duration(tokenResp.ExpiresIn) * time.Second)
    fmt.Printf("✓ Token obtido com sucesso!\n")
    fmt.Printf("Expira em: %s\n", expiresAt.Format("2006-01-02 15:04:05"))

    return &tokenResp, nil
}

func main() {
    tokenResp, err := getAccessToken()
    if err != nil {
        fmt.Printf("Erro: %v\n", err)
        return
    }

    fmt.Printf("\nToken: %s...\n", tokenResp.AccessToken[:50])
}