ZexosPay API de lojista

const crypto = require('crypto');
const express = require('express');

const EnvironmentMode = {
    SANDBOX: 'sandbox',
    PRODUCTION: 'production'
};

// Handler do webhook
app.post('/api/webhooks/zexospay', async (req, res) => {
    const environment = req.headers['x-environment'] || 'production';
    const signature = req.headers['x-signature'];
    
    # Pegue o segredo correto conforme o ambiente
    const secret = getSecretForEnvironment(environment);
    
    # Verificar assinatura
    if (!verifySignature(JSON.stringify(req.body), signature, secret)) {
        console.warn('ZexosPay webhook signature verification failed', {
            environment: environment
        });
        
        return res.status(401).json({ error: 'Assinatura inválida' });
    }
    
    const payload = req.body;
    
    try {
        # Trate conforme o ambiente
        if (environment === EnvironmentMode.SANDBOX) {
            await handleSandboxWebhook(payload);
        } else {
            await handleProductionWebhook(payload);
        }
        
        res.json({ status: 'processado' });
    } catch (error) {
        console.error('Erro ao processar o webhook:', error);
        res.status(500).json({ error: 'O processamento falhou' });
    }
});

function getSecretForEnvironment(environment) {
    # Retorne o segredo de teste no sandbox e o segredo real em produção
    return environment === 'sandbox' 
        ? process.env.ZEXOSPAY_TEST_WEBHOOK_SECRET
        : process.env.ZEXOSPAY_WEBHOOK_SECRET;
}

function verifySignature(payload, signature, secret) {
    if (!signature) {
        return false;
    }
    
    const expectedSignature = crypto
        .createHmac('sha256', secret)
        .update(payload)
        .digest('hex');
    const providedSignature = signature.startsWith('sha256=') ? signature.slice(7) : signature;
    
    return crypto.timingSafeEqual(
        Buffer.from(expectedSignature),
        Buffer.from(providedSignature)
    );
}

async function handleSandboxWebhook(payload) {
    console.log('Processando webhook de sandbox:', payload);
    
    # Sua lógica de sandbox aqui
    # Não entregue pedidos, não mande e-mails para clientes reais etc.
}

async function handleProductionWebhook(payload) {
    console.log('Processando webhook de produção:', payload);
    
    # Sua lógica de produção aqui
    # Entregue pedidos, mande e-mails de confirmação etc.
}

import hmac
import hashlib
import json
import logging
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_http_methods

logger = logging.getLogger(__name__)

ENVIRONMENT_MODE = {
    'SANDBOX': 'sandbox',
    'PRODUCTION': 'production'
}

@csrf_exempt
@require_http_methods(["POST"])
def zexospay_webhook(request):
    environment = request.headers.get('X-Environment', 'production')
    signature = request.headers.get('X-Signature', '')
    
    # Pegue o segredo correto conforme o ambiente
    secret = get_secret_for_environment(environment)
    
    # Verificar assinatura
    if not verify_signature(request.body, signature, secret):
        logger.warning('ZexosPay webhook signature verification failed', extra={
            'environment': environment
        })
        
        return JsonResponse({'error': 'Assinatura inválida'}, status=401)
    
    try:
        payload = json.loads(request.body)
        
        # Trate conforme o ambiente
        if environment == ENVIRONMENT_MODE['SANDBOX']:
            handle_sandbox_webhook(payload)
        else:
            handle_production_webhook(payload)
        
        return JsonResponse({'status': 'processado'})
    
    except Exception as e:
        logger.error(f'Erro ao processar o webhook:{str(e)}')
        return JsonResponse({'error': 'O processamento falhou'}, status=500)

def get_secret_for_environment(environment):
    from django.conf import settings
    
    # Retorne o segredo de teste no sandbox e o segredo real em produção
    return (settings.ZEXOSPAY_TEST_WEBHOOK_SECRET 
            if environment == 'sandbox' 
            else settings.ZEXOSPAY_WEBHOOK_SECRET)

