Vyzkoušet zdarma
ÚvodPlatformaCeníkOtázkyNápovědaKontakt Kivea FlexiKivea PohodaKivea účetnictvíKivea fakturace Vyzkoušet zdarma

Co je to?

Poznámka pro administrátory: Tento systém zajišťuje, že k citlivým datům vašeho e-shopu mají přístup pouze oprávněné osoby a aplikace. Je to jako digitální „bezpečnostní brána“ pro vaše integrace.

Pro koho je to určeno? Administrátoři musí rozumět různým možnostem zabezpečení (jako jsou klíče API nebo autorizace aplikací), aby mohli spravovat, kdo má přístup k systému. Konkrétní technické nastavení a příklady kódu by však měly být předány vašemu vývojovému týmu nebo integračnímu partnerovi.

Klíčové výhody pro e-shop:

  • Pevné zabezpečení: Udržujte svá obchodní data v bezpečí přesnou kontrolou, které externí nástroje mají přístup.
  • Snadná integrace: Rychle vytvářejte „klíče“ pro interní nástroje nebo bezpečně připojujte profesionální aplikace třetích stran.
  • Správa přístupu: Snadno zrušte přístup, pokud nástroj již není potřeba nebo pokud máte podezření na bezpečnostní riziko.
  • Připraveno na automatizaci: Bezpečně propojte svůj e-shop s jinými systémy pro automatizaci objednávek, inventáře a dalších.

Autorizace

Zabezpečený přístup k API pomocí klíčů API, OAuth 2.0 nebo autorizace pluginů

Přehled

Systém podporuje tři autorizační metody pro ověřování požadavků API a bezpečný přístup k prostředkům. Vyberte metodu, která nejlépe vyhovuje vašim integračním požadavkům a bezpečnostním potřebám.

Metody autorizace

Klíč API

Nejjednodušší metoda pro interní integrace a skripty. Statické, dlouhodobé přihlašovací údaje.

Doporučeno pro: Interní nástroje

OAuth 2.0

Průmyslový standardní protokol pro aplikace třetích stran se souhlasem uživatele a správou tokenů.

Doporučeno pro: Externí aplikace

Autorizace pluginu

Automatické přihlašovací údaje poskytované pluginům. Není vyžadována žádná ruční konfigurace.

Doporučeno pro: Pluginy

Autorizace pomocí klíče API

Nejjednodušší autorizační metoda využívající statický klíč API pro ověřování.

Jak to funguje

Klíče API jsou dlouhodobé, statické přihlašovací údaje, které identifikují vaši aplikaci. Jsou uloženy přímo v databázi (šifrované) a jsou ideální pro integrace server-to-server, interní nástroje a skripty, kde kontrolujete prostředí.

**Bezpečnostní poznámka:** Klíče API by měly být uchovávány v tajnosti a nikdy by neměly být vystaveny v kódu na straně klienta nebo ve veřejných repozitářích. Poskytují plný přístup k vašemu účtu.

Vytvoření klíče API

  1. Přejděte na stránku Klíče API
  2. Klikněte na „Vytvořit nový klíč API“
  3. Nastavte popisný název a volitelné datum vypršení platnosti
  4. Okamžitě zkopírujte vygenerovaný klíč (již se znovu nezobrazí)
  5. Klíč bezpečně uložte do konfigurace vaší aplikace

Příklady použití

TypeScript – Použití Query API

const API_KEY = 'your_api_key_here';
const API_URL = 'https://your-domain.com';

async function fetchProducts() {
  try {
    const response = await fetch(
      `${API_URL}/api/query`,
      {
        method: 'POST',
        headers: {
          'X-API-Key': API_KEY,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          query: `products { 
            id, 
            name, 
            price, 
            stock 
          }`
        })
      }
    );
    
    if (!response.ok) {
      throw new Error(`API Error: ${response.status}`);
    }
    
    const data = await response.json();
    return data.products;
  } catch (error) {
    console.error('API Error:', error);
    throw error;
  }
}

// Usage
fetchProducts().then(products => {
  console.log(`Found ${products.length} products`);
  products.forEach(p => {
    console.log(`${p.name}: ${p.price}`);
  });
});

