Documentação Completa

baseUrl = rtrim($baseUrl, '/') . '/api';
        }
    }

    /**
     * Adiciona uma nova conexão Bull-ex
     */
    public function addConnection($email, $password, $connectionId = null) {
        $data = [
            'email' => $email,
            'password' => $password
        ];

        if ($connectionId) {
            $data['connection_id'] = $connectionId;
        }

        return $this->makeRequest('POST', '/connections', $data);
    }

    /**
     * Obtém status de todas as conexões
     */
    public function getStatus() {
        return $this->makeRequest('GET', '/status');
    }

    /**
     * Obtém saldos de todas as contas
     */
    public function getAllBalances() {
        return $this->makeRequest('GET', '/balances');
    }

    /**
     * Obtém PnL agregado
     */
    public function getAggregatedPnL($date = null) {
        $url = '/pnl/aggregated';
        if ($date) {
            $url .= '?date=' . urlencode($date);
        }
        return $this->makeRequest('GET', $url);
    }

    /**
     * Obtém saldo de conexão específica
     */
    public function getConnectionBalance($connectionId) {
        return $this->makeRequest('GET', "/connections/{$connectionId}/balance");
    }

    /**
     * Obtém histórico de conexão específica
     */
    public function getConnectionHistory($connectionId, $limit = 100) {
        return $this->makeRequest('GET', "/connections/{$connectionId}/history?limit={$limit}");
    }

    /**
     * Remove uma conexão
     */
    public function removeConnection($connectionId) {
        return $this->makeRequest('DELETE', "/connections/{$connectionId}");
    }

    /**
     * Faz requisição HTTP
     */
    private function makeRequest($method, $endpoint, $data = null) {
        $url = $this->baseUrl . $endpoint;

        $ch = curl_init();
        curl_setopt_array($ch, [
            CURLOPT_URL => $url,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_TIMEOUT => $this->timeout,
            CURLOPT_HTTPHEADER => [
                'Content-Type: application/json',
                'Accept: application/json',
                'User-Agent: BullexAnalytics-PHP/1.0'
            ]
        ]);

        if ($method === 'POST') {
            curl_setopt($ch, CURLOPT_POST, true);
            if ($data) {
                curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
            }
        } elseif ($method === 'DELETE') {
            curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
        }

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

        if ($error) {
            throw new Exception("cURL Error: " . $error);
        }

        return [
            'status_code' => $httpCode,
            'data' => json_decode($response, true),
            'raw_response' => $response
        ];
    }
}

// Exemplo de uso
try {
    $api = new BullexAnalyticsAPI();

    // Adicionar conexão
    $result = $api->addConnection('email@dominio.com', '123456');

    if ($result['data']['success']) {
        $connectionId = $result['data']['connection_id'];
        echo "✅ Conexão adicionada: {$connectionId}\n";

        // Aguardar conexão estabelecer
        sleep(3);

        // Obter saldo
        $balance = $api->getConnectionBalance($connectionId);
        echo "💰 Saldo: " . json_encode($balance['data']) . "\n";

        // Obter histórico
        $history = $api->getConnectionHistory($connectionId, 50);
        $tradeCount = count($history['data']['data'] ?? []);
        echo "📊 Histórico: {$tradeCount} trades\n";

        // PnL agregado
        $pnl = $api->getAggregatedPnL();
        $totalPnl = $pnl['data']['data']['total_pnl'] ?? 0;
        echo "📈 PnL Total: R$ {$totalPnl}\n";
    } else {
        echo "❌ Erro: " . ($result['data']['message'] ?? 'Erro desconhecido') . "\n";
    }

} catch (Exception $e) {
    echo "🔥 Exception: " . $e->getMessage() . "\n";
}
?>

# Adicionar conexão
curl http://localhost:5000/api/status

# Verificar status
curl -X GET "http://localhost:5000/api/status" \
  -H "Content-Type: application/json"

# Consultar saldo
curl -X GET "http://localhost:5000/api/balances" \
  -H "Accept: application/json"

# Obter histórico
curl -X GET "http://localhost:5000/api/connections/abc123/history?limit=50" \
  -H "Accept: application/json"

# PnL agregado
curl -X GET "http://localhost:5000/api/pnl/aggregated?date=2024-08-09" \
  -H "Accept: application/json"

import requests
import json
import time

