blockmine 1.16.2 → 1.17.0

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

@@ -22,6 +22,173 @@ const upload = multer({ storage: multer.memoryStorage() });
 
 const router = express.Router();
 
+const conditionalRestartAuth = (req, res, next) => {
+    if (process.env.DEBUG === 'true' || process.env.NODE_ENV === 'development') {
+        console.log('[Debug] Роут перезапуска бота доступен без проверки прав');
+        return next();
+    }
+    
+    return authenticate(req, res, (err) => {
+        if (err) return next(err);
+        return authorize('bot:start_stop')(req, res, next);
+    });
+};
+
+const conditionalChatAuth = (req, res, next) => {
+    if (process.env.DEBUG === 'true' || process.env.NODE_ENV === 'development') {
+        console.log('[Debug] Роут отправки сообщения боту доступен без проверки прав');
+        return next();
+    }
+    
+    return authenticate(req, res, (err) => {
+        if (err) return next(err);
+        return authorize('bot:interact')(req, res, next);
+    });
+};
+
+const conditionalStartStopAuth = (req, res, next) => {
+    if (process.env.DEBUG === 'true' || process.env.NODE_ENV === 'development') {
+        console.log('[Debug] Роут запуска/остановки бота доступен без проверки прав');
+        return next();
+    }
+    
+    return authenticate(req, res, (err) => {
+        if (err) return next(err);
+        return authorize('bot:start_stop')(req, res, next);
+    });
+};
+
+const conditionalListAuth = (req, res, next) => {
+    if (process.env.DEBUG === 'true' || process.env.NODE_ENV === 'development') {
+        console.log('[Debug] Роут списка ботов/состояния доступен без проверки прав');
+        return next();
+    }
+    
+    return authenticate(req, res, (err) => {
+        if (err) return next(err);
+        return authorize('bot:list')(req, res, next);
+    });
+};
+
+router.post('/:id/restart', conditionalRestartAuth, async (req, res) => {
+    try {
+        const botId = parseInt(req.params.id, 10);
+        botManager.stopBot(botId);
+        setTimeout(async () => {
+            const botConfig = await prisma.bot.findUnique({ where: { id: botId }, include: { server: true } });
+            if (!botConfig) {
+                return res.status(404).json({ success: false, message: 'Бот не найден' });
+            }
+            botManager.startBot(botConfig);
+            res.status(202).json({ success: true, message: 'Команда на перезапуск отправлена.' });
+        }, 1000);
+    } catch (error) {
+        console.error(`[API] Ошибка перезапуска бота ${req.params.id}:`, error);
+        res.status(500).json({ success: false, message: 'Ошибка при перезапуске бота: ' + error.message });
+    }
+});
+
+router.post('/:id/chat', conditionalChatAuth, (req, res) => {
+    try {
+        const botId = parseInt(req.params.id, 10);
+        const { message } = req.body;
+        if (!message) return res.status(400).json({ error: 'Сообщение не может быть пустым' });
+        const result = botManager.sendMessageToBot(botId, message);
+        if (result.success) res.json({ success: true });
+        else res.status(404).json(result);
+    } catch (error) { res.status(500).json({ error: 'Внутренняя ошибка сервера: ' + error.message }); }
+});
+
+router.post('/:id/start', conditionalStartStopAuth, async (req, res) => {
+    try {
+        const botId = parseInt(req.params.id, 10);
+        const botConfig = await prisma.bot.findUnique({ where: { id: botId }, include: { server: true } });
+        if (!botConfig) {
+            return res.status(404).json({ success: false, message: 'Бот не найден' });
+        }
+        botManager.startBot(botConfig);
+        res.status(202).json({ success: true, message: 'Команда на запуск отправлена.' });
+    } catch (error) {
+        console.error(`[API] Ошибка запуска бота ${req.params.id}:`, error);
+        res.status(500).json({ success: false, message: 'Ошибка при запуске бота: ' + error.message });
+    }
+});
+
+router.post('/:id/stop', conditionalStartStopAuth, (req, res) => {
+    try {
+        const botId = parseInt(req.params.id, 10);
+        botManager.stopBot(botId);
+        res.status(202).json({ success: true, message: 'Команда на остановку отправлена.' });
+    } catch (error) {
+        console.error(`[API] Ошибка остановки бота ${req.params.id}:`, error);
+        res.status(500).json({ success: false, message: 'Ошибка при остановке бота: ' + error.message });
+    }
+});
+
+router.get('/', conditionalListAuth, async (req, res) => {
+    try {
+        const botsWithoutSortOrder = await prisma.bot.findMany({
+            where: { sortOrder: null },
+            select: { id: true }
+        });
+        
+        if (botsWithoutSortOrder.length > 0) {
+            console.log(`[API] Обновляем sortOrder для ${botsWithoutSortOrder.length} ботов`);
+            for (const bot of botsWithoutSortOrder) {
+                await prisma.bot.update({
+                    where: { id: bot.id },
+                    data: { sortOrder: bot.id }
+                });
+            }
+        }
+        
+        const bots = await prisma.bot.findMany({ 
+            include: { server: true }, 
+            orderBy: { sortOrder: 'asc' } 
+        });
+        res.json(bots);
+    } catch (error) { 
+        console.error("[API /api/bots] Ошибка получения списка ботов:", error);
+        res.status(500).json({ error: 'Не удалось получить список ботов' }); 
+    }
+});
+
+router.get('/state', conditionalListAuth, (req, res) => {
+    try {
+        const state = botManager.getFullState();
+        res.json(state);
+    } catch (error) { res.status(500).json({ error: 'Не удалось получить состояние ботов' }); }
+});
+
+router.get('/:id/logs', conditionalListAuth, (req, res) => {
+    try {
+        const botId = parseInt(req.params.id, 10);
+        const { limit = 100, offset = 0 } = req.query;
+        
+        const logs = botManager.getBotLogs(botId);
+        
+        const startIndex = parseInt(offset);
+        const endIndex = startIndex + parseInt(limit);
+        const paginatedLogs = logs.slice(startIndex, endIndex);
+        
+        res.json({
+            success: true,
+            data: {
+                logs: paginatedLogs,
+                pagination: {
+                    total: logs.length,
+                    limit: parseInt(limit),
+                    offset: startIndex,
+                    hasMore: endIndex < logs.length
+                }
+            }
+        });
+    } catch (error) { 
+        console.error(`[API] Ошибка получения логов бота ${req.params.id}:`, error);
+        res.status(500).json({ error: 'Не удалось получить логи бота' }); 
+    }
+});
+
 router.use(authenticate);
 router.use('/:botId/event-graphs', eventGraphsRouter);
 router.use('/:botId/plugins/ide', pluginIdeRouter);
