blockmine 1.21.0 → 1.22.0

package/backend/src/lib/prisma.js

@@ -1,5 +1,3 @@
-const { PrismaClient } = require('@prisma/client');
+const prismaService = require('../core/PrismaService');
 
-const prisma = new PrismaClient();
-
-module.exports = prisma; 
+module.exports = prismaService.getClient(); 

package/backend/src/real-time/botApi/handlers/commandHandlers.js

@@ -0,0 +1,28 @@
+const { botManager } = require('../../../core/services');
+const logger = require('../../../lib/logger');
+
+async function handleExecuteCommand(socket, payload) {
+    const { username, command, args } = payload;
+    const botId = socket.botId;
+
+    try {
+        if (!botManager.isBotRunning(botId)) {
+            return socket.emit('command:error', { error: 'Bot is not running' });
+        }
+        if (!username) {
+            return socket.emit('command:error', { error: 'Username is required.' });
+        }
+
+
+        const result = await botManager.validateAndExecuteCommandForApi(botId, username, command, args);
+        socket.emit('command:result', { result });
+
+    } catch (error) {
+        logger.error(`[Bot API] Error executing command '${command}' for bot ${botId}:`, error);
+        socket.emit('command:error', { error: error.message });
+    }
+}
+
+module.exports = {
+    handleExecuteCommand,
+};

package/backend/src/real-time/botApi/handlers/graphHandlers.js

@@ -0,0 +1,99 @@
+const prisma = require('../../../lib/prisma');
+const { botManager } = require('../../../core/services');
+
+/**
+ * action:trigger_graph - Запустить визуальный граф
+ */
+async function handleTriggerGraph(socket, payload) {
+    // Проверяем права
+    if (socket.permissions === 'Read') {
+        return socket.emit('error', {
+            action: 'trigger_graph',
+            message: 'Insufficient permissions: Read-only key',
+        });
+    }
+
+    try {
+        const { graphName, context = {} } = payload;
+
+        if (!graphName) {
+            return socket.emit('error', {
+                action: 'trigger_graph',
+                message: 'graphName is required',
+            });
+        }
+
+        // Проверяем, что бот онлайн
+        if (!botManager.isBotRunning(socket.botId)) {
+            return socket.emit('error', {
+                action: 'trigger_graph',
+                message: 'Bot is offline',
+            });
+        }
+
+        // Проверяем, что EventGraphManager инициализирован
+        if (!botManager.eventGraphManager) {
+            return socket.emit('error', {
+                action: 'trigger_graph',
+                message: 'Event graph manager not initialized',
+            });
+        }
+
+        // Получаем граф из базы с триггерами
+        const graph = await prisma.eventGraph.findFirst({
+            where: {
+                botId: socket.botId,
+                name: graphName,
+                isEnabled: true,
+            },
+            include: { triggers: true },
+        });
+
+        if (!graph) {
+            return socket.emit('error', {
+                action: 'trigger_graph',
+                message: `Graph "${graphName}" not found or disabled`,
+            });
+        }
+
+        if (!graph.graphJson) {
+            return socket.emit('error', {
+                action: 'trigger_graph',
+                message: `Graph "${graphName}" has no valid graph data`,
+            });
+        }
+
+        // Парсим граф
+        const parsedGraph = JSON.parse(graph.graphJson);
+
+        // Запускаем граф напрямую через executeGraph
+        await botManager.eventGraphManager.executeGraph(
+            socket.botId,
+            'api_trigger', // Тип события
+            {
+                id: graph.id,
+                name: graph.name,
+                nodes: parsedGraph.nodes,
+                connections: parsedGraph.connections,
+                variables: parsedGraph.variables || [],
+            },
+            context // Передаем context как eventArgs
+        );
+
+        socket.emit('action:result', {
+            action: 'trigger_graph',
+            success: true,
+            graphName,
+        });
+    } catch (error) {
+        console.error('[Bot API] Ошибка запуска графа:', error);
+        socket.emit('error', {
+            action: 'trigger_graph',
+            message: 'Internal error',
+        });
+    }
+}
+
+module.exports = {
+    handleTriggerGraph,
+};

