+------------------+      +-----------------+      +-------------------+
|   AsisteClick    |      |    Webhook      |      |   Tu Sistema      |
|                  |      |    POST         |      |                   |
|  Conversación     | ---> |    JSON         | ---> |   CRM / BI /      |
|  Archivada       |      |    Payload      |      |   Data Warehouse  |
+------------------+      +-----------------+      +-------------------+

\{
  "event_type": "TICKET.CLOSED",
  "ticket_id": "#1FY",
  "key": "md5(ticket_id + access_token)",
  "timestamp": 1586229907754,
  "channel": "WEB",
  "source": "CHAT",
  "source_id": null,
  "status": "CLOSED",
  "subject": "I'm interested in the new red shoes",
  "department": \{
    "id": 93,
    "name": "Customer support"
  \},
  "bot": \{
    "id": 25478,
    "name": "Agustin",
    "transferred_to_agent": true
  \},
  "agent": \{
    "id": 569884,
    "name": "Agustin",
    "email": "[email protected]"
  \},
  "customer": \{
    "fingerprint": "k811xkn31fhzcss0dia8bbd3sr56l20lpx6gx76y",
    "name": "John",
    "email": "[email protected]",
    "phone": "",
    "facebook_id": "",
    "sentiment": "",
    "ip": "95.256.142.145",
    "browser_os": "Chrome on Windows 10 64-bit",
    "country_code": "US",
    "country_name": "United States"
  \},
  "event": \{
    "calendar_id": "1",
    "base36_id": "HX34S",
    "customer_locale": "es",
    "customer_timezone": "-3",
    "event_status": "ACTIVE",
    "event_url": "<event url>",
    "friendly": "Chrome on Windows 10 64-bit",
    "location": "Av. Libertador 2632, Olivos"
  \},
  "messages": [
    \{
      "action": "OUT",
      "timestamp": 1586229888461,
      "name": "Bruno",
      "message": "Hi John! I'm Bruno, a virtual assistant. How can I help you?"
    \},
    \{
      "action": "IN",
      "timestamp": 1586229891562,
      "name": "John",
      "message": "I'm interested in the new red shoes"
    \}
  ],
  "tags": ["venta", "calzado"],
  "custom_fields": [
    \{
      "producto_interes": "zapatos rojos"
    \}
  ]
\}

https://api.tuempresa.com/webhook::header1:value1;header2:value2

# Agregar API Key
https://api.tuempresa.com/webhook::x-api-key:tu-api-key-secreto

# Agregar múltiples headers
https://api.tuempresa.com/webhook::Authorization:Bearer abc123;X-Custom-Header:valor

# Agregar header de ambiente
https://api.tuempresa.com/webhook::Environment:production;Source:asisteclick

from flask import Flask, request, jsonify
import hashlib
import json

app = Flask(__name__)

# Tu clave privada (debe coincidir con AsisteClick)
PRIVATE_KEY = "tu-clave-secreta"

def validate_ticket_token(ticket_id, received_token):
    """Valida el token del ticket"""
    expected = hashlib.md5(
        (ticket_id + PRIVATE_KEY).encode()
    ).hexdigest()
    return received_token == expected

@app.route('/webhook/asisteclick', methods=['POST'])
def webhook():
    # Obtener headers de autenticacion
    ticket_token = request.headers.get('AsisteClick-Ticket-Token')
    access_token = request.headers.get('AsisteClick-Access-Token')

    # Parsear el payload
    data = request.get_json()

    # Validar autenticacion (opcional pero recomendado)
    if not ticket_token or not access_token:
        return jsonify(\{'error': 'Missing authentication'\}), 401

    # Procesar según tipo de evento
    event_type = data.get('event_type')
    ticket_id = data.get('ticket_id')

    print(f"Recibido: \{event_type\} - Ticket: \{ticket_id\}")

    if event_type == 'TICKET.CLOSED':
        process_closed_ticket(data)
    elif event_type == 'TICKET.HANDOFF':
        process_handoff(data)
    elif event_type.startswith('EVENT.'):
        process_calendar_event(data)

    # Responder con 200 OK
    return jsonify(\{'status': 'received'\}), 200

def process_closed_ticket(data):
    """Procesa tickets cerrados"""
    customer = data.get('customer', \{\})
    messages = data.get('messages', [])

    # Ejemplo: Guardar en base de datos
    # db.save_conversation(data)

    # Ejemplo: Enviar a CRM
    # crm.create_interaction(customer['email'], messages)

    print(f"Ticket cerrado - Cliente: \{customer.get('name')\}")
    print(f"Total mensajes: \{len(messages)\}")

