Przykłady kodu

Poniżej znajdziesz przykłady typowych operacji na API Ogarni.AI. Wszystkie przykłady zakładają, że token jest zapisany w zmiennej środowiskowej OGARNIAI_API_TOKEN.

curl

Uwierzytelnienie i pierwsze zapytanie

# Ustaw token
export OGARNIAI_API_TOKEN="oai_twoj_token"

# Pobierz podsumowanie tygodniowe
curl -X GET "https://api.ogarni.ai/api/weekly-summaries/latest" \
  -H "X-API-Key: $OGARNIAI_API_TOKEN" \
  -H "Accept: application/json"

Lista dokumentów z filtrem dat

curl -X GET "https://api.ogarni.ai/api/PurchaseDocuments/my?from=2025-01-01&to=2025-01-31&sortBy=purchase_time&sortDirection=desc" \
  -H "X-API-Key: $OGARNIAI_API_TOKEN"

Podsumowanie bieżącego miesiąca

curl -X GET "https://api.ogarni.ai/api/summaries/presets?preset=current-month&granularity=Day" \
  -H "X-API-Key: $OGARNIAI_API_TOKEN"

Nieprzeczytane powiadomienia

curl -X GET "https://api.ogarni.ai/api/Notifications?isRead=false" \
  -H "X-API-Key: $OGARNIAI_API_TOKEN"

---

Python

Prosty klient

import os
import requests

class OgarniAiClient:
    def __init__(self):
        self.token = os.environ["OGARNIAI_API_TOKEN"]
        self.base_url = "https://api.ogarni.ai"
        self.headers = {
            "X-API-Key": self.token,
            "Accept": "application/json",
        }

    def get(self, endpoint, params=None):
        response = requests.get(
            f"{self.base_url}{endpoint}",
            headers=self.headers,
            params=params,
        )
        response.raise_for_status()
        return response.json()

    def list_documents(self, from_date=None, to_date=None):
        return self.get("/api/PurchaseDocuments/my", {
            "from": from_date,
            "to": to_date,
        })

    def get_weekly_summary(self):
        return self.get("/api/weekly-summaries/latest")

    def get_categories(self):
        return self.get("/api/Categories")

    def get_current_month_summary(self):
        return self.get("/api/summaries/presets", {
            "preset": "current-month",
            "granularity": "Day",
        })

Użycie klienta

client = OgarniAiClient()

# Podsumowanie bieżącego miesiąca
summary = client.get_current_month_summary()
print(f"Suma: {summary['totalAmount']} PLN")

for cat in summary["categoryTotals"]:
    print(f"  {cat['category']}: {cat['totalAmount']} PLN")

# Ostatnie paragony
docs = client.list_documents()
for doc in docs["items"][:5]:
    print(f"{doc['storeName']}: {doc['totalAmount']} {doc['currency']}")

Obsługa rate limitów

import time

def safe_request(client, endpoint, params=None, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.get(
                f"{client.base_url}{endpoint}",
                headers=client.headers,
                params=params,
            )

            remaining = response.headers.get("X-RateLimit-Remaining")
            if remaining:
                print(f"Pozostalo zapytan: {remaining}")

            if response.status_code == 429:
                retry_after = int(response.headers.get("Retry-After", 60))
                print(f"Limit przekroczony, czekam {retry_after}s...")
                time.sleep(retry_after)
                continue

            response.raise_for_status()
            return response.json()

        except requests.exceptions.RequestException as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)

    raise Exception("Przekroczono maksymalna liczbe prob")

---

JavaScript / Node.js

Klient z fetch

const API_TOKEN = process.env.OGARNIAI_API_TOKEN;
const BASE_URL = "https://api.ogarni.ai";

async function apiGet(endpoint, params = {}) {
  const url = new URL(`${BASE_URL}${endpoint}`);
  Object.entries(params).forEach(([key, value]) => {
    if (value !== undefined) url.searchParams.set(key, String(value));
  });

  const response = await fetch(url, {
    headers: {
      "X-API-Key": API_TOKEN,
      Accept: "application/json",
    },
  });

  if (!response.ok) {
    throw new Error(`Blad API: ${response.status} ${response.statusText}`);
  }

  return response.json();
}

// Lista dokumentow
const docs = await apiGet("/api/PurchaseDocuments/my");
console.log(`Znaleziono ${docs.items.length} dokumentow`);

// Podsumowanie miesiaca
const summary = await apiGet("/api/summaries/presets", {
  preset: "current-month",
});
console.log(`Suma: ${summary.totalAmount} PLN`);

// Kategorie
const categories = await apiGet("/api/Categories");
categories.categories.forEach((cat) => {
  console.log(`${cat.emoji} ${cat.polishName}`);
});

Klient z axios i obsługą rate limitów

import axios from "axios";

const client = axios.create({
  baseURL: "https://api.ogarni.ai",
  headers: {
    "X-API-Key": process.env.OGARNIAI_API_TOKEN,
    Accept: "application/json",
  },
});

// Interceptor logujący stan limitu
client.interceptors.response.use(
  (response) => {
    const remaining = response.headers["x-ratelimit-remaining"];
    if (remaining) {
      console.log(`Pozostalo zapytan: ${remaining}`);
    }
    return response;
  },
  async (error) => {
    if (error.response?.status === 429) {
      const retryAfter = parseInt(
        error.response.headers["retry-after"] || "60",
        10
      );
      console.log(`Limit przekroczony, czekam ${retryAfter}s...`);
      await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
      return client.request(error.config);
    }
    throw error;
  }
);

// Użycie
const { data: summary } = await client.get("/api/weekly-summaries/latest");
console.log(summary.summary);