Notificacao via Callback

Exemplo de Implementacao

Node.js (Express)

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

app.use(express.json());

// Endpoint para receber notificacoes de Service Orders
app.post('/api/webhooks/service-orders', async (req, res) => {
  try {
    const serviceOrder = req.body;

    // Log da notificacao recebida
    console.log('Notificacao recebida:', {
      id: serviceOrder.id,
      externalId: serviceOrder.externalId,
      state: serviceOrder.state,
      orderDate: serviceOrder.orderDate
    });

    // Processar a notificacao de forma assincrona
    processServiceOrderNotification(serviceOrder)
      .catch(err => console.error('Erro ao processar notificacao:', err));

    // Retornar resposta rapida (nao esperar processamento)
    res.status(200).json({ received: true });

  } catch (error) {
    console.error('Erro ao receber notificacao:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

async function processServiceOrderNotification(serviceOrder) {
  // Verificar idempotencia (evitar processar duplicatas)
  const alreadyProcessed = await checkIfEventProcessed(serviceOrder.id);
  if (alreadyProcessed) {
    console.log('Pedido ja processado:', serviceOrder.id);
    return;
  }

  // Salvar que este pedido foi processado
  await markEventAsProcessed(serviceOrder.id);

  // Atualizar seu sistema baseado no novo estado
  switch (serviceOrder.state) {
    case 'Acknowledged':
      await updateOrderStatus(serviceOrder.externalId, 'RECEBIDO');
      await notifyCustomer(serviceOrder.externalId, 'Seu pedido foi recebido');
      break;

    case 'InProgress':
      await updateOrderStatus(serviceOrder.externalId, 'EM_ANDAMENTO');
      await notifyCustomer(serviceOrder.externalId, 'Seu pedido esta em andamento');
      break;

    case 'Completed':
      await updateOrderStatus(serviceOrder.externalId, 'CONCLUIDO');
      await notifyCustomer(serviceOrder.externalId, 'Seu pedido foi concluido');
      break;

    case 'Failed':
      await updateOrderStatus(serviceOrder.externalId, 'FALHOU');
      await notifyCustomer(serviceOrder.externalId, 'Houve um problema com seu pedido');
      break;

    case 'Cancelled':
      await updateOrderStatus(serviceOrder.externalId, 'CANCELADO');
      await notifyCustomer(serviceOrder.externalId, 'Seu pedido foi cancelado');
      break;

    default:
      console.log('Estado desconhecido:', serviceOrder.state);
  }
}

// Funcoes auxiliares (implementar conforme sua necessidade)
async function checkIfEventProcessed(orderId) {
  // Verificar no banco de dados se este orderId ja foi processado
  // Retorna true se ja foi processado, false caso contrario
}

async function markEventAsProcessed(orderId) {
  // Salvar no banco de dados que este pedido foi processado
  // Incluir timestamp para auditoria
}

async function updateOrderStatus(externalId, status) {
  // Atualizar status do pedido no seu sistema
}

async function notifyCustomer(externalId, message) {
  // Enviar notificacao para o cliente (email, SMS, push, etc)
}

app.listen(3000, () => {
  console.log('Servidor rodando na porta 3000');
});

Python (Flask)

from flask import Flask, request, jsonify
import logging
from datetime import datetime

app = Flask(__name__)
logging.basicConfig(level=logging.INFO)

@app.route('/api/webhooks/service-orders', methods=['POST'])
def service_order_webhook():
    try:
        service_order = request.get_json()

        # Log da notificacao
        logging.info(f"Notificacao recebida: {service_order.get('id')}")

        # Processar de forma assincrona
        process_service_order_notification(service_order)

        # Retornar resposta rapida
        return jsonify({"received": True}), 200

    except Exception as e:
        logging.error(f"Erro ao processar webhook: {str(e)}")
        return jsonify({"error": "Internal server error"}), 500


def process_service_order_notification(service_order):
    order_id = service_order.get('id')
    external_id = service_order.get('externalId')
    state = service_order.get('state')

    # Verificar idempotencia
    if check_if_event_processed(order_id):
        logging.info(f"Pedido ja processado: {order_id}")
        return

    # Marcar como processado
    mark_event_as_processed(order_id)

    # Processar baseado no estado
    if state == 'Acknowledged':
        update_order_status(external_id, 'RECEBIDO')
        notify_customer(external_id, 'Seu pedido foi recebido')

    elif state == 'InProgress':
        update_order_status(external_id, 'EM_ANDAMENTO')
        notify_customer(external_id, 'Seu pedido esta em andamento')

    elif state == 'Completed':
        update_order_status(external_id, 'CONCLUIDO')
        notify_customer(external_id, 'Seu pedido foi concluido')

    elif state == 'Failed':
        update_order_status(external_id, 'FALHOU')
        notify_customer(external_id, 'Houve um problema')

    elif state == 'Cancelled':
        update_order_status(external_id, 'CANCELADO')
        notify_customer(external_id, 'Seu pedido foi cancelado')


def check_if_event_processed(order_id):
    # Implementar verificacao no banco de dados
    pass

def mark_event_as_processed(order_id):
    # Implementar gravacao no banco de dados
    pass

def update_order_status(external_id, status):
    # Implementar atualizacao de status
    pass

def notify_customer(external_id, message):
    # Implementar notificacao ao cliente
    pass


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