%

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;
+                        const { password, ...userWithoutPassword } = user;
-                    resolve(userWithoutPassword);
+                        resolve(userWithoutPassword);
-                } else {
+                    } else {
-                    resolve(null);
+                        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 (!process.env.LDAP_AUTH_URL) {
+                console.log('⚠️ LDAP_AUTH_URL не задан в .env');
+                return null;
+            }
 
-        if (data.success) {
+            const response = await fetch(process.env.LDAP_AUTH_URL, {
-            return this.processLDAPUser(data);
+                method: 'POST',
-        } else {
+                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 { username, full_name, groups, description } = ldapData;
-    const allowedGroups = process.env.ALLOWED_GROUPS ? 
-        process.env.ALLOWED_GROUPS.split(',').map(g => g.trim()) : [];
         
-    // ВАЖНО: Проверяем актуальные группы при каждом входе
+        // Определяем роль пользователя на основе групп
-    const isAdmin = groups && groups.some(group => 
+        const allowedGroups = process.env.ALLOWED_GROUPS ? 
-        allowedGroups.includes(group)
+            process.env.ALLOWED_GROUPS.split(',').map(g => g.trim()) : [];
-    );
         
-    const role = isAdmin ? 'admin' : 'teacher';
+        // ВАЖНО: Проверяем актуальные группы при каждом входе
+        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 = {
+        // Сохраняем/обновляем пользователя в базе
-                login: username,
+        return new Promise((resolve, reject) => {
-                name: full_name || username,
+            this.db.get("SELECT * FROM users WHERE login = ? AND auth_type = 'ldap'", [username], async (err, existingUser) => {
-                email: `${username}@school25.ru`,
+                if (err) {
-                role: role, // Всегда обновляем роль из актуальных групп
+                    reject(err);
-                auth_type: 'ldap',
+                    return;
-                groups: groups ? JSON.stringify(groups) : '[]',
+                }
-                description: description || '',
-                last_login: new Date().toISOString()
-            };
 
-            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 установлено');
-        console.log('База данных расположена:', dbPath);
-        initializeDatabase();
-    }
-});
     
-function initializeDatabase() {
+    if (USE_POSTGRES) {
+        // Используем PostgreSQL
+        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,
+            });
+
+            // Тестируем подключение
+            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
+};

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

@@ -1823,3 +1823,392 @@ 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 };