Bramka SMS - dokumentacja API

#!/usr/bin/env bash
# Wysylka SMS przez bramke + sprawdzenie statusu.
set -euo pipefail

BRAMKA="https://sms.inonet.pl"
KLUCZ="smsb_TWOJ_KLUCZ_API"
NUMER="+48123456789"
TRESC="Przypominamy o wizycie jutro o 10:00."

# --- 1. wyslanie ---------------------------------------------------------
ODPOWIEDZ=$(curl -sS -m 15 -w '\n%{http_code}' \
  -X POST "$BRAMKA/api/sms/send" \
  -H "X-API-Key: $KLUCZ" \
  -H "Content-Type: application/json" \
  -d "{\"recipient\":\"$NUMER\",\"message\":\"$TRESC\",\"priority\":5}")

KOD=$(printf '%s' "$ODPOWIEDZ" | tail -n1)
CIALO=$(printf '%s' "$ODPOWIEDZ" | sed '$d')

if [ "$KOD" != "201" ]; then
  echo "Blad wysylki (HTTP $KOD): $CIALO" >&2
  exit 1
fi

# id bez zewnetrznych narzedzi (jesli masz jq: ID=$(echo "$CIALO" | jq -r .id))
ID=$(printf '%s' "$CIALO" | grep -o '"id":[0-9]*' | head -n1 | cut -d: -f2)
echo "Zakolejkowano, id=$ID"

# --- 2. sprawdzenie statusu (nie czesciej niz co 10 s) --------------------
for _ in 1 2 3 4 5 6; do
  sleep 10
  STATUS=$(curl -sS -m 15 "$BRAMKA/api/sms/status/$ID" -H "X-API-Key: $KLUCZ" \
           | grep -o '"status":"[a-z]*"' | head -n1 | cut -d'"' -f4)
  echo "status: $STATUS"
  case "$STATUS" in
    sent)    echo "OK - wiadomosc nadana"; exit 0 ;;
    failed)  echo "Nie poszlo - mozna powtorzyc"; exit 1 ;;
    unknown) echo "UWAGA: wynik nierozstrzygniety. NIE ponawiaj automatycznie -"
             echo "wiadomosc mogla zostac nadana. Do przejrzenia przez czlowieka."
             exit 2 ;;
  esac
done

echo "Wiadomosc nadal w kolejce - sprawdz pozniej"

#!/usr/bin/env python3
"""Wysylka SMS przez bramke + sprawdzenie statusu.

Wymaga: pip install httpx
(dziala tak samo z 'requests' - zamien httpx.Client na requests.Session)
"""

import os
import sys
import time

import httpx

BRAMKA = "https://sms.inonet.pl"
KLUCZ = os.environ.get("SMS_API_KEY", "smsb_TWOJ_KLUCZ_API")


class BledneZadanie(Exception):
    """Blad, ktorego nie ma sensu ponawiac bez zmiany danych."""


class LimitWyczerpany(Exception):
    """429 - limit dzienny. Atrybut 'za_ile' mowi, ile sekund czekac."""

    def __init__(self, za_ile: int) -> None:
        super().__init__(f"Limit dzienny wyczerpany, ponow za {za_ile} s")
        self.za_ile = za_ile


def wyslij(klient: httpx.Client, numer: str, tresc: str,
           priorytet: int = 5, termin: str | None = None) -> int:
    """Kolejkuje SMS i zwraca jego id."""
    dane = {"recipient": numer, "message": tresc, "priority": priorytet}
    if termin:
        # bez strefy = czas lokalny Europe/Warsaw
        dane["scheduled_at"] = termin

    odp = klient.post("/api/sms/send", json=dane)

    if odp.status_code == 201:
        return int(odp.json()["id"])

    if odp.status_code == 429:
        # Retry-After podaje bramka - nie licz polnocy samodzielnie
        za_ile = int(odp.headers.get("Retry-After", "3600"))
        raise LimitWyczerpany(za_ile)

    if odp.status_code in (400, 401, 403, 422):
        raise BledneZadanie(f"HTTP {odp.status_code}: {odp.text}")

    # 500 / 503 - blad przejsciowy, ponowienie ma sens
    odp.raise_for_status()
    raise RuntimeError(f"Nieoczekiwany kod {odp.status_code}")


def sprawdz_status(klient: httpx.Client, sms_id: int) -> dict:
    """Zwraca pelny stan wiadomosci."""
    odp = klient.get(f"/api/sms/status/{sms_id}")
    odp.raise_for_status()
    return odp.json()


def czekaj_na_wynik(klient: httpx.Client, sms_id: int,
                    prob: int = 6, odstep: int = 10) -> dict:
    """Odpytuje status co 'odstep' sekund - NIE co sekunde."""
    for _ in range(prob):
        time.sleep(odstep)
        stan = sprawdz_status(klient, sms_id)
        if stan["status"] in ("sent", "failed", "unknown"):
            return stan
    return sprawdz_status(klient, sms_id)


