Описание изменений

backend/routes/access.js

@@ -4,43 +4,24 @@ const { Pool } = require('pg');
 const { requireAuth, requireAdmin } = require('../middleware/auth');
 const db = require('../db');
 const { ethers } = require('ethers');
-
-// Подключение к БД
-const pool = new Pool({
-  connectionString: process.env.DATABASE_URL,
-  ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false,
-});
+const authService = require('../services/auth-service');
+const logger = require('../utils/logger');
 
 // Проверка доступа
 router.get('/check', async (req, res) => {
-  const walletAddress = req.headers['x-wallet-address'];
-
-  if (!walletAddress) {
-    return res.status(400).json({ error: 'No wallet address provided' });
-  }
-
   try {
-    // Проверяем наличие активного токена для адреса
-    const result = await pool.query(
-      'SELECT * FROM access_tokens WHERE wallet_address = $1 AND expires_at > NOW()',
-      [walletAddress.toLowerCase()]
-    );
-
-    if (result.rows.length === 0) {
-      return res.json({ hasAccess: false });
+    const { address } = req.query;
+    
+    if (!address) {
+      return res.status(400).json({ error: 'Address is required' });
     }
-
-    const token = result.rows[0];
-
-    res.json({
-      hasAccess: true,
-      tokenId: token.id,
-      role: token.role,
-      expiresAt: token.expires_at,
-    });
+    
+    const isAdmin = await authService.checkAdminToken(address);
+    
+    res.json({ isAdmin });
   } catch (error) {
-    console.error('Access check error:', error);
-    res.status(500).json({ error: error.message });
+    logger.error(`Error checking access: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 
@@ -63,40 +44,14 @@ router.get('/admin-only', async (req, res) => {
   }
 });
 
-// Получение списка токенов
+// Получение всех токенов доступа
 router.get('/tokens', async (req, res) => {
-  const walletAddress = req.headers['x-wallet-address'];
-
-  if (!walletAddress) {
-    return res.status(400).json({ error: 'No wallet address provided' });
-  }
-
   try {
-    // Проверяем права администратора
-    const adminCheck = await pool.query(
-      'SELECT * FROM access_tokens WHERE wallet_address = $1 AND role = $2 AND expires_at > NOW()',
-      [walletAddress.toLowerCase(), 'ADMIN']
-    );
-
-    if (adminCheck.rows.length === 0) {
-      return res.status(403).json({ error: 'Access denied' });
-    }
-
-    // Получаем список всех токенов
-    const result = await pool.query('SELECT * FROM access_tokens ORDER BY created_at DESC');
-
-    res.json(
-      result.rows.map((token) => ({
-        id: token.id,
-        walletAddress: token.wallet_address,
-        role: token.role,
-        createdAt: token.created_at,
-        expiresAt: token.expires_at,
-      }))
-    );
+    const tokens = await authService.getAllTokens();
+    res.json(tokens);
   } catch (error) {
-    console.error('Tokens list error:', error);
-    res.status(500).json({ error: error.message });
+    logger.error(`Error getting tokens: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 
@@ -110,12 +65,9 @@ router.post('/tokens', async (req, res) => {
 
   try {
     // Проверяем права администратора
-    const adminCheck = await pool.query(
-      'SELECT * FROM access_tokens WHERE wallet_address = $1 AND role = $2 AND expires_at > NOW()',
-      [walletAddress.toLowerCase(), 'ADMIN']
-    );
+    const isAdmin = await authService.checkAdminToken(walletAddress);
 
-    if (adminCheck.rows.length === 0) {
+    if (!isAdmin) {
       return res.status(403).json({ error: 'Access denied' });
     }
 
@@ -130,7 +82,7 @@ router.post('/tokens', async (req, res) => {
     expiresAt.setDate(expiresAt.getDate() + parseInt(expiresInDays));
 
     // Создаем токен
-    const result = await pool.query(
+    const result = await db.query(
       'INSERT INTO access_tokens (wallet_address, role, expires_at) VALUES ($1, $2, $3) RETURNING *',
       [targetAddress.toLowerCase(), role, expiresAt]
     );
@@ -158,19 +110,16 @@ router.delete('/tokens/:id', async (req, res) => {
 
   try {
     // Проверяем права администратора
-    const adminCheck = await pool.query(
-      'SELECT * FROM access_tokens WHERE wallet_address = $1 AND role = $2 AND expires_at > NOW()',
-      [walletAddress.toLowerCase(), 'ADMIN']
-    );
+    const isAdmin = await authService.checkAdminToken(walletAddress);
 
-    if (adminCheck.rows.length === 0) {
+    if (!isAdmin) {
       return res.status(403).json({ error: 'Access denied' });
     }
 
     const { id } = req.params;
 
     // Удаляем токен
-    await pool.query('DELETE FROM access_tokens WHERE id = $1', [id]);
+    await db.query('DELETE FROM access_tokens WHERE id = $1', [id]);
 
     res.json({ success: true });
   } catch (error) {
@@ -182,118 +131,95 @@ router.delete('/tokens/:id', async (req, res) => {
 // Получение информации о роли текущего пользователя
 router.get('/role', requireAuth, async (req, res) => {
   try {
-    const address = req.session.address.toLowerCase();
-
-    const result = await db.query(
-      'SELECT r.name as role FROM users u JOIN roles r ON u.role_id = r.id WHERE LOWER(u.address) = $1',
-      [address]
-    );
-
-    if (result.rows.length === 0) {
-      return res.status(404).json({ error: 'Пользователь не найден' });
-    }
-
-    return res.json({ role: result.rows[0].role });
+    const role = await authService.getUserRole(req.user.id);
+    return res.json({ role });
   } catch (error) {
-    console.error('Ошибка при получении роли:', error);
+    logger.error('Ошибка при получении роли:', error);
     return res.status(500).json({ error: 'Внутренняя ошибка сервера' });
   }
 });
 
 // Получение списка всех пользователей (только для администраторов)
-router.get('/users', requireAdmin, async (req, res) => {
+router.get('/users', requireAuth, requireAdmin, async (req, res) => {
   try {
-    const result = await db.query(
-      'SELECT u.id, u.wallet_address, r.name as role, u.created_at FROM users u JOIN roles r ON u.role_id = r.id'
-    );
+    const result = await db.query(`
+      SELECT u.id, ui.identity_value as wallet_address, r.name as role, u.created_at 
+      FROM users u 
+      JOIN roles r ON u.role_id = r.id
+      LEFT JOIN user_identities ui ON u.id = ui.user_id AND ui.identity_type = 'wallet'
+    `);
 
     return res.json(result.rows);
   } catch (error) {
-    console.error('Ошибка при получении списка пользователей:', error);
+    logger.error('Ошибка при получении списка пользователей:', error);
     return res.status(500).json({ error: 'Внутренняя ошибка сервера' });
   }
 });
 
-// Изменение роли пользователя (только для администраторов)
-router.post('/users/:userId/role', requireAdmin, async (req, res) => {
+// Обновление роли пользователя
+router.post('/update-role', async (req, res) => {
   try {
-    const { userId } = req.params;
-    const { role } = req.body;
-
-    if (!role || !['admin', 'user'].includes(role)) {
-      return res.status(400).json({ error: 'Некорректная роль' });
+    const { userId, role } = req.body;
+    
+    if (!userId || !role) {
+      return res.status(400).json({ error: 'User ID and role are required' });
+    }
+    
+    const success = await authService.updateUserRole(userId, role);
+    
+    if (success) {
+      res.json({ success: true });
+    } else {
+      res.status(400).json({ error: 'Failed to update role' });
     }
-
-    await db.query(
-      'UPDATE users SET role_id = (SELECT id FROM roles WHERE name = $1) WHERE id = $2',
-      [role, userId]
-    );
-
-    return res.json({ success: true });
   } catch (error) {
-    console.error('Ошибка при изменении роли пользователя:', error);
-    return res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+    logger.error(`Error updating role: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 
-// Получение информации о токенах доступа текущего пользователя
-router.get('/tokens', requireAuth, async (req, res) => {
+// Связывание нового идентификатора с аккаунтом
+router.post('/link-identity', requireAuth, async (req, res) => {
   try {
-    // Логирование для отладки
-    console.log('GET /api/access/tokens запрос получен');
-    console.log('Сессия пользователя:', req.session);
-
-    // Получаем адрес из сессии, а не из заголовков
-    if (!req.session || !req.session.address) {
-      return res.status(400).json({ error: 'No wallet address in session' });
+    const { identityType, identityValue } = req.body;
+    
+    if (!identityType || !identityValue) {
+      return res.status(400).json({ error: 'Отсутствуют обязательные поля' });
     }
-
-    const address = req.session.address.toLowerCase();
-
-    // Используем правильное имя таблицы и полей
-    const result = await db.query(
-      'SELECT id, wallet_address, role, created_at, expires_at FROM access_tokens WHERE LOWER(wallet_address) = $1',
-      [address]
-    );
-
-    return res.json(result.rows);
-  } catch (error) {
-    console.error('Ошибка при получении токенов:', error);
-    res.status(500).json({ error: 'Ошибка сервера' });
-  }
-});
-
-router.post('/mint', requireAuth, requireAdmin, async (req, res) => {
-  try {
-    // Логирование для отладки
-    console.log('POST /api/access/mint запрос получен');
-    console.log('Данные запроса:', req.body);
-
-    const { walletAddress, role, expiresInDays } = req.body;
-
-    if (!walletAddress || !role || !expiresInDays) {
-      return res.status(400).json({ error: 'Missing required fields' });
+    
+    // Проверяем, не привязан ли уже этот идентификатор к другому пользователю
+    const existingUserId = await authService.getUserIdByIdentity(identityType, identityValue);
+    
+    if (existingUserId && existingUserId !== req.user.id) {
+      return res.status(400).json({ error: 'Этот идентификатор уже привязан к другому аккаунту' });
     }
-
-    // Вычисляем дату истечения
-    const expiresAt = new Date();
-    expiresAt.setDate(expiresAt.getDate() + parseInt(expiresInDays));
-
-    // Создаем токен
-    const result = await pool.query(
-      'INSERT INTO access_tokens (wallet_address, role, expires_at) VALUES ($1, $2, $3) RETURNING *',
-      [walletAddress.toLowerCase(), role, expiresAt]
-    );
-
+    
+    // Добавляем новый идентификатор
+    if (!existingUserId) {
+      await db.query(
+        'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
+        [req.user.id, identityType, identityValue]
+      );
+    }
+    
+    // Если добавлен кошелек, проверяем токены
+    if (identityType === 'wallet') {
+      await authService.checkTokensAndUpdateRole(identityValue);
+    }
+    
+    // Получаем все идентификаторы пользователя
+    const identities = await authService.getAllUserIdentities(req.user.id);
+    
+    // Получаем текущую роль
+    const isAdmin = await authService.isAdmin(req.user.id);
+    
     res.json({
-      id: result.rows[0].id,
-      walletAddress: result.rows[0].wallet_address,
-      role: result.rows[0].role,
-      createdAt: result.rows[0].created_at,
-      expiresAt: result.rows[0].expires_at,
+      success: true,
+      identities,
+      isAdmin
     });
   } catch (error) {
-    console.error('Ошибка при создании токена:', error);
+    logger.error(`Link identity error: ${error.message}`);
     res.status(500).json({ error: 'Ошибка сервера' });
   }
 });

backend/routes/admin.js

@@ -1,79 +1,7 @@
 const express = require('express');
 const router = express.Router();
 const db = require('../db');
-const { checkIfAdmin } = require('../utils/access-check');
-
-// Middleware для проверки прав администратора
-const requireAdmin = async (req, res, next) => {
-  console.log('Проверка прав администратора:', {
-    session: req.session
-      ? {
-          authenticated: req.session.authenticated,
-          address: req.session.address,
-          isAdmin: req.session.isAdmin,
-        }
-      : null,
-    headers: {
-      authorization: req.headers.authorization,
-    },
-  });
-
-  // Проверка аутентификации через сессию
-  if (req.session && req.session.authenticated && req.session.isAdmin) {
-    console.log('Пользователь авторизован как администратор через сессию');
-    return next();
-  }
-
-  // Проверка через заголовок авторизации
-  const authHeader = req.headers.authorization;
-  if (!authHeader || !authHeader.startsWith('Bearer ')) {
-    console.log('Отсутствует заголовок авторизации');
-    return res.status(401).json({ error: 'Unauthorized' });
-  }
-
-  const address = authHeader.split(' ')[1];
-  console.log('Проверка адреса из заголовка:', address);
-
-  try {
-    // Проверяем напрямую в базе данных
-    const userResult = await db.query('SELECT is_admin FROM users WHERE address = $1', [
-      address.toLowerCase(),
-    ]);
-
-    if (userResult.rows.length === 0) {
-      console.log(`Пользователь с адресом ${address} не найден`);
-      return res.status(404).json({ error: 'User not found' });
-    }
-
-    const isAdmin = userResult.rows[0].is_admin;
-    console.log(`Пользователь с адресом ${address} имеет статус администратора:`, isAdmin);
-
-    if (!isAdmin) {
-      console.log(`Пользователь с адресом ${address} не является администратором`);
-      return res.status(403).json({ error: 'Forbidden' });
-    }
-
-    // Обновляем сессию
-    if (req.session) {
-      req.session.authenticated = true;
-      req.session.address = address;
-      req.session.isAdmin = true;
-
-      console.log('Сессия обновлена из middleware:', {
-        address,
-        isAdmin: true,
-      });
-    }
-
-    next();
-  } catch (error) {
-    console.error('Ошибка при проверке прав администратора:', error);
-    return res.status(500).json({ error: 'Internal server error' });
-  }
-};
-
-// Применяем middleware ко всем маршрутам
-router.use(requireAdmin);
+const { requireAdmin } = require('../middleware/auth');
 
 // Маршрут для получения списка пользователей
 router.get('/users', async (req, res) => {
@@ -86,8 +14,8 @@ router.get('/users', async (req, res) => {
   }
 });
 
-// Маршрут для получения статистики
-router.get('/stats', async (req, res) => {
+// Маршрут для получения статистики (защищен middleware requireAdmin)
+router.get('/stats', requireAdmin, async (req, res) => {
   try {
     // Получаем количество пользователей
     const usersCount = await db.query('SELECT COUNT(*) FROM users');

backend/routes/auth.js

@@ -6,10 +6,10 @@ const db = require('../db');
 const logger = require('../utils/logger');
 const helmet = require('helmet');
 const rateLimit = require('express-rate-limit');
-const { checkIfAdmin } = require('../utils/access-check');
 const { checkRole, requireAuth } = require('../middleware/auth');
 const { pool } = require('../db');
 const { verifySignature, checkAccess, findOrCreateUser } = require('../utils/auth');
+const authService = require('../services/auth-service');
 
 // Создайте лимитер для попыток аутентификации
 const authLimiter = rateLimit({
@@ -24,39 +24,31 @@ const authLimiter = rateLimit({
 router.get('/nonce', async (req, res) => {
   try {
     const { address } = req.query;
-
     if (!address) {
       return res.status(400).json({ error: 'Address is required' });
     }
 
-    // Генерируем nonce
+    // Генерируем случайный nonce
     const nonce = crypto.randomBytes(16).toString('hex');
-
+    
     // Сохраняем nonce в сессии
     req.session.authNonce = nonce;
-    req.session.pendingAddress = address.toLowerCase();
-
-    console.log('Сгенерирован nonce для адреса:', address);
-    console.log('Сессия после генерации nonce:', req.session);
-
-    // Сохраняем сессию и ждем завершения
+    req.session.pendingAddress = address;
+    
+    // Важно: сохраняем сессию перед отправкой ответа
     await new Promise((resolve, reject) => {
-      req.session.save((err) => {
-        if (err) {
-          console.error('Ошибка при сохранении сессии:', err);
-          reject(err);
-        } else {
-          resolve();
-        }
+      req.session.save(err => {
+        if (err) reject(err);
+        else resolve();
       });
     });
-
-    // Проверяем, что nonce сохранился
+    
+    console.log('Сессия после генерации nonce:', req.session);
     console.log('Сессия после сохранения:', req.session);
-
+    
     return res.json({ nonce });
   } catch (error) {
-    console.error('Ошибка при генерации nonce:', error);
+    console.error('Error generating nonce:', error);
     return res.status(500).json({ error: 'Internal server error' });
   }
 });
@@ -89,135 +81,227 @@ async function checkUserRole(address, req) {
   }
 }
 
-// Верификация подписи
+// Проверка подписи и аутентификация
 router.post('/verify', async (req, res) => {
   try {
-    const { address, signature, message, nonce } = req.body;
+    const { address, signature, message } = req.body;
     
-    console.log('Верификация подписи:', { address, signature, message });
-    console.log('Сессия при верификации:', req.session);
+    console.log('Verify request: address=' + address + ', signature=' + signature.substring(0, 10) + '...');
+    console.log('Session data: nonce=' + req.session.authNonce + ', pendingAddress=' + req.session.pendingAddress);
     
-    if (!address || !signature || !message) {
-      return res.status(400).json({ error: 'Address, signature and message are required' });
+    // Проверяем, что nonce и адрес совпадают с сохраненными в сессии
+    if (!req.session.authNonce || !req.session.pendingAddress || req.session.pendingAddress !== address) {
+      console.error(`Invalid session or address mismatch: nonce=${req.session.authNonce}, pendingAddress=${req.session.pendingAddress}, address=${address}`);
+      return res.status(401).json({ error: 'Invalid session or address mismatch' });
     }
-
-    // Проверяем наличие nonce в сессии
-    if (!req.session.authNonce || !req.session.pendingAddress) {
-      console.error('Сессия не содержит nonce или pendingAddress:', req.session);
-
-      // Проверяем наличие nonce в заголовке
-      const headerNonce = req.headers['x-auth-nonce'];
-      if (headerNonce) {
-        console.log('Найден nonce в заголовке:', headerNonce);
-        req.session.authNonce = headerNonce;
-        req.session.pendingAddress = address.toLowerCase();
-      }
-
-      // Если в запросе есть nonce в сообщении, извлекаем его
-      let extractedNonce = null;
-      if (message) {
-        const match = message.match(/nonce: ([a-f0-9]+)/);
-        if (match && match[1]) {
-          extractedNonce = match[1];
-          console.log('Извлечен nonce из сообщения:', extractedNonce);
-
-          // Устанавливаем nonce в сессию
-          req.session.authNonce = extractedNonce;
-          req.session.pendingAddress = address.toLowerCase();
-
-          // Сохраняем сессию
-          await new Promise((resolve) => {
-            req.session.save((err) => {
-              if (err) console.error('Ошибка при сохранении сессии:', err);
-              resolve();
-            });
-          });
+    
+    // Проверяем подпись
+    const isValid = await verifySignature(req.session.authNonce, signature, address);
+    console.log('Signature verification result:', isValid);
+    
+    if (!isValid) {
+      return res.status(401).json({ error: 'Invalid signature' });
+    }
+    
+    // Находим или создаем пользователя
+    console.log('Finding or creating user for address:', address);
+    const { userId, isAdmin } = await findOrCreateUser(address);
+    console.log('User found/created:', { userId, isAdmin });
+    
+    // Очищаем nonce и pendingAddress из сессии
+    const nonce = req.session.authNonce;
+    req.session.authNonce = null;
+    req.session.pendingAddress = null;
+    
+    // Устанавливаем пользователя в сессии
+    req.session.userId = userId;
+    req.session.address = address;
+    req.session.isAdmin = isAdmin;
+    req.session.authenticated = true;
+    
+    // Сохраняем сессию
+    await new Promise((resolve, reject) => {
+      req.session.save(err => {
+        if (err) {
+          console.error('Error saving session:', err);
+          reject(err);
+        } else {
+          console.log('Session saved successfully');
+          resolve();
         }
-      }
-    }
-
-    // Формируем ожидаемое сообщение
-    const expectedMessage = `Подтвердите вход в DApp for Business с nonce: ${req.session.authNonce}`;
-
-    // Проверяем, что адрес совпадает с ожидаемым
-    if (req.session.pendingAddress && req.session.pendingAddress.toLowerCase() !== address.toLowerCase()) {
-      console.error('Адрес не совпадает с ожидаемым:', {
-        expected: req.session.pendingAddress,
-        received: address,
       });
-      return res.status(400).json({ error: 'Invalid address' });
+    });
+    
+    console.log('Authentication successful for user:', { userId, address, isAdmin });
+    
+    return res.json({
+      authenticated: true,
+      userId,
+      address,
+      isAdmin,
+      authType: 'wallet'
+    });
+  } catch (error) {
+    console.error('Error verifying signature:', error);
+    return res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Аутентификация через Telegram
+router.post('/telegram', async (req, res) => {
+  try {
+    const { telegramId, authData } = req.body;
+    
+    // Здесь должна быть проверка данных от Telegram
+    
+    // Получаем или создаем пользователя
+    let userId = await authService.getUserIdByIdentity('telegram', telegramId);
+    
+    if (!userId) {
+      // Создаем нового пользователя
+      const userResult = await db.query(
+        'INSERT INTO users (created_at, role_id) VALUES (NOW(), (SELECT id FROM roles WHERE name = $1)) RETURNING id',
+        ['user']
+      );
+      
+      userId = userResult.rows[0].id;
+      
+      // Добавляем идентификатор Telegram
+      await db.query(
+        'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
+        [userId, 'telegram', telegramId]
+      );
     }
-
-    let verified = false;
-    try {
-      // Проверяем подпись с использованием ethers.js
-      const recoveredAddress = ethers.verifyMessage(expectedMessage, signature);
-
-      if (recoveredAddress.toLowerCase() !== address.toLowerCase()) {
-        console.error('Неверная подпись:', {
-          expected: address.toLowerCase(),
-          recovered: recoveredAddress.toLowerCase(),
-        });
-        return res.status(400).json({ error: 'Invalid signature' });
-      }
-
-      verified = true;
-      console.log('Подпись успешно проверена');
-    } catch (error) {
-      console.error('Ошибка при проверке подписи:', error);
-      return res.status(400).json({ error: 'Invalid signature format' });
+    
+    // Проверяем связанные аккаунты
+    const identities = await authService.getAllUserIdentities(userId);
+    
+    // Если есть связанный кошелек, проверяем токены
+    if (identities.wallet) {
+      await authService.checkTokensAndUpdateRole(identities.wallet);
     }
+    
+    // Получаем текущую роль
+    const isAdmin = await authService.isAdmin(userId);
+    
+    // Устанавливаем сессию
+    req.session.userId = userId;
+    req.session.telegramId = telegramId;
+    req.session.authType = 'telegram';
+    req.session.authenticated = true;
+    
+    res.json({
+      authenticated: true,
+      userId,
+      isAdmin,
+      authType: 'telegram',
+      identities
+    });
+  } catch (error) {
+    logger.error(`Telegram auth error: ${error.message}`);
+    res.status(500).json({ error: 'Ошибка сервера' });
+  }
+});
 
-    // Если подпись верна, аутентифицируем пользователя
-    if (verified) {
-      // Найдем или создадим пользователя
-      const user = await findOrCreateUser(address, 'wallet');
+// Аутентификация через Email
+router.post('/email', async (req, res) => {
+  try {
+    const { email, verificationCode } = req.body;
+    
+    // Здесь должна быть проверка кода подтверждения
+    
+    // Получаем или создаем пользователя
+    let userId = await authService.getUserIdByIdentity('email', email);
+    
+    if (!userId) {
+      // Создаем нового пользователя
+      const userResult = await db.query(
+        'INSERT INTO users (created_at, role_id) VALUES (NOW(), (SELECT id FROM roles WHERE name = $1)) RETURNING id',
+        ['user']
+      );
       
-      // Обновляем сессию
-      req.session.authenticated = true;
-      req.session.address = address;
-      req.session.userId = user.id;
-      req.session.authType = 'wallet';
-      req.session.isAdmin = user.is_admin;
-      req.session.role = user.role;
-      req.session.authChannel = 'web';
-      req.session.language = req.body.language || 'en';
+      userId = userResult.rows[0].id;
       
-      // Удаляем временные данные
-      delete req.session.authNonce;
-      delete req.session.pendingAddress;
-      
-      // Сохраняем сессию
-      await new Promise((resolve, reject) => {
-        req.session.save(err => {
-          if (err) {
-            console.error('Ошибка при сохранении сессии:', err);
-            reject(err);
-          } else {
-            resolve();
-          }
-        });
-      });
-      
-      console.log('Аутентификация успешна:', { 
-        address, 
-        isAdmin: user.is_admin,
-        userId: user.id,
-        role: user.role
-      });
+      // Добавляем идентификатор Email
+      await db.query(
+        'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
+        [userId, 'email', email]
+      );
+    }
+    
+    // Проверяем связанные аккаунты
+    const identities = await authService.getAllUserIdentities(userId);
+    
+    // Если есть связанный кошелек, проверяем токены
+    if (identities.wallet) {
+      await authService.checkTokensAndUpdateRole(identities.wallet);
+    }
+    
+    // Получаем текущую роль
+    const isAdmin = await authService.isAdmin(userId);
+    
+    // Устанавливаем сессию
+    req.session.userId = userId;
+    req.session.email = email;
+    req.session.authType = 'email';
+    req.session.authenticated = true;
       
       res.json({ 
         authenticated: true, 
-        address, 
-        isAdmin: user.is_admin,
-        role: user.role
-      });
-    } else {
-      res.status(401).json({ error: 'Invalid signature' });
-    }
+      userId,
+      isAdmin,
+      authType: 'email',
+      identities
+    });
   } catch (error) {
-    console.error('Authentication error:', error);
-    res.status(500).json({ error: 'Internal server error' });
+    logger.error(`Email auth error: ${error.message}`);
+    res.status(500).json({ error: 'Ошибка сервера' });
+  }
+});
+
+// Связывание аккаунтов
+router.post('/link-identity', async (req, res) => {
+  try {
+    if (!req.session || !req.session.userId) {
+      return res.status(401).json({ error: 'Требуется аутентификация' });
+    }
+    
+    const { identityType, identityValue } = req.body;
+    
+    // Проверяем, не привязан ли уже этот идентификатор к другому пользователю
+    const existingUserId = await authService.getUserIdByIdentity(identityType, identityValue);
+    
+    if (existingUserId && existingUserId !== req.session.userId) {
+      return res.status(400).json({ error: 'Этот идентификатор уже привязан к другому аккаунту' });
+    }
+    
+    // Добавляем новый идентификатор
+    if (!existingUserId) {
+      await db.query(
+        'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
+        [req.session.userId, identityType, identityValue]
+      );
+    }
+    
+    // Если добавлен кошелек, проверяем токены
+    if (identityType === 'wallet') {
+      await authService.checkTokensAndUpdateRole(identityValue);
+    }
+    
+    // Получаем все идентификаторы пользователя
+    const identities = await authService.getAllUserIdentities(req.session.userId);
+    
+    // Получаем текущую роль
+    const isAdmin = await authService.isAdmin(req.session.userId);
+    
+    res.json({
+      success: true,
+      identities,
+      isAdmin
+    });
+  } catch (error) {
+    logger.error(`Link identity error: ${error.message}`);
+    res.status(500).json({ error: 'Ошибка сервера' });
   }
 });
 
@@ -418,76 +502,42 @@ router.get('/check-access', requireAuth, (req, res) => {
   }
 });
 
-// Упрощенный маршрут для обновления сессии
+// Добавьте этот маршрут в routes/auth.js
 router.post('/refresh-session', async (req, res) => {
   try {
     const { address } = req.body;
-
+    
     if (!address) {
-      return res.status(400).json({ success: false, message: 'Адрес не указан' });
+      return res.status(400).json({ error: 'Address is required' });
     }
-
-    console.log(`Получен запрос на обновление сессии для адреса: ${address}`);
-
-    // Проверяем, существует ли пользователь в базе данных
-    const userResult = await pool.query('SELECT * FROM users WHERE address = $1', [
-      address.toLowerCase(),
-    ]);
-
-    let user = null;
-
-    if (userResult.rows.length > 0) {
-      user = userResult.rows[0];
-      console.log(`Найден пользователь: ${user.id}`);
-    } else {
-      console.log(`Пользователь с адресом ${address} не найден`);
+    
+    logger.info(`Получен запрос на обновление сессии для адреса: ${address}`);
+    
+    // Проверяем доступ пользователя
+    const accessInfo = await checkAccess(address);
+    
+    if (!accessInfo.hasAccess) {
+      return res.status(401).json({ error: 'Unauthorized' });
     }
-
-    // Обновляем сессию
+    
+    // Устанавливаем данные сессии
     req.session.authenticated = true;
-    req.session.address = address.toLowerCase();
-
-    if (user) {
-      req.session.userId = user.id;
-      req.session.isAdmin = user.is_admin || false;
-      req.session.role = user.is_admin ? 'ADMIN' : 'USER';
-    } else {
-      // Если пользователь не найден в базе, проверяем через переменные окружения
-      const adminAddresses = (process.env.ADMIN_ADDRESSES || '')
-        .split(',')
-        .map((a) => a.toLowerCase());
-      const isAdmin = adminAddresses.includes(address.toLowerCase());
-      req.session.isAdmin = isAdmin;
-      req.session.role = isAdmin ? 'ADMIN' : 'USER';
-    }
-
-    // Сохраняем сессию
-    await new Promise((resolve, reject) => {
-      req.session.save((err) => {
-        if (err) {
-          console.error('Ошибка при сохранении сессии:', err);
-          reject(err);
-        } else {
-          resolve();
-        }
-      });
-    });
-
-    console.log('Сессия обновлена:', req.session);
-
-    return res.json({
-      success: true,
-      message: 'Сессия обновлена',
-      user: {
-        id: user ? user.id : null,
-        address: address.toLowerCase(),
-        isAdmin: req.session.isAdmin,
-        role: req.session.role,
-      },
+    req.session.address = address;
+    req.session.userId = accessInfo.userId;
+    req.session.isAdmin = accessInfo.isAdmin;
+    req.session.authType = 'wallet';
+    
+    await req.session.save();
+    
+    res.json({
+      authenticated: true,
+      address,
+      isAdmin: accessInfo.isAdmin,
+      authType: 'wallet'
     });
   } catch (error) {
-    console.error('Ошибка при обновлении сессии:', error);
-    return res.status(500).json({ success: false, message: 'Ошибка сервера' });
+    logger.error(`Error refreshing session: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 
@@ -555,10 +605,56 @@ router.get('/check-db-structure', async (req, res) => {
   }
 });
 
+// Добавьте этот маршрут для отладки
+router.get('/debug-session', (req, res) => {
+  res.json({
+    sessionID: req.sessionID,
+    session: req.session,
+    authenticated: req.session ? req.session.authenticated : undefined,
+    address: req.session ? req.session.address : undefined,
+    userId: req.session ? req.session.userId : undefined,
+    isAdmin: req.session ? req.session.isAdmin : undefined,
+    role: req.session ? req.session.role : undefined
+  });
+});
+
+// Маршрут для проверки сессии
+router.get('/session-debug', (req, res) => {
+  console.log('Текущая сессия:', {
+    id: req.sessionID,
+    session: req.session,
+    cookie: req.session.cookie
+  });
+  
+  res.json({
+    sessionID: req.sessionID,
+    authenticated: req.session.authenticated,
+    address: req.session.address,
+    userId: req.session.userId,
+    isAdmin: req.session.isAdmin,
+    role: req.session.role,
+    cookie: req.session.cookie
+  });
+});
+
+// Маршрут для проверки содержимого таблицы сессий
+router.get('/check-sessions', async (req, res) => {
+  try {
+    const result = await pool.query('SELECT * FROM sessions');
+    res.json({
+      currentSessionID: req.sessionID,
+      sessions: result.rows
+    });
+  } catch (error) {
+    console.error('Ошибка при получении сессий:', error);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
 // Добавьте обработку ошибок
 router.use((err, req, res, next) => {
   console.error('Auth route error:', err);
   res.status(500).json({ success: false, message: 'Ошибка сервера' });
 });
 
-module.exports = { router };
+module.exports = router;

backend/routes/chat.js

@@ -8,14 +8,12 @@ const logger = require('../utils/logger');
 
 // Обработчик сообщений чата
 router.post('/message', requireAuth, async (req, res) => {
+  console.log('Сессия в /api/chat/message:', req.session);
+  console.log('Аутентифицирован:', req.session.authenticated);
+  
   try {
     const { message, language = 'ru' } = req.body;
     
-    // Проверка аутентификации
-    if (!req.session || !req.session.authenticated) {
-      return res.status(401).json({ error: 'Требуется аутентификация' });
-    }
-    
     console.log(`Получено сообщение: ${message}, язык: ${language}`);
 
     // Определяем язык сообщения, если не указан явно
@@ -175,26 +173,4 @@ router.get('/admin/history', requireAdmin, async (req, res) => {
   }
 });
 
-// Сохранение сообщения в историю чата
-router.post('/message', requireAuth, async (req, res) => {
-  try {
-    const { content, channel = 'web', metadata = {} } = req.body;
-    const userId = req.session.userId;
-    
-    // Сохранение сообщения пользователя
-    const userMessageResult = await db.query(`
-      INSERT INTO chat_history (user_id, channel, sender_type, content, metadata)
-      VALUES ($1, $2, 'user', $3, $4)
-      RETURNING id
-    `, [userId, channel, content, metadata]);
-    
-    const messageId = userMessageResult.rows[0].id;
-    
-    res.json({ success: true, messageId });
-  } catch (error) {
-    logger.error('Error saving chat message:', error);
-    res.status(500).json({ error: 'Внутренняя ошибка сервера' });
-  }
-});
-
 module.exports = router;

backend/routes/conversations.js

@@ -0,0 +1 @@
+

backend/routes/identities.js

@@ -1,27 +1,14 @@
 const express = require('express');
 const router = express.Router();
 const { linkIdentity, getUserIdentities } = require('../utils/identity-linker');
-const { Pool } = require('pg');
-
-// Подключение к БД
-const pool = new Pool({
-  connectionString: process.env.DATABASE_URL,
-  ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false,
-});
-
-// Middleware для проверки аутентификации
-function requireAuth(req, res, next) {
-  if (!req.session || (!req.session.isAuthenticated && !req.session.authenticated)) {
-    return res.status(401).json({ error: 'Unauthorized' });
-  }
-  next();
-}
+const db = require('../db');
+const { requireAuth } = require('../middleware/auth');
 
 // Получение связанных идентификаторов пользователя
 router.get('/', requireAuth, async (req, res) => {
   try {
     // Получаем ID пользователя по Ethereum-адресу
-    const result = await pool.query('SELECT id FROM users WHERE address = $1', [
+    const result = await db.query('SELECT id FROM users WHERE address = $1', [
       req.session.address,
     ]);
 
@@ -47,7 +34,7 @@ router.delete('/:type/:value', requireAuth, async (req, res) => {
     const { type, value } = req.params;
 
     // Получаем ID пользователя по Ethereum-адресу
-    const result = await pool.query('SELECT id FROM users WHERE address = $1', [
+    const result = await db.query('SELECT id FROM users WHERE address = $1', [
       req.session.address,
     ]);
 
@@ -58,7 +45,7 @@ router.delete('/:type/:value', requireAuth, async (req, res) => {
     const userId = result.rows[0].id;
 
     // Удаляем идентификатор
-    await pool.query(
+    await db.query(
       'DELETE FROM user_identities WHERE user_id = $1 AND identity_type = $2 AND identity_value = $3',
       [userId, type, value]
     );

backend/routes/roles.js

@@ -2,54 +2,164 @@ const express = require('express');
 const router = express.Router();
 const db = require('../db');
 const { requireAuth, requireAdmin } = require('../middleware/auth');
-const { checkTokenBalanceAndUpdateRole } = require('../utils/access-check');
+const authService = require('../services/auth-service');
 const logger = require('../utils/logger');
+const { USER_ROLES } = require('../utils/constants');
 
-// Маршрут для проверки и обновления роли пользователя
-router.post('/check-role', requireAuth, async (req, res) => {
-  try {
-    if (!req.session.address) {
-      return res.status(400).json({ error: 'В сессии отсутствует адрес кошелька' });
-    }
-    
-    const isAdmin = await checkTokenBalanceAndUpdateRole(req.session.address);
-    
-    // Обновление сессии
-    req.session.isAdmin = isAdmin;
-    
-    res.json({ isAdmin });
-  } catch (error) {
-    logger.error('Error checking role:', error);
-    res.status(500).json({ error: 'Внутренняя ошибка сервера' });
-  }
-});
-
-// Маршрут для получения всех ролей (только для админов)
-router.get('/', requireAdmin, async (req, res) => {
+// Получение всех ролей
+router.get('/', async (req, res) => {
   try {
     const result = await db.query('SELECT * FROM roles ORDER BY id');
     res.json(result.rows);
   } catch (error) {
-    logger.error('Error fetching roles:', error);
-    res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+    logger.error(`Error getting roles: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 
-// Маршрут для получения пользователей с их ролями (только для админов)
-router.get('/users', requireAdmin, async (req, res) => {
+// Получение роли текущего пользователя
+router.get('/me', requireAuth, async (req, res) => {
   try {
-    const result = await db.query(`
-      SELECT u.id, u.username, u.preferred_language, r.name as role, 
-             u.created_at, u.last_token_check
-      FROM users u
-      LEFT JOIN roles r ON u.role_id = r.id
-      ORDER BY u.created_at DESC
-    `);
+    const userId = req.session.userId;
     
-    res.json(result.rows);
+    const result = await db.query(`
+      SELECT r.name as role
+      FROM users u
+      JOIN roles r ON u.role_id = r.id
+      WHERE u.id = $1
+    `, [userId]);
+    
+    if (result.rows.length === 0) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+    
+    res.json({ role: result.rows[0].role });
   } catch (error) {
-    logger.error('Error fetching users with roles:', error);
-    res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+    logger.error(`Error getting user role: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Создание новой роли (только для администраторов)
+router.post('/', requireAuth, requireAdmin, async (req, res) => {
+  try {
+    const { name, description } = req.body;
+    
+    if (!name) {
+      return res.status(400).json({ error: 'Role name is required' });
+    }
+    
+    // Проверяем, существует ли уже такая роль
+    const existingRole = await db.query('SELECT * FROM roles WHERE name = $1', [name]);
+    
+    if (existingRole.rows.length > 0) {
+      return res.status(400).json({ error: 'Role already exists' });
+    }
+    
+    // Создаем новую роль
+    const result = await db.query(
+      'INSERT INTO roles (name, description) VALUES ($1, $2) RETURNING *',
+      [name, description || '']
+    );
+    
+    res.status(201).json(result.rows[0]);
+  } catch (error) {
+    logger.error(`Error creating role: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Обновление роли (только для администраторов)
+router.put('/:id', requireAuth, requireAdmin, async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { name, description } = req.body;
+    
+    if (!name) {
+      return res.status(400).json({ error: 'Role name is required' });
+    }
+    
+    // Проверяем, существует ли роль
+    const existingRole = await db.query('SELECT * FROM roles WHERE id = $1', [id]);
+    
+    if (existingRole.rows.length === 0) {
+      return res.status(404).json({ error: 'Role not found' });
+    }
+    
+    // Обновляем роль
+    const result = await db.query(
+      'UPDATE roles SET name = $1, description = $2 WHERE id = $3 RETURNING *',
+      [name, description || '', id]
+    );
+    
+    res.json(result.rows[0]);
+  } catch (error) {
+    logger.error(`Error updating role: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Удаление роли (только для администраторов)
+router.delete('/:id', requireAuth, requireAdmin, async (req, res) => {
+  try {
+    const { id } = req.params;
+    
+    // Проверяем, существует ли роль
+    const existingRole = await db.query('SELECT * FROM roles WHERE id = $1', [id]);
+    
+    if (existingRole.rows.length === 0) {
+      return res.status(404).json({ error: 'Role not found' });
+    }
+    
+    // Проверяем, не используется ли роль
+    const usersWithRole = await db.query('SELECT COUNT(*) FROM users WHERE role_id = $1', [id]);
+    
+    if (parseInt(usersWithRole.rows[0].count) > 0) {
+      return res.status(400).json({ error: 'Cannot delete role that is assigned to users' });
+    }
+    
+    // Удаляем роль
+    await db.query('DELETE FROM roles WHERE id = $1', [id]);
+    
+    res.json({ success: true });
+  } catch (error) {
+    logger.error(`Error deleting role: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Назначение роли пользователю (только для администраторов)
+router.post('/assign', requireAuth, requireAdmin, async (req, res) => {
+  try {
+    const { userId, roleName } = req.body;
+    
+    if (!userId || !roleName) {
+      return res.status(400).json({ error: 'User ID and role name are required' });
+    }
+    
+    // Проверяем, существует ли роль
+    const roleResult = await db.query('SELECT id FROM roles WHERE name = $1', [roleName]);
+    
+    if (roleResult.rows.length === 0) {
+      return res.status(404).json({ error: 'Role not found' });
+    }
+    
+    const roleId = roleResult.rows[0].id;
+    
+    // Проверяем, существует ли пользователь
+    const userResult = await db.query('SELECT * FROM users WHERE id = $1', [userId]);
+    
+    if (userResult.rows.length === 0) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+    
+    // Назначаем роль
+    await db.query('UPDATE users SET role_id = $1 WHERE id = $2', [roleId, userId]);
+    
+    res.json({ success: true });
+  } catch (error) {
+    logger.error(`Error assigning role: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
   }
 });