Receiving RCS Webhooks

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/webhooks/rcs", methods=["POST"])
def handle_rcs_webhook():
    event = request.json
    event_type = event["data"]["event_type"]
    payload = event["data"]["payload"]

    if event_type == "message.received":
        handle_inbound(payload)
    elif event_type == "message.sent":
        print(f"Message {payload['id']} sent")
    elif event_type == "message.finalized":
        handle_delivery(payload)
    elif event_type == "message.read":
        handle_read_receipt(payload)

    return jsonify({"status": "ok"}), 200


def handle_inbound(payload):
    body = payload["body"]
    sender = payload["from"]["phone_number"]

    if "text" in body:
        print(f"Text from {sender}: {body['text']}")
    elif "user_file" in body:
        file_info = body["user_file"]["payload"]
        print(f"File from {sender}: {file_info['file_name']} ({file_info['mime_type']})")
    elif "location" in body:
        loc = body["location"]
        print(f"Location from {sender}: {loc['latitude']}, {loc['longitude']}")
    elif "suggestion_response" in body:
        resp = body["suggestion_response"]
        print(f"Suggestion from {sender}: {resp['text']} (postback: {resp['postback_data']})")


def handle_delivery(payload):
    message_id = payload["id"]
    for recipient in payload.get("to", []):
        status = recipient.get("status")
        phone = recipient.get("phone_number")
        print(f"Message {message_id} to {phone}: {status}")

        if status == "delivery_failed":
            # Implement fallback — e.g., send via SMS
            print(f"Delivery failed for {phone}, triggering SMS fallback")


def handle_read_receipt(payload):
    message_id = payload["id"]
    for recipient in payload.get("to", []):
        phone = recipient.get("phone_number")
        print(f"Message {message_id} read by {phone}")
        # Update message status in your database
        # db.messages.update(message_id, read=True, read_at=datetime.utcnow())


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

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

app.post('/webhooks/rcs', (req, res) => {
  const event = req.body;
  const eventType = event.data.event_type;
  const payload = event.data.payload;

  switch (eventType) {
    case 'message.received':
      handleInbound(payload);
      break;
    case 'message.sent':
      console.log(`Message ${payload.id} sent`);
      break;
    case 'message.finalized':
      handleDelivery(payload);
      break;
    case 'message.read':
      handleReadReceipt(payload);
      break;
  }

  res.status(200).json({ status: 'ok' });
});

function handleInbound(payload) {
  const body = payload.body;
  const sender = payload.from.phone_number;

  if (body.text) {
    console.log(`Text from ${sender}: ${body.text}`);
  } else if (body.user_file) {
    const file = body.user_file.payload;
    console.log(`File from ${sender}: ${file.file_name} (${file.mime_type})`);
  } else if (body.location) {
    console.log(`Location from ${sender}: ${body.location.latitude}, ${body.location.longitude}`);
  } else if (body.suggestion_response) {
    const resp = body.suggestion_response;
    console.log(`Suggestion from ${sender}: ${resp.text} (postback: ${resp.postback_data})`);
  }
}

function handleDelivery(payload) {
  const messageId = payload.id;
  for (const recipient of payload.to || []) {
    console.log(`Message ${messageId} to ${recipient.phone_number}: ${recipient.status}`);

    if (recipient.status === 'delivery_failed') {
      console.log(`Delivery failed for ${recipient.phone_number}, triggering SMS fallback`);
    }
  }
}

function handleReadReceipt(payload) {
  const messageId = payload.id;
  for (const recipient of payload.to || []) {
    console.log(`Message ${messageId} read by ${recipient.phone_number}`);
    // Update message status in your database
  }
}

app.listen(5000, () => console.log('RCS webhook server running on port 5000'));

require "sinatra"
require "json"

set :port, 5000

post "/webhooks/rcs" do
  event = JSON.parse(request.body.read)
  event_type = event.dig("data", "event_type")
  payload = event.dig("data", "payload")

  case event_type
  when "message.received"
    handle_inbound(payload)
  when "message.sent"
    puts "Message #{payload['id']} sent"
  when "message.finalized"
    handle_delivery(payload)
  when "message.read"
    handle_read_receipt(payload)
  end

  { status: "ok" }.to_json
end

def handle_inbound(payload)
  body = payload["body"]
  sender = payload.dig("from", "phone_number")

  if body["text"]
    puts "Text from #{sender}: #{body['text']}"
  elsif body["user_file"]
    file = body.dig("user_file", "payload")
    puts "File from #{sender}: #{file['file_name']} (#{file['mime_type']})"
  elsif body["location"]
    loc = body["location"]
    puts "Location from #{sender}: #{loc['latitude']}, #{loc['longitude']}"
  elsif body["suggestion_response"]
    resp = body["suggestion_response"]
    puts "Suggestion from #{sender}: #{resp['text']} (postback: #{resp['postback_data']})"
  end
end

def handle_delivery(payload)
  payload.fetch("to", []).each do |recipient|
    puts "Message #{payload['id']} to #{recipient['phone_number']}: #{recipient['status']}"
  end
end

