Webhooks

// webhook.js — Wis.Chat webhook receiver (Node.js + Express)
const express = require('express');
const fs      = require('fs');

const VERIFY_TOKEN = 'TU_TOKEN_VERIFICACION';
const PORT         = 3000;
const LOG_FILE     = './wischat_webhook.log';

const app = express();
app.use(express.json({ limit: '1mb' }));

app.post('/webhook', (req, res) => {
  // 1. Validar token
  const token = req.headers['x-wischat-token'];
  if (token !== VERIFY_TOKEN) return res.status(401).send('Unauthorized');

  // 2. Loguear
  fs.appendFileSync(LOG_FILE,
    new Date().toISOString() + ' ' + JSON.stringify(req.body) + '\n'
  );

  // 3. Responder OK rápido — procesa async después
  res.status(200).send('OK');

  // 4. Procesar evento (sin bloquear la respuesta)
  setImmediate(() => procesarEvento(req.body));
});

function procesarEvento(evt) {
  const { event: tipo, data } = evt;

  if (tipo === 'message.received') {
    manejarMensajeEntrante(data);
  } else if (tipo === 'message.status') {
    actualizarEstado(data);
  }
}

function manejarMensajeEntrante(data) {
  const { from: de, type: tipo } = data;

  if (tipo === 'text') {
    const texto = data.text?.body;
    // TODO: guardar en BD, disparar bot, notificar agente, etc.
  } else if (tipo === 'interactive') {
    const btnId = data.interactive?.button_reply?.id;
    // TODO: rutear según el botón
  }
}

function actualizarEstado(data) {
  const { wamid, status: estado } = data;
  // TODO: actualizar estado del mensaje en tu BD
}

app.listen(PORT, () => console.log(`Webhook escuchando en :${PORT}`));

# webhook.py — Wis.Chat webhook receiver (Flask)
from flask import Flask, request, jsonify
from threading import Thread
import json, datetime

VERIFY_TOKEN = 'TU_TOKEN_VERIFICACION'
LOG_FILE     = 'wischat_webhook.log'

app = Flask(__name__)

@app.route('/webhook', methods=['POST'])
def webhook():
    # 1. Validar token
    if request.headers.get('X-Wischat-Token') != VERIFY_TOKEN:
        return 'Unauthorized', 401

    evt = request.get_json(silent=True)
    if evt is None:
        return 'Bad JSON', 400

    # 2. Loguear
    with open(LOG_FILE, 'a') as f:
        f.write(f'{datetime.datetime.utcnow().isoformat()} {json.dumps(evt)}\n')

    # 3. Procesar en background — responde rápido
    Thread(target=procesar_evento, args=(evt,)).start()
    return 'OK', 200


def procesar_evento(evt):
    tipo = evt.get('event')
    data = evt.get('data', {})

    if tipo == 'message.received':
        manejar_mensaje_entrante(data)
    elif tipo == 'message.status':
        actualizar_estado(data)


def manejar_mensaje_entrante(data):
    de   = data.get('from')
    tipo = data.get('type')

    if tipo == 'text':
        texto = data.get('text', {}).get('body', '')
        # TODO: guardar en BD, disparar bot, notificar agente, etc.
    elif tipo == 'interactive':
        btn_id = data.get('interactive', {}).get('button_reply', {}).get('id')
        # TODO: rutear según el botón


def actualizar_estado(data):
    wamid  = data.get('wamid')
    estado = data.get('status')
    # TODO: actualizar estado del mensaje en tu BD


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=3000)

// WebhookController.cs — Wis.Chat webhook receiver (ASP.NET Core)
using Microsoft.AspNetCore.Mvc;
using System.Text.Json;

[ApiController]
[Route("webhook")]
public class WebhookController : ControllerBase
{
    private const string VerifyToken = "TU_TOKEN_VERIFICACION";
    private const string LogFile     = "wischat_webhook.log";

    [HttpPost]
    public async Task<IActionResult> Recibir()
    {
        // 1. Validar token
        if (!Request.Headers.TryGetValue("X-Wischat-Token", out var token)
            || token != VerifyToken)
        {
            return Unauthorized();
        }

        // 2. Leer body
        using var reader = new StreamReader(Request.Body);
        var body = await reader.ReadToEndAsync();
        var evt = JsonDocument.Parse(body).RootElement;

        // 3. Loguear
        await System.IO.File.AppendAllTextAsync(LogFile,
            $"{DateTime.UtcNow:o} {body}\n");

        // 4. Procesar en background
        _ = Task.Run(() => ProcesarEvento(evt));

        return Ok();
    }

    private void ProcesarEvento(JsonElement evt)
    {
        var tipo = evt.GetProperty("event").GetString();
        var data = evt.GetProperty("data");

        switch (tipo)
        {
            case "message.received":
                ManejarMensajeEntrante(data);
                break;
            case "message.status":
                ActualizarEstado(data);
                break;
        }
    }

    private void ManejarMensajeEntrante(JsonElement data)
    {
        var de   = data.GetProperty("from").GetString();
        var tipo = data.GetProperty("type").GetString();

        if (tipo == "text")
        {
            var texto = data.GetProperty("text").GetProperty("body").GetString();
            // TODO: guardar en BD, disparar bot, notificar agente, etc.
        }
        else if (tipo == "interactive")
        {
            var btnId = data.GetProperty("interactive")
                            .GetProperty("button_reply")
                            .GetProperty("id").GetString();
            // TODO: rutear según el botón
        }
    }

    private void ActualizarEstado(JsonElement data)
    {
        var wamid  = data.GetProperty("wamid").GetString();
        var estado = data.GetProperty("status").GetString();
        // TODO: actualizar estado del mensaje en tu BD
    }
}