TypeScript – Použití OData API

const API_KEY = 'your_api_key_here';
const API_URL = 'https://your-domain.com';

async function fetchProductsOData() {
  try {
    const params = new URLSearchParams({
      '$select': 'id,name,price,stock',
      '$filter': 'stock gt 0',
      '$top': '100',
      '$orderby': 'name asc'
    });
    
    const response = await fetch(
      `${API_URL}/odata/products?${params}`,
      {
        headers: {
          'X-API-Key': API_KEY
        }
      }
    );
    
    if (!response.ok) {
      throw new Error(`OData Error: ${response.status}`);
    }
    
    const data = await response.json();
    return data.value;
  } catch (error) {
    console.error('OData Error:', error);
    throw error;
  }
}

// Usage
fetchProductsOData().then(products => {
  console.log('In-stock products:', products);
});

TypeScript – Použití Import API

import fs from 'fs';

const API_KEY = 'your_api_key_here';
const API_URL = 'https://your-domain.com';

async function importProducts(filePath: string) {
  const formData = new FormData();
  const fileContent = fs.readFileSync(filePath);
  const blob = new Blob([fileContent]);
  
  formData.append('file', blob, 'products.csv');
  formData.append('entity', 'products');
  formData.append('mapperId', 'your-mapper-id');

  try {
    const response = await fetch(
      `${API_URL}/api/import`,
      {
        method: 'POST',
        headers: {
          'X-API-Key': API_KEY
        },
        body: formData
      }
    );
    
    if (!response.ok) {
      throw new Error(`Import Error: ${response.status}`);
    }
    
    return await response.json();
  } catch (error) {
    console.error('Import Error:', error);
    throw error;
  }
}

// Usage
importProducts('./products.csv').then(result => {
  console.log(`Import completed: ${result.imported} imported`);
});

PHP – Použití Query API

<?php

$apiKey = 'your_api_key_here';
$apiUrl = 'https://your-domain.com';

function fetchProducts($apiKey, $apiUrl) {
    $query = [
        'query' => 'products { id, name, price, stock }'
    ];
    
    $ch = curl_init($apiUrl . '/api/query');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($query));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'X-API-Key: ' . $apiKey,
        'Content-Type: application/json'
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode !== 200) {
        throw new Exception('API Error: ' . $httpCode);
    }
    
    $data = json_decode($response, true);
    return $data['products'];
}

// Usage
try {
    $products = fetchProducts($apiKey, $apiUrl);
    echo "Found " . count($products) . " products\n";
    
    foreach ($products as $product) {
        echo "{$product['name']}: {$product['price']}\n";
    }
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

PHP – Použití OData API

<?php

$apiKey = 'your_api_key_here';
$apiUrl = 'https://your-domain.com';

function fetchProductsOData($apiKey, $apiUrl) {
    $params = [
        '$select' => 'id,name,price,stock',
        '$filter' => 'stock gt 0',
        '$top' => 100,
        '$orderby' => 'name asc'
    ];
    
    $url = $apiUrl . '/odata/products?' . http_build_query($params);
    
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'X-API-Key: ' . $apiKey
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode !== 200) {
        throw new Exception('OData Error: ' . $httpCode);
    }
    
    $data = json_decode($response, true);
    return $data['value'];
}

// Usage
try {
    $products = fetchProductsOData($apiKey, $apiUrl);
    echo "In-stock products: " . count($products) . "\n";
    print_r($products);
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

PHP – Použití Import API

<?php

$apiKey = 'your_api_key_here';
$apiUrl = 'https://your-domain.com';

function importProducts($apiKey, $apiUrl, $filePath) {
    $file = new CURLFile($filePath, 'text/csv', 'products.csv');
    
    $postData = [
        'file' => $file,
        'entity' => 'products',
        'mapperId' => 'your-mapper-id'
    ];
    
    $ch = curl_init($apiUrl . '/api/import');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'X-API-Key: ' . $apiKey
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode !== 200) {
        throw new Exception('Import Error: ' . $httpCode);
    }
    
    return json_decode($response, true);
}