def handle_read_receipt(payload)
  payload.fetch("to", []).each do |recipient|
    puts "Message #{payload['id']} read by #{recipient['phone_number']}"
  end
end

import com.sun.net.httpserver.*;
import java.io.*;
import java.net.InetSocketAddress;
import org.json.*;

public class RcsWebhookServer {
    public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress(5000), 0);
        server.createContext("/webhooks/rcs", exchange -> {
            if (!"POST".equals(exchange.getRequestMethod())) {
                exchange.sendResponseHeaders(405, -1);
                return;
            }

            String body = new String(exchange.getRequestBody().readAllBytes());
            JSONObject event = new JSONObject(body);
            String eventType = event.getJSONObject("data").getString("event_type");
            JSONObject payload = event.getJSONObject("data").getJSONObject("payload");

            switch (eventType) {
                case "message.received" -> handleInbound(payload);
                case "message.finalized" -> handleDelivery(payload);
                case "message.read" -> handleReadReceipt(payload);
                default -> System.out.println("Event: " + eventType);
            }

            String response = "{\"status\":\"ok\"}";
            exchange.sendResponseHeaders(200, response.length());
            exchange.getResponseBody().write(response.getBytes());
            exchange.close();
        });
        server.start();
        System.out.println("RCS webhook server running on port 5000");
    }

    static void handleInbound(JSONObject payload) {
        JSONObject body = payload.getJSONObject("body");
        String sender = payload.getJSONObject("from").getString("phone_number");

        if (body.has("text")) {
            System.out.printf("Text from %s: %s%n", sender, body.getString("text"));
        } else if (body.has("suggestion_response")) {
            JSONObject resp = body.getJSONObject("suggestion_response");
            System.out.printf("Suggestion from %s: %s%n", sender, resp.getString("text"));
        }
    }

    static void handleDelivery(JSONObject payload) {
        String msgId = payload.getString("id");
        JSONArray to = payload.getJSONArray("to");
        for (int i = 0; i < to.length(); i++) {
            JSONObject r = to.getJSONObject(i);
            System.out.printf("Message %s to %s: %s%n",
                msgId, r.getString("phone_number"), r.getString("status"));
        }
    }

    static void handleReadReceipt(JSONObject payload) {
        String msgId = payload.getString("id");
        JSONArray to = payload.getJSONArray("to");
        for (int i = 0; i < to.length(); i++) {
            System.out.printf("Message %s read by %s%n",
                msgId, to.getJSONObject(i).getString("phone_number"));
        }
    }
}

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using System.Text.Json;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/webhooks/rcs", async (HttpContext context) =>
{
    var body = await new StreamReader(context.Request.Body).ReadToEndAsync();
    var doc = JsonDocument.Parse(body);
    var data = doc.RootElement.GetProperty("data");
    var eventType = data.GetProperty("event_type").GetString();
    var payload = data.GetProperty("payload");

    switch (eventType)
    {
        case "message.received":
            HandleInbound(payload);
            break;
        case "message.finalized":
            HandleDelivery(payload);
            break;
        case "message.read":
            HandleReadReceipt(payload);
            break;
    }

    return Results.Json(new { status = "ok" });
});

void HandleInbound(JsonElement payload)
{
    var body = payload.GetProperty("body");
    var sender = payload.GetProperty("from").GetProperty("phone_number").GetString();

    if (body.TryGetProperty("text", out var text))
        Console.WriteLine($"Text from {sender}: {text}");
    else if (body.TryGetProperty("suggestion_response", out var suggestion))
        Console.WriteLine($"Suggestion from {sender}: {suggestion.GetProperty("text")}");
    else if (body.TryGetProperty("location", out var location))
        Console.WriteLine($"Location from {sender}: {location.GetProperty("latitude")}, {location.GetProperty("longitude")}");
}

void HandleDelivery(JsonElement payload)
{
    var msgId = payload.GetProperty("id").GetString();
    foreach (var r in payload.GetProperty("to").EnumerateArray())
        Console.WriteLine($"Message {msgId} to {r.GetProperty("phone_number")}: {r.GetProperty("status")}");
}

void HandleReadReceipt(JsonElement payload)
{
    var msgId = payload.GetProperty("id").GetString();
    foreach (var r in payload.GetProperty("to").EnumerateArray())
        Console.WriteLine($"Message {msgId} read by {r.GetProperty("phone_number")}");
}

app.Run("http://0.0.0.0:5000");

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

$eventType = $event['data']['event_type'];
$data = $event['data']['payload'];

switch ($eventType) {
    case 'message.received':
        handleInbound($data);
        break;
    case 'message.finalized':
        handleDelivery($data);
        break;
    case 'message.read':
        handleReadReceipt($data);
        break;
}

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

function handleInbound(array $payload): void
{
    $body = $payload['body'];
    $sender = $payload['from']['phone_number'];

    if (isset($body['text'])) {
        echo "Text from {$sender}: {$body['text']}\n";
    } elseif (isset($body['user_file'])) {
        $file = $body['user_file']['payload'];
        echo "File from {$sender}: {$file['file_name']} ({$file['mime_type']})\n";
    } elseif (isset($body['location'])) {
        $loc = $body['location'];
        echo "Location from {$sender}: {$loc['latitude']}, {$loc['longitude']}\n";
    } elseif (isset($body['suggestion_response'])) {
        $resp = $body['suggestion_response'];
        echo "Suggestion from {$sender}: {$resp['text']} (postback: {$resp['postback_data']})\n";
    }
}

