Webhooks

1. 1. Endpoint URL: The HTTPS URL where we'll send webhook events
2. 2. Events: Select which event types to subscribe to
3. 3. Filters (Optional): Filter events by specific criteria (e.g., only certain asset types)
4. 4. Timeout & Retries: Configure timeout duration (1-60 seconds) and retry attempts (0-10)

Node.js / Express Example:

const crypto = require('crypto');

function verifyWebhookSignature(req, webhookSecret) {
  const signature = req.headers['x-tageur-signature'];
  const payload = JSON.stringify(req.body);

  const expectedSignature = crypto
    .createHmac('sha256', webhookSecret)
    .update(payload)
    .digest('hex');

  return signature === expectedSignature;
}

// Express route handler
app.post('/webhooks/tageur', (req, res) => {
  if (!verifyWebhookSignature(req, process.env.TAGEUR_WEBHOOK_SECRET)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  // Process webhook event
  const { event, data } = req.body;
  console.log(\`Received event: \${event}\`, data);

  res.status(200).json({ received: true });
});

Python / Flask Example:

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

app = Flask(__name__)

def verify_webhook_signature(request, webhook_secret):
    signature = request.headers.get('X-Tageur-Signature')
    payload = request.get_data()

    expected_signature = hmac.new(
        webhook_secret.encode('utf-8'),
        payload,
        hashlib.sha256
    ).hexdigest()

    return hmac.compare_digest(signature, expected_signature)

@app.route('/webhooks/tageur', methods=['POST'])
def handle_webhook():
    if not verify_webhook_signature(request, os.environ['TAGEUR_WEBHOOK_SECRET']):
        return jsonify({'error': 'Invalid signature'}), 401

    event_data = request.json
    event_type = event_data.get('event')
    data = event_data.get('data')

    print(f"Received event: {event_type}", data)

    return jsonify({'received': True}), 200

Retry Behavior:

• Timeout: Configurable from 1-60 seconds (default: 30s)
• Max Retries: Configurable from 0-10 attempts (default: 3)
• Retry Schedule: Exponential backoff (1m, 5m, 15m, 1h, 3h...)
• Success Criteria: HTTP 200-299 response status

When Webhooks Fail:

Deliveries are marked as failed if:

• Connection timeout or network error
• HTTP status code 4xx or 5xx
• Maximum retry attempts exceeded

// Sync new Tageur assets to Dynamics 365
app.post('/webhooks/tageur-to-dynamics', async (req, res) => {
  if (!verifyWebhookSignature(req, WEBHOOK_SECRET)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  const { event, data } = req.body;

  if (event === 'asset.created' || event === 'asset.updated') {
    try {
      // Map Tageur asset to Dynamics entity
      const dynamicsEntity = {
        name: data.attributes.name,
        serialnumber: data.attributes.serial_number,
        assettype: data.attributes.asset_type,
        statuscode: mapStatusToDynamics(data.attributes.status),
        purchasedate: data.attributes.purchase_date,
        // Custom fields
        tageur_asset_id: data.id
      };

      // Update or create in Dynamics
      await dynamicsClient.upsert('equipment', dynamicsEntity);

      res.status(200).json({ synced: true });
    } catch (error) {
      console.error('Dynamics sync error:', error);
      res.status(500).json({ error: error.message });
    }
  } else {
    res.status(200).json({ skipped: true });
  }
});

# Send task completion notifications to Slack
@app.route('/webhooks/tageur-to-slack', methods=['POST'])
def notify_slack():
    if not verify_webhook_signature(request, WEBHOOK_SECRET):
        return jsonify({'error': 'Invalid signature'}), 401

    event_data = request.json
    event_type = event_data.get('event')

    if event_type == 'task.completed':
        data = event_data.get('data', {}).get('attributes', {})

        message = {
            "text": f"✅ Task Completed: {data.get('title')}",
            "blocks": [
                {
                    "type": "section",
                    "text": {
                        "type": "mrkdwn",
                        "text": f"*Task:* {data.get('title')}\\n*Completed by:* {data.get('assigned_to_name')}\\n*Asset:* #{data.get('asset_id')}"
                    }
                }
            ]
        }

        # Send to Slack webhook
        requests.post(SLACK_WEBHOOK_URL, json=message)

    return jsonify({'received': True}), 200

# Using ngrok
ngrok http 3000

# Your webhook URL becomes:
# https://abc123.ngrok.io/webhooks/tageur

POST https://tageur.com/api/webhooks/receive

Headers:
  Authorization: Bearer YOUR_API_KEY
  X-Tageur-Company-ID: YOUR_COMPANY_ID
  Content-Type: application/json

// Microsoft Dynamics 365 webhook integration
const axios = require('axios');

// Dynamics webhook handler
app.post('/webhooks/dynamics-to-tageur', async (req, res) => {
  const dynamicsAsset = req.body;

  // Map Dynamics fields to Tageur format
  const tageurPayload = {
    event: 'asset.created',
    timestamp: new Date().toISOString(),
    data: {
      type: 'asset',
      attributes: {
        name: dynamicsAsset.Name,
        serial_number: dynamicsAsset.SerialNumber,
        asset_type: dynamicsAsset.AssetCategory,
        status: dynamicsAsset.Status === 'Active' ? 'operational' : 'retired',
        brand: dynamicsAsset.Manufacturer,
        model_number: dynamicsAsset.ModelNumber,
        location: dynamicsAsset.Location,
        purchase_date: dynamicsAsset.PurchaseDate,
        extra_values: {
          dynamics_id: dynamicsAsset.AssetId,
          cost_center: dynamicsAsset.CostCenter,
          department: dynamicsAsset.Department,
          purchase_cost: dynamicsAsset.PurchaseCost // Store in extra_values instead
        }
      }
    }
  };

  try {
    // Send to Tageur
    const response = await axios.post(
      'https://tageur.com/api/webhooks/receive',
      tageurPayload,
      {
        headers: {
          'Authorization': `Bearer ${process.env.TAGEUR_API_KEY}`,
          'X-Tageur-Company-ID': process.env.TAGEUR_COMPANY_ID,
          'Content-Type': 'application/json'
        }
      }
    );

    console.log('Asset synced to Tageur:', response.data);
    res.status(200).json({ success: true });
  } catch (error) {
    console.error('Failed to sync to Tageur:', error.response?.data);
    res.status(500).json({ error: 'Sync failed' });
  }
});