@@ -62,34 +229,25 @@ async function setupDefaultPermissionsForBot(botId, prismaClient = prisma) {
     console.log(`[Setup] Для бота ID ${botId} созданы группы и права по умолчанию.`);
 }
 
-router.get('/', authorize('bot:list'), async (req, res) => {
-    try {
-        const bots = await prisma.bot.findMany({ include: { server: true }, orderBy: { createdAt: 'asc' } });
-        res.json(bots);
-    } catch (error) { 
-        console.error("[API /api/bots] Ошибка получения списка ботов:", error);
-        res.status(500).json({ error: 'Не удалось получить список ботов' }); 
-    }
-});
 
-router.get('/state', authorize('bot:list'), (req, res) => {
-    try {
-        const state = botManager.getFullState();
-        res.json(state);
-    } catch (error) { res.status(500).json({ error: 'Не удалось получить состояние ботов' }); }
-});
 
 router.post('/', authorize('bot:create'), async (req, res) => {
     try {
         const { username, password, prefix, serverId, note } = req.body;
         if (!username || !serverId) return res.status(400).json({ error: 'Имя и сервер обязательны' });
         
+        const maxSortOrder = await prisma.bot.aggregate({
+            _max: { sortOrder: true }
+        });
+        const nextSortOrder = (maxSortOrder._max.sortOrder || 0) + 1;
+        
         const data = { 
             username, 
             prefix, 
             note, 
             serverId: parseInt(serverId, 10),
-            password: password ? encrypt(password) : null 
+            password: password ? encrypt(password) : null,
+            sortOrder: nextSortOrder
         };
 
         const newBot = await prisma.bot.create({
@@ -168,98 +326,102 @@ router.put('/:id', authorize('bot:update'), async (req, res) => {
         const updatedBot = await prisma.bot.update({
             where: { id: botId },
             data: dataToUpdate,
-            include: {
-                server: true
-            }
+            include: { server: true }
         });
 
-        const botManager = req.app.get('botManager');
-        botManager.reloadBotConfigInRealTime(botId);
-
         res.json(updatedBot);
     } catch (error) {
-        console.error('Error updating bot:', error);
-        console.error('Error details:', {
-            code: error.code,
-            meta: error.meta,
-            message: error.message
-        });
-        
-        if (error.code === 'P2002' && error.meta?.target?.includes('username')) {
-            return res.status(400).json({ 
-                message: 'Бот с таким именем уже существует. Выберите другое имя.' 
-            });
-        }
-        
-        res.status(500).json({ message: `Не удалось обновить бота: ${error.message}` });
+        console.error("[API Error] /bots PUT:", error);
+        res.status(500).json({ error: 'Не удалось обновить бота' });
     }
 });
 
-router.delete('/:id', authorize('bot:delete'), async (req, res) => {
+router.put('/:id/sort-order', authorize('bot:update'), async (req, res) => {
     try {
+        const { newPosition } = req.body;
         const botId = parseInt(req.params.id, 10);
-        if (botManager.bots.has(botId)) return res.status(400).json({ error: 'Нельзя удалить запущенного бота' });
-        await prisma.bot.delete({ where: { id: botId } });
-        res.status(204).send();
-    } catch (error) { res.status(500).json({ error: 'Не удалось удалить бота' }); }
-});
+        
+        console.log(`[API] Запрос на изменение порядка бота ${botId} на позицию ${newPosition}`);
+        
+        if (isNaN(botId) || typeof newPosition !== 'number') {
+            console.log(`[API] Неверные параметры: botId=${botId}, newPosition=${newPosition}`);
+            return res.status(400).json({ error: 'Неверные параметры' });
+        }
 
-router.post('/:id/start', authorize('bot:start_stop'), async (req, res) => {
-    try {
-        const botId = parseInt(req.params.id, 10);
-        const botConfig = await prisma.bot.findUnique({ where: { id: botId }, include: { server: true } });
-        if (!botConfig) {
-            return res.status(404).json({ success: false, message: 'Бот не найден' });
+        const currentBot = await prisma.bot.findUnique({
+            where: { id: botId },
+            select: { sortOrder: true }
+        });
+
+        if (!currentBot) {
+            console.log(`[API] Бот ${botId} не найден`);
+            return res.status(404).json({ error: 'Бот не найден' });
         }
-        botManager.startBot(botConfig);
-        res.status(202).json({ success: true, message: 'Команда на запуск отправлена.' });
-    } catch (error) { 
-        console.error(`[API] Ошибка запуска бота ${req.params.id}:`, error);
-        res.status(500).json({ success: false, message: 'Ошибка при запуске бота: ' + error.message }); 
-    }
-});
 
-router.post('/:id/stop', authorize('bot:start_stop'), (req, res) => {
-    try {
-        const botId = parseInt(req.params.id, 10);
-        botManager.stopBot(botId);
-        res.status(202).json({ success: true, message: 'Команда на остановку отправлена.' });
-    } catch (error) {
-        console.error(`[API] Ошибка остановки бота ${req.params.id}:`, error);
-        res.status(500).json({ success: false, message: 'Ошибка при остановке бота: ' + error.message });
-    }
-});
+        const currentPosition = currentBot.sortOrder;
+        console.log(`[API] Текущая позиция бота ${botId}: ${currentPosition}, новая позиция: ${newPosition}`);
+        
+        if (newPosition === currentPosition) {
+            console.log(`[API] Позиция не изменилась для бота ${botId}`);
+            return res.json({ success: true, message: 'Позиция не изменилась' });
+        }
 
-router.post('/:id/restart', authorize('bot:start_stop'), async (req, res) => {
-    try {
-        const botId = parseInt(req.params.id, 10);
-        botManager.stopBot(botId);
-        setTimeout(async () => {
-            const botConfig = await prisma.bot.findUnique({ where: { id: botId }, include: { server: true } });
-            if (!botConfig) {
-                return res.status(404).json({ success: false, message: 'Бот не найден' });
-            }
-            botManager.startBot(botConfig);
-            res.status(202).json({ success: true, message: 'Команда на перезапуск отправлена.' });
-        }, 1000);
+        if (newPosition > currentPosition) {
+            console.log(`[API] Перемещаем бота ${botId} вниз с позиции ${currentPosition} на ${newPosition}`);
+            const updateResult = await prisma.bot.updateMany({
+                where: {
+                    sortOrder: {
+                        gt: currentPosition,
+                        lte: newPosition
+                    }
+                },
+                data: {
+                    sortOrder: {
+                        decrement: 1
+                    }
+                }
+            });
+            console.log(`[API] Обновлено ${updateResult.count} ботов при перемещении вниз`);
+        } else {
+            console.log(`[API] Перемещаем бота ${botId} вверх с позиции ${currentPosition} на ${newPosition}`);
+            const updateResult = await prisma.bot.updateMany({
+                where: {
+                    sortOrder: {
+                        gte: newPosition,
+                        lt: currentPosition
+                    }
+                },
+                data: {
+                    sortOrder: {
+                        increment: 1
+                    }
+                }
+            });
+            console.log(`[API] Обновлено ${updateResult.count} ботов при перемещении вверх`);
+        }
+
+        await prisma.bot.update({
+            where: { id: botId },
+            data: { sortOrder: newPosition }
+        });
+
+        console.log(`[API] Успешно обновлен порядок бота ${botId} на позицию ${newPosition}`);
+        res.json({ success: true, message: 'Порядок ботов обновлен' });
     } catch (error) {
-        console.error(`[API] Ошибка перезапуска бота ${req.params.id}:`, error);
-        res.status(500).json({ success: false, message: 'Ошибка при перезапуске бота: ' + error.message });
+        console.error("[API Error] /bots sort-order PUT:", error);
+        res.status(500).json({ error: 'Не удалось обновить порядок ботов' });
     }
 });
 
-router.post('/:id/chat', authorize('bot:interact'), (req, res) => {
+router.delete('/:id', authorize('bot:delete'), async (req, res) => {
     try {
         const botId = parseInt(req.params.id, 10);
-        const { message } = req.body;
-        if (!message) return res.status(400).json({ error: 'Сообщение не может быть пустым' });
-        const result = botManager.sendMessageToBot(botId, message);
-        if (result.success) res.json({ success: true });
-        else res.status(404).json(result);
-    } catch (error) { res.status(500).json({ error: 'Внутренняя ошибка сервера: ' + error.message }); }
+        if (botManager.bots.has(botId)) return res.status(400).json({ error: 'Нельзя удалить запущенного бота' });
+        await prisma.bot.delete({ where: { id: botId } });
+        res.status(204).send();
+    } catch (error) { res.status(500).json({ error: 'Не удалось удалить бота' }); }
 });
 
-
 router.get('/servers', authorize('bot:list'), async (req, res) => {
     try {
         const servers = await prisma.server.findMany();
@@ -317,24 +479,49 @@ router.get('/:botId/plugins/:pluginId/settings', authorize('plugin:settings:view
         if (!plugin) return res.status(404).json({ error: 'Установленный плагин не найден' });
 
         const savedSettings = plugin.settings ? JSON.parse(plugin.settings) : {};
-        let defaultSettings = {};
+        const defaultSettings = {};
         const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
+        const manifestSettings = manifest.settings || {};
 
-        if (manifest.settings) {
-            for (const key in manifest.settings) {
-                const config = manifest.settings[key];
-                if (config.type === 'json_file' && config.defaultPath) {
-                    const configFilePath = path.join(plugin.path, config.defaultPath);
-                    try {
-                        const fileContent = await fs.readFile(configFilePath, 'utf-8');
-                        defaultSettings[key] = JSON.parse(fileContent);
-                    } catch (e) { defaultSettings[key] = {}; }
-                } else {
-                    try { defaultSettings[key] = JSON.parse(config.default || 'null'); } 
-                    catch { defaultSettings[key] = config.default; }
+
+        const firstSettingValue = Object.values(manifestSettings)[0];
+        const isGrouped = firstSettingValue && typeof firstSettingValue === 'object' && !firstSettingValue.type && firstSettingValue.label;
+
+        const processSetting = async (settingKey, config) => {
+            if (!config || !config.type) return;
+
+            if (config.type === 'json_file' && config.defaultPath) {
+                const configFilePath = path.join(plugin.path, config.defaultPath);
+                try {
+                    const fileContent = await fs.readFile(configFilePath, 'utf-8');
+                    defaultSettings[settingKey] = JSON.parse(fileContent);
+                } catch (e) {
+                    console.error(`[API Settings] Не удалось прочитать defaultPath ${config.defaultPath} для плагина ${plugin.name}: ${e.message}`);
+                    defaultSettings[settingKey] = {};
+                }
+            } else if (config.default !== undefined) {
+                try {
+                    defaultSettings[settingKey] = JSON.parse(config.default);
+                } catch {
+                    defaultSettings[settingKey] = config.default;
                 }
             }
+        };
+
+        if (isGrouped) {
+            for (const categoryKey in manifestSettings) {
+                const categoryConfig = manifestSettings[categoryKey];
+                for (const settingKey in categoryConfig) {
+                    if (settingKey === 'label') continue;
+                    await processSetting(settingKey, categoryConfig[settingKey]);
+                }
+            }
+        } else {
+            for (const settingKey in manifestSettings) {
+                await processSetting(settingKey, manifestSettings[settingKey]);
+            }
         }
+
         const finalSettings = { ...defaultSettings, ...savedSettings };
         res.json(finalSettings);
     } catch (error) {
@@ -1492,6 +1679,25 @@ router.get('/:botId/export', authorize('bot:export'), async (req, res) => {
             const installedPlugins = await prisma.installedPlugin.findMany({ where: { botId } });
             archive.append(JSON.stringify(installedPlugins, null, 2), { name: 'plugins.json' });
 
+            try {
+                const installedPlugins = await prisma.installedPlugin.findMany({ where: { botId } });
+                const pluginSettings = installedPlugins
+                    .filter(plugin => plugin.settings && plugin.settings !== '{}')
+                    .map(plugin => ({
+                        pluginName: plugin.name,
+                        settings: plugin.settings
+                    }));
+                
+                if (pluginSettings.length > 0) {
+                    console.log(`[Export] Экспорт настроек плагинов для бота ${botId}: ${pluginSettings.length} настроек`);
+                    archive.append(JSON.stringify(pluginSettings, null, 2), { name: 'settings.json' });
+                } else {
+                    console.log(`[Export] Нет настроек плагинов для экспорта`);
+                }
+            } catch (error) {
+                console.warn(`[Export] Ошибка при экспорте настроек плагинов:`, error.message);
+            }
+
             if (includePluginFiles === 'true') {
                 for (const plugin of installedPlugins) {
                     const pluginPath = plugin.path;
@@ -1519,7 +1725,9 @@ router.get('/:botId/export', authorize('bot:export'), async (req, res) => {
 
     } catch (error) {
         console.error('Failed to export bot:', error);
-        res.status(500).json({ error: `Failed to export bot: ${error.message}` });
+        if (!res.headersSent) {
+            res.status(500).json({ error: `Failed to export bot: ${error.message}` });
+        }
     }
 });
 
@@ -1716,4 +1924,221 @@ router.post('/import', authorize('bot:create'), upload.single('file'), async (re
     }
 });
 
+router.post('/import/preview', authorize('bot:create'), upload.single('file'), async (req, res) => {
+    try {
+        if (!req.file) {
+            return res.status(400).json({ error: 'Файл не загружен' });
+        }
+
+        const tempDir = path.join(os.tmpdir(), `import-${Date.now()}`);
+        await fse.ensureDir(tempDir);
+
+        try {
+            const zip = new AdmZip(req.file.buffer);
+            zip.extractAllTo(tempDir, true);
+
+            console.log('[Import] Файлы в архиве:', zip.getEntries().map(entry => entry.entryName));
+
+            const importData = {
+                plugins: [],
+                commands: [],
+                eventGraphs: [],
+                settings: null,
+                bot: null
+            };
+
+            const botConfigPath = path.join(tempDir, 'bot.json');
+            if (await fse.pathExists(botConfigPath)) {
+                console.log('[Import] Найден bot.json');
+                const botConfig = JSON.parse(await fse.readFile(botConfigPath, 'utf8'));
+                delete botConfig.password;
+                delete botConfig.proxyPassword;
+                delete botConfig.id;
+                delete botConfig.createdAt;
+                delete botConfig.updatedAt;
+                importData.bot = botConfig;
+            } else {
+                console.log('[Import] bot.json не найден');
+            }
+
+            const pluginsPath = path.join(tempDir, 'plugins.json');
+            if (await fse.pathExists(pluginsPath)) {
+                console.log('[Import] Найден plugins.json');
+                importData.plugins = JSON.parse(await fse.readFile(pluginsPath, 'utf8'));
+                console.log('[Import] Плагинов:', importData.plugins.length);
+            } else {
+                console.log('[Import] plugins.json не найден');
+            }
+
+            const commandsPath = path.join(tempDir, 'commands.json');
+            if (await fse.pathExists(commandsPath)) {
+                console.log('[Import] Найден commands.json');
+                importData.commands = JSON.parse(await fse.readFile(commandsPath, 'utf8'));
+                console.log('[Import] Команд:', importData.commands.length);
+            } else {
+                console.log('[Import] commands.json не найден');
+            }
+
+            const eventGraphsPath = path.join(tempDir, 'event_graphs.json');
+            if (await fse.pathExists(eventGraphsPath)) {
+                console.log('[Import] Найден event_graphs.json');
+                importData.eventGraphs = JSON.parse(await fse.readFile(eventGraphsPath, 'utf8'));
+                console.log('[Import] Графов событий:', importData.eventGraphs.length);
+            } else {
+                console.log('[Import] event_graphs.json не найден');
+                const eventGraphsPathAlt = path.join(tempDir, 'event-graphs.json');
+                if (await fse.pathExists(eventGraphsPathAlt)) {
+                    console.log('[Import] Найден event-graphs.json');
+                    importData.eventGraphs = JSON.parse(await fse.readFile(eventGraphsPathAlt, 'utf8'));
+                    console.log('[Import] Графов событий:', importData.eventGraphs.length);
+                } else {
+                    console.log('[Import] event-graphs.json тоже не найден');
+                }
+            }
+
+            const settingsPath = path.join(tempDir, 'settings.json');
+            if (await fse.pathExists(settingsPath)) {
+                console.log('[Import] Найден settings.json');
+                importData.settings = JSON.parse(await fse.readFile(settingsPath, 'utf8'));
+            } else {
+                console.log('[Import] settings.json не найден');
+            }
+
+            console.log('[Import] Итоговые данные:', {
+                plugins: importData.plugins.length,
+                commands: importData.commands.length,
+                eventGraphs: importData.eventGraphs.length,
+                hasSettings: !!importData.settings,
+                hasBot: !!importData.bot
+            });
+
+            res.json(importData);
+
+        } finally {
+            await fse.remove(tempDir);
+        }
+
+    } catch (error) {
+        console.error('[API Error] /bots/import/preview:', error);
+        res.status(500).json({ error: 'Не удалось обработать архив импорта' });
+    }
+});
+
+router.post('/import/create', authorize('bot:create'), async (req, res) => {
+    try {
+        const { username, password, prefix, serverId, note, owners, proxyHost, proxyPort, proxyUsername, proxyPassword, importData } = req.body;
+        
+        if (!username || !serverId) {
+            return res.status(400).json({ error: 'Имя и сервер обязательны' });
+        }
+
+        const botData = { 
+            username, 
+            prefix, 
+            note, 
+            serverId: parseInt(serverId, 10),
+            password: password ? encrypt(password) : null,
+            owners: owners || '',
+            proxyHost: proxyHost || null,
+            proxyPort: proxyPort ? parseInt(proxyPort, 10) : null,
+            proxyUsername: proxyUsername || null,
+            proxyPassword: proxyPassword ? encrypt(proxyPassword) : null
+        };
+
+        const newBot = await prisma.bot.create({
+            data: botData,
+            include: { server: true }
+        });
+
+        await setupDefaultPermissionsForBot(newBot.id);
+
+        if (importData) {
+            try {
+                if (importData.plugins && Array.isArray(importData.plugins)) {
+                    for (const plugin of importData.plugins) {
+                        try {
+                            await prisma.installedPlugin.create({
+                                data: {
+                                    ...plugin,
+                                    botId: newBot.id,
+                                    id: undefined
+                                }
+                            });
+                            console.log(`[Import] Импортирован плагин ${plugin.name}`);
+                        } catch (error) {
+                            console.warn(`[Import] Не удалось импортировать плагин ${plugin.name}:`, error.message);
+                        }
+                    }
+                }
+
+                if (importData.commands && Array.isArray(importData.commands)) {
+                    for (const command of importData.commands) {
+                        try {
+                            await prisma.command.create({
+                                data: {
+                                    ...command,
+                                    botId: newBot.id,
+                                    id: undefined
+                                }
+                            });
+                        } catch (error) {
+                            console.warn(`[Import] Не удалось импортировать команду ${command.name}:`, error.message);
+                        }
+                    }
+                }
+
+                if (importData.eventGraphs && Array.isArray(importData.eventGraphs)) {
+                    for (const graph of importData.eventGraphs) {
+                        try {
+                            await prisma.eventGraph.create({
+                                data: {
+                                    ...graph,
+                                    botId: newBot.id,
+                                    id: undefined
+                                }
+                            });
+                        } catch (error) {
+                            console.warn(`[Import] Не удалось импортировать граф событий ${graph.name}:`, error.message);
+                        }
+                    }
+                }
+
+                if (importData.settings && Array.isArray(importData.settings)) {
+                    for (const setting of importData.settings) {
+                        try {
+                            const updated = await prisma.installedPlugin.updateMany({
+                                where: {
+                                    botId: newBot.id,
+                                    name: setting.pluginName
+                                },
+                                data: {
+                                    settings: setting.settings
+                                }
+                            });
+                            if (updated.count > 0) {
+                                console.log(`[Import] Импортированы настройки плагина ${setting.pluginName}`);
+                            } else {
+                                console.warn(`[Import] Плагин ${setting.pluginName} не найден для применения настроек`);
+                            }
+                        } catch (error) {
+                            console.warn(`[Import] Не удалось импортировать настройки плагина ${setting.pluginName}:`, error.message);
+                        }
+                    }
+                }
+
+            } catch (error) {
+                console.error('[Import] Ошибка при импорте данных:', error);
+            }
+        }
+
+        res.status(201).json(newBot);
+    } catch (error) {
+        if (error.code === 'P2002') {
+            return res.status(409).json({ error: 'Бот с таким именем уже существует' });
+        }
+        console.error("[API Error] /bots/import/create:", error);
+        res.status(500).json({ error: 'Не удалось создать бота с импортированными данными' });
+    }
+});
+
 module.exports = router;