def verify_signature(payload, signature, secret):
    if not signature:
        return False
    
    expected_signature = hmac.new(
        secret.encode('utf-8'),
        payload,
        hashlib.sha256
    ).hexdigest()
    provided_signature = signature[7:] if signature.startswith('sha256=') else signature
    
    return hmac.compare_digest(expected_signature, provided_signature)

def handle_sandbox_webhook(payload):
    logger.info('Processando webhook de sandbox', extra=payload)
    
    # Sua lógica de sandbox aqui
    # Não entregue pedidos, não mande e-mails para clientes reais etc.

def handle_production_webhook(payload):
    logger.info('Processando webhook de produção', extra=payload)
    
    # Sua lógica de produção aqui
    # Entregue pedidos, mande e-mails de confirmação etc.

// Node.js Integration Service
const axios = require('axios');

class ZexosPayService {
    constructor() {
        this.baseUrl = process.env.ZEXOSPAY_BASE_URL || 'https://usepay.online';
        this.environment = process.env.ZEXOSPAY_ENVIRONMENT || 'sandbox'; // sandbox or production
        this.merchantKey = process.env.ZEXOSPAY_MERCHANT_KEY; // Use appropriate prefix
        this.apiKey = process.env.ZEXOSPAY_API_KEY; // Use appropriate prefix
    }

    async initiatePayment(paymentData) {
        try {
            const response = await axios.post(`${this.baseUrl}/api/v1/initiate-payment`, paymentData, {
                headers: {
                    'Content-Type': 'application/json',
                    'X-Environment': this.environment,
                    'X-Merchant-Key': this.merchantKey,
                    'X-API-Key': this.apiKey
                }
            });

            return response.data;
        } catch (error) {
            throw new Error(`ZexosPay API Error: ${error.message}`);
        }
    }

    async verifyPayment(transactionId) {
        try {
            const response = await axios.get(`${this.baseUrl}/api/v1/verify-payment/${transactionId}`, {
                headers: {
                    'Accept': 'application/json',
                    'X-Environment': this.environment,
                    'X-Merchant-Key': this.merchantKey,
                    'X-API-Key': this.apiKey
                }
            });

            return response.data;
        } catch (error) {
            throw new Error(`ZexosPay API Error: ${error.message}`);
        }
    }
}

// Express.js Route Example
const express = require('express');
const app = express();
const zexospay = new ZexosPayService();

