Kod Örnekleri

Bu sayfa, SeoAuthor API'yi farklı programlama dillerinde nasıl kullanacağınızı gösteren kapsamlı örnekler içermektedir.

🌟 Başlangıç Örnekleri

JavaScript/Node.js

Temel API Client

class FinexAPIClient {
  constructor() {
    this.baseUrl = "https://integration.seoauthor.ai";
    this.accessToken = null;
    this.refreshToken = null;
  }

  // Giriş yapma
  async login(email, password) {
    try {
      const response = await fetch(`${this.baseUrl}/api/v1/auth/login`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ email, password }),
      });

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

      const data = await response.json();
      this.accessToken = data.accessToken;
      this.refreshToken = data.refreshToken;

      return data;
    } catch (error) {
      console.error("Login error:", error);
      throw error;
    }
  }

  // Token yenileme
  async refreshAccessToken() {
    if (!this.refreshToken) {
      throw new Error("No refresh token available");
    }

    const response = await fetch(`${this.baseUrl}/api/v1/auth/refresh`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ refreshToken: this.refreshToken }),
    });

    if (!response.ok) {
      throw new Error("Token refresh failed");
    }

    const data = await response.json();
    this.accessToken = data.accessToken;
    this.refreshToken = data.refreshToken;

    return data;
  }

  // API çağrısı yapma (otomatik token yönetimi ile)
  async makeRequest(method, endpoint, body = null) {
    const makeCall = async (token) => {
      const options = {
        method,
        headers: {
          Authorization: `Bearer ${token}`,
          "Content-Type": "application/json",
        },
      };

      if (body) {
        options.body = JSON.stringify(body);
      }

      return fetch(`${this.baseUrl}${endpoint}`, options);
    };

    let response = await makeCall(this.accessToken);

    // Token süresi dolmuşsa yenile ve tekrar dene
    if (response.status === 401) {
      await this.refreshAccessToken();
      response = await makeCall(this.accessToken);
    }

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

    return response.json();
  }

  // Makale oluşturma
  async createArticle(baslik, yazimTonu, makaleBoyutu) {
    return this.makeRequest("POST", "/api/v1/makaleler/makale-olustur", {
      baslik,
      yazimTonu,
      makaleBoyutu,
    });
  }

  // Toplu makale oluşturma
  async createBulkArticles(makaleler, yazimTonu, makaleBoyutu) {
    return this.makeRequest("POST", "/api/v1/makaleler/toplu-makale-olustur", {
      makaleler,
      yazimTonu,
      makaleBoyutu,
    });
  }

  // Makale listesi
  async getMyArticles(filters = {}) {
    const params = new URLSearchParams(filters);
    return this.makeRequest("GET", `/api/v1/makaleler/makalelerim?${params}`);
  }

  // Bakiye sorgulama
  async getCurrentBalance() {
    return this.makeRequest("GET", "/api/v1/profil/guncel-bakiye");
  }
}

// Kullanım örneği
async function example() {
  const client = new FinexAPIClient();

  try {
    // Giriş yap
    await client.login("your-email@example.com", "your-password");
    console.log("Giriş başarılı!");

    // Bakiye kontrol et
    const balance = await client.getCurrentBalance();
    console.log("Mevcut bakiye:", balance);

    // Makale oluştur
    const article = await client.createArticle(
      "JavaScript ile Modern Web Geliştirme",
      1, // Profesyonel ton
      2 // Orta boyut
    );
    console.log("Makale oluşturuldu:", article);

    // Makaleleri listele
    const articles = await client.getMyArticles({ pageSize: 10 });
    console.log("Makalelerim:", articles);
  } catch (error) {
    console.error("Hata:", error);
  }
}

example();

Python

Comprehensive Python Client

import requests
import time
import json
from typing import Optional, Dict, List

