blockmine 1.20.0 → 1.22.0

package/backend/src/real-time/botApi/utils.js

@@ -0,0 +1,54 @@
+/**
+ * Отправляет событие всем подключенным API клиентам бота
+ * @param {Server} io - Socket.IO сервер
+ * @param {number} botId - ID бота
+ * @param {string} eventName - Название события (например, "chat:message")
+ * @param {object} data - Данные события
+ */
+function broadcastToApiClients(io, botId, eventName, data) {
+    try {
+        const apiNamespace = io.of('/bot-api');
+        apiNamespace.to(`bot_${botId}`).emit(eventName, data);
+    } catch (error) {
+        console.error('[Bot API] Ошибка broadcast:', error);
+    }
+}
+
+/**
+ * Отправляет событие изменения статуса бота всем подключенным API клиентам
+ * @param {Server} io - Socket.IO сервер
+ * @param {number} botId - ID бота
+ * @param {boolean} online - Онлайн ли бот
+ */
+function broadcastBotStatus(io, botId, online) {
+    try {
+        const apiNamespace = io.of('/bot-api');
+        apiNamespace.to(`bot_${botId}`).emit('bot:status', { online });
+        console.log(`[Bot API] Broadcast статуса бота ${botId}: ${online ? 'ONLINE' : 'OFFLINE'}`);
+    } catch (error) {
+        console.error('[Bot API] Ошибка broadcast статуса:', error);
+    }
+}
+
+/**
+ * Получить количество подключенных API клиентов для конкретного бота
+ * @param {Server} io - Socket.IO сервер
+ * @param {number} botId - ID бота
+ * @returns {number} Количество подключенных клиентов
+ */
+function getConnectedClientsCount(io, botId) {
+    try {
+        const apiNamespace = io.of('/bot-api');
+        const room = apiNamespace.adapter.rooms.get(`bot_${botId}`);
+        return room ? room.size : 0;
+    } catch (error) {
+        console.error('[Bot API] Ошибка получения количества клиентов:', error);
+        return 0;
+    }
+}
+
+module.exports = {
+    broadcastToApiClients,
+    broadcastBotStatus,
+    getConnectedClientsCount,
+};

package/backend/src/real-time/socketHandler.js

@@ -3,6 +3,7 @@ const config = require('../config');
 
 const { botManager } = require('../core/services');
 const presence = require('./presence');
+const { initializeBotApiNamespace } = require('./botApi');
 
 let io;
 
@@ -18,9 +19,12 @@ function initializeSocket(httpServer) {
         transports: ['websocket', 'polling']
     });
 
+    // Инициализируем /bot-api namespace для WebSocket API
+    initializeBotApiNamespace(io);
+
     io.on('connection', (socket) => {
         presence.handleConnection(io, socket);
-        
+
         socket.on('disconnect', () => {
             botManager.handleSocketDisconnect(socket);
         });
@@ -33,7 +37,7 @@ function initializeSocket(httpServer) {
             botManager.unsubscribeFromPluginUi(botId, pluginName, socket);
         });
     });
-    
+
     return io;
 }
 

package/backend/src/repositories/BaseRepository.js

@@ -0,0 +1,43 @@
+class BaseRepository {
+    constructor({ prisma }) {
+        this.prisma = prisma;
+        // modelName устанавливается в дочерних классах
+    }
+
+    get model() {
+        return this.prisma[this.modelName];
+    }
+
+    async findById(id) {
+        return this.model.findUnique({ where: { id } });
+    }
+
+    async findMany(where = {}, options = {}) {
+        return this.model.findMany({ where, ...options });
+    }
+
+    async findFirst(where, options = {}) {
+        return this.model.findFirst({ where, ...options });
+    }
+
+    async create(data) {
+        return this.model.create({ data });
+    }
+
+    async update(id, data) {
+        return this.model.update({
+            where: { id },
+            data,
+        });
+    }
+
+    async delete(id) {
+        return this.model.delete({ where: { id } });
+    }
+
+    async count(where = {}) {
+        return this.model.count({ where });
+    }
+}
+
+module.exports = BaseRepository;

package/backend/src/repositories/BotRepository.js

