Kimlik Doğrulama

class PayvenClient {
  constructor({ slug, clientId, clientSecret, identityBaseUrl }) {
    this.slug = slug;
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    this.identityBaseUrl = identityBaseUrl;
    this.accessToken = null;
    this.refreshToken = null;
    this.expiresAt = 0;
  }

  async getToken() {
    if (this.accessToken && Date.now() < this.expiresAt - 60_000) {
      return this.accessToken;
    }

    if (this.refreshToken && (await this.tryRefresh())) {
      return this.accessToken;
    }

    const res = await fetch(`${this.identityBaseUrl}/api/v1/auth/${this.slug}/token`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        client_id: this.clientId,
        client_secret: this.clientSecret,
      }),
    });
    if (!res.ok) throw new Error(`Token alınamadı: ${res.status}`);
    const data = await res.json();
    this.accessToken = data.access_token;
    this.refreshToken = data.refresh_token;
    this.expiresAt = Date.now() + data.expires_in * 1000;
    return this.accessToken;
  }

  async tryRefresh() {
    const res = await fetch(`${this.identityBaseUrl}/api/v1/auth/${this.slug}/refresh`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ refresh_token: this.refreshToken }),
    });
    if (!res.ok) {
      this.refreshToken = null;
      return false;
    }
    const data = await res.json();
    this.accessToken = data.access_token;
    this.refreshToken = data.refresh_token;
    this.expiresAt = Date.now() + data.expires_in * 1000;
    return true;
  }

  async call(productBaseUrl, path, init = {}) {
    const token = await this.getToken();
    return fetch(productBaseUrl + path, {
      ...init,
      headers: {
        ...(init.headers ?? {}),
        Authorization: `Bearer ${token}`,
      },
    });
  }
}

import time
import httpx


class PayvenClient:
    def __init__(self, slug: str, client_id: str, client_secret: str, identity_base_url: str):
        self.slug = slug
        self.client_id = client_id
        self.client_secret = client_secret
        self.identity_base_url = identity_base_url
        self.access_token: str | None = None
        self.refresh_token: str | None = None
        self.expires_at: float = 0
        self._http = httpx.Client()

    def get_token(self) -> str:
        if self.access_token and time.time() < self.expires_at - 60:
            return self.access_token
        if self.refresh_token and self._refresh():
            return self.access_token  # type: ignore[return-value]

        r = self._http.post(
            f"{self.identity_base_url}/api/v1/auth/{self.slug}/token",
            json={"client_id": self.client_id, "client_secret": self.client_secret},
        )
        r.raise_for_status()
        data = r.json()
        self.access_token = data["access_token"]
        self.refresh_token = data["refresh_token"]
        self.expires_at = time.time() + data["expires_in"]
        return self.access_token

    def _refresh(self) -> bool:
        r = self._http.post(
            f"{self.identity_base_url}/api/v1/auth/{self.slug}/refresh",
            json={"refresh_token": self.refresh_token},
        )
        if r.status_code != 200:
            self.refresh_token = None
            return False
        data = r.json()
        self.access_token = data["access_token"]
        self.refresh_token = data["refresh_token"]
        self.expires_at = time.time() + data["expires_in"]
        return True

public class PayvenClient
{
    private readonly HttpClient _http = new();
    private readonly string _slug, _clientId, _clientSecret, _identityBase;
    private string? _accessToken, _refreshToken;
    private DateTimeOffset _expiresAt;
    private readonly SemaphoreSlim _lock = new(1, 1);

    public PayvenClient(string slug, string clientId, string clientSecret, string identityBaseUrl)
        => (_slug, _clientId, _clientSecret, _identityBase) = (slug, clientId, clientSecret, identityBaseUrl);