def process_handoff(data):
    """Procesa transferencias a agente"""
    agent = data.get('agent', \{\})
    print(f"Transferido a: \{agent.get('name')\}")

def process_calendar_event(data):
    """Procesa eventos de calendario"""
    event = data.get('event', \{\})
    print(f"Evento: \{event.get('event_status')\}")

if __name__ == '__main__':
    app.run(port=5000)

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

const app = express();
app.use(express.json());

const PRIVATE_KEY = 'tu-clave-secreta';

// Función para validar token
function validateToken(ticketId, receivedToken) \{
    const expected = crypto
        .createHash('md5')
        .update(ticketId + PRIVATE_KEY)
        .digest('hex');
    return expected === receivedToken;
\}

// Endpoint del webhook
app.post('/webhook/asisteclick', (req, res) => \{
    // Headers de autenticación
    const ticketToken = req.headers['asisteclick-ticket-token'];
    const accessToken = req.headers['asisteclick-access-token'];

    // Payload
    const data = req.body;
    const eventType = data.event_type;
    const ticketId = data.ticket_id;

    console.log(`Evento: $\{eventType\} | Ticket: $\{ticketId\}`);

    // Procesar según tipo de evento
    switch (eventType) \{
        case 'TICKET.CLOSED':
            handleClosedTicket(data);
            break;
        case 'TICKET.HANDOFF':
            handleHandoff(data);
            break;
        default:
            if (eventType.startsWith('EVENT.')) \{
                handleCalendarEvent(data);
            \}
    \}

    // Responder OK
    res.status(200).json(\{ status: 'received' \});
\});

function handleClosedTicket(data) \{
    const customer = data.customer || \{\};
    const messages = data.messages || [];

    console.log(`Cliente: $\{customer.name || 'Desconocido'\}`);
    console.log(`Email: $\{customer.email || 'No disponible'\}`);
    console.log(`Canal: $\{data.channel\}`);
    console.log(`Mensajes: $\{messages.length\}`);

    // Ejemplo: Guardar en MongoDB
    // await db.conversations.insertOne(data);

    // Ejemplo: Enviar a Slack
    // await slack.sendMessage(formatConversation(data));
\}

function handleHandoff(data) \{
    const agent = data.agent || \{\};
    console.log(`Transferido a: $\{agent.name\}`);
\}

function handleCalendarEvent(data) \{
    const event = data.event || \{\};
    console.log(`Evento calendario: $\{event.event_status\}`);
\}

app.listen(3000, () => \{
    console.log('Webhook server running on port 3000');
\});

<?php
// webhook.php

// Leer el payload JSON
$input = file_get_contents('php://input');
$data = json_decode($input, true);

// Headers de autenticación
$ticketToken = $_SERVER['HTTP_ASISTECLICK_TICKET_TOKEN'] ?? null;
$accessToken = $_SERVER['HTTP_ASISTECLICK_ACCESS_TOKEN'] ?? null;

// Log del evento
error_log("Webhook recibido: " . $data['event_type'] . " - " . $data['ticket_id']);

// Validar que llegó data
if (!$data || !isset($data['event_type'])) \{
    http_response_code(400);
    echo json_encode(['error' => 'Invalid payload']);
    exit;
\}

// Procesar según tipo de evento
switch ($data['event_type']) \{
    case 'TICKET.CLOSED':
        processClosedTicket($data);
        break;
    case 'TICKET.HANDOFF':
        processHandoff($data);
        break;
    default:
        if (strpos($data['event_type'], 'EVENT.') === 0) \{
            processCalendarEvent($data);
        \}
\}

// Responder OK
http_response_code(200);
echo json_encode(['status' => 'received']);

function processClosedTicket($data) \{
    $customer = $data['customer'] ?? [];
    $messages = $data['messages'] ?? [];

    // Ejemplo: Guardar en MySQL
    // $pdo->prepare("INSERT INTO conversations ...")->execute([...]);

    // Ejemplo: Enviar a API de CRM
    // $ch = curl_init('https://tu-crm.com/api/interactions');

    error_log("Ticket cerrado: " . ($customer['name'] ?? 'N/A'));
    error_log("Canal: " . ($data['channel'] ?? 'N/A'));
    error_log("Mensajes: " . count($messages));
\}

