Kullanım Örnekleri

SignaPort API kullanımı için pratik örnekler.

Temel İmzalama

JavaScript

async function signDocument(xmlContent) {
  // 1. Token al
  const tokenResponse = await fetch('https://api.signaport.com/api/v1/auth/get-token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      licenseKey: 'TEST-KEY-12345',
      password: 'your-password',
      imzaTipi: 0
    })
  });
  
  const { signToken } = await tokenResponse.json();
  
  // 2. SignaPort'a gönder
  const signResponse = await fetch('http://localhost:4741/api/sign', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      data: JSON.stringify({
        SignMethod: 0,
        Data: JSON.stringify({
          Token: signToken,
          PinCode: '',
          XmlFile: [xmlContent]
        })
      })
    })
  });
  
  const result = await signResponse.json();
  
  if (result.result === 'success') {
    return result.signedContent['0'];
  } else {
    throw new Error(result.message);
  }
}

// Kullanım
const xml = '<ereceteBilgisi>...</ereceteBilgisi>';
const signedXml = await signDocument(xml);
console.log('İmzalı XML:', signedXml);

C#

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class SignaPortClient
{
    private readonly HttpClient _client;
    private const string API_URL = "https://api.signaport.com";
    
    public SignaPortClient()
    {
        _client = new HttpClient();
    }
    
    public async Task<string> SignDocument(string xmlContent)
    {
        // 1. Token al
        var tokenRequest = new
        {
            licenseKey = "TEST-KEY-12345",
            password = "your-password",
            imzaTipi = 0
        };
        
        var tokenResponse = await _client.PostAsync(
            $"{API_URL}/api/v1/auth/get-token",
            new StringContent(JsonConvert.SerializeObject(tokenRequest), Encoding.UTF8, "application/json")
        );
        
        var tokenData = JsonConvert.DeserializeObject<dynamic>(
            await tokenResponse.Content.ReadAsStringAsync()
        );
        
        string signToken = tokenData.signToken;
        
        // 2. SignaPort'a gönder
        var signRequest = new
        {
            data = JsonConvert.SerializeObject(new
            {
                SignMethod = 0,
                Data = JsonConvert.SerializeObject(new
                {
                    Token = signToken,
                    PinCode = "",
                    XmlFile = new[] { xmlContent }
                })
            })
        };
        
        var signResponse = await _client.PostAsync(
            "http://localhost:4741/api/sign",
            new StringContent(JsonConvert.SerializeObject(signRequest), Encoding.UTF8, "application/json")
        );
        
        var result = JsonConvert.DeserializeObject<dynamic>(
            await signResponse.Content.ReadAsStringAsync()
        );
        
        if (result.result == "success")
        {
            return result.signedContent["0"];
        }
        
        throw new Exception(result.message.ToString());
    }
}

// Kullanım
var client = new SignaPortClient();
var xml = "<ereceteBilgisi>...</ereceteBilgisi>";
var signedXml = await client.SignDocument(xml);
Console.WriteLine("İmzalı XML: " + signedXml);

Toplu İmzalama

JavaScript

async function signMultipleDocuments(xmlList) {
  const results = [];
  
  for (const xml of xmlList) {
    try {
      // Her XML için yeni token al
      const tokenResponse = await fetch('https://api.signaport.com/api/v1/auth/get-token', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          licenseKey: 'TEST-KEY-12345',
          password: 'your-password',
          imzaTipi: 0
        })
      });
      
      const { signToken } = await tokenResponse.json();
      
      // İmzala
      const signResponse = await fetch('http://localhost:4741/api/sign', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          data: JSON.stringify({
            SignMethod: 0,
            Data: JSON.stringify({
              Token: signToken,
              PinCode: '',
              XmlFile: [xml]
            })
          })
        })
      });
      
      const result = await signResponse.json();
      results.push({
        xml: xml.substring(0, 50) + '...',
        success: result.result === 'success',
        signedContent: result.signedContent ? result.signedContent['0'] : null,
        error: result.message
      });
      
    } catch (error) {
      results.push({
        xml: xml.substring(0, 50) + '...',
        success: false,
        error: error.message
      });
    }
  }
  
  return results;
}

// Kullanım
const xmlList = [
  '<ereceteBilgisi>...1</ereceteBilgisi>',
  '<ereceteBilgisi>...2</ereceteBilgisi>',
  '<ereceteBilgisi>...3</ereceteBilgisi>'
];