app.post('/initiate-payment', async (req, res) => {
    const paymentData = {
        payment_amount: req.body.amount,
        currency_code: 'USD',
        ref_trx: `ORDER_${Date.now()}`,
        description: req.body.description,
        success_redirect: `${req.protocol}://${req.get('host')}/payment/success`,
        cancel_redirect: `${req.protocol}://${req.get('host')}/payment/cancelled`,
        ipn_url: `${req.protocol}://${req.get('host')}/webhooks/zexospay`,
        allow_payment_methods: ['stripe', 'paypal'],
    };

    try {
        const result = await zexospay.initiatePayment(paymentData);
        res.redirect(result.payment_url);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

module.exports = ZexosPayService;

# Python/Django Integration Service
import os
import requests
from django.conf import settings

class ZexosPayService:
    def __init__(self):
        self.base_url = getattr(settings, 'ZEXOSPAY_BASE_URL', 'https://usepay.online')
        self.environment = getattr(settings, 'ZEXOSPAY_ENVIRONMENT', 'sandbox')  # sandbox or production
        self.merchant_key = getattr(settings, 'ZEXOSPAY_MERCHANT_KEY')  # Use appropriate prefix
        self.api_key = getattr(settings, 'ZEXOSPAY_API_KEY')  # Use appropriate prefix

    def initiate_payment(self, payment_data):
        try:
            headers = {
                'Content-Type': 'application/json',
                'X-Environment': self.environment,
                'X-Merchant-Key': self.merchant_key,
                'X-API-Key': self.api_key
            }

            response = requests.post(
                f"{self.base_url}/api/v1/initiate-payment",
                headers=headers,
                json=payment_data,
                timeout=30
            )

            response.raise_for_status()
            return response.json()

        except requests.RequestException as e:
            raise Exception(f'ZexosPay API Error: {str(e)}')

    def verify_payment(self, transaction_id):
        try:
            headers = {
                'Accept': 'application/json',
                'X-Environment': self.environment,
                'X-Merchant-Key': self.merchant_key,
                'X-API-Key': self.api_key
            }

            response = requests.get(
                f"{self.base_url}/api/v1/verify-payment/{transaction_id}",
                headers=headers,
                timeout=30
            )

            response.raise_for_status()
            return response.json()

        except requests.RequestException as e:
            raise Exception(f'ZexosPay API Error: {str(e)}')

# Django Settings Configuration
ZEXOSPAY_BASE_URL = 'https://usepay.online'
ZEXOSPAY_ENVIRONMENT = 'sandbox'  # Change to 'production' for live
ZEXOSPAY_MERCHANT_KEY = os.environ.get('ZEXOSPAY_MERCHANT_KEY')  # Use appropriate prefix
ZEXOSPAY_API_KEY = os.environ.get('ZEXOSPAY_API_KEY')  # Use appropriate prefix

# Django View Example
from django.shortcuts import redirect
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
import json

zexospay = ZexosPayService()

@csrf_exempt
def initiate_payment(request):
    if request.method == 'POST':
        data = json.loads(request.body)
        
        payment_data = {
            'payment_amount': data['amount'],
            'currency_code': 'USD',
            'ref_trx': f'ORDER_{int(time.time())}',
            'description': data['description'],
            'success_redirect': request.build_absolute_uri('/payment/success/'),
            'cancel_redirect': request.build_absolute_uri('/payment/cancelled/'),
            'ipn_url': request.build_absolute_uri('/webhooks/zexospay/'),
            'allow_payment_methods': ['stripe', 'paypal'],
        }

        try:
            result = zexospay.initiate_payment(payment_data)
            return redirect(result['payment_url'])
        except Exception as e:
            return JsonResponse({'error': str(e)}, status=500)

# Environment Variables Setup
export ZEXOSPAY_ENVIRONMENT="sandbox"  # or "production"
export ZEXOSPAY_MERCHANT_KEY="test_merchant_your_key"  # or "merchant_your_key" for production
export ZEXOSPAY_API_KEY="test_your_api_key"  # or "your_api_key" for production

# Initiate Payment
curl -X POST "https://usepay.online/api/v1/initiate-payment" \
  -H "Content-Type: application/json" \
  -H "X-Environment: $ZEXOSPAY_ENVIRONMENT" \
  -H "X-Merchant-Key: $ZEXOSPAY_MERCHANT_KEY" \
  -H "X-API-Key: $ZEXOSPAY_API_KEY" \
  -d '{
    "payment_amount": 250.00,
    "currency_code": "USD",
    "ref_trx": "ORDER_12345",
    "description": "Premium Subscription",
    "success_redirect": "https://yoursite.com/payment/success",
    "cancel_redirect": "https://yoursite.com/payment/cancelled",
    "ipn_url": "https://yoursite.com/api/webhooks/zexospay",
    "allow_payment_methods": ["stripe", "paypal"]
  }'

# Verify Payment
curl -X GET "https://usepay.online/api/v1/verify-payment/TXNQ5V8K2L9N3XM1" \
  -H "Accept: application/json" \
  -H "X-Environment: $ZEXOSPAY_ENVIRONMENT" \
  -H "X-Merchant-Key: $ZEXOSPAY_MERCHANT_KEY" \
  -H "X-API-Key: $ZEXOSPAY_API_KEY"

# Environment-specific credential examples:
# Sandbox: test_merchant_xxxxx, test_api_key_xxxxx
# Production: merchant_xxxxx, api_key_xxxxx