blockmine 1.22.0 → 1.23.0

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;

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

@@ -0,0 +1,36 @@
+const express = require('express');
+const { authenticateUniversal, authorize } = require('../middleware/auth');
+const { botManager } = require('../../core/services');
+
+const router = express.Router();
+
+router.get('/:id/status', authenticateUniversal, authorize('bot:list'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.id, 10);
+
+        const botProcess = botManager.bots.get(botId);
+
+        if (!botProcess) {
+            return res.json({
+                online: false,
+                connected: false,
+                status: 'offline'
+            });
+        }
+
+        const status = botProcess.status || 'unknown';
+        const isOnline = status === 'running' || status === 'online';
+        const isConnected = botProcess.bot?.isConnected?.() || false;
+
+        res.json({
+            online: isOnline,
+            connected: isConnected,
+            status: status
+        });
+    } catch (error) {
+        console.error('[API Error] GET /bots/:id/status:', error);
+        res.status(500).json({ error: 'Не удалось получить статус бота' });
+    }
+});
+
+module.exports = router;

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

@@ -0,0 +1,162 @@
+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/users/:username', authenticateUniversal, authorize('management:view'), async (req, res) => {
+    console.log('[botUsers] GET /:botId/users/:username called', req.params);
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const { username } = req.params;
+
+        const user = await prisma.user.findFirst({
+            where: { botId, username },
+            include: { groups: { include: { group: true } } }
+        });
+
+        if (!user) {
+            return res.status(404).json({ error: 'Пользователь не найден' });
+        }
+
+        res.json(user);
+    } catch (error) {
+        console.error('[API Error] GET /bots/:botId/users/:username:', error);
+        res.status(500).json({ error: 'Не удалось получить пользователя' });
+    }
+});
+
+router.get('/:botId/users', 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.username = { contains: search };
+        }
+
+        const [users, total] = await Promise.all([
+            prisma.user.findMany({
+                where,
+                include: { groups: { include: { group: true } } },
+                orderBy: { username: 'asc' },
+                skip,
+                take
+            }),
+            prisma.user.count({ where })
+        ]);
+
+        res.json({
+            items: users,
+            total,
+            page: parseInt(page),
+            pageSize: take
+        });
+    } catch (error) {
+        console.error('[API Error] GET /bots/:botId/users:', error);
+        res.status(500).json({ error: 'Не удалось получить список пользователей' });
+    }
+});
+
+router.put('/:botId/users/:username', authenticateUniversal, authorize('management:edit'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const { username } = req.params;
+        const { isBlacklisted, groupIds } = req.body;
+
+        let user = await prisma.user.findFirst({
+            where: { botId, username }
+        });
+
+        if (!user) {
+            user = await prisma.user.create({
+                data: {
+                    botId,
+                    username,
+                    isBlacklisted: isBlacklisted || false
+                }
+            });
+        }
+
+        const updateData = {};
+        if (typeof isBlacklisted === 'boolean') {
+            updateData.isBlacklisted = isBlacklisted;
+        }
+
+        if (Array.isArray(groupIds)) {
+            await prisma.userGroup.deleteMany({ where: { userId: user.id } });
+            updateData.groups = {
+                create: groupIds.map(gid => ({ groupId: gid }))
+            };
+        }
+
+        const updatedUser = await prisma.user.update({
+            where: { id: user.id },
+            data: updateData,
+            include: { groups: { include: { group: true } } }
+        });
+
+        botManager.invalidateUserCache(botId, username);
+        UserService.clearCache(username, botId);
+
+        res.json(updatedUser);
+    } catch (error) {
+        console.error('[API Error] PUT /bots/:botId/users/:username:', error);
+        res.status(500).json({ error: 'Не удалось обновить пользователя' });
+    }
+});
+
+router.delete('/:botId/users/:username', authenticateUniversal, authorize('management:edit'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const { username } = req.params;
+
+        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 } });
+        await prisma.user.delete({ where: { id: user.id } });
+
+        botManager.invalidateUserCache(botId, username);
+        UserService.clearCache(username, botId);
+
+        res.json({ success: true });
+    } catch (error) {
+        console.error('[API Error] DELETE /bots/:botId/users/:username:', error);
+        res.status(500).json({ error: 'Не удалось удалить пользователя' });
+    }
+});
+
+router.get('/:botId/users/:username/groups', authenticateUniversal, authorize('management:view'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const { username } = req.params;
+
+        const user = await prisma.user.findFirst({
+            where: { botId, username },
+            include: { groups: true }
+        });
+
+        if (!user) {
+            return res.status(404).json({ error: 'Пользователь не найден' });
+        }
+
+        res.json({ groupIds: user.groups.map(g => g.groupId) });
+    } catch (error) {
+        console.error('[API Error] GET /bots/:botId/users/:username/groups:', error);
+        res.status(500).json({ error: 'Не удалось получить группы пользователя' });
+    }
+});
+
+module.exports = router;