    public async Task<string> GetTokenAsync(CancellationToken ct = default)
    {
        await _lock.WaitAsync(ct);
        try
        {
            if (_accessToken is not null && DateTimeOffset.UtcNow < _expiresAt.AddSeconds(-60))
                return _accessToken;

            if (_refreshToken is not null && await TryRefreshAsync(ct))
                return _accessToken!;

            var resp = await _http.PostAsJsonAsync(
                $"{_identityBase}/api/v1/auth/{_slug}/token",
                new { client_id = _clientId, client_secret = _clientSecret }, ct);
            resp.EnsureSuccessStatusCode();
            var data = await resp.Content.ReadFromJsonAsync<TokenResponse>(cancellationToken: ct);
            _accessToken = data!.access_token;
            _refreshToken = data.refresh_token;
            _expiresAt = DateTimeOffset.UtcNow.AddSeconds(data.expires_in);
            return _accessToken;
        }
        finally { _lock.Release(); }
    }

    private async Task<bool> TryRefreshAsync(CancellationToken ct)
    {
        var resp = await _http.PostAsJsonAsync(
            $"{_identityBase}/api/v1/auth/{_slug}/refresh",
            new { refresh_token = _refreshToken }, ct);
        if (!resp.IsSuccessStatusCode) { _refreshToken = null; return false; }
        var data = await resp.Content.ReadFromJsonAsync<TokenResponse>(cancellationToken: ct);
        _accessToken = data!.access_token;
        _refreshToken = data.refresh_token;
        _expiresAt = DateTimeOffset.UtcNow.AddSeconds(data.expires_in);
        return true;
    }

    private record TokenResponse(string access_token, string refresh_token, int expires_in);
}

package payven

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "sync"
    "time"
)

type Client struct {
    Slug, ClientID, ClientSecret, IdentityBase string
    accessToken, refreshToken                  string
    expiresAt                                  time.Time
    mu                                         sync.Mutex
}

type tokenResponse struct {
    AccessToken  string `json:"access_token"`
    RefreshToken string `json:"refresh_token"`
    ExpiresIn    int    `json:"expires_in"`
}

func (c *Client) GetToken() (string, error) {
    c.mu.Lock()
    defer c.mu.Unlock()

    if c.accessToken != "" && time.Now().Before(c.expiresAt.Add(-60*time.Second)) {
        return c.accessToken, nil
    }
    if c.refreshToken != "" {
        if err := c.refresh(); err == nil {
            return c.accessToken, nil
        }
    }
    body, _ := json.Marshal(map[string]string{
        "client_id":     c.ClientID,
        "client_secret": c.ClientSecret,
    })
    return c.fetchToken(fmt.Sprintf("%s/api/v1/auth/%s/token", c.IdentityBase, c.Slug), body)
}

<?php
class PayvenClient {
    private string $slug, $clientId, $clientSecret, $identityBase;
    private ?string $accessToken = null, $refreshToken = null;
    private int $expiresAt = 0;

    public function __construct(string $slug, string $clientId, string $clientSecret, string $identityBase) {
        $this->slug = $slug; $this->clientId = $clientId;
        $this->clientSecret = $clientSecret; $this->identityBase = $identityBase;
    }

    public function getToken(): string {
        if ($this->accessToken && time() < $this->expiresAt - 60) return $this->accessToken;
        if ($this->refreshToken && $this->refresh()) return $this->accessToken;

        $resp = $this->post("/api/v1/auth/{$this->slug}/token", [
            "client_id"     => $this->clientId,
            "client_secret" => $this->clientSecret,
        ]);
        $this->accessToken = $resp["access_token"];
        $this->refreshToken = $resp["refresh_token"];
        $this->expiresAt = time() + $resp["expires_in"];
        return $this->accessToken;
    }

    private function post(string $path, array $body): array {
        $ch = curl_init($this->identityBase . $path);
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_POST => true,
            CURLOPT_HTTPHEADER => ["Content-Type: application/json"],
            CURLOPT_POSTFIELDS => json_encode($body),
        ]);
        $body = curl_exec($ch);
        $code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);
        if ($code !== 200) throw new Exception("Token request failed: $code");
        return json_decode($body, true);
    }
}