Autenticação

import requests
from typing import Optional

class CaktoAPIClient:
  def __init__(self, client_id: str, client_secret: str):
      self.client_id = client_id
      self.client_secret = client_secret
      self.base_url = "https://api.cakto.com.br"
      self.access_token: Optional[str] = None
      self.refresh_token: Optional[str] = None
  
  def authenticate(self):
      """Obtém um novo access token"""
      url = f"{self.base_url}/public_api/token/"
      data = {
          "client_id": self.client_id,
          "client_secret": self.client_secret,
      }
      
      response = requests.post(url, data=data)
      response.raise_for_status()
      
      token_data = response.json()
      self.access_token = token_data["access_token"]
      self.refresh_token = token_data.get("refresh_token")
      
      return token_data
  
  def get_headers(self) -> dict:
      """Retorna headers com autenticação"""
      if not self.access_token:
          self.authenticate()
      
      return {
          "Authorization": f"Bearer {self.access_token}",
          "Content-Type": "application/json"
      }
  
  def get(self, endpoint: str, **kwargs):
      """Faz uma requisição GET"""
      url = f"{self.base_url}{endpoint}"
      response = requests.get(url, headers=self.get_headers(), **kwargs)
      response.raise_for_status()
      return response.json()
  
  def post(self, endpoint: str, data: dict, **kwargs):
      """Faz uma requisição POST"""
      url = f"{self.base_url}{endpoint}"
      response = requests.post(
          url, 
          headers=self.get_headers(), 
          json=data, 
          **kwargs
      )
      response.raise_for_status()
      return response.json()

# Uso
client = CaktoAPIClient(
    client_id="seu_client_id",
    client_secret="seu_client_secret"
)

# Listar produtos
products = client.get("/api/products/")
print(f"Total de produtos: {products['count']}")

  class CaktoAPIClient {
    private baseUrl = 'https://api.cakto.com.br';
    private accessToken?: string;
    private refreshToken?: string;

    constructor(
      private clientId: string,
      private clientSecret: string
    ) {}

    async authenticate(): Promise<void> {
      const response = await fetch(`${this.baseUrl}/public_api/token/`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
        },
        body: new URLSearchParams({
          client_id: this.clientId,
          client_secret: this.clientSecret,
        }),
      });

      if (!response.ok) {
        throw new Error(`Authentication failed: ${response.statusText}`);
      }

      const tokenData = await response.json();
      this.accessToken = tokenData.access_token;
      this.refreshToken = tokenData.refresh_token;
    }

    private async getHeaders(): Promise<HeadersInit> {
      if (!this.accessToken) {
        await this.authenticate();
      }

      return {
        'Authorization': `Bearer ${this.accessToken}`,
        'Content-Type': 'application/json',
      };
    }

    async get<T>(endpoint: string): Promise<T> {
      const response = await fetch(`${this.baseUrl}${endpoint}`, {
        method: 'GET',
        headers: await this.getHeaders(),
      });

      if (!response.ok) {
        throw new Error(`GET request failed: ${response.statusText}`);
      }

      return response.json();
    }

    async post<T>(endpoint: string, data: any): Promise<T> {
      const response = await fetch(`${this.baseUrl}${endpoint}`, {
        method: 'POST',
        headers: await this.getHeaders(),
        body: JSON.stringify(data),
      });

      if (!response.ok) {
        throw new Error(`POST request failed: ${response.statusText}`);
      }

      return response.json();
    }
  }

  // Uso
  const client = new CaktoAPIClient(
    'seu_client_id',
    'seu_client_secret'
  );

  // Listar produtos
  const products = await client.get('/api/products/');
  console.log(`Total de produtos: ${products.count}`);