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

backend/routes/chat.js

@@ -69,59 +69,99 @@ async function getAIResponse(message, language = 'ru') {
 // Функция для обработки гостевых сообщений после аутентификации
 async function processGuestMessages(userId, guestId) {
   try {
-    console.log(`Starting to process guest messages for user ${userId} with guestId ${guestId}`);
-
+    console.log(`Processing guest messages for user ${userId} with guest ID ${guestId}`);
+    
     // Получаем все гостевые сообщения
-    const guestMessages = await db.query(
-      `SELECT m.id, m.content, m.conversation_id, m.metadata, m.created_at
-       FROM messages m
-       WHERE m.metadata->>'guest_id' = $1
-       ORDER BY m.created_at ASC`,
+    const guestMessagesResult = await db.query(
+      'SELECT * FROM guest_messages WHERE guest_id = $1 ORDER BY created_at ASC',
       [guestId]
     );
-
-    console.log(`Found ${guestMessages.rows.length} guest messages to process`);
-
-    // Обновляем user_id для всех бесед с гостевыми сообщениями
-    await db.query(
-      `UPDATE conversations c
-       SET user_id = $1
-       WHERE id IN (
-         SELECT DISTINCT conversation_id
-         FROM messages m
-         WHERE m.metadata->>'guest_id' = $2
-       )`,
-      [userId, guestId]
-    );
-
-    // Обрабатываем каждое гостевое сообщение
-    for (const msg of guestMessages.rows) {
-      console.log(`Processing guest message ${msg.id}: ${msg.content}`);
-      
-      // Получаем язык из метаданных
-      const metadata = typeof msg.metadata === 'string' ? JSON.parse(msg.metadata) : msg.metadata;
-      const language = metadata?.language || 'ru';
-
-      // Получаем ответ от AI
-      console.log(`Getting AI response for message ${msg.id} in ${language}`);
-      const aiResponse = await aiAssistant.getResponse(msg.content, language);
-
-      // Сохраняем ответ AI в ту же беседу
-      await db.query(
-        `INSERT INTO messages 
-         (conversation_id, sender_type, content, channel, created_at)
-         VALUES ($1, 'assistant', $2, 'chat', NOW())`,
-        [msg.conversation_id, aiResponse]
-      );
-
-      console.log(`Saved AI response for message ${msg.id}`);
+    
+    if (guestMessagesResult.rows.length === 0) {
+      console.log('No guest messages found');
+      return { success: true, message: 'No guest messages found' };
     }
-
-    console.log(`Successfully processed all guest messages for user ${userId}`);
-    return true;
+    
+    const guestMessages = guestMessagesResult.rows;
+    console.log(`Found ${guestMessages.length} guest messages`);
+    
+    // Создаем новый диалог для этих сообщений
+    const firstMessage = guestMessages[0];
+    const title = firstMessage.content.length > 30 
+      ? `${firstMessage.content.substring(0, 30)}...` 
+      : firstMessage.content;
+    
+    const newConversationResult = await db.query(
+      'INSERT INTO conversations (user_id, title) VALUES ($1, $2) RETURNING *',
+      [userId, title]
+    );
+    
+    const conversation = newConversationResult.rows[0];
+    console.log('Created new conversation for guest messages:', conversation);
+    
+    // Обрабатываем каждое гостевое сообщение
+    for (const guestMessage of guestMessages) {
+      console.log(`Processing guest message ID ${guestMessage.id}: ${guestMessage.content}`);
+      
+      // Сохраняем сообщение пользователя
+      const userMessageResult = await db.query(
+        `INSERT INTO messages 
+          (conversation_id, content, sender_type, role, guest_message_id, channel, created_at) 
+         VALUES 
+          ($1, $2, $3, $4, $5, $6, $7) 
+         RETURNING *`,
+        [
+          conversation.id, 
+          guestMessage.content, 
+          'user', 
+          'user', 
+          guestMessage.id,
+          'web',
+          guestMessage.created_at
+        ]
+      );
+      
+      console.log(`Saved user message with ID ${userMessageResult.rows[0].id}`);
+      
+      // Получаем ответ от ИИ
+      console.log('Getting AI response for:', guestMessage.content);
+      const language = guestMessage.language || 'auto';
+      const aiResponse = await aiAssistant.getResponse(guestMessage.content, language);
+      console.log('AI response received:', aiResponse);
+      
+      // Сохраняем ответ от ИИ
+      const aiMessageResult = await db.query(
+        `INSERT INTO messages 
+          (conversation_id, content, sender_type, role, guest_message_id, channel, created_at) 
+         VALUES 
+          ($1, $2, $3, $4, $5, $6, $7) 
+         RETURNING *`,
+        [
+          conversation.id, 
+          aiResponse, 
+          'assistant', 
+          'assistant', 
+          guestMessage.id,
+          'web',
+          new Date()
+        ]
+      );
+      
+      console.log(`Saved AI response with ID ${aiMessageResult.rows[0].id}`);
+    }
+    
+    // Удаляем гостевые сообщения, так как они уже обработаны
+    await db.query('DELETE FROM guest_messages WHERE guest_id = $1', [guestId]);
+    console.log('Deleted processed guest messages');
+    
+    return { 
+      success: true, 
+      message: `Processed ${guestMessages.length} guest messages`,
+      conversationId: conversation.id
+    };
   } catch (error) {
     console.error('Error processing guest messages:', error);
-    return false;
+    throw error;
   }
 }
 
@@ -157,55 +197,82 @@ router.post('/guest-message', async (req, res) => {
 
 // Маршрут для обычных сообщений (для аутентифицированных пользователей)
 router.post('/message', requireAuth, async (req, res) => {
+  const { message, conversationId, language = 'auto' } = req.body;
+  
+  if (!message) {
+    return res.status(400).json({ error: 'Message is required' });
+  }
+
   try {
-    const { message, language } = req.body;
+    console.log('Processing message:', { message, conversationId, language, userId: req.session.userId });
     const userId = req.session.userId;
-
-    // Используем методы из aiAssistant вместо прямого обращения к vectorStore
-    const similarDocs = await aiAssistant.findSimilarDocuments(message);
-    const aiResponse = await aiAssistant.getResponse(message, language);
-
-    // Создаем новую беседу или получаем существующую
-    const conversationResult = await db.query(
-      `INSERT INTO conversations (user_id, created_at)
-       VALUES ($1, NOW())
-       RETURNING id`,
-      [userId]
+    
+    let conversation;
+    
+    // Если указан ID диалога, проверяем его существование и принадлежность пользователю
+    if (conversationId) {
+      const conversationResult = await db.query(
+        'SELECT * FROM conversations WHERE id = $1 AND user_id = $2',
+        [conversationId, userId]
+      );
+      
+      if (conversationResult.rows.length === 0) {
+        return res.status(404).json({ error: 'Conversation not found or access denied' });
+      }
+      
+      conversation = conversationResult.rows[0];
+      console.log('Using existing conversation:', conversation);
+    } else {
+      // Создаем новый диалог
+      const title = message.length > 30 ? `${message.substring(0, 30)}...` : message;
+      
+      const newConversationResult = await db.query(
+        'INSERT INTO conversations (user_id, title) VALUES ($1, $2) RETURNING *',
+        [userId, title]
+      );
+      
+      conversation = newConversationResult.rows[0];
+      console.log('Created new conversation:', conversation);
+    }
+    
+    // Сохраняем сообщение пользователя
+    console.log('Saving user message');
+    const userMessageResult = await db.query(
+      `INSERT INTO messages 
+        (conversation_id, content, sender_type, role, tokens_used, channel, created_at) 
+       VALUES 
+        ($1, $2, $3, $4, $5, $6, $7) 
+       RETURNING *`,
+      [conversation.id, message, 'user', 'user', 0, 'web', new Date()]
     );
     
-    const conversationId = conversationResult.rows[0].id;
-
-    // Сохраняем сообщение пользователя
-    await db.query(
+    // Получаем ответ от ИИ
+    console.log('Getting AI response');
+    const aiResponse = await aiAssistant.getResponse(message, language);
+    console.log('AI response received:', aiResponse);
+    
+    // Сохраняем ответ от ИИ
+    console.log('Saving AI response');
+    const aiMessageResult = await db.query(
       `INSERT INTO messages 
-       (conversation_id, sender_type, content, channel, metadata, created_at)
-       VALUES ($1, 'user', $2, 'chat', $3, NOW())`,
-      [
-        conversationId,
-        message,
-        JSON.stringify({ language: language || 'ru' })
-      ]
+        (conversation_id, content, sender_type, role, tokens_used, channel, created_at) 
+       VALUES 
+        ($1, $2, $3, $4, $5, $6, $7) 
+       RETURNING *`,
+      [conversation.id, aiResponse, 'assistant', 'assistant', 0, 'web', new Date()]
     );
-
-    // Сохраняем ответ AI
-    await db.query(
-      `INSERT INTO messages 
-       (conversation_id, sender_type, content, channel, metadata, created_at)
-       VALUES ($1, 'assistant', $2, 'chat', $3, NOW())`,
-      [
-        conversationId,
-        aiResponse,
-        JSON.stringify({ language: language || 'ru' })
-      ]
-    );
-
-    res.json({
+    
+    const response = {
       success: true,
-      message: aiResponse
-    });
+      userMessage: userMessageResult.rows[0],
+      aiMessage: aiMessageResult.rows[0],
+      conversation
+    };
+    
+    res.json(response);
   } catch (error) {
-    logger.error('Error processing message:', error);
-    res.status(500).json({ error: 'Internal server error' });
+    console.error('Error processing message:', error);
+    res.status(500).json({ error: 'Error processing message' });
   }
 });
 
@@ -232,35 +299,79 @@ router.get('/history', async (req, res) => {
       id: req.sessionID,
       userId: req.session.userId,
       address: req.session.address,
-      authenticated: req.session.authenticated
+      authenticated: req.session.authenticated,
+      guestId: req.session.guestId
     });
     
-    if (!req.session.authenticated || !req.session.userId) {
-      return res.status(401).json({ error: 'Unauthorized' });
-    }
-
     const limit = parseInt(req.query.limit) || 50;
     const offset = parseInt(req.query.offset) || 0;
 
-    // Получаем сообщения с пагинацией
-    const result = await db.query(
-      `SELECT 
-         m.id, 
-         m.content, 
-         m.sender_type as role, 
-         m.created_at,
-         c.user_id
-       FROM messages m
-       JOIN conversations c ON m.conversation_id = c.id
-       WHERE c.user_id = $1
-       ORDER BY m.created_at DESC
-       LIMIT $2 OFFSET $3`,
-      [req.session.userId, limit, offset]
-    );
+    let messages = [];
+    let total = 0;
+
+    // Если пользователь аутентифицирован, получаем его сообщения
+    if (req.session.authenticated && req.session.userId) {
+      const countResult = await db.query(
+        `SELECT COUNT(*) as total FROM messages m
+         JOIN conversations c ON m.conversation_id = c.id
+         WHERE c.user_id = $1`,
+        [req.session.userId]
+      );
+      total = parseInt(countResult.rows[0].total) || 0;
+
+      const result = await db.query(
+        `SELECT 
+           m.id, 
+           m.content, 
+           m.sender_type,
+           m.role,
+           m.created_at,
+           c.user_id,
+           c.id as conversation_id
+         FROM messages m
+         JOIN conversations c ON m.conversation_id = c.id
+         WHERE c.user_id = $1
+         ORDER BY m.created_at ASC
+         LIMIT $2 OFFSET $3`,
+        [req.session.userId, limit, offset]
+      );
+      
+      messages = result.rows;
+      console.log(`Found ${messages.length} messages for authenticated user`);
+    }
+    // Если есть guestId, получаем гостевые сообщения
+    else if (req.session.guestId) {
+      const countResult = await db.query(
+        `SELECT COUNT(*) as total FROM guest_messages
+         WHERE guest_id = $1`,
+        [req.session.guestId]
+      );
+      total = parseInt(countResult.rows[0].total) || 0;
+
+      const result = await db.query(
+        `SELECT 
+           id, 
+           content, 
+           'user' as sender_type, 
+           'user' as role, 
+           created_at,
+           guest_id as user_id,
+           NULL as conversation_id
+         FROM guest_messages
+         WHERE guest_id = $1
+         ORDER BY created_at ASC
+         LIMIT $2 OFFSET $3`,
+        [req.session.guestId, limit, offset]
+      );
+      
+      messages = result.rows;
+      console.log(`Found ${messages.length} guest messages`);
+    }
 
     return res.json({
       success: true,
-      messages: result.rows.reverse()
+      messages: messages,
+      total: total
     });
 
   } catch (error) {
@@ -316,30 +427,49 @@ router.post('/link-guest-messages', requireAuth, async (req, res) => {
     }
 
     // Проверяем наличие гостевых сообщений
-    const guestMessages = await db.query(
+    const guestMessagesCheck = await db.query(
       'SELECT EXISTS(SELECT 1 FROM guest_messages WHERE guest_id = $1)',
       [guestId]
     );
 
-    console.log('Guest messages check:', guestMessages.rows[0]);
+    console.log('Guest messages check:', guestMessagesCheck.rows[0]);
 
-    if (!guestMessages.rows[0].exists) {
+    if (!guestMessagesCheck.rows[0].exists) {
       console.log('No guest messages found for guestId:', guestId);
       return res.json({ success: true, message: 'No guest messages to link' });
     }
 
-    // Связываем сообщения
-    console.log('Calling link_guest_messages function');
-    await db.query('SELECT link_guest_messages($1, $2)', [userId, guestId]);
-    
-    // Очищаем guestId из сессии после связывания
-    delete req.session.guestId;
-    
-    console.log('Messages linked successfully');
-    res.json({ success: true });
+    try {
+      // Обрабатываем гостевые сообщения для получения ответов от AI
+      console.log('Processing guest messages to get AI responses');
+      const result = await processGuestMessages(userId, guestId);
+      console.log('Guest messages processed:', result);
+      
+      // Очищаем guestId из сессии после связывания
+      req.session.guestId = null;
+      await req.session.save();
+      
+      console.log('Messages linked and processed successfully');
+      return res.json({ 
+        success: true,
+        message: 'Guest messages linked and processed',
+        result
+      });
+    } catch (processError) {
+      console.error('Error processing guest messages:', processError);
+      return res.status(500).json({ 
+        success: false, 
+        error: 'Error processing guest messages',
+        details: processError.message
+      });
+    }
   } catch (error) {
     console.error('Error linking guest messages:', error);
-    res.status(500).json({ success: false, error: 'Internal server error' });
+    return res.status(500).json({ 
+      success: false, 
+      error: 'Internal server error',
+      details: error.message
+    });
   }
 });
 
@@ -395,4 +525,28 @@ router.delete('/message/:id', requireAuth, async (req, res) => {
   }
 });
 
+// Маршрут для проверки и инициализации сессии
+router.get('/check-session', async (req, res) => {
+  try {
+    // Если у пользователя нет guestId, создаем его
+    if (!req.session.guestId) {
+      req.session.guestId = crypto.randomBytes(16).toString('hex');
+      await req.session.save();
+      console.log('Created new guestId:', req.session.guestId);
+    }
+    
+    res.json({
+      success: true,
+      guestId: req.session.guestId,
+      isAuthenticated: req.session.authenticated || false
+    });
+  } catch (error) {
+    console.error('Error checking session:', error);
+    res.status(500).json({
+      success: false,
+      error: 'Internal server error'
+    });
+  }
+});
+
 module.exports = router;

backend/services/ai-assistant.js

@@ -2,6 +2,7 @@ const { ChatOllama } = require('@langchain/ollama');
 const { HNSWLib } = require('@langchain/community/vectorstores/hnswlib');
 const { OpenAIEmbeddings } = require('@langchain/openai');
 const logger = require('../utils/logger');
+const fetch = require('node-fetch');
 
 class AIAssistant {
   constructor() {
@@ -18,7 +19,10 @@ class AIAssistant {
     return new ChatOllama({
       baseUrl: this.baseUrl,
       model: this.defaultModel,
-      system: systemPrompt
+      system: systemPrompt,
+      temperature: 0.7,
+      maxTokens: 1000,
+      timeout: 30000 // 30 секунд таймаут
     });
   }
 
@@ -31,25 +35,38 @@ class AIAssistant {
   // Основной метод для получения ответа
   async getResponse(message, language = 'auto') {
     try {
+      console.log('getResponse called with:', { message, language });
+      
       // Определяем язык, если не указан явно
       const detectedLanguage = language === 'auto' 
         ? this.detectLanguage(message) 
         : language;
 
-      const chat = this.createChat(detectedLanguage);
+      console.log('Detected language:', detectedLanguage);
       
+      // Сначала пробуем прямой API запрос
       try {
-        // Пробуем получить ответ через ChatOllama
+        console.log('Trying direct API request...');
+        const response = await this.fallbackRequest(message, detectedLanguage);
+        console.log('Direct API response received:', response);
+        return response;
+      } catch (error) {
+        console.error('Error in direct API request:', error);
+      }
+
+      // Если прямой запрос не удался, пробуем через ChatOllama
+      const chat = this.createChat(detectedLanguage);
+      try {
+        console.log('Sending request to ChatOllama...');
         const response = await chat.invoke(message);
+        console.log('ChatOllama response:', response);
         return response.content;
       } catch (error) {
-        logger.error('Error using ChatOllama:', error);
-        
-        // Пробуем альтернативный метод через прямой API
-        return await this.fallbackRequest(message, detectedLanguage);
+        console.error('Error using ChatOllama:', error);
+        throw error;
       }
     } catch (error) {
-      logger.error('Error in getResponse:', error);
+      console.error('Error in getResponse:', error);
       return "Извините, я не смог обработать ваш запрос. Пожалуйста, попробуйте позже.";
     }
   }
@@ -57,12 +74,13 @@ class AIAssistant {
   // Альтернативный метод запроса через прямой API
   async fallbackRequest(message, language) {
     try {
-      logger.info('Using fallback request method');
+      console.log('Using fallback request method with:', { message, language });
       
       const systemPrompt = language === 'ru'
         ? 'Вы - полезный ассистент. Отвечайте на русском языке.'
         : 'You are a helpful assistant. Respond in English.';
 
+      console.log('Sending request to Ollama API...');
       const response = await fetch(`${this.baseUrl}/api/generate`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
@@ -70,14 +88,23 @@ class AIAssistant {
           model: this.defaultModel,
           prompt: message,
           system: systemPrompt,
-          stream: false
+          stream: false,
+          options: {
+            temperature: 0.7,
+            num_predict: 1000
+          }
         }),
       });
       
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      
       const data = await response.json();
+      console.log('Ollama API response:', data);
       return data.response;
     } catch (error) {
-      logger.error('Error in fallback request:', error);
+      console.error('Error in fallback request:', error);
       throw error;
     }
   }