blockmine 1.23.0 → 1.23.2

package/backend/src/core/EventGraphManager.js

@@ -1,195 +1,195 @@
-const prismaService = require('./PrismaService');
-const { safeJsonParse } = require('./utils/jsonParser');
-const { parseVariables } = require('./utils/variableParser');
-const validationService = require('./services/ValidationService');
-const botHistoryStore = require('./BotHistoryStore');
-
-const prisma = prismaService.getClient();
-
-class EventGraphManager {
-    constructor(botManager = null) {
-        this.botManager = botManager;
-        this.activeGraphs = new Map();
-        this.graphStates = new Map();
-    }
-
-    setBotManager(botManager) {
-        this.botManager = botManager;
-    }
-
-    async loadGraphsForBot(botId) {
-        console.log(`[EventGraphs] Загрузка графов для бота ${botId}...`);
-        const botGraphs = await prisma.eventGraph.findMany({
-            where: { botId, isEnabled: true },
-            include: { triggers: true },
-        });
-
-        const graphsByEvent = new Map();
-        for (const graph of botGraphs) {
-            if (!graph.triggers || graph.triggers.length === 0 || !graph.graphJson) continue;
-
-            try {
-                const parsedGraph = validationService.parseGraph(graph.graphJson, `EventGraph ID ${graph.id}`);
-                if (!validationService.hasValidBasicStructure(parsedGraph)) continue;
-
-                const initialState = {};
-                if (graph.variables) {
-                    const parsedVars = safeJsonParse(graph.variables, [], `EventGraph ID ${graph.id} variables`);
-                    Object.assign(initialState, parseVariables(parsedVars, `EventGraph ID ${graph.id}`));
-                }
-                this.graphStates.set(`${botId}-${graph.id}`, initialState);
-
-                for (const trigger of graph.triggers) {
-                    if (!graphsByEvent.has(trigger.eventType)) {
-                        graphsByEvent.set(trigger.eventType, []);
-                    }
-                    graphsByEvent.get(trigger.eventType).push({
-                        id: graph.id,
-                        name: graph.name,
-                        nodes: parsedGraph.nodes,
-                        connections: parsedGraph.connections,
-                        variables: parsedGraph.variables || [],
-                    });
-                }
-            } catch (e) {
-                console.error(`[EventGraphs] Ошибка парсинга JSON для графа ID ${graph.id}:`, e);
-            }
-        }
-
-        this.activeGraphs.set(botId, graphsByEvent);
-        console.log(`[EventGraphs] Загружено ${botGraphs.length} графов, сгруппировано по ${graphsByEvent.size} событиям для бота ${botId}.`);
-    }
-
-    unloadGraphsForBot(botId) {
-        this.activeGraphs.delete(botId);
-        for (const key of this.graphStates.keys()) {
-            if (key.startsWith(`${botId}-`)) {
-                this.graphStates.delete(key);
-            }
-        }
-        console.log(`[EventGraphs] Графы и их состояния для бота ${botId} выгружены.`);
-    }
-
-    async handleEvent(botId, eventType, args) {
-        this.broadcastEventToApi(botId, eventType, args);
-
-        const graphsForBot = this.activeGraphs.get(botId);
-        if (!graphsForBot) return;
-
-        const graphsToRun = graphsForBot.get(eventType);
-        if (!graphsToRun || graphsToRun.length === 0) return;
-
-        for (const graph of graphsToRun) {
-            try {
-                await this.executeGraphInChildProcess(botId, eventType, graph, args);
-            } catch (error) {
-                console.error(`[EventGraphManager] Error sending event to child process for '${eventType}':`, error);
-                this.botManager.appendLog(botId, `[ERROR] Error in event graph: ${error.message}`);
-            }
-        }
-    }
-
-    /**
-     * Отправляет граф в child process для выполнения
-     */
-    async executeGraphInChildProcess(botId, eventType, graph, eventArgs) {
-        if (!graph || !graph.nodes || graph.nodes.length === 0) return;
-
-        const childProcess = this.botManager.getChildProcess(botId);
-        if (!childProcess || !childProcess.send) {
-            console.error(`[EventGraphManager] No child process found for bot ${botId}`);
-            return;
-        }
-
-        childProcess.send({
-            type: 'execute_event_graph',
-            botId: botId,
-            graph: graph,
-            eventType: eventType,
-            eventArgs: eventArgs
-        });
-    }
-
-    /**
-     * Отправляет события в WebSocket API
-     */
-    broadcastEventToApi(botId, eventType, args) {
-        try {
-            // Динамический импорт для избежания циклической зависимости
-            const { getIOSafe } = require('../real-time/socketHandler');
-            const { broadcastToApiClients } = require('../real-time/botApi');
-
-            const io = getIOSafe();
-            if (!io) return;
-
-            switch (eventType) {
-                case 'chat':
-                case 'private':
-                case 'global':
-                case 'clan':
-                    const chatData = {
-                        type: eventType,
-                        username: args.username,
-                        message: args.message,
-                        raw_message: args.rawText || args.raw_message,
-                    };
-
-                    broadcastToApiClients(io, botId, 'chat:message', chatData);
-
-                    botHistoryStore.addChatMessage(botId, {
-                        type: eventType,
-                        username: args.username,
-                        message: args.message
-                    });
-                    break;
-
-                case 'playerJoined':
-                    broadcastToApiClients(io, botId, 'player:join', {
-                        username: args.user?.username || args.username,
-                    });
-                    break;
-
-                case 'playerLeft':
-                    broadcastToApiClients(io, botId, 'player:leave', {
-                        username: args.user?.username || args.username,
-                    });
-                    break;
-
-                case 'health':
-                    broadcastToApiClients(io, botId, 'bot:health', {
-                        health: args.health,
-                        food: args.food,
-                    });
-                    break;
-
-                case 'death':
-                    broadcastToApiClients(io, botId, 'bot:death', {});
-                    break;
-            }
-        } catch (error) {
-        }
-    }
-
-    /**
-     * Отправляет кастомное событие от плагина в WebSocket API
-     */
-    emitCustomApiEvent(botId, eventName, payload = {}) {
-        try {
-            const { getIOSafe } = require('../real-time/socketHandler');
-            const { broadcastToApiClients } = require('../real-time/botApi');
-
-            const io = getIOSafe();
-            if (!io) return;
-
-            broadcastToApiClients(io, botId, 'plugin:custom_event', {
-                eventName,
-                payload,
-                timestamp: new Date().toISOString(),
-            });
-        } catch (error) {
-            // Игнорируем другие ошибки
-        }
-    }
-}
-
+const prismaService = require('./PrismaService');
+const { safeJsonParse } = require('./utils/jsonParser');
+const { parseVariables } = require('./utils/variableParser');
+const validationService = require('./services/ValidationService');
+const botHistoryStore = require('./BotHistoryStore');
+
+const prisma = prismaService.getClient();
+
+class EventGraphManager {
+    constructor(botManager = null) {
+        this.botManager = botManager;
+        this.activeGraphs = new Map();
+        this.graphStates = new Map();
+    }
+
+    setBotManager(botManager) {
+        this.botManager = botManager;
+    }
+
+    async loadGraphsForBot(botId) {
+        console.log(`[EventGraphs] Загрузка графов для бота ${botId}...`);
+        const botGraphs = await prisma.eventGraph.findMany({
+            where: { botId, isEnabled: true },
+            include: { triggers: true },
+        });
+
+        const graphsByEvent = new Map();
+        for (const graph of botGraphs) {
+            if (!graph.triggers || graph.triggers.length === 0 || !graph.graphJson) continue;
+
+            try {
+                const parsedGraph = validationService.parseGraph(graph.graphJson, `EventGraph ID ${graph.id}`);
+                if (!validationService.hasValidBasicStructure(parsedGraph)) continue;
+
+                const initialState = {};
+                if (graph.variables) {
+                    const parsedVars = safeJsonParse(graph.variables, [], `EventGraph ID ${graph.id} variables`);
+                    Object.assign(initialState, parseVariables(parsedVars, `EventGraph ID ${graph.id}`));
+                }
+                this.graphStates.set(`${botId}-${graph.id}`, initialState);
+
+                for (const trigger of graph.triggers) {
+                    if (!graphsByEvent.has(trigger.eventType)) {
+                        graphsByEvent.set(trigger.eventType, []);
+                    }
+                    graphsByEvent.get(trigger.eventType).push({
+                        id: graph.id,
+                        name: graph.name,
+                        nodes: parsedGraph.nodes,
+                        connections: parsedGraph.connections,
+                        variables: parsedGraph.variables || [],
+                    });
+                }
+            } catch (e) {
+                console.error(`[EventGraphs] Ошибка парсинга JSON для графа ID ${graph.id}:`, e);
+            }
+        }
+
+        this.activeGraphs.set(botId, graphsByEvent);
+        console.log(`[EventGraphs] Загружено ${botGraphs.length} графов, сгруппировано по ${graphsByEvent.size} событиям для бота ${botId}.`);
+    }
+
+    unloadGraphsForBot(botId) {
+        this.activeGraphs.delete(botId);
+        for (const key of this.graphStates.keys()) {
+            if (key.startsWith(`${botId}-`)) {
+                this.graphStates.delete(key);
+            }
+        }
+        console.log(`[EventGraphs] Графы и их состояния для бота ${botId} выгружены.`);
+    }
+
+    async handleEvent(botId, eventType, args) {
+        this.broadcastEventToApi(botId, eventType, args);
+
+        const graphsForBot = this.activeGraphs.get(botId);
+        if (!graphsForBot) return;
+
+        const graphsToRun = graphsForBot.get(eventType);
+        if (!graphsToRun || graphsToRun.length === 0) return;
+
+        for (const graph of graphsToRun) {
+            try {
+                await this.executeGraphInChildProcess(botId, eventType, graph, args);
+            } catch (error) {
+                console.error(`[EventGraphManager] Error sending event to child process for '${eventType}':`, error);
+                this.botManager.appendLog(botId, `[ERROR] Error in event graph: ${error.message}`);
+            }
+        }
+    }
+
+    /**
+     * Отправляет граф в child process для выполнения
+     */
+    async executeGraphInChildProcess(botId, eventType, graph, eventArgs) {
+        if (!graph || !graph.nodes || graph.nodes.length === 0) return;
+
+        const childProcess = this.botManager.getChildProcess(botId);
+        if (!childProcess || !childProcess.send) {
+            console.error(`[EventGraphManager] No child process found for bot ${botId}`);
+            return;
+        }
+
+        childProcess.send({
+            type: 'execute_event_graph',
+            botId: botId,
+            graph: graph,
+            eventType: eventType,
+            eventArgs: eventArgs
+        });
+    }
+
+    /**
+     * Отправляет события в WebSocket API
+     */
+    broadcastEventToApi(botId, eventType, args) {
+        try {
+            // Динамический импорт для избежания циклической зависимости
+            const { getIOSafe } = require('../real-time/socketHandler');
+            const { broadcastToApiClients } = require('../real-time/botApi');
+
+            const io = getIOSafe();
+            if (!io) return;
+
+            switch (eventType) {
+                case 'chat':
+                case 'private':
+                case 'global':
+                case 'clan':
+                    const chatData = {
+                        type: eventType,
+                        username: args.username,
+                        message: args.message,
+                        raw_message: args.rawText || args.raw_message,
+                    };
+
+                    broadcastToApiClients(io, botId, 'chat:message', chatData);
+
+                    botHistoryStore.addChatMessage(botId, {
+                        type: eventType,
+                        username: args.username,
+                        message: args.message
+                    });
+                    break;
+
+                case 'playerJoined':
+                    broadcastToApiClients(io, botId, 'player:join', {
+                        username: args.user?.username || args.username,
+                    });
+                    break;
+
+                case 'playerLeft':
+                    broadcastToApiClients(io, botId, 'player:leave', {
+                        username: args.user?.username || args.username,
+                    });
+                    break;
+
+                case 'health':
+                    broadcastToApiClients(io, botId, 'bot:health', {
+                        health: args.health,
+                        food: args.food,
+                    });
+                    break;
+
+                case 'death':
+                    broadcastToApiClients(io, botId, 'bot:death', {});
+                    break;
+            }
+        } catch (error) {
+        }
+    }
+
+    /**
+     * Отправляет кастомное событие от плагина в WebSocket API
+     */
+    emitCustomApiEvent(botId, eventName, payload = {}) {
+        try {
+            const { getIOSafe } = require('../real-time/socketHandler');
+            const { broadcastToApiClients } = require('../real-time/botApi');
+
+            const io = getIOSafe();
+            if (!io) return;
+
+            broadcastToApiClients(io, botId, 'plugin:custom_event', {
+                eventName,
+                payload,
+                timestamp: new Date().toISOString(),
+            });
+        } catch (error) {
+            // Игнорируем другие ошибки
+        }
+    }
+}
+
 module.exports = EventGraphManager;