def main() -> int:
    with httpx.Client(
        base_url=BRAMKA,
        headers={"X-API-Key": KLUCZ},
        timeout=15.0,
    ) as klient:
        try:
            sms_id = wyslij(klient, "+48123456789",
                            "Przypominamy o wizycie jutro o 10:00.")
        except LimitWyczerpany as exc:
            print(f"Limit dzienny wyczerpany - ponow za {exc.za_ile} s", file=sys.stderr)
            return 1
        except BledneZadanie as exc:
            print(f"Zadanie odrzucone: {exc}", file=sys.stderr)
            return 1

        print(f"Zakolejkowano, id={sms_id}")
        stan = czekaj_na_wynik(klient, sms_id)

        if stan["status"] == "sent":
            print(f"OK - nadano {stan['sent_at']}")
            return 0

        if stan["status"] == "failed":
            # jedyny status, przy ktorym wolno powtorzyc automatycznie
            print(f"Nie poszlo: {stan['last_error']} - mozna powtorzyc", file=sys.stderr)
            return 1

        if stan["status"] == "unknown":
            # NIE PONAWIAJ. SMS mogl zostac nadany.
            print("UWAGA: wynik nierozstrzygniety - wiadomosc mogla zostac nadana.",
                  file=sys.stderr)
            print("Nie ponawiaj automatycznie. Oznacz do przejrzenia przez czlowieka.",
                  file=sys.stderr)
            print(f"Szczegoly: {stan['last_error']}", file=sys.stderr)
            return 2

        print(f"Nadal w kolejce (status={stan['status']}) - sprawdz pozniej")
        return 0


if __name__ == "__main__":
    raise SystemExit(main())

<?php
/**
 * Wysylka SMS przez bramke + sprawdzenie statusu.
 * Wymaga rozszerzenia ext-curl (standardowe w PHP).
 */

declare(strict_types=1);

const BRAMKA = 'https://sms.inonet.pl';
const KLUCZ  = 'smsb_TWOJ_KLUCZ_API';

/**
 * Jedno zapytanie do API. Zwraca ['kod' => int, 'dane' => array, 'naglowki' => array].
 */
function zapytaj(string $metoda, string $sciezka, ?array $cialo = null): array
{
    $ch = curl_init(BRAMKA . $sciezka);

    $naglowki = [];
    curl_setopt_array($ch, [
        CURLOPT_CUSTOMREQUEST  => $metoda,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 15,
        CURLOPT_HTTPHEADER     => [
            'X-API-Key: ' . KLUCZ,
            'Content-Type: application/json',
            'Accept: application/json',
        ],
        // zbieramy naglowki odpowiedzi - potrzebny bedzie Retry-After przy 429
        CURLOPT_HEADERFUNCTION => function ($ch, string $linia) use (&$naglowki): int {
            $czesci = explode(':', $linia, 2);
            if (count($czesci) === 2) {
                $naglowki[strtolower(trim($czesci[0]))] = trim($czesci[1]);
            }
            return strlen($linia);
        },
    ]);

    if ($cialo !== null) {
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($cialo, JSON_UNESCAPED_UNICODE));
    }

    $odp = curl_exec($ch);
    if ($odp === false) {
        $blad = curl_error($ch);
        curl_close($ch);
        throw new RuntimeException('Blad polaczenia z bramka: ' . $blad);
    }

    $kod = (int) curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
    curl_close($ch);

    return [
        'kod'      => $kod,
        'dane'     => json_decode((string) $odp, true) ?? [],
        'naglowki' => $naglowki,
    ];
}

/** Kolejkuje SMS, zwraca jego id. */
function wyslij(string $numer, string $tresc, int $priorytet = 5): int
{
    $r = zapytaj('POST', '/api/sms/send', [
        'recipient' => $numer,
        'message'   => $tresc,
        'priority'  => $priorytet,
    ]);

    if ($r['kod'] === 201) {
        return (int) $r['dane']['id'];
    }

    if ($r['kod'] === 429) {
        // liczbe sekund do polnocy podaje bramka
        $zaIle = (int) ($r['naglowki']['retry-after'] ?? 3600);
        throw new RuntimeException("Limit dzienny wyczerpany - ponow za {$zaIle} s");
    }

    throw new RuntimeException(
        "Wysylka odrzucona (HTTP {$r['kod']}): " . json_encode($r['dane'], JSON_UNESCAPED_UNICODE)
    );
}

/** Zwraca pelny stan wiadomosci. */
function status(int $smsId): array
{
    $r = zapytaj('GET', '/api/sms/status/' . $smsId);
    if ($r['kod'] !== 200) {
        throw new RuntimeException("Nie mozna odczytac statusu (HTTP {$r['kod']})");
    }
    return $r['dane'];
}

