Перейти к основному содержимому

💡 Примеры использования

Практические примеры интеграции ServerCon API в различные проекты и платформы.

🚀 Быстрый старт​

1️⃣ Получите API ключ​

Используйте тестовый ключ test_key_12345 или получите свой в личном кабинете.

2️⃣ Сделайте первый запрос​

curl -H "Authorization: Bearer test_key_12345" \
     http://138.124.109.53:5000/api/v1/servers?limit=5

3️⃣ Изучите ответ​

{
  "success": true,
  "data": [
    {
      "id": 12345,
      "name": "Мой сервер",
      "game_id": 30,
      "game_name": "Minecraft",
      "players": {
        "online": 45,
        "max": 100
      },
      "status": "online"
    }
  ]
}

🟨 JavaScript/Node.js​

Базовый класс для работы с API​

class ServerConAPI {
  constructor(apiKey, baseUrl = 'http://138.124.109.53:5000') {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
  }

  async request(endpoint, options = {}) {
    const url = `${this.baseUrl}${endpoint}`;
    const headers = {
      'Authorization': `Bearer ${this.apiKey}`,
      'Content-Type': 'application/json',
      ...options.headers
    };

    try {
      const response = await fetch(url, {
        ...options,
        headers
      });

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

      return await response.json();
    } catch (error) {
      console.error('API Error:', error);
      throw error;
    }
  }

  // Получить все серверы
  async getServers(params = {}) {
    const query = new URLSearchParams(params).toString();
    return this.request(`/api/v1/servers${query ? '?' + query : ''}`);
  }

  // Получить сервер по ID
  async getServer(serverId) {
    return this.request(`/api/v1/servers/${serverId}`);
  }

  // Получить серверы по игре
  async getServersByGame(gameId, params = {}) {
    return this.request(`/api/v1/servers/game/${gameId}`, {
      method: 'GET',
      ...params
    });
  }

  // Получить статистику сервера
  async getServerStats(serverId) {
    return this.request(`/api/v1/analytics/server/${serverId}`);
  }
}

// Использование
const api = new ServerConAPI(process.env.SERVERCON_API_KEY);

async function example() {
  try {
    const servers = await api.getServers({ game_id: 30, limit: 10 });
    console.log('Minecraft серверы:', servers.data);
  } catch (error) {
    console.error('Ошибка получения серверов:', error);
  }
}

React компонент для отображения серверов​

import React, { useState, useEffect } from 'react';

function ServerList({ gameId = 30 }) {
  const [servers, setServers] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    async function fetchServers() {
      try {
        setLoading(true);
        const response = await fetch(
          `http://138.124.109.53:5000/api/v1/servers/game/${gameId}?limit=20`,
          {
            headers: {
              'Authorization': 'Bearer test_key_12345',
              'Content-Type': 'application/json'
            }
          }
        );
        
        if (!response.ok) {
          throw new Error(`HTTP ${response.status}`);
        }
        
        const data = await response.json();
        setServers(data.data);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    }

    fetchServers();
  }, [gameId]);

  if (loading) return <div>Загрузка...</div>;
  if (error) return <div>Ошибка: {error}</div>;

  return (
    <div className="server-list">
      <h2>Серверы игры</h2>
      {servers.map(server => (
        <div key={server.id} className="server-card">
          <h3>{server.name}</h3>
          <p>Игроков: {server.players.online}/{server.players.max}</p>
          <p>Статус: {server.status}</p>
          <p>IP: {server.ip}:{server.port}</p>
        </div>
      ))}
    </div>
  );
}

export default ServerList;

Next.js API Route​