// Usage
try {
    $result = importProducts($apiKey, $apiUrl, './products.csv');
    echo "Import completed: " . $result['imported'] . " imported\n";
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

Doporučené postupy

✅ Ukládejte bezpečně: Používejte proměnné prostředí nebo zabezpečené konfigurační soubory

✅ Nastavte vypršení platnosti: Nakonfigurujte automatické datum vypršení platnosti pro zvýšení bezpečnosti

✅ Pravidelně obměňujte: Pravidelně vytvářejte nové klíče a deaktivujte staré

✅ Používejte HTTPS: Vždy používejte HTTPS, abyste zabránili zachycení klíče

❌ Nikdy necommitujte: Necommitujte klíče API do systémů pro správu verzí

Autorizace OAuth 2.0

Průmyslový standardní protokol pro bezpečný delegovaný přístup se souhlasem uživatele.

Jak to funguje

OAuth 2.0 je průmyslový standardní protokol pro autorizaci. Umožňuje aplikacím třetích stran získat omezený přístup k uživatelským účtům bez odhalení hesel. Autorizační tok používá krátkodobé přístupové tokeny a dlouhodobé obnovovací tokeny, přičemž tajemství jsou uložena šifrovaně v SafeStore pomocí šifrování s rozdělenými znalostmi (AES-256-CBC).

**Zabezpečení:** 
Tokeny OAuth jsou bezpečnější než klíče API. Přístupové tokeny jsou tokeny JWT, které vyprší, a tajemství jsou šifrována jak serverovým "pepperem", tak uživatelsky specifickými šifrovacími klíči.

Kroky nastavení

1. Vytvořte vývojářský účet

Zaregistrujte se jako vývojář v systému pro přístup k funkcím OAuth

2. Vytvořte vývojářskou aplikaci

Vytvořte aplikaci s URI pro přesměrování, rozsahy a nastavením OAuth

3. Získejte klientské přihlašovací údaje

Zkopírujte své ID klienta a tajný klíč klienta z nastavení aplikace

4. Implementujte tok OAuth

Použijte tok autorizačního kódu k získání přístupových tokenů pro vaše uživatele

Kompletní dokumentace OAuth 2.0

Podrobné informace naleznete zde:

Příklady toku OAuth

TypeScript – Krok 1: Přesměrování uživatele k autorizaci

import crypto from 'crypto';

const CLIENT_ID = 'your_client_id';
const REDIRECT_URI = 'https://yourapp.com/oauth/callback';
const API_URL = 'https://your-domain.com';

// Generate state parameter for CSRF protection
const state = crypto.randomBytes(16).toString('hex');
sessionStorage.setItem('oauth_state', state);

// Build authorization URL
const authUrl = new URL(`${API_URL}/auth/oauth/authorize`);
authUrl.searchParams.set('client_id', CLIENT_ID);
authUrl.searchParams.set('redirect_uri', REDIRECT_URI);
authUrl.searchParams.set('response_type', 'code');
authUrl.searchParams.set('scope', 'read write');
authUrl.searchParams.set('state', state);

// Redirect to authorization page
window.location.href = authUrl.toString();

TypeScript – Krok 2: Zpracování zpětného volání a výměna kódu

const CLIENT_ID = 'your_client_id';
const CLIENT_SECRET = 'your_client_secret';
const REDIRECT_URI = 'https://yourapp.com/oauth/callback';
const API_URL = 'https://your-domain.com';

interface TokenResponse {
  access_token: string;
  token_type: string;
  expires_in: number;
  refresh_token?: string;
  scope: string;
}

async function handleOAuthCallback(code: string, state: string): Promise<TokenResponse> {
  // Verify state parameter
  const savedState = sessionStorage.getItem('oauth_state');
  if (state !== savedState) {
    throw new Error('Invalid state parameter - CSRF attack detected');
  }

  // Exchange authorization code for tokens
  try {
    const response = await fetch(
      `${API_URL}/auth/oauth/token`,
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        },
        body: new URLSearchParams({
          grant_type: 'authorization_code',
          code: code,
          redirect_uri: REDIRECT_URI,
          client_id: CLIENT_ID,
          client_secret: CLIENT_SECRET
        })
      }
    );

    if (!response.ok) {
      throw new Error(`Token exchange failed: ${response.status}`);
    }

    const tokens: TokenResponse = await response.json();

    // Store tokens securely
    localStorage.setItem('access_token', tokens.access_token);
    if (tokens.refresh_token) {
      localStorage.setItem('refresh_token', tokens.refresh_token);
    }

    return tokens;
  } catch (error) {
    console.error('Token exchange failed:', error);
    throw error;
  }
}

