blockmine 1.20.0 → 1.22.0

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

@@ -0,0 +1,113 @@
+const { GRAPH_TYPES } = require('../constants/graphTypes');
+
+/**
+ * Регистрация нод категории "Время"
+ */
+function registerNodes(registry) {
+  registry.registerNodeType({
+    type: 'time:datetime_literal',
+    label: '📅 Дата и время',
+    category: 'Время',
+    description: 'Создает объект даты и времени из строки. Если строка пустая, вернет текущее время.',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/data/datetime_literal').evaluate,
+    pins: {
+      inputs: [
+        { id: 'date', name: 'Дата (строка)', type: 'String', required: false }
+      ],
+      outputs: [
+        { id: 'value', name: 'Дата', type: 'DateTime' }
+      ]
+    }
+  });
+
+  registry.registerNodeType({
+    type: 'time:now',
+    label: '⏰ Текущее время',
+    category: 'Время',
+    description: 'Возвращает текущую дату и время.',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/time/now').evaluate,
+    pins: {
+      inputs: [],
+      outputs: [
+        { id: 'now', name: 'Сейчас', type: 'DateTime' }
+      ]
+    }
+  });
+
+  registry.registerNodeType({
+    type: 'time:format',
+    label: '📝 Отформатировать дату',
+    category: 'Время',
+    description: 'Форматирует дату в строку. Формат по-умолчанию: yyyy-MM-dd HH:mm:ss',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/time/format').evaluate,
+    pins: {
+      inputs: [
+        { id: 'date', name: 'Дата', type: 'DateTime', required: true },
+        { id: 'format', name: 'Формат', type: 'String', required: false }
+      ],
+      outputs: [
+        { id: 'formatted', name: 'Строка', type: 'String' }
+      ]
+    }
+  });
+
+  registry.registerNodeType({
+    type: 'time:add',
+    label: '➕ Прибавить время',
+    category: 'Время',
+    description: 'Добавляет к дате указанный промежуток времени. Пример объекта продолжительности: { "seconds": 5, "minutes": 1 }',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/time/add').evaluate,
+    pins: {
+      inputs: [
+        { id: 'date', name: 'Дата', type: 'DateTime', required: true },
+        { id: 'duration', name: 'Продолжительность (объект)', type: 'Object', required: true }
+      ],
+      outputs: [
+        { id: 'result', name: 'Новая дата', type: 'DateTime' }
+      ]
+    }
+  });
+
+  registry.registerNodeType({
+    type: 'time:diff',
+    label: '↔️ Разница во времени',
+    category: 'Время',
+    description: 'Вычисляет разницу между двумя датами в миллисекундах (Дата А - Дата Б).',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/time/diff').evaluate,
+    pins: {
+      inputs: [
+        { id: 'date_left', name: 'Дата А', type: 'DateTime', required: true },
+        { id: 'date_right', name: 'Дата Б', type: 'DateTime', required: true }
+      ],
+      outputs: [
+        { id: 'diff', name: 'Разница (мс)', type: 'Number' }
+      ]
+    }
+  });
+
+  registry.registerNodeType({
+    type: 'time:compare',
+    label: '⚖️ Сравнить даты',
+    category: 'Время',
+    description: 'Сравнивает две даты.',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/time/compare').evaluate,
+    pins: {
+      inputs: [
+        { id: 'date_left', name: 'Дата А', type: 'DateTime', required: true },
+        { id: 'date_right', name: 'Дата Б', type: 'DateTime', required: true },
+        { id: 'operation', name: 'Операция', type: 'String', required: false }
+      ],
+      outputs: [
+        { id: 'result', name: 'Результат', type: 'Boolean' }
+      ]
+    }
+  });
+}
+
+module.exports = { registerNodes };

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