package/backend/src/real-time/botApi/handlers/graphWebSocketHandlers.js

@@ -0,0 +1,147 @@
+const prisma = require('../../../lib/prisma');
+const { botManager } = require('../../../core/services');
+
+/**
+ * action:call_graph - Вызвать граф и получить ответ
+ * Граф получит событие websocket_call и сможет отправить ответ
+ */
+async function handleCallGraph(socket, payload) {
+    if (socket.permissions === 'Read') {
+        return socket.emit('error', {
+            action: 'call_graph',
+            message: 'Insufficient permissions: Read-only key',
+        });
+    }
+
+    try {
+        const { graphName, data = {} } = payload;
+
+        if (!graphName) {
+            return socket.emit('error', {
+                action: 'call_graph',
+                message: 'graphName is required',
+            });
+        }
+
+        if (!botManager.isBotRunning(socket.botId)) {
+            return socket.emit('error', {
+                action: 'call_graph',
+                message: 'Bot is offline',
+            });
+        }
+
+        if (!botManager.eventGraphManager) {
+            return socket.emit('error', {
+                action: 'call_graph',
+                message: 'Event graph manager not initialized',
+            });
+        }
+
+        const graph = await prisma.eventGraph.findFirst({
+            where: {
+                botId: socket.botId,
+                name: graphName,
+                isEnabled: true,
+            },
+            include: { triggers: true },
+        });
+
+        if (!graph) {
+            return socket.emit('error', {
+                action: 'call_graph',
+                message: `Graph "${graphName}" not found or disabled`,
+            });
+        }
+
+
+        const hasWebSocketTrigger = graph.triggers?.some(t => t.eventType === 'websocket_call');
+        if (!hasWebSocketTrigger) {
+            return socket.emit('error', {
+                action: 'call_graph',
+                message: `Graph "${graphName}" does not have "WebSocket API Call" trigger`,
+            });
+        }
+
+        if (!graph.graphJson) {
+            return socket.emit('error', {
+                action: 'call_graph',
+                message: `Graph "${graphName}" has no valid graph data`,
+            });
+        }
+
+        const parsedGraph = JSON.parse(graph.graphJson);
+
+        let responseSent = false;
+        const sendResponse = (responseData) => {
+            if (responseSent) return;
+            responseSent = true;
+
+            socket.emit('action:result', {
+                action: 'call_graph',
+                success: true,
+                graphName,
+                response: responseData,
+            });
+        };
+
+
+        const timeout = setTimeout(() => {
+            if (!responseSent) {
+                responseSent = true;
+                socket.emit('error', {
+                    action: 'call_graph',
+                    message: 'Graph execution timeout (no response sent)',
+                });
+            }
+        }, 30000);
+
+        try {
+            await botManager.eventGraphManager.executeGraph(
+                socket.botId,
+                'websocket_call',
+                {
+                    id: graph.id,
+                    name: graph.name,
+                    nodes: parsedGraph.nodes,
+                    connections: parsedGraph.connections,
+                    variables: parsedGraph.variables || [],
+                },
+                {
+                    graphName,
+                    data,
+                    socketId: socket.id,
+                    keyPrefix: socket.keyPrefix,
+                    // Callback для отправки ответа
+                    sendResponse: (responseData) => {
+                        clearTimeout(timeout);
+                        sendResponse(responseData);
+                    },
+                }
+            );
+
+            // Если граф завершился без отправки ответа, отправляем успех
+            clearTimeout(timeout);
+            if (!responseSent) {
+                sendResponse({ completed: true });
+            }
+        } catch (error) {
+            clearTimeout(timeout);
+            if (!responseSent) {
+                socket.emit('error', {
+                    action: 'call_graph',
+                    message: error.message || 'Graph execution error',
+                });
+            }
+        }
+    } catch (error) {
+        console.error('[Bot API] Ошибка вызова графа:', error);
+        socket.emit('error', {
+            action: 'call_graph',
+            message: 'Internal error',
+        });
+    }
+}
+
+module.exports = {
+    handleCallGraph,
+};

