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

Čo je to?

Poznámka pre administrátora: Tento systém zabezpečuje, že k citlivým dátam vášho e-shopu majú prístup iba oprávnené osoby a aplikácie. Je to ako digitálna „bezpečnostná brána“ pre vaše integrácie.

Pre koho je to určené? Administrátori musia rozumieť rôznym možnostiam zabezpečenia (ako sú kľúče API alebo autorizácia aplikácií), aby mohli spravovať, kto má prístup k systému. Konkrétne technické nastavenia a príklady kódu by však mali byť postúpené vášmu vývojovému tímu alebo integračnému partnerovi.

Kľúčové výhody pre e-shop:

  • Pevné zabezpečenie: Udržujte svoje obchodné dáta v bezpečí presnou kontrolou, ktoré externé nástroje majú prístup.
  • Jednoduchá integrácia: Rýchlo vytvárajte „kľúče“ pre interné nástroje alebo bezpečne pripájajte profesionálne aplikácie tretích strán.
  • Správa prístupu: Jednoducho zrušte prístup, ak nástroj už nie je potrebný alebo ak máte podozrenie na bezpečnostné riziko.
  • Pripravené na automatizáciu: Bezpečne pripojte svoj e-shop k iným systémom na automatizáciu objednávok, inventára a ďalších.

Autorizácia

Zabezpečený prístup k API pomocou kľúčov API, OAuth 2.0 alebo autorizácie pluginov

Prehľad

Systém podporuje tri metódy autorizácie na autentifikáciu požiadaviek API a bezpečný prístup k zdrojom. Vyberte si metódu, ktorá najlepšie vyhovuje vašim integračným požiadavkám a bezpečnostným potrebám.

Metódy autorizácie

Kľúč API

Najjednoduchšia metóda pre interné integrácie a skripty. Statické, dlhodobé prihlasovacie údaje.

Odporúčané pre: Interné nástroje

OAuth 2.0

Priemyselný štandardný protokol pre aplikácie tretích strán so súhlasom používateľa a správou tokenov.

Odporúčané pre: Externé aplikácie

Autorizácia pluginov

Automatické prihlasovacie údaje poskytované pluginom. Nevyžaduje sa žiadna manuálna konfigurácia.

Odporúčané pre: Pluginy

Autorizácia pomocou kľúča API

Najjednoduchšia metóda autorizácie pomocou statického kľúča API na autentifikáciu.

Ako to funguje

Kľúče API sú dlhodobé, statické prihlasovacie údaje, ktoré identifikujú vašu aplikáciu. Sú uložené priamo v databáze (šifrované) a sú ideálne pre integrácie server-to-server, interné nástroje a skripty, kde ovládate prostredie.

**Bezpečnostná poznámka:** Kľúče API by mali byť uchovávané v tajnosti a nikdy by nemali byť vystavené v kóde na strane klienta alebo vo verejných repozitároch. Poskytujú plný prístup k vášmu účtu.

Vytvorenie kľúča API

  1. Prejdite na stránku Kľúče API
  2. Kliknite na „Vytvoriť nový kľúč API“
  3. Nastavte popisný názov a voliteľný dátum vypršania platnosti
  4. Okamžite skopírujte vygenerovaný kľúč (už sa znova nezobrazí)
  5. Kľúč bezpečne uložte do konfigurácie vašej aplikácie

Príklady použitia

TypeScript – Použitie 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žitie 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žitie 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žitie 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žitie 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žitie 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";
}

Osvedčené postupy

✅ Uložte bezpečne: Používajte premenné prostredia alebo bezpečné konfiguračné súbory

✅ Nastavte vypršanie platnosti: Nakonfigurujte automatické dátumy vypršania platnosti pre zvýšenú bezpečnosť

✅ Pravidelne rotujte: Pravidelne vytvárajte nové kľúče a deaktivujte staré

✅ Používajte HTTPS: Vždy používajte HTTPS, aby ste zabránili zachyteniu kľúča

❌ Nikdy necommitujte: Necommitujte kľúče API do systémov na správu verzií

Autorizácia OAuth 2.0

Priemyselný štandardný protokol pre bezpečný delegovaný prístup so súhlasom používateľa.

Ako to funguje

OAuth 2.0 je priemyselný štandardný protokol pre autorizáciu. Umožňuje aplikáciám tretích strán získať obmedzený prístup k používateľským účtom bez odhalenia hesiel. Autorizačný tok používa krátkodobé prístupové tokeny a dlhodobé obnovovacie tokeny, pričom tajné údaje sú šifrované v SafeStore pomocou šifrovania s rozdelenými znalosťami (AES-256-CBC).

**Bezpečnosť:** 
Tokeny OAuth sú bezpečnejšie ako kľúče API. Prístupové tokeny sú tokeny JWT, ktoré vypršia, a tajné údaje sú šifrované pomocou serverového „peppera“ aj šifrovacích kľúčov špecifických pre používateľa.