// Usage in callback route
const urlParams = new URLSearchParams(window.location.search);
const code = urlParams.get('code');
const state = urlParams.get('state');

if (code && state) {
  handleOAuthCallback(code, state).then(tokens => {
    console.log('OAuth successful, access token obtained');
    // Now you can make API calls
  });
}

TypeScript – Krok 3: Provádění ověřených požadavků

const API_URL = 'https://your-domain.com';
const CLIENT_ID = 'your_client_id';
const CLIENT_SECRET = 'your_client_secret';

async function makeAuthenticatedRequest(endpoint: string, data?: any) {
  const accessToken = localStorage.getItem('access_token');
  
  if (!accessToken) {
    throw new Error('No access token available');
  }

  try {
    const response = await fetch(
      `${API_URL}${endpoint}`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${accessToken}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(data)
      }
    );

    if (response.status === 401) {
      // Token expired, refresh it
      await refreshAccessToken();
      // Retry request
      return makeAuthenticatedRequest(endpoint, data);
    }

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

    return await response.json();
  } catch (error) {
    throw error;
  }
}

// Refresh token when access token expires
async function refreshAccessToken() {
  const refreshToken = localStorage.getItem('refresh_token');
  
  if (!refreshToken) {
    throw new Error('No refresh token available');
  }

  const response = await fetch(
    `${API_URL}/auth/oauth/token`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
      },
      body: new URLSearchParams({
        grant_type: 'refresh_token',
        refresh_token: refreshToken,
        client_id: CLIENT_ID,
        client_secret: CLIENT_SECRET
      })
    }
  );

  if (!response.ok) {
    throw new Error(`Token refresh failed: ${response.status}`);
  }

  const tokens = await response.json();
  localStorage.setItem('access_token', tokens.access_token);
  return tokens;
}

// Usage
makeAuthenticatedRequest('/api/query', {
  query: 'products { id, name, price }'
}).then(data => {
  console.log('Products:', data.products);
});

PHP – Krok 1: Přesměrování uživatele k autorizaci

<?php
session_start();

$clientId = 'your_client_id';
$redirectUri = 'https://yourapp.com/oauth/callback.php';
$apiUrl = 'https://your-domain.com';

// Generate state parameter for CSRF protection
$state = bin2hex(random_bytes(16));
$_SESSION['oauth_state'] = $state;

// Build authorization URL
$params = [
    'client_id' => $clientId,
    'redirect_uri' => $redirectUri,
    'response_type' => 'code',
    'scope' => 'read write',
    'state' => $state
];

$authUrl = $apiUrl . '/auth/oauth/authorize?' . http_build_query($params);

// Redirect to authorization page
header('Location: ' . $authUrl);
exit;

PHP – Krok 2: Zpracování zpětného volání a výměna kódu

<?php
session_start();

$clientId = 'your_client_id';
$clientSecret = 'your_client_secret';
$redirectUri = 'https://yourapp.com/oauth/callback.php';
$apiUrl = 'https://your-domain.com';

