SAPI Dokumentácia

// Node.js / browser (fetch API)
const BASE = "https://epostak.sk/api";

class EpostakClient {
  #token = null;
  #refreshToken = null;

  async authenticate(clientId, clientSecret) {
    const resp = await fetch(`${BASE}/auth/token`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        client_id: clientId,
        client_secret: clientSecret,
        grant_type: "client_credentials"
      })
    });
    const data = await resp.json();
    this.#token = data.access_token;
    this.#refreshToken = data.refresh_token;
    return data;
  }

  #headers(peppolId) {
    return {
      "Authorization": `Bearer ${this.#token}`,
      "X-Peppol-Participant-Id": peppolId,
      "Content-Type": "application/json"
    };
  }

  async sendInvoice(xmlPayload, metadata, peppolId) {
    const resp = await fetch(`${BASE}/document/send`, {
      method: "POST",
      headers: {
        ...this.#headers(peppolId),
        "Idempotency-Key": crypto.randomUUID()
      },
      body: JSON.stringify({
        metadata, payload: xmlPayload, payloadFormat: "XML"
      })
    });
    return resp.json();
  }

  async getReceived(peppolId, status = "RECEIVED") {
    const resp = await fetch(
      `${BASE}/document/receive?status=${status}`,
      { headers: this.#headers(peppolId) }
    );
    return resp.json();
  }

  async acknowledge(docId, peppolId) {
    const resp = await fetch(
      `${BASE}/document/receive/${docId}/acknowledge`,
      { method: "POST", headers: this.#headers(peppolId) }
    );
    return resp.json();
  }

  async renew() {
    const resp = await fetch(`${BASE}/auth/renew`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ refresh_token: this.#refreshToken })
    });
    const data = await resp.json();
    this.#token = data.access_token;
    this.#refreshToken = data.refresh_token;
    return data;
  }
}

// Pouzitie:
const client = new EpostakClient();
await client.authenticate("test_98b486a08b3e3d7f", "sk_test_e888be545de8bf6e132e5934b790761cdabc65b67595b3a6");

const docs = await client.getReceived("0245:0000000001");
for (const doc of docs.documents) {
  await client.acknowledge(doc.documentId, "0245:0000000001");
}

// PHP 8+ s cURL
class EpostakClient {
    private $base = "https://epostak.sk/api";
    private ?string $token = null;
    private ?string $refreshToken = null;

    public function authenticate(string $clientId, string $secret): array {
        $data = $this->post("/auth/token", [
            "client_id" => $clientId,
            "client_secret" => $secret,
            "grant_type" => "client_credentials"
        ]);
        $this->token = $data["access_token"];
        $this->refreshToken = $data["refresh_token"];
        return $data;
    }

    public function sendInvoice(string $xml, array $meta, string $peppolId): array {
        return $this->post("/document/send", [
            "metadata" => $meta,
            "payload" => $xml,
            "payloadFormat" => "XML"
        ], $peppolId, bin2hex(random_bytes(16)));
    }

    public function getReceived(string $peppolId, string $status = "RECEIVED"): array {
        return $this->get("/document/receive?status={$status}", $peppolId);
    }

    public function acknowledge(string $docId, string $peppolId): array {
        return $this->post("/document/receive/{$docId}/acknowledge", [], $peppolId);
    }

    private function post(string $path, array $body, ?string $peppolId = null, ?string $idem = null): array {
        $headers = ["Content-Type: application/json"];
        if ($this->token) $headers[] = "Authorization: Bearer {$this->token}";
        if ($peppolId) $headers[] = "X-Peppol-Participant-Id: {$peppolId}";
        if ($idem) $headers[] = "Idempotency-Key: {$idem}";

        $ch = curl_init($this->base . $path);
        curl_setopt_array($ch, [
            CURLOPT_POST => true,
            CURLOPT_HTTPHEADER => $headers,
            CURLOPT_POSTFIELDS => json_encode($body),
            CURLOPT_RETURNTRANSFER => true
        ]);
        $resp = curl_exec($ch);
        curl_close($ch);
        return json_decode($resp, true);
    }

    private function get(string $path, string $peppolId): array {
        $opts = ["http" => ["header" =>
            "Authorization: Bearer {$this->token}\r\nX-Peppol-Participant-Id: {$peppolId}"]];
        return json_decode(file_get_contents(
            $this->base . $path, false, stream_context_create($opts)), true);
    }
}