@@ -0,0 +1,79 @@
+const { GRAPH_TYPES } = require('../constants/graphTypes');
+
+/**
+ * Регистрация нод категории "Пользователи"
+ */
+function registerNodes(registry) {
+  registry.registerNodeType({
+    type: 'user:check_blacklist',
+    label: '❓ В черном списке?',
+    category: 'Пользователи',
+    description: 'Проверяет, находится ли пользователь в черном списке.',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/users/check_blacklist').evaluate,
+    pins: {
+      inputs: [
+        { id: 'user', name: 'Пользователь', type: 'User', required: true }
+      ],
+      outputs: [
+        { id: 'is_blacklisted', name: 'В ЧС', type: 'Boolean' }
+      ]
+    }
+  });
+
+  registry.registerNodeType({
+    type: 'user:set_blacklist',
+    label: '🚫 Установить ЧС',
+    category: 'Пользователи',
+    description: 'Добавляет или убирает пользователя из черного списка.',
+    graphType: GRAPH_TYPES.ALL,
+    executor: require('../nodes/users/set_blacklist').execute,
+    pins: {
+      inputs: [
+        { id: 'exec', name: 'Выполнить', type: 'Exec', required: true },
+        { id: 'user', name: 'Пользователь', type: 'User', required: true },
+        { id: 'blacklist_status', name: 'Статус ЧС', type: 'Boolean', required: true }
+      ],
+      outputs: [
+        { id: 'exec', name: 'Далее', type: 'Exec' },
+        { id: 'updated_user', name: 'Обновленный пользователь', type: 'User' }
+      ]
+    }
+  });
+
+  registry.registerNodeType({
+    type: 'user:get_groups',
+    label: '👥 Получить группы',
+    category: 'Пользователи',
+    description: 'Возвращает массив названий групп, в которых состоит пользователь.',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/users/get_groups').evaluate,
+    pins: {
+      inputs: [
+        { id: 'user', name: 'Пользователь', type: 'User', required: true }
+      ],
+      outputs: [
+        { id: 'groups', name: 'Группы', type: 'Array' }
+      ]
+    }
+  });
+
+  registry.registerNodeType({
+    type: 'user:get_permissions',
+    label: '🔑 Получить права',
+    category: 'Пользователи',
+    description: 'Возвращает массив прав пользователя.',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/users/get_permissions').evaluate,
+    pins: {
+      inputs: [
+        { id: 'user', name: 'Пользователь', type: 'User', required: true }
+      ],
+      outputs: [
+        { id: 'permissions', name: 'Права', type: 'Array' }
+      ]
+    }
+  });
+}
+
+module.exports = { registerNodes };

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

@@ -0,0 +1,36 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    const target = await resolvePinValue(node, 'target');
+    const yOffset = await resolvePinValue(node, 'add_y', 0);
+
+    if (target && context.bot?.lookAt) {
+        let finalPosition;
+        // Если цель - это сущность, у которой есть позиция
+        if (target.position) {
+            finalPosition = { ...target.position };
+        }
+        // Если цель - это объект с координатами
+        else if (target.x !== undefined && target.y !== undefined && target.z !== undefined) {
+            finalPosition = { ...target };
+        }
+
+        if (finalPosition) {
+            finalPosition.y += Number(yOffset || 0);
+            context.bot.lookAt(finalPosition);
+        }
+    }
+
+    await traverse(node, 'exec');
+}
+
+module.exports = {
+    execute,
+};

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

@@ -0,0 +1,32 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    const varName = await resolvePinValue(node, 'name', '');
+    const varValue = await resolvePinValue(node, 'value');
+    let shouldPersist = await resolvePinValue(node, 'persist', false);
+
+    // В графах команд принудительно отключаем сохранение в БД, чтобы избежать случайных записей
+    if (context.eventType === 'command') {
+        shouldPersist = false;
+    }
+
+    if (varName) {
+        context.variables[varName] = varValue;
+        if (context.persistenceIntent) {
+          context.persistenceIntent.set(varName, shouldPersist);
+        }
+    }
+
+    await traverse(node, 'exec');
+}
+
+module.exports = {
+    execute,
+};

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