Kroky nastavenia

1. Vytvorte účet vývojára

Zaregistrujte sa ako vývojár v systéme, aby ste získali prístup k funkciám OAuth

2. Vytvorte vývojársku aplikáciu

Vytvorte aplikáciu s URI presmerovania, rozsahmi a nastaveniami OAuth

3. Získajte klientske prihlasovacie údaje

Skopírujte svoje ID klienta a tajný kľúč klienta z nastavení aplikácie

4. Implementujte tok OAuth

Použite tok autorizačného kódu na získanie prístupových tokenov pre vašich používateľov

Kompletná dokumentácia OAuth 2.0

Podrobné informácie nájdete tu:

Príklady toku OAuth

TypeScript – Krok 1: Presmerovanie používateľa na autorizáciu

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: Spracovanie spätného volania a výmena 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: Vytváranie overených požiadaviek

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: Presmerovanie používateľa na autorizáciu

<?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: Spracovanie spätného volania a výmena 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: Vytváranie overených požiadaviek

<?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();
}

Kľúčové funkcie

✅ Súhlas používateľa: Používatelia explicitne autorizujú vašu aplikáciu

✅ Tokeny JWT: Prístupové tokeny sú bezstavové tokeny JWT (platnosť 30 dní)

✅ Šifrované úložisko: Tajné kľúče uložené s AES-256-CBC šifrovaním s rozdeleným poznaním

✅ Obnovovacie tokeny: Dlhodobé tokeny na získanie nových prístupových tokenov

✅ Ochrana proti CSRF: Parameter stavu zabraňuje falšovaniu požiadaviek medzi stránkami

Autorizácia doplnkov

Automatické poverenia OAuth pre doplnky s nulovou konfiguráciou.

Ako to funguje

Pri vývoji doplnkov pre systém nemusíte manuálne vytvárať vývojárske aplikácie ani spravovať poverenia OAuth. Systém automaticky poskytuje vášmu doplnku potrebné client_id a client_secret počas behu prostredníctvom premenných prostredia alebo konfigurácie.

**Automatické nastavenie:** 
Autorizácia doplnkov je systémom spracovaná automaticky. Kód vášho doplnku jednoducho načíta poskytnuté poverenia z premenných prostredia.

Ako doplnky prijímajú poverenia

Keď sa váš doplnok načíta, systém poskytuje poverenia OAuth prostredníctvom:

OAUTH_CLIENT_ID Jedinečný identifikátor klienta vášho doplnku

OAUTH_CLIENT_SECRET Tajný kľúč vášho doplnku pre autentifikáciu

API_BASE_URL Základná URL pre vykonávanie požiadaviek API

Príklad doplnku

Doplnok 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;
}

Doplnok 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 autorizácie doplnkov

✅ Nulová konfigurácia: Nevyžaduje sa žiadne manuálne nastavenie pre vývojárov

✅ Automatické vkladanie: Poverenia poskytované prostredníctvom premenných prostredia

✅ Bezpečné v predvolenom nastavení: Používa OAuth 2.0 so šifrovaným úložiskom

✅ Konzistentné API: Rovnaký tok autentifikácie ako pre externé aplikácie

Porovnávacia tabuľka

Vyberte si správnu metódu autorizácie pre váš prípad použitia.

Funkcia Kľúč API OAuth 2.0 Autorizácia doplnkov
Zložitosť nastavenia Jednoduché Stredné Automatické
Úroveň zabezpečenia Základné (statické tajné kľúče) Vysoká (šifrované, s expiráciou) Vysoká (založené na OAuth)
Expirácia tokenu Manuálne/konfigurovateľné 30 dní (JWT) 30 dní (JWT)
Súhlas používateľa Nie Áno (explicitný) Nie (na úrovni systému)
Najlepšie pre Interné nástroje, skripty Aplikácie tretích strán Systémové doplnky
Možnosť obnovenia N/A (statické) Áno (obnovovacie tokeny) Áno (automatické)
Vyžadovaná konfigurácia Vytvoriť kľúč API Vytvoriť vývojára + aplikáciu Žiadna (automatické)

Koncové body API

Autentifikácia kľúčom API

Všetky koncové body API podporujú autentifikáciu kľúčom API prostredníctvom 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

Koncový bod autorizácie

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}

Obnovenie 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}

Udelenie poverení klienta (pre doplnky)

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}

Overené požiadavky API

Keď máte prístupový token, zahrňte ho do hlavičky Authorization:

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

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

Súvisiaca dokumentácia

[navigate:query.md|API pre dopyty|code|left]

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

[navigate:imports.md|API pre import|upload|left]

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

[navigate:rate-limiting.md|Obmedzenia rýchlosti|gauge|left]