@peopl-health/nexus 1.0.3 → 1.1.1

package/lib/controllers/conversationController.js

@@ -0,0 +1,582 @@
+const { Message } = require('../models/messageModel');
+const { sendMessage } = require('../services/whatsappService');
+const { fetchConversationData, processConversations } = require('../services/conversationService');
+
+const getConversationController = async (req, res) => {
+  const startTime = Date.now();
+  console.log('Starting getConversationController at', new Date().toISOString());
+
+  try {
+    // Parse pagination parameters
+    const limit = parseInt(req.query.limit) || 100;
+    const page = parseInt(req.query.page) || 1;
+    const skip = (page - 1) * limit;
+    const filter = req.query.filter || 'all';
+
+    console.log(`Pagination: page ${page}, limit ${limit}, skip ${skip}, filter: ${filter}`);
+
+    // Check if messages exist
+    const messageCount = await Message.countDocuments({});
+    console.log('Total message count:', messageCount);
+    
+    if (messageCount === 0) {
+      console.log('No messages found in database, returning empty conversations list');
+      return res.status(200).json({
+        success: true,
+        conversations: [],
+        emptyDatabase: true
+      });
+    }
+
+    // Fetch conversation data
+    const { conversations, total, nameMap, unreadMap } = await fetchConversationData(filter, skip, limit);
+
+    if (!conversations || conversations.length === 0) {
+      console.log('No conversations found, returning empty list');
+      return res.status(200).json({
+        success: true,
+        conversations: [],
+        noConversations: true
+      });
+    }
+
+    // Process conversations for response
+    const processedConversations = await processConversations(conversations, nameMap, unreadMap);
+
+    const totalPages = Math.ceil(total / limit);
+    const totalTime = Date.now() - startTime;
+    
+    console.log('Number of conversations found:', conversations?.length || 0);
+    console.log(`Total controller execution time: ${totalTime}ms`);
+    console.log(`Filter: ${filter}, Pagination: ${conversations.length} of ${total} conversations (page ${page}/${totalPages})`);
+
+    res.status(200).json({
+      success: true,
+      conversations: processedConversations,
+      filter: filter,
+      pagination: {
+        page,
+        limit,
+        total,
+        totalPages,
+        hasNext: page < totalPages,
+        hasPrev: page > 1
+      }
+    });
+    console.log('Response sent successfully!');
+
+  } catch (error) {
+    console.error('Error fetching conversations:', error);
+    console.error('Error stack:', error.stack);
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch conversations'
+    });
+  }
+};
+
+const getConversationMessagesController = async (req, res) => {
+  console.log('Starting getConversationMessagesController at', new Date().toISOString());
+  try {
+    const { phoneNumber } = req.params;
+    console.log('Requested conversation for phone number:', phoneNumber);
+    
+    if (!phoneNumber) {
+      return res.status(400).json({
+        success: false,
+        error: 'Phone number is required'
+      });
+    }
+    
+    const limit = parseInt(req.query.limit) || 50;
+    const { before } = req.query;
+        
+    const query = { numero: phoneNumber, is_group: false };
+    if (before) {
+      try {
+        query.createdAt = { $lt: new Date(before) };
+      } catch (parseError) {
+        console.warn('Invalid date format for before parameter:', before, parseError);
+        query.createdAt = { $lt: before };
+      }
+    }
+    
+    console.log('Fetching conversation messages with query:', JSON.stringify(query));
+    console.log('Using limit:', limit);
+        
+    console.log('About to execute Message.find with query:', JSON.stringify(query));
+    let messages = [];
+    
+    try {
+      const countResult = await Message.countDocuments(query);
+      console.log(`Found ${countResult} messages matching query criteria`);
+      
+      if (countResult > 0) {
+        messages = await Message.find(query)
+          .sort({ createdAt: -1 })
+          .limit(limit)
+          .lean();
+          
+        console.log(`Retrieved ${messages.length} messages, inspecting for potential issues...`);
+        
+        const problematicMessages = messages.filter(msg => {
+          if (!msg || !msg.numero || !msg.createdAt) {
+            console.warn('Found message missing required fields:', msg?._id || 'unknown');
+            return true;
+          }
+          
+          if (msg.is_media === true) {
+            if (!msg.media || typeof msg.media !== 'object') {
+              console.warn('Found media message with invalid media data:', msg._id);
+              return true;
+            }
+            
+            if (msg.media && (typeof msg.media.data === 'function' || msg.media.data instanceof Buffer)) {
+              console.warn('Found media message with Buffer data that might cause serialization issues:', msg._id);
+              return true;
+            }
+          }
+          
+          return false;
+        });
+        
+        if (problematicMessages.length > 0) {
+          console.warn(`Found ${problematicMessages.length} potentially problematic messages`);
+          console.log('First problematic message IDs:', problematicMessages.slice(0, 3).map(m => m?._id || 'unknown'));
+        }
+      } else {
+        console.log('No messages found for this query');
+      }
+    } catch (err) {
+      console.error('Database query error in message retrieval:', err);
+      messages = [];
+    }
+    
+    console.log(`Retrieved a total of ${messages?.length || 0} messages for phone number: ${phoneNumber}`);
+    
+    const sanitizedMessages = (messages || []).map(msg => {
+      try {
+        JSON.stringify(msg);
+        return msg;
+      } catch (serializationError) {
+        console.error(`Found non-serializable message with ID ${msg._id}:`, serializationError);
+        return {
+          _id: msg._id?.toString() || 'unknown',
+          numero: msg.numero || phoneNumber,
+          body: msg.body || '[Message content unavailable]',
+          createdAt: msg.createdAt || new Date(),
+          from_me: !!msg.from_me,
+          is_media: !!msg.is_media,
+          error: 'Message contained non-serializable data'
+        };
+      }
+    });
+        
+    const reversedMessages = sanitizedMessages.reverse();
+    console.log(`Sending ${reversedMessages.length} sanitized messages in response`);
+        
+    res.status(200).json({
+      success: true,
+      phoneNumber,
+      messages: reversedMessages
+    });
+    console.log('Successfully sent conversation messages response');
+  } catch (error) {
+    console.error(`Error fetching conversation for ${req.params?.phoneNumber || 'unknown'}:`, error);
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch conversation'
+    });
+  }
+};
+
+const getConversationReplyController = async (req, res) => {
+  console.log('Starting getConversationReplyController at', new Date().toISOString());
+  try {
+    const { phoneNumber, message, mediaData, contentSid, variables } = req.body;
+    console.log('Reply request params:', { 
+      phoneNumber, 
+      hasMessage: !!message, 
+      hasMediaData: !!mediaData,
+      hasContentSid: !!contentSid,
+      hasVariables: !!variables
+    });
+        
+    if (!phoneNumber || (!message && !mediaData && !contentSid)) {
+      return res.status(400).json({
+        success: false,
+        error: 'Phone number and either message, media data, or template ID are required'
+      });
+    }
+        
+    const formattedPhoneNumber = phoneNumber?.startsWith('whatsapp:') 
+      ? phoneNumber 
+      : `whatsapp:${phoneNumber}`;
+    console.log('Formatted phone number:', formattedPhoneNumber);
+    
+    const messageData = {
+      code: formattedPhoneNumber,
+      fileType: 'text'
+    };
+    
+    // Handle template message (contentSid provided)
+    if (contentSid) {
+      console.log('Processing template message with contentSid:', contentSid);
+      messageData.contentSid = contentSid;
+      
+      if (variables && Object.keys(variables).length > 0) {
+        console.log('Template variables:', JSON.stringify(variables));
+        messageData.variables = variables;
+      }
+      
+      const now = new Date();
+      const timestamp = now.getTime();
+      const uniqueId = `${Math.floor(Math.random() * 10000)}`;
+      
+      messageData.templateMetadata = {
+        timestamp: timestamp,
+        uniqueId: uniqueId,
+        variableCount: variables ? Object.keys(variables).length : 0
+      };
+    }
+    // Handle media message
+    else if (mediaData && mediaData.fileUrl) {
+      console.log('Processing media data:', { fileType: mediaData.fileType, hasFileUrl: !!mediaData.fileUrl, fileName: mediaData.fileName });
+      messageData.fileUrl = mediaData.fileUrl;
+      messageData.fileType = mediaData.fileType || 'image';
+      
+      if (mediaData.fileName) {
+        messageData.fileName = mediaData.fileName;
+      }
+      
+      if (message && message.trim() !== '') {
+        messageData.message = message;
+      }
+    }
+    // Handle text message
+    else if (message) {
+      messageData.message = message;
+    }
+        
+    console.log('Sending message with data:', JSON.stringify(messageData));
+    await sendMessage(messageData);
+    console.log('Message sent successfully');
+        
+    res.status(200).json({
+      success: true,
+      message: 'Reply sent successfully'
+    });
+  } catch (error) {
+    console.error('Error sending reply:', error);
+    console.log('Request body:', JSON.stringify(req.body || {}));
+    const errorMsg = error.message || 'Failed to send reply';
+    console.error('Responding with error:', errorMsg);
+    res.status(500).json({
+      success: false,
+      error: errorMsg
+    });
+  }
+};
+
+const searchConversationsController = async (req, res) => {
+  try {
+    const { query, limit = 50 } = req.query;
+
+    if (!query || query.trim().length === 0) {
+      return res.status(400).json({
+        success: false,
+        error: 'Search query is required'
+      });
+    }
+
+    console.log(`Searching conversations for query: "${query}"`);
+    const searchStartTime = Date.now();
+
+    const escapedQuery = query.replace(/\+/g, '\\+');
+
+    // Search through all conversations in the database
+    const conversations = await Message.aggregate([
+      { $match: { 
+        is_group: false,
+        $or: [
+          { numero: { $regex: escapedQuery, $options: 'i' } },
+          { nombre_whatsapp: { $regex: escapedQuery, $options: 'i' } },
+          { body: { $regex: escapedQuery, $options: 'i' } }
+        ]
+      }},
+      { $project: {
+        numero: 1,
+        body: 1,
+        createdAt: 1,
+        timestamp: 1,
+        is_media: 1,
+        media: 1,
+        nombre_whatsapp: 1,
+        from_me: 1
+      }},
+      { $group: {
+        _id: '$numero',
+        latestMessage: { $first: '$$ROOT' },
+        messageCount: { $sum: 1 }
+      }},
+      { $sort: { 'latestMessage.createdAt': -1 } },
+      { $limit: parseInt(limit) }
+    ]);
+
+    const searchTime = Date.now() - searchStartTime;
+    console.log(`Search completed in ${searchTime}ms, found ${conversations.length} conversations`);
+
+    // Process conversations for response
+    const processedConversations = conversations.map(conv => {
+      if (!conv || !conv.latestMessage) {
+        return {
+          phoneNumber: conv?._id || 'unknown',
+          name: 'Unknown',
+          lastMessage: '',
+          lastMessageTime: new Date(),
+          messageCount: 0,
+          unreadCount: 0,
+          isLastMessageMedia: false,
+          lastMessageType: null,
+          lastMessageFromMe: false
+        };
+      }
+
+      const isMedia = conv.latestMessage.is_media === true;
+      let mediaType = null;
+
+      if (isMedia && conv?.latestMessage?.media) {
+        if (conv.latestMessage.media.mediaType) {
+          mediaType = conv.latestMessage.media.mediaType;
+        } else if (conv.latestMessage.media.contentType) {
+          const contentType = conv.latestMessage.media.contentType;
+          const contentTypeParts = contentType?.split('/') || ['unknown'];
+          mediaType = contentTypeParts[0] || 'unknown';
+
+          if (mediaType === 'application') {
+            mediaType = 'document';
+          } else if (contentTypeParts[1] === 'webp') {
+            mediaType = 'sticker';
+          }
+        }
+      }
+
+      return {
+        phoneNumber: conv._id,
+        name: conv?.latestMessage?.nombre_whatsapp || 'Unknown',
+        lastMessage: conv?.latestMessage?.body || '',
+        lastMessageTime: conv?.latestMessage?.createdAt || conv?.latestMessage?.timestamp || new Date(),
+        messageCount: conv.messageCount || 0,
+        unreadCount: 0,
+        isLastMessageMedia: isMedia || false,
+        lastMessageType: mediaType || null,
+        lastMessageFromMe: conv?.latestMessage?.from_me || false
+      };
+    });
+
+    res.status(200).json({
+      success: true,
+      conversations: processedConversations,
+      searchInfo: {
+        query,
+        results: processedConversations.length,
+        searchTime
+      }
+    });
+
+  } catch (error) {
+    console.error('Error searching conversations:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to search conversations'
+    });
+  }
+};
+
+const getConversationsByNameController = async (req, res) => {
+  try {
+    const conversations = await Message.aggregate([
+      { $match: { from_me: false, is_group: false } },
+      { $sort: { timestamp: -1 } },
+      { $group: {
+        _id: '$numero',
+        name: { $first: '$nombre_whatsapp' },
+        latestMessage: { $first: '$$ROOT' },
+        messageCount: { $sum: 1 }
+      }},
+      { $sort: { 'latestMessage.timestamp': -1 } }
+    ]);
+        
+    res.status(200).json({
+      success: true,
+      conversations: conversations.map(conv => ({
+        phoneNumber: conv._id,
+        name: conv.name,
+        lastMessage: conv.latestMessage.body,
+        lastMessageTime: conv.latestMessage.timestamp,
+        messageCount: conv.messageCount
+      }))
+    });
+  } catch (error) {
+    console.error('Error fetching conversations by name:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch conversations by name'
+    });
+  }
+};
+
+const getNewMessagesController = async (req, res) => {
+  try {
+    const { phoneNumber } = req.params;
+    const { after, limit = 20 } = req.query;
+        
+    if (!after) {
+      return res.status(400).json({
+        success: false,
+        error: 'The after parameter is required'
+      });
+    }
+        
+    const lastMessage = await Message.findById(after).lean();
+        
+    if (!lastMessage) {
+      return res.status(404).json({
+        success: false,
+        error: 'Reference message not found'
+      });
+    }
+        
+    const query = { 
+      numero: phoneNumber, 
+      is_group: false,
+      createdAt: { $gt: lastMessage.createdAt }
+    };
+        
+    const messages = await Message.find(query)
+      .sort({ createdAt: 1 })
+      .limit(parseInt(limit))
+      .lean();
+        
+    res.status(200).json({
+      success: true,
+      phoneNumber,
+      messages: messages
+    });
+  } catch (error) {
+    console.error(`Error fetching new messages for ${req.params.phoneNumber}:`, error);
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch new messages'
+    });
+  }
+};
+
+const markMessagesAsReadController = async (req, res) => {
+  console.log('Starting markMessagesAsReadController at', new Date().toISOString());
+  try {
+    const { phoneNumber } = req.params;
+        
+    if (!phoneNumber) {
+      return res.status(400).json({
+        success: false,
+        error: 'Phone number is required'
+      });
+    }
+        
+    console.log('Marking messages as read for phone number:', phoneNumber);
+    const result = await Message.updateMany(
+      { 
+        numero: phoneNumber, 
+        from_me: false, 
+        $or: [
+          { read: false },
+          { read: { $exists: false } }
+        ]
+      },
+      { $set: { read: true } }
+    );
+        
+    res.status(200).json({
+      success: true,
+      message: `${result.nModified || result.modifiedCount} messages marked as read`,
+      modifiedCount: result.nModified || result.modifiedCount
+    });
+  } catch (error) {
+    console.error(`Error marking messages as read for ${req.params?.phoneNumber || 'unknown'}:`, error);
+    console.error('Error stack:', error.stack);
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to mark messages as read'
+    });
+  }
+};
+
+const sendTemplateToNewNumberController = async (req, res) => {
+  console.log('Starting sendTemplateToNewNumberController at', new Date().toISOString());
+  try {
+    const { phoneNumber, templateId, variables } = req.body;
+    
+    if (!phoneNumber) {
+      return res.status(400).json({
+        success: false,
+        error: 'Phone number is required'
+      });
+    }
+
+    if (!templateId) {
+      return res.status(400).json({
+        success: false,
+        error: 'Template ID is required'
+      });
+    }
+
+    // Format phone number for WhatsApp if needed
+    const formattedPhoneNumber = phoneNumber.startsWith('whatsapp:') 
+      ? phoneNumber 
+      : `whatsapp:${phoneNumber}`;
+    
+    // Log template details for debugging
+    console.log('Sending template to new number with details:', { 
+      phoneNumber: formattedPhoneNumber,
+      templateId,
+      hasVariables: variables && Object.keys(variables).length > 0,
+      variableKeys: variables ? Object.keys(variables) : []  
+    });
+    
+    const messageData = {
+      code: formattedPhoneNumber,
+      contentSid: templateId
+    };
+    
+    if (variables && Object.keys(variables).length > 0) {
+      messageData.variables = variables;
+      console.log('Template variables:', JSON.stringify(variables));
+    }
+    
+    const message = await sendMessage(messageData);
+
+    res.status(200).json({
+      success: true,
+      message: 'Template sent successfully',
+      messageId: message.sid
+    });
+  } catch (error) {
+    console.error('Error sending template to new number:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to send template to new number'
+    });
+  }
+};
+
+module.exports = {
+  getConversationController,
+  getConversationMessagesController,
+  getConversationReplyController,
+  getConversationsByNameController,
+  getNewMessagesController,
+  markMessagesAsReadController,
+  searchConversationsController,
+  sendTemplateToNewNumberController
+};

