%

auth.js

@@ -1,48 +1,70 @@
 const bcrypt = require('bcryptjs');
-const { db } = require('./database');
 const fetch = require('node-fetch');
 
 class AuthService {
     constructor() {
+        this.db = null;
+        this.initialized = false;
+    }
+
+    setDatabase(database) {
+        this.db = database;
+        this.initialized = true;
+        console.log('✅ База данных установлена в AuthService');
         this.initUsers();
     }
 
     async initUsers() {
-        // Создаем пользователей из .env
+        if (!this.db) {
-        const users = [
+            console.log('⚠️ База данных не установлена, откладываем создание пользователей');
-            {
+            return;
-                login: process.env.USER_1_LOGIN,
+        }
-                password: process.env.USER_1_PASSWORD,
-                name: process.env.USER_1_NAME,
-                email: process.env.USER_1_EMAIL,
-                auth_type: 'local'
-            },
-            {
-                login: process.env.USER_2_LOGIN,
-                password: process.env.USER_2_PASSWORD,
-                name: process.env.USER_2_NAME,
-                email: process.env.USER_2_EMAIL,
-                auth_type: 'local'
-            },
-            {
-                login: process.env.USER_3_LOGIN,
-                password: process.env.USER_3_PASSWORD,
-                name: process.env.USER_3_NAME,
-                email: process.env.USER_3_EMAIL,
-                auth_type: 'local'
-            }
-        ];
 
-        for (const userData of users) {
+        try {
-            if (userData.login && userData.password) {
+            // Создаем пользователей из .env
-                await this.createUserIfNotExists(userData);
+            const users = [
+                {
+                    login: process.env.USER_1_LOGIN,
+                    password: process.env.USER_1_PASSWORD,
+                    name: process.env.USER_1_NAME,
+                    email: process.env.USER_1_EMAIL,
+                    auth_type: 'local'
+                },
+                {
+                    login: process.env.USER_2_LOGIN,
+                    password: process.env.USER_2_PASSWORD,
+                    name: process.env.USER_2_NAME,
+                    email: process.env.USER_2_EMAIL,
+                    auth_type: 'local'
+                },
+                {
+                    login: process.env.USER_3_LOGIN,
+                    password: process.env.USER_3_PASSWORD,
+                    name: process.env.USER_3_NAME,
+                    email: process.env.USER_3_EMAIL,
+                    auth_type: 'local'
+                }
+            ];
+
+            for (const userData of users) {
+                if (userData.login && userData.password) {
+                    await this.createUserIfNotExists(userData);
+                }
             }
+        } catch (error) {
+            console.error('❌ Ошибка инициализации пользователей:', error.message);
         }
     }
 
     async createUserIfNotExists(userData) {
         return new Promise((resolve, reject) => {
-            db.get("SELECT id FROM users WHERE login = ?", [userData.login], async (err, row) => {
+            if (!this.db) {
+                console.error('❌ База данных не доступна в createUserIfNotExists');
+                reject(new Error('База данных не инициализирована'));
+                return;
+            }
+
+            this.db.get("SELECT id FROM users WHERE login = ?", [userData.login], async (err, row) => {
                 if (err) {
                     reject(err);
                     return;
@@ -50,7 +72,7 @@ class AuthService {
 
                 if (!row) {
                     const hashedPassword = await bcrypt.hash(userData.password, 10);
-                    db.run(
+                    this.db.run(
                         "INSERT INTO users (login, password, name, email, role, auth_type, created_at) VALUES (?, ?, ?, ?, ?, ?, datetime('now'))",
                         [
                             userData.login, 
@@ -64,7 +86,7 @@ class AuthService {
                             if (err) {
                                 reject(err);
                             } else {
-                                console.log(`Создан пользователь: ${userData.name}`);
+                                console.log(`✅ Создан пользователь: ${userData.name}`);
                                 resolve(this.lastID);
                             }
                         }
@@ -77,8 +99,12 @@ class AuthService {
     }
 
     async authenticateLocal(login, password) {
+        if (!this.db) {
+            throw new Error('База данных не инициализирована в AuthService');
+        }
+
         return new Promise((resolve, reject) => {
-            db.get("SELECT * FROM users WHERE login = ? AND auth_type = 'local'", [login], async (err, user) => {
+            this.db.get("SELECT * FROM users WHERE login = ? AND auth_type = 'local'", [login], async (err, user) => {
                 if (err) {
                     reject(err);
                     return;
@@ -89,158 +115,193 @@ class AuthService {
                     return;
                 }
 
-                const isValid = await bcrypt.compare(password, user.password);
+                try {
-                if (isValid) {
+                    const isValid = await bcrypt.compare(password, user.password);
-                    // Обновляем last_login
+                    if (isValid) {
-                    db.run("UPDATE users SET last_login = datetime('now') WHERE id = ?", [user.id]);
+                        // Обновляем last_login
-                    
+                        this.db.run("UPDATE users SET last_login = datetime('now') WHERE id = ?", [user.id]);
-                    // Не возвращаем пароль
+                        
-                    const { password, ...userWithoutPassword } = user;
+                        // Не возвращаем пароль
-                    resolve(userWithoutPassword);
+                        const { password, ...userWithoutPassword } = user;
-                } else {
+                        resolve(userWithoutPassword);
-                    resolve(null);
+                    } else {
+                        resolve(null);
+                    }
+                } catch (error) {
+                    reject(error);
                 }
             });
         });
     }
 
-async authenticateLDAP(username, password) {
+    async authenticateLDAP(username, password) {
-    try {
+        if (!this.db) {
-        const response = await fetch(process.env.LDAP_AUTH_URL, {
+            throw new Error('База данных не инициализирована в AuthService');
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({ username, password })
-        });
-
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
         }
 
-        const data = await response.json();
+        try {
-        
+            // Проверяем наличие URL для LDAP
-        if (data.success) {
+            if (!process.env.LDAP_AUTH_URL) {
-            return this.processLDAPUser(data);
+                console.log('⚠️ LDAP_AUTH_URL не задан в .env');
-        } else {
+                return null;
+            }
+
+            const response = await fetch(process.env.LDAP_AUTH_URL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ username, password })
+            });
+
+            if (!response.ok) {
+                console.log(`⚠️ LDAP сервер вернул ошибку: ${response.status}`);
+                return null;
+            }
+
+            const data = await response.json();
+            
+            if (data.success) {
+                return this.processLDAPUser(data);
+            } else {
+                return null;
+            }
+        } catch (error) {
+            console.error('❌ Ошибка LDAP аутентификации:', error.message);
             return null;
         }
-    } catch (error) {
-        console.error('LDAP authentication error:', error);
-        return null;
     }
-}
 
-async processLDAPUser(ldapData) {
+    async processLDAPUser(ldapData) {
-    const { username, full_name, groups, description } = ldapData;
+        if (!this.db) {
-    
+            throw new Error('База данных не инициализирована в AuthService');
-    // Определяем роль пользователя на основе групп
+        }
-    const allowedGroups = process.env.ALLOWED_GROUPS ? 
-        process.env.ALLOWED_GROUPS.split(',').map(g => g.trim()) : [];
-    
-    // ВАЖНО: Проверяем актуальные группы при каждом входе
-    const isAdmin = groups && groups.some(group => 
-        allowedGroups.includes(group)
-    );
-    
-    const role = isAdmin ? 'admin' : 'teacher';
-    
-    // Сохраняем/обновляем пользователя в базе
-    return new Promise((resolve, reject) => {
-        db.get("SELECT * FROM users WHERE login = ? AND auth_type = 'ldap'", [username], async (err, existingUser) => {
-            if (err) {
-                reject(err);
-                return;
-            }
 
-            const userData = {
+        const { username, full_name, groups, description } = ldapData;
-                login: username,
+        
-                name: full_name || username,
+        // Определяем роль пользователя на основе групп
-                email: `${username}@school25.ru`,
+        const allowedGroups = process.env.ALLOWED_GROUPS ? 
-                role: role, // Всегда обновляем роль из актуальных групп
+            process.env.ALLOWED_GROUPS.split(',').map(g => g.trim()) : [];
-                auth_type: 'ldap',
+        
-                groups: groups ? JSON.stringify(groups) : '[]',
+        // ВАЖНО: Проверяем актуальные группы при каждом входе
-                description: description || '',
+        const isAdmin = groups && groups.some(group => 
-                last_login: new Date().toISOString()
+            allowedGroups.includes(group)
-            };
+        );
+        
+        const role = isAdmin ? 'admin' : 'teacher';
+        
+        // Сохраняем/обновляем пользователя в базе
+        return new Promise((resolve, reject) => {
+            this.db.get("SELECT * FROM users WHERE login = ? AND auth_type = 'ldap'", [username], async (err, existingUser) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
 
-            if (existingUser) {
+                const userData = {
-                // Всегда обновляем роль, даже если пользователь уже существует
+                    login: username,
-                db.run(
+                    name: full_name || username,
-                    `UPDATE users SET 
+                    email: `${username}@school25.ru`,
-                     name = ?, email = ?, role = ?, groups = ?, description = ?, last_login = datetime('now'),
+                    role: role, // Всегда обновляем роль из актуальных групп
-                     updated_at = datetime('now')
+                    auth_type: 'ldap',
-                     WHERE id = ?`,
+                    groups: groups ? JSON.stringify(groups) : '[]',
-                    [userData.name, userData.email, userData.role, userData.groups, userData.description, existingUser.id],
+                    description: description || '',
-                    function(err) {
+                    last_login: new Date().toISOString()
-                        if (err) {
+                };
-                            reject(err);
+
-                        } else {
+                if (existingUser) {
-                            console.log(`Обновлены данные LDAP пользователя ${username}. Роль: ${userData.role}, Группы: ${groups}`);
+                    // Всегда обновляем роль, даже если пользователь уже существует
-                            resolve({ 
+                    this.db.run(
-                                id: existingUser.id,
+                        `UPDATE users SET 
-                                login: userData.login,
+                         name = ?, email = ?, role = ?, groups = ?, description = ?, last_login = datetime('now'),
-                                name: userData.name,
+                         updated_at = datetime('now')
-                                email: userData.email,
+                         WHERE id = ?`,
-                                role: userData.role,
+                        [userData.name, userData.email, userData.role, userData.groups, userData.description, existingUser.id],
-                                auth_type: userData.auth_type,
+                        function(err) {
-                                groups: userData.groups,
+                            if (err) {
-                                description: userData.description,
+                                reject(err);
-                                last_login: new Date().toISOString()
+                            } else {
-                            });
+                                console.log(`✅ Обновлены данные LDAP пользователя ${username}. Роль: ${userData.role}, Группы: ${groups}`);
+                                resolve({ 
+                                    id: existingUser.id,
+                                    login: userData.login,
+                                    name: userData.name,
+                                    email: userData.email,
+                                    role: userData.role,
+                                    auth_type: userData.auth_type,
+                                    groups: userData.groups,
+                                    description: userData.description,
+                                    last_login: new Date().toISOString()
+                                });
+                            }
                         }
-                    }
+                    );
-                );
+                } else {
-            } else {
+                    // Создаем нового пользователя
-                // Создаем нового пользователя
+                    this.db.run(
-                db.run(
+                        `INSERT INTO users (login, name, email, role, auth_type, groups, description, created_at, last_login) 
-                    `INSERT INTO users (login, name, email, role, auth_type, groups, description, created_at, last_login) 
+                         VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))`,
-                     VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))`,
+                        [userData.login, userData.name, userData.email, userData.role, userData.auth_type, 
-                    [userData.login, userData.name, userData.email, userData.role, userData.auth_type, 
+                         userData.groups, userData.description],
-                     userData.groups, userData.description],
+                        function(err) {
-                    function(err) {
+                            if (err) {
-                        if (err) {
+                                reject(err);
-                            reject(err);
+                            } else {
-                        } else {
+                                console.log(`✅ Создан новый LDAP пользователь ${username}. Роль: ${userData.role}, Группы: ${groups}`);
-                            console.log(`Создан новый LDAP пользователь ${username}. Роль: ${userData.role}, Группы: ${groups}`);
+                                resolve({
-                            resolve({
+                                    id: this.lastID,
-                                id: this.lastID,
+                                    login: userData.login,
-                                login: userData.login,
+                                    name: userData.name,
-                                name: userData.name,
+                                    email: userData.email,
-                                email: userData.email,
+                                    role: userData.role,
-                                role: userData.role,
+                                    auth_type: userData.auth_type,
-                                auth_type: userData.auth_type,
+                                    groups: userData.groups,
-                                groups: userData.groups,
+                                    description: userData.description,
-                                description: userData.description,
+                                    last_login: new Date().toISOString()
-                                last_login: new Date().toISOString()
+                                });
-                            });
+                            }
                         }
-                    }
+                    );
-                );
+                }
-            }
+            });
         });
-    });
+    }
-}
 
     async authenticate(login, password) {
+        if (!this.db) {
+            throw new Error('База данных не инициализирована в AuthService');
+        }
+
         // Сначала пробуем локальную авторизацию
-        const localUser = await this.authenticateLocal(login, password);
+        try {
-        if (localUser) {
+            const localUser = await this.authenticateLocal(login, password);
-            return localUser;
+            if (localUser) {
+                return localUser;
+            }
+        } catch (error) {
+            console.error('Ошибка локальной аутентификации:', error.message);
         }
 
         // Если локальная не сработала, пробуем LDAP
-        const ldapUser = await this.authenticateLDAP(login, password);
+        try {
-        if (ldapUser) {
+            const ldapUser = await this.authenticateLDAP(login, password);
-            return ldapUser;
+            if (ldapUser) {
+                return ldapUser;
+            }
+        } catch (error) {
+            console.error('Ошибка LDAP аутентификации:', error.message);
         }
 
         return null;
     }
 
     getUserById(id) {
+        if (!this.db) {
+            throw new Error('База данных не инициализирована в AuthService');
+        }
+
         return new Promise((resolve, reject) => {
-            db.get("SELECT id, login, name, email, role, auth_type, groups, description, last_login FROM users WHERE id = ?", [id], (err, user) => {
+            this.db.get("SELECT id, login, name, email, role, auth_type, groups, description, last_login FROM users WHERE id = ?", [id], (err, user) => {
                 if (err) {
                     reject(err);
                 } else {
@@ -249,6 +310,14 @@ async processLDAPUser(ldapData) {
             });
         });
     }
+
+    // Метод для проверки готовности сервиса
+    isReady() {
+        return this.db !== null;
+    }
 }
 
-module.exports = new AuthService();
+// Создаем singleton экземпляр
+const authService = new AuthService();
+
+module.exports = authService;

database.js

@@ -1,8 +1,15 @@
 const sqlite3 = require('sqlite3').verbose();
+const { Pool } = require('pg');
 const path = require('path');
 const fs = require('fs');
 require('dotenv').config();
 
+// Определяем, какую базу использовать
+const USE_POSTGRES = process.env.POSTGRESQL === 'yes';
+let db = null; // Основной объект базы данных
+let postgresPool = null; // Пул соединений PostgreSQL
+let isInitialized = false; // Флаг инициализации
+
 const dataDir = path.join(__dirname, 'data');
 const createDirIfNotExists = (dirPath) => {
     if (!fs.existsSync(dirPath)) {
@@ -21,17 +28,72 @@ createDirIfNotExists(uploadsDir);
 createDirIfNotExists(tasksDir);
 createDirIfNotExists(logsDir);
 
-const db = new sqlite3.Database(dbPath, (err) => {
+// Инициализация базы данных
-    if (err) {
+async function initializeDatabase() {
-        console.error('Ошибка подключения к БД:', err.message);
+    console.log(`🔧 Используется ${USE_POSTGRES ? 'PostgreSQL' : 'SQLite'}`);
-    } else {
+    
-        console.log('Подключение к SQLite установлено');
+    if (USE_POSTGRES) {
-        console.log('База данных расположена:', dbPath);
+        // Используем PostgreSQL
-        initializeDatabase();
+        try {
-    }
+            postgresPool = new Pool({
-});
+                host: process.env.DB_HOST,
+                port: process.env.DB_PORT || 5432,
+                database: process.env.DB_NAME || 'minicrm',
+                user: process.env.DB_USER,
+                password: process.env.DB_PASSWORD,
+                max: 10,
+                idleTimeoutMillis: 30000,
+                connectionTimeoutMillis: 5000,
+            });
 
-function initializeDatabase() {
+            // Тестируем подключение
+            const client = await postgresPool.connect();
+            await client.query('SELECT 1');
+            client.release();
+            
+            console.log('✅ Подключение к PostgreSQL установлено');
+            
+            // Создаем адаптер для PostgreSQL
+            db = createPostgresAdapter(postgresPool);
+            
+            // Проверяем и создаем таблицы
+            await createPostgresTables();
+            
+            isInitialized = true;
+            
+        } catch (error) {
+            console.error('❌ Ошибка подключения к PostgreSQL:', error.message);
+            console.log('🔄 Пытаемся использовать SQLite как запасной вариант...');
+            await initializeSQLite();
+        }
+    } else {
+        // Используем SQLite
+        await initializeSQLite();
+    }
+    
+    return db;
+}
+
+function initializeSQLite() {
+    return new Promise((resolve, reject) => {
+        db = new sqlite3.Database(dbPath, (err) => {
+            if (err) {
+                console.error('❌ Ошибка подключения к SQLite:', err.message);
+                reject(err);
+                return;
+            } else {
+                console.log('✅ Подключение к SQLite установлено');
+                console.log('📁 База данных расположена:', dbPath);
+                createSQLiteTables();
+                isInitialized = true;
+                resolve(db);
+            }
+        });
+    });
+}
+
+function createSQLiteTables() {
+    // SQLite таблицы
     db.run(`CREATE TABLE IF NOT EXISTS users (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         login TEXT UNIQUE NOT NULL,
@@ -113,11 +175,260 @@ function initializeDatabase() {
         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
     )`);
 
-    console.log('База данных инициализирована в папке data');
+    console.log('✅ База данных SQLite инициализирована');
-    
     setTimeout(addMissingColumns, 1000);
 }
 
+function createPostgresAdapter(pool) {
+    // Адаптер для PostgreSQL с совместимым API
+    return {
+        all: (sql, params = [], callback) => {
+            if (!callback && typeof params === 'function') {
+                callback = params;
+                params = [];
+            }
+            
+            // Адаптируем SQL для PostgreSQL
+            const adaptedSql = adaptSQLForPostgres(sql);
+            
+            pool.query(adaptedSql, params)
+                .then(result => callback(null, result.rows))
+                .catch(err => {
+                    console.error('PostgreSQL Error (all):', err.message, 'SQL:', adaptedSql);
+                    callback(err);
+                });
+        },
+        
+        get: (sql, params = [], callback) => {
+            if (!callback && typeof params === 'function') {
+                callback = params;
+                params = [];
+            }
+            
+            // Адаптируем SQL для PostgreSQL
+            const adaptedSql = adaptSQLForPostgres(sql);
+            
+            pool.query(adaptedSql, params)
+                .then(result => callback(null, result.rows[0] || null))
+                .catch(err => {
+                    console.error('PostgreSQL Error (get):', err.message, 'SQL:', adaptedSql);
+                    callback(err);
+                });
+        },
+        
+        run: (sql, params = [], callback) => {
+            if (!callback && typeof params === 'function') {
+                callback = params;
+                params = [];
+            }
+            
+            // Адаптируем SQL для PostgreSQL
+            const adaptedSql = adaptSQLForPostgres(sql);
+            
+            pool.query(adaptedSql, params)
+                .then(result => {
+                    if (callback) {
+                        const lastIdQuery = sql.toLowerCase().includes('insert into') ? 
+                            "SELECT lastval() as last_id" : "SELECT 0 as last_id";
+                        
+                        if (sql.toLowerCase().includes('insert into')) {
+                            pool.query("SELECT lastval() as last_id", [])
+                                .then(lastIdResult => {
+                                    callback(null, {
+                                        lastID: lastIdResult.rows[0]?.last_id || null,
+                                        changes: result.rowCount || 0
+                                    });
+                                })
+                                .catch(err => callback(err));
+                        } else {
+                            callback(null, {
+                                lastID: null,
+                                changes: result.rowCount || 0
+                            });
+                        }
+                    }
+                })
+                .catch(err => {
+                    console.error('PostgreSQL Error (run):', err.message, 'SQL:', adaptedSql);
+                    if (callback) callback(err);
+                });
+        },
+        
+        // Для транзакций - эмуляция
+        serialize: (callback) => {
+            // В PostgreSQL транзакции обрабатываются по-другому
+            // Здесь просто выполняем колбэк
+            try {
+                callback();
+            } catch (error) {
+                console.error('Error in serialize:', error);
+            }
+        },
+        
+        // Закрытие соединения
+        close: (callback) => {
+            pool.end()
+                .then(() => {
+                    if (callback) callback(null);
+                })
+                .catch(err => {
+                    if (callback) callback(err);
+                });
+        },
+        
+        // Дополнительные методы
+        exec: (sql, callback) => {
+            pool.query(sql)
+                .then(() => {
+                    if (callback) callback(null);
+                })
+                .catch(err => {
+                    if (callback) callback(err);
+                });
+        }
+    };
+}
+
+function adaptSQLForPostgres(sql) {
+    // Адаптируем SQL запросы для PostgreSQL
+    let adaptedSql = sql;
+    
+    // Заменяем SQLite-специфичные синтаксисы
+    adaptedSql = adaptedSql.replace(/AUTOINCREMENT/gi, 'SERIAL');
+    adaptedSql = adaptedSql.replace(/DATETIME/gi, 'TIMESTAMP');
+    adaptedSql = adaptedSql.replace(/INTEGER PRIMARY KEY/gi, 'SERIAL PRIMARY KEY');
+    adaptedSql = adaptedSql.replace(/datetime\('now'\)/gi, 'CURRENT_TIMESTAMP');
+    adaptedSql = adaptedSql.replace(/CURRENT_TIMESTAMP/gi, 'CURRENT_TIMESTAMP');
+    
+    // Исправляем INSERT с возвратом ID
+    if (adaptedSql.includes('INSERT INTO') && adaptedSql.includes('RETURNING id')) {
+        adaptedSql = adaptedSql.replace('RETURNING id', 'RETURNING id');
+    }
+    
+    return adaptedSql;
+}
+
+async function createPostgresTables() {
+    if (!USE_POSTGRES) return;
+    
+    try {
+        const client = await postgresPool.connect();
+        
+        console.log('🔧 Проверяем/создаем таблицы в PostgreSQL...');
+        
+        // Создаем таблицы PostgreSQL
+        await client.query(`
+            CREATE TABLE IF NOT EXISTS users (
+                id SERIAL PRIMARY KEY,
+                login VARCHAR(100) UNIQUE NOT NULL,
+                password TEXT,
+                name VARCHAR(255) NOT NULL,
+                email VARCHAR(255) UNIQUE NOT NULL,
+                role VARCHAR(50) DEFAULT 'teacher',
+                auth_type VARCHAR(50) DEFAULT 'local',
+                groups TEXT DEFAULT '[]',
+                description TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                last_login TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        
+        await client.query(`
+            CREATE TABLE IF NOT EXISTS tasks (
+                id SERIAL PRIMARY KEY,
+                title VARCHAR(500) NOT NULL,
+                description TEXT,
+                status VARCHAR(50) DEFAULT 'active',
+                created_by INTEGER NOT NULL REFERENCES users(id),
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                deleted_at TIMESTAMP,
+                deleted_by INTEGER REFERENCES users(id),
+                original_task_id INTEGER REFERENCES tasks(id),
+                start_date TIMESTAMP,
+                due_date TIMESTAMP,
+                rework_comment TEXT,
+                closed_at TIMESTAMP,
+                closed_by INTEGER REFERENCES users(id)
+            )
+        `);
+        
+        await client.query(`
+            CREATE TABLE IF NOT EXISTS task_assignments (
+                id SERIAL PRIMARY KEY,
+                task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+                user_id INTEGER NOT NULL REFERENCES users(id),
+                status VARCHAR(50) DEFAULT 'assigned',
+                start_date TIMESTAMP,
+                due_date TIMESTAMP,
+                rework_comment TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        
+        await client.query(`
+            CREATE TABLE IF NOT EXISTS task_files (
+                id SERIAL PRIMARY KEY,
+                task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+                user_id INTEGER NOT NULL REFERENCES users(id),
+                filename VARCHAR(255) NOT NULL,
+                original_name VARCHAR(500) NOT NULL,
+                file_path TEXT NOT NULL,
+                file_size BIGINT NOT NULL,
+                uploaded_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        
+        await client.query(`
+            CREATE TABLE IF NOT EXISTS activity_logs (
+                id SERIAL PRIMARY KEY,
+                task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+                user_id INTEGER NOT NULL REFERENCES users(id),
+                action VARCHAR(100) NOT NULL,
+                details TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        
+        await client.query(`
+            CREATE TABLE IF NOT EXISTS notification_logs (
+                id SERIAL PRIMARY KEY,
+                notification_key VARCHAR(500) NOT NULL,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        
+        // Создаем индексы
+        const indexes = [
+            'CREATE INDEX IF NOT EXISTS idx_tasks_created_by ON tasks(created_by)',
+            'CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)',
+            'CREATE INDEX IF NOT EXISTS idx_tasks_closed_at ON tasks(closed_at)',
+            'CREATE INDEX IF NOT EXISTS idx_task_assignments_task_id ON task_assignments(task_id)',
+            'CREATE INDEX IF NOT EXISTS idx_task_assignments_user_id ON task_assignments(user_id)',
+            'CREATE INDEX IF NOT EXISTS idx_task_assignments_status ON task_assignments(status)',
+            'CREATE INDEX IF NOT EXISTS idx_task_files_task_id ON task_files(task_id)',
+            'CREATE INDEX IF NOT EXISTS idx_activity_logs_task_id ON activity_logs(task_id)',
+            'CREATE INDEX IF NOT EXISTS idx_activity_logs_created_at ON activity_logs(created_at)'
+        ];
+        
+        for (const indexQuery of indexes) {
+            try {
+                await client.query(indexQuery);
+            } catch (err) {
+                console.warn(`⚠️ Не удалось создать индекс: ${err.message}`);
+            }
+        }
+        
+        client.release();
+        console.log('✅ Таблицы PostgreSQL проверены/созданы');
+        
+    } catch (error) {
+        console.error('❌ Ошибка создания таблиц PostgreSQL:', error.message);
+    }
+}
+
 function addMissingColumns() {
     const columnsToAdd = [
         { table: 'tasks', column: 'rework_comment', type: 'TEXT' },
@@ -272,11 +583,25 @@ function checkOverdueTasks() {
 setInterval(checkOverdueTasks, 60000);
 
 module.exports = { 
-    db, 
+    initializeDatabase, // Экспортируем функцию инициализации
+    getDb: () => {
+        if (!isInitialized) {
+            throw new Error('База данных не инициализирована');
+        }
+        return db;
+    },
+    isInitialized: () => isInitialized,
     logActivity, 
     createTaskFolder, 
     createUserTaskFolder, 
     saveTaskMetadata, 
     updateTaskMetadata,
-    checkTaskAccess
+    checkTaskAccess,
-};
+    USE_POSTGRES,
+    getDatabaseType: () => USE_POSTGRES ? 'PostgreSQL' : 'SQLite'
+};
+
+// Запускаем инициализацию при экспорте (но она завершится позже)
+initializeDatabase().catch(err => {
+    console.error('❌ Ошибка инициализации базы данных:', err.message);
+});

migrate.js

@@ -0,0 +1,483 @@
+
+const sqlite3 = require('sqlite3').verbose();
+const { Pool } = require('pg');
+const path = require('path');
+const fs = require('fs');
+require('dotenv').config();
+
+async function migrateToPostgres() {
+    console.log('🚀 Начинаем миграцию данных из SQLite в PostgreSQL...');
+    
+    // Проверяем существование SQLite базы
+    const sqlitePath = path.join(__dirname, 'data', 'school_crm.db');
+    if (!fs.existsSync(sqlitePath)) {
+        console.error('❌ Файл SQLite базы не найден:', sqlitePath);
+        process.exit(1);
+    }
+    
+    // Подключаемся к SQLite
+    const sqliteDb = new sqlite3.Database(sqlitePath, (err) => {
+        if (err) {
+            console.error('❌ Ошибка подключения к SQLite:', err.message);
+            process.exit(1);
+        }
+    });
+    
+    console.log('✅ SQLite база найдена и подключена');
+    
+    // Проверяем настройки PostgreSQL
+    if (!process.env.DB_HOST || !process.env.DB_USER || !process.env.DB_PASSWORD) {
+        console.error('❌ Настройки PostgreSQL не указаны в .env файле');
+        console.error('   Укажите DB_HOST, DB_USER, DB_PASSWORD');
+        process.exit(1);
+    }
+    
+    // Подключаемся к PostgreSQL
+    const pgPool = new Pool({
+        host: process.env.DB_HOST,
+        port: process.env.DB_PORT || 5432,
+        database: process.env.DB_NAME || 'minicrm',
+        user: process.env.DB_USER,
+        password: process.env.DB_PASSWORD,
+        max: 5,
+        idleTimeoutMillis: 30000,
+        connectionTimeoutMillis: 10000,
+    });
+    
+    let client;
+    try {
+        console.log('🔌 Подключаемся к PostgreSQL...');
+        client = await pgPool.connect();
+        console.log('✅ Подключение к PostgreSQL установлено');
+        
+        // Создаем таблицы в PostgreSQL если их нет
+        console.log('🔧 Создаем/проверяем таблицы в PostgreSQL...');
+        await createPostgresTables(client);
+        
+        // Отключаем foreign key constraints для упрощения миграции
+        await client.query('SET session_replication_role = replica;');
+        
+        // Мигрируем таблицу users
+        console.log('📦 Мигрируем таблицу users...');
+        const users = await new Promise((resolve, reject) => {
+            sqliteDb.all('SELECT * FROM users ORDER BY id', [], (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows);
+            });
+        });
+        
+        if (users.length > 0) {
+            let migratedUsers = 0;
+            for (const user of users) {
+                try {
+                    await client.query(`
+                        INSERT INTO users (id, login, password, name, email, role, auth_type, 
+                                          groups, description, created_at, last_login, updated_at)
+                        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+                        ON CONFLICT (id) DO UPDATE SET
+                            login = EXCLUDED.login,
+                            name = EXCLUDED.name,
+                            email = EXCLUDED.email,
+                            role = EXCLUDED.role,
+                            auth_type = EXCLUDED.auth_type,
+                            groups = EXCLUDED.groups,
+                            description = EXCLUDED.description,
+                            last_login = EXCLUDED.last_login,
+                            updated_at = EXCLUDED.updated_at
+                    `, [
+                        user.id,
+                        user.login,
+                        user.password || null,
+                        user.name,
+                        user.email,
+                        user.role || 'teacher',
+                        user.auth_type || 'local',
+                        user.groups || '[]',
+                        user.description || '',
+                        user.created_at,
+                        user.last_login,
+                        user.updated_at || user.created_at
+                    ]);
+                    migratedUsers++;
+                } catch (error) {
+                    console.error(`   Ошибка при миграции пользователя ${user.id}:`, error.message);
+                }
+            }
+            console.log(`✅ Мигрировано ${migratedUsers} из ${users.length} пользователей`);
+        } else {
+            console.log('ℹ️  В таблице users нет данных для миграции');
+        }
+        
+        // Мигрируем таблицу tasks
+        console.log('📦 Мигрируем таблицу tasks...');
+        const tasks = await new Promise((resolve, reject) => {
+            sqliteDb.all('SELECT * FROM tasks ORDER BY id', [], (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows);
+            });
+        });
+        
+        if (tasks.length > 0) {
+            let migratedTasks = 0;
+            for (const task of tasks) {
+                try {
+                    await client.query(`
+                        INSERT INTO tasks (id, title, description, status, created_by, created_at, 
+                                         updated_at, deleted_at, deleted_by, original_task_id,
+                                         start_date, due_date, rework_comment, closed_at, closed_by)
+                        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
+                        ON CONFLICT (id) DO UPDATE SET
+                            title = EXCLUDED.title,
+                            description = EXCLUDED.description,
+                            status = EXCLUDED.status,
+                            created_by = EXCLUDED.created_by,
+                            updated_at = EXCLUDED.updated_at,
+                            deleted_at = EXCLUDED.deleted_at,
+                            deleted_by = EXCLUDED.deleted_by,
+                            original_task_id = EXCLUDED.original_task_id,
+                            start_date = EXCLUDED.start_date,
+                            due_date = EXCLUDED.due_date,
+                            rework_comment = EXCLUDED.rework_comment,
+                            closed_at = EXCLUDED.closed_at,
+                            closed_by = EXCLUDED.closed_by
+                    `, [
+                        task.id,
+                        task.title,
+                        task.description || '',
+                        task.status || 'active',
+                        task.created_by,
+                        task.created_at,
+                        task.updated_at || task.created_at,
+                        task.deleted_at,
+                        task.deleted_by,
+                        task.original_task_id,
+                        task.start_date,
+                        task.due_date,
+                        task.rework_comment,
+                        task.closed_at,
+                        task.closed_by
+                    ]);
+                    migratedTasks++;
+                } catch (error) {
+                    console.error(`   Ошибка при миграции задачи ${task.id}:`, error.message);
+                }
+            }
+            console.log(`✅ Мигрировано ${migratedTasks} из ${tasks.length} задач`);
+        } else {
+            console.log('ℹ️  В таблице tasks нет данных для миграции');
+        }
+        
+        // Мигрируем таблицу task_assignments
+        console.log('📦 Мигрируем таблицу task_assignments...');
+        const assignments = await new Promise((resolve, reject) => {
+            sqliteDb.all('SELECT * FROM task_assignments ORDER BY id', [], (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows);
+            });
+        });
+        
+        if (assignments.length > 0) {
+            let migratedAssignments = 0;
+            for (const assignment of assignments) {
+                try {
+                    await client.query(`
+                        INSERT INTO task_assignments (id, task_id, user_id, status, start_date, 
+                                                    due_date, rework_comment, created_at, updated_at)
+                        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+                        ON CONFLICT (id) DO UPDATE SET
+                            task_id = EXCLUDED.task_id,
+                            user_id = EXCLUDED.user_id,
+                            status = EXCLUDED.status,
+                            start_date = EXCLUDED.start_date,
+                            due_date = EXCLUDED.due_date,
+                            rework_comment = EXCLUDED.rework_comment,
+                            updated_at = EXCLUDED.updated_at
+                    `, [
+                        assignment.id,
+                        assignment.task_id,
+                        assignment.user_id,
+                        assignment.status || 'assigned',
+                        assignment.start_date,
+                        assignment.due_date,
+                        assignment.rework_comment,
+                        assignment.created_at,
+                        assignment.updated_at || assignment.created_at
+                    ]);
+                    migratedAssignments++;
+                } catch (error) {
+                    console.error(`   Ошибка при миграции назначения ${assignment.id}:`, error.message);
+                }
+            }
+            console.log(`✅ Мигрировано ${migratedAssignments} из ${assignments.length} назначений`);
+        } else {
+            console.log('ℹ️  В таблице task_assignments нет данных для миграции');
+        }
+        
+        // Мигрируем таблицу task_files
+        console.log('📦 Мигрируем таблицу task_files...');
+        const files = await new Promise((resolve, reject) => {
+            sqliteDb.all('SELECT * FROM task_files ORDER BY id', [], (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows);
+            });
+        });
+        
+        if (files.length > 0) {
+            let migratedFiles = 0;
+            for (const file of files) {
+                try {
+                    await client.query(`
+                        INSERT INTO task_files (id, task_id, user_id, filename, original_name, 
+                                              file_path, file_size, uploaded_at)
+                        VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+                        ON CONFLICT (id) DO UPDATE SET
+                            task_id = EXCLUDED.task_id,
+                            user_id = EXCLUDED.user_id,
+                            filename = EXCLUDED.filename,
+                            original_name = EXCLUDED.original_name,
+                            file_path = EXCLUDED.file_path,
+                            file_size = EXCLUDED.file_size
+                    `, [
+                        file.id,
+                        file.task_id,
+                        file.user_id,
+                        file.filename,
+                        file.original_name,
+                        file.file_path,
+                        file.file_size,
+                        file.uploaded_at
+                    ]);
+                    migratedFiles++;
+                } catch (error) {
+                    console.error(`   Ошибка при миграции файла ${file.id}:`, error.message);
+                }
+            }
+            console.log(`✅ Мигрировано ${migratedFiles} из ${files.length} файлов`);
+        } else {
+            console.log('ℹ️  В таблице task_files нет данных для миграции');
+        }
+        
+        // Мигрируем таблицу activity_logs
+        console.log('📦 Мигрируем таблицу activity_logs...');
+        const logs = await new Promise((resolve, reject) => {
+            sqliteDb.all('SELECT * FROM activity_logs ORDER BY id', [], (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows);
+            });
+        });
+        
+        if (logs.length > 0) {
+            let migratedLogs = 0;
+            for (const log of logs) {
+                try {
+                    await client.query(`
+                        INSERT INTO activity_logs (id, task_id, user_id, action, details, created_at)
+                        VALUES ($1, $2, $3, $4, $5, $6)
+                        ON CONFLICT (id) DO UPDATE SET
+                            task_id = EXCLUDED.task_id,
+                            user_id = EXCLUDED.user_id,
+                            action = EXCLUDED.action,
+                            details = EXCLUDED.details
+                    `, [
+                        log.id,
+                        log.task_id,
+                        log.user_id,
+                        log.action,
+                        log.details || '',
+                        log.created_at
+                    ]);
+                    migratedLogs++;
+                } catch (error) {
+                    console.error(`   Ошибка при миграции лога ${log.id}:`, error.message);
+                }
+            }
+            console.log(`✅ Мигрировано ${migratedLogs} из ${logs.length} логов активности`);
+        } else {
+            console.log('ℹ️  В таблице activity_logs нет данных для миграции');
+        }
+        
+        // Мигрируем таблицу notification_logs
+        console.log('📦 Мигрируем таблицу notification_logs...');
+        const notifications = await new Promise((resolve, reject) => {
+            sqliteDb.all('SELECT * FROM notification_logs ORDER BY id', [], (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows);
+            });
+        });
+        
+        if (notifications.length > 0) {
+            let migratedNotifications = 0;
+            for (const notification of notifications) {
+                try {
+                    await client.query(`
+                        INSERT INTO notification_logs (id, notification_key, created_at)
+                        VALUES ($1, $2, $3)
+                        ON CONFLICT (id) DO UPDATE SET
+                            notification_key = EXCLUDED.notification_key
+                    `, [
+                        notification.id,
+                        notification.notification_key,
+                        notification.created_at
+                    ]);
+                    migratedNotifications++;
+                } catch (error) {
+                    console.error(`   Ошибка при миграции уведомления ${notification.id}:`, error.message);
+                }
+            }
+            console.log(`✅ Мигрировано ${migratedNotifications} из ${notifications.length} логов уведомлений`);
+        } else {
+            console.log('ℹ️  В таблице notification_logs нет данных для миграции');
+        }
+        
+        // Включаем foreign key constraints обратно
+        await client.query('SET session_replication_role = DEFAULT;');
+        
+        // Обновляем последовательности
+        await updateSequences(client);
+        
+        client.release();
+        sqliteDb.close();
+        
+        console.log('\n🎉 Миграция успешно завершена!');
+        console.log('📊 Сводка:');
+        console.log(`   👥 Пользователи: ${users.length}`);
+        console.log(`   📋 Задачи: ${tasks.length}`);
+        console.log(`   👤 Назначения: ${assignments.length}`);
+        console.log(`   📁 Файлы: ${files.length}`);
+        console.log(`   📝 Логи активности: ${logs.length}`);
+        console.log(`   🔔 Логи уведомлений: ${notifications.length}`);
+        console.log('\n⚠️  Для переключения на PostgreSQL выполните следующие действия:');
+        console.log('   1. Откройте файл .env');
+        console.log('   2. Измените POSTGRESQL=no на POSTGRESQL=yes');
+        console.log('   3. Перезапустите сервер командой: npm start');
+        
+    } catch (error) {
+        console.error('❌ Ошибка миграции:', error.message);
+        if (client) client.release();
+        sqliteDb.close();
+        process.exit(1);
+    } finally {
+        await pgPool.end();
+    }
+}
+
+async function createPostgresTables(client) {
+    // Создаем таблицы PostgreSQL
+    await client.query(`
+        CREATE TABLE IF NOT EXISTS users (
+            id SERIAL PRIMARY KEY,
+            login VARCHAR(100) UNIQUE NOT NULL,
+            password TEXT,
+            name VARCHAR(255) NOT NULL,
+            email VARCHAR(255) UNIQUE NOT NULL,
+            role VARCHAR(50) DEFAULT 'teacher',
+            auth_type VARCHAR(50) DEFAULT 'local',
+            groups TEXT DEFAULT '[]',
+            description TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            last_login TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    `);
+    
+    await client.query(`
+        CREATE TABLE IF NOT EXISTS tasks (
+            id SERIAL PRIMARY KEY,
+            title VARCHAR(500) NOT NULL,
+            description TEXT,
+            status VARCHAR(50) DEFAULT 'active',
+            created_by INTEGER NOT NULL REFERENCES users(id),
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            deleted_at TIMESTAMP,
+            deleted_by INTEGER REFERENCES users(id),
+            original_task_id INTEGER REFERENCES tasks(id),
+            start_date TIMESTAMP,
+            due_date TIMESTAMP,
+            rework_comment TEXT,
+            closed_at TIMESTAMP,
+            closed_by INTEGER REFERENCES users(id)
+        )
+    `);
+    
+    await client.query(`
+        CREATE TABLE IF NOT EXISTS task_assignments (
+            id SERIAL PRIMARY KEY,
+            task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+            user_id INTEGER NOT NULL REFERENCES users(id),
+            status VARCHAR(50) DEFAULT 'assigned',
+            start_date TIMESTAMP,
+            due_date TIMESTAMP,
+            rework_comment TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    `);
+    
+    await client.query(`
+        CREATE TABLE IF NOT EXISTS task_files (
+            id SERIAL PRIMARY KEY,
+            task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+            user_id INTEGER NOT NULL REFERENCES users(id),
+            filename VARCHAR(255) NOT NULL,
+            original_name VARCHAR(500) NOT NULL,
+            file_path TEXT NOT NULL,
+            file_size BIGINT NOT NULL,
+            uploaded_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    `);
+    
+    await client.query(`
+        CREATE TABLE IF NOT EXISTS activity_logs (
+            id SERIAL PRIMARY KEY,
+            task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+            user_id INTEGER NOT NULL REFERENCES users(id),
+            action VARCHAR(100) NOT NULL,
+            details TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    `);
+    
+    await client.query(`
+        CREATE TABLE IF NOT EXISTS notification_logs (
+            id SERIAL PRIMARY KEY,
+            notification_key VARCHAR(500) NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    `);
+    
+    console.log('✅ Таблицы PostgreSQL созданы/проверены');
+}
+
+async function updateSequences(client) {
+    // Обновляем последовательности для автоинкремента
+    const tables = [
+        { name: 'users', id: 'id' },
+        { name: 'tasks', id: 'id' },
+        { name: 'task_assignments', id: 'id' },
+        { name: 'task_files', id: 'id' },
+        { name: 'activity_logs', id: 'id' },
+        { name: 'notification_logs', id: 'id' }
+    ];
+    
+    for (const table of tables) {
+        try {
+            const result = await client.query(`
+                SELECT MAX(${table.id}) as max_id FROM ${table.name}
+            `);
+            
+            const maxId = result.rows[0].max_id || 0;
+            if (maxId > 0) {
+                await client.query(`
+                    SELECT setval(pg_get_serial_sequence('${table.name}', '${table.id}'), ${maxId}, true)
+                `);
+                console.log(`🔢 Последовательность для ${table.name} обновлена до ${maxId}`);
+            }
+        } catch (error) {
+            console.warn(`⚠️ Не удалось обновить последовательность для ${table.name}: ${error.message}`);
+        }
+    }
+}
+
+// Запускаем миграцию
+migrateToPostgres().catch(console.error);

notifications.js

@@ -0,0 +1,489 @@
+const fetch = require('node-fetch');
+const postgresLogger = require('./postgres');
+const { getDb } = require('./database');
+
+async function sendDeadlineNotification(assignment, hoursLeft) {
+    try {
+        if (!process.env.NOTIFICATION_SERVICE_URL || 
+            !process.env.NOTIFICATION_SERVICE_LOGIN || 
+            !process.env.NOTIFICATION_SERVICE_PASSWORD) {
+            return;
+        }
+
+        const notificationKey = `deadline_${hoursLeft}h_task_${assignment.task_id}_user_${assignment.user_id}`;
+        const lastSent = await getLastNotificationSent(notificationKey);
+        const now = new Date();
+
+        if (lastSent) {
+            const timeSinceLast = now.getTime() - new Date(lastSent).getTime();
+            if (timeSinceLast < 12 * 60 * 60 * 1000) {
+                return;
+            }
+        }
+
+        const subject = `⚠️ До окончания срока задачи осталось менее ${hoursLeft} часов`;
+        const content = `Задача: ${assignment.title}\n\n` +
+                       `Описание: ${assignment.description || 'Без описания'}\n` +
+                       `Срок выполнения: ${new Date(assignment.due_date).toLocaleString('ru-RU')}\n` +
+                       `Осталось времени: ${hoursLeft} часов\n\n` +
+                       `Пожалуйста, завершите задачу в срок.`;
+
+        const recipients = [
+            { id: assignment.user_id, name: assignment.user_name, email: assignment.user_email },
+            { id: assignment.created_by, name: assignment.creator_name, email: assignment.creator_email }
+        ].filter((value, index, self) => 
+            self.findIndex(r => r.id === value.id) === index
+        );
+
+        const recipientIds = recipients.map(r => r.id);
+
+        const authHeader = encodeBasicAuth(
+            process.env.NOTIFICATION_SERVICE_LOGIN,
+            process.env.NOTIFICATION_SERVICE_PASSWORD
+        );
+
+        const FormData = require('form-data');
+        const formData = new FormData();
+        formData.append('subject', subject);
+        formData.append('content', content);
+        formData.append('recipients', JSON.stringify(recipientIds));
+        formData.append('deliveryMethods', JSON.stringify(['email', 'telegram', 'vk']));
+
+        const response = await fetch(process.env.NOTIFICATION_SERVICE_URL, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Basic ${authHeader}`
+            },
+            body: formData
+        });
+
+        if (response.ok) {
+            await saveNotificationSent(notificationKey);
+            console.log(`✅ Уведомление о сроке (${hoursLeft}ч) отправлено для задачи ${assignment.task_id}`);
+        }
+    } catch (error) {
+        console.error('❌ Ошибка отправки уведомления о сроке:', error);
+    }
+}
+
+function getLastNotificationSent(key) {
+    return new Promise((resolve) => {
+        const db = getDb();
+        if (!db) {
+            resolve(null);
+            return;
+        }
+        
+        db.get("SELECT created_at FROM notification_logs WHERE notification_key = ? ORDER BY created_at DESC LIMIT 1", 
+            [key], (err, row) => {
+                resolve(row ? row.created_at : null);
+            }
+        );
+    });
+}
+
+function saveNotificationSent(key) {
+    const db = getDb();
+    if (!db) return;
+    
+    db.run("INSERT INTO notification_logs (notification_key) VALUES (?)", [key]);
+}
+
+function encodeBasicAuth(login, password) {
+    return Buffer.from(`${login}:${password}`).toString('base64');
+}
+
+async function sendTaskNotifications(type, taskId, taskTitle, taskDescription, authorId, comment = '', status = '', userName = '') {
+    try {
+        const db = getDb();
+        if (!db) {
+            console.log('❌ База данных не доступна для отправки уведомлений');
+            return;
+        }
+
+        if (!process.env.NOTIFICATION_SERVICE_URL || 
+            !process.env.NOTIFICATION_SERVICE_LOGIN || 
+            !process.env.NOTIFICATION_SERVICE_PASSWORD) {
+            console.log('⚠️ Настройки сервиса уведомлений не заданы');
+            
+            // Логируем в PostgreSQL даже если уведомления не отправляются
+            await logNotificationToPostgres({
+                type,
+                taskId,
+                taskTitle,
+                taskDescription,
+                authorId,
+                comment,
+                status,
+                userName,
+                error: 'Сервис уведомлений не настроен'
+            });
+            
+            return;
+        }
+
+        console.log(`📢 Начинаем отправку уведомлений для задачи ${taskId}:`);
+        console.log(`   Тип: ${type}, Автор действия: ${authorId}, Название: ${taskTitle}`);
+
+        // Получаем заказчика (создателя задачи) ОТДЕЛЬНО
+        const creator = await new Promise((resolve, reject) => {
+            db.get(`
+                SELECT t.created_by as user_id, u.name as user_name, u.login as user_login, u.email
+                FROM tasks t
+                LEFT JOIN users u ON t.created_by = u.id
+                WHERE t.id = ?
+            `, [taskId], (err, row) => {
+                if (err) reject(err);
+                else resolve(row);
+            });
+        });
+
+        // Получаем исполнителей ОТДЕЛЬНО
+        const assignees = await new Promise((resolve, reject) => {
+            db.all(`
+                SELECT ta.user_id, u.name as user_name, u.login as user_login, u.email
+                FROM task_assignments ta
+                LEFT JOIN users u ON ta.user_id = u.id
+                WHERE ta.task_id = ?
+            `, [taskId], (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows || []);
+            });
+        });
+
+        // Собираем всех участников
+        const participants = [];
+        if (creator) {
+            participants.push({
+                ...creator,
+                role: 'creator',
+                is_creator: true
+            });
+        }
+        
+        if (assignees && assignees.length > 0) {
+            assignees.forEach(assignee => {
+                participants.push({
+                    ...assignee,
+                    role: 'assignee',
+                    is_creator: false
+                });
+            });
+        }
+
+        // Получаем информацию об авторе действия
+        const author = await new Promise((resolve, reject) => {
+            db.get("SELECT name, login FROM users WHERE id = ?", [authorId], (err, row) => {
+                if (err) reject(err);
+                else resolve(row);
+            });
+        });
+
+        const authorName = author ? author.name : 'Система';
+        const authorLogin = author ? author.login : 'system';
+        
+        // Логируем в PostgreSQL
+        const postgresLogIds = await logNotificationToPostgres({
+            type,
+            taskId,
+            taskTitle,
+            taskDescription,
+            authorId,
+            authorName,
+            authorLogin,
+            participants,
+            comment,
+            status,
+            userName
+        });
+
+        let subject, content;
+
+        switch (type) {
+            case 'created':
+                subject = `Новая задача: ${taskTitle}`;
+                content = `Создана новая задача:\n\n` +
+                         `📋 ${taskTitle}\n` +
+                         `📝 ${taskDescription || 'Без описания'}\n` +
+                         `👤 Автор: ${authorName}\n\n` +
+                         `Для просмотра перейдите в систему управления задачами.`;
+                break;
+
+            case 'updated':
+                subject = `Обновлена задача: ${taskTitle}`;
+                content = `Задача была обновлена:\n\n` +
+                         `📋 ${taskTitle}\n` +
+                         `📝 ${taskDescription || 'Без описания'}\n` +
+                         `👤 Изменено: ${authorName}\n\n` +
+                         `Для просмотра изменений перейдите в систему управления задачами.`;
+                break;
+
+            case 'rework':
+                subject = `Задача возвращена на доработку: ${taskTitle}`;
+                content = `Задача возвращена на доработку:\n\n` +
+                         `📋 ${taskTitle}\n` +
+                         `📝 Комментарий: ${comment}\n` +
+                         `👤 Автор замечания: ${authorName}\n\n` +
+                         `Пожалуйста, исправьте замечания и обновите статус задачи.`;
+                break;
+
+            case 'closed':
+                subject = `Задача закрыта: ${taskTitle}`;
+                content = `Задача была закрыта:\n\n` +
+                         `📋 ${taskTitle}\n` +
+                         `👤 Закрыта: ${authorName}\n\n` +
+                         `Задача завершена и перемещена в архив.`;
+                break;
+
+            case 'status_changed':
+                const statusText = getStatusText(status);
+                subject = `Изменен статус задачи: ${taskTitle}`;
+                content = `Статус задачи изменен:\n\n` +
+                         `📋 ${taskTitle}\n` +
+                         `🔄 Новый статус: ${statusText}\n` +
+                         `👤 Изменил: ${userName || authorName}\n\n` +
+                         `Для просмотра перейдите в систему управления задачами.`;
+                break;
+
+            default:
+                console.log(`⚠️ Неизвестный тип уведомления: ${type}`);
+                return;
+        }
+
+        // Фильтруем получателей: исключаем автора действия
+        const recipientIds = participants
+            .filter(p => {
+                const shouldExclude = p.user_id === authorId;
+                if (shouldExclude) {
+                    console.log(`   ✋ Исключаем автора действия: ${p.user_name} (ID: ${p.user_id})`);
+                }
+                return !shouldExclude;
+            })
+            .map(p => p.user_id);
+
+        if (recipientIds.length === 0) {
+            console.log('❌ Нет получателей для уведомления (все участники - автор изменения)');
+            
+            // Обновляем статус в PostgreSQL
+            await updatePostgresLogStatus(postgresLogIds, 'no_recipients', 'Нет получателей после фильтрации');
+            return;
+        }
+
+        const authHeader = encodeBasicAuth(
+            process.env.NOTIFICATION_SERVICE_LOGIN,
+            process.env.NOTIFICATION_SERVICE_PASSWORD
+        );
+
+        const FormData = require('form-data');
+        const formData = new FormData();
+        formData.append('subject', subject);
+        formData.append('content', content);
+        formData.append('recipients', JSON.stringify(recipientIds));
+        formData.append('deliveryMethods', JSON.stringify(['email', 'telegram', 'vk']));
+
+        console.log(`🚀 Отправляем запрос на сервис уведомлений...`);
+
+        try {
+            const response = await fetch(process.env.NOTIFICATION_SERVICE_URL, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Basic ${authHeader}`
+                },
+                body: formData
+            });
+
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+
+            const result = await response.json();
+            console.log(`✅ Уведомления успешно отправлены для задачи ${taskId}`);
+            
+            // Обновляем статус в PostgreSQL
+            await updatePostgresLogStatus(postgresLogIds, 'sent', null, new Date().toISOString());
+            
+            console.log(`   Результат от сервиса:`, result);
+
+        } catch (error) {
+            console.error('❌ Ошибка отправки уведомлений:', error);
+            
+            // Обновляем статус в PostgreSQL
+            await updatePostgresLogStatus(postgresLogIds, 'failed', error.message);
+            
+            console.error('   Детали ошибки:', {
+                taskId,
+                type,
+                authorId,
+                errorMessage: error.message,
+                stack: error.stack
+            });
+        }
+
+    } catch (error) {
+        console.error('❌ Общая ошибка при обработке уведомлений:', error);
+    }
+}
+
+// Вспомогательные функции для работы с PostgreSQL
+async function logNotificationToPostgres(data) {
+    try {
+        const {
+            type,
+            taskId,
+            taskTitle,
+            taskDescription,
+            authorId,
+            authorName,
+            authorLogin,
+            participants = [],
+            comment = '',
+            status = '',
+            userName = '',
+            error = ''
+        } = data;
+
+        // Создаем сообщение
+        let messageContent = '';
+        switch (type) {
+            case 'created':
+                messageContent = `Создана новая задача: ${taskTitle}`;
+                break;
+            case 'updated':
+                messageContent = `Обновлена задача: ${taskTitle}`;
+                break;
+            case 'rework':
+                messageContent = `Задача возвращена на доработку: ${taskTitle}. Комментарий: ${comment}`;
+                break;
+            case 'closed':
+                messageContent = `Задача закрыта: ${taskTitle}`;
+                break;
+            case 'status_changed':
+                messageContent = `Изменен статус задачи: ${taskTitle}. Новый статус: ${getStatusText(status)}`;
+                break;
+        }
+
+        // Логируем для каждого получателя отдельно
+        const recipientsToNotify = participants.filter(p => p.user_id !== authorId);
+        const logIds = [];
+
+        for (const recipient of recipientsToNotify) {
+            const logId = await postgresLogger.logNotification({
+                taskId,
+                taskTitle,
+                taskDescription,
+                notificationType: type,
+                authorId,
+                authorName,
+                authorLogin,
+                recipientId: recipient.user_id,
+                recipientName: recipient.user_name,
+                recipientLogin: recipient.user_login,
+                messageContent: `${messageContent}\n\nЗадача: ${taskTitle}\nОписание: ${taskDescription || 'Без описания'}\nАвтор: ${authorName}`,
+                messageSubject: getNotificationSubject(type, taskTitle),
+                deliveryMethods: ['email', 'telegram', 'vk'],
+                comments: error ? `Ошибка: ${error}` : comment
+            });
+
+            if (logId) {
+                logIds.push(logId);
+            }
+        }
+
+        return logIds;
+
+    } catch (error) {
+        console.error('❌ Ошибка логирования в PostgreSQL:', error);
+        return [];
+    }
+}
+
+async function updatePostgresLogStatus(logIds, status, errorMessage = null, sentAt = null) {
+    if (!logIds || logIds.length === 0) return;
+
+    for (const logId of logIds) {
+        await postgresLogger.updateNotificationStatus(logId, status, errorMessage, sentAt);
+    }
+}
+
+function getNotificationSubject(type, taskTitle) {
+    switch (type) {
+        case 'created':
+            return `Новая задача: ${taskTitle}`;
+        case 'updated':
+            return `Обновлена задача: ${taskTitle}`;
+        case 'rework':
+            return `Задача возвращена на доработку: ${taskTitle}`;
+        case 'closed':
+            return `Задача закрыта: ${taskTitle}`;
+        case 'status_changed':
+            return `Изменен статус задачи: ${taskTitle}`;
+        default:
+            return `Уведомление по задаче: ${taskTitle}`;
+    }
+}
+
+function getStatusText(status) {
+    const statusMap = {
+        'assigned': 'Назначена',
+        'in_progress': 'В работе',
+        'completed': 'Завершена',
+        'overdue': 'Просрочена',
+        'rework': 'На доработке'
+    };
+    return statusMap[status] || status;
+}
+
+function checkUpcomingDeadlines() {
+    const now = new Date();
+    const in48Hours = new Date(now.getTime() + 48 * 60 * 60 * 1000).toISOString();
+    const in24Hours = new Date(now.getTime() + 24 * 60 * 60 * 1000).toISOString();
+    const nowISO = now.toISOString();
+
+    const query = `
+        SELECT DISTINCT ta.*, t.title, t.description, t.created_by, u.name as user_name, u.email as user_email,
+               creator.name as creator_name, creator.email as creator_email
+        FROM task_assignments ta
+        JOIN tasks t ON ta.task_id = t.id
+        JOIN users u ON ta.user_id = u.id
+        JOIN users creator ON t.created_by = creator.id
+        WHERE ta.due_date IS NOT NULL 
+        AND ta.due_date > ?
+        AND ta.due_date <= ?
+        AND ta.status NOT IN ('completed', 'overdue')
+        AND t.status = 'active'
+        AND t.closed_at IS NULL
+    `;
+
+    const db = getDb();
+    if (!db) {
+        console.error('❌ База данных не доступна для проверки сроков');
+        return;
+    }
+
+    db.all(query, [nowISO, in48Hours], async (err, assignments) => {
+        if (err) {
+            console.error('❌ Ошибка при проверке сроков задач:', err);
+            return;
+        }
+
+        for (const assignment of assignments) {
+            const dueDate = new Date(assignment.due_date);
+            const timeLeft = dueDate.getTime() - now.getTime();
+            const hoursLeft = Math.floor(timeLeft / (60 * 60 * 1000));
+
+            if (hoursLeft <= 48 && hoursLeft > 24) {
+                await sendDeadlineNotification(assignment, 48);
+            } else if (hoursLeft <= 24) {
+                await sendDeadlineNotification(assignment, 24);
+            }
+        }
+    });
+}
+
+// Экспортируем функции
+module.exports = {
+    sendTaskNotifications,
+    checkUpcomingDeadlines,
+    sendDeadlineNotification,
+    getStatusText
+};

postgres-init.js

@@ -1,100 +1,100 @@
-const { Client } = require('pg');
+const { Client } = require('pg');
-require('dotenv').config();
+require('dotenv').config();
-
+
-async function initializeDatabase() {
+async function initializeDatabase() {
-    console.log('🔄 Инициализация PostgreSQL...');
+    console.log('🔄 Инициализация PostgreSQL...');
-    
+    
-    // Сначала подключаемся без конкретной БД
+    // Сначала подключаемся без конкретной БД
-    const adminClient = new Client({
+    const adminClient = new Client({
-        host: process.env.DB_HOST,
+        host: process.env.DB_HOST,
-        port: process.env.DB_PORT || 5432,
+        port: process.env.DB_PORT || 5432,
-        user: process.env.DB_USER,
+        user: process.env.DB_USER,
-        password: process.env.DB_PASSWORD,
+        password: process.env.DB_PASSWORD,
-        database: 'postgres' // Подключаемся к системной БД
+        database: 'postgres' // Подключаемся к системной БД
-    });
+    });
-
+
-    try {
+    try {
-        await adminClient.connect();
+        await adminClient.connect();
-        console.log('✅ Подключение к PostgreSQL установлено');
+        console.log('✅ Подключение к PostgreSQL установлено');
-
+
-        // Проверяем существование базы данных
+        // Проверяем существование базы данных
-        const dbCheck = await adminClient.query(`
+        const dbCheck = await adminClient.query(`
-            SELECT 1 FROM pg_database WHERE datname = '${process.env.DB_NAME}'
+            SELECT 1 FROM pg_database WHERE datname = '${process.env.DB_NAME}'
-        `);
+        `);
-
+
-        if (dbCheck.rows.length === 0) {
+        if (dbCheck.rows.length === 0) {
-            console.log(`📦 База данных ${process.env.DB_NAME} не существует, создаем...`);
+            console.log(`📦 База данных ${process.env.DB_NAME} не существует, создаем...`);
-            await adminClient.query(`CREATE DATABASE ${process.env.DB_NAME}`);
+            await adminClient.query(`CREATE DATABASE ${process.env.DB_NAME}`);
-            console.log(`✅ База данных ${process.env.DB_NAME} создана`);
+            console.log(`✅ База данных ${process.env.DB_NAME} создана`);
-        } else {
+        } else {
-            console.log(`✅ База данных ${process.env.DB_NAME} уже существует`);
+            console.log(`✅ База данных ${process.env.DB_NAME} уже существует`);
-        }
+        }
-
+
-        await adminClient.end();
+        await adminClient.end();
-
+
-        // Теперь подключаемся к созданной БД
+        // Теперь подключаемся к созданной БД
-        const dbClient = new Client({
+        const dbClient = new Client({
-            host: process.env.DB_HOST,
+            host: process.env.DB_HOST,
-            port: process.env.DB_PORT || 5432,
+            port: process.env.DB_PORT || 5432,
-            user: process.env.DB_USER,
+            user: process.env.DB_USER,
-            password: process.env.DB_PASSWORD,
+            password: process.env.DB_PASSWORD,
-            database: process.env.DB_NAME
+            database: process.env.DB_NAME
-        });
+        });
-
+
-        await dbClient.connect();
+        await dbClient.connect();
-        
+        
-        // Создаем таблицы
+        // Создаем таблицы
-        await dbClient.query(`
+        await dbClient.query(`
-            CREATE TABLE IF NOT EXISTS sms_logs (
+            CREATE TABLE IF NOT EXISTS sms_logs (
-                id SERIAL PRIMARY KEY,
+                id SERIAL PRIMARY KEY,
-                task_id INTEGER NOT NULL,
+                task_id INTEGER NOT NULL,
-                task_title VARCHAR(500) NOT NULL,
+                task_title VARCHAR(500) NOT NULL,
-                task_description TEXT,
+                task_description TEXT,
-                notification_type VARCHAR(50) NOT NULL,
+                notification_type VARCHAR(50) NOT NULL,
-                creator_id INTEGER,
+                creator_id INTEGER,
-                creator_name VARCHAR(255),
+                creator_name VARCHAR(255),
-                creator_login VARCHAR(100),
+                creator_login VARCHAR(100),
-                assignee_id INTEGER,
+                assignee_id INTEGER,
-                assignee_name VARCHAR(255),
+                assignee_name VARCHAR(255),
-                assignee_login VARCHAR(100),
+                assignee_login VARCHAR(100),
-                message_content TEXT NOT NULL,
+                message_content TEXT NOT NULL,
-                message_subject VARCHAR(500),
+                message_subject VARCHAR(500),
-                delivery_methods JSONB DEFAULT '[]',
+                delivery_methods JSONB DEFAULT '[]',
-                status VARCHAR(50) DEFAULT 'pending',
+                status VARCHAR(50) DEFAULT 'pending',
-                error_message TEXT,
+                error_message TEXT,
-                retry_count INTEGER DEFAULT 0,
+                retry_count INTEGER DEFAULT 0,
-                sent_at TIMESTAMP,
+                sent_at TIMESTAMP,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                comments TEXT
+                comments TEXT
-            )
+            )
-        `);
+        `);
-
+
-        // Создаем индексы
+        // Создаем индексы
-        const indexes = [
+        const indexes = [
-            'CREATE INDEX IF NOT EXISTS idx_sms_logs_task_id ON sms_logs(task_id)',
+            'CREATE INDEX IF NOT EXISTS idx_sms_logs_task_id ON sms_logs(task_id)',
-            'CREATE INDEX IF NOT EXISTS idx_sms_logs_creator_id ON sms_logs(creator_id)',
+            'CREATE INDEX IF NOT EXISTS idx_sms_logs_creator_id ON sms_logs(creator_id)',
-            'CREATE INDEX IF NOT EXISTS idx_sms_logs_assignee_id ON sms_logs(assignee_id)',
+            'CREATE INDEX IF NOT EXISTS idx_sms_logs_assignee_id ON sms_logs(assignee_id)',
-            'CREATE INDEX IF NOT EXISTS idx_sms_logs_status ON sms_logs(status)',
+            'CREATE INDEX IF NOT EXISTS idx_sms_logs_status ON sms_logs(status)',
-            'CREATE INDEX IF NOT EXISTS idx_sms_logs_created_at ON sms_logs(created_at)'
+            'CREATE INDEX IF NOT EXISTS idx_sms_logs_created_at ON sms_logs(created_at)'
-        ];
+        ];
-
+
-        for (const indexQuery of indexes) {
+        for (const indexQuery of indexes) {
-            try {
+            try {
-                await dbClient.query(indexQuery);
+                await dbClient.query(indexQuery);
-            } catch (err) {
+            } catch (err) {
-                console.warn(`⚠️ Индекс не создан: ${err.message}`);
+                console.warn(`⚠️ Индекс не создан: ${err.message}`);
-            }
+            }
-        }
+        }
-
+
-        await dbClient.end();
+        await dbClient.end();
-        console.log('✅ PostgreSQL полностью инициализирован');
+        console.log('✅ PostgreSQL полностью инициализирован');
-        return true;
+        return true;
-        
+        
-    } catch (error) {
+    } catch (error) {
-        console.error('❌ Ошибка инициализации PostgreSQL:', error.message);
+        console.error('❌ Ошибка инициализации PostgreSQL:', error.message);
-        return false;
+        return false;
-    }
+    }
-}
+}
-
+
 module.exports = { initializeDatabase };

postgres.js

@@ -1,206 +1,206 @@
-const { Pool } = require('pg');
+const { Pool } = require('pg');
-require('dotenv').config();
+require('dotenv').config();
-const { initializeDatabase } = require('./postgres-init');
+const { initializeDatabase } = require('./postgres-init');
-
+
-class PostgresLogger {
+class PostgresLogger {
-    constructor() {
+    constructor() {
-        this.pool = null;
+        this.pool = null;
-        this.initialized = false;
+        this.initialized = false;
-        this.init();
+        this.init();
-    }
+    }
-
+
-    async init() {
+    async init() {
-        try {
+        try {
-            console.log('🔌 Инициализация PostgreSQL логгера...');
+            console.log('🔌 Инициализация PostgreSQL логгера...');
-
+
-            // Проверяем наличие переменных окружения
+            // Проверяем наличие переменных окружения
-            if (!process.env.DB_HOST || !process.env.DB_USER || !process.env.DB_PASSWORD) {
+            if (!process.env.DB_HOST || !process.env.DB_USER || !process.env.DB_PASSWORD) {
-                console.log('⚠️ Переменные окружения для PostgreSQL не заданы');
+                console.log('⚠️ Переменные окружения для PostgreSQL не заданы');
-                console.log('   DB_HOST:', process.env.DB_HOST || 'не задано');
+                console.log('   DB_HOST:', process.env.DB_HOST || 'не задано');
-                console.log('   DB_USER:', process.env.DB_USER || 'не задано');
+                console.log('   DB_USER:', process.env.DB_USER || 'не задано');
-                console.log('   DB_NAME:', process.env.DB_NAME || 'minicrm');
+                console.log('   DB_NAME:', process.env.DB_NAME || 'minicrm');
-                this.initialized = false;
+                this.initialized = false;
-                return;
+                return;
-            }
+            }
-
+
-            // Создаем базу данных если нужно
+            // Создаем базу данных если нужно
-            const dbInitialized = await initializeDatabase();
+            const dbInitialized = await initializeDatabase();
-            if (!dbInitialized) {
+            if (!dbInitialized) {
-                console.error('❌ Не удалось инициализировать базу данных');
+                console.error('❌ Не удалось инициализировать базу данных');
-                this.initialized = false;
+                this.initialized = false;
-                return;
+                return;
-            }
+            }
-
+
-            // Подключаемся к созданной БД
+            // Подключаемся к созданной БД
-            this.pool = new Pool({
+            this.pool = new Pool({
-                host: process.env.DB_HOST,
+                host: process.env.DB_HOST,
-                port: process.env.DB_PORT || 5432,
+                port: process.env.DB_PORT || 5432,
-                database: process.env.DB_NAME || 'minicrm',
+                database: process.env.DB_NAME || 'minicrm',
-                user: process.env.DB_USER,
+                user: process.env.DB_USER,
-                password: process.env.DB_PASSWORD,
+                password: process.env.DB_PASSWORD,
-                max: 5,
+                max: 5,
-                idleTimeoutMillis: 30000,
+                idleTimeoutMillis: 30000,
-                connectionTimeoutMillis: 5000,
+                connectionTimeoutMillis: 5000,
-            });
+            });
-
+
-            // Тестируем подключение
+            // Тестируем подключение
-            const client = await this.pool.connect();
+            const client = await this.pool.connect();
-            await client.query('SELECT 1');
+            await client.query('SELECT 1');
-            client.release();
+            client.release();
-
+
-            this.initialized = true;
+            this.initialized = true;
-            console.log('✅ PostgreSQL логгер готов к работе');
+            console.log('✅ PostgreSQL логгер готов к работе');
-            
+            
-        } catch (error) {
+        } catch (error) {
-            console.error('❌ Ошибка инициализации PostgreSQL логгера:', error.message);
+            console.error('❌ Ошибка инициализации PostgreSQL логгера:', error.message);
-            console.error('   Убедитесь, что:');
+            console.error('   Убедитесь, что:');
-            console.error('   1. PostgreSQL сервер запущен на', process.env.DB_HOST);
+            console.error('   1. PostgreSQL сервер запущен на', process.env.DB_HOST);
-            console.error('   2. Пользователь', process.env.DB_USER, 'имеет права на создание БД');
+            console.error('   2. Пользователь', process.env.DB_USER, 'имеет права на создание БД');
-            console.error('   3. Пароль указан верно в .env файле');
+            console.error('   3. Пароль указан верно в .env файле');
-            this.initialized = false;
+            this.initialized = false;
-        }
+        }
-    }
+    }
-
+
-    async logNotification(notificationData) {
+    async logNotification(notificationData) {
-        if (!this.initialized) {
+        if (!this.initialized) {
-            console.log('⚠️ PostgreSQL не инициализирован, логирование пропущено');
+            console.log('⚠️ PostgreSQL не инициализирован, логирование пропущено');
-            return null;
+            return null;
-        }
+        }
-
+
-        const {
+        const {
-            taskId,
+            taskId,
-            taskTitle,
+            taskTitle,
-            taskDescription = '',
+            taskDescription = '',
-            notificationType,
+            notificationType,
-            authorId,
+            authorId,
-            authorName,
+            authorName,
-            authorLogin,
+            authorLogin,
-            recipientId,
+            recipientId,
-            recipientName,
+            recipientName,
-            recipientLogin,
+            recipientLogin,
-            messageContent,
+            messageContent,
-            messageSubject = '',
+            messageSubject = '',
-            deliveryMethods = ['email', 'telegram', 'vk'],
+            deliveryMethods = ['email', 'telegram', 'vk'],
-            comments = ''
+            comments = ''
-        } = notificationData;
+        } = notificationData;
-
+
-        let client;
+        let client;
-        try {
+        try {
-            client = await this.pool.connect();
+            client = await this.pool.connect();
-            
+            
-            const query = `
+            const query = `
-                INSERT INTO sms_logs (
+                INSERT INTO sms_logs (
-                    task_id, task_title, task_description, notification_type,
+                    task_id, task_title, task_description, notification_type,
-                    creator_id, creator_name, creator_login,
+                    creator_id, creator_name, creator_login,
-                    assignee_id, assignee_name, assignee_login,
+                    assignee_id, assignee_name, assignee_login,
-                    message_content, message_subject, delivery_methods,
+                    message_content, message_subject, delivery_methods,
-                    status, comments, created_at
+                    status, comments, created_at
-                ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, CURRENT_TIMESTAMP)
+                ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, CURRENT_TIMESTAMP)
-                RETURNING id;
+                RETURNING id;
-            `;
+            `;
-
+
-            const values = [
+            const values = [
-                taskId,
+                taskId,
-                taskTitle?.substring(0, 500) || 'Без названия',
+                taskTitle?.substring(0, 500) || 'Без названия',
-                taskDescription?.substring(0, 5000) || '',
+                taskDescription?.substring(0, 5000) || '',
-                notificationType,
+                notificationType,
-                authorId,
+                authorId,
-                authorName || 'Неизвестно',
+                authorName || 'Неизвестно',
-                authorLogin || 'unknown',
+                authorLogin || 'unknown',
-                recipientId,
+                recipientId,
-                recipientName || 'Неизвестно',
+                recipientName || 'Неизвестно',
-                recipientLogin || 'unknown',
+                recipientLogin || 'unknown',
-                messageContent?.substring(0, 5000) || '',
+                messageContent?.substring(0, 5000) || '',
-                messageSubject?.substring(0, 500) || '',
+                messageSubject?.substring(0, 500) || '',
-                JSON.stringify(deliveryMethods),
+                JSON.stringify(deliveryMethods),
-                'pending',
+                'pending',
-                comments
+                comments
-            ];
+            ];
-
+
-            const result = await client.query(query, values);
+            const result = await client.query(query, values);
-            const logId = result.rows[0]?.id;
+            const logId = result.rows[0]?.id;
-            
+            
-            if (logId) {
+            if (logId) {
-                console.log(`📝 Уведомление записано в PostgreSQL, ID: ${logId}`);
+                console.log(`📝 Уведомление записано в PostgreSQL, ID: ${logId}`);
-            }
+            }
-            
+            
-            return logId || null;
+            return logId || null;
-            
+            
-        } catch (error) {
+        } catch (error) {
-            console.error('❌ Ошибка записи уведомления в PostgreSQL:', error.message);
+            console.error('❌ Ошибка записи уведомления в PostgreSQL:', error.message);
-            return null;
+            return null;
-        } finally {
+        } finally {
-            if (client) client.release();
+            if (client) client.release();
-        }
+        }
-    }
+    }
-
+
-    async updateNotificationStatus(logId, status, errorMessage = null, sentAt = null) {
+    async updateNotificationStatus(logId, status, errorMessage = null, sentAt = null) {
-        if (!this.initialized || !logId) return;
+        if (!this.initialized || !logId) return;
-
+
-        let client;
+        let client;
-        try {
+        try {
-            client = await this.pool.connect();
+            client = await this.pool.connect();
-            
+            
-            const query = `
+            const query = `
-                UPDATE sms_logs 
+                UPDATE sms_logs 
-                SET status = $1, 
+                SET status = $1, 
-                    error_message = $2, 
+                    error_message = $2, 
-                    sent_at = $3,
+                    sent_at = $3,
-                    updated_at = CURRENT_TIMESTAMP
+                    updated_at = CURRENT_TIMESTAMP
-                WHERE id = $4;
+                WHERE id = $4;
-            `;
+            `;
-
+
-            await client.query(query, [
+            await client.query(query, [
-                status,
+                status,
-                errorMessage,
+                errorMessage,
-                sentAt ? new Date(sentAt) : (status === 'sent' ? new Date() : null),
+                sentAt ? new Date(sentAt) : (status === 'sent' ? new Date() : null),
-                logId
+                logId
-            ]);
+            ]);
-
+
-            console.log(`📝 Статус уведомления ${logId} обновлен на: ${status}`);
+            console.log(`📝 Статус уведомления ${logId} обновлен на: ${status}`);
-            
+            
-        } catch (error) {
+        } catch (error) {
-            console.error('❌ Ошибка обновления статуса уведомления:', error.message);
+            console.error('❌ Ошибка обновления статуса уведомления:', error.message);
-        } finally {
+        } finally {
-            if (client) client.release();
+            if (client) client.release();
-        }
+        }
-    }
+    }
-
+
-    async healthCheck() {
+    async healthCheck() {
-        if (!this.initialized) {
+        if (!this.initialized) {
-            return {
+            return {
-                connected: false,
+                connected: false,
-                error: 'PostgreSQL не инициализирован',
+                error: 'PostgreSQL не инициализирован',
-                timestamp: new Date().toISOString()
+                timestamp: new Date().toISOString()
-            };
+            };
-        }
+        }
-
+
-        let client;
+        let client;
-        try {
+        try {
-            client = await this.pool.connect();
+            client = await this.pool.connect();
-            await client.query('SELECT 1');
+            await client.query('SELECT 1');
-            
+            
-            return {
+            return {
-                connected: true,
+                connected: true,
-                timestamp: new Date().toISOString(),
+                timestamp: new Date().toISOString(),
-                database: process.env.DB_NAME || 'minicrm',
+                database: process.env.DB_NAME || 'minicrm',
-                host: process.env.DB_HOST
+                host: process.env.DB_HOST
-            };
+            };
-            
+            
-        } catch (error) {
+        } catch (error) {
-            return {
+            return {
-                connected: false,
+                connected: false,
-                error: error.message,
+                error: error.message,
-                timestamp: new Date().toISOString()
+                timestamp: new Date().toISOString()
-            };
+            };
-        } finally {
+        } finally {
-            if (client) client.release();
+            if (client) client.release();
-        }
+        }
-    }
+    }
-
+
-    // Другие методы остаются без изменений...
+    // Другие методы остаются без изменений...
-}
+}
-
+
-// Экспортируем singleton
+// Экспортируем singleton
-const postgresLogger = new PostgresLogger();
+const postgresLogger = new PostgresLogger();
 module.exports = postgresLogger;

public/admin-script.js

@@ -1,361 +1,361 @@
-let currentUser = null;
+let currentUser = null;
-let users = [];
+let users = [];
-let filteredUsers = [];
+let filteredUsers = [];
-
+
-document.addEventListener('DOMContentLoaded', function() {
+document.addEventListener('DOMContentLoaded', function() {
-    checkAuth();
+    checkAuth();
-    setupEventListeners();
+    setupEventListeners();
-});
+});
-
+
-async function checkAuth() {
+async function checkAuth() {
-    try {
+    try {
-        const response = await fetch('/api/user');
+        const response = await fetch('/api/user');
-        if (response.ok) {
+        if (response.ok) {
-            const data = await response.json();
+            const data = await response.json();
-            currentUser = data.user;
+            currentUser = data.user;
-            
+            
-            if (currentUser.role !== 'admin') {
+            if (currentUser.role !== 'admin') {
-                window.location.href = '/';
+                window.location.href = '/';
-                return;
+                return;
-            }
+            }
-            
+            
-            showAdminInterface();
+            showAdminInterface();
-        } else {
+        } else {
-            showLoginInterface();
+            showLoginInterface();
-        }
+        }
-    } catch (error) {
+    } catch (error) {
-        showLoginInterface();
+        showLoginInterface();
-    }
+    }
-}
+}
-
+
-function showLoginInterface() {
+function showLoginInterface() {
-    document.getElementById('login-modal').style.display = 'block';
+    document.getElementById('login-modal').style.display = 'block';
-    document.querySelector('.admin-container').style.display = 'none';
+    document.querySelector('.admin-container').style.display = 'none';
-}
+}
-
+
-function showAdminInterface() {
+function showAdminInterface() {
-    document.getElementById('login-modal').style.display = 'none';
+    document.getElementById('login-modal').style.display = 'none';
-    document.querySelector('.admin-container').style.display = 'block';
+    document.querySelector('.admin-container').style.display = 'block';
-    
+    
-    let userInfo = `Администратор: ${currentUser.name}`;
+    let userInfo = `Администратор: ${currentUser.name}`;
-    if (currentUser.auth_type === 'ldap') {
+    if (currentUser.auth_type === 'ldap') {
-        userInfo += ` (LDAP)`;
+        userInfo += ` (LDAP)`;
-    }
+    }
-    
+    
-    document.getElementById('current-user').textContent = userInfo;
+    document.getElementById('current-user').textContent = userInfo;
-    
+    
-    loadUsers();
+    loadUsers();
-    loadDashboardStats();
+    loadDashboardStats();
-}
+}
-
+
-function setupEventListeners() {
+function setupEventListeners() {
-    document.getElementById('login-form').addEventListener('submit', login);
+    document.getElementById('login-form').addEventListener('submit', login);
-    document.getElementById('edit-user-form').addEventListener('submit', updateUser);
+    document.getElementById('edit-user-form').addEventListener('submit', updateUser);
-}
+}
-
+
-async function login(event) {
+async function login(event) {
-    event.preventDefault();
+    event.preventDefault();
-    
+    
-    const login = document.getElementById('login').value;
+    const login = document.getElementById('login').value;
-    const password = document.getElementById('password').value;
+    const password = document.getElementById('password').value;
-
+
-    try {
+    try {
-        const response = await fetch('/api/login', {
+        const response = await fetch('/api/login', {
-            method: 'POST',
+            method: 'POST',
-            headers: {
+            headers: {
-                'Content-Type': 'application/json',
+                'Content-Type': 'application/json',
-            },
+            },
-            body: JSON.stringify({ login, password })
+            body: JSON.stringify({ login, password })
-        });
+        });
-
+
-        if (response.ok) {
+        if (response.ok) {
-            const data = await response.json();
+            const data = await response.json();
-            currentUser = data.user;
+            currentUser = data.user;
-            
+            
-            if (currentUser.role !== 'admin') {
+            if (currentUser.role !== 'admin') {
-                window.location.href = '/';
+                window.location.href = '/';
-                return;
+                return;
-            }
+            }
-            
+            
-            showAdminInterface();
+            showAdminInterface();
-        } else {
+        } else {
-            const error = await response.json();
+            const error = await response.json();
-            alert(error.error || 'Ошибка входа');
+            alert(error.error || 'Ошибка входа');
-        }
+        }
-    } catch (error) {
+    } catch (error) {
-        console.error('Ошибка:', error);
+        console.error('Ошибка:', error);
-        alert('Ошибка подключения к серверу');
+        alert('Ошибка подключения к серверу');
-    }
+    }
-}
+}
-
+
-async function logout() {
+async function logout() {
-    try {
+    try {
-        await fetch('/api/logout', { method: 'POST' });
+        await fetch('/api/logout', { method: 'POST' });
-        currentUser = null;
+        currentUser = null;
-        showLoginInterface();
+        showLoginInterface();
-    } catch (error) {
+    } catch (error) {
-        console.error('Ошибка выхода:', error);
+        console.error('Ошибка выхода:', error);
-    }
+    }
-}
+}
-
+
-function showAdminSection(sectionName) {
+function showAdminSection(sectionName) {
-    document.querySelectorAll('.admin-tab').forEach(tab => {
+    document.querySelectorAll('.admin-tab').forEach(tab => {
-        tab.classList.remove('active');
+        tab.classList.remove('active');
-    });
+    });
-    
+    
-    document.querySelectorAll('.admin-section').forEach(section => {
+    document.querySelectorAll('.admin-section').forEach(section => {
-        section.classList.remove('active');
+        section.classList.remove('active');
-    });
+    });
-    
+    
-    document.querySelector(`.admin-tab[onclick="showAdminSection('${sectionName}')"]`).classList.add('active');
+    document.querySelector(`.admin-tab[onclick="showAdminSection('${sectionName}')"]`).classList.add('active');
-    document.getElementById(`admin-${sectionName}`).classList.add('active');
+    document.getElementById(`admin-${sectionName}`).classList.add('active');
-    
+    
-    if (sectionName === 'users') {
+    if (sectionName === 'users') {
-        loadUsers();
+        loadUsers();
-    } else if (sectionName === 'dashboard') {
+    } else if (sectionName === 'dashboard') {
-        loadDashboardStats();
+        loadDashboardStats();
-    }
+    }
-}
+}
-
+
-async function loadUsers() {
+async function loadUsers() {
-    try {
+    try {
-        const response = await fetch('/admin/users');
+        const response = await fetch('/admin/users');
-        if (!response.ok) {
+        if (!response.ok) {
-            throw new Error('Ошибка загрузки пользователей');
+            throw new Error('Ошибка загрузки пользователей');
-        }
+        }
-        users = await response.json();
+        users = await response.json();
-        filteredUsers = [...users];
+        filteredUsers = [...users];
-        renderUsersTable();
+        renderUsersTable();
-    } catch (error) {
+    } catch (error) {
-        console.error('Ошибка загрузки пользователей:', error);
+        console.error('Ошибка загрузки пользователей:', error);
-        showError('users-table-body', 'Ошибка загрузки пользователей');
+        showError('users-table-body', 'Ошибка загрузки пользователей');
-    }
+    }
-}
+}
-
+
-async function loadDashboardStats() {
+async function loadDashboardStats() {
-    try {
+    try {
-        const response = await fetch('/admin/stats');
+        const response = await fetch('/admin/stats');
-        if (!response.ok) {
+        if (!response.ok) {
-            throw new Error('Ошибка загрузки статистики');
+            throw new Error('Ошибка загрузки статистики');
-        }
+        }
-        
+        
-        const stats = await response.json();
+        const stats = await response.json();
-        updateStatsUI(stats);
+        updateStatsUI(stats);
-    } catch (error) {
+    } catch (error) {
-        console.error('Ошибка загрузки статистики:', error);
+        console.error('Ошибка загрузки статистики:', error);
-    }
+    }
-}
+}
-
+
-function updateStatsUI(stats) {
+function updateStatsUI(stats) {
-    // Задачи
+    // Задачи
-    document.getElementById('total-tasks').textContent = stats.totalTasks;
+    document.getElementById('total-tasks').textContent = stats.totalTasks;
-    document.getElementById('active-tasks').textContent = stats.activeTasks;
+    document.getElementById('active-tasks').textContent = stats.activeTasks;
-    document.getElementById('closed-tasks').textContent = stats.closedTasks;
+    document.getElementById('closed-tasks').textContent = stats.closedTasks;
-    document.getElementById('deleted-tasks').textContent = stats.deletedTasks;
+    document.getElementById('deleted-tasks').textContent = stats.deletedTasks;
-    
+    
-    // Процент активных задач
+    // Процент активных задач
-    if (stats.totalTasks > 0) {
+    if (stats.totalTasks > 0) {
-        const activePercentage = Math.round((stats.activeTasks / stats.totalTasks) * 100);
+        const activePercentage = Math.round((stats.activeTasks / stats.totalTasks) * 100);
-        document.getElementById('active-tasks-bar').style.width = `${activePercentage}%`;
+        document.getElementById('active-tasks-bar').style.width = `${activePercentage}%`;
-    }
+    }
-    
+    
-    // Назначения
+    // Назначения
-    document.getElementById('total-assignments').textContent = stats.totalAssignments;
+    document.getElementById('total-assignments').textContent = stats.totalAssignments;
-    document.getElementById('assigned-count').textContent = stats.assignedCount;
+    document.getElementById('assigned-count').textContent = stats.assignedCount;
-    document.getElementById('in-progress-count').textContent = stats.inProgressCount;
+    document.getElementById('in-progress-count').textContent = stats.inProgressCount;
-    document.getElementById('completed-count').textContent = stats.completedCount;
+    document.getElementById('completed-count').textContent = stats.completedCount;
-    document.getElementById('overdue-count').textContent = stats.overdueCount;
+    document.getElementById('overdue-count').textContent = stats.overdueCount;
-    document.getElementById('rework-count').textContent = stats.reworkCount;
+    document.getElementById('rework-count').textContent = stats.reworkCount;
-    
+    
-    // Пользователи
+    // Пользователи
-    document.getElementById('total-users').textContent = stats.totalUsers;
+    document.getElementById('total-users').textContent = stats.totalUsers;
-    document.getElementById('admin-users').textContent = stats.adminUsers;
+    document.getElementById('admin-users').textContent = stats.adminUsers;
-    document.getElementById('teacher-users').textContent = stats.teacherUsers;
+    document.getElementById('teacher-users').textContent = stats.teacherUsers;
-    document.getElementById('ldap-users').textContent = stats.ldapUsers;
+    document.getElementById('ldap-users').textContent = stats.ldapUsers;
-    document.getElementById('local-users').textContent = stats.localUsers;
+    document.getElementById('local-users').textContent = stats.localUsers;
-    
+    
-    // Файлы
+    // Файлы
-    document.getElementById('total-files').textContent = stats.totalFiles;
+    document.getElementById('total-files').textContent = stats.totalFiles;
-    const fileSizeMB = (stats.totalFilesSize / 1024 / 1024).toFixed(2);
+    const fileSizeMB = (stats.totalFilesSize / 1024 / 1024).toFixed(2);
-    document.getElementById('total-files-size').textContent = `${fileSizeMB} MB`;
+    document.getElementById('total-files-size').textContent = `${fileSizeMB} MB`;
-    
+    
-}
+}
-
+
-function searchUsers() {
+function searchUsers() {
-    const search = document.getElementById('user-search').value.toLowerCase();
+    const search = document.getElementById('user-search').value.toLowerCase();
-    filteredUsers = users.filter(user => 
+    filteredUsers = users.filter(user => 
-        user.login.toLowerCase().includes(search) ||
+        user.login.toLowerCase().includes(search) ||
-        user.name.toLowerCase().includes(search) ||
+        user.name.toLowerCase().includes(search) ||
-        user.email.toLowerCase().includes(search) ||
+        user.email.toLowerCase().includes(search) ||
-        user.role.toLowerCase().includes(search) ||
+        user.role.toLowerCase().includes(search) ||
-        user.auth_type.toLowerCase().includes(search)
+        user.auth_type.toLowerCase().includes(search)
-    );
+    );
-    renderUsersTable();
+    renderUsersTable();
-}
+}
-
+
-function renderUsersTable() {
+function renderUsersTable() {
-    const tbody = document.getElementById('users-table-body');
+    const tbody = document.getElementById('users-table-body');
-    
+    
-    if (!filteredUsers || filteredUsers.length === 0) {
+    if (!filteredUsers || filteredUsers.length === 0) {
-        tbody.innerHTML = '<tr><td colspan="9" class="loading">Пользователи не найдены</td></tr>';
+        tbody.innerHTML = '<tr><td colspan="9" class="loading">Пользователи не найдены</td></tr>';
-        return;
+        return;
-    }
+    }
-
+
-    tbody.innerHTML = filteredUsers.map(user => `
+    tbody.innerHTML = filteredUsers.map(user => `
-        <tr>
+        <tr>
-            <td>${user.id}</td>
+            <td>${user.id}</td>
-            <td>
+            <td>
-                ${user.login}
+                ${user.login}
-                ${user.auth_type === 'ldap' ? '<span class="ldap-badge">LDAP</span>' : ''}
+                ${user.auth_type === 'ldap' ? '<span class="ldap-badge">LDAP</span>' : ''}
-            </td>
+            </td>
-            <td>${user.name}</td>
+            <td>${user.name}</td>
-            <td>${user.email}</td>
+            <td>${user.email}</td>
-            <td>
+            <td>
-                ${user.role === 'admin' ? 'Администратор' : 'Учитель'}
+                ${user.role === 'admin' ? 'Администратор' : 'Учитель'}
-                ${user.role === 'admin' ? '<span class="admin-badge">ADMIN</span>' : ''}
+                ${user.role === 'admin' ? '<span class="admin-badge">ADMIN</span>' : ''}
-            </td>
+            </td>
-            <td>${user.auth_type === 'ldap' ? 'LDAP' : 'Локальная'}</td>
+            <td>${user.auth_type === 'ldap' ? 'LDAP' : 'Локальная'}</td>
-            <td>${formatDate(user.created_at)}</td>
+            <td>${formatDate(user.created_at)}</td>
-            <td>${user.last_login ? formatDateTime(user.last_login) : 'Никогда'}</td>
+            <td>${user.last_login ? formatDateTime(user.last_login) : 'Никогда'}</td>
-            <td class="user-actions">
+            <td class="user-actions">
-                <button class="edit-btn" onclick="openEditUserModal(${user.id})" title="Редактировать">✏️</button>
+                <button class="edit-btn" onclick="openEditUserModal(${user.id})" title="Редактировать">✏️</button>
-                <button class="delete-btn" onclick="deleteUser(${user.id})" title="Удалить" ${user.id === currentUser.id ? 'disabled' : ''}>🗑️</button>
+                <button class="delete-btn" onclick="deleteUser(${user.id})" title="Удалить" ${user.id === currentUser.id ? 'disabled' : ''}>🗑️</button>
-            </td>
+            </td>
-        </tr>
+        </tr>
-    `).join('');
+    `).join('');
-}
+}
-
+
-async function openEditUserModal(userId) {
+async function openEditUserModal(userId) {
-    try {
+    try {
-        const response = await fetch(`/admin/users/${userId}`);
+        const response = await fetch(`/admin/users/${userId}`);
-        if (!response.ok) {
+        if (!response.ok) {
-            throw new Error('Ошибка загрузки пользователя');
+            throw new Error('Ошибка загрузки пользователя');
-        }
+        }
-        
+        
-        const user = await response.json();
+        const user = await response.json();
-        
+        
-        document.getElementById('edit-user-id').value = user.id;
+        document.getElementById('edit-user-id').value = user.id;
-        document.getElementById('edit-login').value = user.login;
+        document.getElementById('edit-login').value = user.login;
-        document.getElementById('edit-name').value = user.name;
+        document.getElementById('edit-name').value = user.name;
-        document.getElementById('edit-email').value = user.email;
+        document.getElementById('edit-email').value = user.email;
-        document.getElementById('edit-role').value = user.role;
+        document.getElementById('edit-role').value = user.role;
-        document.getElementById('edit-auth-type').value = user.auth_type;
+        document.getElementById('edit-auth-type').value = user.auth_type;
-        document.getElementById('edit-groups').value = user.groups || '[]';
+        document.getElementById('edit-groups').value = user.groups || '[]';
-        document.getElementById('edit-description').value = user.description || '';
+        document.getElementById('edit-description').value = user.description || '';
-        
+        
-        document.getElementById('edit-user-modal').style.display = 'block';
+        document.getElementById('edit-user-modal').style.display = 'block';
-    } catch (error) {
+    } catch (error) {
-        console.error('Ошибка:', error);
+        console.error('Ошибка:', error);
-        alert('Ошибка загрузки пользователя');
+        alert('Ошибка загрузки пользователя');
-    }
+    }
-}
+}
-
+
-function closeEditUserModal() {
+function closeEditUserModal() {
-    document.getElementById('edit-user-modal').style.display = 'none';
+    document.getElementById('edit-user-modal').style.display = 'none';
-}
+}
-
+
-async function updateUser(event) {
+async function updateUser(event) {
-    event.preventDefault();
+    event.preventDefault();
-    
+    
-    const userId = document.getElementById('edit-user-id').value;
+    const userId = document.getElementById('edit-user-id').value;
-    const login = document.getElementById('edit-login').value;
+    const login = document.getElementById('edit-login').value;
-    const name = document.getElementById('edit-name').value;
+    const name = document.getElementById('edit-name').value;
-    const email = document.getElementById('edit-email').value;
+    const email = document.getElementById('edit-email').value;
-    const role = document.getElementById('edit-role').value;
+    const role = document.getElementById('edit-role').value;
-    const auth_type = document.getElementById('edit-auth-type').value;
+    const auth_type = document.getElementById('edit-auth-type').value;
-    const groups = document.getElementById('edit-groups').value;
+    const groups = document.getElementById('edit-groups').value;
-    const description = document.getElementById('edit-description').value;
+    const description = document.getElementById('edit-description').value;
-    
+    
-    if (!login || !name || !email) {
+    if (!login || !name || !email) {
-        alert('Заполните обязательные поля');
+        alert('Заполните обязательные поля');
-        return;
+        return;
-    }
+    }
-    
+    
-    const userData = {
+    const userData = {
-        login,
+        login,
-        name,
+        name,
-        email,
+        email,
-        role,
+        role,
-        auth_type,
+        auth_type,
-        groups: groups || '[]',
+        groups: groups || '[]',
-        description
+        description
-    };
+    };
-
+
-    try {
+    try {
-        const response = await fetch(`/admin/users/${userId}`, {
+        const response = await fetch(`/admin/users/${userId}`, {
-            method: 'PUT',
+            method: 'PUT',
-            headers: {
+            headers: {
-                'Content-Type': 'application/json',
+                'Content-Type': 'application/json',
-            },
+            },
-            body: JSON.stringify(userData)
+            body: JSON.stringify(userData)
-        });
+        });
-
+
-        if (response.ok) {
+        if (response.ok) {
-            alert('Пользователь успешно обновлен!');
+            alert('Пользователь успешно обновлен!');
-            closeEditUserModal();
+            closeEditUserModal();
-            loadUsers();
+            loadUsers();
-            loadDashboardStats();
+            loadDashboardStats();
-        } else {
+        } else {
-            const error = await response.json();
+            const error = await response.json();
-            alert(error.error || 'Ошибка обновления пользователя');
+            alert(error.error || 'Ошибка обновления пользователя');
-        }
+        }
-    } catch (error) {
+    } catch (error) {
-        console.error('Ошибка:', error);
+        console.error('Ошибка:', error);
-        alert('Ошибка обновления пользователя');
+        alert('Ошибка обновления пользователя');
-    }
+    }
-}
+}
-
+
-async function deleteUser(userId) {
+async function deleteUser(userId) {
-    if (userId === currentUser.id) {
+    if (userId === currentUser.id) {
-        alert('Нельзя удалить самого себя');
+        alert('Нельзя удалить самого себя');
-        return;
+        return;
-    }
+    }
-    
+    
-    if (!confirm('Вы уверены, что хотите удалить этого пользователя?')) {
+    if (!confirm('Вы уверены, что хотите удалить этого пользователя?')) {
-        return;
+        return;
-    }
+    }
-
+
-    try {
+    try {
-        const response = await fetch(`/admin/users/${userId}`, {
+        const response = await fetch(`/admin/users/${userId}`, {
-            method: 'DELETE'
+            method: 'DELETE'
-        });
+        });
-
+
-        if (response.ok) {
+        if (response.ok) {
-            alert('Пользователь успешно удален!');
+            alert('Пользователь успешно удален!');
-            loadUsers();
+            loadUsers();
-            loadDashboardStats();
+            loadDashboardStats();
-        } else {
+        } else {
-            const error = await response.json();
+            const error = await response.json();
-            alert(error.error || 'Ошибка удаления пользователя');
+            alert(error.error || 'Ошибка удаления пользователя');
-        }
+        }
-    } catch (error) {
+    } catch (error) {
-        console.error('Ошибка:', error);
+        console.error('Ошибка:', error);
-        alert('Ошибка удаления пользователя');
+        alert('Ошибка удаления пользователя');
-    }
+    }
-}
+}
-
+
-function formatDateTime(dateTimeString) {
+function formatDateTime(dateTimeString) {
-    if (!dateTimeString) return '';
+    if (!dateTimeString) return '';
-    const date = new Date(dateTimeString);
+    const date = new Date(dateTimeString);
-    return date.toLocaleString('ru-RU');
+    return date.toLocaleString('ru-RU');
-}
+}
-
+
-function formatDate(dateString) {
+function formatDate(dateString) {
-    if (!dateString) return '';
+    if (!dateString) return '';
-    const date = new Date(dateString);
+    const date = new Date(dateString);
-    return date.toLocaleDateString('ru-RU');
+    return date.toLocaleDateString('ru-RU');
-}
+}
-
+
-function showError(elementId, message) {
+function showError(elementId, message) {
-    const element = document.getElementById(elementId);
+    const element = document.getElementById(elementId);
-    if (element) {
+    if (element) {
-        element.innerHTML = `<tr><td colspan="9" class="error">${message}</td></tr>`;
+        element.innerHTML = `<tr><td colspan="9" class="error">${message}</td></tr>`;
-    }
+    }
-}
+}
-
+
-// Автоматическое обновление статистики каждые 30 секунд
+// Автоматическое обновление статистики каждые 30 секунд
-setInterval(() => {
+setInterval(() => {
-    if (document.getElementById('admin-dashboard').classList.contains('active')) {
+    if (document.getElementById('admin-dashboard').classList.contains('active')) {
-        loadDashboardStats();
+        loadDashboardStats();
-    }
+    }
 }, 30000);

public/admin.html

@@ -1,462 +1,462 @@
-<!DOCTYPE html>
+<!DOCTYPE html>
-<html lang="ru">
+<html lang="ru">
-<head>
+<head>
-    <meta charset="UTF-8">
+    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>School CRM - Административная панель</title>
+    <title>School CRM - Административная панель</title>
-    <link rel="stylesheet" href="style.css">
+    <link rel="stylesheet" href="style.css">
-    <style>
+    <style>
-        .stats-grid {
+        .stats-grid {
-            display: grid;
+            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-            gap: 20px;
+            gap: 20px;
-            margin-bottom: 30px;
+            margin-bottom: 30px;
-        }
+        }
-
+
-        .stat-card {
+        .stat-card {
-            background: white;
+            background: white;
-            padding: 20px;
+            padding: 20px;
-            border-radius: 10px;
+            border-radius: 10px;
-            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
+            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
-            border-left: 4px solid #3498db;
+            border-left: 4px solid #3498db;
-        }
+        }
-
+
-        .stat-card.task-stat {
+        .stat-card.task-stat {
-            border-left-color: #3498db;
+            border-left-color: #3498db;
-        }
+        }
-
+
-        .stat-card.user-stat {
+        .stat-card.user-stat {
-            border-left-color: #2ecc71;
+            border-left-color: #2ecc71;
-        }
+        }
-
+
-        .stat-card.file-stat {
+        .stat-card.file-stat {
-            border-left-color: #9b59b6;
+            border-left-color: #9b59b6;
-        }
+        }
-
+
-        .stat-card.status-stat {
+        .stat-card.status-stat {
-            border-left-color: #f39c12;
+            border-left-color: #f39c12;
-        }
+        }
-
+
-        .stat-card h3 {
+        .stat-card h3 {
-            margin: 0 0 15px 0;
+            margin: 0 0 15px 0;
-            color: #495057;
+            color: #495057;
-            font-size: 1.1rem;
+            font-size: 1.1rem;
-            font-weight: 600;
+            font-weight: 600;
-        }
+        }
-
+
-        .stat-value {
+        .stat-value {
-            font-size: 2.5rem;
+            font-size: 2.5rem;
-            font-weight: 700;
+            font-weight: 700;
-            color: #2c3e50;
+            color: #2c3e50;
-            margin-bottom: 10px;
+            margin-bottom: 10px;
-        }
+        }
-
+
-        .stat-desc {
+        .stat-desc {
-            color: #6c757d;
+            color: #6c757d;
-            font-size: 0.9rem;
+            font-size: 0.9rem;
-            margin-bottom: 10px;
+            margin-bottom: 10px;
-        }
+        }
-
+
-        .stat-subitems {
+        .stat-subitems {
-            margin-top: 10px;
+            margin-top: 10px;
-        }
+        }
-
+
-        .stat-subitem {
+        .stat-subitem {
-            display: flex;
+            display: flex;
-            justify-content: space-between;
+            justify-content: space-between;
-            padding: 5px 0;
+            padding: 5px 0;
-            border-bottom: 1px solid #f1f1f1;
+            border-bottom: 1px solid #f1f1f1;
-            font-size: 0.9rem;
+            font-size: 0.9rem;
-        }
+        }
-
+
-        .stat-subitem:last-child {
+        .stat-subitem:last-child {
-            border-bottom: none;
+            border-bottom: none;
-        }
+        }
-
+
-        .stat-subitem .label {
+        .stat-subitem .label {
-            color: #6c757d;
+            color: #6c757d;
-        }
+        }
-
+
-        .stat-subitem .value {
+        .stat-subitem .value {
-            font-weight: 600;
+            font-weight: 600;
-            color: #2c3e50;
+            color: #2c3e50;
-        }
+        }
-
+
-        .recent-tasks {
+        .recent-tasks {
-            background: white;
+            background: white;
-            padding: 20px;
+            padding: 20px;
-            border-radius: 10px;
+            border-radius: 10px;
-            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
+            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
-            margin-top: 20px;
+            margin-top: 20px;
-        }
+        }
-
+
-        .recent-tasks h3 {
+        .recent-tasks h3 {
-            margin: 0 0 15px 0;
+            margin: 0 0 15px 0;
-            color: #495057;
+            color: #495057;
-            font-size: 1.2rem;
+            font-size: 1.2rem;
-        }
+        }
-
+
-        .task-item {
+        .task-item {
-            display: flex;
+            display: flex;
-            justify-content: space-between;
+            justify-content: space-between;
-            align-items: center;
+            align-items: center;
-            padding: 12px;
+            padding: 12px;
-            border-bottom: 1px solid #e9ecef;
+            border-bottom: 1px solid #e9ecef;
-            transition: all 0.3s ease;
+            transition: all 0.3s ease;
-        }
+        }
-
+
-        .task-item:hover {
+        .task-item:hover {
-            background: #f8f9fa;
+            background: #f8f9fa;
-        }
+        }
-
+
-        .task-item:last-child {
+        .task-item:last-child {
-            border-bottom: none;
+            border-bottom: none;
-        }
+        }
-
+
-        .task-info {
+        .task-info {
-            flex: 1;
+            flex: 1;
-        }
+        }
-
+
-        .task-title {
+        .task-title {
-            font-weight: 600;
+            font-weight: 600;
-            color: #2c3e50;
+            color: #2c3e50;
-            margin-bottom: 5px;
+            margin-bottom: 5px;
-        }
+        }
-
+
-        .task-meta {
+        .task-meta {
-            font-size: 0.85rem;
+            font-size: 0.85rem;
-            color: #6c757d;
+            color: #6c757d;
-        }
+        }
-
+
-        .task-actions {
+        .task-actions {
-            display: flex;
+            display: flex;
-            gap: 8px;
+            gap: 8px;
-        }
+        }
-
+
-        .view-task-btn {
+        .view-task-btn {
-            padding: 6px 12px;
+            padding: 6px 12px;
-            background: #3498db;
+            background: #3498db;
-            color: white;
+            color: white;
-            border: none;
+            border: none;
-            border-radius: 6px;
+            border-radius: 6px;
-            cursor: pointer;
+            cursor: pointer;
-            font-size: 0.85rem;
+            font-size: 0.85rem;
-            text-decoration: none;
+            text-decoration: none;
-            display: inline-block;
+            display: inline-block;
-        }
+        }
-
+
-        .view-task-btn:hover {
+        .view-task-btn:hover {
-            background: #2980b9;
+            background: #2980b9;
-        }
+        }
-
+
-        .percentage-bar {
+        .percentage-bar {
-            height: 6px;
+            height: 6px;
-            background: #e9ecef;
+            background: #e9ecef;
-            border-radius: 3px;
+            border-radius: 3px;
-            margin-top: 8px;
+            margin-top: 8px;
-            overflow: hidden;
+            overflow: hidden;
-        }
+        }
-
+
-        .percentage-fill {
+        .percentage-fill {
-            height: 100%;
+            height: 100%;
-            background: #3498db;
+            background: #3498db;
-            border-radius: 3px;
+            border-radius: 3px;
-            transition: width 0.3s ease;
+            transition: width 0.3s ease;
-        }
+        }
-
+
-        .users-table {
+        .users-table {
-            width: 100%;
+            width: 100%;
-            border-collapse: collapse;
+            border-collapse: collapse;
-            margin-top: 20px;
+            margin-top: 20px;
-        }
+        }
-
+
-        .users-table th,
+        .users-table th,
-        .users-table td {
+        .users-table td {
-            padding: 12px;
+            padding: 12px;
-            text-align: left;
+            text-align: left;
-            border-bottom: 1px solid #e9ecef;
+            border-bottom: 1px solid #e9ecef;
-        }
+        }
-
+
-        .users-table th {
+        .users-table th {
-            background: #f8f9fa;
+            background: #f8f9fa;
-            font-weight: 600;
+            font-weight: 600;
-            color: #495057;
+            color: #495057;
-        }
+        }
-
+
-        .users-table tr:hover {
+        .users-table tr:hover {
-            background: #f8f9fa;
+            background: #f8f9fa;
-        }
+        }
-
+
-        .user-actions {
+        .user-actions {
-            display: flex;
+            display: flex;
-            gap: 8px;
+            gap: 8px;
-        }
+        }
-
+
-        .ldap-badge {
+        .ldap-badge {
-            background: #3498db;
+            background: #3498db;
-            color: white;
+            color: white;
-            padding: 3px 8px;
+            padding: 3px 8px;
-            border-radius: 12px;
+            border-radius: 12px;
-            font-size: 0.75rem;
+            font-size: 0.75rem;
-            margin-left: 5px;
+            margin-left: 5px;
-        }
+        }
-
+
-        .admin-badge {
+        .admin-badge {
-            background: #e74c3c;
+            background: #e74c3c;
-            color: white;
+            color: white;
-            padding: 3px 8px;
+            padding: 3px 8px;
-            border-radius: 12px;
+            border-radius: 12px;
-            font-size: 0.75rem;
+            font-size: 0.75rem;
-            margin-left: 5px;
+            margin-left: 5px;
-        }
+        }
-
+
-        .form-row {
+        .form-row {
-            display: flex;
+            display: flex;
-            gap: 20px;
+            gap: 20px;
-            margin-bottom: 20px;
+            margin-bottom: 20px;
-        }
+        }
-
+
-        .form-row .form-group {
+        .form-row .form-group {
-            flex: 1;
+            flex: 1;
-        }
+        }
-
+
-        .modal-lg {
+        .modal-lg {
-            max-width: 800px;
+            max-width: 800px;
-        }
+        }
-
+
-        .search-container {
+        .search-container {
-            display: flex;
+            display: flex;
-            gap: 10px;
+            gap: 10px;
-            margin-bottom: 20px;
+            margin-bottom: 20px;
-        }
+        }
-
+
-        .search-container input {
+        .search-container input {
-            flex: 1;
+            flex: 1;
-        }
+        }
-
+
-        .file-size {
+        .file-size {
-            font-size: 1.2rem;
+            font-size: 1.2rem;
-            color: #2c3e50;
+            color: #2c3e50;
-            margin-top: 5px;
+            margin-top: 5px;
-        }
+        }
-    </style>
+    </style>
-</head>
+</head>
-<body>
+<body>
-    <div id="login-modal" class="modal">
+    <div id="login-modal" class="modal">
-        <div class="modal-content">
+        <div class="modal-content">
-            <h2>Вход в School CRM</h2>
+            <h2>Вход в School CRM</h2>
-            <form id="login-form">
+            <form id="login-form">
-                <div class="form-group">
+                <div class="form-group">
-                    <label for="login">Логин:</label>
+                    <label for="login">Логин:</label>
-                    <input type="text" id="login" name="login" required>
+                    <input type="text" id="login" name="login" required>
-                </div>
+                </div>
-                <div class="form-group">
+                <div class="form-group">
-                    <label for="password">Пароль:</label>
+                    <label for="password">Пароль:</label>
-                    <input type="password" id="password" name="password" required>
+                    <input type="password" id="password" name="password" required>
-                </div>
+                </div>
-                <button type="submit">Войти</button>
+                <button type="submit">Войти</button>
-            </form>
+            </form>
-            <div class="test-users">
+            <div class="test-users">
-                <h3>Тестовые пользователи:</h3>
+                <h3>Тестовые пользователи:</h3>
-                <ul>
+                <ul>
-                    <li><strong>admin</strong> / admin123 (Администратор)</li>
+                    <li><strong>admin</strong> / admin123 (Администратор)</li>
-                    <li><strong>teacher</strong> / teacher123</li>
+                    <li><strong>teacher</strong> / teacher123</li>
-                </ul>
+                </ul>
-            </div>
+            </div>
-        </div>
+        </div>
-    </div>
+    </div>
-
+
-    <div class="admin-container">
+    <div class="admin-container">
-        <div class="admin-header">
+        <div class="admin-header">
-            <h1>Административная панель</h1>
+            <h1>Административная панель</h1>
-            <div class="user-info">
+            <div class="user-info">
-                <span id="current-user"></span>
+                <span id="current-user"></span>
-                <button onclick="window.location.href = '/'">Назад к задачам</button>
+                <button onclick="window.location.href = '/'">Назад к задачам</button>
-                <button onclick="logout()">Выйти</button>
+                <button onclick="logout()">Выйти</button>
-            </div>
+            </div>
-        </div>
+        </div>
-
+
-        <div class="admin-tabs">
+        <div class="admin-tabs">
-            <button class="admin-tab active" onclick="showAdminSection('dashboard')">Дашборд</button>
+            <button class="admin-tab active" onclick="showAdminSection('dashboard')">Дашборд</button>
-            <button class="admin-tab" onclick="showAdminSection('users')">Пользователи</button>
+            <button class="admin-tab" onclick="showAdminSection('users')">Пользователи</button>
-            <button class="admin-tab" onclick="showAdminSection('dashboard')">test</button>
+            <button class="admin-tab" onclick="showAdminSection('dashboard')">test</button>
-        </div>
+        </div>
-
+
-        <div id="admin-dashboard" class="admin-section active">
+        <div id="admin-dashboard" class="admin-section active">
-            <h2>Статистика системы</h2>
+            <h2>Статистика системы</h2>
-            
+            
-            <div class="stats-grid">
+            <div class="stats-grid">
-                <div class="stat-card task-stat">
+                <div class="stat-card task-stat">
-                    <h3>Задачи</h3>
+                    <h3>Задачи</h3>
-                    <div class="stat-value" id="total-tasks">0</div>
+                    <div class="stat-value" id="total-tasks">0</div>
-                    <div class="stat-desc">Всего задач в системе</div>
+                    <div class="stat-desc">Всего задач в системе</div>
-                    <div class="percentage-bar">
+                    <div class="percentage-bar">
-                        <div class="percentage-fill" id="active-tasks-bar" style="width: 0%"></div>
+                        <div class="percentage-fill" id="active-tasks-bar" style="width: 0%"></div>
-                    </div>
+                    </div>
-                    <div class="stat-subitems">
+                    <div class="stat-subitems">
-                        <div class="stat-subitem">
+                        <div class="stat-subitem">
-                            <span class="label">Активные:</span>
+                            <span class="label">Активные:</span>
-                            <span class="value" id="active-tasks">0</span>
+                            <span class="value" id="active-tasks">0</span>
-                        </div>
+                        </div>
-                        <div class="stat-subitem">
+                        <div class="stat-subitem">
-                            <span class="label">Закрытые:</span>
+                            <span class="label">Закрытые:</span>
-                            <span class="value" id="closed-tasks">0</span>
+                            <span class="value" id="closed-tasks">0</span>
-                        </div>
+                        </div>
-                        <div class="stat-subitem">
+                        <div class="stat-subitem">
-                            <span class="label">Удаленные:</span>
+                            <span class="label">Удаленные:</span>
-                            <span class="value" id="deleted-tasks">0</span>
+                            <span class="value" id="deleted-tasks">0</span>
-                        </div>
+                        </div>
-                    </div>
+                    </div>
-                </div>
+                </div>
-
+
-                <div class="stat-card status-stat">
+                <div class="stat-card status-stat">
-                    <h3>Статусы назначений</h3>
+                    <h3>Статусы назначений</h3>
-                    <div class="stat-value" id="total-assignments">0</div>
+                    <div class="stat-value" id="total-assignments">0</div>
-                    <div class="stat-desc">Всего назначений</div>
+                    <div class="stat-desc">Всего назначений</div>
-                    <div class="stat-subitems">
+                    <div class="stat-subitems">
-                        <div class="stat-subitem">
+                        <div class="stat-subitem">
-                            <span class="label">Назначено:</span>
+                            <span class="label">Назначено:</span>
-                            <span class="value" id="assigned-count">0</span>
+                            <span class="value" id="assigned-count">0</span>
-                        </div>
+                        </div>
-                        <div class="stat-subitem">
+                        <div class="stat-subitem">
-                            <span class="label">В работе:</span>
+                            <span class="label">В работе:</span>
-                            <span class="value" id="in-progress-count">0</span>
+                            <span class="value" id="in-progress-count">0</span>
-                        </div>
+                        </div>
-                        <div class="stat-subitem">
+                        <div class="stat-subitem">
-                            <span class="label">Выполнено:</span>
+                            <span class="label">Выполнено:</span>
-                            <span class="value" id="completed-count">0</span>
+                            <span class="value" id="completed-count">0</span>
-                        </div>
+                        </div>
-                        <div class="stat-subitem">
+                        <div class="stat-subitem">
-                            <span class="label">Просрочено:</span>
+                            <span class="label">Просрочено:</span>
-                            <span class="value" id="overdue-count">0</span>
+                            <span class="value" id="overdue-count">0</span>
-                        </div>
+                        </div>
-                        <div class="stat-subitem">
+                        <div class="stat-subitem">
-                            <span class="label">На доработке:</span>
+                            <span class="label">На доработке:</span>
-                            <span class="value" id="rework-count">0</span>
+                            <span class="value" id="rework-count">0</span>
-                        </div>
+                        </div>
-                    </div>
+                    </div>
-                </div>
+                </div>
-
+
-                <div class="stat-card user-stat">
+                <div class="stat-card user-stat">
-                    <h3>Пользователи</h3>
+                    <h3>Пользователи</h3>
-                    <div class="stat-value" id="total-users">0</div>
+                    <div class="stat-value" id="total-users">0</div>
-                    <div class="stat-desc">Зарегистрировано пользователей</div>
+                    <div class="stat-desc">Зарегистрировано пользователей</div>
-                    <div class="stat-subitems">
+                    <div class="stat-subitems">
-                        <div class="stat-subitem">
+                        <div class="stat-subitem">
-                            <span class="label">Администраторы:</span>
+                            <span class="label">Администраторы:</span>
-                            <span class="value" id="admin-users">0</span>
+                            <span class="value" id="admin-users">0</span>
-                        </div>
+                        </div>
-                        <div class="stat-subitem">
+                        <div class="stat-subitem">
-                            <span class="label">Учителя:</span>
+                            <span class="label">Учителя:</span>
-                            <span class="value" id="teacher-users">0</span>
+                            <span class="value" id="teacher-users">0</span>
-                        </div>
+                        </div>
-                        <div class="stat-subitem">
+                        <div class="stat-subitem">
-                            <span class="label">LDAP:</span>
+                            <span class="label">LDAP:</span>
-                            <span class="value" id="ldap-users">0</span>
+                            <span class="value" id="ldap-users">0</span>
-                        </div>
+                        </div>
-                        <div class="stat-subitem">
+                        <div class="stat-subitem">
-                            <span class="label">Локальные:</span>
+                            <span class="label">Локальные:</span>
-                            <span class="value" id="local-users">0</span>
+                            <span class="value" id="local-users">0</span>
-                        </div>
+                        </div>
-                    </div>
+                    </div>
-                </div>
+                </div>
-
+
-                <div class="stat-card file-stat">
+                <div class="stat-card file-stat">
-                    <h3>Файлы</h3>
+                    <h3>Файлы</h3>
-                    <div class="stat-value" id="total-files">0</div>
+                    <div class="stat-value" id="total-files">0</div>
-                    <div class="stat-desc">Всего загружено файлов</div>
+                    <div class="stat-desc">Всего загружено файлов</div>
-                    <div class="file-size" id="total-files-size">0 MB</div>
+                    <div class="file-size" id="total-files-size">0 MB</div>
-                </div>
+                </div>
-            </div>
+            </div>
-        </div>
+        </div>
-
+
-        <div id="admin-users-section" class="admin-section">
+        <div id="admin-users-section" class="admin-section">
-            <h2>Управление пользователями</h2>
+            <h2>Управление пользователями</h2>
-            
+            
-            <div class="search-container">
+            <div class="search-container">
-                <input type="text" id="user-search" placeholder="Поиск пользователей по логину, имени или email..." oninput="searchUsers()">
+                <input type="text" id="user-search" placeholder="Поиск пользователей по логину, имени или email..." oninput="searchUsers()">
-                <button onclick="loadUsers()">Сбросить</button>
+                <button onclick="loadUsers()">Сбросить</button>
-            </div>
+            </div>
-
+
-            <table class="users-table">
+            <table class="users-table">
-                <thead>
+                <thead>
-                    <tr>
+                    <tr>
-                        <th>ID</th>
+                        <th>ID</th>
-                        <th>Логин</th>
+                        <th>Логин</th>
-                        <th>Имя</th>
+                        <th>Имя</th>
-                        <th>Email</th>
+                        <th>Email</th>
-                        <th>Роль</th>
+                        <th>Роль</th>
-                        <th>Тип</th>
+                        <th>Тип</th>
-                        <th>Дата создания</th>
+                        <th>Дата создания</th>
-                        <th>Последний вход</th>
+                        <th>Последний вход</th>
-                        <th>Действия</th>
+                        <th>Действия</th>
-                    </tr>
+                    </tr>
-                </thead>
+                </thead>
-                <tbody id="users-table-body">
+                <tbody id="users-table-body">
-                    <tr>
+                    <tr>
-                        <td colspan="9" class="loading">Загрузка пользователей...</td>
+                        <td colspan="9" class="loading">Загрузка пользователей...</td>
-                    </tr>
+                    </tr>
-                </tbody>
+                </tbody>
-            </table>
+            </table>
-        </div>
+        </div>
-    </div>
+    </div>
-
+
-    <div id="edit-user-modal" class="modal">
+    <div id="edit-user-modal" class="modal">
-        <div class="modal-content modal-lg">
+        <div class="modal-content modal-lg">
-            <span class="close" onclick="closeEditUserModal()">&times;</span>
+            <span class="close" onclick="closeEditUserModal()">&times;</span>
-            <h3>Редактировать пользователя</h3>
+            <h3>Редактировать пользователя</h3>
-            <form id="edit-user-form">
+            <form id="edit-user-form">
-                <input type="hidden" id="edit-user-id">
+                <input type="hidden" id="edit-user-id">
-                
+                
-                <div class="form-row">
+                <div class="form-row">
-                    <div class="form-group">
+                    <div class="form-group">
-                        <label for="edit-login">Логин *</label>
+                        <label for="edit-login">Логин *</label>
-                        <input type="text" id="edit-login" name="login" required>
+                        <input type="text" id="edit-login" name="login" required>
-                    </div>
+                    </div>
-                    <div class="form-group">
+                    <div class="form-group">
-                        <label for="edit-name">Имя *</label>
+                        <label for="edit-name">Имя *</label>
-                        <input type="text" id="edit-name" name="name" required>
+                        <input type="text" id="edit-name" name="name" required>
-                    </div>
+                    </div>
-                </div>
+                </div>
-
+
-                <div class="form-row">
+                <div class="form-row">
-                    <div class="form-group">
+                    <div class="form-group">
-                        <label for="edit-email">Email *</label>
+                        <label for="edit-email">Email *</label>
-                        <input type="email" id="edit-email" name="email" required>
+                        <input type="email" id="edit-email" name="email" required>
-                    </div>
+                    </div>
-                    <div class="form-group">
+                    <div class="form-group">
-                        <label for="edit-role">Роль</label>
+                        <label for="edit-role">Роль</label>
-                        <select id="edit-role" name="role">
+                        <select id="edit-role" name="role">
-                            <option value="teacher">Учитель</option>
+                            <option value="teacher">Учитель</option>
-                            <option value="admin">Администратор</option>
+                            <option value="admin">Администратор</option>
-                        </select>
+                        </select>
-                    </div>
+                    </div>
-                </div>
+                </div>
-
+
-                <div class="form-row">
+                <div class="form-row">
-                    <div class="form-group">
+                    <div class="form-group">
-                        <label for="edit-auth-type">Тип авторизации</label>
+                        <label for="edit-auth-type">Тип авторизации</label>
-                        <select id="edit-auth-type" name="auth_type">
+                        <select id="edit-auth-type" name="auth_type">
-                            <option value="local">Локальная</option>
+                            <option value="local">Локальная</option>
-                            <option value="ldap">LDAP</option>
+                            <option value="ldap">LDAP</option>
-                        </select>
+                        </select>
-                    </div>
+                    </div>
-                    <div class="form-group">
+                    <div class="form-group">
-                        <label for="edit-groups">Группы (JSON)</label>
+                        <label for="edit-groups">Группы (JSON)</label>
-                        <input type="text" id="edit-groups" name="groups" placeholder='["group1", "group2"]'>
+                        <input type="text" id="edit-groups" name="groups" placeholder='["group1", "group2"]'>
-                    </div>
+                    </div>
-                </div>
+                </div>
-
+
-                <div class="form-group">
+                <div class="form-group">
-                    <label for="edit-description">Описание</label>
+                    <label for="edit-description">Описание</label>
-                    <textarea id="edit-description" name="description" rows="3"></textarea>
+                    <textarea id="edit-description" name="description" rows="3"></textarea>
-                </div>
+                </div>
-
+
-                <button type="submit">Сохранить изменения</button>
+                <button type="submit">Сохранить изменения</button>
-            </form>
+            </form>
-        </div>
+        </div>
-    </div>
+    </div>
-
+
-    <script src="admin-script.js"></script>
+    <script src="admin-script.js"></script>
-</body>
+</body>
 </html>

public/index.html

@@ -41,6 +41,7 @@
                 <button onclick="showSection('tasks')">Задачи</button>
                 <button onclick="showSection('create-task')">Создать задачу</button>
                 <button onclick="showTasksWithoutDate()" id="tasks-no-date-btn">Задачи без срока</button>
+                <button onclick="showKanbanSection()" class="nav-btn">📋 Канбан</button>
                 <button onclick="showSection('logs')">Лог активности</button>
                 <button onclick="window.location.href = '/admin'" style="background: linear-gradient(135deg, #e74c3c, #c0392b);">Админ-панель</button>
             </nav>
@@ -234,7 +235,16 @@
             </form>
         </div>
     </div>
-
+<div id="kanban-section" class="section kanban-section">
+    <div class="section-header">
+        <h2>📋 Канбан-доска</h2>
+        <p>Перетаскивайте задачи между колонками для изменения статуса</p>
+    </div>
+    
+    <div id="kanban-board" class="kanban-board">
+        <div class="loading">Загрузка Канбан-доски...</div>
+    </div>
+</div>
     <script src="script.js"></script>
 </body>
 </html>

public/script.js

@@ -5,6 +5,9 @@ let filteredUsers = [];
 let expandedTasks = new Set();
 let showingTasksWithoutDate = false;
 
+let kanbanTasks = [];
+let kanbanDays = 14;
+
 document.addEventListener('DOMContentLoaded', function() {
     checkAuth();
     setupEventListeners();
@@ -59,6 +62,7 @@ function showMainInterface() {
     loadTasks();
     loadActivityLogs();
     showSection('tasks');
+    loadKanbanTasks();
     
     showingTasksWithoutDate = false;
     const btn = document.getElementById('tasks-no-date-btn');
@@ -127,6 +131,9 @@ function showSection(sectionName) {
     } else if (sectionName === 'logs') {
         loadActivityLogs();
     }
+    if (sectionName === 'kanban') {
+    loadKanbanTasks();
+}
 }
 
 async function loadUsers() {
@@ -161,6 +168,355 @@ function populateFilterDropdowns() {
     });
 }
 
+function showKanbanSection() {
+    showSection('kanban');
+}
+
+async function loadKanbanTasks() {
+    try {
+        const daysSelect = document.getElementById('kanban-days');
+        const filterSelect = document.getElementById('kanban-filter');
+        
+        // Если есть выбор в интерфейсе - используем его, иначе - значение по умолчанию
+        if (daysSelect) {
+            kanbanDays = parseInt(daysSelect.value) || 14;
+        } else {
+            kanbanDays = 14;
+        }
+        
+        let filter = 'all';
+        if (filterSelect) {
+            filter = filterSelect.value;
+        }
+        
+        const response = await fetch(`/api/kanban-tasks?days=${kanbanDays}&filter=${filter}`);
+        if (!response.ok) {
+            throw new Error(`Ошибка сервера: ${response.status}`);
+        }
+        const data = await response.json();
+        kanbanTasks = data.tasks || [];
+        renderKanban(data.filter);
+    } catch (error) {
+        console.error('Ошибка загрузки задач для Канбана:', error);
+        document.getElementById('kanban-board').innerHTML = `
+            <div class="error-message">
+                ❌ Ошибка загрузки Канбана: ${error.message}
+                <button onclick="loadKanbanTasks()" class="retry-btn">Повторить</button>
+            </div>
+        `;
+    }
+}
+
+function renderKanban() {
+    const container = document.getElementById('kanban-board');
+    
+    // Группируем задачи по статусам
+    const columns = {
+        'unassigned': { title: 'Не назначены', tasks: [], color: '#95a5a6' },
+        'assigned': { title: 'Назначены', tasks: [], color: '#e74c3c' },
+        'in_progress': { title: 'В работе', tasks: [], color: '#f39c12' },
+        'rework': { title: 'На доработке', tasks: [], color: '#f1c40f' },
+        'overdue': { title: 'Просрочены', tasks: [], color: '#c0392b' },
+        'completed': { title: 'Выполнены', tasks: [], color: '#2ecc71' }
+    };
+    
+    // Распределяем задачи по колонкам
+    kanbanTasks.forEach(task => {
+        const status = task.kanbanStatus || 'unassigned';
+        if (columns[status]) {
+            columns[status].tasks.push(task);
+        }
+    });
+    
+    // Рендерим доску
+    container.innerHTML = `
+        <div class="kanban-controls">
+            <div class="kanban-period">
+                <label>Период просмотра:</label>
+                <select id="kanban-days" onchange="loadKanbanTasks()">
+                    ${[1, 2, 3, 4, 5, 6, 7, 14].map(days => 
+                        `<option value="${days}" ${days === kanbanDays ? 'selected' : ''}>${days} ${getDayWord(days)}</option>`
+                    ).join('')}
+                </select>
+            </div>
+            <div class="kanban-stats">
+                <span>Всего задач: ${kanbanTasks.length}</span>
+                <button onclick="loadKanbanTasks()" class="refresh-btn">🔄 Обновить</button>
+            </div>
+        </div>
+        
+        <div class="kanban-columns">
+            ${Object.entries(columns).map(([status, column]) => `
+                <div class="kanban-column" data-status="${status}">
+                    <div class="kanban-column-header" style="background: ${column.color}">
+                        <h3>${column.title}</h3>
+                        <span class="kanban-count">${column.tasks.length}</span>
+                    </div>
+                    <div class="kanban-column-body" id="kanban-column-${status}">
+                        ${renderKanbanCards(column.tasks)}
+                    </div>
+                </div>
+            `).join('')}
+        </div>
+    `;
+    
+    // Делаем колонки перетаскиваемыми
+    makeKanbanDraggable();
+}
+function renderKanbanCards(tasks, filter) {
+    if (tasks.length === 0) {
+        return '<div class="kanban-empty">Нет задач</div>';
+    }
+    
+    return tasks.map(task => {
+        // Определяем иконку роли
+        let roleIcon = '';
+        let roleTitle = '';
+        
+        if (task.userRole === 'creator') {
+            roleIcon = '👤';
+            roleTitle = 'Вы поставили эту задачу';
+        } else if (task.userRole === 'assignee') {
+            roleIcon = '🎯';
+            roleTitle = 'Вам поставили эту задачу';
+        }
+        
+        // Исправление: безопасное получение имени пользователя
+        const userName = task.assignments && task.assignments.length > 0 && task.assignments[0]?.user_name 
+            ? task.assignments[0].user_name 
+            : 'Неизвестно';
+        
+        // Исправление: безопасное получение первого символа имени
+        const userInitial = userName && userName.length > 0 ? userName.charAt(0) : '?';
+        
+        return `
+        <div class="kanban-card" draggable="true" data-task-id="${task.id}">
+            <div class="kanban-card-header">
+                <div class="kanban-task-id">#${task.id}</div>
+                <div class="kanban-task-role" title="${roleTitle}">${roleIcon}</div>
+                <div class="kanban-task-actions">
+                    <button onclick="openKanbanTask(${task.id})" title="Открыть">👁️</button>
+                    <button onclick="copyKanbanTask(${task.id})" title="Копировать">📋</button>
+                </div>
+            </div>
+            <div class="kanban-task-title" onclick="openKanbanTask(${task.id})">
+                ${task.title || 'Без названия'}
+            </div>
+            <div class="kanban-task-info">
+                <div class="kanban-deadline">
+                    ${task.due_date ? `<span class="kanban-date">📅 ${formatDate(task.due_date)}</span>` : '<span class="kanban-no-date">Без срока</span>'}
+                </div>
+                <div class="kanban-assignees">
+                    ${task.assignments && task.assignments.length > 0 ? 
+                        task.assignments.slice(0, 3).map(a => {
+                            // Исправление: безопасное получение имени исполнителя
+                            const assigneeName = a.user_name || 'Неизвестно';
+                            const assigneeInitial = assigneeName && assigneeName.length > 0 ? assigneeName.charAt(0) : '?';
+                            return `<span class="kanban-assignee" title="${assigneeName}">${assigneeInitial}</span>`;
+                        }).join('') : 
+                        '<span class="kanban-no-assignee">👤</span>'
+                    }
+                    ${task.assignments && task.assignments.length > 3 ? 
+                        `<span class="kanban-more-assignees">+${task.assignments.length - 3}</span>` : ''
+                    }
+                </div>
+            </div>
+            <div class="kanban-task-footer">
+                <span class="kanban-creator">👤 ${task.creator_name || 'Неизвестно'}</span>
+                ${task.files && task.files.length > 0 ? 
+                    `<span class="kanban-files">📎 ${task.files.length}</span>` : ''
+                }
+            </div>
+        </div>
+        `;
+    }).join('');
+}
+function renderKanban(filter = 'all') {
+    const container = document.getElementById('kanban-board');
+    
+    // Группируем задачи по статусам (убрали 'unassigned')
+    const columns = {
+        'assigned': { title: 'Назначены', tasks: [], color: '#e74c3c' },
+        'in_progress': { title: 'В работе', tasks: [], color: '#f39c12' },
+        'rework': { title: 'На доработке', tasks: [], color: '#f1c40f' },
+        'overdue': { title: 'Просрочены', tasks: [], color: '#c0392b' },
+        'completed': { title: 'Выполнены', tasks: [], color: '#2ecc71' }
+    };
+    
+    // Распределяем задачи по колонкам
+    kanbanTasks.forEach(task => {
+        const status = task.kanbanStatus || 'assigned';
+        // Преобразуем 'unassigned' в 'assigned'
+        const actualStatus = status === 'unassigned' ? 'assigned' : status;
+        
+        if (columns[actualStatus]) {
+            columns[actualStatus].tasks.push(task);
+        } else {
+            // Если статус не найден, добавляем в 'assigned'
+            columns['assigned'].tasks.push(task);
+        }
+    });
+    
+    // Статистика по фильтру
+    let filterTitle = 'Все задачи';
+    if (filter === 'created') filterTitle = 'Задачи, которые я поставил';
+    if (filter === 'assigned') filterTitle = 'Задачи, которые мне поставили';
+    
+    container.innerHTML = `
+        <div class="kanban-controls">
+            <div class="kanban-filters">
+                <div class="kanban-period">
+                    <label>Период просмотра:</label>
+                    <select id="kanban-days" onchange="loadKanbanTasks()">
+                        ${[1, 2, 3, 4, 5, 6, 7, 14, 30, 62].map(days => 
+                            `<option value="${days}" ${days === kanbanDays ? 'selected' : ''}>${days} ${getDayWord(days)}</option>`
+                        ).join('')}
+                    </select>
+                </div>
+                <div class="kanban-filter-type">
+                    <label>Показать:</label>
+                    <select id="kanban-filter" onchange="loadKanbanTasks()">
+                        <option value="all" ${filter === 'all' ? 'selected' : ''}>Все задачи</option>
+                        <option value="created" ${filter === 'created' ? 'selected' : ''}>Я поставил</option>
+                        <option value="assigned" ${filter === 'assigned' ? 'selected' : ''}>Мне поставили</option>
+                    </select>
+                </div>
+                <div class="kanban-stats">
+                    <span class="filter-title">${filterTitle}</span>
+                    <span class="task-count">Всего задач: ${kanbanTasks.length}</span>
+                    <button onclick="loadKanbanTasks()" class="refresh-btn">🔄 Обновить</button>
+                </div>
+            </div>
+        </div>
+        
+        <div class="kanban-columns">
+            ${Object.entries(columns).map(([status, column]) => `
+                <div class="kanban-column" data-status="${status}" ${status === 'overdue' || status === 'assigned' ? 'ondragover="return false" ondrop="return false"' : ''}>
+                    <div class="kanban-column-header" style="background: ${column.color}">
+                        <h3>${column.title}</h3>
+                        <span class="kanban-count">${column.tasks.length}</span>
+                    </div>
+                    <div class="kanban-column-body" id="kanban-column-${status}" 
+                         ${status === 'overdue' || status === 'assigned' ? 'style="opacity: 0.6; cursor: not-allowed;"' : ''}>
+                        ${renderKanbanCards(column.tasks, filter)}
+                    </div>
+                </div>
+            `).join('')}
+        </div>
+    `;
+    
+    // Делаем колонки перетаскиваемыми (кроме 'overdue' и 'assigned')
+    makeKanbanDraggable();
+}
+
+function getDayWord(days) {
+    if (days === 1) return 'день';
+    if (days >= 2 && days <= 4) return 'дня';
+    return 'дней';
+}
+
+function makeKanbanDraggable() {
+    const cards = document.querySelectorAll('.kanban-card');
+    const columns = document.querySelectorAll('.kanban-column-body:not([style*="opacity: 0.6"])');
+    
+    cards.forEach(card => {
+        card.addEventListener('dragstart', (e) => {
+            e.dataTransfer.setData('text/plain', card.dataset.taskId);
+            card.classList.add('dragging');
+        });
+        
+        card.addEventListener('dragend', () => {
+            card.classList.remove('dragging');
+        });
+    });
+    
+    columns.forEach(column => {
+        const status = column.parentElement.dataset.status;
+        
+        // Запрещаем перетаскивание в 'overdue' и 'assigned'
+        if (status === 'overdue' || status === 'assigned') {
+            return;
+        }
+        
+        column.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            const draggingCard = document.querySelector('.dragging');
+            if (draggingCard) {
+                column.appendChild(draggingCard);
+            }
+        });
+        
+        column.addEventListener('drop', async (e) => {
+            e.preventDefault();
+            const taskId = e.dataTransfer.getData('text/plain');
+            const newStatus = column.parentElement.dataset.status;
+            
+            if (taskId) {
+                try {
+                    // Запрещаем установку статуса 'overdue' и 'assigned'
+                    if (newStatus === 'overdue' || newStatus === 'assigned') {
+                        alert('Невозможно изменить статус задачи на "Просрочены" или "Назначены" через Канбан');
+                        // Возвращаем задачу в исходное положение
+                        loadKanbanTasks();
+                        return;
+                    }
+                    
+                    // Обновляем статус на сервере
+                    const response = await fetch(`/api/kanban-tasks/${taskId}/status`, {
+                        method: 'PUT',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({ status: newStatus })
+                    });
+                    
+                    if (response.ok) {
+                        // Перезагружаем Канбан
+                        loadKanbanTasks();
+                    } else {
+                        const error = await response.json();
+                        alert(`Ошибка обновления статуса: ${error.error || 'Неизвестная ошибка'}`);
+                        // Возвращаем задачу в исходное положение
+                        loadKanbanTasks();
+                    }
+                } catch (error) {
+                    console.error('Ошибка обновления статуса:', error);
+                    alert('Ошибка обновления статуса');
+                    loadKanbanTasks();
+                }
+            }
+        });
+    });
+}
+
+function openKanbanTask(taskId) {
+    // Находим задачу и открываем её в основном интерфейсе
+    const task = kanbanTasks.find(t => t.id == taskId);
+    if (task) {
+        showSection('tasks');
+        // Прокручиваем к задаче
+        setTimeout(() => {
+            const taskElement = document.querySelector(`.task-card[data-task-id="${taskId}"]`);
+            if (taskElement) {
+                taskElement.scrollIntoView({ behavior: 'smooth', block: 'center' });
+                // Раскрываем задачу если она свернута
+                if (!expandedTasks.has(taskId)) {
+                    toggleTask(taskId);
+                }
+            }
+        }, 100);
+    }
+}
+
+function copyKanbanTask(taskId) {
+    openCopyModal(taskId);
+}
+
+function formatDate(dateString) {
+    if (!dateString) return '';
+    const date = new Date(dateString);
+    return date.toLocaleDateString('ru-RU');
+}
 function filterUsers() {
     const search = document.getElementById('user-search').value.toLowerCase();
     filteredUsers = users.filter(user => 
@@ -1081,7 +1437,18 @@ function getUserRoleInTask(task) {
     if (!currentUser) return 'Нет доступа';
     
     if (currentUser.role === 'admin') return 'Администратор';
-    if (parseInt(task.created_by) === currentUser.id) return 'Заказчик';
+    
+    if (parseInt(task.created_by) === currentUser.id) {
+        if (task.assignments && task.assignments.length > 0) {
+            const assignedToOthers = task.assignments.some(assignment => 
+                parseInt(assignment.user_id) !== currentUser.id
+            );
+            if (assignedToOthers) {
+                return 'Создатель (только просмотр)';
+            }
+        }
+        return 'Создатель';
+    }
     
     if (task.assignments) {
         const isExecutor = task.assignments.some(assignment => 
@@ -1105,8 +1472,37 @@ function getRoleBadgeClass(role) {
 function canUserEditTask(task) {
     if (!currentUser) return false;
     
+    // Администратор может всё
     if (currentUser.role === 'admin') return true;
-    if (parseInt(task.created_by) === currentUser.id) return true;
+    
+    // Создатель может редактировать свою задачу
+    if (parseInt(task.created_by) === currentUser.id) {
+        // Но если задача уже назначена другим пользователям,
+        // создатель может только просматривать
+        if (task.assignments && task.assignments.length > 0) {
+            // Проверяем, назначена ли задача другим пользователям (не только себе)
+            const assignedToOthers = task.assignments.some(assignment => 
+                parseInt(assignment.user_id) !== currentUser.id
+            );
+            
+            if (assignedToOthers) {
+                // Создатель может только просматривать и закрывать задачу
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    // Исполнитель может менять только свой статус
+    if (task.assignments) {
+        const isExecutor = task.assignments.some(assignment => 
+            parseInt(assignment.user_id) === currentUser.id
+        );
+        if (isExecutor) {
+            // Исполнитель может менять только статус
+            return false;
+        }
+    }
     
     return false;
 }

public/style.css

@@ -1822,4 +1822,393 @@ button.reopen-btn:hover {
 
 .assignment:last-child {
     margin-bottom: 0;
+}
+/* Добавить в стили */
+.kanban-section {
+    padding: 20px;
+}
+
+.kanban-board {
+    background: #f5f5f5;
+    border-radius: 10px;
+    padding: 20px;
+    min-height: 70vh;
+}
+
+.kanban-controls {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 20px;
+    padding: 15px;
+    background: white;
+    border-radius: 8px;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+.kanban-period {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+}
+
+.kanban-period label {
+    font-weight: bold;
+}
+
+.kanban-period select {
+    padding: 8px 15px;
+    border: 2px solid #3498db;
+    border-radius: 5px;
+    background: white;
+    font-size: 14px;
+    cursor: pointer;
+}
+
+.kanban-stats {
+    display: flex;
+    align-items: center;
+    gap: 15px;
+}
+
+.kanban-stats span {
+    font-weight: bold;
+    color: #2c3e50;
+}
+
+.refresh-btn {
+    padding: 8px 15px;
+    background: #3498db;
+    color: white;
+    border: none;
+    border-radius: 5px;
+    cursor: pointer;
+    font-size: 14px;
+}
+
+.refresh-btn:hover {
+    background: #2980b9;
+}
+
+.kanban-columns {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 20px;
+    margin-top: 20px;
+}
+
+.kanban-column {
+    background: white;
+    border-radius: 8px;
+    overflow: hidden;
+    box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+    min-height: 500px;
+}
+
+.kanban-column-header {
+    padding: 15px;
+    color: white;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.kanban-column-header h3 {
+    margin: 0;
+    font-size: 16px;
+}
+
+.kanban-count {
+    background: rgba(255,255,255,0.3);
+    padding: 3px 10px;
+    border-radius: 20px;
+    font-weight: bold;
+}
+
+.kanban-column-body {
+    padding: 15px;
+    min-height: 450px;
+    max-height: 600px;
+    overflow-y: auto;
+}
+
+.kanban-empty {
+    text-align: center;
+    padding: 40px 20px;
+    color: #95a5a6;
+    font-style: italic;
+}
+
+.kanban-card {
+    background: white;
+    border: 1px solid #e0e0e0;
+    border-radius: 6px;
+    padding: 15px;
+    margin-bottom: 15px;
+    cursor: move;
+    transition: all 0.3s ease;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+}
+
+.kanban-card:hover {
+    box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+    transform: translateY(-2px);
+    border-color: #3498db;
+}
+
+.kanban-card.dragging {
+    opacity: 0.5;
+    transform: rotate(5deg);
+}
+
+.kanban-card-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 10px;
+}
+
+.kanban-task-id {
+    font-size: 12px;
+    color: #7f8c8d;
+    font-weight: bold;
+}
+
+.kanban-task-actions {
+    display: flex;
+    gap: 5px;
+}
+
+.kanban-task-actions button {
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-size: 14px;
+    opacity: 0.7;
+}
+
+.kanban-task-actions button:hover {
+    opacity: 1;
+}
+
+.kanban-task-title {
+    font-weight: bold;
+    margin-bottom: 10px;
+    cursor: pointer;
+    color: #2c3e50;
+}
+
+.kanban-task-title:hover {
+    color: #3498db;
+}
+
+.kanban-task-info {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 10px;
+    font-size: 12px;
+}
+
+.kanban-deadline {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+}
+
+.kanban-date {
+    color: #e74c3c;
+    font-weight: bold;
+}
+
+.kanban-no-date {
+    color: #95a5a6;
+    font-style: italic;
+}
+
+.kanban-assignees {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+}
+
+.kanban-assignee {
+    width: 24px;
+    height: 24px;
+    border-radius: 50%;
+    background: #3498db;
+    color: white;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 10px;
+    font-weight: bold;
+}
+
+.kanban-no-assignee {
+    opacity: 0.5;
+}
+
+.kanban-more-assignees {
+    font-size: 10px;
+    color: #7f8c8d;
+    margin-left: 5px;
+}
+
+.kanban-task-footer {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 11px;
+    color: #7f8c8d;
+    border-top: 1px solid #f0f0f0;
+    padding-top: 8px;
+    margin-top: 8px;
+}
+
+.kanban-creator {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+}
+
+.kanban-files {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+}
+
+/* Адаптивность */
+@media (max-width: 1200px) {
+    .kanban-columns {
+        grid-template-columns: repeat(2, 1fr);
+    }
+}
+
+@media (max-width: 768px) {
+    .kanban-columns {
+        grid-template-columns: 1fr;
+    }
+    
+    .kanban-controls {
+        flex-direction: column;
+        gap: 15px;
+        align-items: stretch;
+    }
+}
+.error-message {
+    background: #ffebee;
+    border: 1px solid #f44336;
+    border-radius: 8px;
+    padding: 20px;
+    text-align: center;
+    color: #c62828;
+    margin: 20px;
+}
+
+.retry-btn {
+    background: #4CAF50;
+    color: white;
+    border: none;
+    padding: 10px 20px;
+    border-radius: 4px;
+    cursor: pointer;
+    margin-top: 10px;
+    font-size: 14px;
+}
+
+.retry-btn:hover {
+    background: #45a049;
+}
+.kanban-filters {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 20px;
+    align-items: center;
+    margin-bottom: 20px;
+    padding: 15px;
+    background: #f8f9fa;
+    border-radius: 8px;
+    border: 1px solid #e9ecef;
+}
+
+.kanban-period, .kanban-filter-type {
+    display: flex;
+    flex-direction: column;
+    gap: 5px;
+}
+
+.kanban-period label, .kanban-filter-type label {
+    font-size: 12px;
+    color: #6c757d;
+    font-weight: 500;
+}
+
+.kanban-period select, .kanban-filter-type select {
+    padding: 8px 12px;
+    border: 1px solid #dee2e6;
+    border-radius: 4px;
+    background: white;
+    font-size: 14px;
+    min-width: 150px;
+}
+
+.kanban-stats {
+    display: flex;
+    align-items: center;
+    gap: 15px;
+    margin-left: auto;
+}
+
+.filter-title {
+    font-weight: 600;
+    color: #495057;
+    background: #e9ecef;
+    padding: 6px 12px;
+    border-radius: 20px;
+    font-size: 14px;
+}
+
+.task-count {
+    color: #6c757d;
+    font-size: 14px;
+}
+
+.refresh-btn {
+    background: #6c757d;
+    color: white;
+    border: none;
+    padding: 8px 16px;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 14px;
+    display: flex;
+    align-items: center;
+    gap: 5px;
+}
+
+.refresh-btn:hover {
+    background: #5a6268;
+}
+
+.kanban-task-role {
+    font-size: 16px;
+    cursor: help;
+    margin: 0 5px;
+}
+.kanban-column[data-status="overdue"] .kanban-column-body,
+.kanban-column[data-status="assigned"] .kanban-column-body {
+    opacity: 0.6;
+    cursor: not-allowed !important;
+}
+
+.kanban-column[data-status="overdue"] .kanban-card,
+.kanban-column[data-status="assigned"] .kanban-card {
+    cursor: not-allowed !important;
+}
+
+.kanban-column[data-status="overdue"] .kanban-card:hover,
+.kanban-column[data-status="assigned"] .kanban-card:hover {
+    transform: none !important;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1) !important;
 }

server-init.js

@@ -0,0 +1,83 @@
+// server-init.js
+const path = require('path');
+const fs = require('fs');
+const { setupUploadMiddleware } = require('./upload-middleware');
+const { setupTaskEndpoints } = require('./task-endpoints');
+
+async function initializeServer(app) {
+    console.log('🚀 Инициализация сервера...');
+    
+    try {
+        const { initializeDatabase, getDb, isInitialized } = require('./database');
+        const authService = require('./auth');
+        const postgresLogger = require('./postgres');
+        
+        // 1. Инициализируем базу данных
+        console.log('🔧 Инициализация базы данных...');
+        await initializeDatabase();
+        
+        // 2. Получаем объект БД
+        const db = getDb();
+        console.log('✅ База данных готова');
+        
+        // 3. Настраиваем authService с БД
+        authService.setDatabase(db);
+        console.log('✅ Сервис аутентификации готов');
+        
+        // 4. Настраиваем загрузку файлов
+        const upload = setupUploadMiddleware();
+        console.log('✅ Middleware загрузки файлов настроен');
+        
+        // 5. Настраиваем endpoint'ы для задач
+        setupTaskEndpoints(app, db, upload);
+        console.log('✅ Endpoint\'ы задач настроены');
+        
+        // 6. Загружаем админ роутер
+        try {
+            const adminRouter = require('./admin-server');
+            console.log('Admin router loaded:', adminRouter);
+            console.log('Type:', typeof adminRouter);
+            
+            if (adminRouter && typeof adminRouter === 'function') {
+                app.use(adminRouter);
+                console.log('✅ Админ роутер подключен');
+            } else {
+                console.error('❌ Admin router is not a valid middleware function');
+                // Создаем заглушку, чтобы сервер работал
+                const express = require('express');
+                const stubRouter = express.Router();
+                stubRouter.get('*', (req, res) => {
+                    res.status(501).json({ error: 'Admin router not available' });
+                });
+                app.use(stubRouter);
+                console.log('⚠️  Используется заглушка для админ роутера');
+            }
+        } catch (error) {
+            console.error('❌ Ошибка загрузки админ роутера:', error.message);
+            console.error('Stack:', error.stack);
+            
+            // Создаем заглушку, чтобы сервер не падал
+            const express = require('express');
+            const stubRouter = express.Router();
+            stubRouter.get('*', (req, res) => {
+                res.status(503).json({ 
+                    error: 'Admin panel temporarily unavailable',
+                    message: error.message 
+                });
+            });
+            app.use(stubRouter);
+            console.log('⚠️  Создана заглушка для админ роутера из-за ошибки');
+        }
+        
+        console.log('✅ Сервер полностью инициализирован');
+        
+        return { db, upload };
+        
+    } catch (error) {
+        console.error('❌ Ошибка инициализации сервера:', error.message);
+        console.error(error.stack);
+        throw error;
+    }
+}
+
+module.exports = { initializeServer };

upload-middleware.js

@@ -0,0 +1,40 @@
+// upload-middleware.js
+const multer = require('multer');
+const path = require('path');
+const fs = require('fs');
+
+function setupUploadMiddleware() {
+    const { createUserTaskFolder } = require('./database');
+    
+    const storage = multer.diskStorage({
+        destination: (req, file, cb) => {
+            const taskId = req.body.taskId || req.params.taskId;
+            const userLogin = req.session.user?.login;
+            
+            if (taskId && userLogin) {
+                const userFolder = createUserTaskFolder(taskId, userLogin);
+                cb(null, userFolder);
+            } else {
+                const tempDir = path.join(__dirname, 'data', 'uploads', 'temp');
+                if (!fs.existsSync(tempDir)) {
+                    fs.mkdirSync(tempDir, { recursive: true });
+                }
+                cb(null, tempDir);
+            }
+        },
+        filename: (req, file, cb) => {
+            const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
+            cb(null, uniqueSuffix + path.extname(file.originalname));
+        }
+    });
+
+    return multer({
+        storage: storage,
+        limits: {
+            fileSize: 300 * 1024 * 1024,
+            files: 15
+        }
+    });
+}
+
+module.exports = { setupUploadMiddleware };