class FinexAPIClient:
    def __init__(self, base_url: str = "https://integration.seoauthor.ai"):
        self.base_url = base_url
        self.access_token: Optional[str] = None
        self.refresh_token: Optional[str] = None
        self.session = requests.Session()

    def login(self, email: str, password: str) -> Dict:
        """Sisteme giriş yapma"""
        url = f"{self.base_url}/api/v1/auth/login"
        data = {
            "email": email,
            "password": password
        }

        try:
            response = self.session.post(url, json=data)
            response.raise_for_status()

            auth_data = response.json()
            self.access_token = auth_data['accessToken']
            self.refresh_token = auth_data['refreshToken']

            # Session headers'ını güncelle
            self.session.headers.update({
                'Authorization': f'Bearer {self.access_token}'
            })

            return auth_data
        except requests.exceptions.RequestException as e:
            raise Exception(f"Login failed: {e}")

    def refresh_access_token(self) -> Dict:
        """Access token yenileme"""
        if not self.refresh_token:
            raise Exception("No refresh token available")

        url = f"{self.base_url}/api/v1/auth/refresh"
        data = {"refreshToken": self.refresh_token}

        # Refresh için geçici session kullan
        temp_session = requests.Session()
        response = temp_session.post(url, json=data)

        if response.status_code == 401:
            raise Exception("Refresh token expired. Please login again.")

        response.raise_for_status()
        auth_data = response.json()

        self.access_token = auth_data['accessToken']
        self.refresh_token = auth_data['refreshToken']

        # Ana session'ı güncelle
        self.session.headers.update({
            'Authorization': f'Bearer {self.access_token}'
        })

        return auth_data

    def make_request(self, method: str, endpoint: str, data: Optional[Dict] = None) -> Dict:
        """API çağrısı yapma (otomatik token yönetimi ile)"""
        url = f"{self.base_url}{endpoint}"

        # İlk deneme
        response = self.session.request(method, url, json=data)

        # Token süresi dolmuşsa yenile ve tekrar dene
        if response.status_code == 401:
            print("Token expired, refreshing...")
            self.refresh_access_token()
            response = self.session.request(method, url, json=data)

        response.raise_for_status()
        return response.json()

    def create_article(self, baslik: str, yazim_tonu: int, makale_boyutu: int) -> Dict:
        """Tek makale oluşturma"""
        data = {
            "baslik": baslik,
            "yazimTonu": yazim_tonu,
            "makaleBoyutu": makale_boyutu
        }
        return self.make_request('POST', '/api/v1/makaleler/makale-olustur', data)

    def create_bulk_articles(self, makaleler: List[Dict], yazim_tonu: int, makale_boyutu: int) -> Dict:
        """Toplu makale oluşturma"""
        data = {
            "makaleler": makaleler,
            "yazimTonu": yazim_tonu,
            "makaleBoyutu": makale_boyutu
        }
        return self.make_request('POST', '/api/v1/makaleler/toplu-makale-olustur', data)

    def get_my_articles(self, **filters) -> Dict:
        """Makale listesi"""
        params = "&".join([f"{k}={v}" for k, v in filters.items() if v is not None])
        endpoint = f"/api/v1/makaleler/makalelerim"
        if params:
            endpoint += f"?{params}"
        return self.make_request('GET', endpoint)

    def get_current_balance(self) -> Dict:
        """Mevcut bakiye"""
        return self.make_request('GET', '/api/v1/profil/guncel-bakiye')

    def get_writing_tones(self) -> Dict:
        """Yazım tonları"""
        return self.make_request('GET', '/api/v1/makaleler/yazim-tonlari')

    def get_article_sizes(self) -> Dict:
        """Makale boyutları"""
        return self.make_request('GET', '/api/v1/makaleler/makale-boyutları')

    def add_topic(self, konu: str, limit: int) -> Dict:
        """Konu ekleme"""
        data = {
            "konu": konu,
            "limit": limit
        }
        return self.make_request('POST', '/api/v1/konular/konu-ekle', data)

    def create_title(self, anahtar_kelime: str, adet: int = 1) -> Dict:
        """Başlık oluşturma"""
        data = {
            "anahtarKelime": anahtar_kelime,
            "adet": adet
        }
        return self.make_request('POST', '/api/v1/basliklar/baslik-olustur', data)