const results = await signMultipleDocuments(xmlList);
console.log(`Toplam: ${results.length}`);
console.log(`Başarılı: ${results.filter(r => r.success).length}`);
console.log(`Başarısız: ${results.filter(r => !r.success).length}`);

Kontör Takibi

JavaScript

async function checkQuotaBeforeSigning(xmlContent) {
  // 1. Kontör kontrol et
  const quotaResponse = await fetch(
    'https://api.signaport.com/api/license/check-quota/TEST-KEY-12345'
  );
  
  const quota = await quotaResponse.json();
  
  // 2. Uyarı ver
  if (quota.remainingQuota < 10) {
    console.warn(`Kontörünüz azaldı! Kalan: ${quota.remainingQuota}`);
  }
  
  if (quota.remainingQuota === 0) {
    throw new Error('Kontör bitmiş! Yeni paket satın alınız.');
  }
  
  // 3. İmzala
  const signedXml = await signDocument(xmlContent);
  
  // 4. Güncel durumu göster
  console.log(`İmza başarılı. Kalan kontör: ${quota.remainingQuota - 1}`);
  
  return signedXml;
}

// Kullanım
const xml = '<ereceteBilgisi>...</ereceteBilgisi>';
const signed = await checkQuotaBeforeSigning(xml);

C#

public async Task<QuotaInfo> GetQuotaInfo(string licenseKey)
{
    var response = await _client.GetAsync(
        $"{API_URL}/api/license/check-quota/{licenseKey}"
    );
    
    var data = JsonConvert.DeserializeObject<QuotaInfo>(
        await response.Content.ReadAsStringAsync()
    );
    
    return data;
}

public async Task<string> SignWithQuotaCheck(string xml)
{
    // Kontör kontrol
    var quota = await GetQuotaInfo("TEST-KEY-12345");
    
    if (quota.RemainingQuota < 10)
    {
        Console.WriteLine($"UYARI: Kontör azaldı! Kalan: {quota.RemainingQuota}");
    }
    
    if (quota.RemainingQuota == 0)
    {
        throw new Exception("Kontör bitmiş!");
    }
    
    // İmzala
    return await SignDocument(xml);
}

public class QuotaInfo
{
    public bool Success { get; set; }
    public string FirmaId { get; set; }
    public string FirmaAdi { get; set; }
    public int TotalPurchased { get; set; }
    public int TotalUsed { get; set; }
    public int RemainingQuota { get; set; }
    public int MedulaUsed { get; set; }
    public int IbysUsed { get; set; }
    public bool IsActive { get; set; }
}

Hata Yönetimi

JavaScript

async function signWithErrorHandling(xmlContent) {
  try {
    // Token al
    const tokenResponse = await fetch('https://api.signaport.com/api/v1/auth/get-token', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        licenseKey: 'TEST-KEY-12345',
        password: 'your-password',
        imzaTipi: 0
      })
    });
    
    if (!tokenResponse.ok) {
      const error = await tokenResponse.json();
      
      if (error.error && error.error.code === 'INSUFFICIENT_QUOTA') {
        alert('Kontör bitmiş! Yeni paket satın alınız.');
        return null;
      }
      
      throw new Error(error.message || 'Token alınamadı');
    }
    
    const { signToken } = await tokenResponse.json();
    
    // İmzala
    const signResponse = await fetch('http://localhost:4741/api/sign', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        data: JSON.stringify({
          SignMethod: 0,
          Data: JSON.stringify({
            Token: signToken,
            PinCode: '',
            XmlFile: [xmlContent]
          })
        })
      })
    });
    
    const result = await signResponse.json();
    
    if (result.result !== 'success') {
      if (result.message.includes('kotası doldu')) {
        alert('İmza hakkınız bitmiştir!');
        return null;
      }
      
      throw new Error(result.message);
    }
    
    return result.signedContent['0'];
    
  } catch (error) {
    console.error('İmzalama hatası:', error);
    alert('İmzalama sırasında hata oluştu: ' + error.message);
    return null;
  }
}

// Kullanım
const xml = '<ereceteBilgisi>...</ereceteBilgisi>';
const signed = await signWithErrorHandling(xml);

if (signed) {
  console.log('İmza başarılı');
} else {
  console.log('İmza başarısız');
}

Retry Mekanizması

JavaScript