function handleDelivery(array $payload): void
{
    foreach ($payload['to'] ?? [] as $recipient) {
        echo "Message {$payload['id']} to {$recipient['phone_number']}: {$recipient['status']}\n";
    }
}

function handleReadReceipt(array $payload): void
{
    foreach ($payload['to'] ?? [] as $recipient) {
        echo "Message {$payload['id']} read by {$recipient['phone_number']}\n";
    }
}

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

type WebhookEvent struct {
	Data struct {
		EventType string `json:"event_type"`
		Payload   struct {
			ID   string `json:"id"`
			Body struct {
				Text               string                 `json:"text,omitempty"`
				Location           map[string]float64     `json:"location,omitempty"`
				SuggestionResponse map[string]string      `json:"suggestion_response,omitempty"`
				UserFile           map[string]interface{} `json:"user_file,omitempty"`
			} `json:"body"`
			From struct {
				PhoneNumber string `json:"phone_number"`
				AgentID     string `json:"agent_id"`
			} `json:"from"`
			To []struct {
				PhoneNumber string `json:"phone_number"`
				Status      string `json:"status"`
			} `json:"to"`
		} `json:"payload"`
	} `json:"data"`
}

func main() {
	http.HandleFunc("/webhooks/rcs", func(w http.ResponseWriter, r *http.Request) {
		body, _ := io.ReadAll(r.Body)
		var event WebhookEvent
		json.Unmarshal(body, &event)

		switch event.Data.EventType {
		case "message.received":
			handleInbound(event)
		case "message.finalized":
			handleDelivery(event)
		case "message.read":
			handleReadReceipt(event)
		}

		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(200)
		fmt.Fprint(w, `{"status":"ok"}`)
	})

	fmt.Println("RCS webhook server running on port 5000")
	http.ListenAndServe(":5000", nil)
}

func handleInbound(event WebhookEvent) {
	p := event.Data.Payload
	sender := p.From.PhoneNumber

	if p.Body.Text != "" {
		fmt.Printf("Text from %s: %s\n", sender, p.Body.Text)
	} else if p.Body.SuggestionResponse != nil {
		fmt.Printf("Suggestion from %s: %s (postback: %s)\n",
			sender, p.Body.SuggestionResponse["text"], p.Body.SuggestionResponse["postback_data"])
	} else if p.Body.Location != nil {
		fmt.Printf("Location from %s: %f, %f\n",
			sender, p.Body.Location["latitude"], p.Body.Location["longitude"])
	}
}

func handleDelivery(event WebhookEvent) {
	for _, r := range event.Data.Payload.To {
		fmt.Printf("Message %s to %s: %s\n", event.Data.Payload.ID, r.PhoneNumber, r.Status)
	}
}

func handleReadReceipt(event WebhookEvent) {
	for _, r := range event.Data.Payload.To {
		fmt.Printf("Message %s read by %s\n", event.Data.Payload.ID, r.PhoneNumber)
	}
}

def normalize_message(event):
    """Normalize SMS/MMS and RCS webhook payloads into a common format."""
    payload = event["data"]["payload"]
    msg_type = payload.get("type", "SMS")

    if msg_type == "RCS":
        # RCS: body is nested object
        body = payload.get("body", {})
        text = body.get("text", "")
        media = []
        if "user_file" in body:
            file_info = body["user_file"]["payload"]
            media.append({
                "url": file_info["file_uri"],
                "content_type": file_info["mime_type"],
                "size": file_info.get("file_size_bytes"),
            })
        sender = payload.get("from", {}).get("phone_number", "")
    else:
        # SMS/MMS: body is flat
        text = payload.get("text", "")
        media = [
            {"url": m["url"], "content_type": m["content_type"]}
            for m in payload.get("media", [])
        ]
        sender = payload.get("from", {}).get("phone_number", "")

    return {
        "id": payload["id"],
        "type": msg_type,
        "sender": sender,
        "text": text,
        "media": media,
        "direction": payload.get("direction"),
    }

function normalizeMessage(event) {
  const payload = event.data.payload;
  const msgType = payload.type || 'SMS';

  if (msgType === 'RCS') {
    const body = payload.body || {};
    const media = [];
    if (body.user_file) {
      const file = body.user_file.payload;
      media.push({
        url: file.file_uri,
        contentType: file.mime_type,
        size: file.file_size_bytes,
      });
    }
    return {
      id: payload.id,
      type: msgType,
      sender: payload.from?.phone_number || '',
      text: body.text || '',
      media,
      direction: payload.direction,
    };
  }

  // SMS/MMS
  return {
    id: payload.id,
    type: msgType,
    sender: payload.from?.phone_number || '',
    text: payload.text || '',
    media: (payload.media || []).map(m => ({
      url: m.url,
      contentType: m.content_type,
    })),
    direction: payload.direction,
  };
}