@@ -0,0 +1,98 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ * @param {Map} helpers.memo - Карта для мемоизации значений.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse, memo } = helpers;
+
+    const url = await resolvePinValue(node, 'url', '');
+    const method = await resolvePinValue(node, 'method', node.data?.method || 'GET');
+    const headersStr = await resolvePinValue(node, 'headers', '');
+    const body = await resolvePinValue(node, 'body', '');
+    const timeout = await resolvePinValue(node, 'timeout', 5000);
+
+    let headers = {};
+    if (headersStr) {
+        try {
+            headers = JSON.parse(headersStr);
+        } catch (e) {
+            console.error('[HTTP Request] Ошибка парсинга headers:', e);
+            headers = {};
+        }
+    }
+
+    let requestBody = null;
+    if (body && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+        if (typeof body === 'object') {
+            requestBody = JSON.stringify(body);
+        } else if (typeof body === 'string') {
+            // Пробуем распарсить строку как JSON
+            try {
+                const parsed = JSON.parse(body);
+                requestBody = JSON.stringify(parsed);
+            } catch {
+                // Если не JSON, отправляем как есть
+                requestBody = body;
+            }
+        } else {
+            requestBody = String(body);
+        }
+
+        if (!headers['Content-Type']) {
+            headers['Content-Type'] = 'application/json';
+        }
+    }
+
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+        const response = await fetch(url, {
+            method,
+            headers,
+            body: requestBody,
+            signal: controller.signal
+        });
+
+        clearTimeout(timeoutId);
+
+        const responseText = await response.text();
+        let responseBody;
+        try {
+            responseBody = JSON.parse(responseText);
+        } catch {
+            responseBody = responseText;
+        }
+
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+            responseHeaders[key] = value;
+        });
+
+        memo.set(`${node.id}:status`, response.status);
+        memo.set(`${node.id}:response`, responseBody);
+        memo.set(`${node.id}:response_headers`, responseHeaders);
+        memo.set(`${node.id}:success`, response.ok);
+        memo.set(`${node.id}:error`, null);
+
+        await traverse(node, 'exec');
+    } catch (error) {
+        console.error('[HTTP Request] Ошибка запроса:', error);
+
+        memo.set(`${node.id}:status`, 0);
+        memo.set(`${node.id}:response`, null);
+        memo.set(`${node.id}:response_headers`, {});
+        memo.set(`${node.id}:success`, false);
+        memo.set(`${node.id}:error`, error.message);
+
+        await traverse(node, 'exec_error');
+    }
+}
+
+module.exports = {
+    execute,
+};

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

@@ -0,0 +1,28 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    let message = await helpers.resolvePinValue(node, 'message', '');
+
+    // Если сообщение - это объект или массив, форматируем как JSON
+    if (typeof message === 'object' && message !== null) {
+        message = JSON.stringify(message, null, 2);
+    }
+
+    if (context?.bot?.sendLog) {
+        context.bot.sendLog(`[Graph] ${message}`);
+    } else {
+        // Fallback - консоль терминала
+        console.log(`[Graph Log] ${message}`);
+    }
+
+    await helpers.traverse(node, 'exec');
+}
+
+module.exports = {
+    execute,
+};

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

@@ -0,0 +1,32 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    let 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');
+}
+
+module.exports = {
+    execute,
+};

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

