Webhooks

import { parseWebhookPayload } from '@wistfare/payments';

// In your webhook handler (e.g. Express)
app.post('/webhooks/wistfare', (req, res) => {
  const payload = parseWebhookPayload(req.body);

  switch (payload.event) {
    case 'collection.completed':
      // Credit the order
      break;
    case 'collection.failed':
      // Notify the customer
      break;
  }

  res.status(200).send('ok');
});

from wistfare.payments.client import parse_webhook_payload

# In your webhook handler (e.g. Flask)
@app.route("/webhooks/wistfare", methods=["POST"])
def handle_webhook():
    payload = parse_webhook_payload(request.data)

    if payload.event == "collection.completed":
        # Credit the order
        pass
    elif payload.event == "collection.failed":
        # Notify the customer
        pass

    return "ok", 200

import "github.com/wistfare/wistfare-go/payments"

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    body, _ := io.ReadAll(r.Body)
    payload, err := payments.ParseWebhookPayload(body)
    if err != nil {
        http.Error(w, "invalid payload", http.StatusBadRequest)
        return
    }

    switch payload.Event {
    case "collection.completed":
        // Credit the order
    case "collection.failed":
        // Notify the customer
    }

    w.WriteHeader(http.StatusOK)
}

import 'package:wistfare_payments/wistfare_payments.dart';

// In your shelf/dart_frog handler
Future<Response> onRequest(RequestContext context) async {
  final body = await context.request.body();
  final payload = parseWebhookPayload(body);

  switch (payload.event) {
    case WebhookEvent.collectionCompleted:
      // Credit the order
      break;
    case WebhookEvent.collectionFailed:
      // Notify the customer
      break;
    default:
      break;
  }

  return Response(statusCode: 200);
}

use wistfare::parse_webhook_payload;

// In your Axum/Actix handler
async fn webhook_handler(body: Bytes) -> impl IntoResponse {
    let payload = parse_webhook_payload(&body)
        .expect("invalid webhook payload");

    match payload.event.as_str() {
        "collection.completed" => { /* Credit the order */ }
        "collection.failed" => { /* Notify the customer */ }
        _ => {}
    }

    StatusCode::OK
}

import Wistfare

// In your Vapor route handler
app.post("webhooks", "wistfare") { req async throws -> HTTPStatus in
    let data = Data(buffer: req.body.data!)
    let payload = try PaymentsClient.parseWebhookPayload(data)

    switch payload.event {
    case "collection.completed":
        // Credit the order
        break
    case "collection.failed":
        // Notify the customer
        break
    default:
        break
    }

    return .ok
}

import com.wistfare.sdk.parseWebhookPayload

// In your Ktor/Spring handler
post("/webhooks/wistfare") {
    val body = call.receiveText()
    val payload = parseWebhookPayload(body)

    when (payload.event) {
        "collection.completed" -> { /* Credit the order */ }
        "collection.failed" -> { /* Notify the customer */ }
    }

    call.respond(HttpStatusCode.OK)
}

using Wistfare.Payments;

// In your ASP.NET Core controller
[HttpPost("webhooks/wistfare")]
public IActionResult HandleWebhook()
{
    using var reader = new StreamReader(Request.Body);
    var body = reader.ReadToEnd();
    var payload = WebhookPayload.ParseWebhookPayload(body);

    switch (payload.Event)
    {
        case "collection.completed":
            // Credit the order
            break;
        case "collection.failed":
            // Notify the customer
            break;
    }

    return Ok();
}