package/backend/src/core/GraphExecutionEngine.js

@@ -462,7 +462,34 @@ class GraphExecutionEngine {
           const sourceNode = this.activeGraph.nodes.find(n => n.id === connection.sourceNodeId);
           return await this.evaluateOutputPin(sourceNode, connection.sourcePinId, defaultValue);
       }
-      return node.data && node.data[pinId] !== undefined ? node.data[pinId] : defaultValue;
+
+      let value = node.data && node.data[pinId] !== undefined ? node.data[pinId] : defaultValue;
+
+      // Автоматически заменяем переменные {varName} в строковых значениях
+      if (typeof value === 'string' && value.includes('{')) {
+          value = await this._replaceVariablesInString(value, node);
+      }
+
+      return value;
+  }
+
+  /**
+   * Заменяет переменные {varName} на значения из пинов
+   * @private
+   */
+  async _replaceVariablesInString(text, node) {
+      const variablePattern = /\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
+      const matches = [...text.matchAll(variablePattern)];
+
+      let result = text;
+
+      for (const match of matches) {
+          const varName = match[1];
+          const varValue = await this.resolvePinValue(node, `var_${varName}`, '');
+          result = result.replace(match[0], String(varValue));
+      }
+
+      return result;
   }
 
   async evaluateOutputPin(node, pinId, defaultValue = null) {

package/backend/src/core/node-registries/actions.js

@@ -10,7 +10,6 @@ function registerNodes(registry) {
     category: 'Действия',
     description: 'Отправляет сообщение в чат. Поддерживает переменные в формате {varName}',
     graphType: GRAPH_TYPES.ALL,
-    dynamicPins: true,
     executor: require('../nodes/actions/send_message').execute,
     pins: {
       inputs: [
@@ -112,7 +111,8 @@ function registerNodes(registry) {
         { id: 'exec', name: 'Выполнить', type: 'Exec', required: true },
         { id: 'url', name: 'URL', type: 'String', required: true },
         { id: 'method', name: 'Метод', type: 'String', required: false },
-        { id: 'headers', name: 'Заголовки (JSON)', type: 'String', required: false },
+        { id: 'queryParams', name: 'Query Params', type: 'Object', required: false },
+        { id: 'headers', name: 'Headers', type: 'Object', required: false },
         { id: 'body', name: 'Тело (JSON)', type: 'Wildcard', required: false },
         { id: 'timeout', name: 'Таймаут (мс)', type: 'Number', required: false }
       ],

package/backend/src/core/nodes/actions/http_request.js

@@ -9,16 +9,35 @@
 async function execute(node, context, helpers) {
     const { resolvePinValue, traverse, memo } = helpers;
 
-    const url = await resolvePinValue(node, 'url', '');
+    let url = await resolvePinValue(node, 'url', '');
     const method = await resolvePinValue(node, 'method', node.data?.method || 'GET');
-    const headersStr = await resolvePinValue(node, 'headers', '');
+    const headersInput = await resolvePinValue(node, 'headers', null);
+    const queryParamsInput = await resolvePinValue(node, 'queryParams', null);
     const body = await resolvePinValue(node, 'body', '');
     const timeout = await resolvePinValue(node, 'timeout', 5000);
 
+    if (queryParamsInput) {
+        try {
+            const params = typeof queryParamsInput === 'string'
+                ? JSON.parse(queryParamsInput)
+                : queryParamsInput;
+
+            const urlObj = new URL(url);
+            Object.entries(params).forEach(([key, value]) => {
+                urlObj.searchParams.append(key, value);
+            });
+            url = urlObj.toString();
+        } catch (e) {
+            console.error('[HTTP Request] Ошибка обработки query params:', e);
+        }
+    }
+
     let headers = {};
-    if (headersStr) {
+    if (headersInput) {
         try {
-            headers = JSON.parse(headersStr);
+            headers = typeof headersInput === 'string'
+                ? JSON.parse(headersInput)
+                : headersInput;
         } catch (e) {
             console.error('[HTTP Request] Ошибка парсинга headers:', e);
             headers = {};

package/backend/src/core/nodes/actions/send_message.js

@@ -8,21 +8,11 @@
 async function execute(node, context, helpers) {
     const { resolvePinValue, traverse } = helpers;
 
-    let message = String(await resolvePinValue(node, 'message', ''));
+    // resolvePinValue теперь автоматически заменяет {varName} на значения
+    const message = String(await resolvePinValue(node, 'message', ''));
     const chatType = await resolvePinValue(node, 'chat_type', context.typeChat);
     const recipient = await resolvePinValue(node, 'recipient', context.user?.username);
 
-    // Парсим и заменяем переменные в формате {varName}
-    const variablePattern = /\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
-    const matches = [...message.matchAll(variablePattern)];
-
-    for (const match of matches) {
-        const varName = match[1];
-        // Для динамических пинов, созданных на фронтенде, значение нужно будет получить, используя resolvePinValue
-        const varValue = await resolvePinValue(node, `var_${varName}`, '');
-        message = message.replace(match[0], String(varValue));
-    }
-
     context.bot.sendMessage(chatType, message, recipient);
     await traverse(node, 'exec');
 }

package/backend/src/core/nodes/data/string_literal.js

@@ -10,19 +10,8 @@ async function evaluate(node, pinId, context, helpers) {
     const { resolvePinValue } = helpers;
 
     if (pinId === 'value') {
-        let text = String(node.data?.value || '');
-
-        // Парсим и заменяем переменные в формате {varName}
-        const variablePattern = /\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
-        const matches = [...text.matchAll(variablePattern)];
-
-        for (const match of matches) {
-            const varName = match[1];
-            // Получаем значение из динамического пина
-            const varValue = await resolvePinValue(node, `var_${varName}`, '');
-            text = text.replace(match[0], String(varValue));
-        }
-
+        // resolvePinValue автоматически заменит переменные {varName}
+        const text = String(await resolvePinValue(node, 'value', ''));
         return text;
     }