@@ -0,0 +1,42 @@
+const BaseRepository = require('./BaseRepository');
+
+class BotRepository extends BaseRepository {
+    constructor({ prisma }) {
+        super({ prisma });
+        this.modelName = 'bot';
+    }
+
+    async findByIdWithServer(id) {
+        return this.model.findUnique({
+            where: { id },
+            include: { server: true },
+        });
+    }
+
+    async findAllWithServer(options = {}) {
+        return this.model.findMany({
+            include: { server: true },
+            orderBy: { sortOrder: 'asc' },
+            ...options,
+        });
+    }
+
+    async findByUsername(username) {
+        return this.model.findUnique({
+            where: { username },
+        });
+    }
+
+    async findByServerId(serverId) {
+        return this.model.findMany({
+            where: { serverId },
+            orderBy: { sortOrder: 'asc' },
+        });
+    }
+
+    async updateSortOrder(botId, sortOrder) {
+        return this.update(botId, { sortOrder });
+    }
+}
+
+module.exports = BotRepository;

package/backend/src/repositories/CommandRepository.js

@@ -0,0 +1,53 @@
+const BaseRepository = require('./BaseRepository');
+
+class CommandRepository extends BaseRepository {
+    constructor({ prisma }) {
+        super({ prisma });
+        this.modelName = 'command';
+    }
+
+    async findByBotId(botId) {
+        return this.model.findMany({
+            where: { botId },
+            orderBy: { name: 'asc' },
+        });
+    }
+
+    async findEnabledByBotId(botId) {
+        return this.model.findMany({
+            where: {
+                botId,
+                isEnabled: true,
+            },
+            orderBy: { name: 'asc' },
+        });
+    }
+
+    async findByName(botId, name) {
+        return this.model.findFirst({
+            where: { botId, name },
+        });
+    }
+
+    async findByNameOrAlias(botId, nameOrAlias) {
+        const commands = await this.model.findMany({
+            where: { botId, isEnabled: true },
+        });
+
+        return commands.find(cmd => {
+            if (cmd.name === nameOrAlias) return true;
+            try {
+                const aliases = JSON.parse(cmd.aliases || '[]');
+                return aliases.includes(nameOrAlias);
+            } catch {
+                return false;
+            }
+        });
+    }
+
+    async updateEnabled(commandId, isEnabled) {
+        return this.update(commandId, { isEnabled });
+    }
+}
+
+module.exports = CommandRepository;

package/backend/src/repositories/EventGraphRepository.js

@@ -0,0 +1,40 @@
+const BaseRepository = require('./BaseRepository');
+
+class EventGraphRepository extends BaseRepository {
+    constructor({ prisma }) {
+        super({ prisma });
+        this.modelName = 'eventGraph';
+    }
+
+    async findByBotId(botId) {
+        return this.model.findMany({
+            where: { botId },
+            orderBy: { name: 'asc' },
+        });
+    }
+
+    async findEnabledByBotId(botId) {
+        return this.model.findMany({
+            where: {
+                botId,
+                isEnabled: true,
+            },
+        });
+    }
+
+    async findByEventType(botId, eventType) {
+        return this.model.findMany({
+            where: {
+                botId,
+                eventType,
+                isEnabled: true,
+            },
+        });
+    }
+
+    async updateEnabled(graphId, isEnabled) {
+        return this.update(graphId, { isEnabled });
+    }
+}
+
+module.exports = EventGraphRepository;

package/backend/src/repositories/GroupRepository.js

@@ -0,0 +1,69 @@
+const BaseRepository = require('./BaseRepository');
+
+class GroupRepository extends BaseRepository {
+    constructor({ prisma }) {
+        super({ prisma });
+        this.modelName = 'group';
+    }
+
+    async findByBotId(botId) {
+        return this.model.findMany({
+            where: { botId },
+            include: {
+                permissions: {
+                    include: {
+                        permission: true,
+                    },
+                },
+            },
+            orderBy: { name: 'asc' },
+        });
+    }
+
+    async findByName(botId, name) {
+        return this.model.findUnique({
+            where: {
+                botId_name: { botId, name },
+            },
+            include: {
+                permissions: {
+                    include: {
+                        permission: true,
+                    },
+                },
+            },
+        });
+    }
+
+    async upsertGroup(botId, name, data) {
+        return this.model.upsert({
+            where: {
+                botId_name: { botId, name },
+            },
+            update: data,
+            create: {
+                botId,
+                name,
+                ...data,
+            },
+        });
+    }
+
+    async addPermissionToGroup(groupId, permissionId, prisma) {
+        return prisma.groupPermission.upsert({
+            where: {
+                groupId_permissionId: { groupId, permissionId },
+            },
+            update: {},
+            create: { groupId, permissionId },
+        });
+    }
+
+    async removePermissionFromGroup(groupId, permissionId, prisma) {
+        return prisma.groupPermission.deleteMany({
+            where: { groupId, permissionId },
+        });
+    }
+}
+
+module.exports = GroupRepository;