// Pouzitie:
$client = new EpostakClient();
$client->authenticate("test_98b486a08b3e3d7f", "sk_test_e888be545de8bf6e132e5934b790761cdabc65b67595b3a6");
$docs = $client->getReceived("0245:0000000001");

// C# / .NET 8+
using System.Net.Http.Json;

public class EpostakClient : IDisposable {
    private readonly HttpClient _http = new();
    private string? _token, _refreshToken;
    const string Base = "https://epostak.sk/api";

    public async Task<TokenResponse> AuthenticateAsync(string clientId, string secret) {
        var resp = await _http.PostAsJsonAsync($"{Base}/auth/token", new {
            client_id = clientId,
            client_secret = secret,
            grant_type = "client_credentials"
        });
        resp.EnsureSuccessStatusCode();
        var data = await resp.Content.ReadFromJsonAsync<TokenResponse>();
        _token = data.AccessToken;
        _refreshToken = data.RefreshToken;
        return data;
    }

    public async Task<JsonElement> SendInvoiceAsync(
        string xml, object metadata, string peppolId) {
        var req = new HttpRequestMessage(HttpMethod.Post, $"{Base}/document/send");
        req.Headers.Add("Authorization", $"Bearer {_token}");
        req.Headers.Add("Idempotency-Key", Guid.NewGuid().ToString());
        req.Headers.Add("X-Peppol-Participant-Id", peppolId);
        req.Content = JsonContent.Create(new {
            metadata, payload = xml, payloadFormat = "XML"
        });
        var resp = await _http.SendAsync(req);
        return await resp.Content.ReadFromJsonAsync<JsonElement>();
    }

    public void Dispose() => _http.Dispose();
}

public record TokenResponse(
    [property: JsonPropertyName("access_token")] string AccessToken,
    [property: JsonPropertyName("refresh_token")] string RefreshToken,
    [property: JsonPropertyName("expires_in")] int ExpiresIn
);

// Java 17+ (java.net.http)
import java.net.http.*;
import com.google.gson.*;

public class EpostakClient {
    private static final String BASE = "https://epostak.sk/api";
    private final HttpClient http = HttpClient.newHttpClient();
    private String token, refreshToken;

    public JsonObject authenticate(String clientId, String secret) throws Exception {
        String body = new Gson().toJson(Map.of(
            "client_id", clientId,
            "client_secret", secret,
            "grant_type", "client_credentials"));

        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create(BASE + "/auth/token"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();

        HttpResponse<String> resp = http.send(req,
            HttpResponse.BodyHandlers.ofString());

        JsonObject json = JsonParser.parseString(resp.body())
            .getAsJsonObject();
        this.token = json.get("access_token").getAsString();
        this.refreshToken = json.get("refresh_token").getAsString();
        return json;
    }

    public JsonObject getReceived(String peppolId) throws Exception {
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create(BASE + "/document/receive?status=RECEIVED"))
            .header("Authorization", "Bearer " + token)
            .header("X-Peppol-Participant-Id", peppolId)
            .GET().build();

        HttpResponse<String> resp = http.send(req,
            HttpResponse.BodyHandlers.ofString());
        return JsonParser.parseString(resp.body()).getAsJsonObject();
    }
}

# Ruby (net/http)
require "net/http"
require "json"
require "securerandom"

class EpostakClient
  BASE = URI("https://epostak.sk/api")

  def authenticate(client_id, client_secret)
    data = post("/auth/token", {
      client_id: client_id,
      client_secret: client_secret,
      grant_type: "client_credentials"
    })
    @token = data["access_token"]
    @refresh = data["refresh_token"]
    data
  end

  def send_invoice(xml, metadata, peppol_id)
    post("/document/send",
      { metadata: metadata, payload: xml, payloadFormat: "XML" },
      peppol_id, SecureRandom.uuid)
  end

  def get_received(peppol_id, status: "RECEIVED")
    get("/document/receive?status=#{status}", peppol_id)
  end

  def acknowledge(doc_id, peppol_id)
    post("/document/receive/#{doc_id}/acknowledge", {}, peppol_id)
  end

  private

  def post(path, body, peppol_id = nil, idem = nil)
    uri = URI(BASE.to_s + path)
    req = Net::HTTP::Post.new(uri)
    req["Content-Type"] = "application/json"
    req["Authorization"] = "Bearer #{@token}" if @token
    req["X-Peppol-Participant-Id"] = peppol_id if peppol_id
    req["Idempotency-Key"] = idem if idem
    req.body = body.to_json
    resp = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
    JSON.parse(resp.body)
  end
end