package/lib/controllers/mediaController.js

@@ -0,0 +1,105 @@
+// Optional AWS config - will be undefined if not available
+let downloadFileFromS3, s3;
+try {
+  downloadFileFromS3 = require('../config/awsConfig')?.downloadFileFromS3;
+  s3 = require('../config/awsConfig')?.s3;
+} catch (e) {
+  // AWS config not available
+}
+const bucketName = process.env.AWS_S3_BUCKET_NAME;
+
+
+const getMediaController = async (req, res) => {
+  try {
+    const { key } = req.params;
+        
+    console.log(`[MediaController] Received request for media file with key: ${key}`);
+    console.log(`[MediaController] Original URL path: ${req.originalUrl}`);
+        
+    if (!key || key.trim() === '') {
+      console.error('[MediaController] Invalid key provided:', key);
+      return res.status(400).json({
+        success: false,
+        error: 'Invalid media key provided'
+      });
+    }
+        
+    let mediaKey = key;
+        
+    console.log(`[MediaController] Final S3 key to fetch: ${mediaKey}`);
+        
+    const fileData = await downloadFileFromS3(bucketName, mediaKey);
+        
+    if (!fileData || !fileData.Body) {
+      console.error(`[MediaController] Media not found in S3: ${key}`);
+            
+      try {
+        const prefix = key.split('/')[0];
+        console.log(`[MediaController] Checking S3 for objects with prefix: ${prefix}/`);
+                
+        s3.listObjectsV2({
+          Bucket: bucketName,
+          Prefix: prefix + '/',
+          MaxKeys: 10
+        }).promise()
+          .then(listData => {
+            if (listData.Contents && listData.Contents.length > 0) {
+              console.log(`[MediaController] Found ${listData.Contents.length} objects with similar prefix:`);
+              listData.Contents.forEach(item => {
+                console.log(`[MediaController] - ${item.Key} (${item.Size} bytes)`);
+                if (item.Key.includes(key.split('/').pop().substring(0, 10))) {
+                  console.log(`[MediaController] !!! POTENTIAL MATCH: ${item.Key}`);
+                }
+              });
+            } else {
+              console.log(`[MediaController] No objects found with prefix: ${prefix}/`);
+            }
+          })
+          .catch(listErr => {
+            console.error(`[MediaController] Error listing objects: ${listErr.message}`);
+          });
+      } catch (listErr) {
+        console.error(`[MediaController] Error setting up bucket listing: ${listErr.message}`);
+      }
+            
+      return res.status(404).json({
+        success: false,
+        error: 'Media not found in S3',
+        key: key,
+        bucket: bucketName,
+        timestamp: new Date().toISOString()
+      });
+    }
+        
+    let contentType = fileData.ContentType || 'application/octet-stream';
+        
+    if (contentType === 'application/octet-stream') {
+      const fileExtension = key.split('.').pop().toLowerCase();
+            
+      if (['jpg', 'jpeg', 'png', 'webp'].includes(fileExtension)) {
+        contentType = `image/${fileExtension === 'jpg' ? 'jpeg' : fileExtension}`;
+      } else if (fileExtension === 'pdf') {
+        contentType = 'application/pdf';
+      } else if (['mp3', 'wav', 'ogg', 'm4a'].includes(fileExtension)) {
+        contentType = `audio/${fileExtension}`;
+      } else if (['mp4', 'webm', '3gp'].includes(fileExtension)) {
+        contentType = `video/${fileExtension}`;
+      }
+    }
+        
+    res.setHeader('Cache-Control', 'public, max-age=86400');
+    res.setHeader('Content-Type', contentType);
+        
+    res.send(fileData.Body);
+  } catch (error) {
+    console.error('Error serving media:', error);
+    res.status(500).json({
+      success: false,
+      error: 'Failed to retrieve media'
+    });
+  }
+};
+
+module.exports = {
+  getMediaController
+};