async function signWithRetry(xmlContent, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      console.log(`Deneme ${attempt}/${maxRetries}`);
      
      const signed = await signDocument(xmlContent);
      return signed;
      
    } catch (error) {
      // Retry yapılmaması gereken hatalar
      const noRetryErrors = [
        'Token süresi dolmuş',
        'zaten kullanılmış',
        'kotası doldu',
        'Geçersiz lisans'
      ];
      
      if (noRetryErrors.some(e => error.message.includes(e))) {
        console.error('Retry yapılamaz hata:', error.message);
        throw error;
      }
      
      // Son deneme
      if (attempt === maxRetries) {
        console.error('Tüm denemeler başarısız');
        throw error;
      }
      
      // Exponential backoff
      const delay = 1000 * Math.pow(2, attempt - 1);
      console.log(`${delay}ms bekleyip tekrar denenecek...`);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

// Kullanım
const xml = '<ereceteBilgisi>...</ereceteBilgisi>';
const signed = await signWithRetry(xml);

React Kullanımı

import React, { useState } from 'react';

function SignButton({ xmlContent }) {
  const [signing, setSigning] = useState(false);
  const [error, setError] = useState(null);
  const [signedXml, setSignedXml] = useState(null);
  
  const handleSign = async () => {
    setSigning(true);
    setError(null);
    
    try {
      // Token al
      const tokenRes = await fetch('https://api.signaport.com/api/v1/auth/get-token', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          licenseKey: process.env.REACT_APP_LICENSE_KEY,
          password: process.env.REACT_APP_LICENSE_PASSWORD,
          imzaTipi: 0
        })
      });
      
      const { signToken } = await tokenRes.json();
      
      // İmzala
      const signRes = await fetch('http://localhost:4741/api/sign', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          data: JSON.stringify({
            SignMethod: 0,
            Data: JSON.stringify({
              Token: signToken,
              PinCode: '',
              XmlFile: [xmlContent]
            })
          })
        })
      });
      
      const result = await signRes.json();
      
      if (result.result === 'success') {
        setSignedXml(result.signedContent['0']);
      } else {
        throw new Error(result.message);
      }
      
    } catch (err) {
      setError(err.message);
    } finally {
      setSigning(false);
    }
  };
  
  return (
    <div>
      <button onClick={handleSign} disabled={signing}>
        {signing ? 'İmzalanıyor...' : 'İmzala'}
      </button>
      
      {error && <div style={{color: 'red'}}>{error}</div>}
      {signedXml && <div style={{color: 'green'}}>İmza başarılı!</div>}
    </div>
  );
}

export default SignButton;

PHP Kullanımı

<?php

class SignaPortClient {
    private $apiUrl = 'https://api.signaport.com';
    private $licenseKey;
    private $password;
    
    public function __construct($licenseKey, $password) {
        $this->licenseKey = $licenseKey;
        $this->password = $password;
    }
    
    public function signDocument($xmlContent, $imzaTipi = 0) {
        // Token al
        $tokenData = $this->getToken($imzaTipi);
        $signToken = $tokenData['signToken'];
        
        // SignaPort'a gönder
        $signRequest = [
            'data' => json_encode([
                'SignMethod' => 0,
                'Data' => json_encode([
                    'Token' => $signToken,
                    'PinCode' => '',
                    'XmlFile' => [$xmlContent]
                ])
            ])
        ];
        
        $ch = curl_init('http://localhost:4741/api/sign');
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($signRequest));
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
        
        $response = curl_exec($ch);
        curl_close($ch);
        
        $result = json_decode($response, true);
        
        if ($result['result'] === 'success') {
            return $result['signedContent']['0'];
        }
        
        throw new Exception($result['message']);
    }
    
    private function getToken($imzaTipi) {
        $data = [
            'licenseKey' => $this->licenseKey,
            'password' => $this->password,
            'imzaTipi' => $imzaTipi
        ];
        
        $ch = curl_init($this->apiUrl . '/api/v1/auth/get-token');
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
        
        $response = curl_exec($ch);
        curl_close($ch);
        
        return json_decode($response, true);
    }
}

// Kullanım
$client = new SignaPortClient('TEST-KEY-12345', 'your-password');
$xml = '<ereceteBilgisi>...</ereceteBilgisi>';

try {
    $signedXml = $client->signDocument($xml);
    echo "İmza başarılı!";
} catch (Exception $e) {
    echo "Hata: " . $e->getMessage();
}

?>