function exchangeCodeForToken($code, $state) {
    global $clientId, $clientSecret, $redirectUri, $apiUrl;
    
    // Verify state parameter
    if (!isset($_SESSION['oauth_state']) || $state !== $_SESSION['oauth_state']) {
        throw new Exception('Invalid state parameter - CSRF attack detected');
    }
    
    unset($_SESSION['oauth_state']);
    
    // Prepare token request
    $postData = [
        'grant_type' => 'authorization_code',
        'code' => $code,
        'redirect_uri' => $redirectUri,
        'client_id' => $clientId,
        'client_secret' => $clientSecret
    ];
    
    // Exchange code for tokens
    $ch = curl_init($apiUrl . '/auth/oauth/token');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($postData));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Content-Type: application/x-www-form-urlencoded'
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode !== 200) {
        throw new Exception('Token exchange failed: ' . $httpCode);
    }
    
    $tokens = json_decode($response, true);
    
    // Store tokens securely (in session, database, or secure cookie)
    $_SESSION['access_token'] = $tokens['access_token'];
    if (isset($tokens['refresh_token'])) {
        $_SESSION['refresh_token'] = $tokens['refresh_token'];
    }
    $_SESSION['token_expires'] = time() + $tokens['expires_in'];
    
    return $tokens;
}

// Handle callback
if (isset($_GET['code']) && isset($_GET['state'])) {
    try {
        $tokens = exchangeCodeForToken($_GET['code'], $_GET['state']);
        echo "OAuth successful! Access token obtained.\n";
        echo "Token expires in: " . $tokens['expires_in'] . " seconds\n";
        
        // Redirect to your application
        header('Location: /dashboard.php');
        exit;
    } catch (Exception $e) {
        echo "OAuth Error: " . $e->getMessage();
    }
} else if (isset($_GET['error'])) {
    echo "OAuth Error: " . $_GET['error'];
}

PHP – Krok 3: Provádění ověřených požadavků

<?php
session_start();

$clientId = 'your_client_id';
$clientSecret = 'your_client_secret';
$apiUrl = 'https://your-domain.com';

function makeAuthenticatedRequest($endpoint, $data = null) {
    global $apiUrl;
    
    if (!isset($_SESSION['access_token'])) {
        throw new Exception('No access token available');
    }
    
    // Check if token is expired
    if (isset($_SESSION['token_expires']) && time() >= $_SESSION['token_expires']) {
        refreshAccessToken();
    }
    
    $ch = curl_init($apiUrl . $endpoint);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    
    if ($data !== null) {
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    }
    
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Authorization: Bearer ' . $_SESSION['access_token'],
        'Content-Type: application/json'
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode === 401) {
        // Token expired, refresh and retry
        refreshAccessToken();
        return makeAuthenticatedRequest($endpoint, $data);
    }
    
    if ($httpCode !== 200) {
        throw new Exception('API Error: ' . $httpCode);
    }
    
    return json_decode($response, true);
}

function refreshAccessToken() {
    global $apiUrl, $clientId, $clientSecret;
    
    if (!isset($_SESSION['refresh_token'])) {
        throw new Exception('No refresh token available');
    }
    
    $postData = [
        'grant_type' => 'refresh_token',
        'refresh_token' => $_SESSION['refresh_token'],
        'client_id' => $clientId,
        'client_secret' => $clientSecret
    ];
    
    $ch = curl_init($apiUrl . '/auth/oauth/token');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($postData));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Content-Type: application/x-www-form-urlencoded'
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode !== 200) {
        throw new Exception('Token refresh failed: ' . $httpCode);
    }
    
    $tokens = json_decode($response, true);
    $_SESSION['access_token'] = $tokens['access_token'];
    $_SESSION['token_expires'] = time() + $tokens['expires_in'];
}

// Usage
try {
    $data = makeAuthenticatedRequest('/api/query', [
        'query' => 'products { id, name, price }'
    ]);
    
    echo "Found " . count($data['products']) . " products\n";
    foreach ($data['products'] as $product) {
        echo $product['name'] . ": " . $product['price'] . "\n";
    }
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}

Klíčové funkce

✅ Souhlas uživatele: Uživatelé explicitně autorizují vaši aplikaci

✅ Tokeny JWT: Přístupové tokeny jsou bezstavové tokeny JWT (platnost 30 dní)

✅ Šifrované úložiště: Tajné klíče uložené s šifrováním AES-256-CBC s rozděleným klíčem

✅ Obnovovací tokeny: Dlouhodobé tokeny pro získávání nových přístupových tokenů