# Kullanım örneği
def main():
    client = FinexAPIClient()

    try:
        # Giriş
        print("Giriş yapılıyor...")
        auth_data = client.login("your-email@example.com", "your-password")
        print("✅ Giriş başarılı!")

        # Bakiye kontrol
        balance = client.get_current_balance()
        print(f"💰 Mevcut bakiye: {balance}")

        # Yazım tonları
        tones = client.get_writing_tones()
        print(f"✍️ Mevcut yazım tonları: {len(tones)} adet")

        # Makale oluştur
        print("📝 Makale oluşturuluyor...")
        article_result = client.create_article(
            "Python ile API Geliştirme Rehberi",
            1,  # Profesyonel
            2   # Orta
        )
        print("✅ Makale oluşturma başlatıldı:", article_result)

        # Toplu makale örneği
        bulk_articles = [
            {"baslik": "Web Scraping ile Veri Toplama"},
            {"baslik": "Machine Learning Temelleri"},
            {"baslik": "Django ile Web Geliştirme"}
        ]

        print("📚 Toplu makale oluşturuluyor...")
        bulk_result = client.create_bulk_articles(bulk_articles, 3, 2)
        print("✅ Toplu makale işlemi başlatıldı:", bulk_result)

        # Makale listesi
        print("📋 Makaleler getiriliyor...")
        articles = client.get_my_articles(pageSize=5, durumId=3)
        print(f"📖 Toplam makale sayısı: {len(articles.get('makaleler', []))}")

    except Exception as e:
        print(f"❌ Hata: {e}")

if __name__ == "__main__":
    main()

PHP

Professional PHP Client

<?php

class FinexAPIClient {
    private $baseUrl;
    private $accessToken;
    private $refreshToken;

    public function __construct($baseUrl = 'https://integration.seoauthor.ai') {
        $this->baseUrl = $baseUrl;
    }

    /**
     * Sisteme giriş yapma
     */
    public function login($email, $password) {
        $data = [
            'email' => $email,
            'password' => $password
        ];

        $response = $this->makeHTTPRequest('POST', '/api/v1/auth/login', $data, false);

        if (isset($response['accessToken'])) {
            $this->accessToken = $response['accessToken'];
            $this->refreshToken = $response['refreshToken'];
        }

        return $response;
    }

    /**
     * Token yenileme
     */
    public function refreshAccessToken() {
        if (!$this->refreshToken) {
            throw new Exception('No refresh token available');
        }

        $data = ['refreshToken' => $this->refreshToken];
        $response = $this->makeHTTPRequest('POST', '/api/v1/auth/refresh', $data, false);

        if (isset($response['accessToken'])) {
            $this->accessToken = $response['accessToken'];
            $this->refreshToken = $response['refreshToken'];
        }

        return $response;
    }

    /**
     * HTTP isteği yapma
     */
    private function makeHTTPRequest($method, $endpoint, $data = null, $useAuth = true) {
        $url = $this->baseUrl . $endpoint;
        $headers = ['Content-Type: application/json'];

        if ($useAuth && $this->accessToken) {
            $headers[] = 'Authorization: Bearer ' . $this->accessToken;
        }

        $options = [
            'http' => [
                'header' => implode("\r\n", $headers),
                'method' => $method,
                'timeout' => 30
            ]
        ];

        if ($data) {
            $options['http']['content'] = json_encode($data);
        }

        $context = stream_context_create($options);
        $result = @file_get_contents($url, false, $context);

        if ($result === false) {
            // HTTP status kontrol
            if (isset($http_response_header)) {
                $status_line = $http_response_header[0];
                if (strpos($status_line, '401') !== false && $useAuth) {
                    // Token yenile ve tekrar dene
                    $this->refreshAccessToken();
                    return $this->makeHTTPRequest($method, $endpoint, $data, $useAuth);
                }
            }
            throw new Exception('HTTP request failed');
        }

        $response = json_decode($result, true);
        if (json_last_error() !== JSON_ERROR_NONE) {
            throw new Exception('Invalid JSON response');
        }

        return $response;
    }

    /**
     * API çağrısı yapma
     */
    public function makeRequest($method, $endpoint, $data = null) {
        return $this->makeHTTPRequest($method, $endpoint, $data, true);
    }

    /**
     * Makale oluşturma
     */
    public function createArticle($baslik, $yazimTonu, $makaleBoyutu) {
        $data = [
            'baslik' => $baslik,
            'yazimTonu' => $yazimTonu,
            'makaleBoyutu' => $makaleBoyutu
        ];

        return $this->makeRequest('POST', '/api/v1/makaleler/makale-olustur', $data);
    }

    /**
     * Toplu makale oluşturma
     */
    public function createBulkArticles($makaleler, $yazimTonu, $makaleBoyutu) {
        $data = [
            'makaleler' => $makaleler,
            'yazimTonu' => $yazimTonu,
            'makaleBoyutu' => $makaleBoyutu
        ];

        return $this->makeRequest('POST', '/api/v1/makaleler/toplu-makale-olustur', $data);
    }