package/backend/src/repositories/PermissionRepository.js

@@ -0,0 +1,48 @@
+const BaseRepository = require('./BaseRepository');
+
+class PermissionRepository extends BaseRepository {
+    constructor({ prisma }) {
+        super({ prisma });
+        this.modelName = 'permission';
+    }
+
+    async findByBotId(botId) {
+        return this.model.findMany({
+            where: { botId },
+            orderBy: { name: 'asc' },
+        });
+    }
+
+    async findByName(botId, name) {
+        return this.model.findUnique({
+            where: {
+                botId_name: { botId, name },
+            },
+        });
+    }
+
+    async upsertPermission(botId, name, data) {
+        return this.model.upsert({
+            where: {
+                botId_name: { botId, name },
+            },
+            update: data,
+            create: {
+                botId,
+                name,
+                ...data,
+            },
+        });
+    }
+
+    async findSystemPermissions(botId) {
+        return this.model.findMany({
+            where: {
+                botId,
+                owner: 'system',
+            },
+        });
+    }
+}
+
+module.exports = PermissionRepository;

package/backend/src/repositories/PluginRepository.js

@@ -0,0 +1,42 @@
+const BaseRepository = require('./BaseRepository');
+
+class PluginRepository extends BaseRepository {
+    constructor({ prisma }) {
+        super({ prisma });
+        this.modelName = 'installedPlugin';
+    }
+
+    async findByBotId(botId) {
+        return this.model.findMany({
+            where: { botId },
+            orderBy: { name: 'asc' },
+        });
+    }
+
+    async findByName(botId, name) {
+        return this.model.findFirst({
+            where: { botId, name },
+        });
+    }
+
+    async findEnabledByBotId(botId) {
+        return this.model.findMany({
+            where: {
+                botId,
+                isEnabled: true,
+            },
+        });
+    }
+
+    async updateEnabled(pluginId, isEnabled) {
+        return this.update(pluginId, { isEnabled });
+    }
+
+    async deleteByName(botId, name) {
+        return this.model.deleteMany({
+            where: { botId, name },
+        });
+    }
+}
+
+module.exports = PluginRepository;

package/backend/src/repositories/ServerRepository.js

@@ -0,0 +1,27 @@
+const BaseRepository = require('./BaseRepository');
+
+class ServerRepository extends BaseRepository {
+    constructor({ prisma }) {
+        super({ prisma });
+        this.modelName = 'server';
+    }
+
+    async findByHost(host, port) {
+        return this.model.findFirst({
+            where: { host, port },
+        });
+    }
+
+    async findAllWithBots() {
+        return this.model.findMany({
+            include: {
+                bots: {
+                    orderBy: { sortOrder: 'asc' },
+                },
+            },
+            orderBy: { id: 'asc' },
+        });
+    }
+}
+
+module.exports = ServerRepository;

package/backend/src/repositories/UserRepository.js

@@ -0,0 +1,48 @@
+const BaseRepository = require('./BaseRepository');
+
+class UserRepository extends BaseRepository {
+    constructor({ prisma }) {
+        super({ prisma });
+        this.modelName = 'user';
+    }
+
+    async findByUsername(botId, username) {
+        return this.model.findUnique({
+            where: {
+                botId_username: { botId, username },
+            },
+        });
+    }
+
+    async findByBotId(botId) {
+        return this.model.findMany({
+            where: { botId },
+            orderBy: { username: 'asc' },
+        });
+    }
+
+    async upsertUser(botId, username, data) {
+        return this.model.upsert({
+            where: {
+                botId_username: { botId, username },
+            },
+            update: data,
+            create: {
+                botId,
+                username,
+                ...data,
+            },
+        });
+    }
+
+    async updateBlacklist(botId, username, isBlacklisted) {
+        return this.model.update({
+            where: {
+                botId_username: { botId, username },
+            },
+            data: { isBlacklisted },
+        });
+    }
+}
+
+module.exports = UserRepository;

package/backend/src/server.js

@@ -21,6 +21,7 @@ const TaskScheduler = require('./core/TaskScheduler');
 const panelRoutes = require('./api/routes/panel');
 const changelogRoutes = require('./api/routes/changelog');
 const logsRoutes = require('./api/routes/logs');
+const systemRoutes = require('./api/routes/system');
 
 const app = express();
 const server = http.createServer(app);
@@ -64,6 +65,7 @@ app.use('/api/search', searchRoutes);
 app.use('/api/panel', panelRoutes);
 app.use('/api/changelog', changelogRoutes);
 app.use('/api/logs', logsRoutes);