✅ Ochrana proti CSRF: Parametr stavu zabraňuje padělání požadavků mezi weby

Autorizace pluginu

Automatické přihlašovací údaje OAuth pro pluginy s nulovou konfigurací.

Jak to funguje

Při vývoji pluginů pro systém nemusíte ručně vytvářet vývojářské aplikace ani spravovat přihlašovací údaje OAuth. Systém automaticky poskytuje vašemu pluginu potřebné client_id a client_secret za běhu prostřednictvím proměnných prostředí nebo konfigurace.

**Automatické nastavení:** 
Autorizace pluginu je automaticky zpracována systémem. Kód vašeho pluginu jednoduše načte poskytnuté přihlašovací údaje z proměnných prostředí.

Jak pluginy přijímají přihlašovací údaje

Když se váš plugin načte, systém poskytne přihlašovací údaje OAuth prostřednictvím:

OAUTH_CLIENT_ID Jedinečný identifikátor klienta vašeho pluginu

OAUTH_CLIENT_SECRET Tajný klíč vašeho pluginu pro ověřování

API_BASE_URL Základní URL pro provádění požadavků API

Příklad pluginu

Plugin TypeScript

// Plugin receives these credentials automatically
// OAUTH_CLIENT_ID will be provided by the system
// OAUTH_CLIENT_SECRET will be provided by the system
// API_BASE_URL will be provided by the system

const CLIENT_ID = process.env.OAUTH_CLIENT_ID!;
const CLIENT_SECRET = process.env.OAUTH_CLIENT_SECRET!;
const API_BASE_URL = process.env.API_BASE_URL!;

class PluginApiClient {
  private accessToken: string | null = null;
  private tokenExpiry: number = 0;

  async authenticate() {
    // Use client credentials grant
    const response = await fetch(
      `${API_BASE_URL}/auth/oauth/token`,
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        },
        body: new URLSearchParams({
          grant_type: 'client_credentials',
          client_id: CLIENT_ID,
          client_secret: CLIENT_SECRET,
          scope: 'read write'
        })
      }
    );

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

    const tokens = await response.json();
    this.accessToken = tokens.access_token;
    this.tokenExpiry = Date.now() + (tokens.expires_in * 1000);
  }

  async makeRequest(endpoint: string, data?: any) {
    // Refresh token if expired
    if (!this.accessToken || Date.now() >= this.tokenExpiry) {
      await this.authenticate();
    }

    const response = await fetch(
      `${API_BASE_URL}${endpoint}`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.accessToken}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(data)
      }
    );

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

    return await response.json();
  }
}

// Usage in your plugin
const client = new PluginApiClient();

export async function pluginFunction() {
  const products = await client.makeRequest('/api/query', {
    query: 'products { id, name, price }'
  });

  console.log('Fetched products:', products);
  return products;
}

Plugin PHP

<?php

// Plugin receives these credentials automatically
// OAUTH_CLIENT_ID will be provided by the system
// OAUTH_CLIENT_SECRET will be provided by the system
// API_BASE_URL will be provided by the system

$clientId = getenv('OAUTH_CLIENT_ID');
$clientSecret = getenv('OAUTH_CLIENT_SECRET');
$apiBaseUrl = getenv('API_BASE_URL');

class PluginApiClient {
    private $clientId;
    private $clientSecret;
    private $apiBaseUrl;
    private $accessToken = null;
    private $tokenExpiry = 0;

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

    private function authenticate() {
        $postData = [
            'grant_type' => 'client_credentials',
            'client_id' => $this->clientId,
            'client_secret' => $this->clientSecret,
            'scope' => 'read write'
        ];

        $ch = curl_init($this->apiBaseUrl . '/auth/oauth/token');
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($postData));
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Content-Type: application/x-www-form-urlencoded'
        ]);

        $response = curl_exec($ch);
        curl_close($ch);

        $data = json_decode($response, true);
        $this->accessToken = $data['access_token'];
        $this->tokenExpiry = time() + $data['expires_in'];
    }

    public function makeRequest($endpoint, $data = null) {
        // Refresh token if expired
        if ($this->accessToken === null || time() >= $this->tokenExpiry) {
            $this->authenticate();
        }

        $ch = curl_init($this->apiBaseUrl . $endpoint);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        
        if ($data !== null) {
            curl_setopt($ch, CURLOPT_POST, true);
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        }
        
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Authorization: Bearer ' . $this->accessToken,
            'Content-Type: application/json'
        ]);

        $response = curl_exec($ch);
        curl_close($ch);

        return json_decode($response, true);
    }
}

