Reintentos y entregas

import os
from compense_gateway import CompenseClient

client = CompenseClient(api_key=os.environ["COMPENSE_API_KEY"], environment="sandbox")

page = client.webhooks.deliveries.list(
    status="failed",
    event_type="credits.decision",
    date_from="2026-10-01",
    date_to="2026-10-31",
    page_size=50,
)
print("total:", page.count)
for d in page:
    print(d["id"], d["event_type"], d["status"], d["attempt_number"], d["response_status_code"])

import { CompenseClient } from "@compense/sdk";

const client = new CompenseClient({ apiKey: process.env.COMPENSE_API_KEY!, environment: "sandbox" });

const page = await client.webhooks.deliveries.list({
  status: "failed",
  eventType: "credits.decision",
  dateFrom: "2026-10-01",
  dateTo: "2026-10-31",
  pageSize: 50,
});
console.log("total:", page.count);
for (const d of page) {
  console.log(d.id, d.event_type, d.status, d.attempt_number, d.response_status_code);
}

<?php
require __DIR__ . '/vendor/autoload.php';

use Compense\Sdk\CompenseClient;

$client = new CompenseClient(apiKey: getenv('COMPENSE_API_KEY'), environment: 'sandbox');

$page = $client->webhooks->deliveries->list(
    status: 'failed',
    eventType: 'credits.decision',
    dateFrom: '2026-10-01',
    dateTo: '2026-10-31',
    pageSize: 50,
);
echo 'total: ', $page->count, PHP_EOL;
foreach ($page as $d) {
    echo $d['id'], ' ', $d['event_type'], ' ', $d['status'], ' ', $d['attempt_number'], PHP_EOL;
}

using System.Text.Json.Nodes;
using Compense.Sdk;
using Compense.Sdk.Models;

using var client = new CompenseClient(
    Environment.GetEnvironmentVariable("COMPENSE_API_KEY")!, CompenseEnvironment.Sandbox);

Page page = await client.Webhooks.Deliveries.ListAsync(
    status: "failed",
    eventType: "credits.decision",
    dateFrom: "2026-10-01",
    dateTo: "2026-10-31",
    pageSize: 50);
Console.WriteLine($"total: {page.Count}");
foreach (JsonObject d in page)
{
    Console.WriteLine($"{d["id"]} {d["event_type"]} {d["status"]} {d["attempt_number"]} {d["response_status_code"]}");
}

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	compense "github.com/Appiasoft/compense-saas-sdk-go"
)

