Documentație Webhooks

from flask import Flask, request, jsonify
import os

app = Flask(__name__)
WEBHOOK_TOKEN = os.environ.get('CONTENTO_WEBHOOK_TOKEN')

@app.route('/contento/webhook', methods=['POST'])
def webhook():
    # Verifică token-ul de acces
    auth_header = request.headers.get('Authorization', '')
    if WEBHOOK_TOKEN and auth_header != f'Bearer {WEBHOOK_TOKEN}':
        return jsonify({'error': 'Unauthorized'}), 401

    payload = request.get_json()

    # Verificare conexiune
    if payload.get('data', {}).get('verify'):
        return jsonify({'status': 'ok'}), 200

    # Procesează articolele
    articles = payload['data']['articles']
    for article in articles:
        print(f"Articol primit: {article['title']}")
        # Salvează articolul în baza de date, publică-l pe site etc.

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

<?php
$webhookToken = getenv('CONTENTO_WEBHOOK_TOKEN');

// Verifică token-ul de acces
$authHeader = $_SERVER['HTTP_AUTHORIZATION'] ?? '';
if ($webhookToken && $authHeader !== "Bearer $webhookToken") {
    http_response_code(401);
    echo json_encode(['error' => 'Unauthorized']);
    exit;
}

$payload = json_decode(file_get_contents('php://input'), true);

// Verificare conexiune
if (!empty($payload['data']['verify'])) {
    http_response_code(200);
    echo json_encode(['status' => 'ok']);
    exit;
}

// Procesează articolele
foreach ($payload['data']['articles'] as $article) {
    error_log("Articol primit: " . $article['title']);
    // Salvează articolul în baza de date, publică-l pe site etc.
}

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

require 'sinatra'
require 'json'

WEBHOOK_TOKEN = ENV['CONTENTO_WEBHOOK_TOKEN']

post '/contento/webhook' do
  content_type :json

  # Verifică token-ul de acces
  if WEBHOOK_TOKEN
    auth_header = request.env['HTTP_AUTHORIZATION'] || ''
    unless auth_header == "Bearer #{WEBHOOK_TOKEN}"
      halt 401, { error: 'Unauthorized' }.to_json
    end
  end

  payload = JSON.parse(request.body.read)

  # Verificare conexiune
  if payload.dig('data', 'verify')
    return { status: 'ok' }.to_json
  end

  # Procesează articolele
  payload['data']['articles'].each do |article|
    puts "Articol primit: #{article['title']}"
    puts "Slug: #{article['slug']}"
    # Salvează articolul în baza de date, publică-l pe site etc.
  end

  { status: 'received' }.to_json
end

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"strings"
)

type Article struct {
	ID              string  `json:"id"`
	Title           string  `json:"title"`
	ContentMarkdown string  `json:"content_markdown"`
	ContentHTML     string  `json:"content_html"`
	MetaDescription string  `json:"meta_description"`
	CreatedAt       string  `json:"created_at"`
	Slug            string  `json:"slug"`
	ImageURL        *string `json:"image_url"`
}

type Payload struct {
	Timestamp string `json:"timestamp"`
	Data      struct {
		Verify   bool      `json:"verify,omitempty"`
		Articles []Article `json:"articles,omitempty"`
	} `json:"data"`
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	webhookToken := os.Getenv("CONTENTO_WEBHOOK_TOKEN")
	w.Header().Set("Content-Type", "application/json")

	// Verifică token-ul de acces
	if webhookToken != "" {
		auth := r.Header.Get("Authorization")
		if !strings.HasPrefix(auth, "Bearer ") || auth[7:] != webhookToken {
			w.WriteHeader(http.StatusUnauthorized)
			json.NewEncoder(w).Encode(map[string]string{"error": "Unauthorized"})
			return
		}
	}

	var payload Payload
	json.NewDecoder(r.Body).Decode(&payload)

	// Verificare conexiune
	if payload.Data.Verify {
		json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
		return
	}

	// Procesează articolele
	for _, article := range payload.Data.Articles {
		fmt.Printf("Articol primit: %s\n", article.Title)
		fmt.Printf("Slug: %s\n", article.Slug)
		// Salvează articolul în baza de date, publică-l pe site etc.
	}

	json.NewEncoder(w).Encode(map[string]string{"status": "received"})
}

func main() {
	http.HandleFunc("/contento/webhook", webhookHandler)
	http.ListenAndServe(":8080", nil)
}