blockmine 1.22.0 → 1.23.1

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

@@ -5,6 +5,7 @@ const crypto = require('crypto');
 const { PrismaClient } = require('@prisma/client');
 const config = require('../../config');
 const { authenticate, authorize } = require('../middleware/auth');
+const { authenticatePanelApiKey } = require('../middleware/panelApiAuth');
 const path = require('path');
 const os = require('os');
 
@@ -16,6 +17,66 @@ const JWT_EXPIRES_IN = '7d';
 
 const activeResetTokens = new Map();
 
+const ALL_PERMISSIONS = [
+    { id: '*', label: 'Все права (Администратор)' },
+    { id: 'bot:list', label: 'Просмотр ботов' },
+    { id: 'bot:create', label: 'Создание ботов' },
+    { id: 'bot:update', label: 'Редактирование ботов' },
+    { id: 'bot:delete', label: 'Удаление ботов' },
+    { id: 'bot:start_stop', label: 'Запуск/остановка ботов' },
+    { id: 'bot:interact', label: 'Взаимодействие с ботом (консоль)' },
+    { id: 'bot:export', label: 'Экспорт ботов' },
+    { id: 'bot:import', label: 'Импорт ботов' },
+    { id: 'bot:history:view', label: 'Просмотр истории чата и команд' },
+    { id: 'bot:history:manage', label: 'Управление историей (очистка)' },
+    { id: 'management:view', label: 'Просмотр вкладки "Управление" у бота' },
+    { id: 'management:edit', label: 'Редактирование на вкладке "Управление" у бота' },
+    { id: 'plugin:list', label: 'Просмотр плагинов' },
+    { id: 'plugin:install', label: 'Установка плагинов' },
+    { id: 'plugin:delete', label: 'Удаление плагинов' },
+    { id: 'plugin:update', label: 'Обновление плагинов' },
+    { id: 'plugin:settings:view', label: 'Просмотр настроек плагинов' },
+    { id: 'plugin:settings:edit', label: 'Редактирование настроек плагинов' },
+    { id: 'plugin:browse', label: 'Просмотр каталога плагинов' },
+    { id: 'plugin:develop', label: 'Разработка и редактирование плагинов (IDE)' },
+    { id: 'server:list', label: 'Просмотр серверов' },
+    { id: 'server:create', label: 'Создание серверов' },
+    { id: 'server:delete', label: 'Удаление серверов' },
+    { id: 'proxy:list', label: 'Просмотр прокси' },
+    { id: 'proxy:create', label: 'Создание и редактирование прокси' },
+    { id: 'proxy:delete', label: 'Удаление прокси' },
+    { id: 'task:list', label: 'Просмотр задач' },
+    { id: 'task:create', label: 'Создание задач' },
+    { id: 'task:edit', label: 'Редактирование задач' },
+    { id: 'task:delete', label: 'Удаление задач' },
+    { id: 'panel:user:list', label: 'Просмотр пользователей панели' },
+    { id: 'panel:user:create', label: 'Создание пользователей панели' },
+    { id: 'panel:user:edit', label: 'Редактирование пользователей панели' },
+    { id: 'panel:user:delete', label: 'Удаление пользователей панели' },
+    { id: 'panel:role:list', label: 'Просмотр ролей панели' },
+    { id: 'panel:role:create', label: 'Создание ролей панели' },
+    { id: 'panel:role:edit', label: 'Редактирование ролей панели' },
+    { id: 'panel:role:delete', label: 'Удаление ролей панели' },
+    { id: 'panel:settings:view', label: 'Просмотр глобальных настроек' },
+    { id: 'panel:settings:edit', label: 'Редактирование глобальных настроек' },
+    { id: 'graph:read', label: 'Просмотр магазина графов' },
+    { id: 'graph:download', label: 'Скачивание графов из магазина' },
+    { id: 'graph:like', label: 'Лайки графов в магазине' },
+    { id: 'graph:publish', label: 'Публикация графов в магазин' },
+];
+
+const VIEWER_PERMISSIONS = [
+    'bot:list',
+    'bot:history:view',
+    'plugin:list',
+    'plugin:settings:view',
+    'management:view',
+    'server:list',
+    'proxy:list',
+    'task:list',
+    'graph:read',
+];
+
 function ownerOnly(req, res, next) {
     if (req.user && req.user.userId === 1) return next();
     return res.status(403).json({ error: 'Только владелец может изменять права пользователей и роли.' });
@@ -271,7 +332,12 @@ router.post('/login', async (req, res) => {
             return res.status(401).json({ error: 'Неверные учетные данные' });
         }
 
-        const permissions = JSON.parse(user.role.permissions || '[]');
+        let permissions = JSON.parse(user.role.permissions || '[]');
+
+        // Владелец (первый пользователь) всегда получает все актуальные права
+        if (user.id === 1) {
+            permissions = ALL_PERMISSIONS.map(p => p.id).filter(id => id !== '*');
+        }
 
         const payload = {
             userId: user.id,
@@ -297,6 +363,28 @@ router.post('/login', async (req, res) => {
 });
 
 
+/**
+ * @route   GET /api/auth/validate
+ * @desc    Validate Panel API key
+ * @access  Public (requires API key)
+ */
+router.get('/validate', authenticatePanelApiKey, async (req, res) => {
+    res.json({
+        valid: true,
+        user: {
+            id: req.user.id,
+            username: req.user.username,
+            role: req.user.roleName,
+            permissions: req.user.permissions
+        },
+        apiKey: {
+            id: req.apiKey.id,
+            name: req.apiKey.name,
+            prefix: req.apiKey.prefix
+        }
+    });
+});
+
 /**
  * @route   GET /api/auth/me
  * @desc    Получить данные текущего пользователя по токену
@@ -312,7 +400,7 @@ router.get('/me', authenticate, async (req, res) => {
         if (!user) {
             return res.status(404).json({ error: "Пользователь не найден." });
         }
-        
+
         res.json({
             id: user.id,
             username: user.username,
@@ -401,58 +489,6 @@ router.get('/roles', authenticate, authorize('panel:role:list'), async (req, res
     }
 });
 
-const ALL_PERMISSIONS = [
-    { id: '*', label: 'Все права (Администратор)' },
-    { id: 'bot:list', label: 'Просмотр ботов' },
-    { id: 'bot:create', label: 'Создание ботов' },
-    { id: 'bot:update', label: 'Редактирование ботов' },
-    { id: 'bot:delete', label: 'Удаление ботов' },
-    { id: 'bot:start_stop', label: 'Запуск/остановка ботов' },
-    { id: 'bot:interact', label: 'Взаимодействие с ботом (консоль)' },
-    { id: 'bot:export', label: 'Экспорт ботов' },
-    { id: 'bot:import', label: 'Импорт ботов' },
-    { id: 'management:view', label: 'Просмотр вкладки "Управление" у бота' },
-    { id: 'management:edit', label: 'Редактирование на вкладке "Управление" у бота' },
-    { id: 'plugin:list', label: 'Просмотр плагинов' },
-    { id: 'plugin:install', label: 'Установка плагинов' },
-    { id: 'plugin:delete', label: 'Удаление плагинов' },
-    { id: 'plugin:update', label: 'Обновление плагинов' },
-    { id: 'plugin:settings:view', label: 'Просмотр настроек плагинов' },
-    { id: 'plugin:settings:edit', label: 'Редактирование настроек плагинов' },
-    { id: 'plugin:browse', label: 'Просмотр каталога плагинов' },
-    { id: 'plugin:develop', label: 'Разработка и редактирование плагинов (IDE)' },
-    { id: 'server:list', label: 'Просмотр серверов' },
-    { id: 'server:create', label: 'Создание серверов' },
-    { id: 'server:delete', label: 'Удаление серверов' },
-    { id: 'task:list', label: 'Просмотр задач' },
-    { id: 'task:create', label: 'Создание задач' },
-    { id: 'task:edit', label: 'Редактирование задач' },
-    { id: 'task:delete', label: 'Удаление задач' },
-    { id: 'panel:user:list', label: 'Просмотр пользователей панели' },
-    { id: 'panel:user:create', label: 'Создание пользователей панели' },
-    { id: 'panel:user:edit', label: 'Редактирование пользователей панели' },
-    { id: 'panel:user:delete', label: 'Удаление пользователей панели' },
-    { id: 'panel:role:list', label: 'Просмотр ролей панели' },
-    { id: 'panel:role:create', label: 'Создание ролей панели' },
-    { id: 'panel:role:edit', label: 'Редактирование ролей панели' },
-    { id: 'panel:role:delete', label: 'Удаление ролей панели' },
-    { id: 'panel:settings:view', label: 'Просмотр глобальных настроек' },
-    { id: 'panel:settings:edit', label: 'Редактирование глобальных настроек' },
-    { id: 'graph:read', label: 'Просмотр магазина графов' },
-    { id: 'graph:download', label: 'Скачивание графов из магазина' },
-    { id: 'graph:like', label: 'Лайки графов в магазине' },
-    { id: 'graph:publish', label: 'Публикация графов в магазин' },
-];
-
-const VIEWER_PERMISSIONS = [
-    'bot:list',
-    'plugin:list',
-    'plugin:settings:view',
-    'management:view',
-    'server:list',
-    'task:list',
-    'graph:read',
-];
 
 /**
  * @route   GET /api/auth/permissions

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

@@ -0,0 +1,107 @@
+const express = require('express');
+const prisma = require('../../lib/prisma');
+const { authenticateUniversal, authorize } = require('../middleware/auth');
+
+const router = express.Router();
+
+router.get('/:botId/commands', authenticateUniversal, authorize('management:view'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const { page = 1, pageSize = 100, search } = req.query;
+
+        const skip = (parseInt(page) - 1) * parseInt(pageSize);
+        const take = parseInt(pageSize);
+
+        const where = { botId };
+        if (search) {
+            where.name = { contains: search };
+        }
+
+        const [commands, total] = await Promise.all([
+            prisma.command.findMany({
+                where,
+                include: {
+                    permission: true,
+                    pluginOwner: { select: { id: true, name: true, version: true } }
+                },
+                orderBy: { name: 'asc' },
+                skip,
+                take
+            }),
+            prisma.command.count({ where })
+        ]);
+
+        res.json({
+            items: commands,
+            total,
+            page: parseInt(page),
+            pageSize: take
+        });
+    } catch (error) {
+        console.error('[API Error] GET /bots/:botId/commands:', error);
+        res.status(500).json({ error: 'Не удалось получить список команд' });
+    }
+});
+
+router.get('/:botId/commands/:commandId', authenticateUniversal, authorize('management:view'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const commandId = parseInt(req.params.commandId, 10);
+
+        const command = await prisma.command.findFirst({
+            where: { id: commandId, botId },
+            include: {
+                permission: true,
+                pluginOwner: { select: { id: true, name: true, version: true } }
+            }
+        });
+
+        if (!command) {
+            return res.status(404).json({ error: 'Команда не найдена' });
+        }
+
+        res.json(command);
+    } catch (error) {
+        console.error('[API Error] GET /bots/:botId/commands/:commandId:', error);
+        res.status(500).json({ error: 'Не удалось получить команду' });
+    }
+});
+
+router.patch('/:botId/commands/:commandId', authenticateUniversal, authorize('management:edit'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const commandId = parseInt(req.params.commandId, 10);
+        const { isEnabled, cooldown, aliases, permissionId, allowedChatTypes } = req.body;
+
+        const command = await prisma.command.findFirst({
+            where: { id: commandId, botId }
+        });
+
+        if (!command) {
+            return res.status(404).json({ error: 'Команда не найдена' });
+        }
+
+        const updateData = {};
+        if (typeof isEnabled === 'boolean') updateData.isEnabled = isEnabled;
+        if (typeof cooldown === 'number') updateData.cooldown = cooldown;
+        if (aliases !== undefined) updateData.aliases = JSON.stringify(aliases);
+        if (permissionId !== undefined) updateData.permissionId = permissionId;
+        if (allowedChatTypes !== undefined) updateData.allowedChatTypes = JSON.stringify(allowedChatTypes);
+
+        const updated = await prisma.command.update({
+            where: { id: commandId },
+            data: updateData,
+            include: {
+                permission: true,
+                pluginOwner: { select: { id: true, name: true, version: true } }
+            }
+        });
+
+        res.json(updated);
+    } catch (error) {
+        console.error('[API Error] PATCH /bots/:botId/commands/:commandId:', error);
+        res.status(500).json({ error: 'Не удалось обновить команду' });
+    }
+});
+
+module.exports = router;

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

@@ -0,0 +1,165 @@
+const express = require('express');
+const prisma = require('../../lib/prisma');
+const { authenticateUniversal, authorize } = require('../middleware/auth');
+const { botManager } = require('../../core/services');
+const UserService = require('../../core/UserService');
+
+const router = express.Router();
+
+router.get('/:botId/groups', authenticateUniversal, authorize('management:view'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+
+        const groups = await prisma.group.findMany({
+            where: { botId },
+            include: { permissions: { include: { permission: true } } },
+            orderBy: { name: 'asc' }
+        });
+
+        res.json({
+            items: groups,
+            total: groups.length
+        });
+    } catch (error) {
+        console.error('[API Error] GET /bots/:botId/groups:', error);
+        res.status(500).json({ error: 'Не удалось получить список групп' });
+    }
+});
+
+router.get('/:botId/groups/:groupId', authenticateUniversal, authorize('management:view'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const groupId = parseInt(req.params.groupId, 10);
+
+        const group = await prisma.group.findFirst({
+            where: { id: groupId, botId },
+            include: { permissions: { include: { permission: true } } }
+        });
+
+        if (!group) {
+            return res.status(404).json({ error: 'Группа не найдена' });
+        }
+
+        res.json(group);
+    } catch (error) {
+        console.error('[API Error] GET /bots/:botId/groups/:groupId:', error);
+        res.status(500).json({ error: 'Не удалось получить группу' });
+    }
+});
+
+router.post('/:botId/groups/:groupId/permissions', authenticateUniversal, authorize('management:edit'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const groupId = parseInt(req.params.groupId, 10);
+        const { permissionId } = req.body;
+
+        const group = await prisma.group.findFirst({ where: { id: groupId, botId } });
+        if (!group) {
+            return res.status(404).json({ error: 'Группа не найдена' });
+        }
+
+        const permission = await prisma.permission.findFirst({ where: { id: permissionId, botId } });
+        if (!permission) {
+            return res.status(404).json({ error: 'Право не найдено' });
+        }
+
+        await prisma.groupPermission.upsert({
+            where: { groupId_permissionId: { groupId, permissionId } },
+            create: { groupId, permissionId },
+            update: {}
+        });
+
+        res.json({ success: true });
+    } catch (error) {
+        console.error('[API Error] POST /bots/:botId/groups/:groupId/permissions:', error);
+        res.status(500).json({ error: 'Не удалось добавить право в группу' });
+    }
+});
+
+router.delete('/:botId/groups/:groupId/permissions/:permissionId', authenticateUniversal, authorize('management:edit'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const groupId = parseInt(req.params.groupId, 10);
+        const permissionId = parseInt(req.params.permissionId, 10);
+
+        const group = await prisma.group.findFirst({ where: { id: groupId, botId } });
+        if (!group) {
+            return res.status(404).json({ error: 'Группа не найдена' });
+        }
+
+        await prisma.groupPermission.deleteMany({
+            where: { groupId, permissionId }
+        });
+
+        res.json({ success: true });
+    } catch (error) {
+        console.error('[API Error] DELETE /bots/:botId/groups/:groupId/permissions/:permissionId:', error);
+        res.status(500).json({ error: 'Не удалось удалить право из группы' });
+    }
+});
+
+router.post('/:botId/groups/:groupId/users', authenticateUniversal, authorize('management:edit'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const groupId = parseInt(req.params.groupId, 10);
+        const { username } = req.body;
+
+        const group = await prisma.group.findFirst({ where: { id: groupId, botId } });
+        if (!group) {
+            return res.status(404).json({ error: 'Группа не найдена' });
+        }
+
+        let user = await prisma.user.findFirst({ where: { botId, username } });
+        if (!user) {
+            user = await prisma.user.create({
+                data: { botId, username, isBlacklisted: false }
+            });
+        }
+
+        await prisma.userGroup.upsert({
+            where: { userId_groupId: { userId: user.id, groupId } },
+            create: { userId: user.id, groupId },
+            update: {}
+        });
+
+        botManager.invalidateUserCache(botId, username);
+        UserService.clearCache(username, botId);
+
+        res.json({ success: true });
+    } catch (error) {
+        console.error('[API Error] POST /bots/:botId/groups/:groupId/users:', error);
+        res.status(500).json({ error: 'Не удалось добавить пользователя в группу' });
+    }
+});
+
+router.delete('/:botId/groups/:groupId/users/:username', authenticateUniversal, authorize('management:edit'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const groupId = parseInt(req.params.groupId, 10);
+        const { username } = req.params;
+
+        const group = await prisma.group.findFirst({ where: { id: groupId, botId } });
+        if (!group) {
+            return res.status(404).json({ error: 'Группа не найдена' });
+        }
+
+        const user = await prisma.user.findFirst({ where: { botId, username } });
+        if (!user) {
+            return res.status(404).json({ error: 'Пользователь не найден' });
+        }
+
+        await prisma.userGroup.deleteMany({
+            where: { userId: user.id, groupId }
+        });
+
+        botManager.invalidateUserCache(botId, username);
+        UserService.clearCache(username, botId);
+
+        res.json({ success: true });
+    } catch (error) {
+        console.error('[API Error] DELETE /bots/:botId/groups/:groupId/users/:username:', error);
+        res.status(500).json({ error: 'Не удалось удалить пользователя из группы' });
+    }
+});
+
+module.exports = router;

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

@@ -0,0 +1,108 @@
+const express = require('express');
+const { authenticateUniversal, authorize } = require('../middleware/auth');
+const botHistoryStore = require('../../core/BotHistoryStore');
+
+const router = express.Router();
+
+router.get('/:botId/chat', authenticateUniversal, authorize('bot:list'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId);
+        const { type, username, search, from, to, limit, offset } = req.query;
+
+        const result = botHistoryStore.getChatHistory(botId, {
+            type,
+            username,
+            search,
+            from,
+            to,
+            limit: limit || 100,
+            offset: offset || 0
+        });
+
+        res.json({
+            messages: result.messages,
+            total: result.total,
+            pagination: {
+                total: result.total,
+                limit: parseInt(limit) || 100,
+                offset: parseInt(offset) || 0,
+                hasMore: (parseInt(offset) || 0) + (parseInt(limit) || 100) < result.total
+            }
+        });
+    } catch (error) {
+        console.error('[API Error] GET /bots/:botId/chat:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Не удалось получить историю чата.'
+        });
+    }
+});
+
+router.get('/:botId/commands', authenticateUniversal, authorize('bot:list'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId);
+        const { username, command, success, from, to, limit, offset } = req.query;
+
+        const result = botHistoryStore.getCommandLogs(botId, {
+            username,
+            command,
+            success,
+            from,
+            to,
+            limit: limit || 100,
+            offset: offset || 0
+        });
+
+        res.json({
+            logs: result.logs,
+            total: result.total,
+            pagination: {
+                total: result.total,
+                limit: parseInt(limit) || 100,
+                offset: parseInt(offset) || 0,
+                hasMore: (parseInt(offset) || 0) + (parseInt(limit) || 100) < result.total
+            }
+        });
+    } catch (error) {
+        console.error('[API Error] GET /bots/:botId/commands:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Не удалось получить логи команд.'
+        });
+    }
+});
+
+router.get('/:botId/stats', authenticateUniversal, authorize('bot:list'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId);
+        const stats = botHistoryStore.getStats(botId);
+
+        res.json(stats);
+    } catch (error) {
+        console.error('[API Error] GET /bots/:botId/stats:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Не удалось получить статистику.'
+        });
+    }
+});
+
+router.delete('/:botId/clear', authenticateUniversal, authorize('bot:list'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId);
+        botHistoryStore.clearBot(botId);
+
+        res.json({
+            success: true,
+            message: 'История бота очищена.'
+        });
+    } catch (error) {
+        console.error('[API Error] DELETE /bots/:botId/clear:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Не удалось очистить историю.'
+        });
+    }
+});
+
+module.exports = router;

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

@@ -0,0 +1,99 @@
+const express = require('express');
+const prisma = require('../../lib/prisma');
+const { authenticateUniversal, authorize } = require('../middleware/auth');
+
+const router = express.Router();
+
+router.get('/:botId/permissions', authenticateUniversal, authorize('management:view'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+
+        const permissions = await prisma.permission.findMany({
+            where: { botId },
+            orderBy: { name: 'asc' }
+        });
+
+        res.json({
+            items: permissions,
+            total: permissions.length
+        });
+    } catch (error) {
+        console.error('[API Error] GET /bots/:botId/permissions:', error);
+        res.status(500).json({ error: 'Не удалось получить список прав' });
+    }
+});
+
+router.get('/:botId/permissions/:permissionId', authenticateUniversal, authorize('management:view'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const permissionId = parseInt(req.params.permissionId, 10);
+
+        const permission = await prisma.permission.findFirst({
+            where: { id: permissionId, botId }
+        });
+
+        if (!permission) {
+            return res.status(404).json({ error: 'Право не найдено' });
+        }
+
+        res.json(permission);
+    } catch (error) {
+        console.error('[API Error] GET /bots/:botId/permissions/:permissionId:', error);
+        res.status(500).json({ error: 'Не удалось получить право' });
+    }
+});
+
+router.put('/:botId/permissions/:permissionId', authenticateUniversal, authorize('management:edit'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const permissionId = parseInt(req.params.permissionId, 10);
+        const { name, description } = req.body;
+
+        const permission = await prisma.permission.findFirst({
+            where: { id: permissionId, botId }
+        });
+
+        if (!permission) {
+            return res.status(404).json({ error: 'Право не найдено' });
+        }
+
+        const updateData = {};
+        if (name !== undefined) updateData.name = name;
+        if (description !== undefined) updateData.description = description;
+
+        const updated = await prisma.permission.update({
+            where: { id: permissionId },
+            data: updateData
+        });
+
+        res.json(updated);
+    } catch (error) {
+        console.error('[API Error] PUT /bots/:botId/permissions/:permissionId:', error);
+        res.status(500).json({ error: 'Не удалось обновить право' });
+    }
+});
+
+router.delete('/:botId/permissions/:permissionId', authenticateUniversal, authorize('management:edit'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const permissionId = parseInt(req.params.permissionId, 10);
+
+        const permission = await prisma.permission.findFirst({
+            where: { id: permissionId, botId }
+        });
+
+        if (!permission) {
+            return res.status(404).json({ error: 'Право не найдено' });
+        }
+
+        await prisma.groupPermission.deleteMany({ where: { permissionId } });
+        await prisma.permission.delete({ where: { id: permissionId } });
+
+        res.json({ success: true });
+    } catch (error) {
+        console.error('[API Error] DELETE /bots/:botId/permissions/:permissionId:', error);
+        res.status(500).json({ error: 'Не удалось удалить право' });
+    }
+});
+
+module.exports = router;