class BullexAnalyticsAPI:
    def __init__(self, base_url="http://localhost:5000"):
        self.base_url = base_url.rstrip('/') + '/api'
        self.session = requests.Session()
        self.session.headers.update({
            'Content-Type': 'application/json',
            'Accept': 'application/json',
            'User-Agent': 'BullexAnalytics-Python/1.0'
        })

    def add_connection(self, email, password, connection_id=None):
        """Adiciona nova conexão"""
        data = {'email': email, 'password': password}
        if connection_id:
            data['connection_id'] = connection_id

        response = self.session.post(f'{self.base_url}/connections', json=data)
        return self._handle_response(response)

    def get_status(self):
        """Obtém status das conexões"""
        response = self.session.get(f'{self.base_url}/status')
        return self._handle_response(response)

    def get_all_balances(self):
        """Obtém saldos de todas as contas"""
        response = self.session.get(f'{self.base_url}/balances')
        return self._handle_response(response)

    def get_aggregated_pnl(self, date=None):
        """Obtém PnL agregado"""
        url = f'{self.base_url}/pnl/aggregated'
        if date:
            url += f'?date={date}'

        response = self.session.get(url)
        return self._handle_response(response)

    def get_connection_balance(self, connection_id):
        """Obtém saldo de conexão específica"""
        response = self.session.get(f'{self.base_url}/connections/{connection_id}/balance')
        return self._handle_response(response)

    def get_connection_history(self, connection_id, limit=100):
        """Obtém histórico de conexão específica"""
        response = self.session.get(f'{self.base_url}/connections/{connection_id}/history?limit={limit}')
        return self._handle_response(response)

    def remove_connection(self, connection_id):
        """Remove conexão"""
        response = self.session.delete(f'{self.base_url}/connections/{connection_id}')
        return self._handle_response(response)

    def _handle_response(self, response):
        """Processa resposta HTTP"""
        return {
            'status_code': response.status_code,
            'data': response.json() if response.headers.get('content-type', '').startswith('application/json') else None,
            'success': 200 <= response.status_code < 300
        }

# Exemplo de uso
if __name__ == '__main__':
    api = BullexAnalyticsAPI()

    try:
        # Adicionar conexão
        result = api.add_connection('email@dominio.com', '123456')

        if result['success'] and result['data']['success']:
            connection_id = result['data']['connection_id']
            print(f"✅ Conexão adicionada: {connection_id}")

            # Aguardar conexão
            time.sleep(3)

            # Obter saldo
            balance = api.get_connection_balance(connection_id)
            print(f"💰 Saldo: {json.dumps(balance['data'], indent=2)}")

            # Obter histórico
            history = api.get_connection_history(connection_id, 50)
            trade_count = len(history['data']['data']) if history['data']['data'] else 0
            print(f"📊 Histórico: {trade_count} trades")

            # PnL agregado
            pnl = api.get_aggregated_pnl()
            total_pnl = pnl['data']['data']['total_pnl'] if pnl['data']['data'] else 0
            print(f"📈 PnL Total: R$ {total_pnl}")

        else:
            error_msg = result['data']['message'] if result['data'] else 'Erro desconhecido'
            print(f"❌ Erro: {error_msg}")

    except Exception as e:
        print(f"🔥 Exception: {e}")

class BullexAnalyticsAPI {
    constructor(baseUrl = 'http://localhost:5000') {
        this.baseUrl = baseUrl.replace(/\/$/, '') + '/api';
        this.headers = {
            'Content-Type': 'application/json',
            'Accept': 'application/json'
        };
    }

    async addConnection(email, password, connectionId = null) {
        const data = { email, password };
        if (connectionId) data.connection_id = connectionId;

        return this.makeRequest('POST', '/connections', data);
    }

    async getStatus() {
        return this.makeRequest('GET', '/status');
    }

    async getAllBalances() {
        return this.makeRequest('GET', '/balances');
    }

    async getAggregatedPnL(date = null) {
        const url = date ? `/pnl/aggregated?date=${date}` : '/pnl/aggregated';
        return this.makeRequest('GET', url);
    }

    async getConnectionBalance(connectionId) {
        return this.makeRequest('GET', `/connections/${connectionId}/balance`);
    }

    async getConnectionHistory(connectionId, limit = 100) {
        return this.makeRequest('GET', `/connections/${connectionId}/history?limit=${limit}`);
    }

    async removeConnection(connectionId) {
        return this.makeRequest('DELETE', `/connections/${connectionId}`);
    }

    async makeRequest(method, endpoint, data = null) {
        const url = this.baseUrl + endpoint;
        const options = {
            method,
            headers: this.headers
        };

        if (data) {
            options.body = JSON.stringify(data);
        }

        try {
            const response = await fetch(url, options);
            const responseData = await response.json();

            return {
                statusCode: response.status,
                data: responseData,
                success: response.ok
            };
        } catch (error) {
            throw new Error(`Request failed: ${error.message}`);
        }
    }
}

// Exemplo de uso
(async () => {
    const api = new BullexAnalyticsAPI();

    try {
        // Adicionar conexão
        const result = await api.addConnection('email@dominio.com', '123456');

        if (result.success && result.data.success) {
            const connectionId = result.data.connection_id;
            console.log(`✅ Conexão adicionada: ${connectionId}`);

            // Aguardar conexão
            await new Promise(resolve => setTimeout(resolve, 3000));

            // Obter saldo
            const balance = await api.getConnectionBalance(connectionId);
            console.log('💰 Saldo:', JSON.stringify(balance.data, null, 2));

            // Obter histórico
            const history = await api.getConnectionHistory(connectionId, 50);
            const tradeCount = history.data.data ? history.data.data.length : 0;
            console.log(`📊 Histórico: ${tradeCount} trades`);

            // PnL agregado
            const pnl = await api.getAggregatedPnL();
            const totalPnl = pnl.data.data ? pnl.data.data.total_pnl : 0;
            console.log(`📈 PnL Total: R$ ${totalPnl}`);

        } else {
            const errorMsg = result.data ? result.data.message : 'Erro desconhecido';
            console.log(`❌ Erro: ${errorMsg}`);
        }

    } catch (error) {
        console.log(`🔥 Exception: ${error.message}`);
    }
})();