ваше сообщение коммита

backend/routes/auth.js

@@ -264,22 +264,25 @@ router.post('/email/request', authLimiter, async (req, res) => {
       return res.status(400).json({ error: 'Invalid email format' });
     }
     
-    // Создаем или получаем ID пользователя
+    // Используем общую логику инициализации email аутентификации
-    let userId;
+    const { verificationCode } = await emailAuth.initEmailAuth(req.session, email);
     
-    if (req.session.authenticated && req.session.userId) {
+    // Сохраняем сессию после установки pendingEmail
-      userId = req.session.userId;
+    await new Promise((resolve, reject) => {
+      req.session.save(err => {
+        if (err) {
+          logger.error('Error saving session:', err);
+          reject(err);
         } else {
-      const userResult = await db.query(
+          logger.info(`Session saved successfully with pendingEmail: ${email}`);
-        'INSERT INTO users (created_at) VALUES (NOW()) RETURNING id'
+          resolve();
-      );
-      userId = userResult.rows[0].id;
-      req.session.tempUserId = userId;
         }
+      });
+    });
     
     // Отправляем email с кодом подтверждения
     const emailBot = new EmailBotService(process.env.EMAIL_USER, process.env.EMAIL_PASSWORD);
-    const result = await emailBot.sendVerificationCode(email, userId);
+    const result = await emailBot.sendVerificationCode(email, req.session.tempUserId || req.session.userId);
     
     if (result.success) {
       res.json({ 
@@ -294,7 +297,7 @@ router.post('/email/request', authLimiter, async (req, res) => {
     }
   } catch (error) {
     logger.error('Error requesting email code:', error);
-    res.status(500).json({ error: 'Ошибка сервера' });
+    res.status(500).json({ error: error.message || 'Ошибка сервера' });
   }
 });
 
@@ -310,6 +313,13 @@ router.post('/email/verify', async (req, res) => {
       });
     }
     
+    if (!req.session.pendingEmail) {
+      return res.status(400).json({
+        success: false,
+        error: 'Email не найден в сессии. Пожалуйста, запросите код подтверждения снова.'
+      });
+    }
+    
     // Проверяем код через сервис верификации
     const result = await verificationService.verifyCode(code, 'email', req.session.pendingEmail);
     
@@ -323,15 +333,58 @@ router.post('/email/verify', async (req, res) => {
     const userId = result.userId;
     const email = req.session.pendingEmail;
     
+    // Проверяем, существует ли пользователь
+    const userResult = await db.query(
+      'SELECT * FROM users WHERE id = $1',
+      [userId]
+    );
+    
+    if (userResult.rows.length === 0) {
+      return res.status(404).json({
+        success: false,
+        error: 'Пользователь не найден'
+      });
+    }
+    
     // Добавляем email в базу данных
     await db.query(
-      'INSERT INTO user_identities (user_id, identity_type, identity_value, verified, created_at) ' +
+      `INSERT INTO user_identities 
-      'VALUES ($1, $2, $3, true, NOW()) ' +
+       (user_id, provider, provider_id, created_at) 
-      'ON CONFLICT (identity_type, identity_value) ' +
+       VALUES ($1, $2, $3, NOW()) 
-      'DO UPDATE SET user_id = $1, verified = true',
+       ON CONFLICT (provider, provider_id) 
+       DO UPDATE SET user_id = $1`,
       [userId, 'email', email.toLowerCase()]
     );
     
+    // Связываем гостевой ID с пользователем, если его еще нет
+    if (req.session.guestId) {
+      const guestIdentity = await db.query(
+        `SELECT * FROM user_identities 
+         WHERE user_id = $1 AND provider = 'guest' AND provider_id = $2`,
+        [userId, req.session.guestId]
+      );
+      
+      if (guestIdentity.rows.length === 0) {
+        await db.query(
+          `INSERT INTO user_identities 
+           (user_id, provider, provider_id, created_at) 
+           VALUES ($1, $2, $3, NOW())
+           ON CONFLICT (provider, provider_id) DO UPDATE SET user_id = $1`,
+          [userId, 'guest', req.session.guestId]
+        );
+      }
+    }
+    
+    // Связываем все гостевые сообщения с пользователем
+    if (req.session.guestId) {
+      try {
+        await db.query('SELECT link_guest_messages($1, $2)', [userId, req.session.guestId]);
+        logger.info(`Messages linked successfully for user ${userId} and guest ${req.session.guestId}`);
+      } catch (linkError) {
+        logger.error(`Error linking messages: ${linkError.message}`);
+      }
+    }
+    
     // Устанавливаем аутентификацию пользователя
     req.session.authenticated = true;
     req.session.userId = userId;
@@ -342,6 +395,19 @@ router.post('/email/verify', async (req, res) => {
     delete req.session.pendingEmail;
     delete req.session.tempUserId;
     
+    // Сохраняем сессию перед отправкой ответа
+    await new Promise((resolve, reject) => {
+      req.session.save(err => {
+        if (err) {
+          logger.error('Error saving session:', err);
+          reject(err);
+        } else {
+          logger.info('Session saved successfully');
+          resolve();
+        }
+      });
+    });
+    
     return res.json({
       success: true,
       userId,
@@ -1141,14 +1207,30 @@ router.post('/telegram/init', async (req, res) => {
   }
 });
 
-// Инициализация Email аутентификации
+// Инициализация email аутентификации
 router.post('/email/init', async (req, res) => {
   try {
-    const { verificationCode } = await emailAuth.initEmailAuth(req.session);
+    const { email } = req.body;
-    res.json({ success: true, verificationCode });
+    
+    if (!email) {
+      return res.status(400).json({ 
+        success: false, 
+        error: 'Email не указан' 
+      });
+    }
+    
+    const result = await emailAuth.initEmailAuth(req.session, email);
+    
+    return res.json({ 
+      success: true,
+      message: 'Код верификации отправлен на указанный email'
+    });
   } catch (error) {
-    console.error('Error initializing email auth:', error);
+    logger.error('Error initializing email auth:', error);
-    res.status(500).json({ error: 'Internal server error' });
+    return res.status(500).json({ 
+      success: false, 
+      error: error.message || 'Ошибка при инициализации email аутентификации' 
+    });
   }
 });
 
@@ -1176,38 +1258,57 @@ router.get('/check-email-verification', async (req, res) => {
     if (!code) {
       return res.status(400).json({ 
         verified: false, 
-        message: "Код верификации не указан" 
+        message: 'Код верификации не предоставлен' 
       });
     }
     
+    // Проверяем код через сервис верификации
     const result = await emailAuth.checkEmailVerification(code, req.session);
     
-    if (result.verified) {
+    if (!result.verified) {
-      // Обновляем сессию
+      return res.json(result);
-      req.session.userId = result.userId;
+    }
+    
+    // Код верный, обновляем сессию
     req.session.authenticated = true;
+    req.session.userId = result.userId;
     req.session.authType = 'email';
     req.session.email = result.email;
     
-      // Проверяем роль пользователя
+    // Получаем роль пользователя
-      const userRole = await authService.checkUserRole(result.userId);
+    const roleResult = await db.query(
-      req.session.userRole = userRole;
+      'SELECT role FROM users WHERE id = $1',
+      [result.userId]
+    );
+    
+    if (roleResult.rows.length > 0) {
+      req.session.userRole = roleResult.rows[0].role || 'user';
+    } else {
+      req.session.userRole = 'user';
+    }
     
     // Сохраняем сессию
     await new Promise((resolve, reject) => {
       req.session.save(err => {
-          if (err) reject(err);
+        if (err) {
-          else resolve();
+          logger.error('Error saving session:', err);
-        });
+          reject(err);
-      });
+        } else {
+          resolve();
         }
+      });
+    });
     
-    res.json(result);
+    return res.json({
+      verified: true,
+      userId: result.userId,
+      email: result.email
+    });
   } catch (error) {
     logger.error('Error checking email verification:', error);
-    res.status(500).json({ 
+    return res.status(500).json({ 
       verified: false, 
-      message: "Ошибка при проверке кода" 
+      message: 'Ошибка при проверке кода верификации' 
     });
   }
 });

backend/services/emailAuth.js

@@ -2,32 +2,113 @@ const logger = require('../utils/logger');
 const db = require('../db');
 const authService = require('./auth-service');
 const verificationService = require('./verification-service');
+const { EmailBotService } = require('./emailBot');
 
 // Инициализация процесса аутентификации по email
-async function initEmailAuth(session) {
+async function initEmailAuth(session, email) {
   try {
+    if (!email || !email.match(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)) {
+      throw new Error('Некорректный формат email');
+    }
+    
+    // Сохраняем email в сессии для последующей верификации
+    session.pendingEmail = email.toLowerCase();
+    
     // Создаем или получаем ID пользователя
     let userId;
     
-    if (session.authenticated && session.userId) {
+    // Проверяем, существует ли пользователь с этим email
+    const existingEmailUser = await db.query(
+      `SELECT ui.user_id 
+       FROM user_identities ui 
+       WHERE ui.provider = 'email' AND ui.provider_id = $1`,
+      [email.toLowerCase()]
+    );
+    
+    if (existingEmailUser.rows.length > 0) {
+      // Используем существующего пользователя
+      userId = existingEmailUser.rows[0].user_id;
+      logger.info(`Using existing user ${userId} for email ${email}`);
+      
+      // Связываем гостевой ID с существующим пользователем, если еще нет
+      if (session.guestId) {
+        const guestIdentity = await db.query(
+          `SELECT * FROM user_identities 
+           WHERE user_id = $1 AND provider = 'guest' AND provider_id = $2`,
+          [userId, session.guestId]
+        );
+        
+        if (guestIdentity.rows.length === 0) {
+          await db.query(
+            `INSERT INTO user_identities 
+             (user_id, provider, provider_id, created_at) 
+             VALUES ($1, $2, $3, NOW())
+             ON CONFLICT (provider, provider_id) DO UPDATE SET user_id = $1`,
+            [userId, 'guest', session.guestId]
+          );
+        }
+      }
+    } else if (session.authenticated && session.userId) {
+      // Если пользователь уже аутентифицирован, используем его ID
       userId = session.userId;
+    } else if (session.guestId) {
+      // Проверяем, есть ли пользователь с текущим guestId
+      const guestUserResult = await db.query(
+        `SELECT u.id 
+         FROM users u 
+         JOIN user_identities ui ON u.id = ui.user_id 
+         WHERE ui.provider = 'guest' AND ui.provider_id = $1`,
+        [session.guestId]
+      );
+      
+      if (guestUserResult.rows.length > 0) {
+        // Используем существующего пользователя с guestId
+        userId = guestUserResult.rows[0].id;
       } else {
+        // Создаем нового пользователя
         const userResult = await db.query(
           'INSERT INTO users (created_at) VALUES (NOW()) RETURNING id'
         );
         userId = userResult.rows[0].id;
-      session.tempUserId = userId;
+        
+        // Связываем гостевой ID с новым пользователем
+        if (session.guestId) {
+          await db.query(
+            `INSERT INTO user_identities 
+             (user_id, provider, provider_id, created_at) 
+             VALUES ($1, $2, $3, NOW())`,
+            [userId, 'guest', session.guestId]
+          );
         }
+      }
+    } else {
+      // Создаем нового пользователя без гостевого ID
+      const userResult = await db.query(
+        'INSERT INTO users (created_at) VALUES (NOW()) RETURNING id'
+      );
+      userId = userResult.rows[0].id;
+    }
+    
+    session.tempUserId = userId;
     
     // Создаем код через сервис верификации
     const code = await verificationService.createVerificationCode(
       'email',
-      session.guestId || 'temp',
+      email.toLowerCase(),
       userId
     );
     
-    logger.info(`Generated verification code: ${code} for Email auth`);
+    // Создаем экземпляр EmailBotService для отправки кода
-    return { verificationCode: code };
+    const emailService = new EmailBotService(
+      process.env.EMAIL_USER,
+      process.env.EMAIL_PASSWORD
+    );
+    
+    // Отправляем код на email пользователя
+    await emailService.sendVerificationCode(email.toLowerCase(), userId);
+    
+    logger.info(`Generated verification code for Email auth for ${email} and sent to user's email`);
+    return { success: true };
   } catch (error) {
     logger.error('Error initializing email auth:', error);
     throw error;
@@ -37,12 +118,12 @@ async function initEmailAuth(session) {
 // Проверка кода верификации
 async function checkEmailVerification(code, session) {
   try {
-    if (!session?.guestId) {
+    if (!session?.pendingEmail) {
-      return { verified: false, message: "Сессия не найдена" };
+      return { verified: false, message: "Email не найден в сессии" };
     }
 
     // Проверяем код через сервис верификации
-    const result = await verificationService.verifyCode(code, 'email', session.guestId);
+    const result = await verificationService.verifyCode(code, 'email', session.pendingEmail);
     
     if (!result.success) {
       return { verified: false, message: result.error || "Неверный код верификации" };
@@ -63,8 +144,8 @@ async function checkEmailVerification(code, session) {
     // Проверяем, есть ли у пользователя связанный email
     const emailIdentity = await db.query(
       `SELECT * FROM user_identities 
-       WHERE user_id = $1 AND provider = 'email'`,
+       WHERE user_id = $1 AND provider = 'email' AND provider_id = $2`,
-      [userId]
+      [userId, session.pendingEmail]
     );
     
     if (emailIdentity.rows.length === 0) {
@@ -74,11 +155,12 @@ async function checkEmailVerification(code, session) {
          (user_id, provider, provider_id, created_at) 
          VALUES ($1, $2, $3, NOW())
          ON CONFLICT (provider, provider_id) DO UPDATE SET user_id = $1`,
-        [userId, 'email', session.guestId]
+        [userId, 'email', session.pendingEmail]
       );
     }
     
     // Связываем гостевой ID с пользователем, если его еще нет
+    if (session.guestId) {
       const guestIdentity = await db.query(
         `SELECT * FROM user_identities 
          WHERE user_id = $1 AND provider = 'guest' AND provider_id = $2`,
@@ -95,10 +177,25 @@ async function checkEmailVerification(code, session) {
         );
       }
       
+      // Связываем гостевые сообщения с пользователем
+      try {
+        const messagesExist = await db.query(
+          'SELECT EXISTS(SELECT 1 FROM guest_messages WHERE guest_id = $1) as exists',
+          [session.guestId]
+        );
+
+        if (messagesExist.rows[0].exists) {
+          await db.query('SELECT link_guest_messages($1, $2)', [userId, session.guestId]);
+        }
+      } catch (linkError) {
+        logger.error(`Error linking messages: ${linkError}`);
+      }
+    }
+    
     return {
       verified: true,
       userId,
-      email: session.guestId
+      email: session.pendingEmail
     };
   } catch (error) {
     logger.error('Error in Email verification:', error);

backend/services/emailBot.js

@@ -1,8 +1,5 @@
 const { pool } = require('../db');
 const nodemailer = require('nodemailer');
-const Imap = require('imap');
-const simpleParser = require('mailparser').simpleParser;
-const { processMessage } = require('./ai-assistant');
 const { inspect } = require('util');
 const logger = require('../utils/logger');
 const verificationService = require('./verification-service');
@@ -21,30 +18,11 @@ const transporter = nodemailer.createTransport({
   }
 });
 
-// Конфигурация для получения писем
-const imapConfig = {
-  user: process.env.EMAIL_USER,
-  password: process.env.EMAIL_PASSWORD,
-  host: process.env.EMAIL_IMAP_HOST,
-  port: process.env.EMAIL_IMAP_PORT,
-  tls: true,
-  tlsOptions: { rejectUnauthorized: false },
-};
-
 class EmailBotService {
   constructor(user, password) {
     this.user = user;
     this.password = password;
     this.transporter = transporter;
-    this.imap = new Imap(imapConfig);
-    this.initialize();
-    this.listenForReplies();
-  }
-
-  initialize() {
-    this.imap.once('error', (err) => {
-      logger.error(`IMAP connection error: ${err.message}`);
-    });
   }
 
   async sendVerificationCode(toEmail, userId) {
@@ -61,7 +39,7 @@ class EmailBotService {
         from: this.user,
         to: toEmail,
         subject: 'Код подтверждения для DApp for Business',
-        text: `Ваш код подтверждения: ${code}\n\nДля завершения аутентификации, пожалуйста, ответьте на это письмо, указав только полученный код.\n\nКод действителен в течение 15 минут.`,
+        text: `Ваш код подтверждения: ${code}\n\nДля завершения аутентификации, пожалуйста, введите этот код на сайте.\n\nКод действителен в течение 15 минут.`,
         html: `
           <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto; padding: 20px; border: 1px solid #ddd; border-radius: 5px;">
             <h2 style="color: #333;">Код подтверждения для DApp for Business</h2>
@@ -69,7 +47,7 @@ class EmailBotService {
             <div style="font-size: 24px; font-weight: bold; padding: 15px; background-color: #f5f5f5; border-radius: 5px; text-align: center; margin: 20px 0;">
               ${code}
             </div>
-            <p>Для завершения аутентификации, пожалуйста, ответьте на это письмо, указав только полученный код.</p>
+            <p>Для завершения аутентификации, пожалуйста, введите этот код в форме на сайте.</p>
             <p>Код действителен в течение 15 минут.</p>
             <hr style="margin: 20px 0; border: none; border-top: 1px solid #ddd;">
             <p style="font-size: 12px; color: #777;">Это автоматическое сообщение, пожалуйста, не отвечайте на него.</p>
@@ -87,162 +65,12 @@ class EmailBotService {
     }
   }
 
-  listenForReplies() {
-    // Запускаем проверку почты каждые 30 секунд
-    setInterval(() => {
-      this.checkEmails();
-    }, 30000);
-  }
-
-  checkEmails() {
-    try {
-      // Добавляем обработчики ошибок
-      this.imap.once('error', (err) => {
-        logger.error(`IMAP connection error during check: ${err.message}`);
-        // Пытаемся закрыть соединение при ошибке
-        try {
-          this.imap.end();
-        } catch (e) {
-          // Игнорируем ошибки при закрытии
-        }
-      });
-
-      this.imap.once('ready', () => {
-        this.imap.openBox('INBOX', false, (err, box) => {
-          if (err) {
-            logger.error(`Error opening inbox: ${err}`);
-            this.imap.end();
-            return;
-          }
-          
-          // Ищем непрочитанные письма
-          this.imap.search(['UNSEEN'], (err, results) => {
-            if (err) {
-              logger.error(`Error searching messages: ${err}`);
-              this.imap.end();
-              return;
-            }
-            
-            if (!results || results.length === 0) {
-              logger.info('No new messages found');
-              this.imap.end();
-              return;
-            }
-            
-            // Защищаемся от пустых результатов
-            try {
-              const f = this.imap.fetch(results, { bodies: '' });
-              
-              f.on('message', (msg, seqno) => {
-                msg.on('body', (stream, info) => {
-                  simpleParser(stream, async (err, parsed) => {
-                    if (err) {
-                      logger.error(`Error parsing message: ${err}`);
-                      return;
-                    }
-                    
-                    // Обработка входящего письма
-                    try {
-                      await this.processEmail(parsed);
-                    } catch (e) {
-                      logger.error(`Error processing email: ${e.message}`);
-                    }
-                  });
-                });
-              });
-              
-              f.once('error', (err) => {
-                logger.error(`Fetch error: ${err}`);
-              });
-              
-              f.once('end', () => {
-                try {
-                  this.imap.end();
-                } catch (e) {
-                  logger.error(`Error ending IMAP connection: ${e.message}`);
-                }
-              });
-            } catch (e) {
-              logger.error(`Error fetching messages: ${e.message}`);
-              try {
-                this.imap.end();
-              } catch (e) {
-                // Игнорируем ошибки при закрытии
-              }
-            }
-          });
-        });
-      });
-      
-      this.imap.connect();
-    } catch (error) {
-      logger.error(`Global error checking emails: ${error.message}`);
-      // Обеспечиваем корректное завершение IMAP сессии
-      try {
-        this.imap.end();
-      } catch (e) {
-        // Игнорируем ошибки при закрытии
-      }
-    }
-  }
-
-  async processEmail(email) {
-    try {
-      const fromEmail = email.from.value[0].address.toLowerCase();
-      const subject = email.subject;
-      const text = email.text;
-
-      // Ищем код в тексте письма
-      const codeMatch = text.match(/\b\d{6}\b/);
-      if (!codeMatch) return;
-      
-      const code = codeMatch[0];
-      
-      // Проверяем код через сервис верификации
-      const result = await verificationService.verifyCode(code, 'email', fromEmail);
-      
-      if (!result.success) {
-        // Отправляем сообщение об ошибке
-        await this.transporter.sendMail({
-          from: this.user,
-          to: fromEmail,
-          subject: 'Ошибка верификации',
-          text: 'Неверный или истекший код подтверждения. Пожалуйста, запросите новый код.'
-        });
-        return;
-      }
-      
-      // Код верный и актуальный
-      const userId = result.userId;
-      
-      // Добавляем идентификатор email для пользователя
-      await pool.query(
-        'INSERT INTO user_identities (user_id, identity_type, identity_value, verified, created_at) ' +
-        'VALUES ($1, $2, $3, true, NOW()) ' +
-        'ON CONFLICT (identity_type, identity_value) ' +
-        'DO UPDATE SET user_id = $1, verified = true',
-        [userId, 'email', fromEmail]
-      );
-      
-      // Отправляем подтверждение
-      await this.transporter.sendMail({
-        from: this.user,
-        to: fromEmail,
-        subject: 'Аутентификация успешна',
-        text: 'Ваш email успешно связан с аккаунтом DApp for Business.'
-      });
-      
-    } catch (error) {
-      logger.error(`Error processing email: ${error}`);
-    }
-  }
-
   // Метод для проверки кода без IMAP
   async verifyCode(email, code) {
     return await verificationService.verifyCode(code, 'email', email.toLowerCase());
   }
 
-  // Оставляем существующие методы
+  // Оставляем существующий метод для отправки электронных писем
   async sendEmail(to, subject, text) {
     try {
       const mailOptions = {

frontend/src/views/HomeView.vue

@@ -77,8 +77,48 @@
               Подключить Telegram
             </button>
             
-            <!-- Email верификация -->
+            <!-- Email секция -->
-            <div v-if="showEmailVerification" class="verification-block">
+            <!-- Форма ввода email -->
+            <div v-if="showEmailForm" class="email-form">
+              <p>Введите ваш email для получения кода подтверждения:</p>
+              <div class="email-input-container">
+                <input 
+                  v-model="emailInput" 
+                  type="email" 
+                  placeholder="Ваш email" 
+                  class="email-input"
+                  :class="{ 'email-input-error': emailFormatError }"
+                />
+                <button @click="sendEmailVerification" class="send-email-btn" :disabled="isEmailSending">
+                  {{ isEmailSending ? 'Отправка...' : 'Отправить код' }}
+                </button>
+              </div>
+              <p v-if="emailFormatError" class="email-format-error">Пожалуйста, введите корректный email</p>
+            </div>
+            
+            <!-- Форма ввода кода верификации -->
+            <div v-else-if="showEmailVerificationInput" class="email-verification-form">
+              <p>На ваш email <strong>{{ emailVerificationEmail }}</strong> отправлен код подтверждения.</p>
+              <div class="verification-input">
+                <input 
+                  v-model="emailVerificationCode" 
+                  type="text" 
+                  placeholder="Введите код верификации" 
+                  maxlength="6"
+                />
+                <button @click="verifyEmailCode" class="verify-btn" :disabled="isVerifying">
+                  {{ isVerifying ? 'Проверка...' : 'Подтвердить' }}
+                </button>
+              </div>
+            </div>
+            
+            <!-- Сообщение об успехе -->
+            <div v-else-if="showSuccessMessage" class="success-message">
+              <span>{{ successMessage }}</span>
+            </div>
+            
+            <!-- Email верификация через код (старый способ) -->
+            <div v-else-if="showEmailVerification" class="verification-block">
               <div class="verification-code">
                 <span>Код подтверждения:</span>
                 <code @click="copyCode(emailVerificationCode)">{{ emailVerificationCode }}</code>
@@ -130,6 +170,8 @@
                 </div>
               </div>
             </div>
+            
+            <!-- Кнопка для начала email аутентификации -->
             <button v-else class="auth-btn email-btn" @click="handleEmailAuth">
               Подключить Email
             </button>
@@ -195,11 +237,25 @@ const telegramBotLink = ref('');
 const telegramAuthCheckInterval = ref(null);
 const showEmailVerification = ref(false);
 const emailVerificationCode = ref('');
-const emailAuthCheckInterval = ref(null);
 const emailError = ref('');
 const codeCopied = ref(false);
 const showEmailAlternatives = ref(false);
 
+// Добавляем новые состояния для формы ввода кода
+const showEmailVerificationInput = ref(false);
+const emailVerificationEmail = ref('');
+
+// Добавляем новые состояния для формы ввода email
+const showEmailForm = ref(false);
+const emailInput = ref('');
+const emailFormatError = ref(false);
+const isEmailSending = ref(false);
+
+// Добавляем новые состояния для индикации и успешных сообщений
+const isVerifying = ref(false);
+const successMessage = ref('');
+const showSuccessMessage = ref(false);
+
 // Функция для копирования кода
 const copyCode = (code) => {
   navigator.clipboard.writeText(code).then(() => {
@@ -319,53 +375,108 @@ const clearEmailError = () => {
 // Функция для обработки Email аутентификации
 const handleEmailAuth = async () => {
   try {
-    clearEmailError(); // Очищаем ошибку перед новой попыткой
+    // Показываем форму для ввода email
-    
+    showEmailForm.value = true;
-    // Инициализируем процесс аутентификации
+    // Сбрасываем другие состояния форм
-    const response = await axios.post('/api/auth/email/init');
+    showEmailVerification.value = false;
-    
+    showEmailVerificationInput.value = false;
-    if (response.data.success) {
+    // Очищаем поля и ошибки
-      showEmailVerification.value = true;
+    emailInput.value = '';
-      emailVerificationCode.value = response.data.verificationCode;
+    emailFormatError.value = false;
-      
+    emailError.value = '';
-      // Запускаем проверку статуса аутентификации
-      startEmailAuthCheck();
-    }
   } catch (error) {
     console.error('Error in email auth:', error);
-    emailError.value = 'Ошибка при подключении Email';
   }
 };
 
-// Функция для запуска проверки статуса аутентификации по Email
+// Функция для отправки запроса на верификацию email
-const startEmailAuthCheck = () => {
+const sendEmailVerification = async () => {
-  if (emailAuthCheckInterval.value) {
+  try {
-    clearInterval(emailAuthCheckInterval.value);
+    emailFormatError.value = false;
+    emailError.value = '';
+    
+    // Проверяем формат email
+    if (!emailInput.value || !emailInput.value.match(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)) {
+      emailFormatError.value = true;
+      return;
     }
     
-  emailAuthCheckInterval.value = setInterval(async () => {
+    isEmailSending.value = true;
+    
+    // Отправляем запрос на сервер для инициализации email аутентификации
+    const response = await axios.post('/api/auth/email/init', { email: emailInput.value });
+    
+    if (response.data.success) {
+      // Скрываем форму ввода email
+      showEmailForm.value = false;
+      // Показываем форму для ввода кода
+      showEmailVerificationInput.value = true;
+      // Скрываем старую форму кода верификации
+      showEmailVerification.value = false;
+      // Сохраняем email
+      emailVerificationEmail.value = emailInput.value;
+      // Очищаем поле для ввода кода
+      emailVerificationCode.value = '';
+    } else {
+      emailError.value = response.data.error || 'Ошибка инициализации аутентификации по email';
+    }
+  } catch (error) {
+    emailError.value = 'Ошибка при запросе кода подтверждения';
+    console.error('Error in email auth:', error);
+  } finally {
+    isEmailSending.value = false;
+  }
+};
+
+// Функция для проверки введенного кода
+const verifyEmailCode = async () => {
   try {
+    // Очищаем сообщение об ошибке
+    emailError.value = '';
+    
+    if (!emailVerificationCode.value) {
+      emailError.value = 'Пожалуйста, введите код верификации';
+      return;
+    }
+
+    // Показываем индикатор процесса верификации
+    isVerifying.value = true;
+    
     const response = await axios.get('/api/auth/check-email-verification', {
       params: { code: emailVerificationCode.value }
     });
     
     if (response.data.verified) {
-        clearInterval(emailAuthCheckInterval.value);
+      // Сбрасываем все состояния форм email
+      showEmailVerificationInput.value = false;
+      showEmailForm.value = false;
       showEmailVerification.value = false;
       
+      // Показываем сообщение об успешной верификации
+      successMessage.value = `Email ${emailVerificationEmail.value} успешно подтвержден!`;
+      showSuccessMessage.value = true;
+      
+      // Скрываем сообщение через 3 секунды
+      setTimeout(() => {
+        showSuccessMessage.value = false;
+      }, 3000);
+      
       // Обновляем состояние аутентификации
       await auth.checkAuth();
       
-        // Перезагружаем страницу для обновления UI
+      // Перезагружаем страницу для обновления UI через 1 секунду
+      setTimeout(() => {
         window.location.reload();
-      } else if (response.data.message) {
+      }, 1000);
-        // Показываем сообщение пользователю, если есть
+    } else {
-        emailError.value = response.data.message;
+      emailError.value = response.data.message || 'Неверный код верификации';
     }
   } catch (error) {
-      console.error('Error checking email verification:', error);
+    emailError.value = 'Ошибка при проверке кода';
+    console.error('Error verifying email code:', error);
+  } finally {
+    isVerifying.value = false;
   }
-  }, 5000); // Проверяем каждые 5 секунд
 };
 
 // Функция для сокращения адреса кошелька
@@ -654,9 +765,6 @@ onBeforeUnmount(() => {
   if (telegramAuthCheckInterval.value) {
     clearInterval(telegramAuthCheckInterval.value);
   }
-  if (emailAuthCheckInterval.value) {
-    clearInterval(emailAuthCheckInterval.value);
-  }
 });
 </script>
 
@@ -1225,4 +1333,107 @@ h1 {
 .copy-button:hover {
   background-color: #e0e0e0;
 }
+
+.email-verification-form {
+  margin: 10px 0;
+  padding: 15px;
+  background-color: #f5f5f5;
+  border-radius: 5px;
+  border-left: 4px solid #4CAF50;
+}
+
+.verification-input {
+  display: flex;
+  margin-top: 10px;
+  gap: 10px;
+}
+
+.verification-input input {
+  flex: 1;
+  padding: 8px 12px;
+  border: 1px solid #ccc;
+  border-radius: 4px;
+  font-size: 16px;
+  letter-spacing: 2px;
+}
+
+.verify-btn {
+  background-color: #4CAF50;
+  color: white;
+  border: none;
+  border-radius: 4px;
+  padding: 8px 15px;
+  cursor: pointer;
+}
+
+.verify-btn:hover {
+  background-color: #45a049;
+}
+
+.email-form {
+  margin: 10px 0;
+  padding: 15px;
+  background-color: #f5f5f5;
+  border-radius: 5px;
+  border-left: 4px solid #4CAF50;
+}
+
+.email-input-container {
+  display: flex;
+  margin-top: 10px;
+  gap: 10px;
+}
+
+.email-input {
+  flex: 1;
+  padding: 8px 12px;
+  border: 1px solid #ccc;
+  border-radius: 4px;
+  font-size: 16px;
+}
+
+.email-input-error {
+  border-color: #f44336;
+}
+
+.send-email-btn {
+  background-color: #4CAF50;
+  color: white;
+  border: none;
+  border-radius: 4px;
+  padding: 8px 15px;
+  cursor: pointer;
+}
+
+.send-email-btn:hover:not(:disabled) {
+  background-color: #45a049;
+}
+
+.send-email-btn:disabled {
+  background-color: #cccccc;
+  cursor: not-allowed;
+}
+
+.email-format-error {
+  color: #f44336;
+  font-size: 14px;
+  margin-top: 5px;
+  margin-bottom: 0;
+}
+
+.success-message {
+  padding: 10px 15px;
+  background-color: #dff0d8;
+  color: #3c763d;
+  border-radius: 4px;
+  border-left: 4px solid #3c763d;
+  margin: 10px 0;
+  animation: fadeOut 3s forwards;
+}
+
+@keyframes fadeOut {
+  0% { opacity: 1; }
+  80% { opacity: 1; }
+  100% { opacity: 0; }
+}
 </style>