Autenticação - FlexExtractor

curl -X POST "https://hml.flexextractor.com.br/api/v2/Security/GetToken" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "username=seu_username" \
  -d "password=sua_senha"

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

async function getFlexExtractorToken(username, password) {
  try {
    const response = await axios.post(
      'https://hml.flexextractor.com.br/api/v2/Security/GetToken',
      qs.stringify({
        username: username,
        password: password
      }),
      {
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      }
    );

    const { access_token, expires_in, refresh_token } = response.data;

    console.log('✓ Token obtido com sucesso!');
    console.log('Expira em:', expires_in, 'segundos');

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

// Uso
getFlexExtractorToken('seu_username', 'sua_senha')
  .then(tokens => {
    console.log('Access Token:', tokens.accessToken.substring(0, 50) + '...');
  });

import requests
from datetime import datetime, timedelta

def get_flexextractor_token(username: str, password: str):
    """
    Obtém token de acesso FlexExtractor

    Args:
        username: Nome de usuário
        password: Senha

    Returns:
        dict: Contendo access_token, refresh_token e expiration_time
    """
    url = "https://hml.flexextractor.com.br/api/v2/Security/GetToken"

    data = {
        'username': username,
        'password': password
    }

    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']
        refresh_token = token_data.get('refresh_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': access_token,
            'refresh_token': refresh_token,
            'expiration_time': expiration_time
        }

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

# Uso
if __name__ == "__main__":
    tokens = get_flexextractor_token('seu_username', 'sua_senha')
    print(f"\nToken: {tokens['access_token'][:50]}...")

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

public class FlexExtractorAuthClient {

    private static final String TOKEN_URL =
        "https://hml.flexextractor.com.br/api/v2/Security/GetToken";

    public static class TokenResponse {
        public String access_token;
        public String refresh_token;
        public String token_type;
        public int expires_in;
        public int refresh_expires_in;
        public String id_token;
        public String session_state;
        public String scope;
    }

    public static TokenResponse getAccessToken(String username, String password)
            throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        String body = "username=" + URLEncoder.encode(username, "UTF-8") +
                      "&password=" + URLEncoder.encode(password, "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("seu_username", "sua_senha");
            System.out.println("\nToken: " +
                token.access_token.substring(0, 50) + "...");
        } catch (Exception e) {
            System.err.println("Erro: " + e.getMessage());
        }
    }
}

<?php

function getFlexExtractorToken($username, $password) {
    $url = 'https://hml.flexextractor.com.br/api/v2/Security/GetToken';

    $data = [
        'username' => $username,
        'password' => $password
    ];

    $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 [
            'access_token' => $tokenData['access_token'],
            'refresh_token' => $tokenData['refresh_token'] ?? null,
            'expires_at' => $expiresAt
        ];
    } else {
        throw new Exception("Erro ao obter token: {$response}");
    }
}

// Uso
try {
    $tokens = getFlexExtractorToken('seu_username', 'sua_senha');
    echo "\nToken: " . substr($tokens['access_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"`
    RefreshToken     string `json:"refresh_token"`
    TokenType        string `json:"token_type"`
    ExpiresIn        int    `json:"expires_in"`
    RefreshExpiresIn int    `json:"refresh_expires_in"`
    IDToken          string `json:"id_token"`
    SessionState     string `json:"session_state"`
    Scope            string `json:"scope"`
}

func getFlexExtractorToken(username, password string) (*TokenResponse, error) {
    tokenURL := "https://hml.flexextractor.com.br/api/v2/Security/GetToken"

    data := url.Values{}
    data.Set("username", username)
    data.Set("password", password)

    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 := getFlexExtractorToken("seu_username", "sua_senha")
    if err != nil {
        fmt.Printf("Erro: %v\n", err)
        return
    }

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