function processHandoff($data) \{
    $agent = $data['agent'] ?? [];
    error_log("Transferido a: " . ($agent['name'] ?? 'N/A'));
\}

function processCalendarEvent($data) \{
    $event = $data['event'] ?? [];
    error_log("Evento: " . ($event['event_status'] ?? 'N/A'));
\}
?>

def sync_to_crm(data):
    customer = data['customer']

    # Buscar o crear contacto
    contact = crm.find_by_email(customer['email'])
    if not contact:
        contact = crm.create_contact(\{
            'name': customer['name'],
            'email': customer['email'],
            'phone': customer['phone'],
            'source': 'AsisteClick'
        \})

    # Crear interacción/nota
    crm.add_interaction(contact['id'], \{
        'type': 'chat',
        'channel': data['channel'],
        'subject': data['subject'],
        'transcript': format_messages(data['messages']),
        'agent': data['agent']['name'] if data.get('agent') else 'Bot',
        'tags': data.get('tags', [])
    \})

async function sendToBigQuery(data) \{
    const row = \{
        ticket_id: data.ticket_id,
        timestamp: new Date(data.timestamp),
        channel: data.channel,
        customer_country: data.customer.country_code,
        customer_email: data.customer.email,
        message_count: data.messages.length,
        had_agent: data.bot.transferred_to_agent,
        agent_id: data.agent?.id || null,
        department: data.department?.name,
        tags: data.tags?.join(','),
        sentiment: data.customer.sentiment
    \};

    await bigquery
        .dataset('asisteclick')
        .table('conversations')
        .insert([row]);
\}

def notify_slack(data):
    customer = data['customer']

    # Solo notificar si tiene etiqueta importante
    if 'urgente' in data.get('tags', []):
        slack_message = \{
            'text': f":rotating_light: Conversación urgente cerrada",
            'blocks': [
                \{
                    'type': 'section',
                    'text': \{
                        'type': 'mrkdwn',
                        'text': f"*Cliente:* \{customer['name']\}\n*Email:* \{customer['email']\}\n*Canal:* \{data['channel']\}"
                    \}
                \}
            ]
        \}
        requests.post(SLACK_WEBHOOK_URL, json=slack_message)

const AWS = require('aws-sdk');
const s3 = new AWS.S3();

async function backupToS3(data) \{
    const key = `conversations/$\{data.channel\}/$\{data.ticket_id\}.json`;

    await s3.putObject(\{
        Bucket: 'asisteclick-backup',
        Key: key,
        Body: JSON.stringify(data, null, 2),
        ContentType: 'application/json'
    \}).promise();

    console.log(`Guardado en S3: $\{key\}`);
\}

# Instalar ngrok
npm install -g ngrok

# Exponer su servidor local
ngrok http 3000

# Obtendrá una URL como:
# https://abc123.ngrok.io

import json
from datetime import datetime

def log_webhook(data):
    log_entry = \{
        'received_at': datetime.now().isoformat(),
        'event_type': data.get('event_type'),
        'ticket_id': data.get('ticket_id'),
        'channel': data.get('channel'),
        'payload_size': len(json.dumps(data))
    \}

    with open('webhook_log.jsonl', 'a') as f:
        f.write(json.dumps(log_entry) + '\n')

Causa: URL mal configurada o servidor no accesible
Solución:
1. Verificar que la URL sea accesible públicamente
2. Confirmar que el puerto está abierto
3. Revisar firewall/seguridad

Causa: Su servidor tarda mucho en responder
Solución:
1. Responder inmediatamente con 200 OK
2. Procesar el payload de forma asíncrona
3. No hacer operaciones pesadas en el request handler

Causa: El payload tiene caracteres especiales
Solución:
1. Usar json_decode() o JSON.parse() con manejo de errores
2. Verificar encoding UTF-8

import hashlib

def verify_webhook(ticket_id, received_token, access_token):
    # Generar token esperado
    private_key = "asdfsafeWEREereafa(*@sfad5869)_12342aaaaaa!#232AASF!"
    expected_ticket_token = hashlib.md5(
        (ticket_id + private_key).encode()
    ).hexdigest()

    # Validar key del payload
    expected_key = hashlib.md5(
        (ticket_id + access_token).encode()
    ).hexdigest()

    return received_token == expected_ticket_token