Criar Estorno

{
  "id": "ref_def456ghi789jkl012",
  "payment_id": "pay_abc123def456ghi789",
  "status": "processing",
  "amount": 15000,
  "reason": "requested_by_customer",
  "description": "Cliente solicitou cancelamento do pedido",
  "refund_method": "credit_card",
  "estimated_arrival": "2024-01-17T10:30:00Z",
  "split_details": [
    {
      "recipient_id": "rec_marketplace",
      "amount": 1500,
      "status": "processing"
    },
    {
      "recipient_id": "rec_seller", 
      "amount": 13500,
      "status": "processing"
    }
  ],
  "fees": {
    "processing_fee": 450,
    "refund_fee": 0,
    "total_refunded_to_customer": 15000
  },
  "metadata": {
    "order_id": "ORD-12345",
    "support_agent": "agent_001"
  },
  "created_at": "2024-01-15T14:30:00Z"
}

// Estorno automático quando pedido é cancelado
async function cancelOrder(orderId, reason) {
  try {
    // Buscar pagamento do pedido
    const order = await getOrder(orderId);
    const payment = await getPayment(order.payment_id);
    
    if (payment.status === 'paid') {
      const refund = await createRefund({
        payment_id: payment.id,
        reason: reason || 'requested_by_customer',
        description: `Cancelamento do pedido #${orderId}`,
        notify_customer: true,
        metadata: {
          order_id: orderId,
          cancelled_by: 'customer',
          cancel_reason: reason
        }
      });
      
      // Atualizar status do pedido
      await updateOrderStatus(orderId, 'cancelled');
      
      // Notificar equipes internas
      await notifyRefundProcessed(orderId, refund);
      
      return { success: true, refund: refund };
    } else {
      // Apenas cancelar se não foi pago ainda
      await updateOrderStatus(orderId, 'cancelled');
      return { success: true, message: 'Pedido cancelado sem cobrança' };
    }
    
  } catch (error) {
    console.error('Erro ao cancelar pedido:', error);
    throw error;
  }
}

// Estorno parcial para produto com defeito em marketplace
async function refundDefectiveProduct(marketplaceOrder, defectiveItems) {
  const refundAmount = defectiveItems.reduce((sum, item) => sum + item.price, 0);
  
  // Calcular split proporcional
  const originalSplit = await getSplitDetails(marketplaceOrder.payment_id);
  const refundSplit = originalSplit.map(split => ({
    recipient_id: split.recipient_id,
    amount: Math.round((split.amount / marketplaceOrder.total) * refundAmount)
  }));
  
  const refund = await createRefund({
    payment_id: marketplaceOrder.payment_id,
    amount: refundAmount,
    reason: 'product_defective',
    description: `Estorno por produto com defeito: ${defectiveItems.map(i => i.name).join(', ')}`,
    split_behavior: 'custom',
    split_config: refundSplit,
    metadata: {
      marketplace_order_id: marketplaceOrder.id,
      defective_items: defectiveItems.map(i => i.id),
      processed_by: 'customer_service'
    }
  });
  
  // Processar logística reversa
  await createReturnShipping(marketplaceOrder.id, defectiveItems);
  
  // Notificar vendedor
  await notifySellerOfRefund(marketplaceOrder.seller_id, refund);
  
  return refund;
}

// Estorno proporcional para cancelamento de assinatura
async function cancelSubscriptionWithRefund(subscriptionId, cancelDate) {
  const subscription = await getSubscription(subscriptionId);
  const lastPayment = await getLastSubscriptionPayment(subscriptionId);
  
  if (lastPayment && lastPayment.status === 'paid') {
    // Calcular período não utilizado
    const billingPeriodStart = new Date(subscription.current_period_start);
    const billingPeriodEnd = new Date(subscription.current_period_end);
    const cancelDateTime = new Date(cancelDate);
    
    const totalDays = (billingPeriodEnd - billingPeriodStart) / (1000 * 60 * 60 * 24);
    const unusedDays = (billingPeriodEnd - cancelDateTime) / (1000 * 60 * 60 * 24);
    
    if (unusedDays > 0) {
      const refundAmount = Math.round((lastPayment.amount * unusedDays) / totalDays);
      
      const refund = await createRefund({
        payment_id: lastPayment.id,
        amount: refundAmount,
        reason: 'requested_by_customer',
        description: `Cancelamento de assinatura - ${Math.round(unusedDays)} dias não utilizados`,
        metadata: {
          subscription_id: subscriptionId,
          billing_period_start: billingPeriodStart.toISOString(),
          billing_period_end: billingPeriodEnd.toISOString(),
          cancel_date: cancelDate,
          unused_days: Math.round(unusedDays)
        }
      });
      
      // Atualizar assinatura
      await updateSubscription(subscriptionId, {
        status: 'cancelled',
        cancelled_at: cancelDate,
        refund_id: refund.id
      });
      
      return refund;
    }
  }
  
  // Cancelar sem estorno se não há período não utilizado
  await updateSubscription(subscriptionId, {
    status: 'cancelled',
    cancelled_at: cancelDate
  });
  
  return null;
}