    /**
     * Makale listesi
     */
    public function getMyArticles($filters = []) {
        $queryString = http_build_query(array_filter($filters));
        $endpoint = '/api/v1/makaleler/makalelerim';

        if (!empty($queryString)) {
            $endpoint .= '?' . $queryString;
        }

        return $this->makeRequest('GET', $endpoint);
    }

    /**
     * Mevcut bakiye
     */
    public function getCurrentBalance() {
        return $this->makeRequest('GET', '/api/v1/profil/guncel-bakiye');
    }

    /**
     * Yazım tonları
     */
    public function getWritingTones() {
        return $this->makeRequest('GET', '/api/v1/makaleler/yazim-tonlari');
    }

    /**
     * Makale boyutları
     */
    public function getArticleSizes() {
        return $this->makeRequest('GET', '/api/v1/makaleler/makale-boyutları');
    }
}

// Kullanım örneği
try {
    $client = new FinexAPIClient();

    // Giriş
    echo "Giriş yapılıyor...\n";
    $authData = $client->login('your-email@example.com', 'your-password');
    echo "✅ Giriş başarılı!\n";

    // Bakiye
    $balance = $client->getCurrentBalance();
    echo "💰 Mevcut bakiye: " . json_encode($balance) . "\n";

    // Makale oluştur
    echo "📝 Makale oluşturuluyor...\n";
    $articleResult = $client->createArticle(
        'PHP ile API Geliştirme',
        1, // Profesyonel
        2  // Orta
    );
    echo "✅ Makale oluşturuldu: " . json_encode($articleResult) . "\n";

    // Makale listesi
    $articles = $client->getMyArticles(['pageSize' => 5]);
    echo "📚 Makaleler: " . count($articles) . " adet\n";

} catch (Exception $e) {
    echo "❌ Hata: " . $e->getMessage() . "\n";
}
?>

🔧 Utility Fonksiyonları

Token Yönetimi (JavaScript)

class TokenManager {
  constructor() {
    this.storageKeys = {
      accessToken: "finex_access_token",
      refreshToken: "finex_refresh_token",
      tokenExpire: "finex_token_expire",
    };
  }

  // Token'ları localStorage'a kaydet
  saveTokens(accessToken, refreshToken, tokenExpire) {
    localStorage.setItem(this.storageKeys.accessToken, accessToken);
    localStorage.setItem(this.storageKeys.refreshToken, refreshToken);
    localStorage.setItem(this.storageKeys.tokenExpire, tokenExpire.toString());
  }

  // Token'ları al
  getTokens() {
    return {
      accessToken: localStorage.getItem(this.storageKeys.accessToken),
      refreshToken: localStorage.getItem(this.storageKeys.refreshToken),
      tokenExpire: parseInt(localStorage.getItem(this.storageKeys.tokenExpire)),
    };
  }

  // Token süresi kontrolü
  isTokenExpired(bufferMinutes = 5) {
    const { tokenExpire } = this.getTokens();
    if (!tokenExpire) return true;

    const now = Math.floor(Date.now() / 1000);
    const buffer = bufferMinutes * 60;
    return tokenExpire - now <= buffer;
  }

  // Token'ları temizle
  clearTokens() {
    Object.values(this.storageKeys).forEach((key) => {
      localStorage.removeItem(key);
    });
  }

  // Kalan süreyi göster
  getTimeUntilExpiry() {
    const { tokenExpire } = this.getTokens();
    if (!tokenExpire) return "Token bilgisi yok";

    const now = Math.floor(Date.now() / 1000);
    const secondsLeft = tokenExpire - now;

    if (secondsLeft <= 0) return "Token süresi dolmuş";

    const minutes = Math.floor(secondsLeft / 60);
    const hours = Math.floor(minutes / 60);

    if (hours > 0) {
      return `${hours} saat ${minutes % 60} dakika`;
    }
    return `${minutes} dakika`;
  }
}

Rate Limiting (Python)

import time
from collections import defaultdict
from typing import Dict, Optional

