424 lines
15 KiB
PHP
424 lines
15 KiB
PHP
<?php
|
|
/**
|
|
* Webhook OPTIMIZADO para recibir mensajes de WhatsApp
|
|
*
|
|
* CAMBIOS CLAVE:
|
|
* - Responde inmediatamente (< 1 segundo) con 200 OK
|
|
* - Encola mensajes para procesamiento asíncrono
|
|
* - Usa Redis para evitar duplicados
|
|
* - Logging estructurado con Monolog
|
|
*
|
|
* Fecha: Enero 2026
|
|
*/
|
|
|
|
require_once __DIR__ . '/../vendor/autoload.php';
|
|
require_once __DIR__ . '/../config/config.php';
|
|
|
|
use WhatsApp\Queue\RedisQueue;
|
|
use Monolog\Logger;
|
|
use Monolog\Handler\StreamHandler;
|
|
use Monolog\Handler\RotatingFileHandler;
|
|
|
|
// Headers
|
|
header('Content-Type: application/json; charset=utf-8');
|
|
header('Access-Control-Allow-Origin: *');
|
|
header('Access-Control-Allow-Methods: GET, POST');
|
|
header('Access-Control-Allow-Headers: Content-Type');
|
|
|
|
// Configurar logger
|
|
$logger = new Logger('webhook');
|
|
$logger->pushHandler(new RotatingFileHandler(__DIR__ . '/../logs/webhook.log', 7, Logger::INFO));
|
|
|
|
// Inicializar cola
|
|
$queue = new RedisQueue(null, $logger);
|
|
|
|
class OptimizedWebhook {
|
|
private $db;
|
|
private $logger;
|
|
private $queue;
|
|
private $redis;
|
|
|
|
public function __construct($db, $logger, $queue) {
|
|
$this->db = $db;
|
|
$this->logger = $logger;
|
|
$this->queue = $queue;
|
|
|
|
// Inicializar Redis directamente para verificaciones rápidas
|
|
$this->redis = new Predis\Client([
|
|
'scheme' => getenv('REDIS_SCHEME') ?: 'tcp',
|
|
'host' => getenv('REDIS_HOST') ?: '127.0.0.1',
|
|
'port' => getenv('REDIS_PORT') ?: 6379,
|
|
]);
|
|
}
|
|
|
|
public function handleRequest() {
|
|
$method = $_SERVER['REQUEST_METHOD'];
|
|
|
|
if ($method === 'GET') {
|
|
$this->verifyWebhook();
|
|
} elseif ($method === 'POST') {
|
|
$this->processIncomingMessage();
|
|
} else {
|
|
http_response_code(405);
|
|
echo json_encode(['error' => 'Método no permitido']);
|
|
}
|
|
}
|
|
|
|
private function verifyWebhook() {
|
|
$verifyToken = $_GET['hub_verify_token'] ?? '';
|
|
$challenge = $_GET['hub_challenge'] ?? '';
|
|
$mode = $_GET['hub_mode'] ?? '';
|
|
|
|
if ($mode === 'subscribe' && $verifyToken === WEBHOOK_VERIFY_TOKEN) {
|
|
$this->logger->info("Webhook verified successfully");
|
|
echo $challenge;
|
|
exit;
|
|
}
|
|
|
|
$this->logger->warning("Invalid verification attempt", [
|
|
'mode' => $mode,
|
|
'token_match' => $verifyToken === WEBHOOK_VERIFY_TOKEN
|
|
]);
|
|
|
|
http_response_code(403);
|
|
echo json_encode(['error' => 'Token de verificación inválido']);
|
|
}
|
|
|
|
private function processIncomingMessage() {
|
|
$startTime = microtime(true);
|
|
|
|
// Leer payload
|
|
$input = file_get_contents('php://input');
|
|
$data = json_decode($input, true);
|
|
|
|
// Responder inmediatamente con 200 OK (CRÍTICO: < 5 segundos)
|
|
http_response_code(200);
|
|
echo json_encode(['status' => 'received']);
|
|
|
|
// Forzar envío de respuesta al cliente
|
|
if (function_exists('fastcgi_finish_request')) {
|
|
fastcgi_finish_request();
|
|
} else {
|
|
// Fallback para otros SAPIs
|
|
ob_end_flush();
|
|
flush();
|
|
}
|
|
|
|
// Ahora procesamos el webhook sin presión de tiempo
|
|
$processingStart = microtime(true);
|
|
|
|
try {
|
|
// Log webhook (async, no bloquea)
|
|
$this->logWebhookAsync($input);
|
|
|
|
if (!$data || !isset($data['entry'])) {
|
|
$this->logger->warning("Invalid webhook payload received");
|
|
return;
|
|
}
|
|
|
|
$this->logger->info("Webhook received", [
|
|
'entries' => count($data['entry']),
|
|
'response_time_ms' => round((microtime(true) - $startTime) * 1000, 2)
|
|
]);
|
|
|
|
// Procesar cada entrada
|
|
foreach ($data['entry'] as $entry) {
|
|
if (!isset($entry['changes'])) continue;
|
|
|
|
foreach ($entry['changes'] as $change) {
|
|
if (isset($change['value']['messages'])) {
|
|
$this->queueMessages($change['value']['messages']);
|
|
}
|
|
|
|
if (isset($change['value']['statuses'])) {
|
|
$this->updateMessageStatuses($change['value']['statuses']);
|
|
}
|
|
}
|
|
}
|
|
|
|
$totalTime = round((microtime(true) - $startTime) * 1000, 2);
|
|
$processingTime = round((microtime(true) - $processingStart) * 1000, 2);
|
|
|
|
$this->logger->info("Webhook processed", [
|
|
'total_time_ms' => $totalTime,
|
|
'processing_time_ms' => $processingTime,
|
|
'response_sent_in_ms' => round(($processingStart - $startTime) * 1000, 2)
|
|
]);
|
|
|
|
} catch (Exception $e) {
|
|
$this->logger->error("Error processing webhook", [
|
|
'error' => $e->getMessage(),
|
|
'trace' => $e->getTraceAsString()
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Encolar mensajes para procesamiento asíncrono
|
|
*/
|
|
private function queueMessages($messages) {
|
|
foreach ($messages as $message) {
|
|
try {
|
|
$messageId = $message['id'] ?? null;
|
|
$phoneNumber = $message['from'] ?? null;
|
|
|
|
if (!$messageId || !$phoneNumber) {
|
|
continue;
|
|
}
|
|
|
|
// Verificación rápida de duplicados en Redis (más rápido que DB)
|
|
$duplicateKey = "whatsapp:processed:" . $messageId;
|
|
if ($this->redis->exists($duplicateKey)) {
|
|
$this->logger->debug("Duplicate message skipped", ['message_id' => $messageId]);
|
|
continue;
|
|
}
|
|
|
|
// Marcar como procesado en Redis (expira en 24h)
|
|
$this->redis->setex($duplicateKey, 86400, time());
|
|
|
|
// Obtener o crear usuario (rápido, solo DB lookup)
|
|
$user = $this->getUserByPhone($phoneNumber);
|
|
if (!$user) {
|
|
$userId = $this->createUser($phoneNumber);
|
|
$user = $this->getUserById($userId);
|
|
}
|
|
|
|
// Extraer tipo y contenido del mensaje
|
|
$messageData = $this->extractMessageData($message);
|
|
|
|
// Guardar mensaje en BD (no esperar resultado del bot)
|
|
$this->saveIncomingMessage(
|
|
$user['id'],
|
|
$messageId,
|
|
$messageData['text'],
|
|
$messageData['type'],
|
|
$messageData['media_url'],
|
|
$messageData['timestamp']
|
|
);
|
|
|
|
// Encolar para procesamiento por worker
|
|
$this->queue->push('messages', [
|
|
'user' => $user,
|
|
'messageText' => $messageData['text'],
|
|
'messageType' => $messageData['type'],
|
|
'messageId' => $messageId,
|
|
'mediaUrl' => $messageData['media_url']
|
|
], 0); // Prioridad alta
|
|
|
|
$this->logger->info("Message queued", [
|
|
'message_id' => $messageId,
|
|
'user_id' => $user['id'],
|
|
'type' => $messageData['type']
|
|
]);
|
|
|
|
} catch (Exception $e) {
|
|
$this->logger->error("Failed to queue message", [
|
|
'message_id' => $messageId ?? 'unknown',
|
|
'error' => $e->getMessage()
|
|
]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extraer datos del mensaje según tipo
|
|
*/
|
|
private function extractMessageData($message) {
|
|
$type = $message['type'] ?? 'text';
|
|
$text = '';
|
|
$mediaUrl = null;
|
|
$timestamp = $message['timestamp'] ?? null;
|
|
|
|
switch ($type) {
|
|
case 'text':
|
|
$text = $message['text']['body'] ?? '';
|
|
break;
|
|
|
|
case 'interactive':
|
|
// Normalizar respuestas de botones/listas
|
|
if (isset($message['interactive']['list_reply']['title'])) {
|
|
$text = $message['interactive']['list_reply']['title'];
|
|
} elseif (isset($message['interactive']['button_reply']['title'])) {
|
|
$text = $message['interactive']['button_reply']['title'];
|
|
}
|
|
// Extraer número si viene como "1. Opción"
|
|
if (preg_match('/^\s*(\d+)\b/', $text, $m)) {
|
|
$text = $m[1];
|
|
}
|
|
break;
|
|
|
|
case 'image':
|
|
$text = $message['image']['caption'] ?? '';
|
|
$mediaUrl = $message['image']['url'] ?? $message['image']['id'] ?? null;
|
|
|
|
// Encolar descarga de media
|
|
if ($mediaUrl) {
|
|
$this->queueMediaDownload($mediaUrl, $message['id'], 'image');
|
|
}
|
|
break;
|
|
|
|
case 'video':
|
|
$text = $message['video']['caption'] ?? '';
|
|
$mediaUrl = $message['video']['url'] ?? $message['video']['id'] ?? null;
|
|
|
|
if ($mediaUrl) {
|
|
$this->queueMediaDownload($mediaUrl, $message['id'], 'video');
|
|
}
|
|
break;
|
|
|
|
case 'audio':
|
|
$mediaUrl = $message['audio']['url'] ?? $message['audio']['id'] ?? null;
|
|
|
|
if ($mediaUrl) {
|
|
$this->queueMediaDownload($mediaUrl, $message['id'], 'audio');
|
|
}
|
|
break;
|
|
|
|
case 'document':
|
|
$text = $message['document']['filename'] ?? '';
|
|
$mediaUrl = $message['document']['url'] ?? $message['document']['id'] ?? null;
|
|
|
|
if ($mediaUrl) {
|
|
$this->queueMediaDownload($mediaUrl, $message['id'], 'document');
|
|
}
|
|
break;
|
|
|
|
case 'reaction':
|
|
$emoji = $message['reaction']['emoji'] ?? '';
|
|
$reactionTo = $message['reaction']['message_id'] ?? '';
|
|
$text = json_encode(['emoji' => $emoji, 'message_id' => $reactionTo]);
|
|
break;
|
|
}
|
|
|
|
return [
|
|
'text' => $text,
|
|
'type' => $type,
|
|
'media_url' => $mediaUrl,
|
|
'timestamp' => $timestamp
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Encolar descarga de media
|
|
*/
|
|
private function queueMediaDownload($mediaUrl, $messageId, $type) {
|
|
$this->queue->push('media', [
|
|
'media_url' => strpos($mediaUrl, 'http') === 0 ? $mediaUrl : null,
|
|
'media_id' => strpos($mediaUrl, 'http') !== 0 ? $mediaUrl : null,
|
|
'message_id' => $messageId,
|
|
'type' => $type,
|
|
'subdir' => date('Y/m')
|
|
], 1); // Prioridad normal
|
|
}
|
|
|
|
/**
|
|
* Actualizar estados de mensajes (entregado, leído, etc.)
|
|
*/
|
|
private function updateMessageStatuses($statuses) {
|
|
foreach ($statuses as $status) {
|
|
try {
|
|
$messageId = $status['id'];
|
|
$newStatus = $status['status'];
|
|
|
|
$this->db->update(
|
|
'conversations',
|
|
['status' => $newStatus],
|
|
'message_id = :message_id',
|
|
['message_id' => $messageId]
|
|
);
|
|
|
|
} catch (Exception $e) {
|
|
$this->logger->error("Failed to update message status", [
|
|
'message_id' => $messageId ?? 'unknown',
|
|
'error' => $e->getMessage()
|
|
]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Guardar mensaje entrante en BD
|
|
*/
|
|
private function saveIncomingMessage($userId, $messageId, $text, $type, $mediaUrl, $timestamp) {
|
|
try {
|
|
$this->db->insert('conversations', [
|
|
'user_id' => $userId,
|
|
'message_id' => $messageId,
|
|
'direction' => 'incoming',
|
|
'content' => $text,
|
|
'message_type' => $type,
|
|
'media_url' => $mediaUrl,
|
|
'status' => 'received',
|
|
'created_at' => $timestamp ? date('Y-m-d H:i:s', $timestamp) : date('Y-m-d H:i:s')
|
|
]);
|
|
|
|
} catch (Exception $e) {
|
|
$this->logger->error("Failed to save message", [
|
|
'user_id' => $userId,
|
|
'message_id' => $messageId,
|
|
'error' => $e->getMessage()
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Log webhook de forma asíncrona (no bloqueante)
|
|
*/
|
|
private function logWebhookAsync($payload) {
|
|
try {
|
|
// Guardar solo últimos 1000 webhooks para no llenar BD
|
|
$this->db->query("DELETE FROM webhook_logs WHERE id < (SELECT id FROM (SELECT id FROM webhook_logs ORDER BY id DESC LIMIT 1 OFFSET 1000) as t)");
|
|
|
|
$this->db->insert('webhook_logs', [
|
|
'request_body' => $payload,
|
|
'response_body' => json_encode(['status' => 'queued']),
|
|
'status_code' => 200,
|
|
'created_at' => date('Y-m-d H:i:s')
|
|
]);
|
|
} catch (Exception $e) {
|
|
$this->logger->warning("Failed to log webhook", ['error' => $e->getMessage()]);
|
|
}
|
|
}
|
|
|
|
private function getUserByPhone($phoneNumber) {
|
|
return $this->db->fetch(
|
|
"SELECT * FROM users WHERE phone_number = :phone",
|
|
['phone' => $phoneNumber]
|
|
);
|
|
}
|
|
|
|
private function createUser($phoneNumber) {
|
|
$this->db->insert('users', [
|
|
'phone_number' => $phoneNumber,
|
|
'name' => $phoneNumber,
|
|
'bot_enabled' => 1,
|
|
'created_at' => date('Y-m-d H:i:s')
|
|
]);
|
|
|
|
return $this->db->lastInsertId();
|
|
}
|
|
|
|
private function getUserById($userId) {
|
|
return $this->db->fetch(
|
|
"SELECT * FROM users WHERE id = :id",
|
|
['id' => $userId]
|
|
);
|
|
}
|
|
}
|
|
|
|
// Ejecutar webhook
|
|
try {
|
|
$db = Database::getInstance();
|
|
$webhook = new OptimizedWebhook($db, $logger, $queue);
|
|
$webhook->handleRequest();
|
|
|
|
} catch (Throwable $e) {
|
|
$logger->critical("Webhook crashed", [
|
|
'error' => $e->getMessage(),
|
|
'trace' => $e->getTraceAsString()
|
|
]);
|
|
|
|
http_response_code(500);
|
|
echo json_encode(['error' => 'Internal server error']);
|
|
}
|