package/backend/src/real-time/botApi/handlers/index.js

@@ -0,0 +1,43 @@
+const { handleGetStatus } = require('./statusHandlers');
+const { handleSendMessage } = require('./messageHandlers');
+const { handleTriggerGraph } = require('./graphHandlers');
+const { handleGetUser, handleUpdateUser } = require('./userHandlers');
+const { handleCallGraph } = require('./graphWebSocketHandlers');
+const { handleExecuteCommand } = require('./commandHandlers');
+
+/**
+ * Регистрирует все обработчики действий для сокета
+ */
+function registerActionHandlers(socket) {
+    socket.on('action:get_status', () => {
+        handleGetStatus(socket);
+    });
+
+    socket.on('action:send_message', (payload) => {
+        handleSendMessage(socket, payload);
+    });
+
+    socket.on('action:trigger_graph', async (payload) => {
+        await handleTriggerGraph(socket, payload);
+    });
+
+    socket.on('action:call_graph', async (payload) => {
+        await handleCallGraph(socket, payload);
+    });
+
+    socket.on('action:get_user', async (payload) => {
+        await handleGetUser(socket, payload);
+    });
+
+    socket.on('action:update_user', async (payload) => {
+        await handleUpdateUser(socket, payload);
+    });
+
+    socket.on('action:execute_command', async (payload) => {
+        await handleExecuteCommand(socket, payload);
+    });
+}
+
+module.exports = {
+    registerActionHandlers,
+};

package/backend/src/real-time/botApi/handlers/messageHandlers.js

@@ -0,0 +1,66 @@
+const { botManager } = require('../../../core/services');
+
+/**
+ * action:send_message - Отправить сообщение от имени бота
+ */
+function handleSendMessage(socket, payload) {
+    // Проверяем права
+    if (socket.permissions === 'Read') {
+        return socket.emit('error', {
+            action: 'send_message',
+            message: 'Insufficient permissions: Read-only key',
+        });
+    }
+
+    try {
+        const { chatType = 'chat', message, recipient } = payload;
+
+        if (!message) {
+            return socket.emit('error', {
+                action: 'send_message',
+                message: 'Message is required',
+            });
+        }
+
+        // Для private чата нужен recipient
+        if (chatType === 'private' && !recipient) {
+            return socket.emit('error', {
+                action: 'send_message',
+                message: 'Recipient is required for private messages',
+            });
+        }
+
+        // Проверяем, что бот онлайн
+        if (!botManager.isBotRunning(socket.botId)) {
+            return socket.emit('error', {
+                action: 'send_message',
+                message: 'Bot is offline',
+            });
+        }
+
+        // Отправляем сообщение боту
+        const result = botManager.sendMessageToBot(socket.botId, message, chatType, recipient);
+
+        if (!result.success) {
+            return socket.emit('error', {
+                action: 'send_message',
+                message: result.message || 'Failed to send message',
+            });
+        }
+
+        socket.emit('action:result', {
+            action: 'send_message',
+            success: true,
+        });
+    } catch (error) {
+        console.error('[Bot API] Ошибка отправки сообщения:', error);
+        socket.emit('error', {
+            action: 'send_message',
+            message: 'Internal error',
+        });
+    }
+}
+
+module.exports = {
+    handleSendMessage,
+};

package/backend/src/real-time/botApi/handlers/statusHandlers.js