// ---------------------------------------------------------------- uzycie
try {
    $id = wyslij('+48123456789', 'Przypominamy o wizycie jutro o 10:00.');
    echo "Zakolejkowano, id={$id}\n";

    // odpytujemy co 10 s, a nie co sekunde
    $stan = ['status' => 'pending', 'sent_at' => null, 'last_error' => null];
    for ($i = 0; $i < 6; $i++) {
        sleep(10);
        $stan = status($id);
        if (in_array($stan['status'], ['sent', 'failed', 'unknown'], true)) {
            break;
        }
    }

    switch ($stan['status']) {
        case 'sent':
            echo "OK - nadano {$stan['sent_at']}\n";
            break;

        case 'failed':
            // jedyny status, przy ktorym wolno powtorzyc automatycznie
            echo "Nie poszlo: {$stan['last_error']} - mozna powtorzyc\n";
            break;

        case 'unknown':
            // NIE PONAWIAJ. SMS mogl zostac nadany.
            echo "UWAGA: wynik nierozstrzygniety - wiadomosc mogla zostac nadana.\n";
            echo "Nie ponawiaj automatycznie. Oznacz do przejrzenia przez czlowieka.\n";
            echo "Szczegoly: {$stan['last_error']}\n";
            break;

        default:
            echo "Nadal w kolejce (status={$stan['status']}) - sprawdz pozniej\n";
    }
} catch (Throwable $e) {
    fwrite(STDERR, 'Blad: ' . $e->getMessage() . "\n");
    exit(1);
}

// Wysylka SMS przez bramke + sprawdzenie statusu.
// Node 18+ ma wbudowane fetch - nie potrzeba zadnych zaleznosci.
//
// UWAGA: ten kod uruchamiaj WYLACZNIE po stronie serwera.
// Klucz API w kodzie ladowanym przez przegladarke jest jawny dla kazdego.

const BRAMKA = 'https://sms.inonet.pl';
const KLUCZ = process.env.SMS_API_KEY || 'smsb_TWOJ_KLUCZ_API';

class LimitWyczerpany extends Error {
  constructor(zaIle) {
    super(`Limit dzienny wyczerpany - ponow za ${zaIle} s`);
    this.zaIle = zaIle;
  }
}

const spij = (ms) => new Promise((r) => setTimeout(r, ms));

async function zapytaj(metoda, sciezka, cialo) {
  const odp = await fetch(BRAMKA + sciezka, {
    method: metoda,
    headers: {
      'X-API-Key': KLUCZ,
      'Content-Type': 'application/json',
      Accept: 'application/json',
    },
    body: cialo ? JSON.stringify(cialo) : undefined,
    signal: AbortSignal.timeout(15000),
  });

  const dane = await odp.json().catch(() => ({}));
  return { kod: odp.status, dane, naglowki: odp.headers };
}

/** Kolejkuje SMS, zwraca jego id. */
async function wyslij(numer, tresc, priorytet = 5, termin = null) {
  const cialo = { recipient: numer, message: tresc, priority: priorytet };
  // termin bez strefy jest rozumiany jako czas lokalny Europe/Warsaw
  if (termin) cialo.scheduled_at = termin;

  const r = await zapytaj('POST', '/api/sms/send', cialo);

  if (r.kod === 201) return r.dane.id;

  if (r.kod === 429) {
    // liczbe sekund do polnocy podaje bramka - nie licz jej samodzielnie
    throw new LimitWyczerpany(Number(r.naglowki.get('retry-after') || 3600));
  }

  throw new Error(`Wysylka odrzucona (HTTP ${r.kod}): ${JSON.stringify(r.dane)}`);
}

/** Zwraca pelny stan wiadomosci. */
async function status(smsId) {
  const r = await zapytaj('GET', `/api/sms/status/${smsId}`);
  if (r.kod !== 200) throw new Error(`Nie mozna odczytac statusu (HTTP ${r.kod})`);
  return r.dane;
}

/** Odpytuje status co 10 s - NIE co sekunde. */
async function czekajNaWynik(smsId, prob = 6, odstepMs = 10000) {
  for (let i = 0; i < prob; i++) {
    await spij(odstepMs);
    const stan = await status(smsId);
    if (['sent', 'failed', 'unknown'].includes(stan.status)) return stan;
  }
  return status(smsId);
}

async function main() {
  const id = await wyslij('+48123456789', 'Przypominamy o wizycie jutro o 10:00.');
  console.log(`Zakolejkowano, id=${id}`);

  const stan = await czekajNaWynik(id);

  switch (stan.status) {
    case 'sent':
      console.log(`OK - nadano ${stan.sent_at}`);
      break;

    case 'failed':
      // jedyny status, przy ktorym wolno powtorzyc automatycznie
      console.error(`Nie poszlo: ${stan.last_error} - mozna powtorzyc`);
      process.exitCode = 1;
      break;

    case 'unknown':
      // NIE PONAWIAJ. SMS mogl zostac nadany.
      console.error('UWAGA: wynik nierozstrzygniety - wiadomosc mogla zostac nadana.');
      console.error('Nie ponawiaj automatycznie. Oznacz do przejrzenia przez czlowieka.');
      console.error(`Szczegoly: ${stan.last_error}`);
      process.exitCode = 2;
      break;

    default:
      console.log(`Nadal w kolejce (status=${stan.status}) - sprawdz pozniej`);
  }
}

main().catch((e) => {
  if (e instanceof LimitWyczerpany) {
    console.error(e.message);
  } else {
    console.error(`Blad: ${e.message}`);
  }
  process.exitCode = 1;
});