// Monitorar taxa de estornos por período
class RefundMonitor {
  constructor(apiKey) {
    this.apiKey = apiKey;
  }
  
  async getRefundMetrics(startDate, endDate) {
    const payments = await this.getPayments(startDate, endDate);
    const refunds = await this.getRefunds(startDate, endDate);
    
    const metrics = {
      total_payments: payments.length,
      total_refunds: refunds.length,
      refund_rate: (refunds.length / payments.length) * 100,
      
      refund_reasons: this.groupBy(refunds, 'reason'),
      
      amounts: {
        total_paid: payments.reduce((sum, p) => sum + p.amount, 0),
        total_refunded: refunds.reduce((sum, r) => sum + r.amount, 0),
        refund_amount_rate: 0
      },
      
      timing: {
        avg_refund_time: this.calculateAverageRefundTime(refunds),
        same_day_refunds: refunds.filter(r => this.isSameDay(r.created_at, r.payment.created_at)).length
      }
    };
    
    metrics.amounts.refund_amount_rate = 
      (metrics.amounts.total_refunded / metrics.amounts.total_paid) * 100;
    
    return metrics;
  }
  
  groupBy(array, key) {
    return array.reduce((groups, item) => {
      const group = item[key];
      groups[group] = groups[group] || [];
      groups[group].push(item);
      return groups;
    }, {});
  }
  
  // Detectar padrões anômalos
  async detectAnomalies(metrics) {
    const alerts = [];
    
    if (metrics.refund_rate > 15) {
      alerts.push({
        type: 'high_refund_rate',
        message: `Taxa de estorno alta: ${metrics.refund_rate.toFixed(2)}%`,
        severity: 'high'
      });
    }
    
    if (metrics.refund_reasons.fraudulent?.length > 5) {
      alerts.push({
        type: 'fraud_pattern',
        message: `Muitos estornos por fraude: ${metrics.refund_reasons.fraudulent.length}`,
        severity: 'critical'
      });
    }
    
    return alerts;
  }
}

<?php

class RefundAlertSystem {
    private $thresholds = [
        'daily_refund_rate' => 10, // % máximo por dia
        'hourly_refund_count' => 20, // máximo por hora
        'suspicious_patterns' => 5 // múltiplos estornos mesmo cliente
    ];
    
    public function checkRefundAlerts() {
        $alerts = [];
        
        // Verificar taxa diária
        $dailyRate = $this->getDailyRefundRate();
        if ($dailyRate > $this->thresholds['daily_refund_rate']) {
            $alerts[] = [
                'type' => 'high_daily_refund_rate',
                'message' => "Taxa de estorno diária alta: {$dailyRate}%",
                'data' => ['rate' => $dailyRate],
                'priority' => 'high'
            ];
        }
        
        // Verificar padrões suspeitos
        $suspiciousPatterns = $this->detectSuspiciousPatterns();
        if (count($suspiciousPatterns) > 0) {
            $alerts[] = [
                'type' => 'suspicious_refund_patterns',
                'message' => 'Padrões suspeitos detectados',
                'data' => $suspiciousPatterns,
                'priority' => 'critical'
            ];
        }
        
        // Enviar alertas se necessário
        foreach ($alerts as $alert) {
            $this->sendAlert($alert);
        }
        
        return $alerts;
    }
    
    private function detectSuspiciousPatterns() {
        // Buscar clientes com múltiplos estornos recentes
        $query = "
            SELECT customer_email, COUNT(*) as refund_count
            FROM refunds r
            JOIN payments p ON r.payment_id = p.id
            WHERE r.created_at > DATE_SUB(NOW(), INTERVAL 24 HOUR)
            GROUP BY customer_email
            HAVING refund_count >= ?
        ";
        
        return $this->db->query($query, [$this->thresholds['suspicious_patterns']]);
    }
}

// Processar eventos de estorno via webhook
app.post('/webhooks/autorizou', (req, res) => {
  const { event, data } = req.body;
  
  switch (event) {
    case 'refund.succeeded':
      handleRefundSucceeded(data.refund);
      break;
      
    case 'refund.failed':
      handleRefundFailed(data.refund);
      break;
      
    case 'refund.processing':
      updateRefundStatus(data.refund.id, 'processing');
      break;
  }
  
  res.status(200).send('OK');
});

async function handleRefundSucceeded(refund) {
  // Atualizar sistema interno
  await updateOrderStatus(refund.metadata.order_id, 'refunded');
  
  // Notificar cliente
  await sendRefundConfirmation(refund.payment.customer.email, refund);
  
  // Atualizar inventário se necessário
  if (refund.reason === 'product_returned') {
    await restoreInventory(refund.metadata.order_id);
  }
  
  // Log para análise
  console.log(`Estorno concluído: ${refund.id} - R$ ${refund.amount / 100}`);
}