Handle inbound media from webhooks

# 1. Fetch message details to get the media_url
curl -X GET "https://api.wazapin.com/v1/messages/9f1fd66d-c37a-4b50-a8c2-b4dca523f9c8" \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Accept: application/json"

# 2. Download the binary file directly using the media_url from the response
curl -o "receipt.png" "https://api.wazapin.com/v1/media/assets/download_url"

import express from "express";
import { Webhook } from "svix";
import { WazapinClient } from "@wazapin/sdk";
import fs from "fs";
import axios from "axios";
import path from "path";

const app = express();
const wazapin = new WazapinClient({ apiKey: process.env.WAZAPIN_API_KEY });
const wh = new Webhook(process.env.WAZAPIN_WEBHOOK_SECRET!);

app.post("/webhooks/wazapin", express.raw({ type: "application/json" }), async (req, res) => {
  try {
    wh.verify(req.body, req.headers as Record<string, string>);
  } catch (err) {
    return res.status(403).send("Invalid signature");
  }

  const payload = JSON.parse(req.body.toString("utf8"));
  const mediaTypes = ["image", "video", "audio", "document", "sticker"];

  if (payload.direction === "inbound" && mediaTypes.includes(payload.msg_type)) {
    const messageId = payload.message_id;

    // 1. Retrieve the message record to get the media URL
    const { data: message } = await wazapin.messages.get(messageId);
    
    // Stickers use content.sticker_url; other media types use content.media_url
    const mediaUrl = message.type === "sticker" 
      ? message.content?.sticker_url 
      : message.content?.media_url;

    if (mediaUrl) {
      // 2. Download and save the file
      const downloadPath = path.join(__dirname, "downloads", `${messageId}.bin`);
      const response = await axios({
        url: mediaUrl,
        method: "GET",
        responseType: "stream",
      });

      const writer = fs.createWriteStream(downloadPath);
      response.data.pipe(writer);

      writer.on("finish", () => console.log(`Downloaded media to ${downloadPath}`));
      writer.on("error", (err) => console.error("Download failed", err));
    }
  }

  res.status(200).send("OK");
});

from fastapi import FastAPI, Request, HTTPException
from svix.webhooks import Webhook, WebhookVerificationError
import requests
import os

app = FastAPI()
wh = Webhook(os.environ["WAZAPIN_WEBHOOK_SECRET"])
API_KEY = os.environ["WAZAPIN_API_KEY"]

@app.post("/webhooks/wazapin")
async def handle_webhook(request: Request):
    body = await request.body()
    try:
        wh.verify(body, dict(request.headers))
    except WebhookVerificationError:
        raise HTTPException(status_code=403, detail="Invalid signature")

    payload = await request.json()
    media_types = {"image", "video", "audio", "document", "sticker"}

    if payload.get("direction") == "inbound" and payload.get("msg_type") in media_types:
        message_id = payload.get("message_id")
        
        # 1. Retrieve message details
        response = requests.get(
            f"https://api.wazapin.com/v1/messages/{message_id}",
            headers={"X-Api-Key": API_KEY, "Accept": "application/json"}
        )
        
        if response.status_code == 200:
            message_data = response.json().get("data", {})
            msg_type = message_data.get("type")
            content = message_data.get("content", {})
            
            # Stickers use sticker_url; other media types use media_url
            media_url = content.get("sticker_url") if msg_type == "sticker" else content.get("media_url")
            
            if media_url:
                # 2. Download and write file binary
                media_res = requests.get(media_url, stream=True)
                if media_res.status_code == 200:
                    file_path = f"downloads/{message_id}.bin"
                    with open(file_path, "wb") as f:
                        for chunk in media_res.iter_content(chunk_size=8192):
                            f.write(chunk)
                    print(f"Media successfully saved to {file_path}")

    return {"ok": True}