class RateLimiter:
    def __init__(self):
        self.requests: Dict[str, list] = defaultdict(list)
        self.limits = {
            'auth': {'limit': 10, 'window': 60},
            'articles': {'limit': 100, 'window': 3600},
            'general': {'limit': 500, 'window': 300}
        }

    def can_make_request(self, endpoint_type: str) -> bool:
        """İstek yapılıp yapılamayacağını kontrol et"""
        now = time.time()

        if endpoint_type not in self.limits:
            endpoint_type = 'general'

        limit_info = self.limits[endpoint_type]
        window_start = now - limit_info['window']

        # Eski istekleri temizle
        self.requests[endpoint_type] = [
            req_time for req_time in self.requests[endpoint_type]
            if req_time > window_start
        ]

        # Limit kontrolü
        return len(self.requests[endpoint_type]) < limit_info['limit']

    def record_request(self, endpoint_type: str) -> None:
        """İsteği kaydet"""
        if endpoint_type not in self.limits:
            endpoint_type = 'general'

        self.requests[endpoint_type].append(time.time())

    def get_wait_time(self, endpoint_type: str) -> Optional[int]:
        """Bekleme süresini hesapla"""
        if self.can_make_request(endpoint_type):
            return None

        if endpoint_type not in self.limits:
            endpoint_type = 'general'

        limit_info = self.limits[endpoint_type]
        oldest_request = min(self.requests[endpoint_type])
        wait_time = int(oldest_request + limit_info['window'] - time.time())

        return max(0, wait_time)

# Kullanım
rate_limiter = RateLimiter()

def make_api_request(endpoint_type: str):
    if not rate_limiter.can_make_request(endpoint_type):
        wait_time = rate_limiter.get_wait_time(endpoint_type)
        print(f"Rate limit aşıldı. {wait_time} saniye bekleyin.")
        return None

    rate_limiter.record_request(endpoint_type)
    # API çağrısını yap...
    print(f"{endpoint_type} API çağrısı yapıldı")

Error Handling (JavaScript)

class APIError extends Error {
  constructor(message, status, code) {
    super(message);
    this.name = "APIError";
    this.status = status;
    this.code = code;
  }
}

class ErrorHandler {
  static handle(error, response) {
    if (response) {
      switch (response.status) {
        case 400:
          throw new APIError(
            "Geçersiz istek parametreleri",
            400,
            "BAD_REQUEST"
          );
        case 401:
          throw new APIError("Kimlik doğrulama gerekli", 401, "UNAUTHORIZED");
        case 403:
          throw new APIError("Yetkisiz işlem", 403, "FORBIDDEN");
        case 404:
          throw new APIError("Kaynak bulunamadı", 404, "NOT_FOUND");
        case 429:
          throw new APIError("Çok fazla istek", 429, "TOO_MANY_REQUESTS");
        case 500:
          throw new APIError("Sunucu hatası", 500, "INTERNAL_ERROR");
        default:
          throw new APIError(
            `HTTP ${response.status} hatası`,
            response.status,
            "HTTP_ERROR"
          );
      }
    }

    if (error.name === "TypeError" && error.message.includes("fetch")) {
      throw new APIError("Bağlantı hatası", 0, "NETWORK_ERROR");
    }

    throw error;
  }

  static async handleResponse(response) {
    if (!response.ok) {
      let errorData;
      try {
        errorData = await response.json();
      } catch {
        errorData = { message: "Bilinmeyen hata" };
      }

      throw new APIError(
        errorData.message || "API hatası",
        response.status,
        errorData.code || "UNKNOWN_ERROR"
      );
    }

    return response.json();
  }
}

// Kullanım
async function safeAPICall(url, options) {
  try {
    const response = await fetch(url, options);
    return await ErrorHandler.handleResponse(response);
  } catch (error) {
    ErrorHandler.handle(error);
  }
}

🧪 Test Örnekleri

Jest Test Suite (JavaScript)

// finex-api.test.js
import { FinexAPIClient } from "../src/finex-api-client";