@@ -0,0 +1,17 @@
+const { botManager } = require('../../../core/services');
+
+/**
+ * action:get_status - Получить текущий статус бота
+ */
+function handleGetStatus(socket) {
+    const isOnline = botManager.isBotRunning(socket.botId);
+    socket.emit('action:result', {
+        action: 'get_status',
+        success: true,
+        online: isOnline,
+    });
+}
+
+module.exports = {
+    handleGetStatus,
+};

package/backend/src/real-time/botApi/handlers/userHandlers.js

@@ -0,0 +1,141 @@
+const UserService = require('../../../core/UserService');
+
+/**
+ * action:get_user - Получить данные о пользователе
+ */
+async function handleGetUser(socket, payload) {
+    try {
+        const { username } = payload;
+
+        if (!username) {
+            return socket.emit('error', {
+                action: 'get_user',
+                message: 'username is required',
+            });
+        }
+
+        const user = await UserService.getUser(username, socket.botId);
+
+        if (!user) {
+            return socket.emit('error', {
+                action: 'get_user',
+                message: `User "${username}" not found`,
+            });
+        }
+
+        socket.emit('action:result', {
+            action: 'get_user',
+            success: true,
+            user: {
+                username: user.username,
+                isBlacklisted: user.isBlacklisted,
+                groups: user.groups ? user.groups.map(g => g.group.name) : [],
+                permissions: Array.from(user.permissionsSet || []),
+            },
+        });
+    } catch (error) {
+        console.error('[Bot API] Ошибка получения пользователя:', error);
+        socket.emit('error', {
+            action: 'get_user',
+            message: 'Internal error',
+        });
+    }
+}
+
+/**
+ * action:update_user - Обновить данные пользователя
+ */
+async function handleUpdateUser(socket, payload) {
+    // Проверяем права
+    if (socket.permissions === 'Read') {
+        return socket.emit('error', {
+            action: 'update_user',
+            message: 'Insufficient permissions: Read-only key',
+        });
+    }
+
+    try {
+        const { username, operation, value } = payload;
+
+        if (!username) {
+            return socket.emit('error', {
+                action: 'update_user',
+                message: 'username is required',
+            });
+        }
+
+        if (!operation) {
+            return socket.emit('error', {
+                action: 'update_user',
+                message: 'operation is required (addGroup, removeGroup, setBlacklist)',
+            });
+        }
+
+        const user = await UserService.getUser(username, socket.botId);
+
+        if (!user) {
+            return socket.emit('error', {
+                action: 'update_user',
+                message: `User "${username}" not found`,
+            });
+        }
+
+        let result;
+
+        switch (operation) {
+            case 'addGroup':
+                if (!value) {
+                    return socket.emit('error', {
+                        action: 'update_user',
+                        message: 'value (group name) is required for addGroup operation',
+                    });
+                }
+                result = await user.addGroup(value);
+                break;
+
+            case 'removeGroup':
+                if (!value) {
+                    return socket.emit('error', {
+                        action: 'update_user',
+                        message: 'value (group name) is required for removeGroup operation',
+                    });
+                }
+                result = await user.removeGroup(value);
+                break;
+
+            case 'setBlacklist':
+                if (typeof value !== 'boolean') {
+                    return socket.emit('error', {
+                        action: 'update_user',
+                        message: 'value (true/false) is required for setBlacklist operation',
+                    });
+                }
+                result = await user.setBlacklist(value);
+                break;
+
+            default:
+                return socket.emit('error', {
+                    action: 'update_user',
+                    message: 'Invalid operation. Use: addGroup, removeGroup, setBlacklist',
+                });
+        }
+
+        socket.emit('action:result', {
+            action: 'update_user',
+            success: true,
+            operation,
+            result,
+        });
+    } catch (error) {
+        console.error('[Bot API] Ошибка обновления пользователя:', error);
+        socket.emit('error', {
+            action: 'update_user',
+            message: error.message || 'Internal error',
+        });
+    }
+}
+
+module.exports = {
+    handleGetUser,
+    handleUpdateUser,
+};

