blockmine 1.22.0 → 1.23.0

package/backend/src/api/routes/proxies.js

@@ -0,0 +1,130 @@
+const express = require('express');
+const router = express.Router();
+const { PrismaClient } = require('@prisma/client');
+const { authenticateUniversal, authorize } = require('../middleware/auth');
+const prisma = new PrismaClient();
+
+router.use(authenticateUniversal);
+
+router.get('/', authorize('proxy:list'), async (req, res) => {
+    try {
+        const proxies = await prisma.proxy.findMany({
+            orderBy: { name: 'asc' },
+            include: {
+                _count: {
+                    select: { bots: true }
+                }
+            }
+        });
+        res.json({
+            items: proxies,
+            total: proxies.length
+        });
+    } catch (error) {
+        console.error("[API /api/proxies] Ошибка получения списка прокси:", error);
+        res.status(500).json({ error: 'Не удалось получить список прокси' });
+    }
+});
+
+router.get('/:id', authorize('proxy:list'), async (req, res) => {
+    try {
+        const proxyId = parseInt(req.params.id, 10);
+        const proxy = await prisma.proxy.findUnique({
+            where: { id: proxyId },
+            include: {
+                _count: {
+                    select: { bots: true }
+                }
+            }
+        });
+        if (!proxy) {
+            return res.status(404).json({ error: 'Прокси не найден' });
+        }
+        res.json(proxy);
+    } catch (error) {
+        console.error("[API /api/proxies/:id] Ошибка получения прокси:", error);
+        res.status(500).json({ error: 'Не удалось получить прокси' });
+    }
+});
+
+router.post('/', authorize('proxy:create'), async (req, res) => {
+    try {
+        const { name, type, host, port, username, password, note } = req.body;
+        if (!name || !host || !port) {
+            return res.status(400).json({ error: 'Имя, хост и порт прокси обязательны' });
+        }
+        if (type && !['socks5', 'http'].includes(type)) {
+            return res.status(400).json({ error: 'Тип прокси должен быть socks5 или http' });
+        }
+        const newProxy = await prisma.proxy.create({
+            data: {
+                name,
+                type: type || 'socks5',
+                host,
+                port: parseInt(port, 10),
+                username: username || null,
+                password: password || null,
+                note: note || null
+            },
+        });
+        res.status(201).json(newProxy);
+    } catch (error) {
+        if (error.code === 'P2002') return res.status(409).json({ error: 'Прокси с таким именем уже существует' });
+        console.error("[API /api/proxies] Ошибка создания прокси:", error);
+        res.status(500).json({ error: 'Не удалось создать прокси' });
+    }
+});
+
+router.put('/:id', authorize('proxy:create'), async (req, res) => {
+    try {
+        const proxyId = parseInt(req.params.id, 10);
+        if (isNaN(proxyId)) return res.status(400).json({ error: 'Некорректный ID прокси' });
+
+        const { name, type, host, port, username, password, note } = req.body;
+
+        if (type && !['socks5', 'http'].includes(type)) {
+            return res.status(400).json({ error: 'Тип прокси должен быть socks5 или http' });
+        }
+
+        const dataToUpdate = {};
+        if (name !== undefined) dataToUpdate.name = name;
+        if (type !== undefined) dataToUpdate.type = type;
+        if (host !== undefined) dataToUpdate.host = host;
+        if (port !== undefined && port !== '') dataToUpdate.port = parseInt(port, 10);
+        if (username !== undefined) dataToUpdate.username = username || null;
+        if (password !== undefined) dataToUpdate.password = password || null;
+        if (note !== undefined) dataToUpdate.note = note || null;
+
+        Object.keys(dataToUpdate).forEach(k => { if (dataToUpdate[k] === undefined) delete dataToUpdate[k]; });
+
+        if (dataToUpdate.name) {
+            const existing = await prisma.proxy.findFirst({ where: { name: dataToUpdate.name, id: { not: proxyId } } });
+            if (existing) return res.status(409).json({ error: 'Прокси с таким именем уже существует' });
+        }
+
+        const updated = await prisma.proxy.update({ where: { id: proxyId }, data: dataToUpdate });
+        res.json(updated);
+    } catch (error) {
+        console.error('[API /api/proxies] Ошибка обновления прокси:', error);
+        res.status(500).json({ error: 'Не удалось обновить прокси' });
+    }
+});
+
+router.delete('/:id', authorize('proxy:delete'), async (req, res) => {
+    try {
+        const proxyId = parseInt(req.params.id, 10);
+
+        const botsUsingProxy = await prisma.bot.count({ where: { proxyId } });
+        if (botsUsingProxy > 0) {
+            return res.status(400).json({ error: `Нельзя удалить прокси, так как он используется ${botsUsingProxy} ботом(ами).` });
+        }
+
+        await prisma.proxy.delete({ where: { id: proxyId } });
+        res.status(204).send();
+    } catch (error) {
+        console.error('[API /api/proxies] Ошибка удаления прокси:', error);
+        res.status(500).json({ error: 'Не удалось удалить прокси' });
+    }
+});
+
+module.exports = router;