describe("FinexAPIClient", () => {
  let client;

  beforeEach(() => {
    client = new FinexAPIClient();
    // Mock fetch
    global.fetch = jest.fn();
  });

  afterEach(() => {
    jest.resetAllMocks();
  });

  describe("Authentication", () => {
    test("should login successfully", async () => {
      const mockResponse = {
        accessToken: "mock-access-token",
        refreshToken: "mock-refresh-token",
        accessTokenExpire: Date.now() + 3600000,
      };

      fetch.mockResolvedValueOnce({
        ok: true,
        json: async () => mockResponse,
      });

      const result = await client.login("test@example.com", "password");

      expect(fetch).toHaveBeenCalledWith(
        "https://integration.seoauthor.ai/api/v1/auth/login",
        expect.objectContaining({
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            email: "test@example.com",
            password: "password",
          }),
        })
      );

      expect(result).toEqual(mockResponse);
      expect(client.accessToken).toBe(mockResponse.accessToken);
    });

    test("should handle login failure", async () => {
      fetch.mockResolvedValueOnce({
        ok: false,
        status: 401,
      });

      await expect(
        client.login("wrong@example.com", "wrongpass")
      ).rejects.toThrow("Login failed: 401");
    });
  });

  describe("Article Operations", () => {
    beforeEach(() => {
      client.accessToken = "mock-token";
    });

    test("should create article", async () => {
      const mockResponse = { success: true, message: "Makale oluşturuldu" };

      fetch.mockResolvedValueOnce({
        ok: true,
        json: async () => mockResponse,
      });

      const result = await client.createArticle("Test Makale", 1, 2);

      expect(fetch).toHaveBeenCalledWith(
        "https://integration.seoauthor.ai/api/v1/makaleler/makale-olustur",
        expect.objectContaining({
          method: "POST",
          headers: {
            Authorization: "Bearer mock-token",
            "Content-Type": "application/json",
          },
          body: JSON.stringify({
            baslik: "Test Makale",
            yazimTonu: 1,
            makaleBoyutu: 2,
          }),
        })
      );

      expect(result).toEqual(mockResponse);
    });
  });
});

PHPUnit Test (PHP)

<?php
use PHPUnit\Framework\TestCase;

class FinexAPIClientTest extends TestCase {
    private $client;

    protected function setUp(): void {
        $this->client = new FinexAPIClient('https://api.test');
    }

    public function testLoginSuccess() {
        // Mock başarılı login
        $mockResponse = [
            'accessToken' => 'mock-access-token',
            'refreshToken' => 'mock-refresh-token',
            'accessTokenExpire' => time() + 3600
        ];

        // HTTP client mock yapılabilir
        // Bu örnekte basit assertion
        $this->assertIsArray($mockResponse);
        $this->assertArrayHasKey('accessToken', $mockResponse);
    }

    public function testCreateArticle() {
        // Makale oluşturma test
        $mockResponse = ['success' => true];

        $this->assertIsArray($mockResponse);
        $this->assertTrue($mockResponse['success']);
    }
}

📱 Framework Entegrasyonları

React Hook

// useFinexAPI.js
import { useState, useEffect, useCallback } from "react";
import { FinexAPIClient } from "./finex-api-client";

export function useFinexAPI() {
  const [client, setClient] = useState(null);
  const [isAuthenticated, setIsAuthenticated] = useState(false);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);

  useEffect(() => {
    setClient(new FinexAPIClient());
  }, []);

  const login = useCallback(
    async (email, password) => {
      if (!client) return;

      setLoading(true);
      setError(null);

      try {
        await client.login(email, password);
        setIsAuthenticated(true);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    },
    [client]
  );

  const createArticle = useCallback(
    async (baslik, yazimTonu, makaleBoyutu) => {
      if (!client || !isAuthenticated) {
        throw new Error("Not authenticated");
      }

      setLoading(true);
      setError(null);

      try {
        const result = await client.createArticle(
          baslik,
          yazimTonu,
          makaleBoyutu
        );
        return result;
      } catch (err) {
        setError(err.message);
        throw err;
      } finally {
        setLoading(false);
      }
    },
    [client, isAuthenticated]
  );

  return {
    login,
    createArticle,
    isAuthenticated,
    loading,
    error,
    client,
  };
}

// Component kullanımı
function ArticleCreator() {
  const { login, createArticle, isAuthenticated, loading, error } =
    useFinexAPI();
  const [articleTitle, setArticleTitle] = useState("");

  const handleCreateArticle = async () => {
    try {
      await createArticle(articleTitle, 1, 2);
      alert("Makale oluşturuldu!");
    } catch (err) {
      alert("Hata: " + err.message);
    }
  };

  if (!isAuthenticated) {
    return (
      <div>
        <button onClick={() => login("email", "password")}>Giriş Yap</button>
      </div>
    );
  }

  return (
    <div>
      <input
        value={articleTitle}
        onChange={(e) => setArticleTitle(e.target.value)}
        placeholder="Makale başlığı"
      />
      <button onClick={handleCreateArticle} disabled={loading}>
        {loading ? "Oluşturuluyor..." : "Makale Oluştur"}
      </button>
      {error && <div>Hata: {error}</div>}
    </div>
  );
}