+app.use('/api/system', systemRoutes);
 
 app.use(express.static(frontendPath));
 
@@ -156,6 +158,7 @@ const gracefulShutdown = async (signal) => {
     console.log(`[Shutdown] Получен сигнал ${signal}. Начинаем корректное завершение...`);
 
     TaskScheduler.shutdown();
+    botManager.cleanup();
 
     const botIds = Array.from(botManager.bots.keys());
     if (botIds.length > 0) {

package/backend/src/test-refactor.js

@@ -0,0 +1,85 @@
+/**
+ * Тестовый скрипт для проверки рефакторинга
+ */
+
+const configureContainer = require('./container');
+
+console.log('=== Тестирование рефакторинга ===\n');
+
+try {
+    // 1. Создаём контейнер
+    console.log('1. Создание DI контейнера...');
+    const container = configureContainer();
+    console.log('   ✓ Контейнер создан\n');
+
+    // 2. Проверяем repositories
+    console.log('2. Проверка Repositories...');
+    const botRepo = container.resolve('botRepository');
+    const commandRepo = container.resolve('commandRepository');
+    const permissionRepo = container.resolve('permissionRepository');
+    console.log('   ✓ BotRepository:', botRepo.constructor.name);
+    console.log('   ✓ CommandRepository:', commandRepo.constructor.name);
+    console.log('   ✓ PermissionRepository:', permissionRepo.constructor.name);
+    console.log('');
+
+    // 3. Проверяем services
+    console.log('3. Проверка Services...');
+    const cacheManager = container.resolve('cacheManager');
+    const processManager = container.resolve('botProcessManager');
+    const resourceMonitor = container.resolve('resourceMonitorService');
+    const telemetry = container.resolve('telemetryService');
+    console.log('   ✓ CacheManager:', cacheManager.constructor.name);
+    console.log('   ✓ BotProcessManager:', processManager.constructor.name);
+    console.log('   ✓ ResourceMonitorService:', resourceMonitor.constructor.name);
+    console.log('   ✓ TelemetryService:', telemetry.constructor.name);
+    console.log('');
+
+    // 4. Проверяем высокоуровневые сервисы
+    console.log('4. Проверка High-level Services...');
+    const lifecycleService = container.resolve('botLifecycleService');
+    const commandService = container.resolve('commandExecutionService');
+    console.log('   ✓ BotLifecycleService:', lifecycleService.constructor.name);
+    console.log('   ✓ CommandExecutionService:', commandService.constructor.name);
+    console.log('');
+
+    // 5. Создаём BotManager facade
+    console.log('5. Создание BotManager facade...');
+    const BotManager = require('./core/BotManager.refactored');
+    const botManager = new BotManager(container.cradle);
+    console.log('   ✓ BotManager создан');
+    console.log('   ✓ Методы:', Object.getOwnPropertyNames(Object.getPrototypeOf(botManager)).filter(m => m !== 'constructor').slice(0, 5).join(', '), '...');
+    console.log('');
+
+    // 6. Проверяем что dependencies правильно инжектируются
+    console.log('6. Проверка dependency injection...');
+    const hasLifecycle = botManager.lifecycleService !== undefined;
+    const hasCommand = botManager.commandService !== undefined;
+    const hasCache = botManager.cache !== undefined;
+    console.log('   ✓ lifecycleService инжектирован:', hasLifecycle);
+    console.log('   ✓ commandService инжектирован:', hasCommand);
+    console.log('   ✓ cacheManager инжектирован:', hasCache);
+    console.log('');
+
+    // 7. Проверяем LRU cache
+    console.log('7. Проверка LRU Cache...');
+    cacheManager.setToken('test-token', { userId: 123 });
+    const tokenData = cacheManager.getToken('test-token');
+    console.log('   ✓ Token сохранён и получен:', tokenData?.userId === 123);
+    console.log('');
+
+    console.log('=== ВСЕ ПРОВЕРКИ ПРОЙДЕНЫ ===\n');
+    console.log('Рефакторинг завершён успешно!');
+    console.log('\nСоздано:');
+    console.log('  - 8 Repositories (BotRepository, CommandRepository, etc.)');
+    console.log('  - 6 Services (CacheManager, BotProcessManager, ResourceMonitorService, TelemetryService, BotLifecycleService, CommandExecutionService)');
+    console.log('  - 1 DI Container (Awilix)');
+    console.log('  - 1 BotManager Facade (для обратной совместимости)');
+    console.log('  - LRU Cache вместо Redis (для self-hosting)');
+
+    process.exit(0);
+
+} catch (error) {
+    console.error('\n❌ ОШИБКА:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+}