Send events to Ontre

import { createHmac } from 'node:crypto';

const baseUrl = process.env.ONTRE_BASE_URL;
const webhookPath = process.env.ONTRE_WEBHOOK_PATH;
const signingKey = process.env.ONTRE_SIGNING_KEY;
if (!baseUrl || !webhookPath || !signingKey) {
  throw new Error('Missing Ontre configuration');
}

const body = JSON.stringify({
  source: 'checkout-api',
  eventType: 'payment.failed',
  eventId: 'evt_2f9a',
  occurredAt: new Date().toISOString(),
  correlationId: 'order_88f2',
  attributes: { amount: 4200, currency: 'NGN' }
});
const timestamp = String(Math.floor(Date.now() / 1000));
const signature = createHmac('sha256', signingKey)
  .update(timestamp + '.' + body, 'utf8')
  .digest('hex');

const response = await fetch(new URL(webhookPath, baseUrl), {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json; charset=utf-8',
    'X-Ontre-Timestamp': timestamp,
    'X-Ontre-Signature': signature
  },
  body
});
if (response.status !== 202) {
  throw new Error('Ontre returned ' + response.status + ': ' + await response.text());
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.util.HexFormat;

public class SendEvent {
  public static void main(String[] args) throws Exception {
    String baseUrl = System.getenv("ONTRE_BASE_URL");
    String webhookPath = System.getenv("ONTRE_WEBHOOK_PATH");
    String signingKey = System.getenv("ONTRE_SIGNING_KEY");
    if (baseUrl == null || webhookPath == null || signingKey == null) {
      throw new IllegalStateException("Missing Ontre configuration");
    }

    String body = "{"
        + "\"source\":\"checkout-api\","
        + "\"eventType\":\"payment.failed\","
        + "\"eventId\":\"evt_2f9a\","
        + "\"occurredAt\":\"" + Instant.now() + "\","
        + "\"correlationId\":\"order_88f2\","
        + "\"attributes\":{\"amount\":4200,\"currency\":\"NGN\"}"
        + "}";
    String timestamp = Long.toString(Instant.now().getEpochSecond());
    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(new SecretKeySpec(signingKey.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
    String signature = HexFormat.of().formatHex(
        mac.doFinal((timestamp + "." + body).getBytes(StandardCharsets.UTF_8)));

    HttpRequest request = HttpRequest.newBuilder(URI.create(baseUrl).resolve(webhookPath))
        .header("Content-Type", "application/json; charset=utf-8")
        .header("X-Ontre-Timestamp", timestamp)
        .header("X-Ontre-Signature", signature)
        .POST(HttpRequest.BodyPublishers.ofString(body, StandardCharsets.UTF_8))
        .build();
    HttpResponse<String> response = HttpClient.newHttpClient()
        .send(request, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
    if (response.statusCode() != 202) {
      throw new IllegalStateException(
          "Ontre returned " + response.statusCode() + ": " + response.body());
    }
  }
}

using System.Net.Http;
using System.Security.Cryptography;
using System.Text;

var baseUrl = Environment.GetEnvironmentVariable("ONTRE_BASE_URL");
var webhookPath = Environment.GetEnvironmentVariable("ONTRE_WEBHOOK_PATH");
var signingKey = Environment.GetEnvironmentVariable("ONTRE_SIGNING_KEY");
if (string.IsNullOrEmpty(baseUrl) || string.IsNullOrEmpty(webhookPath) || string.IsNullOrEmpty(signingKey))
{
    throw new InvalidOperationException("Missing Ontre configuration");
}

var occurredAt = DateTime.UtcNow.ToString("yyyy-MM-dd'T'HH:mm:ss'Z'");
var body = "{"
    + "\"source\":\"checkout-api\","
    + "\"eventType\":\"payment.failed\","
    + "\"eventId\":\"evt_2f9a\","
    + "\"occurredAt\":\"" + occurredAt + "\","
    + "\"correlationId\":\"order_88f2\","
    + "\"attributes\":{\"amount\":4200,\"currency\":\"NGN\"}"
    + "}";
var timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
var signature = Convert.ToHexString(HMACSHA256.HashData(
    Encoding.UTF8.GetBytes(signingKey),
    Encoding.UTF8.GetBytes(timestamp + "." + body))).ToLowerInvariant();

using var client = new HttpClient();
using var request = new HttpRequestMessage(
    HttpMethod.Post, new Uri(new Uri(baseUrl), webhookPath));
request.Content = new StringContent(body, Encoding.UTF8, "application/json");
request.Headers.TryAddWithoutValidation("X-Ontre-Timestamp", timestamp);
request.Headers.TryAddWithoutValidation("X-Ontre-Signature", signature);

var response = await client.SendAsync(request);
var text = await response.Content.ReadAsStringAsync();
if ((int)response.StatusCode != 202)
{
    throw new InvalidOperationException($"Ontre returned {(int)response.StatusCode}: {text}");
}

import hashlib
import hmac
import json
import os
import time
from datetime import datetime, timezone
from urllib.error import HTTPError
from urllib.request import Request, urlopen

base_url = os.environ.get("ONTRE_BASE_URL")
webhook_path = os.environ.get("ONTRE_WEBHOOK_PATH")
signing_key = os.environ.get("ONTRE_SIGNING_KEY")
if not base_url or not webhook_path or not signing_key:
    raise SystemExit("Missing Ontre configuration")

body = json.dumps({
    "source": "checkout-api",
    "eventType": "payment.failed",
    "eventId": "evt_2f9a",
    "occurredAt": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
    "correlationId": "order_88f2",
    "attributes": {"amount": 4200, "currency": "NGN"},
}, separators=(",", ":"))
timestamp = str(int(time.time()))
signature = hmac.new(
    signing_key.encode("utf-8"),
    f"{timestamp}.{body}".encode("utf-8"),
    hashlib.sha256,
).hexdigest()

request = Request(
    base_url.rstrip("/") + "/" + webhook_path.lstrip("/"),
    data=body.encode("utf-8"),
    method="POST",
    headers={
        "Content-Type": "application/json; charset=utf-8",
        "X-Ontre-Timestamp": timestamp,
        "X-Ontre-Signature": signature,
    },
)
try:
    with urlopen(request) as response:
        status, text = response.status, response.read().decode()
except HTTPError as error:
    status, text = error.code, error.read().decode()
if status != 202:
    raise SystemExit(f"Ontre returned {status}: {text}")