// pages/api/servers.js
export default async function handler(req, res) {
  const { game_id, limit = 20 } = req.query;
  
  try {
    const response = await fetch(
      `http://138.124.109.53:5000/api/v1/servers/game/${game_id}?limit=${limit}`,
      {
        headers: {
          'Authorization': `Bearer ${process.env.SERVERCON_API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }
    
    const data = await response.json();
    res.status(200).json(data);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
}

🐍 Python​

Базовый класс для работы с API​

import requests
import os
from typing import Dict, Any, Optional

class ServerConAPI:
    def __init__(self, api_key: str, base_url: str = "http://138.124.109.53:5000"):
        self.api_key = api_key
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        })
    
    def request(self, endpoint: str, method: str = 'GET', **kwargs) -> Dict[Any, Any]:
        url = f"{self.base_url}{endpoint}"
        
        try:
            response = self.session.request(method, url, **kwargs)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"API Error: {e}")
            raise
    
    def get_servers(self, **params) -> Dict[Any, Any]:
        return self.request('/api/v1/servers', params=params)
    
    def get_server(self, server_id: int) -> Dict[Any, Any]:
        return self.request(f'/api/v1/servers/{server_id}')
    
    def get_servers_by_game(self, game_id: int, **params) -> Dict[Any, Any]:
        return self.request(f'/api/v1/servers/game/{game_id}', params=params)
    
    def get_server_stats(self, server_id: int) -> Dict[Any, Any]:
        return self.request(f'/api/v1/analytics/server/{server_id}')

# Использование
api = ServerConAPI(os.getenv('SERVERCON_API_KEY'))

try:
    servers = api.get_servers_by_game(game_id=30, limit=10)
    print("Minecraft серверы:", servers['data'])
except Exception as e:
    print(f"Ошибка: {e}")

Flask приложение​

from flask import Flask, jsonify, request
import requests

app = Flask(__name__)

class ServerConAPI:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "http://138.124.109.53:5000"
    
    def get_servers(self, game_id=None, limit=20):
        url = f"{self.base_url}/api/v1/servers"
        params = {'limit': limit}
        if game_id:
            params['game_id'] = game_id
        
        response = requests.get(url, params=params, headers={
            'Authorization': f'Bearer {self.api_key}'
        })
        response.raise_for_status()
        return response.json()

api = ServerConAPI('test_key_12345')

@app.route('/api/servers')
def get_servers():
    game_id = request.args.get('game_id', type=int)
    limit = request.args.get('limit', 20, type=int)
    
    try:
        data = api.get_servers(game_id=game_id, limit=limit)
        return jsonify(data)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(debug=True)

Django view​

from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
import requests
import json

@csrf_exempt
def get_servers(request):
    if request.method == 'GET':
        game_id = request.GET.get('game_id')
        limit = request.GET.get('limit', 20)
        
        url = "http://138.124.109.53:5000/api/v1/servers"
        params = {'limit': limit}
        if game_id:
            params['game_id'] = game_id
        
        try:
            response = requests.get(url, params=params, headers={
                'Authorization': 'Bearer test_key_12345'
            })
            response.raise_for_status()
            return JsonResponse(response.json())
        except Exception as e:
            return JsonResponse({'error': str(e)}, status=500)
    
    return JsonResponse({'error': 'Method not allowed'}, status=405)

💻 PHP​

Базовый класс для работы с API​

<?php
class ServerConAPI {
    private $apiKey;
    private $baseUrl;
    
    public function __construct($apiKey, $baseUrl = 'http://138.124.109.53:5000') {
        $this->apiKey = $apiKey;
        $this->baseUrl = $baseUrl;
    }
    
    private function request($endpoint, $method = 'GET', $params = []) {
        $url = $this->baseUrl . $endpoint;
        
        $headers = [
            'Authorization: Bearer ' . $this->apiKey,
            'Content-Type: application/json'
        ];
        
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
        
        if ($method === 'POST' && !empty($params)) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($params));
        }
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);
        
        if ($httpCode >= 400) {
            throw new Exception("HTTP $httpCode: $response");
        }
        
        return json_decode($response, true);
    }
    
    public function getServers($params = []) {
        $query = http_build_query($params);
        $endpoint = '/api/v1/servers' . ($query ? '?' . $query : '');
        return $this->request($endpoint);
    }
    
    public function getServer($serverId) {
        return $this->request("/api/v1/servers/$serverId");
    }
    
    public function getServersByGame($gameId, $params = []) {
        $query = http_build_query($params);
        $endpoint = "/api/v1/servers/game/$gameId" . ($query ? '?' . $query : '');
        return $this->request($endpoint);
    }
}

// Использование
$api = new ServerConAPI('test_key_12345');

try {
    $servers = $api->getServersByGame(30, ['limit' => 10]);
    echo "Minecraft серверы: " . json_encode($servers['data']);
} catch (Exception $e) {
    echo "Ошибка: " . $e->getMessage();
}
?>

WordPress плагин​

<?php
// WordPress плагин для отображения серверов
class ServerConWidget extends WP_Widget {
    public function __construct() {
        parent::__construct(
            'servercon_widget',
            'ServerCon Серверы',
            array('description' => 'Отображает список серверов из ServerCon API')
        );
    }
    
    public function widget($args, $instance) {
        $game_id = $instance['game_id'] ?? 30;
        $limit = $instance['limit'] ?? 10;
        
        $servers = $this->get_servers($game_id, $limit);
        
        if ($servers && $servers['success']) {
            echo $args['before_widget'];
            echo $args['before_title'] . 'Серверы' . $args['after_title'];
            
            echo '<ul>';
            foreach ($servers['data'] as $server) {
                echo '<li>';
                echo '<strong>' . esc_html($server['name']) . '</strong><br>';
                echo 'Игроков: ' . $server['players']['online'] . '/' . $server['players']['max'] . '<br>';
                echo 'Статус: ' . $server['status'];
                echo '</li>';
            }
            echo '</ul>';
            
            echo $args['after_widget'];
        }
    }
    
    private function get_servers($game_id, $limit) {
        $response = wp_remote_get(
            "http://138.124.109.53:5000/api/v1/servers/game/$game_id?limit=$limit",
            array(
                'headers' => array(
                    'Authorization' => 'Bearer test_key_12345'
                )
            )
        );
        
        if (is_wp_error($response)) {
            return false;
        }
        
        return json_decode(wp_remote_retrieve_body($response), true);
    }
}

// Регистрация виджета
add_action('widgets_init', function() {
    register_widget('ServerConWidget');
});
?>

🤖 Discord Bot (Python)​

import discord
from discord.ext import commands
import requests

class ServerConBot(commands.Bot):
    def __init__(self):
        intents = discord.Intents.default()
        intents.message_content = True
        super().__init__(command_prefix='!', intents=intents)
    
    async def on_ready(self):
        print(f'{self.user} подключен!')
    
    @commands.command(name='server')
    async def get_server(self, ctx, server_id: int):
        """Получить информацию о сервере по ID"""
        try:
            response = requests.get(
                f'http://138.124.109.53:5000/api/v1/servers/{server_id}',
                headers={'Authorization': 'Bearer test_key_12345'}
            )
            response.raise_for_status()
            data = response.json()
            
            if data['success']:
                server = data['data']
                embed = discord.Embed(
                    title=server['name'],
                    color=0x00ff00 if server['status'] == 'online' else 0xff0000
                )
                embed.add_field(name='Игра', value=server['game_name'], inline=True)
                embed.add_field(name='Игроки', value=f"{server['players']['online']}/{server['players']['max']}", inline=True)
                embed.add_field(name='Статус', value=server['status'], inline=True)
                embed.add_field(name='IP', value=f"{server['ip']}:{server['port']}", inline=False)
                
                await ctx.send(embed=embed)
            else:
                await ctx.send('Сервер не найден!')
                
        except Exception as e:
            await ctx.send(f'Ошибка: {e}')
    
    @commands.command(name='servers')
    async def get_servers(self, ctx, game_id: int = 30, limit: int = 10):
        """Получить список серверов по игре"""
        try:
            response = requests.get(
                f'http://138.124.109.53:5000/api/v1/servers/game/{game_id}?limit={limit}',
                headers={'Authorization': 'Bearer test_key_12345'}
            )
            response.raise_for_status()
            data = response.json()
            
            if data['success']:
                servers = data['data']
                embed = discord.Embed(
                    title=f'Серверы игры (ID: {game_id})',
                    color=0x0099ff
                )
                
                for server in servers[:5]:  # Показываем только первые 5
                    embed.add_field(
                        name=server['name'],
                        value=f"Игроков: {server['players']['online']}/{server['players']['max']} | Статус: {server['status']}",
                        inline=False
                    )
                
                await ctx.send(embed=embed)
            else:
                await ctx.send('Серверы не найдены!')
                
        except Exception as e:
            await ctx.send(f'Ошибка: {e}')

# Запуск бота
bot = ServerConBot()
bot.run('YOUR_BOT_TOKEN')

📱 Мобильное приложение (React Native)​

import React, { useState, useEffect } from 'react';
import { View, Text, FlatList, StyleSheet, TouchableOpacity } from 'react-native';

const ServerList = () => {
  const [servers, setServers] = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetchServers();
  }, []);

  const fetchServers = async () => {
    try {
      const response = await fetch(
        'http://138.124.109.53:5000/api/v1/servers?limit=20',
        {
          headers: {
            'Authorization': 'Bearer test_key_12345',
            'Content-Type': 'application/json'
          }
        }
      );
      
      const data = await response.json();
      if (data.success) {
        setServers(data.data);
      }
    } catch (error) {
      console.error('Ошибка загрузки серверов:', error);
    } finally {
      setLoading(false);
    }
  };

  const renderServer = ({ item }) => (
    <TouchableOpacity style={styles.serverCard}>
      <Text style={styles.serverName}>{item.name}</Text>
      <Text style={styles.serverInfo}>
        {item.game_name} | {item.players.online}/{item.players.max} игроков
      </Text>
      <Text style={styles.serverStatus}>
        Статус: {item.status}
      </Text>
    </TouchableOpacity>
  );

  if (loading) {
    return (
      <View style={styles.container}>
        <Text>Загрузка...</Text>
      </View>
    );
  }

  return (
    <View style={styles.container}>
      <FlatList
        data={servers}
        renderItem={renderServer}
        keyExtractor={(item) => item.id.toString()}
        showsVerticalScrollIndicator={false}
      />
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    padding: 16,
    backgroundColor: '#f5f5f5'
  },
  serverCard: {
    backgroundColor: 'white',
    padding: 16,
    marginBottom: 8,
    borderRadius: 8,
    shadowColor: '#000',
    shadowOffset: { width: 0, height: 2 },
    shadowOpacity: 0.1,
    shadowRadius: 4,
    elevation: 3
  },
  serverName: {
    fontSize: 18,
    fontWeight: 'bold',
    marginBottom: 4
  },
  serverInfo: {
    fontSize: 14,
    color: '#666',
    marginBottom: 2
  },
  serverStatus: {
    fontSize: 12,
    color: '#999'
  }
});

export default ServerList;

🔄 Обработка ошибок и retry логика​

class ServerConAPIWithRetry {
  constructor(apiKey, baseUrl = 'http://138.124.109.53:5000') {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
    this.maxRetries = 3;
    this.retryDelay = 1000; // 1 секунда
  }

  async requestWithRetry(endpoint, options = {}) {
    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
      try {
        const response = await this.request(endpoint, options);
        return response;
      } catch (error) {
        if (attempt === this.maxRetries) {
          throw error;
        }

        // Проверяем, стоит ли повторять запрос
        if (this.shouldRetry(error)) {
          const delay = this.retryDelay * Math.pow(2, attempt - 1);
          await this.sleep(delay);
          continue;
        }

        throw error;
      }
    }
  }

  shouldRetry(error) {
    // Повторяем запрос для временных ошибок
    return error.status >= 500 || error.status === 429;
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  async request(endpoint, options = {}) {
    const url = `${this.baseUrl}${endpoint}`;
    const headers = {
      'Authorization': `Bearer ${this.apiKey}`,
      'Content-Type': 'application/json',
      ...options.headers
    };

    const response = await fetch(url, {
      ...options,
      headers
    });

    if (!response.ok) {
      const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
      error.status = response.status;
      throw error;
    }

    return await response.json();
  }
}

📊 Кэширование и оптимизация​

class ServerConAPICached {
  constructor(apiKey, baseUrl = 'http://138.124.109.53:5000') {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
    this.cache = new Map();
    this.cacheTimeout = 5 * 60 * 1000; // 5 минут
  }

  async getCachedServers(gameId, params = {}) {
    const cacheKey = `servers_${gameId}_${JSON.stringify(params)}`;
    
    if (this.cache.has(cacheKey)) {
      const cached = this.cache.get(cacheKey);
      if (Date.now() - cached.timestamp < this.cacheTimeout) {
        return cached.data;
      }
    }

    const data = await this.request(`/api/v1/servers/game/${gameId}`, {
      method: 'GET',
      ...params
    });

    this.cache.set(cacheKey, {
      data,
      timestamp: Date.now()
    });

    return data;
  }

  clearCache() {
    this.cache.clear();
  }

  // ... остальные методы
}

🔜 Следующие шаги​

Совет

Начните с простых примеров и постепенно переходите к более сложным интеграциям!