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

🚀 Продвинутые примеры

Сложные сценарии использования ServerCon API для создания мощных приложений и интеграций.

📊 Дашборд мониторинга в реальном времени​

React компонент с WebSocket подключением​

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

const RealTimeDashboard = ({ serverId }) => {
  const [serverData, setServerData] = useState(null);
  const [isConnected, setIsConnected] = useState(false);

  const fetchServerData = useCallback(async () => {
    try {
      const response = await fetch(`http://138.124.109.53:5000/api/v1/servers/${serverId}`, {
        headers: { 'Authorization': 'Bearer test_key_12345' }
      });
      const data = await response.json();
      if (data.success) {
        setServerData(data.data);
      }
    } catch (error) {
      console.error('Ошибка получения данных сервера:', error);
    }
  }, [serverId]);

  useEffect(() => {
    fetchServerData();
    const interval = setInterval(fetchServerData, 30000);
    return () => clearInterval(interval);
  }, [fetchServerData]);

  if (!serverData) {
    return <div>Загрузка...</div>;
  }

  return (
    <div className="dashboard">
      <div className="server-info">
        <h2>{serverData.name}</h2>
        <div className="stats">
          <div className="stat">
            <span className="label">Игроки:</span>
            <span className="value">{serverData.players.online}/{serverData.players.max}</span>
          </div>
          <div className="stat">
            <span className="label">Статус:</span>
            <span className={`value status-${serverData.status}`}>{serverData.status}</span>
          </div>
        </div>
      </div>
    </div>
  );
};

export default RealTimeDashboard;

🔄 Автоматическое масштабирование серверов​

Node.js сервис для мониторинга​

const axios = require('axios');
const cron = require('node-cron');

class ServerScaler {
  constructor(apiKey, baseUrl = 'http://138.124.109.53:5000') {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
    this.scalingRules = new Map();
  }

  addScalingRule(gameId, minServers, maxServers, targetPlayersPerServer) {
    this.scalingRules.set(gameId, {
      minServers,
      maxServers,
      targetPlayersPerServer
    });
  }

  async getGameServers(gameId) {
    try {
      const response = await axios.get(`${this.baseUrl}/api/v1/servers/game/${gameId}`, {
        headers: { 'Authorization': `Bearer ${this.apiKey}` }
      });
      return response.data;
    } catch (error) {
      console.error('Ошибка получения серверов:', error);
      return null;
    }
  }

  async checkScaling(gameId) {
    const rule = this.scalingRules.get(gameId);
    if (!rule) return;

    const serversData = await this.getGameServers(gameId);
    if (!serversData || !serversData.success) return;

    const servers = serversData.data;
    const onlineServers = servers.filter(s => s.status === 'online');
    const totalPlayers = onlineServers.reduce((sum, s) => sum + s.players.online, 0);
    const avgPlayersPerServer = onlineServers.length > 0 ? totalPlayers / onlineServers.length : 0;

    console.log(`Игра ${gameId}: ${onlineServers.length} серверов, ${totalPlayers} игроков`);

    if (avgPlayersPerServer > rule.targetPlayersPerServer && onlineServers.length < rule.maxServers) {
      console.log(`Нужно добавить серверы для игры ${gameId}`);
    }
  }

  startMonitoring() {
    cron.schedule('*/5 * * * *', async () => {
      console.log('Проверка масштабирования...');
      for (const [gameId] of this.scalingRules) {
        await this.checkScaling(gameId);
      }
    });
    console.log('Мониторинг масштабирования запущен');
  }
}

// Использование
const scaler = new ServerScaler('test_key_12345');
scaler.addScalingRule(30, 2, 10, 50); // Minecraft
scaler.startMonitoring();

🤖 Telegram Bot с аналитикой​

Python Telegram Bot​

import asyncio
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import Application, CommandHandler, CallbackQueryHandler, ContextTypes
import requests