// Usage in your plugin
$client = new PluginApiClient($clientId, $clientSecret, $apiBaseUrl);

function pluginFunction($client) {
    $products = $client->makeRequest('/api/query', [
        'query' => 'products { id, name, price }'
    ]);

    echo "Fetched products: " . count($products['products']) . "\n";
    return $products;
}

// Execute plugin function
pluginFunction($client);

Výhody autorizace pluginu

✅ Nulová konfigurace: Pro vývojáře není vyžadováno žádné ruční nastavení

✅ Automatická injekce: Přihlašovací údaje poskytovány prostřednictvím proměnných prostředí

✅ Ve výchozím nastavení zabezpečeno: Používá OAuth 2.0 s šifrovaným úložištěm

✅ Konzistentní API: Stejný tok ověřování jako externí aplikace

Srovnávací tabulka

Vyberte správnou metodu autorizace pro váš případ použití.

Funkce Klíč API OAuth 2.0 Autorizace pluginu
Složitost nastavení Jednoduchá Střední Automatická
Úroveň zabezpečení Základní (statické tajné klíče) Vysoká (šifrovaná, vyprší) Vysoká (založená na OAuth)
Platnost tokenu Ruční/konfigurovatelná 30 dní (JWT) 30 dní (JWT)
Souhlas uživatele Ne Ano (explicitní) Ne (na úrovni systému)
Nejlepší pro Interní nástroje, skripty Aplikace třetích stran Systémové pluginy
Možnost obnovení N/A (statické) Ano (obnovovací tokeny) Ano (automatické)
Požadovaná konfigurace Vytvořit klíč API Vytvořit vývojáře + aplikaci Žádná (automatická)

Koncové body API

Ověřování pomocí klíče API

Všechny koncové body API podporují ověřování pomocí klíče API prostřednictvím hlavičky X-API-Key:

POST /api/query
X-API-Key: your_api_key_here
Content-Type: application/json

GET /odata/products
X-API-Key: your_api_key_here

POST /api/import
X-API-Key: your_api_key_here
Content-Type: multipart/form-data

Koncové body OAuth 2.0

Autorizační koncový bod

GET /auth/oauth/authorize
  ?client_id={client_id}
  &redirect_uri={redirect_uri}
  &response_type=code
  &scope={scopes}
  &state={state}

Koncový bod tokenu

POST /auth/oauth/token
Content-Type: application/x-www-form-urlencoded

grant_type=authorization_code
&code={authorization_code}
&redirect_uri={redirect_uri}
&client_id={client_id}
&client_secret={client_secret}

Obnovení tokenu

POST /auth/oauth/token
Content-Type: application/x-www-form-urlencoded

grant_type=refresh_token
&refresh_token={refresh_token}
&client_id={client_id}
&client_secret={client_secret}

Udělení klientských přihlašovacích údajů (pro pluginy)

POST /auth/oauth/token
Content-Type: application/x-www-form-urlencoded

grant_type=client_credentials
&client_id={client_id}
&client_secret={client_secret}
&scope={scopes}

Ověřené požadavky API

Jakmile máte přístupový token, zahrňte jej do hlavičky Authorization:

POST /api/query
Authorization: Bearer {access_token}
Content-Type: application/json

{
  "query": "products { id, name, price }"
}

Související dokumentace

[navigate:query.md|API dotazů|code|left]

[navigate:odata.md|API OData|database|left]

[navigate:imports.md|API importu|upload|left]

[navigate:webhooks.md|Webhooks|webhook|left]

[navigate:rate-limiting.md|Omezení rychlosti|gauge|left]