@@ -0,0 +1,33 @@
+/**
+ * Нода: Отправить ответ в WebSocket
+ * Отправляет данные обратно клиенту, вызвавшему граф через WebSocket API
+ *
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const data = await helpers.resolvePinValue(node, 'data', null);
+
+    // Проверяем, что граф был вызван через WebSocket API
+    if (!context.sendResponse || typeof context.sendResponse !== 'function') {
+        console.warn('[WebSocket Response] Нода может использоваться только в графах, вызванных через WebSocket API');
+        await helpers.traverse(node, 'exec');
+        return;
+    }
+
+    // Отправляем ответ клиенту
+    try {
+        context.sendResponse(data);
+        console.log('[WebSocket Response] Ответ отправлен клиенту:', data);
+    } catch (error) {
+        console.error('[WebSocket Response] Ошибка отправки ответа:', error);
+    }
+
+    // Продолжаем выполнение графа
+    await helpers.traverse(node, 'exec');
+}
+
+module.exports = { execute };

package/backend/src/core/nodes/arrays/add_element.js

@@ -0,0 +1,23 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const arr = await resolvePinValue(node, 'array', []);
+        const element = await resolvePinValue(node, 'element', null);
+        return Array.isArray(arr) ? [...arr, element] : [element];
+    }
+
+    return [];
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/arrays/contains.js

@@ -0,0 +1,40 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @param {Map} helpers.memo - Map для хранения мемоизированных значений.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue, memo } = helpers;
+
+    const arr = await resolvePinValue(node, 'array', []);
+    const element = await resolvePinValue(node, 'element', null);
+
+    if (Array.isArray(arr)) {
+        const index = arr.indexOf(element);
+        memo.set(`${node.id}:index`, index);
+
+        if (pinId === 'result') {
+            return index !== -1;
+        } else if (pinId === 'index') {
+            return index;
+        }
+    } else {
+        memo.set(`${node.id}:index`, -1);
+
+        if (pinId === 'result') {
+            return false;
+        } else if (pinId === 'index') {
+            return -1;
+        }
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/arrays/find_index.js

@@ -0,0 +1,23 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'index') {
+        const arr = await resolvePinValue(node, 'array', []);
+        const element = await resolvePinValue(node, 'element', null);
+        return Array.isArray(arr) ? arr.indexOf(element) : -1;
+    }
+
+    return -1;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/arrays/get_by_index.js

@@ -0,0 +1,23 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'element') {
+        const arr = await resolvePinValue(node, 'array', []);
+        const index = await resolvePinValue(node, 'index', -1);
+        return (!Array.isArray(arr) || index < 0 || index >= arr.length) ? null : arr[index];
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/arrays/get_next.js

@@ -0,0 +1,35 @@
+/**
+ * Получает следующий элемент массива по текущему индексу
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+    const arr = await resolvePinValue(node, 'array', []);
+    const currentIndex = await resolvePinValue(node, 'current_index', -1);
+    
+    const nextIndex = currentIndex + 1;
+    const hasNext = Array.isArray(arr) && nextIndex >= 0 && nextIndex < arr.length;
+
+    switch (pinId) {
+        case 'next_element':
+            return hasNext ? arr[nextIndex] : null;
+        
+        case 'next_index':
+            return nextIndex;
+        
+        case 'has_next':
+            return hasNext;
+        
+        default:
+            return null;
+    }
+}
+
+module.exports = {
+    evaluate,
+};
+
+
+
+
+
+

package/backend/src/core/nodes/arrays/get_random_element.js

@@ -0,0 +1,32 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @param {Map} helpers.memo - Map для хранения мемоизированных значений.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue, memo } = helpers;
+
+    const arr = await resolvePinValue(node, 'array', []);
+    if (!Array.isArray(arr) || arr.length === 0) {
+        return pinId === 'index' ? -1 : null;
+    }
+
+    const randomIndex = Math.floor(Math.random() * arr.length);
+    memo.set(`${node.id}:index`, randomIndex);
+
+    if (pinId === 'element') {
+        return arr[randomIndex];
+    } else if (pinId === 'index') {
+        return randomIndex;
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/arrays/remove_by_index.js

@@ -0,0 +1,30 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const arr = await resolvePinValue(node, 'array', []);
+        const index = await resolvePinValue(node, 'index', -1);
+
+        if (!Array.isArray(arr) || index < 0 || index >= arr.length) {
+            return arr || [];
+        }
+
+        const newArr = [...arr];
+        newArr.splice(index, 1);
+        return newArr;
+    }
+
+    return [];
+}
+
+module.exports = {
+    evaluate,
+};