diff --git a/api-keys.js b/api-keys.js
new file mode 100644
index 0000000..6e6d3d0
--- /dev/null
+++ b/api-keys.js
@@ -0,0 +1,1176 @@
+// api-keys.js - API для управления ключами доступа к задачам с логированием
+
+const express = require('express');
+const crypto = require('crypto');
+const path = require('path');
+const fs = require('fs');
+const router = express.Router();
+
+module.exports = function(app, db, upload) {
+    
+    // Middleware для проверки аутентификации
+    const requireAuth = (req, res, next) => {
+        if (!req.session || !req.session.user) {
+            return res.status(401).json({ error: 'Требуется аутентификация' });
+        }
+        next();
+    };
+
+    // Middleware для проверки прав администратора
+    const requireAdmin = (req, res, next) => {
+        if (!req.session || !req.session.user || req.session.user.role !== 'admin') {
+            return res.status(403).json({ error: 'Недостаточно прав' });
+        }
+        next();
+    };
+
+    // Функция для логирования действий API
+    const logApiAction = (apiKeyId, userId, action, details, req, statusCode = 200, responseTime = 0) => {
+        const timestamp = new Date().toISOString();
+        const ip = req.ip || req.connection.remoteAddress;
+        const userAgent = req.get('User-Agent') || 'Unknown';
+        
+        const logEntry = {
+            timestamp,
+            api_key_id: apiKeyId,
+            user_id: userId,
+            action,
+            details,
+            ip,
+            user_agent: userAgent,
+            method: req.method,
+            path: req.originalUrl,
+            status_code: statusCode,
+            response_time: responseTime
+        };
+
+        // Цветное логирование в консоль
+        const colors = {
+            GET: '\x1b[32m',    // зеленый
+            POST: '\x1b[33m',   // желтый
+            PUT: '\x1b[34m',    // синий
+            DELETE: '\x1b[31m', // красный
+            reset: '\x1b[0m'
+        };
+
+        const methodColor = colors[req.method] || '\x1b[36m';
+        
+        console.log('\n' + '='.repeat(50));
+        console.log(`${methodColor}🔑 API ${req.method} ${req.originalUrl}${colors.reset}`);
+        console.log(`📅 ${timestamp}`);
+        console.log(`👤 Пользователь: ID ${userId} (${req.apiUser?.name || 'Unknown'})`);
+        console.log(`🔑 API Key ID: ${apiKeyId}`);
+        console.log(`📋 Действие: ${action}`);
+        console.log(`📝 Детали: ${details}`);
+        console.log(`🌐 IP: ${ip}`);
+        console.log(`📱 User-Agent: ${userAgent.substring(0, 50)}...`);
+        console.log(`📊 Статус: ${statusCode} | Время: ${responseTime}ms`);
+        console.log('='.repeat(50));
+
+        // Сохраняем в базу данных
+        db.run(`
+            INSERT INTO api_logs (
+                api_key_id, user_id, action, details, ip, user_agent, 
+                method, path, response_status, response_time, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `, [
+            apiKeyId, userId, action, details, ip, userAgent, 
+            req.method, req.originalUrl, statusCode, responseTime, timestamp
+        ], (err) => {
+            if (err) {
+                console.error('❌ Ошибка сохранения лога API:', err.message);
+            }
+        });
+
+        // Логируем в общую активность для важных действий
+        const { logActivity } = require('./database');
+        if (logActivity && (
+            action.includes('STATUS') || 
+            action.includes('FILE') || 
+            action.includes('CREATE') ||
+            action.includes('UPDATE') ||
+            action.includes('DELETE')
+        )) {
+            const taskId = extractTaskIdFromDetails(details) || extractTaskIdFromUrl(req.originalUrl);
+            if (taskId) {
+                logActivity(
+                    taskId, 
+                    userId, 
+                    `API_${action}`,
+                    `[API Key ${apiKeyId}] ${details}`
+                );
+            }
+        }
+    };
+
+    // Вспомогательная функция для извлечения ID задачи из деталей
+    function extractTaskIdFromDetails(details) {
+        const match = details.match(/задачи?\s*[#№]?\s*(\d+)/i);
+        return match ? parseInt(match[1]) : null;
+    }
+
+    // Вспомогательная функция для извлечения ID задачи из URL
+    function extractTaskIdFromUrl(url) {
+        const match = url.match(/\/tasks?\/(\d+)/i);
+        return match ? parseInt(match[1]) : null;
+    }
+
+    // Функция для логирования попыток аутентификации
+    const logApiAttempt = (apiKeyId, userId, action, details, req, statusCode, responseTime) => {
+        const timestamp = new Date().toISOString();
+        const ip = req.ip || req.connection.remoteAddress;
+        const userAgent = req.get('User-Agent') || 'Unknown';
+        
+        const color = statusCode >= 400 ? '\x1b[31m' : '\x1b[33m';
+        
+        console.log('\n' + '='.repeat(50));
+        console.log(`${color}🔑 API ATTEMPT ${req.method} ${req.originalUrl}${'\x1b[0m'}`);
+        console.log(`📅 ${timestamp}`);
+        console.log(`👤 Пользователь ID: ${userId || 'N/A'}`);
+        console.log(`🔑 API Key ID: ${apiKeyId || 'N/A'}`);
+        console.log(`📋 Действие: ${action}`);
+        console.log(`📝 Детали: ${details}`);
+        console.log(`🌐 IP: ${ip}`);
+        console.log(`📊 Статус: ${statusCode} | Время: ${responseTime}ms`);
+        console.log('='.repeat(50));
+
+        if (apiKeyId && userId) {
+            db.run(`
+                INSERT INTO api_logs (
+                    api_key_id, user_id, action, details, ip, user_agent, 
+                    method, path, response_status, response_time, created_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `, [
+                apiKeyId, userId, action, details, ip, userAgent, 
+                req.method, req.originalUrl, statusCode, responseTime, timestamp
+            ], (err) => {
+                if (err) {
+                    console.error('❌ Ошибка сохранения лога попытки:', err.message);
+                }
+            });
+        }
+    };
+
+    // Создание таблиц для API ключей и логов
+function createApiKeysTables() {
+    return new Promise((resolve, reject) => {
+        // Таблица API ключей
+        db.run(`
+            CREATE TABLE IF NOT EXISTS api_keys (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                key TEXT NOT NULL UNIQUE,
+                user_id INTEGER NOT NULL,
+                description TEXT,
+                allowed_ips TEXT,
+                is_active BOOLEAN DEFAULT true,
+                last_used_at DATETIME,
+                last_used_ip TEXT,
+                created_by INTEGER NOT NULL,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+                FOREIGN KEY (created_by) REFERENCES users(id)
+            )
+        `, (err) => {
+            if (err) {
+                console.error('❌ Ошибка создания таблицы api_keys:', err.message);
+                reject(err);
+                return;
+            }
+
+            // Проверяем и добавляем отсутствующие колонки
+            db.all("PRAGMA table_info(api_keys)", (err, columns) => {
+                if (err) {
+                    console.error('❌ Ошибка получения информации о таблице:', err);
+                } else {
+                    const columnNames = columns.map(c => c.name);
+                    
+                    // Добавляем last_used_ip если отсутствует
+                    if (!columnNames.includes('last_used_ip')) {
+                        db.run("ALTER TABLE api_keys ADD COLUMN last_used_ip TEXT", (err) => {
+                            if (err) {
+                                console.error('❌ Ошибка добавления колонки last_used_ip:', err.message);
+                            } else {
+                                console.log('✅ Добавлена колонка last_used_ip в таблицу api_keys');
+                            }
+                        });
+                    }
+                }
+            });
+
+            // Таблица для логов API действий
+            db.run(`
+                CREATE TABLE IF NOT EXISTS api_logs (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    api_key_id INTEGER NOT NULL,
+                    user_id INTEGER NOT NULL,
+                    action TEXT NOT NULL,
+                    details TEXT,
+                    ip TEXT,
+                    user_agent TEXT,
+                    method TEXT,
+                    path TEXT,
+                    response_status INTEGER,
+                    response_time INTEGER,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (api_key_id) REFERENCES api_keys(id) ON DELETE CASCADE,
+                    FOREIGN KEY (user_id) REFERENCES users(id)
+                )
+            `, (err) => {
+                if (err) {
+                    console.error('❌ Ошибка создания таблицы api_logs:', err.message);
+                    reject(err);
+                    return;
+                }
+
+                // Таблица для связи API ключей с задачами
+                db.run(`
+                    CREATE TABLE IF NOT EXISTS api_task_mappings (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        api_key_id INTEGER NOT NULL,
+                        task_id INTEGER NOT NULL,
+                        external_task_id TEXT,
+                        synced_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                        last_status TEXT,
+                        FOREIGN KEY (api_key_id) REFERENCES api_keys(id) ON DELETE CASCADE,
+                        FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE,
+                        UNIQUE(api_key_id, task_id)
+                    )
+                `, (err) => {
+                    if (err) {
+                        console.error('❌ Ошибка создания таблицы api_task_mappings:', err.message);
+                        reject(err);
+                        return;
+                    }
+
+                    // Индексы
+                    db.run('CREATE INDEX IF NOT EXISTS idx_api_keys_user_id ON api_keys(user_id)');
+                    db.run('CREATE INDEX IF NOT EXISTS idx_api_keys_key ON api_keys(key)');
+                    db.run('CREATE INDEX IF NOT EXISTS idx_api_logs_api_key_id ON api_logs(api_key_id)');
+                    db.run('CREATE INDEX IF NOT EXISTS idx_api_logs_created_at ON api_logs(created_at)');
+                    db.run('CREATE INDEX IF NOT EXISTS idx_api_task_mappings_task_id ON api_task_mappings(task_id)');
+                    
+                    console.log('✅ Таблицы для API ключей и логов созданы');
+                    resolve();
+                });
+            });
+        });
+    });
+}
+
+    // Генерация уникального API ключа
+    function generateApiKey() {
+        return crypto.randomBytes(32).toString('hex');
+    }
+
+    // Middleware для проверки API ключа с логированием
+    const requireApiKey = (req, res, next) => {
+        const startTime = Date.now();
+        const apiKey = req.headers['x-api-key'] || req.query.api_key;
+        const ip = req.ip || req.connection.remoteAddress;
+        
+        console.log('\n\x1b[33m%s\x1b[0m', '🔑 Входящий API запрос');
+        console.log('🌐 IP:', ip);
+        console.log('🔑 Ключ:', apiKey ? apiKey.substring(0, 8) + '...' : 'не предоставлен');
+        console.log('🔄 Метод:', req.method);
+        console.log('📍 Путь:', req.originalUrl);
+        
+        if (!apiKey) {
+            logApiAttempt(null, null, 'AUTH_FAILED', 'Ключ не предоставлен', req, 401, Date.now() - startTime);
+            return res.status(401).json({ error: 'API ключ обязателен' });
+        }
+
+        // Проверяем ключ в базе
+        db.get(`
+            SELECT ak.*, u.login as user_login, u.name as user_name, u.id as user_id
+            FROM api_keys ak
+            JOIN users u ON ak.user_id = u.id
+            WHERE ak.key = ? AND ak.is_active = 1
+        `, [apiKey], (err, keyData) => {
+            const responseTime = Date.now() - startTime;
+            
+            if (err) {
+                console.error('❌ Ошибка проверки ключа:', err);
+                logApiAttempt(null, null, 'AUTH_ERROR', `Ошибка БД: ${err.message}`, req, 500, responseTime);
+                return res.status(500).json({ error: 'Ошибка проверки ключа' });
+            }
+            
+            if (!keyData) {
+                console.log('❌ Недействительный ключ:', apiKey.substring(0, 8) + '...');
+                
+                // Проверяем, есть ли такой ключ в базе (неактивный)
+                db.get('SELECT is_active FROM api_keys WHERE key = ?', [apiKey], (err, inactiveKey) => {
+                    const reason = inactiveKey ? 'Ключ деактивирован' : 'Ключ не найден';
+                    logApiAttempt(null, null, 'AUTH_FAILED', reason, req, 401, responseTime);
+                });
+                
+                return res.status(401).json({ error: 'Недействительный API ключ' });
+            }
+
+            // Проверка IP, если настроено
+            if (keyData.allowed_ips) {
+                try {
+                    const allowedIPs = JSON.parse(keyData.allowed_ips);
+                    if (allowedIPs.length > 0 && !allowedIPs.includes(ip)) {
+                        console.log('❌ IP не разрешен:', ip);
+                        logApiAttempt(keyData.id, keyData.user_id, 'AUTH_FAILED', `IP ${ip} не разрешен`, req, 403, responseTime);
+                        return res.status(403).json({ error: 'IP адрес не разрешен' });
+                    }
+                } catch (e) {
+                    console.error('Ошибка парсинга allowed_ips:', e);
+                }
+            }
+
+            // Обновляем информацию о последнем использовании
+            db.run(
+                'UPDATE api_keys SET last_used_at = CURRENT_TIMESTAMP, last_used_ip = ? WHERE id = ?',
+                [ip, keyData.id]
+            );
+
+            console.log('✅ Ключ валидный. Пользователь:', keyData.user_name);
+            console.log('⏱️ Время проверки:', responseTime + 'ms');
+
+            req.apiKey = keyData;
+            req.apiUser = {
+                id: keyData.user_id,
+                login: keyData.user_login,
+                name: keyData.user_name
+            };
+
+            // Сохраняем startTime для логирования времени ответа
+            req.apiRequestStartTime = startTime;
+            
+            next();
+        });
+    };
+
+    // Middleware для логирования ответов
+    const logResponse = (req, res, next) => {
+        const originalJson = res.json;
+        const originalSend = res.send;
+        const startTime = req.apiRequestStartTime || Date.now();
+
+        res.json = function(data) {
+            const responseTime = Date.now() - startTime;
+            
+            if (req.apiKey) {
+                logApiAction(
+                    req.apiKey.id,
+                    req.apiUser.id,
+                    `${req.method}_${req.path.replace(/[^a-zA-Z0-9]/g, '_')}`,
+                    `Статус: ${res.statusCode}`,
+                    req,
+                    res.statusCode,
+                    responseTime
+                );
+            }
+            
+            console.log(`📤 Ответ отправлен за ${responseTime}ms`);
+            originalJson.call(this, data);
+        };
+
+        res.send = function(data) {
+            const responseTime = Date.now() - startTime;
+            
+            if (req.apiKey) {
+                logApiAction(
+                    req.apiKey.id,
+                    req.apiUser.id,
+                    `${req.method}_${req.path.replace(/[^a-zA-Z0-9]/g, '_')}`,
+                    `Статус: ${res.statusCode}`,
+                    req,
+                    res.statusCode,
+                    responseTime
+                );
+            }
+            
+            console.log(`📤 Ответ отправлен за ${responseTime}ms`);
+            originalSend.call(this, data);
+        };
+
+        next();
+    };
+
+    // GET /api/api-keys/logs - Получить логи API (только админ)
+    router.get('/api/api-keys/logs', requireAuth, requireAdmin, (req, res) => {
+        const { limit = 100, offset = 0, api_key_id, user_id, action } = req.query;
+
+        let query = `
+            SELECT l.*, ak.name as api_key_name, u.name as user_name, u.login as user_login
+            FROM api_logs l
+            LEFT JOIN api_keys ak ON l.api_key_id = ak.id
+            LEFT JOIN users u ON l.user_id = u.id
+            WHERE 1=1
+        `;
+        const params = [];
+
+        if (api_key_id) {
+            query += ' AND l.api_key_id = ?';
+            params.push(api_key_id);
+        }
+
+        if (user_id) {
+            query += ' AND l.user_id = ?';
+            params.push(user_id);
+        }
+
+        if (action) {
+            query += ' AND l.action LIKE ?';
+            params.push(`%${action}%`);
+        }
+
+        query += ' ORDER BY l.created_at DESC LIMIT ? OFFSET ?';
+        params.push(parseInt(limit), parseInt(offset));
+
+        db.all(query, params, (err, logs) => {
+            if (err) {
+                console.error('❌ Ошибка получения логов:', err);
+                return res.status(500).json({ error: 'Ошибка получения логов' });
+            }
+
+            // Получаем общее количество
+            db.get('SELECT COUNT(*) as total FROM api_logs', [], (err, count) => {
+                if (err) {
+                    return res.json({ logs: logs || [], total: 0 });
+                }
+
+                res.json({
+                    success: true,
+                    logs: logs || [],
+                    total: count.total,
+                    limit: parseInt(limit),
+                    offset: parseInt(offset)
+                });
+            });
+        });
+    });
+
+    // GET /api/api-keys/:id/logs - Получить логи конкретного ключа
+    router.get('/api/api-keys/:id/logs', requireAuth, requireAdmin, (req, res) => {
+        const { id } = req.params;
+        const { limit = 50 } = req.query;
+
+        db.all(`
+            SELECT l.*, u.name as user_name
+            FROM api_logs l
+            LEFT JOIN users u ON l.user_id = u.id
+            WHERE l.api_key_id = ?
+            ORDER BY l.created_at DESC
+            LIMIT ?
+        `, [id, parseInt(limit)], (err, logs) => {
+            if (err) {
+                console.error('❌ Ошибка получения логов ключа:', err);
+                return res.status(500).json({ error: 'Ошибка получения логов' });
+            }
+
+            res.json({
+                success: true,
+                logs: logs || []
+            });
+        });
+    });
+
+    // GET /api/api-keys/stats - Статистика использования API
+    router.get('/api/api-keys/stats', requireAuth, requireAdmin, (req, res) => {
+        const stats = {};
+
+        // Общая статистика
+        db.get(`
+            SELECT 
+                COUNT(DISTINCT api_key_id) as active_keys,
+                COUNT(*) as total_requests,
+                COUNT(DISTINCT user_id) as unique_users,
+                AVG(response_time) as avg_response_time,
+                COUNT(CASE WHEN response_status >= 400 THEN 1 END) as error_count,
+                COUNT(CASE WHEN DATE(created_at) = DATE('now') THEN 1 END) as today_requests
+            FROM api_logs
+            WHERE created_at >= DATE('now', '-30 days')
+        `, [], (err, total) => {
+            if (err) {
+                console.error('❌ Ошибка получения статистики:', err);
+                return res.status(500).json({ error: 'Ошибка получения статистики' });
+            }
+
+            stats.total = total || {};
+
+            // Статистика по методам
+            db.all(`
+                SELECT method, COUNT(*) as count
+                FROM api_logs
+                WHERE created_at >= DATE('now', '-30 days')
+                GROUP BY method
+                ORDER BY count DESC
+            `, [], (err, methods) => {
+                if (err) {
+                    return res.json(stats);
+                }
+
+                stats.by_method = methods || [];
+
+                // Статистика по дням
+                db.all(`
+                    SELECT DATE(created_at) as date, COUNT(*) as count
+                    FROM api_logs
+                    WHERE created_at >= DATE('now', '-7 days')
+                    GROUP BY DATE(created_at)
+                    ORDER BY date DESC
+                `, [], (err, daily) => {
+                    if (err) {
+                        return res.json(stats);
+                    }
+
+                    stats.daily = daily || [];
+
+                    // Топ ключей
+                    db.all(`
+                        SELECT 
+                            l.api_key_id,
+                            ak.name as api_key_name,
+                            COUNT(*) as request_count,
+                            COUNT(DISTINCT l.user_id) as users_count,
+                            AVG(l.response_time) as avg_time
+                        FROM api_logs l
+                        LEFT JOIN api_keys ak ON l.api_key_id = ak.id
+                        WHERE l.created_at >= DATE('now', '-30 days')
+                        GROUP BY l.api_key_id
+                        ORDER BY request_count DESC
+                        LIMIT 10
+                    `, [], (err, topKeys) => {
+                        if (err) {
+                            return res.json(stats);
+                        }
+
+                        stats.top_keys = topKeys || [];
+
+                        res.json({
+                            success: true,
+                            stats,
+                            timestamp: new Date().toISOString()
+                        });
+                    });
+                });
+            });
+        });
+    });
+
+    // GET /api/api-keys - Получить все ключи (только админ)
+    router.get('/api/api-keys', requireAuth, requireAdmin, (req, res) => {
+        db.all(`
+            SELECT ak.*, u.name as user_name, u.login as user_login,
+                   creator.name as creator_name,
+                   (SELECT COUNT(*) FROM api_logs WHERE api_key_id = ak.id) as request_count,
+                   (SELECT created_at FROM api_logs WHERE api_key_id = ak.id ORDER BY created_at DESC LIMIT 1) as last_request
+            FROM api_keys ak
+            LEFT JOIN users u ON ak.user_id = u.id
+            LEFT JOIN users creator ON ak.created_by = creator.id
+            ORDER BY ak.created_at DESC
+        `, [], (err, keys) => {
+            if (err) {
+                console.error('❌ Ошибка получения API ключей:', err);
+                return res.status(500).json({ error: 'Ошибка получения ключей' });
+            }
+            
+            // Маскируем ключи для безопасности
+            const maskedKeys = (keys || []).map(key => ({
+                ...key,
+                key: key.key.substring(0, 8) + '...' + key.key.substring(key.key.length - 8),
+                request_count: key.request_count || 0
+            }));
+            
+            res.json(maskedKeys);
+        });
+    });
+
+    // POST /api/api-keys - Создать новый API ключ (только админ)
+    router.post('/api/api-keys', requireAuth, requireAdmin, (req, res) => {
+        const { name, user_id, description, allowed_ips } = req.body;
+        const startTime = Date.now();
+
+        if (!name || !user_id) {
+            return res.status(400).json({ error: 'Название и пользователь обязательны' });
+        }
+
+        // Проверяем существование пользователя
+        db.get('SELECT id, name FROM users WHERE id = ?', [user_id], (err, user) => {
+            if (err || !user) {
+                return res.status(404).json({ error: 'Пользователь не найден' });
+            }
+
+            const apiKey = generateApiKey();
+            const allowedIPsJson = allowed_ips ? JSON.stringify(allowed_ips.split(',').map(ip => ip.trim())) : null;
+
+            db.run(`
+                INSERT INTO api_keys (name, key, user_id, description, allowed_ips, created_by)
+                VALUES (?, ?, ?, ?, ?, ?)
+            `, [name, apiKey, user_id, description || '', allowedIPsJson, req.session.user.id],
+            function(err) {
+                const responseTime = Date.now() - startTime;
+                
+                if (err) {
+                    console.error('❌ Ошибка создания API ключа:', err);
+                    return res.status(500).json({ error: 'Ошибка создания ключа' });
+                }
+
+                // Логируем создание ключа
+                logApiAction(
+                    this.lastID,
+                    req.session.user.id,
+                    'API_KEY_CREATED',
+                    `Создан ключ "${name}" для пользователя ${user.name} (ID: ${user_id})`,
+                    req,
+                    201,
+                    responseTime
+                );
+
+                res.status(201).json({
+                    success: true,
+                    id: this.lastID,
+                    key: apiKey,
+                    message: 'API ключ успешно создан'
+                });
+            });
+        });
+    });
+
+    // PUT /api/api-keys/:id/toggle - Активировать/деактивировать ключ
+    router.put('/api/api-keys/:id/toggle', requireAuth, requireAdmin, (req, res) => {
+        const { id } = req.params;
+        const { is_active } = req.body;
+        const startTime = Date.now();
+
+        db.get('SELECT name FROM api_keys WHERE id = ?', [id], (err, key) => {
+            if (err || !key) {
+                return res.status(404).json({ error: 'Ключ не найден' });
+            }
+
+            db.run(
+                'UPDATE api_keys SET is_active = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
+                [is_active ? 1 : 0, id],
+                function(err) {
+                    const responseTime = Date.now() - startTime;
+                    
+                    if (err) {
+                        console.error('❌ Ошибка обновления ключа:', err);
+                        return res.status(500).json({ error: 'Ошибка обновления ключа' });
+                    }
+
+                    logApiAction(
+                        id,
+                        req.session.user.id,
+                        is_active ? 'API_KEY_ACTIVATED' : 'API_KEY_DEACTIVATED',
+                        `Ключ "${key.name}" ${is_active ? 'активирован' : 'деактивирован'}`,
+                        req,
+                        200,
+                        responseTime
+                    );
+
+                    res.json({ 
+                        success: true, 
+                        message: `Ключ ${is_active ? 'активирован' : 'деактивирован'}` 
+                    });
+                }
+            );
+        });
+    });
+
+    // DELETE /api/api-keys/:id - Удалить ключ (только админ)
+    router.delete('/api/api-keys/:id', requireAuth, requireAdmin, (req, res) => {
+        const { id } = req.params;
+        const startTime = Date.now();
+
+        db.get('SELECT name FROM api_keys WHERE id = ?', [id], (err, key) => {
+            if (err || !key) {
+                return res.status(404).json({ error: 'Ключ не найден' });
+            }
+
+            db.run('DELETE FROM api_keys WHERE id = ?', [id], function(err) {
+                const responseTime = Date.now() - startTime;
+                
+                if (err) {
+                    console.error('❌ Ошибка удаления ключа:', err);
+                    return res.status(500).json({ error: 'Ошибка удаления ключа' });
+                }
+
+                logApiAction(
+                    id,
+                    req.session.user.id,
+                    'API_KEY_DELETED',
+                    `Удален ключ "${key.name}"`,
+                    req,
+                    200,
+                    responseTime
+                );
+
+                res.json({ success: true, message: 'Ключ удален' });
+            });
+        });
+    });
+
+    // ==================== Публичное API для внешних сервисов ====================
+
+    // GET /api/external/tasks - Получить задачи для внешнего сервиса
+    router.get('/api/external/tasks', requireApiKey, logResponse, (req, res) => {
+        const userId = req.apiUser.id;
+        const { status, limit = 50, offset = 0 } = req.query;
+        const startTime = Date.now();
+
+        let query = `
+            SELECT DISTINCT
+                t.id,
+                t.title,
+                t.description,
+                t.created_at,
+                t.due_date,
+                t.task_type,
+                u.name as creator_name,
+                (
+                    SELECT json_group_array(json_object(
+                        'id', tf.id,
+                        'filename', tf.original_name,
+                        'file_size', tf.file_size,
+                        'uploaded_at', tf.uploaded_at
+                    ))
+                    FROM task_files tf
+                    WHERE tf.task_id = t.id
+                ) as files,
+                ta.status as assignment_status,
+                ta.start_date,
+                ta.due_date as assignment_due_date
+            FROM tasks t
+            LEFT JOIN users u ON t.created_by = u.id
+            LEFT JOIN task_assignments ta ON t.id = ta.task_id AND ta.user_id = ?
+            WHERE ta.user_id = ? 
+            AND t.status = 'active'
+            AND t.closed_at IS NULL
+        `;
+
+        const params = [userId, userId];
+
+        if (status) {
+            if (status === 'active') {
+                query += ` AND ta.status IN ('assigned', 'in_progress')`;
+            } else {
+                query += ` AND ta.status = ?`;
+                params.push(status);
+            }
+        }
+
+        query += ` ORDER BY t.due_date ASC, t.created_at DESC LIMIT ? OFFSET ?`;
+        params.push(limit, offset);
+
+        db.all(query, params, (err, tasks) => {
+            const responseTime = Date.now() - startTime;
+            
+            if (err) {
+                console.error('❌ Ошибка получения задач:', err);
+                logApiAction(
+                    req.apiKey.id,
+                    userId,
+                    'GET_TASKS_ERROR',
+                    `Ошибка: ${err.message}`,
+                    req,
+                    500,
+                    responseTime
+                );
+                return res.status(500).json({ error: 'Ошибка получения задач' });
+            }
+
+            // Парсим JSON с файлами
+            const result = (tasks || []).map(task => {
+                try {
+                    task.files = JSON.parse(task.files || '[]');
+                } catch (e) {
+                    task.files = [];
+                }
+                return task;
+            });
+
+            logApiAction(
+                req.apiKey.id,
+                userId,
+                'GET_TASKS',
+                `Получено ${result.length} задач${status ? ` (статус: ${status})` : ''}`,
+                req,
+                200,
+                responseTime
+            );
+
+            res.json({
+                success: true,
+                tasks: result,
+                meta: {
+                    total: result.length,
+                    limit,
+                    offset,
+                    user: req.apiUser.name
+                }
+            });
+        });
+    });
+
+    // GET /api/external/tasks/:taskId - Получить конкретную задачу
+    router.get('/api/external/tasks/:taskId', requireApiKey, logResponse, (req, res) => {
+        const { taskId } = req.params;
+        const userId = req.apiUser.id;
+        const startTime = Date.now();
+
+        // Проверяем, что задача назначена этому пользователю
+        db.get(`
+            SELECT t.*, u.name as creator_name,
+                   (
+                       SELECT json_group_array(json_object(
+                           'id', tf.id,
+                           'filename', tf.original_name,
+                           'file_path', tf.file_path,
+                           'file_size', tf.file_size,
+                           'uploaded_at', tf.uploaded_at,
+                           'uploader_name', up.name
+                       ))
+                       FROM task_files tf
+                       LEFT JOIN users up ON tf.user_id = up.id
+                       WHERE tf.task_id = t.id
+                   ) as files,
+                   ta.status as assignment_status,
+                   ta.start_date,
+                   ta.due_date as assignment_due_date
+            FROM tasks t
+            LEFT JOIN users u ON t.created_by = u.id
+            LEFT JOIN task_assignments ta ON t.id = ta.task_id AND ta.user_id = ?
+            WHERE t.id = ? AND ta.user_id IS NOT NULL
+        `, [userId, taskId], (err, task) => {
+            const responseTime = Date.now() - startTime;
+            
+            if (err) {
+                console.error('❌ Ошибка получения задачи:', err);
+                logApiAction(
+                    req.apiKey.id,
+                    userId,
+                    'GET_TASK_ERROR',
+                    `Ошибка получения задачи ${taskId}: ${err.message}`,
+                    req,
+                    500,
+                    responseTime
+                );
+                return res.status(500).json({ error: 'Ошибка получения задачи' });
+            }
+            
+            if (!task) {
+                logApiAction(
+                    req.apiKey.id,
+                    userId,
+                    'GET_TASK_NOT_FOUND',
+                    `Задача ${taskId} не найдена или не назначена`,
+                    req,
+                    404,
+                    responseTime
+                );
+                return res.status(404).json({ error: 'Задача не найдена или не назначена вам' });
+            }
+
+            try {
+                task.files = JSON.parse(task.files || '[]');
+            } catch (e) {
+                task.files = [];
+            }
+
+            logApiAction(
+                req.apiKey.id,
+                userId,
+                'GET_TASK',
+                `Получена задача ${taskId}: "${task.title}"`,
+                req,
+                200,
+                responseTime
+            );
+
+            res.json({ success: true, task });
+        });
+    });
+
+    // PUT /api/external/tasks/:taskId/status - Изменить статус задачи
+    router.put('/api/external/tasks/:taskId/status', requireApiKey, logResponse, (req, res) => {
+        const { taskId } = req.params;
+        const { status, comment } = req.body;
+        const userId = req.apiUser.id;
+        const startTime = Date.now();
+
+        if (!status || !['in_progress', 'completed'].includes(status)) {
+            logApiAction(
+                req.apiKey.id,
+                userId,
+                'UPDATE_STATUS_ERROR',
+                `Попытка установить недопустимый статус "${status}" для задачи ${taskId}`,
+                req,
+                400,
+                Date.now() - startTime
+            );
+            return res.status(400).json({ 
+                error: 'Статус должен быть "in_progress" или "completed"' 
+            });
+        }
+
+        // Проверяем, что задача назначена этому пользователю
+        db.get(`
+            SELECT ta.id, ta.status as current_status, t.title, t.created_by
+            FROM task_assignments ta
+            JOIN tasks t ON ta.task_id = t.id
+            WHERE ta.task_id = ? AND ta.user_id = ?
+        `, [taskId, userId], (err, assignment) => {
+            if (err || !assignment) {
+                const responseTime = Date.now() - startTime;
+                logApiAction(
+                    req.apiKey.id,
+                    userId,
+                    'UPDATE_STATUS_ERROR',
+                    `Задача ${taskId} не назначена пользователю`,
+                    req,
+                    404,
+                    responseTime
+                );
+                return res.status(404).json({ error: 'Задача не назначена вам' });
+            }
+
+            // Обновляем статус
+            db.run(
+                `UPDATE task_assignments 
+                 SET status = ?, updated_at = CURRENT_TIMESTAMP 
+                 WHERE task_id = ? AND user_id = ?`,
+                [status, taskId, userId],
+                function(err) {
+                    const responseTime = Date.now() - startTime;
+                    
+                    if (err) {
+                        console.error('❌ Ошибка обновления статуса:', err);
+                        logApiAction(
+                            req.apiKey.id,
+                            userId,
+                            'UPDATE_STATUS_ERROR',
+                            `Ошибка обновления статуса задачи ${taskId}: ${err.message}`,
+                            req,
+                            500,
+                            responseTime
+                        );
+                        return res.status(500).json({ error: 'Ошибка обновления статуса' });
+                    }
+
+                    const details = `Статус задачи ${taskId} "${assignment.title}" изменен с ${assignment.current_status} на ${status}. Комментарий: ${comment || 'нет'}`;
+                    
+                    logApiAction(
+                        req.apiKey.id,
+                        userId,
+                        `TASK_${status.toUpperCase()}`,
+                        details,
+                        req,
+                        200,
+                        responseTime
+                    );
+
+                    // Логируем в общую активность
+                    const { logActivity } = require('./database');
+                    if (logActivity) {
+                        logActivity(
+                            parseInt(taskId), 
+                            userId, 
+                            `API_TASK_${status.toUpperCase()}`, 
+                            `[API Key ${req.apiKey.id}] ${comment || 'Без комментария'}`
+                        );
+                    }
+
+                    res.json({ 
+                        success: true, 
+                        message: `Статус изменен на "${status}"`,
+                        old_status: assignment.current_status,
+                        new_status: status,
+                        task_title: assignment.title
+                    });
+                }
+            );
+        });
+    });
+
+    // POST /api/external/tasks/:taskId/files - Загрузить файл к задаче
+    router.post('/api/external/tasks/:taskId/files', requireApiKey, logResponse, upload.single('file'), (req, res) => {
+        const { taskId } = req.params;
+        const userId = req.apiUser.id;
+        const startTime = Date.now();
+
+        if (!req.file) {
+            logApiAction(
+                req.apiKey.id,
+                userId,
+                'UPLOAD_FILE_ERROR',
+                `Попытка загрузить файл без файла к задаче ${taskId}`,
+                req,
+                400,
+                Date.now() - startTime
+            );
+            return res.status(400).json({ error: 'Файл обязателен' });
+        }
+
+        // Проверяем, что задача назначена этому пользователю
+        db.get(`
+            SELECT ta.id, t.title
+            FROM task_assignments ta
+            JOIN tasks t ON ta.task_id = t.id
+            WHERE ta.task_id = ? AND ta.user_id = ?
+        `, [taskId, userId], (err, assignment) => {
+            if (err || !assignment) {
+                // Удаляем загруженный файл, если он не нужен
+                if (req.file && req.file.path && fs.existsSync(req.file.path)) {
+                    fs.unlinkSync(req.file.path);
+                }
+                
+                const responseTime = Date.now() - startTime;
+                logApiAction(
+                    req.apiKey.id,
+                    userId,
+                    'UPLOAD_FILE_ERROR',
+                    `Задача ${taskId} не назначена пользователю`,
+                    req,
+                    404,
+                    responseTime
+                );
+                return res.status(404).json({ error: 'Задача не назначена вам' });
+            }
+
+            const { createUserTaskFolder } = require('./database');
+            const userFolder = createUserTaskFolder(taskId, req.apiUser.login);
+
+            const newPath = path.join(userFolder, path.basename(req.file.filename));
+            fs.renameSync(req.file.path, newPath);
+
+            db.run(
+                `INSERT INTO task_files 
+                 (task_id, user_id, filename, original_name, file_path, file_size) 
+                 VALUES (?, ?, ?, ?, ?, ?)`,
+                [taskId, userId, path.basename(req.file.filename), req.file.originalname, newPath, req.file.size],
+                function(err) {
+                    const responseTime = Date.now() - startTime;
+                    
+                    if (err) {
+                        console.error('❌ Ошибка сохранения файла:', err);
+                        logApiAction(
+                            req.apiKey.id,
+                            userId,
+                            'UPLOAD_FILE_ERROR',
+                            `Ошибка сохранения файла для задачи ${taskId}: ${err.message}`,
+                            req,
+                            500,
+                            responseTime
+                        );
+                        return res.status(500).json({ error: 'Ошибка сохранения файла' });
+                    }
+
+                    const details = `Загружен файл "${req.file.originalname}" (${(req.file.size / 1024).toFixed(2)} KB) к задаче ${taskId} "${assignment.title}"`;
+                    
+                    logApiAction(
+                        req.apiKey.id,
+                        userId,
+                        'FILE_UPLOADED',
+                        details,
+                        req,
+                        200,
+                        responseTime
+                    );
+
+                    // Логируем в общую активность
+                    const { logActivity } = require('./database');
+                    if (logActivity) {
+                        logActivity(
+                            parseInt(taskId), 
+                            userId, 
+                            'API_FILE_UPLOADED', 
+                            `[API Key ${req.apiKey.id}] Загружен файл: ${req.file.originalname}`
+                        );
+                    }
+
+                    res.json({
+                        success: true,
+                        file_id: this.lastID,
+                        filename: req.file.originalname,
+                        size: req.file.size,
+                        message: 'Файл успешно загружен'
+                    });
+                }
+            );
+        });
+    });
+
+    // GET /api/external/tasks/:taskId/files/:fileId/download - Скачать файл
+    router.get('/api/external/tasks/:taskId/files/:fileId/download', requireApiKey, logResponse, (req, res) => {
+        const { taskId, fileId } = req.params;
+        const userId = req.apiUser.id;
+        const startTime = Date.now();
+
+        db.get(`
+            SELECT tf.*, t.title as task_title
+            FROM task_files tf
+            JOIN task_assignments ta ON tf.task_id = ta.task_id
+            JOIN tasks t ON tf.task_id = t.id
+            WHERE tf.id = ? AND tf.task_id = ? AND ta.user_id = ?
+        `, [fileId, taskId, userId], (err, file) => {
+            const responseTime = Date.now() - startTime;
+            
+            if (err || !file) {
+                logApiAction(
+                    req.apiKey.id,
+                    userId,
+                    'DOWNLOAD_FILE_ERROR',
+                    `Файл ${fileId} не найден для задачи ${taskId}`,
+                    req,
+                    404,
+                    responseTime
+                );
+                return res.status(404).json({ error: 'Файл не найден' });
+            }
+
+            if (!fs.existsSync(file.file_path)) {
+                logApiAction(
+                    req.apiKey.id,
+                    userId,
+                    'DOWNLOAD_FILE_ERROR',
+                    `Файл ${fileId} не найден на сервере для задачи ${taskId}`,
+                    req,
+                    404,
+                    responseTime
+                );
+                return res.status(404).json({ error: 'Файл не найден на сервере' });
+            }
+
+            logApiAction(
+                req.apiKey.id,
+                userId,
+                'FILE_DOWNLOADED',
+                `Скачан файл "${file.original_name}" из задачи ${taskId} "${file.task_title}"`,
+                req,
+                200,
+                responseTime
+            );
+
+            res.setHeader('Content-Disposition', `attachment; filename*=UTF-8''${encodeURIComponent(file.original_name)}`);
+            res.setHeader('Content-Type', 'application/octet-stream');
+            res.sendFile(file.file_path);
+        });
+    });
+
+    // ==================== Инициализация ====================
+    
+    const init = async () => {
+        try {
+            await createApiKeysTables();
+            console.log('✅ Модуль API ключей с логированием инициализирован');
+        } catch (error) {
+            console.error('❌ Ошибка инициализации API ключей:', error.message);
+        }
+    };
+
+    init();
+    
+    app.use(router);
+
+    return {
+        requireApiKey,
+        generateApiKey
+    };
+};
\ No newline at end of file
diff --git a/public/admin-api-management.html b/public/admin-api-management.html
new file mode 100644
index 0000000..3976d17
--- /dev/null
+++ b/public/admin-api-management.html
@@ -0,0 +1,1787 @@
+<!DOCTYPE html>
+<html lang="ru">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Управление API ключами и пользователями</title>
+    <link rel="stylesheet" href="/style.css">
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+            background: #f5f7fa;
+            color: #2c3e50;
+        }
+
+        .app-container {
+            display: flex;
+            min-height: 100vh;
+        }
+
+        /* Сайдбар */
+        .sidebar {
+            width: 280px;
+            background: linear-gradient(180deg, #2c3e50 0%, #1a2632 100%);
+            color: white;
+            padding: 25px 0;
+            position: fixed;
+            height: 100vh;
+            overflow-y: auto;
+            box-shadow: 2px 0 10px rgba(0,0,0,0.1);
+        }
+
+        .logo {
+            font-size: 24px;
+            font-weight: bold;
+            padding: 0 25px;
+            margin-bottom: 30px;
+            color: #ecf0f1;
+            letter-spacing: 1px;
+        }
+
+        .logo span {
+            color: #3498db;
+        }
+
+        .nav-menu {
+            display: flex;
+            flex-direction: column;
+        }
+
+        .nav-item {
+            padding: 15px 25px;
+            color: #bdc3c7;
+            text-decoration: none;
+            transition: all 0.3s;
+            display: flex;
+            align-items: center;
+            gap: 12px;
+            font-size: 15px;
+            border-left: 4px solid transparent;
+        }
+
+        .nav-item:hover {
+            background: rgba(255,255,255,0.1);
+            color: white;
+        }
+
+        .nav-item.active {
+            background: rgba(52, 152, 219, 0.2);
+            color: white;
+            border-left-color: #3498db;
+        }
+
+        .nav-item i {
+            width: 24px;
+            font-size: 18px;
+        }
+
+        /* Основной контент */
+        .main-content {
+            flex: 1;
+            margin-left: 280px;
+            padding: 30px;
+        }
+
+        .header {
+            background: white;
+            padding: 25px 30px;
+            border-radius: 12px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.05);
+            margin-bottom: 30px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .header h1 {
+            font-size: 28px;
+            color: #2c3e50;
+        }
+
+        .header h1 small {
+            font-size: 14px;
+            color: #7f8c8d;
+            font-weight: normal;
+            margin-left: 15px;
+        }
+
+        .header-actions {
+            display: flex;
+            gap: 15px;
+        }
+
+        .btn-primary {
+            background: #3498db;
+            color: white;
+            border: none;
+            padding: 12px 24px;
+            border-radius: 8px;
+            cursor: pointer;
+            font-size: 15px;
+            font-weight: 500;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            transition: all 0.2s;
+            box-shadow: 0 2px 5px rgba(52,152,219,0.3);
+        }
+
+        .btn-primary:hover {
+            background: #2980b9;
+            transform: translateY(-2px);
+            box-shadow: 0 4px 10px rgba(52,152,219,0.4);
+        }
+
+        .btn-secondary {
+            background: #95a5a6;
+            color: white;
+            border: none;
+            padding: 12px 24px;
+            border-radius: 8px;
+            cursor: pointer;
+            font-size: 15px;
+            font-weight: 500;
+            transition: all 0.2s;
+        }
+
+        .btn-secondary:hover {
+            background: #7f8c8d;
+        }
+
+        .btn-danger {
+            background: #e74c3c;
+            color: white;
+            border: none;
+            padding: 8px 16px;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 13px;
+            transition: all 0.2s;
+        }
+
+        .btn-danger:hover {
+            background: #c0392b;
+        }
+
+        .btn-warning {
+            background: #f39c12;
+            color: white;
+            border: none;
+            padding: 8px 16px;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 13px;
+            transition: all 0.2s;
+        }
+
+        .btn-warning:hover {
+            background: #e67e22;
+        }
+
+        .btn-sm {
+            padding: 6px 12px;
+            font-size: 12px;
+        }
+
+        /* Статистика */
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+            gap: 25px;
+            margin-bottom: 30px;
+        }
+
+        .stat-card {
+            background: white;
+            padding: 25px;
+            border-radius: 12px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.05);
+            display: flex;
+            align-items: center;
+            gap: 20px;
+            transition: transform 0.2s;
+        }
+
+        .stat-card:hover {
+            transform: translateY(-5px);
+            box-shadow: 0 5px 20px rgba(0,0,0,0.1);
+        }
+
+        .stat-icon {
+            width: 60px;
+            height: 60px;
+            background: #f0f7ff;
+            border-radius: 12px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 28px;
+            color: #3498db;
+        }
+
+        .stat-info h3 {
+            font-size: 28px;
+            margin-bottom: 5px;
+            color: #2c3e50;
+        }
+
+        .stat-info p {
+            color: #7f8c8d;
+            font-size: 14px;
+        }
+
+        /* Табы */
+        .tabs {
+            background: white;
+            border-radius: 12px 12px 0 0;
+            padding: 0 20px;
+            display: flex;
+            gap: 5px;
+            border-bottom: 1px solid #ecf0f1;
+        }
+
+        .tab-btn {
+            padding: 18px 25px;
+            background: none;
+            border: none;
+            cursor: pointer;
+            font-size: 15px;
+            font-weight: 500;
+            color: #7f8c8d;
+            position: relative;
+            transition: all 0.2s;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .tab-btn:hover {
+            color: #3498db;
+        }
+
+        .tab-btn.active {
+            color: #3498db;
+        }
+
+        .tab-btn.active::after {
+            content: '';
+            position: absolute;
+            bottom: -1px;
+            left: 0;
+            right: 0;
+            height: 3px;
+            background: #3498db;
+            border-radius: 3px 3px 0 0;
+        }
+
+        .tab-content {
+            background: white;
+            border-radius: 0 0 12px 12px;
+            padding: 25px;
+            margin-bottom: 30px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.05);
+            display: none;
+        }
+
+        .tab-content.active {
+            display: block;
+        }
+
+        /* Поиск */
+        .search-box {
+            margin-bottom: 25px;
+            display: flex;
+            gap: 15px;
+        }
+
+        .search-box input {
+            flex: 1;
+            padding: 12px 20px;
+            border: 2px solid #e1e5e9;
+            border-radius: 8px;
+            font-size: 15px;
+            transition: all 0.2s;
+        }
+
+        .search-box input:focus {
+            border-color: #3498db;
+            outline: none;
+            box-shadow: 0 0 0 3px rgba(52,152,219,0.1);
+        }
+
+        .search-box select {
+            width: 200px;
+            padding: 12px 20px;
+            border: 2px solid #e1e5e9;
+            border-radius: 8px;
+            font-size: 15px;
+            background: white;
+        }
+
+        /* Карточки API ключей */
+        .api-keys-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(400px, 1fr));
+            gap: 20px;
+        }
+
+        .api-key-card {
+            background: white;
+            border: 1px solid #ecf0f1;
+            border-radius: 10px;
+            padding: 20px;
+            transition: all 0.2s;
+            position: relative;
+            box-shadow: 0 2px 5px rgba(0,0,0,0.02);
+        }
+
+        .api-key-card:hover {
+            box-shadow: 0 5px 15px rgba(0,0,0,0.1);
+            border-color: #3498db;
+        }
+
+        .api-key-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 15px;
+        }
+
+        .api-key-name {
+            font-size: 18px;
+            font-weight: bold;
+            color: #2c3e50;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .api-key-badge {
+            padding: 4px 10px;
+            border-radius: 20px;
+            font-size: 11px;
+            font-weight: 600;
+            text-transform: uppercase;
+        }
+
+        .badge-active {
+            background: #d4edda;
+            color: #155724;
+        }
+
+        .badge-inactive {
+            background: #f8d7da;
+            color: #721c24;
+        }
+
+        .api-key-value {
+            background: #f8f9fa;
+            padding: 12px 15px;
+            border-radius: 6px;
+            font-family: 'Courier New', monospace;
+            font-size: 13px;
+            border: 1px solid #e1e5e9;
+            margin: 15px 0;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            word-break: break-all;
+        }
+
+        .api-key-value span {
+            color: #2c3e50;
+        }
+
+        .api-key-meta {
+            font-size: 13px;
+            color: #7f8c8d;
+            margin: 10px 0;
+            padding: 10px 0;
+            border-top: 1px solid #ecf0f1;
+            border-bottom: 1px solid #ecf0f1;
+        }
+
+        .meta-row {
+            display: flex;
+            margin: 5px 0;
+        }
+
+        .meta-label {
+            width: 110px;
+            color: #95a5a6;
+        }
+
+        .meta-value {
+            flex: 1;
+            color: #2c3e50;
+        }
+
+        .api-key-actions {
+            display: flex;
+            gap: 10px;
+            margin-top: 15px;
+            justify-content: flex-end;
+        }
+
+        .copy-btn {
+            background: #ecf0f1;
+            border: none;
+            padding: 8px 15px;
+            border-radius: 6px;
+            cursor: pointer;
+            display: flex;
+            align-items: center;
+            gap: 5px;
+            font-size: 13px;
+            transition: all 0.2s;
+        }
+
+        .copy-btn:hover {
+            background: #bdc3c7;
+        }
+
+        .copy-success {
+            background: #d4edda;
+            color: #155724;
+        }
+
+        /* Таблица пользователей */
+        .users-table {
+            width: 100%;
+            border-collapse: collapse;
+        }
+
+        .users-table th {
+            text-align: left;
+            padding: 15px 10px;
+            background: #f8f9fa;
+            color: #2c3e50;
+            font-weight: 600;
+            border-bottom: 2px solid #e1e5e9;
+        }
+
+        .users-table td {
+            padding: 15px 10px;
+            border-bottom: 1px solid #ecf0f1;
+            vertical-align: middle;
+        }
+
+        .users-table tr:hover td {
+            background: #f8f9fa;
+        }
+
+        .user-avatar {
+            width: 40px;
+            height: 40px;
+            background: #3498db;
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: white;
+            font-weight: bold;
+            font-size: 16px;
+        }
+
+        .user-info {
+            display: flex;
+            align-items: center;
+            gap: 15px;
+        }
+
+        .user-details h4 {
+            font-size: 16px;
+            margin-bottom: 3px;
+        }
+
+        .user-details small {
+            color: #7f8c8d;
+            font-size: 12px;
+        }
+
+        .role-badge {
+            padding: 4px 10px;
+            border-radius: 20px;
+            font-size: 11px;
+            font-weight: 600;
+            background: #e1e5e9;
+            color: #2c3e50;
+        }
+
+        .role-admin {
+            background: #c0392b;
+            color: white;
+        }
+
+        .role-tasks {
+            background: #2980b9;
+            color: white;
+        }
+
+        .api-keys-count {
+            background: #3498db;
+            color: white;
+            padding: 3px 8px;
+            border-radius: 20px;
+            font-size: 11px;
+            margin-left: 8px;
+        }
+
+        /* Модальные окна */
+        .modal {
+            display: none;
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(0,0,0,0.5);
+            z-index: 1000;
+            animation: fadeIn 0.3s;
+        }
+
+        @keyframes fadeIn {
+            from { opacity: 0; }
+            to { opacity: 1; }
+        }
+
+        .modal-content {
+            position: relative;
+            background: white;
+            margin: 50px auto;
+            padding: 0;
+            width: 90%;
+            max-width: 600px;
+            border-radius: 12px;
+            box-shadow: 0 10px 40px rgba(0,0,0,0.2);
+            animation: slideIn 0.3s;
+        }
+
+        @keyframes slideIn {
+            from {
+                transform: translateY(-50px);
+                opacity: 0;
+            }
+            to {
+                transform: translateY(0);
+                opacity: 1;
+            }
+        }
+
+        .modal-header {
+            padding: 20px 25px;
+            background: #f8f9fa;
+            border-bottom: 1px solid #e1e5e9;
+            border-radius: 12px 12px 0 0;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .modal-header h3 {
+            font-size: 20px;
+            color: #2c3e50;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .close {
+            font-size: 28px;
+            cursor: pointer;
+            color: #95a5a6;
+            transition: color 0.2s;
+        }
+
+        .close:hover {
+            color: #e74c3c;
+        }
+
+        .modal-body {
+            padding: 25px;
+            max-height: 70vh;
+            overflow-y: auto;
+        }
+
+        .modal-footer {
+            padding: 20px 25px;
+            background: #f8f9fa;
+            border-top: 1px solid #e1e5e9;
+            border-radius: 0 0 12px 12px;
+            display: flex;
+            justify-content: flex-end;
+            gap: 15px;
+        }
+
+        .form-group {
+            margin-bottom: 20px;
+        }
+
+        .form-group label {
+            display: block;
+            margin-bottom: 8px;
+            font-weight: 500;
+            color: #2c3e50;
+        }
+
+        .form-control {
+            width: 100%;
+            padding: 12px 15px;
+            border: 2px solid #e1e5e9;
+            border-radius: 8px;
+            font-size: 15px;
+            transition: all 0.2s;
+        }
+
+        .form-control:focus {
+            border-color: #3498db;
+            outline: none;
+            box-shadow: 0 0 0 3px rgba(52,152,219,0.1);
+        }
+
+        textarea.form-control {
+            resize: vertical;
+            min-height: 100px;
+        }
+
+        .form-check {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            margin: 15px 0;
+        }
+
+        .form-check input[type="checkbox"] {
+            width: 18px;
+            height: 18px;
+            cursor: pointer;
+        }
+
+        .form-check label {
+            cursor: pointer;
+            color: #2c3e50;
+        }
+
+        .key-display {
+            background: #f0f7ff;
+            border: 2px dashed #3498db;
+            border-radius: 8px;
+            padding: 20px;
+            text-align: center;
+            margin: 20px 0;
+        }
+
+        .key-value {
+            font-family: 'Courier New', monospace;
+            font-size: 20px;
+            background: white;
+            padding: 15px;
+            border-radius: 6px;
+            margin: 15px 0;
+            word-break: break-all;
+            border: 1px solid #e1e5e9;
+        }
+
+        .warning-text {
+            color: #e74c3c;
+            font-size: 13px;
+            margin-top: 10px;
+            display: flex;
+            align-items: center;
+            gap: 5px;
+        }
+
+        .empty-state {
+            text-align: center;
+            padding: 60px 20px;
+            color: #95a5a6;
+            font-size: 16px;
+            background: #f8f9fa;
+            border-radius: 8px;
+        }
+
+        .empty-state i {
+            font-size: 48px;
+            margin-bottom: 15px;
+            color: #bdc3c7;
+        }
+
+        .loading {
+            text-align: center;
+            padding: 40px;
+            color: #7f8c8d;
+        }
+
+        .loading::after {
+            content: '';
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            margin-left: 10px;
+            border: 3px solid #e1e5e9;
+            border-top-color: #3498db;
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+        }
+
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+
+        .alert {
+            padding: 15px 20px;
+            border-radius: 8px;
+            margin-bottom: 20px;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .alert-success {
+            background: #d4edda;
+            color: #155724;
+            border: 1px solid #c3e6cb;
+        }
+
+        .alert-danger {
+            background: #f8d7da;
+            color: #721c24;
+            border: 1px solid #f5c6cb;
+        }
+
+        .alert-warning {
+            background: #fff3cd;
+            color: #856404;
+            border: 1px solid #ffeeba;
+        }
+
+        .tooltip {
+            position: relative;
+            display: inline-block;
+        }
+
+        .tooltip:hover::after {
+            content: attr(data-tooltip);
+            position: absolute;
+            bottom: 100%;
+            left: 50%;
+            transform: translateX(-50%);
+            background: #2c3e50;
+            color: white;
+            padding: 5px 10px;
+            border-radius: 4px;
+            font-size: 11px;
+            white-space: nowrap;
+            z-index: 10;
+        }
+
+        @media (max-width: 768px) {
+            .sidebar {
+                width: 0;
+                display: none;
+            }
+            .main-content {
+                margin-left: 0;
+            }
+            .api-keys-grid {
+                grid-template-columns: 1fr;
+            }
+            .search-box {
+                flex-direction: column;
+            }
+            .search-box select {
+                width: 100%;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="app-container">
+        <!-- Сайдбар -->
+        <div class="sidebar">
+            <div class="logo">CRM <span>API</span></div>
+            <nav class="nav-menu">
+                <a href="/admin" class="nav-item">
+                    <i>📊</i> Дашборд
+                </a>
+                <a href="/admin/profiles" class="nav-item">
+                    <i>👥</i> Профили пользователей
+                </a>
+                <a href="/admin/api-management.html" class="nav-item active">
+                    <i>🔑</i> API управление
+                </a>
+                <a href="/admin/groups.html" class="nav-item">
+                    <i>👥</i> Группы
+                </a>
+                <a href="/" class="nav-item">
+                    <i>🏠</i> На главную
+                </a>
+            </nav>
+        </div>
+
+        <!-- Основной контент -->
+        <div class="main-content">
+            <!-- Шапка -->
+            <div class="header">
+                <div>
+                    <h1>
+                        Управление API ключами и пользователями
+                        <small>интеграция с внешними сервисами</small>
+                    </h1>
+                </div>
+                <div class="header-actions">
+                    <button class="btn-primary" onclick="showCreateKeyModal()">
+                        <i>➕</i> Создать API ключ
+                    </button>
+                    <button class="btn-secondary" onclick="refreshData()">
+                        <i>🔄</i> Обновить
+                    </button>
+                </div>
+            </div>
+
+            <!-- Статистика -->
+            <div class="stats-grid" id="stats-container">
+                <div class="stat-card">
+                    <div class="stat-icon">🔑</div>
+                    <div class="stat-info">
+                        <h3 id="total-keys">0</h3>
+                        <p>Всего API ключей</p>
+                    </div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-icon">✅</div>
+                    <div class="stat-info">
+                        <h3 id="active-keys">0</h3>
+                        <p>Активных ключей</p>
+                    </div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-icon">👤</div>
+                    <div class="stat-info">
+                        <h3 id="total-users">0</h3>
+                        <p>Пользователей</p>
+                    </div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-icon">📊</div>
+                    <div class="stat-info">
+                        <h3 id="users-with-keys">0</h3>
+                        <p>С API ключами</p>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Табы -->
+            <div class="tabs">
+                <button class="tab-btn active" onclick="switchTab('keys')" id="tab-keys-btn">
+                    <i>🔑</i> API Ключи
+                </button>
+                <button class="tab-btn" onclick="switchTab('users')" id="tab-users-btn">
+                    <i>👥</i> Пользователи
+                </button>
+                <button class="tab-btn" onclick="switchTab('docs')" id="tab-docs-btn">
+                    <i>📚</i> Документация
+                </button>
+            </div>
+
+            <!-- Вкладка API ключей -->
+            <div class="tab-content active" id="keys-tab">
+                <div class="search-box">
+                    <input type="text" id="key-search" placeholder="🔍 Поиск по названию, пользователю..." 
+                           oninput="filterApiKeys()">
+                    <select id="key-status-filter" onchange="filterApiKeys()">
+                        <option value="all">Все статусы</option>
+                        <option value="active">Активные</option>
+                        <option value="inactive">Неактивные</option>
+                    </select>
+                </div>
+
+                <div id="api-keys-container">
+                    <div class="loading">Загрузка API ключей...</div>
+                </div>
+            </div>
+
+            <!-- Вкладка пользователей -->
+            <div class="tab-content" id="users-tab">
+                <div class="search-box">
+                    <input type="text" id="user-search" placeholder="🔍 Поиск по имени, логину, email..." 
+                           oninput="filterUsers()">
+                    <select id="user-role-filter" onchange="filterUsers()">
+                        <option value="all">Все роли</option>
+                        <option value="admin">Администраторы</option>
+                        <option value="tasks">Tasks</option>
+                        <option value="teacher">Учителя</option>
+                    </select>
+                </div>
+
+                <div id="users-container">
+                    <div class="loading">Загрузка пользователей...</div>
+                </div>
+            </div>
+
+            <!-- Вкладка документации -->
+            <div class="tab-content" id="docs-tab">
+                <div style="background: white; padding: 30px; border-radius: 12px;">
+                    <h2 style="margin-bottom: 20px; color: #2c3e50;">📚 Документация API</h2>
+                    
+                    <div style="margin-bottom: 30px;">
+                        <h3 style="color: #3498db; margin-bottom: 15px;">Аутентификация</h3>
+                        <div style="background: #f8f9fa; padding: 20px; border-radius: 8px; margin-bottom: 20px;">
+                            <p>Все запросы требуют заголовок <code style="background: #e1e5e9; padding: 3px 8px; border-radius: 4px;">X-API-Key</code> с вашим ключом.</p>
+                        </div>
+                    </div>
+
+                    <div style="margin-bottom: 30px;">
+                        <h3 style="color: #3498db; margin-bottom: 15px;">Эндпоинты</h3>
+                        
+                        <div style="border: 1px solid #e1e5e9; border-radius: 8px; margin-bottom: 15px;">
+                            <div style="background: #f8f9fa; padding: 15px; border-bottom: 1px solid #e1e5e9;">
+                                <code style="font-size: 16px; font-weight: bold;">GET /api/external/tasks</code>
+                            </div>
+                            <div style="padding: 20px;">
+                                <p>Получение списка задач, назначенных пользователю.</p>
+                                <h4 style="margin: 15px 0 10px;">Параметры:</h4>
+                                <ul style="margin-left: 20px;">
+                                    <li><code>status</code> - фильтр по статусу (assigned, in_progress, completed)</li>
+                                    <li><code>limit</code> - количество записей (по умолчанию 50)</li>
+                                    <li><code>offset</code> - смещение для пагинации</li>
+                                </ul>
+                                <h4 style="margin: 15px 0 10px;">Пример ответа:</h4>
+                                <pre style="background: #2c3e50; color: #ecf0f1; padding: 15px; border-radius: 8px; overflow-x: auto;">
+{
+  "success": true,
+  "tasks": [
+    {
+      "id": 123,
+      "title": "Название задачи",
+      "description": "Описание задачи",
+      "created_at": "2024-01-01T10:00:00Z",
+      "due_date": "2024-01-02T19:01:00Z",
+      "task_type": "document",
+      "creator_name": "Иванов И.И.",
+      "files": []
+    }
+  ]
+}</pre>
+                            </div>
+                        </div>
+
+                        <div style="border: 1px solid #e1e5e9; border-radius: 8px; margin-bottom: 15px;">
+                            <div style="background: #f8f9fa; padding: 15px; border-bottom: 1px solid #e1e5e9;">
+                                <code style="font-size: 16px; font-weight: bold;">PUT /api/external/tasks/{taskId}/status</code>
+                            </div>
+                            <div style="padding: 20px;">
+                                <p>Изменение статуса задачи.</p>
+                                <h4 style="margin: 15px 0 10px;">Тело запроса:</h4>
+                                <pre style="background: #2c3e50; color: #ecf0f1; padding: 15px; border-radius: 8px;">
+{
+  "status": "in_progress", // или "completed"
+  "comment": "Комментарий к изменению"
+}</pre>
+                            </div>
+                        </div>
+
+                        <div style="border: 1px solid #e1e5e9; border-radius: 8px; margin-bottom: 15px;">
+                            <div style="background: #f8f9fa; padding: 15px; border-bottom: 1px solid #e1e5e9;">
+                                <code style="font-size: 16px; font-weight: bold;">POST /api/external/tasks/{taskId}/files</code>
+                            </div>
+                            <div style="padding: 20px;">
+                                <p>Загрузка файла к задаче.</p>
+                                <h4 style="margin: 15px 0 10px;">Формат:</h4>
+                                <p>multipart/form-data с полем <code>file</code></p>
+                            </div>
+                        </div>
+
+                        <div style="border: 1px solid #e1e5e9; border-radius: 8px; margin-bottom: 15px;">
+                            <div style="background: #f8f9fa; padding: 15px; border-bottom: 1px solid #e1e5e9;">
+                                <code style="font-size: 16px; font-weight: bold;">GET /api/external/tasks/{taskId}/files/{fileId}/download</code>
+                            </div>
+                            <div style="padding: 20px;">
+                                <p>Скачивание файла.</p>
+                            </div>
+                        </div>
+                    </div>
+
+                    <div style="margin-bottom: 30px;">
+                        <h3 style="color: #3498db; margin-bottom: 15px;">Примеры использования</h3>
+                        
+                        <div style="background: #f8f9fa; padding: 20px; border-radius: 8px;">
+                            <h4 style="margin-bottom: 10px;">cURL:</h4>
+                            <pre style="background: #2c3e50; color: #ecf0f1; padding: 15px; border-radius: 8px; overflow-x: auto;">
+# Получение задач
+curl -H "X-API-Key: ваш_ключ" https://ваш-сервер/api/external/tasks
+
+# Изменение статуса
+curl -X PUT -H "X-API-Key: ваш_ключ" \
+  -H "Content-Type: application/json" \
+  -d '{"status":"in_progress","comment":"Начинаю работу"}' \
+  https://ваш-сервер/api/external/tasks/123/status
+
+# Загрузка файла
+curl -X POST -H "X-API-Key: ваш_ключ" \
+  -F "file=@document.pdf" \
+  https://ваш-сервер/api/external/tasks/123/files</pre>
+
+                            <h4 style="margin: 20px 0 10px;">JavaScript:</h4>
+                            <pre style="background: #2c3e50; color: #ecf0f1; padding: 15px; border-radius: 8px; overflow-x: auto;">
+const API_KEY = 'ваш_ключ';
+
+async function getTasks() {
+  const response = await fetch('/api/external/tasks', {
+    headers: { 'X-API-Key': API_KEY }
+  });
+  return response.json();
+}
+
+async function updateStatus(taskId, status) {
+  const response = await fetch(`/api/external/tasks/${taskId}/status`, {
+    method: 'PUT',
+    headers: {
+      'X-API-Key': API_KEY,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ status, comment: 'Комментарий' })
+  });
+  return response.json();
+}</pre>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Модальное окно создания API ключа -->
+    <div class="modal" id="create-key-modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3><i>🔑</i> Создать новый API ключ</h3>
+                <span class="close" onclick="closeModal('create-key-modal')">&times;</span>
+            </div>
+            <div class="modal-body">
+                <form id="create-key-form">
+                    <div class="form-group">
+                        <label for="key-name">Название ключа *</label>
+                        <input type="text" id="key-name" class="form-control" required
+                               placeholder="Например: Сервис документооборота">
+                        <small style="color: #7f8c8d;">Удобное название для идентификации</small>
+                    </div>
+
+                    <div class="form-group">
+                        <label for="key-user">Пользователь *</label>
+                        <select id="key-user" class="form-control" required>
+                            <option value="">Выберите пользователя...</option>
+                        </select>
+                        <small style="color: #7f8c8d;">Задачи будут назначаться этому пользователю</small>
+                    </div>
+
+                    <div class="form-group">
+                        <label for="key-description">Описание</label>
+                        <textarea id="key-description" class="form-control" rows="3"
+                                  placeholder="Для чего используется этот ключ, какие сервисы будут подключаться..."></textarea>
+                    </div>
+
+                    <div class="form-group">
+                        <label for="key-ips">Разрешенные IP адреса</label>
+                        <input type="text" id="key-ips" class="form-control" 
+                               placeholder="192.168.1.1, 10.0.0.1 (через запятую)">
+                        <small style="color: #7f8c8d;">Оставьте пустым для разрешения всех IP</small>
+                    </div>
+
+                    <div class="form-check">
+                        <input type="checkbox" id="key-active" checked>
+                        <label for="key-active">Активировать сразу после создания</label>
+                    </div>
+
+                    <div class="modal-footer" style="padding: 0; margin-top: 30px;">
+                        <button type="button" class="btn-secondary" onclick="closeModal('create-key-modal')">Отмена</button>
+                        <button type="submit" class="btn-primary">Создать ключ</button>
+                    </div>
+                </form>
+            </div>
+        </div>
+    </div>
+
+    <!-- Модальное окно показа созданного ключа -->
+    <div class="modal" id="show-key-modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3><i>✅</i> API ключ создан</h3>
+                <span class="close" onclick="closeModal('show-key-modal')">&times;</span>
+            </div>
+            <div class="modal-body">
+                <div class="alert alert-warning">
+                    <i>⚠️</i> Сохраните этот ключ в безопасном месте! Он больше не будет показан.
+                </div>
+                
+                <div class="key-display">
+                    <strong>Ваш API ключ:</strong>
+                    <div class="key-value" id="new-api-key"></div>
+                    <button class="btn-primary" onclick="copyApiKey()" style="width: 100%;">
+                        <i>📋</i> Копировать ключ
+                    </button>
+                </div>
+
+                <h4 style="margin: 20px 0 10px;">Быстрый старт:</h4>
+                <pre style="background: #2c3e50; color: #ecf0f1; padding: 15px; border-radius: 8px; overflow-x: auto;">
+# Проверка подключения
+curl -H "X-API-Key: <ваш_ключ>" https://ваш-сервер/api/external/tasks</pre>
+
+                <div class="form-group" style="margin-top: 20px;">
+                    <label>Информация о пользователе:</label>
+                    <div id="key-user-info" style="background: #f8f9fa; padding: 10px; border-radius: 6px;"></div>
+                </div>
+            </div>
+            <div class="modal-footer">
+                <button class="btn-primary" onclick="closeModal('show-key-modal')">Готово</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- Модальное окно редактирования пользователя -->
+    <div class="modal" id="edit-user-modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3><i>👤</i> Редактирование пользователя</h3>
+                <span class="close" onclick="closeModal('edit-user-modal')">&times;</span>
+            </div>
+            <div class="modal-body">
+                <form id="edit-user-form">
+                    <input type="hidden" id="edit-user-id">
+                    
+                    <div class="form-group">
+                        <label>Логин</label>
+                        <input type="text" id="edit-user-login" class="form-control" readonly>
+                    </div>
+
+                    <div class="form-group">
+                        <label>Имя</label>
+                        <input type="text" id="edit-user-name" class="form-control" required>
+                    </div>
+
+                    <div class="form-group">
+                        <label>Email</label>
+                        <input type="email" id="edit-user-email" class="form-control">
+                    </div>
+
+                    <div class="form-group">
+                        <label>Роль</label>
+                        <select id="edit-user-role" class="form-control">
+                            <option value="teacher">Учитель</option>
+                            <option value="tasks">Tasks</option>
+                            <option value="admin">Администратор</option>
+                        </select>
+                    </div>
+
+                    <div class="form-group">
+                        <label>Тип авторизации</label>
+                        <select id="edit-user-auth-type" class="form-control">
+                            <option value="local">Локальный</option>
+                            <option value="ldap">LDAP</option>
+                        </select>
+                    </div>
+
+                    <div class="form-check">
+                        <input type="checkbox" id="edit-user-active" checked>
+                        <label for="edit-user-active">Активен</label>
+                    </div>
+
+                    <div class="modal-footer" style="padding: 0; margin-top: 30px;">
+                        <button type="button" class="btn-secondary" onclick="closeModal('edit-user-modal')">Отмена</button>
+                        <button type="submit" class="btn-primary">Сохранить</button>
+                    </div>
+                </form>
+            </div>
+        </div>
+    </div>
+
+    <!-- Модальное окно просмотра ключей пользователя -->
+    <div class="modal" id="user-keys-modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3><i>🔑</i> API ключи пользователя</h3>
+                <span class="close" onclick="closeModal('user-keys-modal')">&times;</span>
+            </div>
+            <div class="modal-body">
+                <div id="user-keys-list"></div>
+            </div>
+            <div class="modal-footer">
+                <button class="btn-secondary" onclick="closeModal('user-keys-modal')">Закрыть</button>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let currentUser = null;
+        let apiKeys = [];
+        let users = [];
+        let filteredApiKeys = [];
+        let filteredUsers = [];
+
+        // Инициализация
+        document.addEventListener('DOMContentLoaded', async () => {
+            try {
+                // Проверяем авторизацию
+                const userResponse = await fetch('/api/user');
+                const userData = await userResponse.json();
+                
+                if (!userData.user) {
+                    window.location.href = '/';
+                    return;
+                }
+
+                currentUser = userData.user;
+                
+                if (currentUser.role !== 'admin') {
+                    alert('Доступ запрещен');
+                    window.location.href = '/';
+                    return;
+                }
+
+                // Загружаем данные
+                await Promise.all([loadApiKeys(), loadUsers()]);
+                
+            } catch (error) {
+                console.error('Ошибка инициализации:', error);
+                window.location.href = '/';
+            }
+        });
+
+        // Загрузка API ключей
+        async function loadApiKeys() {
+            try {
+                const response = await fetch('/api/api-keys');
+                apiKeys = await response.json();
+                filteredApiKeys = [...apiKeys];
+                renderApiKeys();
+                updateStats();
+            } catch (error) {
+                console.error('Ошибка загрузки ключей:', error);
+                showError('api-keys-container', 'Ошибка загрузки API ключей');
+            }
+        }
+
+        // Загрузка пользователей
+        async function loadUsers() {
+            try {
+                const response = await fetch('/api/users/all');
+                users = await response.json();
+                filteredUsers = [...users];
+                renderUsers();
+                updateStats();
+                
+                // Заполняем select пользователей в модальном окне
+                const select = document.getElementById('key-user');
+                if (select) {
+                    select.innerHTML = '<option value="">Выберите пользователя...</option>' + 
+                        users.map(user => `<option value="${user.id}">${user.name} (${user.login})</option>`).join('');
+                }
+            } catch (error) {
+                console.error('Ошибка загрузки пользователей:', error);
+                showError('users-container', 'Ошибка загрузки пользователей');
+            }
+        }
+
+        // Обновление статистики
+        function updateStats() {
+            const totalKeys = apiKeys.length;
+            const activeKeys = apiKeys.filter(k => k.is_active).length;
+            const totalUsers = users.length;
+            const usersWithKeys = new Set(apiKeys.map(k => k.user_id)).size;
+
+            document.getElementById('total-keys').textContent = totalKeys;
+            document.getElementById('active-keys').textContent = activeKeys;
+            document.getElementById('total-users').textContent = totalUsers;
+            document.getElementById('users-with-keys').textContent = usersWithKeys;
+        }
+
+        // Отображение API ключей
+        function renderApiKeys() {
+            const container = document.getElementById('api-keys-container');
+            
+            if (filteredApiKeys.length === 0) {
+                container.innerHTML = `
+                    <div class="empty-state">
+                        <i>🔑</i>
+                        <h3>Нет API ключей</h3>
+                        <p>Создайте первый API ключ для интеграции с внешними сервисами</p>
+                        <button class="btn-primary" onclick="showCreateKeyModal()" style="margin-top: 20px;">
+                            + Создать ключ
+                        </button>
+                    </div>
+                `;
+                return;
+            }
+
+            container.innerHTML = `
+                <div class="api-keys-grid">
+                    ${filteredApiKeys.map(key => renderApiKeyCard(key)).join('')}
+                </div>
+            `;
+        }
+
+        // Карточка API ключа
+        function renderApiKeyCard(key) {
+            const user = users.find(u => u.id === key.user_id) || {};
+            
+            return `
+                <div class="api-key-card" data-key-id="${key.id}">
+                    <div class="api-key-header">
+                        <div class="api-key-name">
+                            <i>🔑</i>
+                            ${escapeHtml(key.name)}
+                            <span class="api-key-badge ${key.is_active ? 'badge-active' : 'badge-inactive'}">
+                                ${key.is_active ? 'Активен' : 'Неактивен'}
+                            </span>
+                        </div>
+                    </div>
+                    
+                    <div class="api-key-value">
+                        <span>${key.key}</span>
+                        <button class="copy-btn tooltip" data-tooltip="Копировать" onclick="copyText('${key.key}', this)">
+                            📋
+                        </button>
+                    </div>
+                    
+                    <div class="api-key-meta">
+                        <div class="meta-row">
+                            <span class="meta-label">Пользователь:</span>
+                            <span class="meta-value">
+                                <strong>${escapeHtml(user.name || 'Неизвестно')}</strong> 
+                                (${escapeHtml(user.login || '')})
+                            </span>
+                        </div>
+                        ${key.description ? `
+                        <div class="meta-row">
+                            <span class="meta-label">Описание:</span>
+                            <span class="meta-value">${escapeHtml(key.description)}</span>
+                        </div>
+                        ` : ''}
+                        <div class="meta-row">
+                            <span class="meta-label">Создан:</span>
+                            <span class="meta-value">${formatDate(key.created_at)}</span>
+                        </div>
+                        ${key.last_used_at ? `
+                        <div class="meta-row">
+                            <span class="meta-label">Последнее использование:</span>
+                            <span class="meta-value">${formatDate(key.last_used_at)}</span>
+                        </div>
+                        ` : ''}
+                        ${key.allowed_ips ? `
+                        <div class="meta-row">
+                            <span class="meta-label">Разрешенные IP:</span>
+                            <span class="meta-value">${JSON.parse(key.allowed_ips).join(', ')}</span>
+                        </div>
+                        ` : ''}
+                    </div>
+                    
+                    <div class="api-key-actions">
+                        <button class="btn-warning btn-sm" onclick="toggleKey(${key.id}, ${!key.is_active})">
+                            ${key.is_active ? 'Деактивировать' : 'Активировать'}
+                        </button>
+                        <button class="btn-danger btn-sm" onclick="deleteKey(${key.id})">
+                            Удалить
+                        </button>
+                    </div>
+                </div>
+            `;
+        }
+
+        // Отображение пользователей
+        function renderUsers() {
+            const container = document.getElementById('users-container');
+            
+            if (filteredUsers.length === 0) {
+                container.innerHTML = `
+                    <div class="empty-state">
+                        <i>👥</i>
+                        <h3>Нет пользователей</h3>
+                    </div>
+                `;
+                return;
+            }
+
+            container.innerHTML = `
+                <table class="users-table">
+                    <thead>
+                        <tr>
+                            <th>Пользователь</th>
+                            <th>Роль</th>
+                            <th>Тип</th>
+                            <th>API ключи</th>
+                            <th>Дата регистрации</th>
+                            <th>Действия</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        ${filteredUsers.map(user => renderUserRow(user)).join('')}
+                    </tbody>
+                </table>
+            `;
+        }
+
+        // Строка пользователя
+        function renderUserRow(user) {
+            const userKeys = apiKeys.filter(k => k.user_id === user.id);
+            const activeKeysCount = userKeys.filter(k => k.is_active).length;
+            
+            return `
+                <tr>
+                    <td>
+                        <div class="user-info">
+                            <div class="user-avatar">${(user.name || '?').charAt(0)}</div>
+                            <div class="user-details">
+                                <h4>${escapeHtml(user.name || 'Без имени')}</h4>
+                                <small>${escapeHtml(user.login || '')} • ${escapeHtml(user.email || '')}</small>
+                            </div>
+                        </div>
+                    </td>
+                    <td>
+                        <span class="role-badge ${user.role === 'admin' ? 'role-admin' : user.role === 'tasks' ? 'role-tasks' : ''}">
+                            ${user.role || 'teacher'}
+                        </span>
+                    </td>
+                    <td>${user.auth_type || 'local'}</td>
+                    <td>
+                        ${userKeys.length > 0 ? `
+                            <span class="role-badge" style="background: #3498db; color: white; cursor: pointer;" 
+                                  onclick="showUserKeys(${user.id})">
+                                ${userKeys.length} ключей
+                                ${activeKeysCount > 0 ? `(${activeKeysCount} активных)` : ''}
+                            </span>
+                        ` : '<span class="role-badge">Нет ключей</span>'}
+                    </td>
+                    <td>${formatDate(user.created_at)}</td>
+                    <td>
+                        <button class="btn-sm" style="background: #3498db; color: white; border: none; padding: 5px 10px; border-radius: 4px; cursor: pointer;"
+                                onclick="editUser(${user.id})">
+                            ✏️ Ред.
+                        </button>
+                    </td>
+                </tr>
+            `;
+        }
+
+        // Фильтрация API ключей
+        function filterApiKeys() {
+            const search = document.getElementById('key-search').value.toLowerCase();
+            const statusFilter = document.getElementById('key-status-filter').value;
+            
+            filteredApiKeys = apiKeys.filter(key => {
+                const user = users.find(u => u.id === key.user_id) || {};
+                const matchesSearch = key.name.toLowerCase().includes(search) ||
+                                     (user.name || '').toLowerCase().includes(search) ||
+                                     (user.login || '').toLowerCase().includes(search);
+                
+                const matchesStatus = statusFilter === 'all' ||
+                                     (statusFilter === 'active' && key.is_active) ||
+                                     (statusFilter === 'inactive' && !key.is_active);
+                
+                return matchesSearch && matchesStatus;
+            });
+            
+            renderApiKeys();
+        }
+
+        // Фильтрация пользователей
+        function filterUsers() {
+            const search = document.getElementById('user-search').value.toLowerCase();
+            const roleFilter = document.getElementById('user-role-filter').value;
+            
+            filteredUsers = users.filter(user => {
+                const matchesSearch = (user.name || '').toLowerCase().includes(search) ||
+                                     (user.login || '').toLowerCase().includes(search) ||
+                                     (user.email || '').toLowerCase().includes(search);
+                
+                const matchesRole = roleFilter === 'all' || user.role === roleFilter;
+                
+                return matchesSearch && matchesRole;
+            });
+            
+            renderUsers();
+        }
+
+        // Переключение статуса ключа
+        async function toggleKey(id, isActive) {
+            try {
+                const response = await fetch(`/api/api-keys/${id}/toggle`, {
+                    method: 'PUT',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ is_active: isActive })
+                });
+
+                if (response.ok) {
+                    await loadApiKeys();
+                } else {
+                    const error = await response.json();
+                    alert(`Ошибка: ${error.error}`);
+                }
+            } catch (error) {
+                console.error('Ошибка:', error);
+                alert('Сетевая ошибка');
+            }
+        }
+
+        // Удаление ключа
+        async function deleteKey(id) {
+            if (!confirm('Вы уверены, что хотите удалить этот ключ? Это действие нельзя отменить.')) {
+                return;
+            }
+
+            try {
+                const response = await fetch(`/api/api-keys/${id}`, {
+                    method: 'DELETE'
+                });
+
+                if (response.ok) {
+                    await loadApiKeys();
+                } else {
+                    const error = await response.json();
+                    alert(`Ошибка: ${error.error}`);
+                }
+            } catch (error) {
+                console.error('Ошибка:', error);
+                alert('Сетевая ошибка');
+            }
+        }
+
+        // Показать модальное окно создания ключа
+        function showCreateKeyModal() {
+            document.getElementById('create-key-modal').style.display = 'block';
+        }
+
+        // Создание ключа
+        document.getElementById('create-key-form').addEventListener('submit', async (e) => {
+            e.preventDefault();
+
+            const name = document.getElementById('key-name').value;
+            const userId = document.getElementById('key-user').value;
+            const description = document.getElementById('key-description').value;
+            const ips = document.getElementById('key-ips').value;
+            const isActive = document.getElementById('key-active').checked;
+
+            if (!name || !userId) {
+                alert('Заполните обязательные поля');
+                return;
+            }
+
+            const submitBtn = e.target.querySelector('button[type="submit"]');
+            submitBtn.disabled = true;
+            submitBtn.innerHTML = '⏳ Создание...';
+
+            try {
+                const response = await fetch('/api/api-keys', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        name,
+                        user_id: userId,
+                        description,
+                        allowed_ips: ips
+                    })
+                });
+
+                const data = await response.json();
+
+                if (response.ok) {
+                    closeModal('create-key-modal');
+                    document.getElementById('new-api-key').textContent = data.key;
+                    
+                    // Показываем информацию о пользователе
+                    const user = users.find(u => u.id === parseInt(userId));
+                    document.getElementById('key-user-info').innerHTML = `
+                        <strong>${user.name}</strong> (${user.login})<br>
+                        Роль: ${user.role}<br>
+                        Email: ${user.email || 'не указан'}
+                    `;
+                    
+                    document.getElementById('show-key-modal').style.display = 'block';
+                    await loadApiKeys();
+                } else {
+                    alert(`Ошибка: ${data.error}`);
+                }
+            } catch (error) {
+                console.error('Ошибка:', error);
+                alert('Сетевая ошибка');
+            } finally {
+                submitBtn.disabled = false;
+                submitBtn.innerHTML = 'Создать ключ';
+            }
+        });
+
+        // Редактирование пользователя
+        async function editUser(userId) {
+            const user = users.find(u => u.id === userId);
+            if (!user) return;
+
+            document.getElementById('edit-user-id').value = user.id;
+            document.getElementById('edit-user-login').value = user.login || '';
+            document.getElementById('edit-user-name').value = user.name || '';
+            document.getElementById('edit-user-email').value = user.email || '';
+            document.getElementById('edit-user-role').value = user.role || 'teacher';
+            document.getElementById('edit-user-auth-type').value = user.auth_type || 'local';
+            document.getElementById('edit-user-active').checked = user.is_active !== false;
+
+            document.getElementById('edit-user-modal').style.display = 'block';
+        }
+
+        // Сохранение пользователя
+        document.getElementById('edit-user-form').addEventListener('submit', async (e) => {
+            e.preventDefault();
+
+            const userId = document.getElementById('edit-user-id').value;
+            const userData = {
+                name: document.getElementById('edit-user-name').value,
+                email: document.getElementById('edit-user-email').value,
+                role: document.getElementById('edit-user-role').value,
+                auth_type: document.getElementById('edit-user-auth-type').value,
+                is_active: document.getElementById('edit-user-active').checked
+            };
+
+            try {
+                const response = await fetch(`/api/users/${userId}`, {
+                    method: 'PUT',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify(userData)
+                });
+
+                if (response.ok) {
+                    closeModal('edit-user-modal');
+                    await loadUsers();
+                } else {
+                    const error = await response.json();
+                    alert(`Ошибка: ${error.error}`);
+                }
+            } catch (error) {
+                console.error('Ошибка:', error);
+                alert('Сетевая ошибка');
+            }
+        });
+
+        // Показать ключи пользователя
+        function showUserKeys(userId) {
+            const userKeys = apiKeys.filter(k => k.user_id === userId);
+            const user = users.find(u => u.id === userId);
+            
+            const container = document.getElementById('user-keys-list');
+            
+            if (userKeys.length === 0) {
+                container.innerHTML = '<div class="empty-state">У пользователя нет API ключей</div>';
+            } else {
+                container.innerHTML = `
+                    <h4 style="margin-bottom: 15px;">${user.name}</h4>
+                    <div style="display: flex; flex-direction: column; gap: 10px;">
+                        ${userKeys.map(key => `
+                            <div style="background: #f8f9fa; padding: 10px; border-radius: 6px;">
+                                <strong>${key.name}</strong>
+                                <span class="api-key-badge ${key.is_active ? 'badge-active' : 'badge-inactive'}" 
+                                      style="margin-left: 10px;">
+                                    ${key.is_active ? 'Активен' : 'Неактивен'}
+                                </span>
+                                <div style="font-family: monospace; margin: 5px 0;">${key.key}</div>
+                                <small>${key.description || ''}</small>
+                            </div>
+                        `).join('')}
+                    </div>
+                `;
+            }
+            
+            document.getElementById('user-keys-modal').style.display = 'block';
+        }
+
+        // Копирование текста
+        function copyText(text, btn) {
+            navigator.clipboard.writeText(text).then(() => {
+                const originalText = btn.innerHTML;
+                btn.innerHTML = '✅';
+                btn.classList.add('copy-success');
+                
+                setTimeout(() => {
+                    btn.innerHTML = originalText;
+                    btn.classList.remove('copy-success');
+                }, 2000);
+            });
+        }
+
+        // Копирование API ключа
+        function copyApiKey() {
+            const key = document.getElementById('new-api-key').textContent;
+            navigator.clipboard.writeText(key).then(() => {
+                alert('Ключ скопирован в буфер обмена');
+            });
+        }
+
+        // Переключение вкладок
+        function switchTab(tabName) {
+            document.querySelectorAll('.tab-btn').forEach(btn => btn.classList.remove('active'));
+            document.querySelectorAll('.tab-content').forEach(content => content.classList.remove('active'));
+            
+            document.getElementById(`tab-${tabName}-btn`).classList.add('active');
+            document.getElementById(`${tabName}-tab`).classList.add('active');
+        }
+
+        // Обновление данных
+        function refreshData() {
+            Promise.all([loadApiKeys(), loadUsers()]);
+        }
+
+        // Закрытие модального окна
+        function closeModal(modalId) {
+            document.getElementById(modalId).style.display = 'none';
+            if (modalId === 'create-key-modal') {
+                document.getElementById('create-key-form').reset();
+            }
+        }
+
+        // Показать ошибку
+        function showError(containerId, message) {
+            const container = document.getElementById(containerId);
+            if (container) {
+                container.innerHTML = `<div class="alert alert-danger">${message}</div>`;
+            }
+        }
+
+        // Форматирование даты
+        function formatDate(dateString) {
+            if (!dateString) return 'Никогда';
+            return new Date(dateString).toLocaleString('ru-RU', {
+                day: '2-digit',
+                month: '2-digit',
+                year: 'numeric',
+                hour: '2-digit',
+                minute: '2-digit'
+            });
+        }
+
+        // Экранирование HTML
+        function escapeHtml(text) {
+            if (!text) return '';
+            return String(text)
+                .replace(/&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;')
+                .replace(/'/g, '&#039;');
+        }
+
+        // Закрытие модальных окон по клику вне их
+        window.onclick = function(event) {
+            if (event.target.classList.contains('modal')) {
+                event.target.style.display = 'none';
+            }
+        }
+    </script>
+</body>
+</html>
\ No newline at end of file
diff --git a/public/upravlenie.html b/public/upravlenie.html
deleted file mode 100644
index 0116d7e..0000000
--- a/public/upravlenie.html
+++ /dev/null
@@ -1,1058 +0,0 @@
-<!DOCTYPE html>
-<html lang="ru">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Управление межсервисным взаимодействием</title>
-    <style>
-        * {
-            box-sizing: border-box;
-            margin: 0;
-            padding: 0;
-        }
-
-        body {
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
-            background: #f0f2f5;
-            margin: 0;
-            padding: 20px;
-        }
-
-        .header {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            margin-bottom: 20px;
-            background: white;
-            padding: 15px 20px;
-            border-radius: 8px;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        }
-
-        .header h1 {
-            margin: 0;
-            font-size: 24px;
-            color: #1a1a1a;
-        }
-
-        .back-button {
-            background: #6c757d;
-            color: white;
-            border: none;
-            padding: 8px 16px;
-            border-radius: 4px;
-            cursor: pointer;
-            font-size: 14px;
-            font-weight: 500;
-            text-decoration: none;
-            display: inline-flex;
-            align-items: center;
-            gap: 5px;
-        }
-
-        .back-button:hover {
-            background: #5a6268;
-        }
-
-        .container {
-            max-width: 1400px;
-            margin: 0 auto;
-        }
-
-        .tabs {
-            display: flex;
-            gap: 5px;
-            background: white;
-            padding: 10px;
-            border-radius: 8px 8px 0 0;
-            border-bottom: 1px solid #dee2e6;
-        }
-
-        .tab {
-            padding: 10px 20px;
-            background: none;
-            border: none;
-            cursor: pointer;
-            font-size: 14px;
-            font-weight: 500;
-            color: #6c757d;
-            border-radius: 4px 4px 0 0;
-        }
-
-        .tab:hover {
-            background: #f8f9fa;
-            color: #495057;
-        }
-
-        .tab.active {
-            color: #007bff;
-            border-bottom: 2px solid #007bff;
-            background: #f8f9fa;
-        }
-
-        .tab-content {
-            background: white;
-            padding: 20px;
-            border-radius: 0 0 8px 8px;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-            min-height: 500px;
-        }
-
-        .action-bar {
-            margin-bottom: 20px;
-            display: flex;
-            gap: 10px;
-            flex-wrap: wrap;
-        }
-
-        .btn {
-            padding: 8px 16px;
-            border: none;
-            border-radius: 4px;
-            cursor: pointer;
-            font-size: 14px;
-            font-weight: 500;
-            display: inline-flex;
-            align-items: center;
-            gap: 5px;
-        }
-
-        .btn-primary {
-            background: #007bff;
-            color: white;
-        }
-
-        .btn-primary:hover {
-            background: #0069d9;
-        }
-
-        .btn-success {
-            background: #28a745;
-            color: white;
-        }
-
-        .btn-success:hover {
-            background: #218838;
-        }
-
-        .btn-danger {
-            background: #dc3545;
-            color: white;
-        }
-
-        .btn-danger:hover {
-            background: #c82333;
-        }
-
-        .btn-warning {
-            background: #ffc107;
-            color: #212529;
-        }
-
-        .btn-warning:hover {
-            background: #e0a800;
-        }
-
-        .btn-secondary {
-            background: #6c757d;
-            color: white;
-        }
-
-        .btn-secondary:hover {
-            background: #5a6268;
-        }
-
-        table {
-            width: 100%;
-            border-collapse: collapse;
-            margin-top: 10px;
-            font-size: 14px;
-        }
-
-        th {
-            background: #f8f9fa;
-            padding: 12px 8px;
-            text-align: left;
-            font-weight: 600;
-            color: #495057;
-            border-bottom: 2px solid #dee2e6;
-        }
-
-        td {
-            padding: 10px 8px;
-            border-bottom: 1px solid #e9ecef;
-            vertical-align: middle;
-        }
-
-        tr:hover {
-            background: #f8f9fa;
-        }
-
-        .badge {
-            display: inline-block;
-            padding: 3px 8px;
-            border-radius: 12px;
-            font-size: 12px;
-            font-weight: 500;
-        }
-
-        .badge-organizer {
-            background: #cce5ff;
-            color: #004085;
-        }
-
-        .badge-executor {
-            background: #d4edda;
-            color: #155724;
-        }
-
-        .badge-success {
-            background: #d4edda;
-            color: #155724;
-        }
-
-        .badge-error {
-            background: #f8d7da;
-            color: #721c24;
-        }
-
-        .badge-warning {
-            background: #fff3cd;
-            color: #856404;
-        }
-
-        .badge-info {
-            background: #d1ecf1;
-            color: #0c5460;
-        }
-
-        .connection-status {
-            font-size: 12px;
-            margin-top: 5px;
-        }
-
-        .status-success {
-            color: #28a745;
-        }
-
-        .status-error {
-            color: #dc3545;
-        }
-
-        .status-warning {
-            color: #ffc107;
-        }
-
-        .actions {
-            display: flex;
-            gap: 5px;
-            flex-wrap: wrap;
-        }
-
-        .action-btn {
-            padding: 4px 8px;
-            font-size: 12px;
-            border: none;
-            border-radius: 3px;
-            cursor: pointer;
-            background: #f8f9fa;
-            color: #495057;
-        }
-
-        .action-btn:hover {
-            background: #e9ecef;
-        }
-
-        .action-btn-edit {
-            background: #e7f3ff;
-            color: #007bff;
-        }
-
-        .action-btn-sync {
-            background: #e8f5e9;
-            color: #28a745;
-        }
-
-        .action-btn-check {
-            background: #fff3e0;
-            color: #fd7e14;
-        }
-
-        .action-btn-delete {
-            background: #fee;
-            color: #dc3545;
-        }
-
-        .stats-grid {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
-            gap: 20px;
-            margin-bottom: 30px;
-        }
-
-        .stat-card {
-            background: #f8f9fa;
-            padding: 20px;
-            border-radius: 8px;
-            text-align: center;
-        }
-
-        .stat-value {
-            font-size: 36px;
-            font-weight: bold;
-            color: #007bff;
-            margin-bottom: 5px;
-        }
-
-        .stat-label {
-            font-size: 14px;
-            color: #6c757d;
-        }
-
-        .logs-list {
-            max-height: 400px;
-            overflow-y: auto;
-            border: 1px solid #dee2e6;
-            border-radius: 4px;
-        }
-
-        .log-item {
-            padding: 10px;
-            border-bottom: 1px solid #e9ecef;
-            font-size: 13px;
-        }
-
-        .log-item:last-child {
-            border-bottom: none;
-        }
-
-        .log-service {
-            font-weight: 600;
-            color: #495057;
-        }
-
-        .log-time {
-            color: #6c757d;
-            font-size: 11px;
-            margin-left: 10px;
-        }
-
-        .log-status {
-            display: inline-block;
-            width: 8px;
-            height: 8px;
-            border-radius: 50%;
-            margin-right: 8px;
-        }
-
-        .modal {
-            display: none;
-            position: fixed;
-            z-index: 1000;
-            left: 0;
-            top: 0;
-            width: 100%;
-            height: 100%;
-            background-color: rgba(0,0,0,0.5);
-        }
-
-        .modal-content {
-            background-color: white;
-            margin: 2% auto;
-            padding: 20px;
-            border-radius: 8px;
-            width: 450px;
-            max-width: 95%;
-            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
-        }
-
-        .modal-header {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            margin-bottom: 15px;
-        }
-
-        .modal-header h3 {
-            margin: 0;
-            font-size: 18px;
-        }
-
-        .close {
-            font-size: 24px;
-            cursor: pointer;
-            color: #aaa;
-        }
-
-        .close:hover {
-            color: #333;
-        }
-
-        .form-group {
-            margin-bottom: 12px;
-        }
-
-        .form-group label {
-            display: block;
-            font-size: 12px;
-            font-weight: 500;
-            color: #495057;
-            margin-bottom: 3px;
-        }
-
-        .form-group input,
-        .form-group select {
-            width: 100%;
-            padding: 6px 8px;
-            border: 1px solid #ced4da;
-            border-radius: 4px;
-            font-size: 13px;
-        }
-
-        .form-group input:focus,
-        .form-group select:focus {
-            outline: none;
-            border-color: #80bdff;
-            box-shadow: 0 0 0 0.2rem rgba(0,123,255,0.25);
-        }
-
-        .checkbox-group {
-            display: flex;
-            align-items: center;
-            gap: 8px;
-        }
-
-        .checkbox-group input {
-            width: auto;
-        }
-
-        .form-row {
-            display: flex;
-            gap: 8px;
-        }
-
-        .form-row .form-group {
-            flex: 1;
-        }
-
-        .modal-footer {
-            display: flex;
-            gap: 10px;
-            margin-top: 20px;
-        }
-
-        .loading {
-            text-align: center;
-            padding: 40px;
-            color: #6c757d;
-        }
-
-        .loading::after {
-            content: '';
-            display: inline-block;
-            width: 20px;
-            height: 20px;
-            border: 2px solid #f3f3f3;
-            border-top: 2px solid #3498db;
-            border-radius: 50%;
-            animation: spin 1s linear infinite;
-            margin-left: 10px;
-        }
-
-        @keyframes spin {
-            0% { transform: rotate(0deg); }
-            100% { transform: rotate(360deg); }
-        }
-
-        .error-message {
-            color: #dc3545;
-            font-size: 12px;
-            margin-top: 4px;
-        }
-
-        .success-message {
-            color: #28a745;
-            font-size: 12px;
-            margin-top: 4px;
-        }
-
-        .filter-bar {
-            display: flex;
-            gap: 10px;
-            margin-bottom: 15px;
-            flex-wrap: wrap;
-        }
-
-        .filter-select {
-            padding: 6px 10px;
-            border: 1px solid #ced4da;
-            border-radius: 4px;
-            font-size: 13px;
-            min-width: 150px;
-        }
-    </style>
-</head>
-<body>
-    <div class="header">
-        <h1>Управление межсервисным взаимодействием</h1>
-        <a href="/" class="back-button">← Вернуться на главную</a>
-    </div>
-
-    <div class="container">
-        <div class="tabs">
-            <button class="tab active" onclick="openTab('connections')">Подключения</button>
-            <button class="tab" onclick="openTab('stats')">Статистика</button>
-            <button class="tab" onclick="openTab('logs')">Журнал синхронизации</button>
-        </div>
-
-        <div id="connections-tab" class="tab-content">
-            <div class="action-bar">
-                <button class="btn btn-primary" onclick="showAddModal()">
-                    ➕ Добавить подключение
-                </button>
-                <button class="btn btn-secondary" onclick="refreshConnections()">
-                    🔄 Обновить список
-                </button>
-            </div>
-
-            <div class="filter-bar">
-                <select id="typeFilter" class="filter-select" onchange="applyFilters()">
-                    <option value="">Все типы</option>
-                    <option value="organizer">Организаторы</option>
-                    <option value="executor">Исполнители</option>
-                </select>
-                <select id="statusFilter" class="filter-select" onchange="applyFilters()">
-                    <option value="">Все статусы</option>
-                    <option value="active">Активные</option>
-                    <option value="inactive">Неактивные</option>
-                </select>
-            </div>
-
-            <table id="connectionsTable">
-                <thead>
-                    <tr>
-                        <th>ID</th>
-                        <th>Service ID</th>
-                        <th>Название</th>
-                        <th>Тип</th>
-                        <th>Логин API</th>
-                        <th>Локальный пользователь</th>
-                        <th>Статус</th>
-                        <th>Последняя синхр.</th>
-                        <th>Связь</th>
-                        <th>Действия</th>
-                    </tr>
-                </thead>
-                <tbody id="connectionsList">
-                    <tr>
-                        <td colspan="10" class="loading">Загрузка...</td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-
-        <div id="stats-tab" class="tab-content" style="display: none;">
-            <div class="stats-grid">
-                <div class="stat-card">
-                    <div class="stat-value" id="totalConnections">0</div>
-                    <div class="stat-label">Всего подключений</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-value" id="totalOrganizers">0</div>
-                    <div class="stat-label">Организаторов</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-value" id="totalExecutors">0</div>
-                    <div class="stat-label">Исполнителей</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-value" id="successSync">0</div>
-                    <div class="stat-label">Успешных синхр.</div>
-                </div>
-            </div>
-
-            <h3>Последние синхронизации</h3>
-            <table>
-                <thead>
-                    <tr>
-                        <th>Сервис</th>
-                        <th>Время</th>
-                        <th>Статус</th>
-                    </tr>
-                </thead>
-                <tbody id="lastSyncsList">
-                    <tr>
-                        <td colspan="3" class="loading">Загрузка...</td>
-                    </tr>
-                </tbody>
-            </table>
-
-            <h3 style="margin-top: 30px;">Ошибки</h3>
-            <table>
-                <thead>
-                    <tr>
-                        <th>Сервис</th>
-                        <th>Ошибка</th>
-                        <th>Время</th>
-                    </tr>
-                </thead>
-                <tbody id="errorsList">
-                    <tr>
-                        <td colspan="3">Нет ошибок</td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-
-        <div id="logs-tab" class="tab-content" style="display: none;">
-            <div class="action-bar">
-                <button class="btn btn-secondary" onclick="refreshLogs()">
-                    🔄 Обновить
-                </button>
-                <button class="btn btn-warning" onclick="clearLogs()">
-                    🗑️ Очистить
-                </button>
-            </div>
-            <div id="logsList" class="logs-list">
-                <div class="loading">Загрузка...</div>
-            </div>
-        </div>
-    </div>
-
-    <div id="connectionModal" class="modal">
-        <div class="modal-content">
-            <div class="modal-header">
-                <h3 id="modalTitle">Добавление подключения</h3>
-                <span class="close" onclick="closeModal()">&times;</span>
-            </div>
-            
-            <form id="connectionForm">
-                <input type="hidden" id="editId">
-                
-                <div class="form-row">
-                    <div class="form-group">
-                        <label>Service ID (1-4062):</label>
-                        <input type="number" id="service_id" min="1" max="4062" required>
-                    </div>
-                    <div class="form-group">
-                        <label>Название:</label>
-                        <input type="text" id="service_name" required>
-                    </div>
-                </div>
-
-                <div class="form-row">
-                    <div class="form-group">
-                        <label>Тип:</label>
-                        <select id="service_type" required>
-                            <option value="organizer">Организатор</option>
-                            <option value="executor">Исполнитель</option>
-                        </select>
-                    </div>
-                    <div class="form-group">
-                        <label>Логин API:</label>
-                        <input type="text" id="login" required>
-                    </div>
-                </div>
-
-                <div class="form-row">
-                    <div class="form-group">
-                        <label>Пароль API:</label>
-                        <input type="password" id="password" required>
-                    </div>
-                    <div class="form-group">
-                        <label>Интервал (мин):</label>
-                        <input type="number" id="sync_interval" min="1" value="60">
-                    </div>
-                </div>
-
-                <div id="apiUrlGroup" class="form-group">
-                    <label>API URL организатора:</label>
-                    <input type="url" id="api_url" placeholder="https://example.com">
-                </div>
-
-                <div class="form-row">
-                    <div class="form-group">
-                        <label>ID пользователя:</label>
-                        <input type="number" id="local_user_id">
-                    </div>
-                    <div class="form-group">
-                        <label>Логин пользователя:</label>
-                        <input type="text" id="local_user_login">
-                    </div>
-                </div>
-
-                <div class="form-row">
-                    <div class="form-group">
-                        <label>Направление:</label>
-                        <select id="sync_direction">
-                            <option value="outgoing">Отправка статусов</option>
-                            <option value="incoming">Получение задач</option>
-                            <option value="both">Двусторонняя</option>
-                        </select>
-                    </div>
-                    <div class="form-group checkbox-group">
-                        <input type="checkbox" id="sync_enabled" checked>
-                        <label>Активно</label>
-                    </div>
-                </div>
-
-                <div class="modal-footer">
-                    <button type="submit" class="btn btn-success" style="flex: 2;">Сохранить</button>
-                    <button type="button" class="btn btn-danger" style="flex: 1;" onclick="closeModal()">Отмена</button>
-                </div>
-            </form>
-        </div>
-    </div>
-
-    <script>
-        let connections = [];
-        let stats = null;
-
-        async function loadConnections() {
-            try {
-                const response = await fetch('/api/upravlenie/connections');
-                connections = await response.json();
-                renderConnections();
-            } catch (error) {
-                console.error('Ошибка загрузки подключений:', error);
-                document.getElementById('connectionsList').innerHTML = 
-                    '<tr><td colspan="10" style="color: red; text-align: center;">Ошибка загрузки данных</td></tr>';
-            }
-        }
-
-        async function loadStats() {
-            try {
-                const response = await fetch('/api/upravlenie/stats');
-                stats = await response.json();
-                renderStats();
-            } catch (error) {
-                console.error('Ошибка загрузки статистики:', error);
-            }
-        }
-
-        function renderConnections() {
-            const typeFilter = document.getElementById('typeFilter').value;
-            const statusFilter = document.getElementById('statusFilter').value;
-
-            let filtered = [...connections];
-
-            if (typeFilter) {
-                filtered = filtered.filter(c => c.service_type === typeFilter);
-            }
-
-            if (statusFilter === 'active') {
-                filtered = filtered.filter(c => c.is_active === 1);
-            } else if (statusFilter === 'inactive') {
-                filtered = filtered.filter(c => c.is_active === 0);
-            }
-
-            const tbody = document.getElementById('connectionsList');
-            
-            if (filtered.length === 0) {
-                tbody.innerHTML = '<tr><td colspan="10" style="text-align: center;">Нет подключений</td></tr>';
-                return;
-            }
-
-            tbody.innerHTML = filtered.map(conn => `
-                <tr>
-                    <td>${conn.id}</td>
-                    <td><strong>${conn.service_id}</strong></td>
-                    <td>${conn.service_name}</td>
-                    <td><span class="badge badge-${conn.service_type}">${conn.service_type === 'organizer' ? 'Организатор' : 'Исполнитель'}</span></td>
-                    <td>${conn.login}</td>
-                    <td>${conn.local_user_login || conn.local_user_id || '-'}</td>
-                    <td>
-                        ${conn.is_active ? 
-                            '<span class="badge badge-success">Активен</span>' : 
-                            '<span class="badge badge-error">Неактивен</span>'}
-                        ${conn.sync_enabled ? 
-                            '<br><span class="badge badge-info">Синхр. ' + conn.sync_interval + ' мин</span>' : 
-                            ''}
-                    </td>
-                    <td>
-                        ${conn.last_sync_at ? new Date(conn.last_sync_at).toLocaleString() : 'Нет'}
-                        <br>
-                        <span class="badge ${conn.last_sync_status === 'success' ? 'badge-success' : 
-                            conn.last_sync_status === 'error' ? 'badge-error' : 'badge-warning'}">
-                            ${conn.last_sync_status || '?'}
-                        </span>
-                    </td>
-                    <td>
-                        <span id="connection-status-${conn.id}"></span>
-                        <button class="action-btn action-btn-check" onclick="checkConnection(${conn.id})">
-                            🔍 Проверить
-                        </button>
-                    </td>
-                    <td class="actions">
-                        <button class="action-btn action-btn-edit" onclick="editConnection(${conn.id})" title="Редактировать">
-                            ✏️
-                        </button>
-                        <button class="action-btn action-btn-sync" onclick="syncConnection(${conn.id})" title="Синхронизировать">
-                            🔄
-                        </button>
-                        <button class="action-btn action-btn-delete" onclick="deleteConnection(${conn.id})" title="Удалить">
-                            🗑️
-                        </button>
-                    </td>
-                </tr>
-            `).join('');
-        }
-
-        function renderStats() {
-            if (!stats) return;
-
-            document.getElementById('totalConnections').textContent = stats.total || 0;
-            document.getElementById('totalOrganizers').textContent = stats.organizers || 0;
-            document.getElementById('totalExecutors').textContent = stats.executors || 0;
-            document.getElementById('successSync').textContent = stats.lastSyncs?.filter(s => s.status === 'success').length || 0;
-
-            const lastSyncsList = document.getElementById('lastSyncsList');
-            if (stats.lastSyncs?.length > 0) {
-                lastSyncsList.innerHTML = stats.lastSyncs.map(s => `
-                    <tr>
-                        <td>${s.service}</td>
-                        <td>${new Date(s.last_sync).toLocaleString()}</td>
-                        <td><span class="badge ${s.status === 'success' ? 'badge-success' : 
-                            s.status === 'error' ? 'badge-error' : 'badge-warning'}">${s.status}</span></td>
-                    </tr>
-                `).join('');
-            } else {
-                lastSyncsList.innerHTML = '<tr><td colspan="3">Нет данных</td></tr>';
-            }
-
-            const errorsList = document.getElementById('errorsList');
-            if (stats.errors?.length > 0) {
-                errorsList.innerHTML = stats.errors.map(e => `
-                    <tr>
-                        <td>${e.service}</td>
-                        <td style="color: #dc3545;">${e.error}</td>
-                        <td>${new Date(e.time).toLocaleString()}</td>
-                    </tr>
-                `).join('');
-            } else {
-                errorsList.innerHTML = '<tr><td colspan="3">Нет ошибок</td></tr>';
-            }
-        }
-
-        async function refreshLogs() {
-            const logsList = document.getElementById('logsList');
-            logsList.innerHTML = '<div class="loading">Загрузка...</div>';
-            
-            try {
-                const response = await fetch('/api/upravlenie/connections');
-                const conns = await response.json();
-                
-                if (conns.length === 0) {
-                    logsList.innerHTML = '<div class="log-item">Нет данных</div>';
-                    return;
-                }
-
-                let html = '';
-                conns.sort((a, b) => new Date(b.last_sync_at) - new Date(a.last_sync_at)).forEach(conn => {
-                    if (conn.last_sync_at) {
-                        html += `
-                            <div class="log-item">
-                                <span class="log-status ${conn.last_sync_status === 'success' ? 'bg-success' : 
-                                    conn.last_sync_status === 'error' ? 'bg-danger' : 'bg-warning'}"></span>
-                                <span class="log-service">${conn.service_name}</span>
-                                <span class="log-time">${new Date(conn.last_sync_at).toLocaleString()}</span>
-                                <br>
-                                <small>${conn.last_sync_error || 'Статус: ' + conn.last_sync_status}</small>
-                            </div>
-                        `;
-                    }
-                });
-                
-                logsList.innerHTML = html || '<div class="log-item">Нет данных</div>';
-            } catch (error) {
-                logsList.innerHTML = '<div class="log-item" style="color: red;">Ошибка загрузки</div>';
-            }
-        }
-
-        function clearLogs() {
-            if (confirm('Очистить журнал синхронизации?')) {
-                document.getElementById('logsList').innerHTML = '<div class="log-item">Журнал очищен</div>';
-            }
-        }
-
-        function applyFilters() {
-            renderConnections();
-        }
-
-        function showAddModal() {
-            document.getElementById('modalTitle').textContent = 'Добавление подключения';
-            document.getElementById('connectionForm').reset();
-            document.getElementById('editId').value = '';
-            document.getElementById('connectionModal').style.display = 'block';
-            toggleApiUrlField();
-        }
-
-        function closeModal() {
-            document.getElementById('connectionModal').style.display = 'none';
-        }
-
-        async function editConnection(id) {
-            try {
-                const response = await fetch(`/api/upravlenie/connections/${id}`);
-                const conn = await response.json();
-                
-                document.getElementById('modalTitle').textContent = 'Редактирование подключения';
-                document.getElementById('editId').value = conn.id;
-                document.getElementById('service_id').value = conn.service_id;
-                document.getElementById('service_name').value = conn.service_name;
-                document.getElementById('service_type').value = conn.service_type;
-                document.getElementById('login').value = conn.login;
-                document.getElementById('password').value = conn.password;
-                document.getElementById('api_url').value = conn.api_url || '';
-                document.getElementById('local_user_id').value = conn.local_user_id || '';
-                document.getElementById('local_user_login').value = conn.local_user_login || '';
-                document.getElementById('sync_direction').value = conn.sync_direction || 'outgoing';
-                document.getElementById('sync_interval').value = conn.sync_interval || 60;
-                document.getElementById('sync_enabled').checked = conn.sync_enabled === 1;
-                
-                toggleApiUrlField();
-                document.getElementById('connectionModal').style.display = 'block';
-            } catch (error) {
-                alert('Ошибка загрузки данных');
-            }
-        }
-
-        async function checkConnection(id) {
-            const statusSpan = document.getElementById(`connection-status-${id}`);
-            statusSpan.innerHTML = '⏳ Проверка...';
-            
-            try {
-                const response = await fetch(`/api/upravlenie/check/${id}`);
-                const result = await response.json();
-                
-                if (result.service_type === 'executor') {
-                    if (result.status === 'connected') {
-                        statusSpan.innerHTML = '<span class="badge badge-success">✅ Связь есть</span>';
-                    } else {
-                        statusSpan.innerHTML = `<span class="badge badge-error">❌ ${result.error_details || 'Нет связи'}</span>`;
-                    }
-                } else {
-                    statusSpan.innerHTML = `<span class="badge badge-info">📊 Исполнителей: ${result.executors_count || 0}</span>`;
-                }
-            } catch (error) {
-                statusSpan.innerHTML = '<span class="badge badge-error">❌ Ошибка</span>';
-            }
-        }
-
-        async function syncConnection(id) {
-            if (!confirm('Запустить синхронизацию?')) return;
-            
-            try {
-                const response = await fetch(`/api/upravlenie/connections/${id}/sync`, {
-                    method: 'POST'
-                });
-                const result = await response.json();
-                
-                if (result.success) {
-                    alert('Синхронизация запущена');
-                    loadConnections();
-                    loadStats();
-                }
-            } catch (error) {
-                alert('Ошибка запуска синхронизации');
-            }
-        }
-
-        async function deleteConnection(id) {
-            if (!confirm('Удалить подключение?')) return;
-            
-            try {
-                const response = await fetch(`/api/upravlenie/connections/${id}`, {
-                    method: 'DELETE'
-                });
-                const result = await response.json();
-                
-                if (result.success) {
-                    loadConnections();
-                    loadStats();
-                }
-            } catch (error) {
-                alert('Ошибка удаления');
-            }
-        }
-
-        function refreshConnections() {
-            loadConnections();
-        }
-
-        function openTab(tabName) {
-            document.querySelectorAll('.tab').forEach(tab => tab.classList.remove('active'));
-            document.querySelectorAll('.tab-content').forEach(content => content.style.display = 'none');
-            
-            event.target.classList.add('active');
-            document.getElementById(tabName + '-tab').style.display = 'block';
-            
-            if (tabName === 'stats') {
-                loadStats();
-            } else if (tabName === 'logs') {
-                refreshLogs();
-            }
-        }
-
-        function toggleApiUrlField() {
-            const type = document.getElementById('service_type').value;
-            const apiUrlGroup = document.getElementById('apiUrlGroup');
-            apiUrlGroup.style.display = type === 'executor' ? 'block' : 'none';
-        }
-
-        document.getElementById('connectionForm').addEventListener('submit', async (e) => {
-            e.preventDefault();
-            
-            const id = document.getElementById('editId').value;
-            const url = id ? `/api/upravlenie/connections/${id}` : '/api/upravlenie/connections';
-            const method = id ? 'PUT' : 'POST';
-            
-            const data = {
-                service_id: parseInt(document.getElementById('service_id').value),
-                service_name: document.getElementById('service_name').value,
-                service_type: document.getElementById('service_type').value,
-                login: document.getElementById('login').value,
-                password: document.getElementById('password').value,
-                api_url: document.getElementById('api_url').value || null,
-                local_user_id: parseInt(document.getElementById('local_user_id').value) || null,
-                local_user_login: document.getElementById('local_user_login').value || null,
-                sync_direction: document.getElementById('sync_direction').value,
-                sync_interval: parseInt(document.getElementById('sync_interval').value),
-                sync_enabled: document.getElementById('sync_enabled').checked ? 1 : 0
-            };
-            
-            try {
-                const response = await fetch(url, {
-                    method: method,
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(data)
-                });
-                
-                const result = await response.json();
-                
-                if (result.success || result.id) {
-                    closeModal();
-                    loadConnections();
-                    loadStats();
-                } else {
-                    alert('Ошибка: ' + (result.error || 'Неизвестная ошибка'));
-                }
-            } catch (error) {
-                alert('Ошибка сохранения');
-            }
-        });
-
-        document.getElementById('service_type').addEventListener('change', toggleApiUrlField);
-
-        window.onclick = function(event) {
-            const modal = document.getElementById('connectionModal');
-            if (event.target === modal) {
-                closeModal();
-            }
-        }
-
-        loadConnections();
-        loadStats();
-    </script>
-</body>
-</html>
\ No newline at end of file
diff --git a/server.js b/server.js
index 01995c8..4550bae 100644
--- a/server.js
+++ b/server.js
@@ -22,7 +22,8 @@ const api2Groups = require('./api2-groups');
 //
 const chatAPI = require('./api-chat');
 // Подключаем API для управления межсервисным взаимодействием
-const { setupUpravlenieEndpoints } = require('./upravlenie-service');
+//const { setupUpravlenieEndpoints } = require('./upravlenie-service');
+const apiKeysModule = require('./api-keys');
 //
 const app = express();
 const PORT = process.env.PORT || 3000;
@@ -165,6 +166,28 @@ const requireAuth = (req, res, next) => {
     next();
 };
 
+// Middleware для проверки прав администратора
+const requireAdmin = (req, res, next) => {
+    if (!req.session || !req.session.user) {
+        return res.status(401).json({ error: 'Требуется аутентификация' });
+    }
+    if (req.session.user.role !== 'admin') {
+        return res.status(403).json({ error: 'Недостаточно прав. Требуется роль администратора' });
+    }
+    next();
+};
+
+// Middleware для проверки прав на управление задачами (admin или tasks)
+const requireTasksAccess = (req, res, next) => {
+    if (!req.session || !req.session.user) {
+        return res.status(401).json({ error: 'Требуется аутентификация' });
+    }
+    if (req.session.user.role !== 'admin' && req.session.user.role !== 'tasks') {
+        return res.status(403).json({ error: 'Недостаточно прав. Требуется роль admin или tasks' });
+    }
+    next();
+};
+
 // API для аутентификации
 app.post('/api/login', async (req, res) => {
     const { login, password } = req.body;
@@ -303,6 +326,7 @@ app.get('/api/user', (req, res) => {
         res.status(401).json({ error: 'Не аутентифицирован' });
     }
 });
+
 // Получаем актуальные группы пользователя из новой структуры
 app.get('/api/user_v2', (req, res) => {
     if (req.session.user) {
@@ -371,6 +395,7 @@ app.get('/api/users/group/help', requireAuth, (req, res) => {
         res.json(rows);
     });
 });
+
 // API для получения пользователей группы "doc"
 app.get('/api/users/group/doc', requireAuth, (req, res) => {
     db.all(`
@@ -389,6 +414,7 @@ app.get('/api/users/group/doc', requireAuth, (req, res) => {
         res.json(rows);
     });
 });
+
 // Middleware для проверки наличия БД в API endpoints
 app.use((req, res, next) => {
     if (!db && req.path.startsWith('/api/') && req.path !== '/api/health' && req.path !== '/api/login') {
@@ -739,11 +765,9 @@ app.get('/doc', (req, res) => {
     if (!hasAccess) {
         return res.status(403).send('в разработке');
     }
-    //if (!req.session.user || req.session.user.role !== 'admin') {
-    //    return res.status(403).send('в разработке');
-    //}
     res.sendFile(path.join(__dirname, 'public/doc.html'));
 });
+
 // Страница поддержка
 app.get('/help', (req, res) => {
     if (!req.session.user) {
@@ -983,6 +1007,7 @@ app.get('/api/groups', requireAuth, (req, res) => {
         res.json(groups);
     });
 });
+
 // API для всех пользователей с группами
 app.get('/api/users/all', requireAuth, (req, res) => {
     if (req.session.user.role !== 'admin') {
@@ -1032,6 +1057,75 @@ app.get('/api/users/all', requireAuth, (req, res) => {
     });
 });
 
+// API для обновления пользователя (только для админов)
+app.put('/api/users/:userId', requireAuth, requireAdmin, (req, res) => {
+    const { userId } = req.params;
+    const { name, email, role, auth_type, is_active } = req.body;
+
+    // Проверяем существование пользователя
+    db.get('SELECT id FROM users WHERE id = ?', [userId], (err, user) => {
+        if (err) {
+            console.error('❌ Ошибка проверки пользователя:', err);
+            return res.status(500).json({ error: err.message });
+        }
+
+        if (!user) {
+            return res.status(404).json({ error: 'Пользователь не найден' });
+        }
+
+        // Формируем запрос на обновление
+        const updates = [];
+        const params = [];
+
+        if (name !== undefined) {
+            updates.push('name = ?');
+            params.push(name);
+        }
+
+        if (email !== undefined) {
+            updates.push('email = ?');
+            params.push(email);
+        }
+
+        if (role !== undefined) {
+            updates.push('role = ?');
+            params.push(role);
+        }
+
+        if (auth_type !== undefined) {
+            updates.push('auth_type = ?');
+            params.push(auth_type);
+        }
+
+        if (is_active !== undefined) {
+            updates.push('is_active = ?');
+            params.push(is_active ? 1 : 0);
+        }
+
+        if (updates.length === 0) {
+            return res.status(400).json({ error: 'Нет данных для обновления' });
+        }
+
+        updates.push('updated_at = CURRENT_TIMESTAMP');
+        params.push(userId);
+
+        const query = `UPDATE users SET ${updates.join(', ')} WHERE id = ?`;
+
+        db.run(query, params, function(err) {
+            if (err) {
+                console.error('❌ Ошибка обновления пользователя:', err);
+                return res.status(500).json({ error: err.message });
+            }
+
+            res.json({ 
+                success: true, 
+                message: 'Пользователь успешно обновлен',
+                changes: this.changes
+            });
+        });
+    });
+});
+
 // API для добавления пользователя в группу
 app.post('/api/groups/:groupId/users/:userId', requireAuth, (req, res) => {
     if (req.session.user.role !== 'admin') {
@@ -1344,6 +1438,7 @@ app.delete('/api/tasks/:taskId/files/batch-delete', requireAuth, (req, res) => {
         });
     });
 });
+
 // API для получения информации о файле
 app.get('/api/files/:fileId', requireAuth, (req, res) => {
     const { fileId } = req.params;
@@ -1370,6 +1465,7 @@ app.get('/api/files/:fileId', requireAuth, (req, res) => {
         });
     });
 });
+
 // Инициализация сервера
 async function initializeServer() {
     console.log('🚀 Инициализация сервера...');
@@ -1398,7 +1494,7 @@ async function initializeServer() {
         apiDoc(app, db, upload);
         console.log('✅ Endpoint\'ы документов настроены');
         
-        // 5. Загружаем админ роутер динамически
+        // 6. Загружаем админ роутер динамически
         try {
             adminRouter = require('./admin-server');
             console.log('Admin router loaded:', adminRouter);
@@ -1435,14 +1531,19 @@ async function initializeServer() {
             console.log('⚠️  Создана заглушка для админ роутера из-за ошибки');
         }
 
-        // Подключаем API для внешних идентификаторов
+        // 7. Подключаем API для внешних идентификаторов
         api2Groups(app, db);
         console.log('✅ API для внешних идентификаторов подключено');
-        // Подключаем API для управления межсервисным взаимодействием
-        const upravlenieService = setupUpravlenieEndpoints(app, db);
-        console.log('✅ API для управления межсервисным взаимодействием подключено');
         
-        // 6. Помечаем сервер как готовый
+        // 8. Подключаем API для управления межсервисным взаимодействием
+        //const upravlenieService = setupUpravlenieEndpoints(app, db);
+        //console.log('✅ API для управления межсервисным взаимодействием подключено');
+        
+        // 9. Подключаем модуль API ключей
+        apiKeysModule(app, db, upload);
+        console.log('✅ Модуль API ключей подключен');
+        
+        // 10. Помечаем сервер как готовый
         serverReady = true;
         
         console.log('✅ Сервер полностью инициализирован');
@@ -1468,9 +1569,11 @@ initializeServer().then(() => {
         console.log('🔐 LDAP авторизация доступна для пользователей школы');
         console.log(`👥 Разрешенные группы: ${process.env.ALLOWED_GROUPS}`);
         console.log('📢 Система уведомлений активна');
+        
         // Подключаем API для чата
         chatAPI(app, db, upload);
         console.log('✅ API для чата задач подключено');
+        
         // Запускаем фоновые задачи
         setInterval(checkOverdueTasks, 60000);
         setInterval(checkUpcomingDeadlines, 60000);
diff --git a/upravlenie-service.js b/upravlenie-service.js
deleted file mode 100644
index a6590aa..0000000
--- a/upravlenie-service.js
+++ /dev/null
@@ -1,1362 +0,0 @@
-// upravlenie-service.js
-const axios = require('axios');
-const FormData = require('form-data');
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-
-const SERVICE_ID_RANGE = { min: 1, max: 4062 };
-const SYNC_INTERVAL = 60000;
-const MAX_RETRY_COUNT = 3;
-const RETRY_DELAY = 5000;
-
-const TaskStatus = {
-    PENDING: 'pending',
-    IN_PROGRESS: 'in_progress',
-    ASSIGNED: 'assigned',
-    REWORK: 'rework',
-    COMPLETED: 'completed',
-    OVERDUE: 'overdue',
-    CANCELLED: 'cancelled'
-};
-
-const SyncDirection = {
-    INCOMING: 'incoming',
-    OUTGOING: 'outgoing'
-};
-
-class UpravlenieService {
-    constructor(db) {
-        this.db = db;
-        this.syncIntervals = new Map();
-        this.syncInProgress = new Set();
-        this.init();
-    }
-
-    async init() {
-        console.log('🔧 Инициализация сервиса Upravlenie...');
-        await this.createTable();
-        await this.startAllSyncJobs();
-        console.log('✅ Сервис Upravlenie инициализирован');
-    }
-
-    async createTable() {
-        const createTableSQL = `
-            CREATE TABLE IF NOT EXISTS upravlenie (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                service_id INTEGER NOT NULL CHECK(service_id >= 1 AND service_id <= 4062),
-                service_name VARCHAR(255) NOT NULL,
-                service_type VARCHAR(50) NOT NULL CHECK(service_type IN ('organizer', 'executor')),
-                login VARCHAR(255) NOT NULL,
-                password VARCHAR(255) NOT NULL,
-                api_url VARCHAR(500),
-                local_user_id INTEGER,
-                local_user_login VARCHAR(255),
-                sync_direction VARCHAR(50) DEFAULT 'outgoing' CHECK(sync_direction IN ('incoming', 'outgoing', 'both')),
-                sync_enabled BOOLEAN DEFAULT 1,
-                sync_interval INTEGER DEFAULT 60,
-                last_sync_at TIMESTAMP,
-                last_sync_status VARCHAR(50),
-                last_sync_error TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                is_active BOOLEAN DEFAULT 1,
-                FOREIGN KEY (local_user_id) REFERENCES users(id)
-            )
-        `;
-
-        return new Promise((resolve, reject) => {
-            this.db.run(createTableSQL, (err) => {
-                if (err) {
-                    console.error('❌ Ошибка создания таблицы upravlenie:', err);
-                    reject(err);
-                } else {
-                    console.log('✅ Таблица upravlenie создана/проверена');
-                    this.createIndexes().then(resolve).catch(reject);
-                }
-            });
-        });
-    }
-
-    async createIndexes() {
-        const indexes = [
-            'CREATE INDEX IF NOT EXISTS idx_upravlenie_service_id ON upravlenie(service_id)',
-            'CREATE INDEX IF NOT EXISTS idx_upravlenie_service_type ON upravlenie(service_type)',
-            'CREATE INDEX IF NOT EXISTS idx_upravlenie_local_user_id ON upravlenie(local_user_id)',
-            'CREATE INDEX IF NOT EXISTS idx_upravlenie_sync_enabled ON upravlenie(sync_enabled)',
-            'CREATE INDEX IF NOT EXISTS idx_upravlenie_last_sync ON upravlenie(last_sync_at)'
-        ];
-
-        return new Promise((resolve, reject) => {
-            this.db.serialize(() => {
-                let error = null;
-                indexes.forEach(indexSQL => {
-                    this.db.run(indexSQL, (err) => {
-                        if (err) error = err;
-                    });
-                });
-                
-                if (error) {
-                    console.error('❌ Ошибка создания индексов:', error);
-                    reject(error);
-                } else {
-                    console.log('✅ Индексы для upravlenie созданы');
-                    resolve();
-                }
-            });
-        });
-    }
-
-    async createConnection(data) {
-        const { 
-            service_id, service_name, service_type, login, password, 
-            api_url, local_user_id, local_user_login, sync_direction = 'outgoing',
-            sync_enabled = 1, sync_interval = 60
-        } = data;
-
-        if (service_id < SERVICE_ID_RANGE.min || service_id > SERVICE_ID_RANGE.max) {
-            throw new Error(`service_id должен быть в диапазоне ${SERVICE_ID_RANGE.min}-${SERVICE_ID_RANGE.max}`);
-        }
-
-        if (service_type === 'executor' && !api_url) {
-            throw new Error('Для исполнителя необходимо указать api_url организатора');
-        }
-
-        if (local_user_id) {
-            const userExists = await this.checkLocalUserExists(local_user_id);
-            if (!userExists) {
-                throw new Error(`Пользователь с ID ${local_user_id} не существует`);
-            }
-        }
-
-        const existing = await this.getConnectionByServiceId(service_id);
-        if (existing && existing.is_active) {
-            throw new Error(`Подключение с service_id ${service_id} уже существует`);
-        }
-
-        const sql = `
-            INSERT INTO upravlenie (
-                service_id, service_name, service_type, login, password,
-                api_url, local_user_id, local_user_login, sync_direction,
-                sync_enabled, sync_interval
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `;
-
-        return new Promise((resolve, reject) => {
-            this.db.run(sql, [
-                service_id, service_name, service_type, login, password,
-                api_url, local_user_id || null, local_user_login || null,
-                sync_direction, sync_enabled, sync_interval
-            ], function(err) {
-                if (err) {
-                    reject(err);
-                } else {
-                    const connectionId = this.lastID;
-                    console.log(`✅ Создано подключение ${service_name} (ID: ${connectionId}, service_id: ${service_id})`);
-                    resolve({ id: connectionId, ...data });
-                }
-            });
-        });
-    }
-
-    async checkLocalUserExists(userId) {
-        return new Promise((resolve) => {
-            this.db.get('SELECT id FROM users WHERE id = ?', [userId], (err, row) => {
-                resolve(!!row);
-            });
-        });
-    }
-
-    getConnection(id) {
-        return new Promise((resolve, reject) => {
-            this.db.get('SELECT * FROM upravlenie WHERE id = ?', [id], (err, row) => {
-                if (err) reject(err);
-                else resolve(row);
-            });
-        });
-    }
-
-    getConnectionByServiceId(serviceId) {
-        return new Promise((resolve, reject) => {
-            this.db.get(
-                'SELECT * FROM upravlenie WHERE service_id = ? AND is_active = 1',
-                [serviceId],
-                (err, row) => {
-                    if (err) reject(err);
-                    else resolve(row);
-                }
-            );
-        });
-    }
-
-    getAllConnections(filters = {}) {
-        return new Promise((resolve, reject) => {
-            let sql = 'SELECT * FROM upravlenie WHERE 1=1';
-            const params = [];
-
-            if (filters.service_type) {
-                sql += ' AND service_type = ?';
-                params.push(filters.service_type);
-            }
-
-            if (filters.is_active !== undefined) {
-                sql += ' AND is_active = ?';
-                params.push(filters.is_active ? 1 : 0);
-            }
-
-            if (filters.sync_enabled !== undefined) {
-                sql += ' AND sync_enabled = ?';
-                params.push(filters.sync_enabled ? 1 : 0);
-            }
-
-            sql += ' ORDER BY service_name';
-
-            this.db.all(sql, params, (err, rows) => {
-                if (err) reject(err);
-                else resolve(rows);
-            });
-        });
-    }
-
-    async updateConnection(id, data) {
-        const fields = [];
-        const values = [];
-
-        const allowedFields = [
-            'service_name', 'service_type', 'login', 'password',
-            'api_url', 'local_user_id', 'local_user_login',
-            'sync_direction', 'sync_enabled', 'sync_interval',
-            'is_active'
-        ];
-
-        allowedFields.forEach(field => {
-            if (data[field] !== undefined) {
-                fields.push(`${field} = ?`);
-                values.push(data[field]);
-            }
-        });
-
-        if (fields.length === 0) {
-            throw new Error('Нет данных для обновления');
-        }
-
-        fields.push('updated_at = CURRENT_TIMESTAMP');
-        values.push(id);
-
-        const sql = `UPDATE upravlenie SET ${fields.join(', ')} WHERE id = ?`;
-
-        return new Promise((resolve, reject) => {
-            this.db.run(sql, values, function(err) {
-                if (err) {
-                    reject(err);
-                } else {
-                    console.log(`✅ Подключение ${id} обновлено`);
-                    resolve({ id, changes: this.changes });
-                }
-            });
-        });
-    }
-
-    async deleteConnection(id) {
-        return this.updateConnection(id, { is_active: 0 });
-    }
-
-    async startAllSyncJobs() {
-        const connections = await this.getAllConnections({ 
-            is_active: true, 
-            sync_enabled: true 
-        });
-
-        for (const conn of connections) {
-            this.startSyncJob(conn.id, conn.sync_interval);
-        }
-
-        console.log(`✅ Запущено ${connections.length} задач синхронизации`);
-    }
-
-    startSyncJob(connectionId, intervalMinutes) {
-        this.stopSyncJob(connectionId);
-
-        const intervalMs = intervalMinutes * 60 * 1000;
-        const interval = setInterval(() => {
-            this.syncConnection(connectionId);
-        }, intervalMs);
-
-        this.syncIntervals.set(connectionId, interval);
-        console.log(`✅ Запущена синхронизация для подключения ${connectionId} (интервал: ${intervalMinutes} мин)`);
-
-        setTimeout(() => {
-            this.syncConnection(connectionId);
-        }, 1000);
-    }
-
-    stopSyncJob(connectionId) {
-        if (this.syncIntervals.has(connectionId)) {
-            clearInterval(this.syncIntervals.get(connectionId));
-            this.syncIntervals.delete(connectionId);
-            console.log(`✅ Остановлена синхронизация для подключения ${connectionId}`);
-        }
-    }
-
-    async restartSyncJob(connectionId) {
-        this.stopSyncJob(connectionId);
-
-        const connection = await this.getConnection(connectionId);
-        if (connection && connection.is_active && connection.sync_enabled) {
-            this.startSyncJob(connectionId, connection.sync_interval);
-        }
-    }
-
-    async syncConnection(connectionId) {
-        if (this.syncInProgress.has(connectionId)) {
-            console.log(`⚠️ Синхронизация подключения ${connectionId} уже выполняется`);
-            return;
-        }
-
-        this.syncInProgress.add(connectionId);
-
-        try {
-            const connection = await this.getConnection(connectionId);
-            if (!connection || !connection.is_active || !connection.sync_enabled) {
-                return;
-            }
-
-            console.log(`🔄 Синхронизация подключения ${connection.service_name} (${connection.service_id})...`);
-
-            await this.updateSyncStatus(connectionId, 'in_progress');
-
-            if (connection.service_type === 'organizer') {
-                await this.syncFromExecutors(connection);
-            } else {
-                await this.syncToOrganizer(connection);
-            }
-
-            await this.updateSyncStatus(connectionId, 'success');
-            console.log(`✅ Синхронизация подключения ${connection.service_name} завершена`);
-
-        } catch (error) {
-            console.error(`❌ Ошибка синхронизации подключения ${connectionId}:`, error.message);
-            await this.updateSyncStatus(connectionId, 'error', error.message);
-        } finally {
-            this.syncInProgress.delete(connectionId);
-        }
-    }
-
-    updateSyncStatus(connectionId, status, error = null) {
-        return new Promise((resolve, reject) => {
-            this.db.run(
-                `UPDATE upravlenie 
-                 SET last_sync_at = CURRENT_TIMESTAMP,
-                     last_sync_status = ?,
-                     last_sync_error = ?
-                 WHERE id = ?`,
-                [status, error, connectionId],
-                (err) => {
-                    if (err) reject(err);
-                    else resolve();
-                }
-            );
-        });
-    }
-
-    async syncToOrganizer(connection) {
-        if (!connection.api_url) {
-            throw new Error('Для исполнителя не указан api_url организатора');
-        }
-
-        console.log(`🔍 Исполнитель ${connection.service_name} пытается связаться с организатором по URL: ${connection.api_url}`);
-
-        if (!connection.local_user_id) {
-            console.warn(`⚠️ Для подключения ${connection.service_name} не указан локальный пользователь. Задачи не будут создаваться.`);
-            return;
-        }
-
-        try {
-            console.log(`📡 Проверка доступности организатора...`);
-            
-            const organizerTasks = await this.fetchTasksFromOrganizer(connection);
-            console.log(`📥 Получено ${organizerTasks.length} задач от организатора`);
-            
-            const localTasks = await this.getTasksForLocalUser(connection.local_user_id);
-            
-            if (organizerTasks.length > 0) {
-                await this.syncTasksWithOrganizer(connection, organizerTasks, localTasks);
-            }
-            
-            if (localTasks.length > 0) {
-                await this.sendTaskStatusesToOrganizer(connection, localTasks);
-                console.log(`📤 Отправлено ${localTasks.length} статусов организатору`);
-            }
-            
-        } catch (error) {
-            console.error(`❌ Ошибка связи с организатором:`, error.message);
-            if (error.code === 'ECONNREFUSED') {
-                console.error(`🔴 Организатор не доступен по адресу ${connection.api_url}`);
-            } else if (error.code === 'ETIMEDOUT') {
-                console.error(`⏱️ Таймаут при подключении к организатору`);
-            } else if (error.response) {
-                console.error(`📡 Ответ организатора:`, {
-                    status: error.response.status,
-                    data: error.response.data
-                });
-            }
-            throw error;
-        }
-    }
-
-    async syncFromExecutors(connection) {
-        const executors = await this.getAllConnections({
-            service_type: 'executor',
-            is_active: true,
-            sync_enabled: true
-        });
-
-        if (executors.length === 0) {
-            console.log(`📭 Нет активных исполнителей для организатора ${connection.service_name}`);
-            return;
-        }
-
-        for (const executor of executors) {
-            try {
-                if (!executor.local_user_id) {
-                    console.warn(`⚠️ Для исполнителя ${executor.service_name} не указан локальный пользователь. Пропускаем...`);
-                    continue;
-                }
-
-                const taskStatuses = await this.fetchTaskStatusesFromExecutor(executor);
-                
-                if (taskStatuses.length > 0) {
-                    await this.updateTaskStatusesFromExecutor(executor, taskStatuses);
-                    console.log(`✅ Получено ${taskStatuses.length} статусов от исполнителя ${executor.service_name}`);
-                }
-                
-            } catch (error) {
-                console.error(`❌ Ошибка получения статусов от исполнителя ${executor.service_name}:`, error.message);
-            }
-        }
-    }
-
-    getTasksForLocalUser(userId) {
-        return new Promise((resolve, reject) => {
-            if (!userId) {
-                return resolve([]);
-            }
-
-            this.db.all(`
-                SELECT t.*, ta.status as assignment_status, ta.due_date as assignment_due_date
-                FROM tasks t
-                JOIN task_assignments ta ON t.id = ta.task_id
-                WHERE ta.user_id = ? AND t.status = 'active' AND t.closed_at IS NULL
-                ORDER BY t.created_at DESC
-            `, [userId], (err, rows) => {
-                if (err) reject(err);
-                else resolve(rows);
-            });
-        });
-    }
-
-    async fetchTasksFromOrganizer(connection) {
-        try {
-            const response = await axios.get(`${connection.api_url}/api/external/tasks`, {
-                params: {
-                    service_id: connection.service_id,
-                    user_login: connection.local_user_login
-                },
-                auth: {
-                    username: connection.login,
-                    password: connection.password
-                },
-                timeout: 10000
-            });
-
-            return response.data.tasks || [];
-        } catch (error) {
-            console.error(`❌ Ошибка получения задач от организатора:`, error.message);
-            throw new Error(`Не удалось получить задачи: ${error.message}`);
-        }
-    }
-
-    async fetchTaskStatusesFromExecutor(executor) {
-        try {
-            const response = await axios.get(`${executor.api_url}/api/external/task-statuses`, {
-                params: {
-                    service_id: executor.service_id
-                },
-                auth: {
-                    username: executor.login,
-                    password: executor.password
-                },
-                timeout: 10000
-            });
-
-            return response.data.statuses || [];
-        } catch (error) {
-            console.error(`❌ Ошибка получения статусов от исполнителя:`, error.message);
-            throw error;
-        }
-    }
-
-    async sendTaskStatusesToOrganizer(connection, localTasks) {
-        const statuses = localTasks.map(task => ({
-            task_id: task.id,
-            external_task_id: task.external_task_id,
-            status: task.assignment_status,
-            completed_at: task.closed_at,
-            comment: task.rework_comment
-        }));
-
-        try {
-            await axios.post(`${connection.api_url}/api/external/task-statuses`, {
-                service_id: connection.service_id,
-                statuses: statuses
-            }, {
-                auth: {
-                    username: connection.login,
-                    password: connection.password
-                },
-                timeout: 10000
-            });
-
-            console.log(`✅ Отправлено ${statuses.length} статусов организатору`);
-        } catch (error) {
-            console.error(`❌ Ошибка отправки статусов организатору:`, error.message);
-            throw error;
-        }
-    }
-
-    async syncTasksWithOrganizer(connection, organizerTasks, localTasks) {
-        for (const organizerTask of organizerTasks) {
-            const localTask = localTasks.find(t => t.external_task_id === organizerTask.id);
-            
-            if (!localTask) {
-                await this.createTaskFromOrganizer(connection, organizerTask);
-            } else {
-                await this.updateTaskFromOrganizer(connection, organizerTask, localTask);
-            }
-        }
-    }
-
-    async createTaskFromOrganizer(connection, taskData) {
-        return new Promise((resolve, reject) => {
-            if (!connection.local_user_id) {
-                reject(new Error('local_user_id не может быть пустым. Укажите локального пользователя для создания задач.'));
-                return;
-            }
-
-            this.db.all("PRAGMA table_info(tasks)", (err, columns) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-
-                const columnNames = columns.map(c => c.name);
-                
-                let fields = ['title', 'description', 'status', 'created_by', 'start_date', 'due_date', 'task_type'];
-                let placeholders = ['?', '?', '?', '?', '?', '?', '?'];
-                let values = [
-                    taskData.title,
-                    taskData.description || '',
-                    'active',
-                    connection.local_user_id,
-                    taskData.start_date || new Date().toISOString(),
-                    taskData.due_date || null,
-                    'external'
-                ];
-
-                if (columnNames.includes('external_task_id')) {
-                    fields.push('external_task_id');
-                    placeholders.push('?');
-                    values.push(taskData.id);
-                }
-
-                if (columnNames.includes('external_service_id')) {
-                    fields.push('external_service_id');
-                    placeholders.push('?');
-                    values.push(connection.service_id);
-                }
-
-                const sql = `INSERT INTO tasks (${fields.join(', ')}) VALUES (${placeholders.join(', ')})`;
-
-                this.db.run(sql, values, function(err) {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-
-                    const newTaskId = this.lastID;
-
-                    this.db.run(
-                        `INSERT INTO task_assignments (task_id, user_id, status, start_date, due_date)
-                         VALUES (?, ?, ?, ?, ?)`,
-                        [
-                            newTaskId,
-                            connection.local_user_id,
-                            taskData.status || 'assigned',
-                            taskData.start_date || new Date().toISOString(),
-                            taskData.due_date || null
-                        ],
-                        (err) => {
-                            if (err) {
-                                reject(err);
-                                return;
-                            }
-
-                            console.log(`✅ Создана задача ${newTaskId} от организатора ${connection.service_name}`);
-                            resolve(newTaskId);
-                        }
-                    );
-                });
-            });
-        });
-    }
-
-    async updateTaskFromOrganizer(connection, organizerTask, localTask) {
-        return new Promise((resolve, reject) => {
-            this.db.run(
-                `UPDATE tasks 
-                 SET title = ?, description = ?, due_date = ?, updated_at = CURRENT_TIMESTAMP
-                 WHERE id = ?`,
-                [organizerTask.title, organizerTask.description || '', organizerTask.due_date || null, localTask.id],
-                (err) => {
-                    if (err) reject(err);
-                    else {
-                        console.log(`✅ Обновлена задача ${localTask.id} от организатора`);
-                        resolve();
-                    }
-                }
-            );
-        });
-    }
-
-    async updateTaskStatusesFromExecutor(executor, taskStatuses) {
-        for (const status of taskStatuses) {
-            await new Promise((resolve, reject) => {
-                this.db.run(
-                    `UPDATE task_assignments 
-                     SET status = ?, updated_at = CURRENT_TIMESTAMP
-                     WHERE task_id = ? AND user_id = ?`,
-                    [
-                        status.status,
-                        status.task_id,
-                        executor.local_user_id
-                    ],
-                    function(err) {
-                        if (err) reject(err);
-                        else {
-                            if (this.changes > 0) {
-                                console.log(`✅ Обновлен статус задачи ${status.task_id}: ${status.status}`);
-                            }
-                            resolve();
-                        }
-                    }
-                );
-            });
-
-            if (status.status === 'completed') {
-                await this.checkAndCloseTaskIfAllCompleted(status.task_id);
-            }
-        }
-    }
-
-    async checkAndCloseTaskIfAllCompleted(taskId) {
-        return new Promise((resolve) => {
-            this.db.all(
-                'SELECT status FROM task_assignments WHERE task_id = ?',
-                [taskId],
-                (err, assignments) => {
-                    if (!err && assignments && assignments.length > 0) {
-                        const allCompleted = assignments.every(a => a.status === 'completed');
-                        
-                        if (allCompleted) {
-                            this.db.run(
-                                'UPDATE tasks SET closed_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
-                                [taskId],
-                                (err) => {
-                                    if (!err) {
-                                        console.log(`✅ Задача ${taskId} автоматически закрыта`);
-                                    }
-                                    resolve();
-                                }
-                            );
-                        } else {
-                            resolve();
-                        }
-                    } else {
-                        resolve();
-                    }
-                }
-            );
-        });
-    }
-
-    async uploadFileToRemote(connection, taskId, fileId) {
-        return new Promise((resolve, reject) => {
-            this.db.get(
-                'SELECT * FROM task_files WHERE id = ?',
-                [fileId],
-                async (err, file) => {
-                    if (err || !file) {
-                        reject(err || new Error('Файл не найден'));
-                        return;
-                    }
-
-                    if (!fs.existsSync(file.file_path)) {
-                        reject(new Error('Файл не существует на диске'));
-                        return;
-                    }
-
-                    try {
-                        const formData = new FormData();
-                        formData.append('file', fs.createReadStream(file.file_path), {
-                            filename: file.original_name,
-                            contentType: 'application/octet-stream'
-                        });
-                        formData.append('task_id', taskId);
-                        formData.append('service_id', connection.service_id);
-
-                        const response = await axios.post(
-                            `${connection.api_url}/api/external/upload-file`,
-                            formData,
-                            {
-                                headers: formData.getHeaders(),
-                                auth: {
-                                    username: connection.login,
-                                    password: connection.password
-                                },
-                                timeout: 30000,
-                                maxContentLength: Infinity,
-                                maxBodyLength: Infinity
-                            }
-                        );
-
-                        console.log(`✅ Файл ${file.original_name} загружен в удаленный сервис`);
-                        resolve(response.data);
-
-                    } catch (error) {
-                        console.error(`❌ Ошибка загрузки файла в удаленный сервис:`, error.message);
-                        reject(error);
-                    }
-                }
-            );
-        });
-    }
-
-    async downloadFileFromRemote(connection, remoteFileId, localTaskId) {
-        try {
-            const response = await axios.get(
-                `${connection.api_url}/api/external/download-file/${remoteFileId}`,
-                {
-                    params: { service_id: connection.service_id },
-                    auth: {
-                        username: connection.login,
-                        password: connection.password
-                    },
-                    responseType: 'stream',
-                    timeout: 30000
-                }
-            );
-
-            const { createUserTaskFolder } = require('./database');
-            const userFolder = createUserTaskFolder(localTaskId, connection.local_user_login || 'external');
-            
-            const fileName = response.headers['x-file-name'] || `remote_${Date.now()}.bin`;
-            const filePath = path.join(userFolder, fileName);
-
-            const writer = fs.createWriteStream(filePath);
-            response.data.pipe(writer);
-
-            await new Promise((resolve, reject) => {
-                writer.on('finish', resolve);
-                writer.on('error', reject);
-            });
-
-            const fileSize = fs.statSync(filePath).size;
-            
-            return new Promise((resolve, reject) => {
-                this.db.run(
-                    `INSERT INTO task_files (task_id, user_id, filename, original_name, file_path, file_size)
-                     VALUES (?, ?, ?, ?, ?, ?)`,
-                    [
-                        localTaskId,
-                        connection.local_user_id,
-                        fileName,
-                        fileName,
-                        filePath,
-                        fileSize
-                    ],
-                    function(err) {
-                        if (err) reject(err);
-                        else {
-                            console.log(`✅ Файл ${fileName} загружен из удаленного сервиса`);
-                            resolve({ id: this.lastID, filePath, fileName });
-                        }
-                    }
-                );
-            });
-
-        } catch (error) {
-            console.error(`❌ Ошибка загрузки файла из удаленного сервиса:`, error.message);
-            throw error;
-        }
-    }
-
-    generateAuthToken(serviceId, login) {
-        const secret = process.env.EXTERNAL_API_SECRET || 'default_secret_change_me';
-        const timestamp = Math.floor(Date.now() / 1000);
-        const data = `${serviceId}:${login}:${timestamp}`;
-        const hash = crypto.createHmac('sha256', secret).update(data).digest('hex');
-        return `${timestamp}:${hash}`;
-    }
-
-    verifyAuthToken(token, serviceId, login) {
-        try {
-            const secret = process.env.EXTERNAL_API_SECRET || 'default_secret_change_me';
-            const [timestamp, hash] = token.split(':');
-            
-            const now = Math.floor(Date.now() / 1000);
-            if (now - parseInt(timestamp) > 300) {
-                return false;
-            }
-
-            const data = `${serviceId}:${login}:${timestamp}`;
-            const expectedHash = crypto.createHmac('sha256', secret).update(data).digest('hex');
-            
-            return crypto.timingSafeEqual(
-                Buffer.from(hash, 'hex'),
-                Buffer.from(expectedHash, 'hex')
-            );
-        } catch (error) {
-            return false;
-        }
-    }
-
-    async manualSync(connectionId) {
-        console.log(`🔄 Ручная синхронизация подключения ${connectionId}`);
-        await this.syncConnection(connectionId);
-    }
-
-    async checkConnection(connectionId) {
-        const connection = await this.getConnection(connectionId);
-        if (!connection) {
-            return { success: false, error: 'Подключение не найдено' };
-        }
-
-        const result = {
-            id: connection.id,
-            service_id: connection.service_id,
-            service_name: connection.service_name,
-            service_type: connection.service_type,
-            local_user_id: connection.local_user_id,
-            api_url: connection.api_url,
-            status: 'unknown'
-        };
-
-        if (connection.service_type === 'executor') {
-            if (!connection.api_url) {
-                result.status = 'error';
-                result.error = 'Не указан API URL организатора';
-                return result;
-            }
-
-            try {
-                const response = await axios.get(`${connection.api_url}/api/health`, {
-                    timeout: 5000,
-                    auth: {
-                        username: connection.login,
-                        password: connection.password
-                    }
-                });
-
-                result.status = 'connected';
-                result.organizer_status = response.data;
-                
-            } catch (error) {
-                result.status = 'disconnected';
-                result.error = error.message;
-                
-                if (error.code === 'ECONNREFUSED') {
-                    result.error_details = 'Организатор не доступен по указанному адресу';
-                } else if (error.response?.status === 401) {
-                    result.error_details = 'Ошибка аутентификации - проверьте логин/пароль';
-                } else if (error.response?.status === 404) {
-                    result.error_details = 'API организатора не найдено - проверьте URL';
-                } else {
-                    result.error_details = error.message;
-                }
-            }
-        } else {
-            const executors = await this.getAllConnections({
-                service_type: 'executor',
-                is_active: true
-            });
-            
-            result.executors_count = executors.length;
-            result.status = executors.length > 0 ? 'has_executors' : 'no_executors';
-        }
-
-        return result;
-    }
-
-    async getSyncStats() {
-        const connections = await this.getAllConnections({ is_active: true });
-        
-        const stats = {
-            total: connections.length,
-            organizers: 0,
-            executors: 0,
-            lastSyncs: [],
-            errors: []
-        };
-
-        connections.forEach(conn => {
-            if (conn.service_type === 'organizer') {
-                stats.organizers++;
-            } else {
-                stats.executors++;
-            }
-
-            if (conn.last_sync_at) {
-                stats.lastSyncs.push({
-                    service: conn.service_name,
-                    last_sync: conn.last_sync_at,
-                    status: conn.last_sync_status
-                });
-            }
-
-            if (conn.last_sync_error) {
-                stats.errors.push({
-                    service: conn.service_name,
-                    error: conn.last_sync_error,
-                    time: conn.last_sync_at
-                });
-            }
-        });
-
-        return stats;
-    }
-}
-
-function setupUpravlenieEndpoints(app, db) {
-    const upravlenieService = new UpravlenieService(db);
-
-    const requireAuth = (req, res, next) => {
-        if (!req.session || !req.session.user) {
-            return res.status(401).json({ error: 'Требуется аутентификация' });
-        }
-        next();
-    };
-
-    const requireAdmin = (req, res, next) => {
-        if (!req.session || !req.session.user) {
-            return res.status(401).json({ error: 'Требуется аутентификация' });
-        }
-        if (req.session.user.role !== 'admin') {
-            return res.status(403).json({ error: 'Требуются права администратора' });
-        }
-        next();
-    };
-
-    app.get('/api/upravlenie/connections', requireAdmin, async (req, res) => {
-        try {
-            const filters = {
-                service_type: req.query.service_type,
-                is_active: req.query.is_active !== undefined ? req.query.is_active === 'true' : undefined,
-                sync_enabled: req.query.sync_enabled !== undefined ? req.query.sync_enabled === 'true' : undefined
-            };
-            
-            const connections = await upravlenieService.getAllConnections(filters);
-            res.json(connections);
-        } catch (error) {
-            console.error('❌ Ошибка получения подключений:', error);
-            res.status(500).json({ error: error.message });
-        }
-    });
-
-    app.get('/api/upravlenie/connections/:id', requireAdmin, async (req, res) => {
-        try {
-            const connection = await upravlenieService.getConnection(req.params.id);
-            if (!connection) {
-                return res.status(404).json({ error: 'Подключение не найдено' });
-            }
-            res.json(connection);
-        } catch (error) {
-            res.status(500).json({ error: error.message });
-        }
-    });
-
-    app.post('/api/upravlenie/connections', requireAdmin, async (req, res) => {
-        try {
-            const connection = await upravlenieService.createConnection(req.body);
-            res.json({ 
-                success: true, 
-                message: 'Подключение создано',
-                connection: connection
-            });
-        } catch (error) {
-            console.error('❌ Ошибка создания подключения:', error);
-            res.status(400).json({ error: error.message });
-        }
-    });
-
-    app.put('/api/upravlenie/connections/:id', requireAdmin, async (req, res) => {
-        try {
-            const result = await upravlenieService.updateConnection(req.params.id, req.body);
-            res.json({ 
-                success: true, 
-                message: 'Подключение обновлено',
-                changes: result.changes
-            });
-        } catch (error) {
-            res.status(400).json({ error: error.message });
-        }
-    });
-
-    app.delete('/api/upravlenie/connections/:id', requireAdmin, async (req, res) => {
-        try {
-            await upravlenieService.deleteConnection(req.params.id);
-            res.json({ success: true, message: 'Подключение удалено' });
-        } catch (error) {
-            res.status(500).json({ error: error.message });
-        }
-    });
-
-    app.post('/api/upravlenie/connections/:id/sync', requireAdmin, async (req, res) => {
-        try {
-            await upravlenieService.manualSync(req.params.id);
-            res.json({ success: true, message: 'Синхронизация запущена' });
-        } catch (error) {
-            res.status(500).json({ error: error.message });
-        }
-    });
-
-    app.get('/api/upravlenie/check/:id', requireAdmin, async (req, res) => {
-        try {
-            const result = await upravlenieService.checkConnection(req.params.id);
-            res.json(result);
-        } catch (error) {
-            res.status(500).json({ error: error.message });
-        }
-    });
-
-    app.get('/api/upravlenie/stats', requireAdmin, async (req, res) => {
-        try {
-            const stats = await upravlenieService.getSyncStats();
-            res.json(stats);
-        } catch (error) {
-            res.status(500).json({ error: error.message });
-        }
-    });
-
-    const authenticateExternal = async (req, res, next) => {
-        const authHeader = req.headers.authorization;
-        
-        if (!authHeader || !authHeader.startsWith('Basic ')) {
-            return res.status(401).json({ error: 'Требуется базовая аутентификация' });
-        }
-
-        const base64Credentials = authHeader.split(' ')[1];
-        const credentials = Buffer.from(base64Credentials, 'base64').toString('ascii');
-        const [login, password] = credentials.split(':');
-
-        try {
-            const connection = await new Promise((resolve, reject) => {
-                db.get(
-                    'SELECT * FROM upravlenie WHERE login = ? AND password = ? AND is_active = 1',
-                    [login, password],
-                    (err, row) => {
-                        if (err) reject(err);
-                        else resolve(row);
-                    }
-                );
-            });
-
-            if (!connection) {
-                return res.status(401).json({ error: 'Неверные учетные данные' });
-            }
-
-            req.externalConnection = connection;
-            next();
-        } catch (error) {
-            console.error('❌ Ошибка аутентификации:', error);
-            res.status(500).json({ error: 'Ошибка аутентификации' });
-        }
-    };
-
-    app.get('/api/external/tasks', authenticateExternal, async (req, res) => {
-        try {
-            const { service_id, user_login } = req.query;
-            const connection = req.externalConnection;
-
-            if (parseInt(service_id) !== connection.service_id) {
-                return res.status(403).json({ error: 'Неверный service_id' });
-            }
-
-            let userId = null;
-            if (user_login) {
-                const user = await new Promise((resolve) => {
-                    db.get('SELECT id FROM users WHERE login = ?', [user_login], (err, row) => {
-                        resolve(row);
-                    });
-                });
-                userId = user?.id;
-            }
-
-            let tasks = [];
-            if (userId) {
-                tasks = await new Promise((resolve) => {
-                    db.all(`
-                        SELECT t.*, ta.status as assignment_status
-                        FROM tasks t
-                        JOIN task_assignments ta ON t.id = ta.task_id
-                        WHERE ta.user_id = ? AND t.status = 'active' AND t.closed_at IS NULL
-                    `, [userId], (err, rows) => {
-                        resolve(rows || []);
-                    });
-                });
-            } else {
-                tasks = await new Promise((resolve) => {
-                    db.all(`
-                        SELECT t.*, GROUP_CONCAT(ta.user_id) as assigned_users
-                        FROM tasks t
-                        LEFT JOIN task_assignments ta ON t.id = ta.task_id
-                        WHERE t.status = 'active' AND t.closed_at IS NULL
-                        GROUP BY t.id
-                    `, [], (err, rows) => {
-                        resolve(rows || []);
-                    });
-                });
-            }
-
-            res.json({
-                service_id: connection.service_id,
-                tasks: tasks.map(t => ({
-                    id: t.id,
-                    title: t.title,
-                    description: t.description,
-                    status: t.assignment_status || t.status,
-                    created_at: t.created_at,
-                    due_date: t.due_date,
-                    assigned_users: t.assigned_users
-                }))
-            });
-
-        } catch (error) {
-            console.error('❌ Ошибка получения внешних задач:', error);
-            res.status(500).json({ error: error.message });
-        }
-    });
-
-    app.post('/api/external/task-statuses', authenticateExternal, async (req, res) => {
-        try {
-            const { service_id, statuses } = req.body;
-            const connection = req.externalConnection;
-
-            if (parseInt(service_id) !== connection.service_id) {
-                return res.status(403).json({ error: 'Неверный service_id' });
-            }
-
-            if (!Array.isArray(statuses)) {
-                return res.status(400).json({ error: 'statuses должен быть массивом' });
-            }
-
-            for (const status of statuses) {
-                await new Promise((resolve, reject) => {
-                    db.run(
-                        `UPDATE task_assignments 
-                         SET status = ?, updated_at = CURRENT_TIMESTAMP
-                         WHERE task_id = ?`,
-                        [status.status, status.task_id],
-                        function(err) {
-                            if (err) reject(err);
-                            else resolve();
-                        }
-                    );
-                });
-
-                if (status.status === 'completed') {
-                    await checkAndCloseTaskIfAllCompleted(db, status.task_id);
-                }
-            }
-
-            res.json({ 
-                success: true, 
-                message: `Получено ${statuses.length} статусов`,
-                processed: statuses.length
-            });
-
-        } catch (error) {
-            console.error('❌ Ошибка получения статусов от исполнителя:', error);
-            res.status(500).json({ error: error.message });
-        }
-    });
-
-    app.get('/api/external/task-statuses', authenticateExternal, async (req, res) => {
-        try {
-            const { service_id } = req.query;
-            const connection = req.externalConnection;
-
-            if (parseInt(service_id) !== connection.service_id) {
-                return res.status(403).json({ error: 'Неверный service_id' });
-            }
-
-            const statuses = await new Promise((resolve) => {
-                db.all(`
-                    SELECT 
-                        t.id as task_id,
-                        t.external_task_id,
-                        ta.status,
-                        t.closed_at as completed_at,
-                        t.rework_comment as comment
-                    FROM tasks t
-                    JOIN task_assignments ta ON t.id = ta.task_id
-                    WHERE t.external_service_id = ?
-                `, [service_id], (err, rows) => {
-                    resolve(rows || []);
-                });
-            });
-
-            res.json({
-                service_id: connection.service_id,
-                statuses: statuses
-            });
-
-        } catch (error) {
-            console.error('❌ Ошибка получения статусов для организатора:', error);
-            res.status(500).json({ error: error.message });
-        }
-    });
-
-    app.post('/api/external/upload-file', authenticateExternal, async (req, res) => {
-        if (!req.files || !req.files.file) {
-            return res.status(400).json({ error: 'Файл не загружен' });
-        }
-
-        try {
-            const { task_id, service_id } = req.body;
-            const file = req.files.file;
-            const connection = req.externalConnection;
-
-            if (parseInt(service_id) !== connection.service_id) {
-                return res.status(403).json({ error: 'Неверный service_id' });
-            }
-
-            const { createUserTaskFolder } = require('./database');
-            const userFolder = createUserTaskFolder(task_id, connection.local_user_login || 'external');
-
-            const fileName = `${Date.now()}_${file.name}`;
-            const filePath = path.join(userFolder, fileName);
-
-            await file.mv(filePath);
-
-            const result = await new Promise((resolve, reject) => {
-                db.run(
-                    `INSERT INTO task_files (task_id, user_id, filename, original_name, file_path, file_size)
-                     VALUES (?, ?, ?, ?, ?, ?)`,
-                    [
-                        task_id,
-                        connection.local_user_id,
-                        fileName,
-                        file.name,
-                        filePath,
-                        file.size
-                    ],
-                    function(err) {
-                        if (err) reject(err);
-                        else resolve({ id: this.lastID });
-                    }
-                );
-            });
-
-            res.json({
-                success: true,
-                file_id: result.id,
-                message: 'Файл успешно загружен'
-            });
-
-        } catch (error) {
-            console.error('❌ Ошибка загрузки внешнего файла:', error);
-            res.status(500).json({ error: error.message });
-        }
-    });
-
-    app.get('/api/external/download-file/:fileId', authenticateExternal, async (req, res) => {
-        try {
-            const { fileId } = req.params;
-            const { service_id } = req.query;
-            const connection = req.externalConnection;
-
-            if (parseInt(service_id) !== connection.service_id) {
-                return res.status(403).json({ error: 'Неверный service_id' });
-            }
-
-            const file = await new Promise((resolve, reject) => {
-                db.get(
-                    'SELECT * FROM task_files WHERE id = ?',
-                    [fileId],
-                    (err, row) => {
-                        if (err) reject(err);
-                        else resolve(row);
-                    }
-                );
-            });
-
-            if (!file) {
-                return res.status(404).json({ error: 'Файл не найден' });
-            }
-
-            if (!fs.existsSync(file.file_path)) {
-                return res.status(404).json({ error: 'Файл не существует на диске' });
-            }
-
-            res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(file.original_name)}"`);
-            res.setHeader('X-File-Name', encodeURIComponent(file.original_name));
-            res.setHeader('Content-Type', 'application/octet-stream');
-            
-            fs.createReadStream(file.file_path).pipe(res);
-
-        } catch (error) {
-            console.error('❌ Ошибка скачивания файла:', error);
-            res.status(500).json({ error: error.message });
-        }
-    });
-
-    async function checkAndCloseTaskIfAllCompleted(db, taskId) {
-        return new Promise((resolve) => {
-            db.all(
-                'SELECT status FROM task_assignments WHERE task_id = ?',
-                [taskId],
-                (err, assignments) => {
-                    if (!err && assignments && assignments.length > 0) {
-                        const allCompleted = assignments.every(a => a.status === 'completed');
-                        
-                        if (allCompleted) {
-                            db.run(
-                                'UPDATE tasks SET closed_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
-                                [taskId],
-                                (err) => {
-                                    if (!err) {
-                                        console.log(`✅ Задача ${taskId} автоматически закрыта`);
-                                    }
-                                    resolve();
-                                }
-                            );
-                        } else {
-                            resolve();
-                        }
-                    } else {
-                        resolve();
-                    }
-                }
-            );
-        });
-    }
-
-    return upravlenieService;
-}
-
-module.exports = { 
-    UpravlenieService,
-    setupUpravlenieEndpoints,
-    TaskStatus,
-    SyncDirection
-};
\ No newline at end of file