package/backend/src/real-time/botApi/index.js

@@ -0,0 +1,40 @@
+const { botManager } = require('../../core/services');
+const { authenticateApiClient, logConnection } = require('./middleware');
+const { registerActionHandlers } = require('./handlers');
+
+/**
+ * Инициализирует namespace /bot-api для WebSocket API
+ * @param {Server} io - Socket.IO сервер
+ */
+function initializeBotApiNamespace(io) {
+    const apiNamespace = io.of('/bot-api');
+
+
+    apiNamespace.use(authenticateApiClient);
+
+    apiNamespace.on('connection', async (socket) => {
+        console.log(`[Bot API] Клиент подключился к боту ID: ${socket.botId} (ключ: ${socket.keyPrefix})`);
+
+        socket.join(`bot_${socket.botId}`);
+
+
+        const isOnline = botManager.isBotRunning(socket.botId);
+        socket.emit('bot:status', { online: isOnline });
+
+        await logConnection(socket, 'connect');
+
+        registerActionHandlers(socket);
+
+        socket.on('disconnect', async () => {
+            console.log(`[Bot API] Клиент отключился от бота ID: ${socket.botId} (ключ: ${socket.keyPrefix})`);
+            await logConnection(socket, 'disconnect');
+        });
+    });
+
+    return apiNamespace;
+}
+
+module.exports = {
+    initializeBotApiNamespace,
+    ...require('./utils'),
+};

package/backend/src/real-time/botApi/middleware.js

@@ -0,0 +1,79 @@
+const bcrypt = require('bcryptjs');
+const prisma = require('../../lib/prisma');
+
+/**
+ * Middleware для аутентификации API клиентов
+ */
+async function authenticateApiClient(socket, next) {
+    try {
+        const apiKey = socket.handshake.auth.token;
+        const botId = parseInt(socket.handshake.query.botId, 10);
+
+        if (!apiKey || !botId) {
+            console.error('[Bot API] Отклонено: Нет токена или botId');
+            return next(new Error('Authentication error: Missing token or botId'));
+        }
+
+        if (!apiKey.startsWith('bk_')) {
+            console.error('[Bot API] Отклонено: Неверный формат токена');
+            return next(new Error('Authentication error: Invalid token format'));
+        }
+
+        const keys = await prisma.botApiKey.findMany({
+            where: { botId },
+        });
+
+        let matchedKey = null;
+        for (const key of keys) {
+            const isMatch = await bcrypt.compare(apiKey, key.keyHash);
+            if (isMatch) {
+                matchedKey = key;
+                break;
+            }
+        }
+
+        if (!matchedKey) {
+            console.error('[Bot API] Отклонено: Неверный ключ для бота', botId);
+            return next(new Error('Authentication failed: Invalid token'));
+        }
+
+        socket.botId = botId;
+        socket.keyId = matchedKey.id;
+        socket.keyPrefix = matchedKey.keyPrefix;
+        socket.permissions = matchedKey.permissions;
+
+        await prisma.botApiKey.update({
+            where: { id: matchedKey.id },
+            data: { lastUsedAt: new Date() },
+        });
+
+        return next();
+    } catch (error) {
+        console.error('[Bot API] Ошибка аутентификации:', error);
+        return next(new Error('Authentication error'));
+    }
+}
+
+/**
+ * Логирует подключение/отключение клиента
+ */
+async function logConnection(socket, action) {
+    try {
+        await prisma.apiConnectionLog.create({
+            data: {
+                botId: socket.botId,
+                keyPrefix: socket.keyPrefix,
+                ipAddress: socket.handshake.address,
+                userAgent: socket.handshake.headers['user-agent'] || null,
+                action,
+            },
+        });
+    } catch (error) {
+        console.error(`[Bot API] Ошибка логирования ${action}:`, error);
+    }
+}
+
+module.exports = {
+    authenticateApiClient,
+    logConnection,
+};