func main() {
	ctx := context.Background()
	client, err := compense.NewClient(os.Getenv("COMPENSE_API_KEY"),
		compense.WithEnvironment(compense.Sandbox))
	if err != nil {
		log.Fatal(err)
	}

	page, err := client.Webhooks.Deliveries.List(ctx, &compense.DeliveryListParams{
		Status:    "failed",
		EventType: "credits.decision",
		DateFrom:  "2026-10-01",
		DateTo:    "2026-10-31",
		PageSize:  50,
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("total:", page.Count)
	for _, d := range page.Results {
		fmt.Println(d["id"], d["event_type"], d["status"], d["attempt_number"], d["response_status_code"])
	}
}

curl "https://sandbox.dev.compense.co/gw/v1/gateway/webhooks/deliveries/?status=failed&event_type=credits.decision&date_from=2026-10-01&date_to=2026-10-31&page_size=50" \
  -H "X-API-Key: $COMPENSE_API_KEY"

detalle = client.webhooks.deliveries.get("8b7c6d5e-0000-4a1b-9c2d-000000000301")
print(detalle["status"], detalle["response"]["status_code"], detalle["response"]["body_preview"])
for intento in detalle["attempts"]:
    print(intento["attempt_number"], intento["status"], intento["response_status_code"])

const detalle = await client.webhooks.deliveries.get("8b7c6d5e-0000-4a1b-9c2d-000000000301");
const respuesta = detalle.response as Record<string, unknown>;
console.log(detalle.status, respuesta.status_code, respuesta.body_preview);
for (const intento of detalle.attempts as Array<Record<string, unknown>>) {
  console.log(intento.attempt_number, intento.status, intento.response_status_code);
}

$detalle = $client->webhooks->deliveries->get('8b7c6d5e-0000-4a1b-9c2d-000000000301');
echo $detalle['status'], ' ', $detalle['response']['status_code'], ' ', $detalle['response']['body_preview'], PHP_EOL;
foreach ($detalle['attempts'] as $intento) {
    echo $intento['attempt_number'], ' ', $intento['status'], ' ', $intento['response_status_code'], PHP_EOL;
}

JsonObject detalle = await client.Webhooks.Deliveries.GetAsync("8b7c6d5e-0000-4a1b-9c2d-000000000301");
Console.WriteLine($"{detalle["status"]} {detalle["response"]?["status_code"]} {detalle["response"]?["body_preview"]}");
foreach (JsonNode? intento in detalle["attempts"]!.AsArray())
{
    Console.WriteLine($"{intento!["attempt_number"]} {intento["status"]} {intento["response_status_code"]}");
}

detalle, err := client.Webhooks.Deliveries.Get(ctx, "8b7c6d5e-0000-4a1b-9c2d-000000000301")
if err != nil {
	log.Fatal(err)
}
resp, _ := detalle["response"].(map[string]any)
fmt.Println(detalle["status"], resp["status_code"], resp["body_preview"])
for _, raw := range detalle["attempts"].([]any) {
	intento := raw.(map[string]any)
	fmt.Println(intento["attempt_number"], intento["status"], intento["response_status_code"])
}

curl https://sandbox.dev.compense.co/gw/v1/gateway/webhooks/deliveries/$DELIVERY_ID/ \
  -H "X-API-Key: $COMPENSE_API_KEY"

tx = client.webhooks.deliveries.replay(
    "8b7c6d5e-0000-4a1b-9c2d-000000000301",
    idempotency_key="replay-8b7c6d5e-0000-4a1b-9c2d-000000000301",
)
print(tx.data["delivery_id"], tx.data["replayed_from"], tx.data["attempt_number"], tx.data["status"])

const tx = await client.webhooks.deliveries.replay("8b7c6d5e-0000-4a1b-9c2d-000000000301", {
  idempotencyKey: "replay-8b7c6d5e-0000-4a1b-9c2d-000000000301",
});
console.log(tx.data.delivery_id, tx.data.replayed_from, tx.data.attempt_number, tx.data.status);

$tx = $client->webhooks->deliveries->replay(
    '8b7c6d5e-0000-4a1b-9c2d-000000000301',
    idempotencyKey: 'replay-8b7c6d5e-0000-4a1b-9c2d-000000000301',
);
echo $tx->data['delivery_id'], ' ', $tx->data['attempt_number'], ' ', $tx->data['status'], PHP_EOL;

Transaction tx = await client.Webhooks.Deliveries.ReplayAsync(
    "8b7c6d5e-0000-4a1b-9c2d-000000000301",
    idempotencyKey: "replay-8b7c6d5e-0000-4a1b-9c2d-000000000301");
Console.WriteLine($"{tx.Data["delivery_id"]} {tx.Data["replayed_from"]} {tx.Data["attempt_number"]} {tx.Data["status"]}");

tx, err := client.Webhooks.Deliveries.Replay(ctx, "8b7c6d5e-0000-4a1b-9c2d-000000000301",
	compense.WithIdempotencyKey("replay-8b7c6d5e-0000-4a1b-9c2d-000000000301"))
if err != nil {
	log.Fatal(err)
}
fmt.Println(tx.Data["delivery_id"], tx.Data["replayed_from"], tx.Data["attempt_number"], tx.Data["status"])

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/webhooks/deliveries/$DELIVERY_ID/replay/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Idempotency-Key: replay-$DELIVERY_ID"

import os
from compense_gateway import CompenseClient, IdempotencyConflictError

client = CompenseClient(api_key=os.environ["COMPENSE_API_KEY"], environment="sandbox")
DESDE, TAM = "2026-10-01", 100


def ids_por_estado(status: str) -> list[str]:
    ids, pagina = [], 1
    while True:
        page = client.webhooks.deliveries.list(status=status, date_from=DESDE,
                                               page=pagina, page_size=TAM)
        ids.extend(d["id"] for d in page)
        if not page.results or pagina * TAM >= page.count:
            return ids
        pagina += 1


pendientes = ids_por_estado("failed") + ids_por_estado("abandoned")
print(f"{len(pendientes)} entregas por reintentar")

for delivery_id in pendientes:
    try:
        tx = client.webhooks.deliveries.replay(delivery_id, idempotency_key=f"replay-{delivery_id}")
        print(delivery_id, "→", tx.data["delivery_id"])
    except IdempotencyConflictError as e:      # 409: no reintentable o endpoint inactivo
        print(delivery_id, "omitida:", e.detail)

import { CompenseClient, IdempotencyConflictError } from "@compense/sdk";

const client = new CompenseClient({ apiKey: process.env.COMPENSE_API_KEY!, environment: "sandbox" });
const DESDE = "2026-10-01";

async function idsPorEstado(status: string): Promise<string[]> {
  const ids: string[] = [];
  const primera = await client.webhooks.deliveries.list({ status, dateFrom: DESDE, pageSize: 100 });
  for await (const d of primera) ids.push(String(d.id)); // pide las páginas siguientes por ti
  return ids;
}

const pendientes = [...(await idsPorEstado("failed")), ...(await idsPorEstado("abandoned"))];
console.log(`${pendientes.length} entregas por reintentar`);

for (const deliveryId of pendientes) {
  try {
    const tx = await client.webhooks.deliveries.replay(deliveryId, { idempotencyKey: `replay-${deliveryId}` });
    console.log(deliveryId, "→", tx.data.delivery_id);
  } catch (err) {
    if (err instanceof IdempotencyConflictError) console.log(deliveryId, "omitida:", err.detail);
    else throw err;
  }
}

<?php
require __DIR__ . '/vendor/autoload.php';

use Compense\Sdk\CompenseClient;
use Compense\Sdk\Exception\IdempotencyConflictException;

$client = new CompenseClient(apiKey: getenv('COMPENSE_API_KEY'), environment: 'sandbox');
const DESDE = '2026-10-01';
const TAM = 100;

/** @return string[] */
function idsPorEstado(CompenseClient $client, string $status): array
{
    $ids = [];
    for ($pagina = 1; ; $pagina++) {
        $page = $client->webhooks->deliveries->list(status: $status, dateFrom: DESDE, page: $pagina, pageSize: TAM);
        foreach ($page as $d) {
            $ids[] = $d['id'];
        }
        if ($page->results === [] || $pagina * TAM >= $page->count) {
            return $ids;
        }
    }
}

$pendientes = [...idsPorEstado($client, 'failed'), ...idsPorEstado($client, 'abandoned')];
echo count($pendientes), " entregas por reintentar\n";

foreach ($pendientes as $deliveryId) {
    try {
        $tx = $client->webhooks->deliveries->replay($deliveryId, idempotencyKey: "replay-{$deliveryId}");
        echo $deliveryId, ' → ', $tx->data['delivery_id'], PHP_EOL;
    } catch (IdempotencyConflictException $e) {   // 409: no reintentable o endpoint inactivo
        echo $deliveryId, ' omitida: ', $e->detail, PHP_EOL;
    }
}

using System.Linq;
using System.Text.Json.Nodes;
using Compense.Sdk;
using Compense.Sdk.Models;

using var client = new CompenseClient(
    Environment.GetEnvironmentVariable("COMPENSE_API_KEY")!, CompenseEnvironment.Sandbox);
const string Desde = "2026-10-01";

async Task<List<string>> IdsPorEstado(string status)
{
    var ids = new List<string>();
    // ListAutoPagingAsync pide las páginas siguientes por ti.
    await foreach (JsonObject d in client.Webhooks.Deliveries.ListAutoPagingAsync(
        status: status, dateFrom: Desde, pageSize: 100))
    {
        ids.Add(d["id"]!.GetValue<string>());
    }
    return ids;
}

var pendientes = (await IdsPorEstado("failed")).Concat(await IdsPorEstado("abandoned")).ToList();
Console.WriteLine($"{pendientes.Count} entregas por reintentar");

foreach (string deliveryId in pendientes)
{
    try
    {
        Transaction tx = await client.Webhooks.Deliveries.ReplayAsync(deliveryId, idempotencyKey: $"replay-{deliveryId}");
        Console.WriteLine($"{deliveryId} → {tx.Data["delivery_id"]}");
    }
    catch (IdempotencyConflictException e) // 409: no reintentable o endpoint inactivo
    {
        Console.WriteLine($"{deliveryId} omitida: {e.Detail}");
    }
}

package main

import (
	"context"
	"errors"
	"fmt"
	"log"
	"os"

	compense "github.com/Appiasoft/compense-saas-sdk-go"
)

const desde = "2026-10-01"

func idsPorEstado(ctx context.Context, client *compense.Client, status string) ([]string, error) {
	var ids []string
	it := compense.NewPageIterator(ctx, func(ctx context.Context, page int) (*compense.Page, error) {
		return client.Webhooks.Deliveries.List(ctx, &compense.DeliveryListParams{
			Status: status, DateFrom: desde, Page: page, PageSize: 100,
		})
	})
	for it.Next() {
		ids = append(ids, fmt.Sprint(it.Item()["id"]))
	}
	return ids, it.Err()
}

func main() {
	ctx := context.Background()
	client, err := compense.NewClient(os.Getenv("COMPENSE_API_KEY"),
		compense.WithEnvironment(compense.Sandbox))
	if err != nil {
		log.Fatal(err)
	}

	var pendientes []string
	for _, status := range []string{"failed", "abandoned"} {
		ids, err := idsPorEstado(ctx, client, status)
		if err != nil {
			log.Fatal(err)
		}
		pendientes = append(pendientes, ids...)
	}
	fmt.Println(len(pendientes), "entregas por reintentar")

	for _, id := range pendientes {
		tx, err := client.Webhooks.Deliveries.Replay(ctx, id, compense.WithIdempotencyKey("replay-"+id))
		var apiErr *compense.APIError
		switch {
		case compense.IsIdempotencyConflict(err) && errors.As(err, &apiErr): // 409
			fmt.Println(id, "omitida:", apiErr.Detail)
		case err != nil:
			log.Fatal(err)
		default:
			fmt.Println(id, "→", tx.Data["delivery_id"])
		}
	}
}

BASE="https://sandbox.dev.compense.co/gw/v1/gateway/webhooks/deliveries"
: > ids.txt
for STATUS in failed abandoned; do
  PAGE=1
  while :; do
    RESP=$(curl -s "$BASE/?status=$STATUS&date_from=2026-10-01&page=$PAGE&page_size=100" \
      -H "X-API-Key: $COMPENSE_API_KEY")
    echo "$RESP" | jq -r '.results[].id' >> ids.txt
    COUNT=$(echo "$RESP" | jq '.count')
    [ $((PAGE * 100)) -ge "$COUNT" ] && break
    PAGE=$((PAGE + 1))
  done
done

while read -r ID; do
  curl -s -o /dev/null -w "$ID → %{http_code}\n" -X POST "$BASE/$ID/replay/" \
    -H "X-API-Key: $COMPENSE_API_KEY" \
    -H "Idempotency-Key: replay-$ID"
done < ids.txt