package/backend/src/api/routes/search.js

@@ -1,8 +1,12 @@
 const express = require('express');
+const { authenticate } = require('../middleware/auth');
 const router = express.Router();
 const { PrismaClient } = require('@prisma/client');
 const prisma = new PrismaClient();
 
+// Все роуты требуют аутентификации
+router.use(authenticate);
+
 router.get('/', async (req, res) => {
   const { query } = req.query;
 

package/backend/src/api/routes/servers.js

@@ -1,21 +1,38 @@
 const express = require('express');
 const router = express.Router();
 const { PrismaClient } = require('@prisma/client');
-const { authenticate, authorize } = require('../middleware/auth');
+const { authenticateUniversal, authorize } = require('../middleware/auth');
 const prisma = new PrismaClient();
 
-router.use(authenticate);
+router.use(authenticateUniversal);
 
 router.get('/', authorize('server:list'), async (req, res) => {
     try {
         const servers = await prisma.server.findMany({ orderBy: { name: 'asc' } });
-        res.json(servers);
+        res.json({
+            items: servers,
+            total: servers.length
+        });
     } catch (error) {
         console.error("[API /api/servers] Ошибка получения списка серверов:", error);
         res.status(500).json({ error: 'Не удалось получить список серверов' });
     }
 });
 
+router.get('/:id', authorize('server:list'), async (req, res) => {
+    try {
+        const serverId = parseInt(req.params.id, 10);
+        const server = await prisma.server.findUnique({ where: { id: serverId } });
+        if (!server) {
+            return res.status(404).json({ error: 'Сервер не найден' });
+        }
+        res.json(server);
+    } catch (error) {
+        console.error("[API /api/servers/:id] Ошибка получения сервера:", error);
+        res.status(500).json({ error: 'Не удалось получить сервер' });
+    }
+});
+
 router.post('/', authorize('server:create'), async (req, res) => {
     try {
         const { name, host, port, version } = req.body;

package/backend/src/api/routes/settings.js

@@ -1,10 +1,15 @@
 const express = require('express');
+const { authenticate, authorize } = require('../middleware/auth');
 const router = express.Router();
 const { PrismaClient } = require('@prisma/client');
 const PluginService = require('../../core/PluginService');
 
 const prisma = new PrismaClient();
 
+// Все роуты требуют аутентификации и прав администратора
+router.use(authenticate);
+router.use(authorize('system:settings'));
+
 router.get('/plugin-directories', async (req, res) => {
     try {
         const setting = await prisma.setting.findUnique({

package/backend/src/api/routes/system.js

@@ -1,174 +1,174 @@
-const express = require('express');
-const { authenticate } = require('../middleware/auth');
-const os = require('os');
-const pidusage = require('pidusage');
-const rateLimit = require('express-rate-limit');
-
-const router = express.Router();
-
-
-const serverStartTime = Date.now();
-
-/**
- * Вычисляет системное использование CPU на основе средней загрузки
- * Избегает состояния гонки, не используя глобальное состояние
- */
-function getSystemCpuUsage() {
-    // Используем среднюю загрузку системы за 1 минуту
-    const loadAvg = os.loadavg()[0]; // 1-минутное среднее
-    const cpuCount = os.cpus().length;
-    // Конвертируем в процент (loadAvg / cpuCount * 100)
-    const cpuPercentage = Math.round((loadAvg / cpuCount) * 100);
-    return Math.max(0, Math.min(100, cpuPercentage));
-}
-
-/**
- * @route GET /api/system/health
- * @desc Получить информацию о здоровье системы
- * @access Требуется авторизация
- */
-router.get('/health', authenticate, async (req, res) => {
-    try {
-        const uptime = process.uptime();
-        const serverUptime = (Date.now() - serverStartTime) / 1000;
-        
-        const totalMemory = os.totalmem();
-        const freeMemory = os.freemem();
-        const usedMemory = totalMemory - freeMemory;
-        
-        const cpus = os.cpus();
-        
-        const systemCpuUsage = getSystemCpuUsage();
-        
-        let panelCpu = 0;
-        let panelMemory = 0;
-        try {
-            const stats = await pidusage(process.pid);
-            panelCpu = parseFloat(stats.cpu.toFixed(1));
-            panelMemory = parseFloat((stats.memory / 1024 / 1024).toFixed(1)); // MB
-        } catch (error) {
-            console.error('Ошибка получения статистики процесса:', error);
-        }
-        
-        const platform = process.platform;
-        const arch = process.arch;
-        
-        const platformName = {
-            'win32': 'Windows',
-            'linux': 'Linux',
-            'darwin': 'macOS',
-            'freebsd': 'FreeBSD',
-            'openbsd': 'OpenBSD',
-            'aix': 'AIX'
-        }[platform] || platform;
-        
-        // Форматируем uptime
-        const formatUptime = (seconds) => {
-            const days = Math.floor(seconds / 86400);
-            const hours = Math.floor((seconds % 86400) / 3600);
-            const minutes = Math.floor((seconds % 3600) / 60);
-            
-            if (days > 0) return `${days}д ${hours}ч`;
-            if (hours > 0) return `${hours}ч ${minutes}м`;
-            return `${minutes}м`;
-        };
-
-        let websocketStatus = true;
-        let databaseStatus = true;
-        
-        try {
-            const prisma = req.app.get('prisma') || require('../../lib/prisma');
-            await prisma.$queryRaw`SELECT 1`;
-        } catch (error) {
-            databaseStatus = false;
-        }
-        
-        try {
-            const botManager = req.app.get('botManager');
-            websocketStatus = botManager !== null && botManager !== undefined;
-        } catch (error) {
-            websocketStatus = false;
-        }
-
-        res.json({
-            status: 'ok',
-            uptime: formatUptime(serverUptime),
-            uptimeSeconds: Math.floor(serverUptime),
-            processUptime: formatUptime(uptime),
-            memory: {
-                total: Math.round(totalMemory / 1024 / 1024), // MB
-                free: Math.round(freeMemory / 1024 / 1024), // MB
-                used: Math.round(usedMemory / 1024 / 1024), // MB
-                usedPercent: Math.round((usedMemory / totalMemory) * 100),
-                panel: panelMemory // Память используемая панелью
-            },
-            cpu: {
-                cores: cpus.length,
-                model: cpus[0]?.model || 'Unknown',
-                usage: systemCpuUsage,
-                panelUsage: panelCpu,
-                loadAverage: os.loadavg()
-            },
-            platform: platformName,
-            platformRaw: platform,
-            arch: arch,
-            osRelease: os.release(),
-            hostname: os.hostname(),
-            nodeVersion: process.version,
-            services: {
-                panel: true,
-                websocket: websocketStatus,
-                database: databaseStatus
-            }
-        });
-    } catch (error) {
-        console.error('Error getting system health:', error);
-        res.status(500).json({ 
-            error: 'Failed to get system health',
-            message: error.message 
-        });
-    }
-});
-
-/**
- * @route GET /api/system/stats
- * @desc Получить статистику системы
- * @access Требуется авторизация
- */
-router.get('/stats', authenticate, async (req, res) => {
-    try {
-        const prisma = req.app.get('prisma') || require('../../lib/prisma');
-        
-        const totalBots = await prisma.bot.count();
-        const totalServers = await prisma.server.count();
-        const totalUsers = await prisma.panelUser.count();
-        
-        const botManager = req.app.get('botManager');
-        let runningBots = 0;
-        
-        if (botManager && botManager.bots) {
-            runningBots = Array.from(botManager.bots.values())
-                .filter(bot => typeof bot.isRunning === 'function' && bot.isRunning())
-                .length;
-        }
-        
-        res.json({
-            bots: {
-                total: totalBots,
-                running: runningBots,
-                stopped: totalBots - runningBots
-            },
-            servers: totalServers,
-            users: totalUsers
-        });
-    } catch (error) {
-        console.error('Error getting system stats:', error);
-        res.status(500).json({ 
-            error: 'Failed to get system stats',
-            message: error.message 
-        });
-    }
-});
-
-module.exports = router;
-
+const express = require('express');
+const { authenticate, authenticateUniversal } = require('../middleware/auth');
+const os = require('os');
+const pidusage = require('pidusage');
+const rateLimit = require('express-rate-limit');
+
+const router = express.Router();
+
+
+const serverStartTime = Date.now();
+
+/**
+ * Вычисляет системное использование CPU на основе средней загрузки
+ * Избегает состояния гонки, не используя глобальное состояние
+ */
+function getSystemCpuUsage() {
+    // Используем среднюю загрузку системы за 1 минуту
+    const loadAvg = os.loadavg()[0]; // 1-минутное среднее
+    const cpuCount = os.cpus().length;
+    // Конвертируем в процент (loadAvg / cpuCount * 100)
+    const cpuPercentage = Math.round((loadAvg / cpuCount) * 100);
+    return Math.max(0, Math.min(100, cpuPercentage));
+}
+
+/**
+ * @route GET /api/system/health
+ * @desc Получить информацию о здоровье системы
+ * @access Требуется авторизация
+ */
+router.get('/health', authenticateUniversal, async (req, res) => {
+    try {
+        const uptime = process.uptime();
+        const serverUptime = (Date.now() - serverStartTime) / 1000;
+        
+        const totalMemory = os.totalmem();
+        const freeMemory = os.freemem();
+        const usedMemory = totalMemory - freeMemory;
+        
+        const cpus = os.cpus();
+        
+        const systemCpuUsage = getSystemCpuUsage();
+        
+        let panelCpu = 0;
+        let panelMemory = 0;
+        try {
+            const stats = await pidusage(process.pid);
+            panelCpu = parseFloat(stats.cpu.toFixed(1));
+            panelMemory = parseFloat((stats.memory / 1024 / 1024).toFixed(1)); // MB
+        } catch (error) {
+            console.error('Ошибка получения статистики процесса:', error);
+        }
+        
+        const platform = process.platform;
+        const arch = process.arch;
+        
+        const platformName = {
+            'win32': 'Windows',
+            'linux': 'Linux',
+            'darwin': 'macOS',
+            'freebsd': 'FreeBSD',
+            'openbsd': 'OpenBSD',
+            'aix': 'AIX'
+        }[platform] || platform;
+        
+        // Форматируем uptime
+        const formatUptime = (seconds) => {
+            const days = Math.floor(seconds / 86400);
+            const hours = Math.floor((seconds % 86400) / 3600);
+            const minutes = Math.floor((seconds % 3600) / 60);
+            
+            if (days > 0) return `${days}д ${hours}ч`;
+            if (hours > 0) return `${hours}ч ${minutes}м`;
+            return `${minutes}м`;
+        };
+
+        let websocketStatus = true;
+        let databaseStatus = true;
+        
+        try {
+            const prisma = req.app.get('prisma') || require('../../lib/prisma');
+            await prisma.$queryRaw`SELECT 1`;
+        } catch (error) {
+            databaseStatus = false;
+        }
+        
+        try {
+            const botManager = req.app.get('botManager');
+            websocketStatus = botManager !== null && botManager !== undefined;
+        } catch (error) {
+            websocketStatus = false;
+        }
+
+        res.json({
+            status: 'ok',
+            uptime: formatUptime(serverUptime),
+            uptimeSeconds: Math.floor(serverUptime),
+            processUptime: formatUptime(uptime),
+            memory: {
+                total: Math.round(totalMemory / 1024 / 1024), // MB
+                free: Math.round(freeMemory / 1024 / 1024), // MB
+                used: Math.round(usedMemory / 1024 / 1024), // MB
+                usedPercent: Math.round((usedMemory / totalMemory) * 100),
+                panel: panelMemory // Память используемая панелью
+            },
+            cpu: {
+                cores: cpus.length,
+                model: cpus[0]?.model || 'Unknown',
+                usage: systemCpuUsage,
+                panelUsage: panelCpu,
+                loadAverage: os.loadavg()
+            },
+            platform: platformName,
+            platformRaw: platform,
+            arch: arch,
+            osRelease: os.release(),
+            hostname: os.hostname(),
+            nodeVersion: process.version,
+            services: {
+                panel: true,
+                websocket: websocketStatus,
+                database: databaseStatus
+            }
+        });
+    } catch (error) {
+        console.error('Error getting system health:', error);
+        res.status(500).json({ 
+            error: 'Failed to get system health',
+            message: error.message 
+        });
+    }
+});
+
+/**
+ * @route GET /api/system/stats
+ * @desc Получить статистику системы
+ * @access Требуется авторизация
+ */
+router.get('/stats', authenticateUniversal, async (req, res) => {
+    try {
+        const prisma = req.app.get('prisma') || require('../../lib/prisma');
+        
+        const totalBots = await prisma.bot.count();
+        const totalServers = await prisma.server.count();
+        const totalUsers = await prisma.panelUser.count();
+        
+        const botManager = req.app.get('botManager');
+        let runningBots = 0;
+        
+        if (botManager && botManager.bots) {
+            runningBots = Array.from(botManager.bots.values())
+                .filter(bot => typeof bot.isRunning === 'function' && bot.isRunning())
+                .length;
+        }
+        
+        res.json({
+            bots: {
+                total: totalBots,
+                running: runningBots,
+                stopped: totalBots - runningBots
+            },
+            servers: totalServers,
+            users: totalUsers
+        });
+    } catch (error) {
+        console.error('Error getting system stats:', error);
+        res.status(500).json({ 
+            error: 'Failed to get system stats',
+            message: error.message 
+        });
+    }
+});
+
+module.exports = router;
+