class ServerConBot:
    def __init__(self, api_key, bot_token):
        self.api_key = api_key
        self.bot_token = bot_token
        self.base_url = "http://138.124.109.53:5000"
    
    def get_headers(self):
        return {
            'Authorization': f'Bearer {self.api_key}',
            'Content-Type': 'application/json'
        }
    
    async def start(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        user = update.effective_user
        welcome_text = f"""
🎮 Добро пожаловать в ServerCon Bot, {user.first_name}!

Этот бот поможет вам:
• 📊 Мониторить игровые серверы
• 📈 Получать статистику в реальном времени
• 🔔 Настраивать уведомления

Используйте /help для списка команд.
        """
        
        keyboard = [
            [InlineKeyboardButton("📊 Статистика", callback_data="stats")],
            [InlineKeyboardButton("🎮 Серверы", callback_data="servers")]
        ]
        reply_markup = InlineKeyboardMarkup(keyboard)
        
        await update.message.reply_text(welcome_text, reply_markup=reply_markup)
    
    async def stats_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        try:
            response = requests.get(
                f"{self.base_url}/api/v1/analytics/global",
                headers=self.get_headers()
            )
            response.raise_for_status()
            data = response.json()
            
            if data['success']:
                stats = data['data']
                stats_text = f"""
📊 Глобальная статистика ServerCon:

🎮 Всего игр: {stats.get('total_games', 'N/A')}
🖥️ Всего серверов: {stats.get('total_servers', 'N/A')}
👥 Игроков онлайн: {stats.get('total_players', 'N/A')}
                """
                await update.message.reply_text(stats_text)
            else:
                await update.message.reply_text("❌ Ошибка получения статистики")
                
        except Exception as e:
            await update.message.reply_text("❌ Ошибка получения статистики")
    
    def run(self):
        application = Application.builder().token(self.bot_token).build()
        application.add_handler(CommandHandler("start", self.start))
        application.add_handler(CommandHandler("stats", self.stats_command))
        application.run_polling()

# Использование
if __name__ == '__main__':
    bot = ServerConBot('test_key_12345', 'YOUR_BOT_TOKEN')
    bot.run()

🔄 Система уведомлений​

Node.js сервис для отправки уведомлений​

const axios = require('axios');
const nodemailer = require('nodemailer');
const cron = require('node-cron');

class NotificationService {
  constructor(apiKey, emailConfig) {
    this.apiKey = apiKey;
    this.baseUrl = 'http://138.124.109.53:5000';
    this.subscribers = new Map();
    this.lastStatus = new Map();
    
    this.transporter = nodemailer.createTransporter({
      host: emailConfig.host,
      port: emailConfig.port,
      secure: emailConfig.secure,
      auth: {
        user: emailConfig.user,
        pass: emailConfig.pass
      }
    });
  }

  subscribe(serverId, email, notificationTypes = ['status_change']) {
    if (!this.subscribers.has(serverId)) {
      this.subscribers.set(serverId, []);
    }
    
    this.subscribers.get(serverId).push({
      email,
      notificationTypes,
      subscribedAt: new Date()
    });
  }

  async checkStatusChanges() {
    for (const [serverId, subscribers] of this.subscribers) {
      if (subscribers.length === 0) continue;
      
      try {
        const response = await axios.get(`${this.baseUrl}/api/v1/servers/${serverId}`, {
          headers: { 'Authorization': `Bearer ${this.apiKey}` }
        });
        
        if (response.data.success) {
          const serverData = response.data.data;
          const currentStatus = serverData.status;
          const lastStatus = this.lastStatus.get(serverId);
          
          if (lastStatus && lastStatus !== currentStatus) {
            await this.sendStatusChangeNotification(serverId, serverData, lastStatus, currentStatus);
          }
          
          this.lastStatus.set(serverId, currentStatus);
        }
      } catch (error) {
        console.error(`Ошибка проверки сервера ${serverId}:`, error);
      }
    }
  }

  async sendStatusChangeNotification(serverId, serverData, oldStatus, newStatus) {
    const subscribers = this.subscribers.get(serverId);
    
    for (const subscriber of subscribers) {
      const mailOptions = {
        from: 'noreply@servercon.com',
        to: subscriber.email,
        subject: `Изменение статуса сервера ${serverData.name}`,
        html: `
          <h2>Изменение статуса сервера</h2>
          <p><strong>Сервер:</strong> ${serverData.name}</p>
          <p><strong>Статус:</strong> ${oldStatus} → ${newStatus}</p>
          <p><strong>Игроки:</strong> ${serverData.players.online}/${serverData.players.max}</p>
        `
      };
      
      try {
        await this.transporter.sendMail(mailOptions);
        console.log(`Уведомление отправлено ${subscriber.email}`);
      } catch (error) {
        console.error(`Ошибка отправки email:`, error);
      }
    }
  }

  startMonitoring() {
    cron.schedule('* * * * *', async () => {
      console.log('Проверка изменений статуса...');
      await this.checkStatusChanges();
    });
    
    console.log('Сервис уведомлений запущен');
  }
}

// Использование
const notificationService = new NotificationService('test_key_12345', {
  host: 'smtp.gmail.com',
  port: 587,
  secure: false,
  user: 'your-email@gmail.com',
  pass: 'your-app-password'
});

notificationService.subscribe(12345, 'user@example.com');
notificationService.startMonitoring();

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

Совет

Эти примеры показывают, как можно создать мощные приложения с использованием ServerCon API. Адаптируйте их под ваши нужды!