SIGMA API Documentation

<?php

class SigmaAPI {
    private $baseUrl = 'https://sigma.silverday.de/api/v1/';
    private $apiKey;
    
    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
    }
    
    private function makeRequest($endpoint, $method = 'GET', $data = null) {
        $curl = curl_init();
        
        curl_setopt_array($curl, [
            CURLOPT_URL => $this->baseUrl . $endpoint,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_CUSTOMREQUEST => $method,
            CURLOPT_HTTPHEADER => [
                'X-API-Key: ' . $this->apiKey,
                'Content-Type: application/json',
                'Accept: application/json'
            ]
        ]);
        
        if ($data && $method !== 'GET') {
            curl_setopt($curl, CURLOPT_POSTFIELDS, json_encode($data));
        }
        
        $response = curl_exec($curl);
        $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
        curl_close($curl);
        
        return [
            'status' => $httpCode,
            'data' => json_decode($response, true)
        ];
    }
    
    public function getSites($limit = 100) {
        return $this->makeRequest("sites?limit=$limit");
    }
    
    public function getSite($hostname) {
        return $this->makeRequest("sites/" . urlencode($hostname));
    }
    
    public function requestScan($hostname, $force = false) {
        return $this->makeRequest('scan', 'POST', [
            'hostname' => $hostname,
            'force' => $force
        ]);
    }
}

// Usage example
$api = new SigmaAPI('your_api_key_here');
$sites = $api->getSites();

if ($sites['status'] === 200 && $sites['data']['success']) {
    foreach ($sites['data']['data'] as $site) {
        echo "Site: {$site['hostname']} - Grade: {$site['grade']}\n";
    }
}
?>

import requests
import json

class SigmaAPI:
    def __init__(self, api_key):
        self.base_url = 'https://sigma.silverday.de/api/v1/'
        self.headers = {
            'X-API-Key': api_key,
            'Content-Type': 'application/json',
            'Accept': 'application/json'
        }
    
    def get_sites(self, limit=100):
        """Get list of monitored sites"""
        response = requests.get(
            f"{self.base_url}sites",
            headers=self.headers,
            params={'limit': limit}
        )
        return response.json()
    
    def get_site(self, hostname):
        """Get details for specific site"""
        response = requests.get(
            f"{self.base_url}sites/{hostname}",
            headers=self.headers
        )
        return response.json()
    
    def request_scan(self, hostname, force=False):
        """Request new scan for site"""
        data = {
            'hostname': hostname,
            'force': force
        }
        response = requests.post(
            f"{self.base_url}scan",
            headers=self.headers,
            json=data
        )
        return response.json()

# Usage example
api = SigmaAPI('your_api_key_here')

# Get all sites
sites = api.get_sites()
if sites['success']:
    for site in sites['data']:
        print(f"Site: {site['hostname']} - Grade: {site['grade']}")

# Request scan for specific site
scan_result = api.request_scan('example.com')
print(scan_result['message'])

class SigmaAPI {
    constructor(apiKey) {
        this.baseUrl = 'https://sigma.silverday.de/api/v1/';
        this.headers = {
            'X-API-Key': apiKey,
            'Content-Type': 'application/json',
            'Accept': 'application/json'
        };
    }

    async makeRequest(endpoint, options = {}) {
        const url = this.baseUrl + endpoint;
        const config = {
            headers: this.headers,
            ...options
        };

        try {
            const response = await fetch(url, config);
            return await response.json();
        } catch (error) {
            console.error('API request failed:', error);
            throw error;
        }
    }

    async getSites(limit = 100) {
        return await this.makeRequest(`sites?limit=${limit}`);
    }

    async getSite(hostname) {
        return await this.makeRequest(`sites/${encodeURIComponent(hostname)}`);
    }

    async requestScan(hostname, force = false) {
        return await this.makeRequest('scan', {
            method: 'POST',
            body: JSON.stringify({
                hostname: hostname,
                force: force
            })
        });
    }
}

// Usage example
const api = new SigmaAPI('your_api_key_here');

// Get all sites
api.getSites()
    .then(result => {
        if (result.success) {
            result.data.forEach(site => {
                console.log(`Site: ${site.hostname} - Grade: ${site.grade}`);
            });
        }
    })
    .catch(error => console.error('Error:', error));

// Request scan with async/await
async function scanSite(hostname) {
    try {
        const result = await api.requestScan(hostname);
        console.log(result.message);
    } catch (error) {
        console.error('Scan request failed:', error);
    }
}