Laravel Service Provider

<?php
// app/Services/FinexAPIService.php
namespace App\Services;

use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Cache;

class FinexAPIService {
    private $baseUrl;
    private $accessToken;

    public function __construct() {
        $this->baseUrl = config('finex.api_url', 'https://integration.seoauthor.ai');
        $this->accessToken = Cache::get('finex_access_token');
    }

    public function login($email, $password) {
        $response = Http::post($this->baseUrl . '/api/v1/auth/login', [
            'email' => $email,
            'password' => $password
        ]);

        if ($response->successful()) {
            $data = $response->json();

            // Token'ları cache'le
            Cache::put('finex_access_token', $data['accessToken'], 3600);
            Cache::put('finex_refresh_token', $data['refreshToken'], 86400);

            $this->accessToken = $data['accessToken'];

            return $data;
        }

        throw new \Exception('Login failed');
    }

    public function createArticle($baslik, $yazimTonu, $makaleBoyutu) {
        $response = Http::withToken($this->accessToken)
            ->post($this->baseUrl . '/api/v1/makaleler/makale-olustur', [
                'baslik' => $baslik,
                'yazimTonu' => $yazimTonu,
                'makaleBoyutu' => $makaleBoyutu
            ]);

        if ($response->status() === 401) {
            $this->refreshToken();
            // Tekrar dene
            return $this->createArticle($baslik, $yazimTonu, $makaleBoyutu);
        }

        return $response->json();
    }

    private function refreshToken() {
        $refreshToken = Cache::get('finex_refresh_token');

        if (!$refreshToken) {
            throw new \Exception('No refresh token available');
        }

        $response = Http::post($this->baseUrl . '/api/v1/auth/refresh', [
            'refreshToken' => $refreshToken
        ]);

        if ($response->successful()) {
            $data = $response->json();

            Cache::put('finex_access_token', $data['accessToken'], 3600);
            Cache::put('finex_refresh_token', $data['refreshToken'], 86400);

            $this->accessToken = $data['accessToken'];
        }
    }
}

// Controller kullanımı
// app/Http/Controllers/ArticleController.php
class ArticleController extends Controller {
    private $finexAPI;

    public function __construct(FinexAPIService $finexAPI) {
        $this->finexAPI = $finexAPI;
    }

    public function create(Request $request) {
        $request->validate([
            'baslik' => 'required|string|max:255',
            'yazim_tonu' => 'required|integer|between:1,5',
            'makale_boyutu' => 'required|integer|between:1,4'
        ]);

        try {
            $result = $this->finexAPI->createArticle(
                $request->baslik,
                $request->yazim_tonu,
                $request->makale_boyutu
            );

            return response()->json($result);
        } catch (\Exception $e) {
            return response()->json(['error' => $e->getMessage()], 500);
        }
    }
}

Performans İpucu

API çağrılarınızı optimize etmek için connection pooling, caching ve retry mekanizmaları kullanın. Özellikle yüksek trafikli uygulamalarda bu önemlidir.

Test Önerisi

Production'a geçmeden önce tüm API endpoint'lerini test edin. Hem başarılı hem de hata senaryolarını kapsamlı şekilde test etmeyi unutmayın.

Güvenlik Notu

API anahtarlarınızı ve token'larınızı asla version control sistemine commit etmeyin. Environment variables veya güvenli key management sistemleri kullanın.

🌟 Başlangıç Örnekleri​

JavaScript/Node.js​

Temel API Client​

Python​

Comprehensive Python Client​

PHP​

Professional PHP Client​

🔧 Utility Fonksiyonları​

Token Yönetimi (JavaScript)​

Rate Limiting (Python)​

Error Handling (JavaScript)​

🧪 Test Örnekleri​

Jest Test Suite (JavaScript)​

PHPUnit Test (PHP)​

📱 Framework Entegrasyonları​

React Hook​

Laravel Service Provider​