Global Pays - Manual API

<?php

/**
 * Exemplo compatível com PHP 8.0 ou superior.
 *
 * Reutiliza o Token armazenado em cache enquanto ele estiver válido.
 * Um novo Token é solicitado apenas quando necessário, evitando
 * requisições excessivas à rota /auth (HTTP 429).
 */
class ParceladoUsaAuthClient
{
    // URL do ambiente Sandbox.
    // Em produção, utilize a URL correspondente ao ambiente produtivo.
    private const AUTH_URL =
        'https://apisandbox.parceladousa.com/v1/paymentapi/auth';

    // Armazene o arquivo fora da pasta pública da aplicação.
    private const CACHE_FILE = __DIR__ . '/parceladousa_token.json';

    // Renova o Token 60 segundos antes do vencimento.
    private const SAFETY_MARGIN_SECONDS = 60;

    public function __construct(
        private string $pubKey,
        private string $merchantCode
    ) {
    }

    public function getValidToken(): string
    {
        $cached = $this->readCache();

        if (
            isset($cached['token'], $cached['expirate']) &&
            $this->isStillValid($cached['expirate'])
        ) {
            return $cached['token'];
        }

        return $this->requestNewToken();
    }

    private function isStillValid(string $expirate): bool
    {
        $expiresAt = strtotime($expirate); // "expirate": "Y-m-d H:i:s"

        return $expiresAt !== false
            && $expiresAt > time() + self::SAFETY_MARGIN_SECONDS;
    }

    private function requestNewToken(): string
    {
        $payload = json_encode([
            'pubKey' => $this->pubKey,
            'merchantCode' => $this->merchantCode,
        ]);

        if ($payload === false) {
            throw new \RuntimeException(
                'Não foi possível gerar os dados da autenticação.'
            );
        }

        $ch = curl_init(self::AUTH_URL);

        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_POST => true,
            CURLOPT_HTTPHEADER => [
                'Content-Type: application/json',
                'Accept: application/json',
            ],
            CURLOPT_POSTFIELDS => $payload,
            CURLOPT_CONNECTTIMEOUT => 10,
            CURLOPT_TIMEOUT => 30,
        ]);

        $response = curl_exec($ch);
        $curlError = curl_error($ch);
        $httpCode = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);

        curl_close($ch);

        if ($response === false) {
            throw new \RuntimeException(
                'Erro de conexão com a API: ' . $curlError
            );
        }

        if ($httpCode === 429) {
            throw new \RuntimeException(
                'Limite de solicitações de Token excedido (HTTP 429).'
            );
        }

        if ($httpCode < 200 || $httpCode >= 300) {
            throw new \RuntimeException(
                "Erro ao solicitar o Token (HTTP {$httpCode})."
            );
        }

        $data = json_decode($response, true);

        if (
            !is_array($data) ||
            !isset($data['token'], $data['expirate'])
        ) {
            throw new \RuntimeException(
                'A API retornou uma resposta de autenticação inválida.'
            );
        }

        $cache = json_encode([
            'token' => $data['token'],
            'expirate' => $data['expirate'],
        ]);

        if (
            $cache === false ||
            file_put_contents(self::CACHE_FILE, $cache, LOCK_EX) === false
        ) {
            throw new \RuntimeException(
                'Não foi possível salvar o Token em cache.'
            );
        }

        return $data['token'];
    }

    private function readCache(): ?array
    {
        if (!is_file(self::CACHE_FILE)) {
            return null;
        }

        $content = file_get_contents(self::CACHE_FILE);

        if ($content === false) {
            return null;
        }

        $data = json_decode($content, true);

        return is_array($data) ? $data : null;
    }
}

// Exemplo de uso:
$auth = new ParceladoUsaAuthClient(
    'SEU_PUBKEY',
    'SEU_MERCHANT_CODE'
);

$token = $auth->getValidToken();

/**
 * Exemplo compatível com Node.js 18 ou superior.
 *
 * Reutiliza o Token em memória enquanto ele estiver válido e só solicita um
 * novo quando necessário, evitando requisições excessivas à rota /auth
 * (HTTP 429). Em ambientes serverless ou com múltiplas instâncias,
 * substitua o cache em memória por Redis ou banco de dados.
 */

// URL do ambiente Sandbox.
// Em produção, utilize a URL correspondente ao ambiente produtivo.
const AUTH_URL = 'https://apisandbox.parceladousa.com/v1/paymentapi/auth';

// Renova o Token 60 segundos antes do vencimento.
const SAFETY_MARGIN_MS = 60 * 1000;

const REQUEST_TIMEOUT_MS = 30 * 1000;

let cachedToken = null;
let cachedExpiresAt = null;

async function getValidToken(pubKey, merchantCode) {
    if (cachedToken && Date.now() < cachedExpiresAt - SAFETY_MARGIN_MS) {
        return cachedToken;
    }

    return requestNewToken(pubKey, merchantCode);
}

async function requestNewToken(pubKey, merchantCode) {
    let response;

    try {
        response = await fetch(AUTH_URL, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                Accept: 'application/json',
            },
            body: JSON.stringify({ pubKey, merchantCode }),
            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
        });
    } catch (error) {
        throw new Error(`Erro de conexão com a API: ${error.message}`);
    }

    if (response.status === 429) {
        throw new Error('Limite de solicitações de Token excedido (HTTP 429).');
    }

    if (!response.ok) {
        throw new Error(`Erro ao solicitar o Token (HTTP ${response.status}).`);
    }

    const data = await response.json();

    if (!data?.token || !data?.expirate) {
        throw new Error('A API retornou uma resposta de autenticação inválida.');
    }

    // "expirate": "YYYY-MM-DD HH:mm:ss" -> converte para timestamp.
    const expiresAt = new Date(data.expirate.replace(' ', 'T')).getTime();

    if (Number.isNaN(expiresAt)) {
        throw new Error('A data de expiração do Token é inválida.');
    }

    cachedToken = data.token;
    cachedExpiresAt = expiresAt;

    return cachedToken;
}

// Exemplo de uso:
const token = await getValidToken('SEU_PUBKEY', 'SEU_MERCHANT_CODE');