@peopl-health/nexus 1.1.4 → 1.1.6

package/lib/helpers/filesHelper.js

@@ -0,0 +1,134 @@
+const { PDFDocument } = require('pdf-lib');
+const { exec } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const sharp = require('sharp');
+
+
+async function convertPdfToImages(pdfName) {
+  const outputDir = path.join(__dirname, 'assets', 'tmp');
+  const pdfPath = `${outputDir}/${pdfName}.pdf`;
+
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  return new Promise((resolve, reject) => {
+    const command = `pdftoppm -jpeg ${pdfPath} ${outputDir}/${pdfName}`;
+    console.log(command);
+    exec(command, (error, stdout, stderr) => {
+      if (error) {
+        return reject(`Error splitting PDF: ${stderr}`);
+      }
+
+      fs.readdir(outputDir, (err, files) => {
+        if (err) {
+          return reject(`Error reading output directory: ${err.message}`);
+        }
+
+        const pngFiles = files
+          .filter(file => file.startsWith(pdfName) && file.endsWith('.jpg'))
+          .map(file => path.join(outputDir, file));
+
+        resolve(pngFiles);
+      });
+    });
+  });
+}
+
+async function combineImagesToPDF(config) {
+  const { 
+    code, 
+    extensions = ['jpg', 'jpeg', 'png', 'tiff'], 
+    sortNumerically = true 
+  } = config;
+  
+  // Get all files in the directory
+  const inputDir = path.join(__dirname, 'assets', 'tmp');
+  const files = await fs.promises.readdir(inputDir);
+    
+  // Filter for image files with the specified extensions
+  const imageFiles = files.filter(file => {
+    const ext = path.extname(file).toLowerCase().substring(1);
+    const hasValidExtension = extensions.includes(ext);
+    const hasPrefix = code ? file.startsWith(code) : true;
+    return hasValidExtension && hasPrefix;
+  });
+  
+  // Sort files
+  if (sortNumerically) {
+    imageFiles.sort((a, b) => {
+      const aMatch = a.match(/\d+/g);
+      const bMatch = b.match(/\d+/g);
+            
+      if (!aMatch || !bMatch) return a.localeCompare(b);
+            
+      return parseInt(aMatch[0]) - parseInt(bMatch[0]);
+    });
+  } else {
+    imageFiles.sort();
+  }
+  
+  console.log(`Found ${imageFiles.length} image files to combine`);
+    
+  // Create a new PDF document
+  const pdfDoc = await PDFDocument.create();
+  const processedFiles = [];
+    
+  // Process each image file
+  for (const [index, file] of imageFiles.entries()) {
+    try {
+      const filePath = path.join(inputDir, file);
+      console.log(`Processing file ${index + 1}/${imageFiles.length}: ${file}`);
+            
+      const imageBuffer = await fs.promises.readFile(filePath);
+      const pngBuffer = await sharp(imageBuffer)
+        .toFormat('png')
+        .toBuffer();
+            
+      const { width, height } = await sharp(imageBuffer).metadata();
+      const img = await pdfDoc.embedPng(pngBuffer);
+      const page = pdfDoc.addPage([width, height]);
+            
+      // Draw the image on the page
+      page.drawImage(img, {
+        x: 0,
+        y: 0,
+        width: width,
+        height: height,
+      });
+
+      processedFiles.push(filePath);
+    } catch (error) {
+      console.error(`Error processing file ${file}:`, error);
+    }
+  }
+    
+  console.log('Combined PDF created successfully');
+    
+  return {
+    pdfBuffer: await pdfDoc.save(),
+    processedFiles
+  };
+}
+
+function cleanupFiles(files) {
+  files.forEach(file => {
+    if (fs.existsSync(file)) {
+      try {
+        fs.unlinkSync(file);
+        console.log(`Deleted: ${file}`);
+      } catch (error) {
+        console.error(`Error deleting ${file}:`, error);
+      }
+    } else {
+      console.warn(`File not found: ${file}`);
+    }
+  });
+}
+
+module.exports = {
+  convertPdfToImages,
+  combineImagesToPDF,
+  cleanupFiles
+};

package/lib/helpers/llmsHelper.js

@@ -0,0 +1,202 @@
+const { anthropicClient } = require('../config/llmConfig.js');
+const fs = require('fs');
+const mime = require('mime-types');
+
+
+async function analyzeImage(imagePath) {
+  try {
+    // Skip WBMP images and stickers
+    if (imagePath.toLowerCase().includes('.wbmp') || imagePath.toLowerCase().includes('sticker')) {
+      console.log('Skipping WBMP image or sticker analysis:', imagePath);
+      return {
+        medical_analysis: 'NOT_MEDICAL',
+        medical_relevance: false,
+        has_table: false,
+        table_data: null
+      };
+    }
+    
+    // Check MIME type
+    const mimeType = mime.lookup(imagePath) || 'image/jpeg';
+    if (mimeType === 'image/vnd.wap.wbmp' || mimeType.includes('sticker')) {
+      console.log('Skipping image with MIME type:', mimeType);
+      return {
+        medical_analysis: 'NOT_MEDICAL',
+        medical_relevance: false,
+        has_table: false,
+        table_data: null
+      };
+    }
+    // Read the image file and convert to base64
+    const imageBuffer = await fs.promises.readFile(imagePath);
+    const base64Image = imageBuffer.toString('base64');
+
+    // Create a more specific prompt for table detection and extraction
+    const tablePrompt = `Please analyze this image and respond in the following format:
+1. First, determine if there is a table in the image.
+2. If there is NO table, respond with exactly "NONE"
+3. If there IS a table:
+   - Extract all content from the table
+   - Format it as a markdown table
+   - Include all headers and data
+   - Preserve the exact text and numbers as shown
+   - Maintain the original column order
+   - Pay special attention to how values align vertically with test names in the original document
+   - Double-check each value's vertical alignment with its corresponding test name before entering it in the table
+   - Include all units and reference ranges exactly as written
+   - Double-check each value-to-test pairing before including it
+   - Do not summarize or modify the data
+
+Only extract tables - ignore any other content in the image.`;
+
+    // Create the message with the image
+    const messageTable = await anthropicClient.messages.create({
+      model: 'claude-3-7-sonnet-20250219',
+      max_tokens: 1024,
+      messages: [
+        {
+          role: 'user',
+          content: [
+            {
+              type: 'image',
+              source: {
+                type: 'base64',
+                media_type: mime.lookup(imagePath) || 'image/jpeg',
+                data: base64Image,
+              },
+            },
+            {
+              type: 'text',
+              text: tablePrompt,
+            },
+          ],
+        },
+      ],
+    });
+
+    // Create a more specific prompt for table detection and extraction
+    const medImagePrompt = `
+Eres un oncólogo clínico con experiencia. Se te proporcionará una imagen médica o laboratorio. Analízala y responde exactamente en este formato:
+
+1. Image Type:
+   - Especifica tipo de imagen médico (ej. X‑ray, CT, MRI, ecografía, biopsia digital, resultados de laboratorio, etc.) o "NOT_MEDICAL" si no es médica.
+   - Calidad de la imagen: clear / unclear / incomplete.
+
+2. Clinical Analysis:
+   - Hallazgos clave y anomalías.
+   - Estructuras normales significativas presentes.
+   - Medidas críticas (diámetros, densidades, volúmenes), si aplican.
+
+3. Action Items:
+   - Pruebas o vistas adicionales recomendadas.
+   - Limitaciones clave de la evaluación actual.
+
+Si la imagen no permite ningún análisis útil, responde solo con: QUALITY_INSUFFICIENT.
+
+---
+
+<OUTPUT_FORMAT>
+1. Image Type:
+- ...
+2. Clinical Analysis:
+- ...
+3. Action Items:
+- ...
+</OUTPUT_FORMAT>
+
+<EJEMPLOS>
+Ejemplo 1:
+(Descripción breve si compartieras una RX de tórax)
+1. Image Type:
+- X‑ray de tórax PA, clear
+2. Clinical Analysis:
+- Líneas pleurales visibles, silueta cardíaca normal…
+3. Action Items:
+- Sugiero proyección lateral para valorar consolidación…
+</EJEMPLOS>
+`;
+
+    // Create the message with the image
+    const messageMedImage = await anthropicClient.messages.create({
+      model: 'claude-3-7-sonnet-20250219',
+      max_tokens: 1024,
+      messages: [
+        {
+          role: 'user',
+          content: [
+            {
+              type: 'image',
+              source: {
+                type: 'base64',
+                media_type: mime.lookup(imagePath) || 'image/jpeg',
+                data: base64Image,
+              },
+            },
+            {
+              type: 'text',
+              text: medImagePrompt,
+            },
+          ],
+        },
+      ],
+    });
+
+    const relevancePrompt = `Please analyze this image and respond in this format: 
+        Medical Relevance: [YES/NO]`;
+
+    // Create the message with the image
+    const messageRelevance = await anthropicClient.messages.create({
+      model: 'claude-3-7-sonnet-20250219',
+      max_tokens: 1024,
+      messages: [
+        {
+          role: 'user',
+          content: [
+            {
+              type: 'image',
+              source: {
+                type: 'base64',
+                media_type: mime.lookup(imagePath) || 'image/jpeg',
+                data: base64Image,
+              },
+            },
+            {
+              type: 'text',
+              text: relevancePrompt,
+            },
+          ],
+        },
+      ],
+    });
+
+    const messageTableStr = messageTable.content[0].text;
+    const messageRelevanceStr = messageRelevance.content[0].text;
+    const messageAnalysisStr = messageMedImage.content[0].text;
+    const table = (messageTableStr.trim() === 'NONE') ? null : messageTableStr.trim();
+    const isTable = (table === null) ? false : true;
+    const isRelevant = (messageRelevanceStr.includes('YES')) ? true : false;
+
+    return {medical_analysis: messageAnalysisStr, medical_relevance: isRelevant, 
+      has_table: isTable, table_data: table};
+  } catch (error) {
+    console.error('Error analyzing image:', error);
+    throw error;
+  }
+}
+
+/**
+ * Helper to build prompts by replacing context data in template files
+ * @param {Object} conversationContext - Context object to inject into prompt
+ * @param {string} promptPath - Path to the prompt template file
+ * @returns {string} Formatted prompt with context data injected
+ */
+const buildPrompt = (conversationContext, promptPath) => {
+  const promptTemplate = fs.readFileSync(promptPath, 'utf8');
+  
+  return promptTemplate.replace('{{CONVERSATION_DATA}}', JSON.stringify(conversationContext, null, 2));
+};
+
+module.exports = {
+  analyzeImage,
+  buildPrompt
+};

package/lib/helpers/mediaHelper.js

@@ -0,0 +1,72 @@
+const AWS = require('../config/awsConfig.js');
+const path = require('path');
+const fs = require('fs');
+
+async function uploadMediaToS3(buffer, messageID, titleFile, bucketName, contentType, messageType) {
+  const extension = getFileExtension(contentType);
+  const sanitizedTitle = titleFile ? sanitizeFileName(titleFile) : '';
+  const fileName = sanitizedTitle 
+    ? `${messageType}/${messageID}_${sanitizedTitle}.${extension}`
+    : `${messageType}/${messageID}.${extension}`;
+  console.log(titleFile, messageType);
+    
+  try {
+    await AWS.uploadBufferToS3(buffer, bucketName, fileName, contentType);
+    return fileName;
+  } catch (error) {
+    console.error('Failed to upload media to S3:', error.stack);
+    throw error;
+  }
+}
+
+async function saveMediaToLocal(mediaBuffer, messageId, contentType) {
+  const uploadDir = path.join(__dirname, '../uploads');
+    
+  if (!fs.existsSync(uploadDir)) {
+    fs.mkdirSync(uploadDir, { recursive: true });
+  }
+    
+  const fileExt = getFileExtension(contentType);
+  const filePath = path.join(uploadDir, `${messageId}.${fileExt}`);
+    
+  return new Promise((resolve, reject) => {
+    fs.writeFile(filePath, mediaBuffer, (err) => {
+      if (err) reject(err);
+      else resolve(filePath);
+    });
+  });
+}
+
+function getFileExtension(contentType) {
+  const mimeToExt = {
+    'image/jpeg': 'jpg',
+    'image/png': 'png',
+    'image/gif': 'gif',
+    'image/webp': 'webp',
+    'audio/mp4': 'm4a',
+    'audio/mpeg': 'mp3',
+    'audio/ogg': 'ogg',
+    'video/mp4': 'mp4',
+    'video/3gpp': '3gp',
+    'application/pdf': 'pdf',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation': 'pptx',
+    'text/plain': 'txt'
+  };
+    
+  return mimeToExt[contentType] || 'bin';
+}
+
+function sanitizeFileName(fileName) {
+  return fileName
+    .replace(/[^a-zA-Z0-9_-]/g, '')
+    .slice(0, 50);
+}
+
+module.exports = {
+  uploadMediaToS3,
+  saveMediaToLocal,
+  getFileExtension,
+  sanitizeFileName
+};

package/lib/helpers/mongoHelper.js

@@ -0,0 +1,45 @@
+/**
+ * Helper to convert date strings to Date objects in MongoDB filters
+ * @param {Object} filter - Filter that may contain date strings
+ * @returns {Object} Filter with dates converted to Date objects
+ */
+const convertDateStringsInFilter = (filter) => {
+  if (!filter || typeof filter !== 'object') {
+    return filter;
+  }
+
+  const convertedFilter = { ...filter };
+
+  // Recursive function to convert dates
+  const convertDates = (obj) => {
+    for (const key in obj) {
+      if (typeof obj[key] === 'object' && obj[key] !== null) {
+        if (obj[key].$gte || obj[key].$gt || obj[key].$lte || obj[key].$lt) {
+          // Convert date comparison operators
+          if (obj[key].$gte && typeof obj[key].$gte === 'string') {
+            obj[key].$gte = new Date(obj[key].$gte);
+          }
+          if (obj[key].$gt && typeof obj[key].$gt === 'string') {
+            obj[key].$gt = new Date(obj[key].$gt);
+          }
+          if (obj[key].$lte && typeof obj[key].$lte === 'string') {
+            obj[key].$lte = new Date(obj[key].$lte);
+          }
+          if (obj[key].$lt && typeof obj[key].$lt === 'string') {
+            obj[key].$lt = new Date(obj[key].$lt);
+          }
+        } else {
+          // Recursion for nested objects
+          convertDates(obj[key]);
+        }
+      }
+    }
+  };
+
+  convertDates(convertedFilter);
+  return convertedFilter;
+};
+
+module.exports = {
+  convertDateStringsInFilter
+}; 

package/lib/helpers/qrHelper.js

@@ -0,0 +1,22 @@
+const qrcode = require('qrcode');
+
+
+async function generateQRBuffer(text) {
+  try {
+    const qrBuffer = await qrcode.toBuffer(text, { type: 'image/png' });
+    return qrBuffer;
+  } catch (err) {
+    console.error('Error generating QR code:', err.stack);
+    throw err;
+  }
+}
+
+function bufferToBase64(buffer) {
+  return buffer.toString('base64');
+}
+
+
+module.exports = {
+  generateQRBuffer,
+  bufferToBase64
+};

package/lib/helpers/twilioHelper.js

@@ -0,0 +1,138 @@
+const { LegacyMessage } = require('../models/messageModel');
+
+const axios = require('axios');
+const { v4: uuidv4 } = require('uuid');
+
+
+function convertTwilioToInternalFormat(twilioMessage) {
+  const from = twilioMessage.From || '';
+  const to = twilioMessage.To || '';
+  const fromMe = to === from;
+    
+  return {
+    key: {
+      id: twilioMessage.MessageSid || uuidv4(),
+      fromMe: fromMe,
+      remoteJid: fromMe ? to : from
+    },
+    pushName: twilioMessage.ProfileName || '',
+    message: {
+      conversation: twilioMessage.Body || ''
+    },
+    messageTimestamp: Math.floor(Date.now() / 1000)
+  };
+}
+
+
+async function downloadMediaFromTwilio(mediaUrl, logger) {
+  try {
+    logger.info(`Downloading media from: ${mediaUrl}`);
+        
+    const response = await axios({
+      method: 'GET',
+      url: mediaUrl,
+      responseType: 'arraybuffer',
+      headers: {
+        'Authorization': `Basic ${Buffer.from(
+          `${process.env.TWILIO_ACCOUNT_SID}:${process.env.TWILIO_AUTH_TOKEN}`
+        ).toString('base64')}`
+      }
+    });
+        
+    return Buffer.from(response.data);
+  } catch (error) {
+    logger.error(`Failed to download media: ${error.message}`);
+    throw error;
+  }
+}
+
+
+function getMediaTypeFromContentType(contentType) {
+  if (contentType.startsWith('image/')) return 'imageMessage';
+  if (contentType.startsWith('audio/')) return 'audioMessage';
+  if (contentType.startsWith('video/')) return 'videoMessage';
+  if (contentType.startsWith('application/')) return 'documentMessage';
+  return 'unknownMessage';
+}
+
+
+function extractTitle(message, mediaType) {
+  if (mediaType === 'documentMessage' && message.MediaUrl0) {
+    const urlParts = message.MediaUrl0.split('/');
+    return urlParts[urlParts.length - 1] || null;
+  }
+  return null;
+}
+
+
+async function isRecentMessage(chatId) {
+  const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
+
+  const recentMessage = await LegacyMessage.find({
+    $or: [{ group_id: chatId }, { numero: chatId }],
+    timestamp: { $gte: fiveMinutesAgo.toISOString() }
+  }).sort({ timestamp: -1 }).limit(1);
+
+  return !!recentMessage;
+}
+
+
+async function getLastMessages(chatId, n) {
+  const messages = await LegacyMessage.find({ numero: chatId })
+    .sort({ timestamp: -1 })
+    .limit(n)
+    .select('timestamp numero nombre_whatsapp body');
+
+  return messages.map(msg => `[${msg.timestamp}] ${msg.body}`);
+}
+
+
+async function downloadMedia(twilioMessage, logger) {
+  try {
+    const mediaUrl = twilioMessage.MediaUrl0;
+    if (!mediaUrl) {
+      throw new Error('No media URL provided');
+    }
+
+    logger.info(`Downloading media from: ${mediaUrl}`);
+        
+    const response = await axios({
+      method: 'GET',
+      url: mediaUrl,
+      responseType: 'arraybuffer',
+      headers: {
+        'Authorization': `Basic ${Buffer.from(
+          `${process.env.TWILIO_ACCOUNT_SID}:${process.env.TWILIO_AUTH_TOKEN}`
+        ).toString('base64')}`
+      }
+    });
+        
+    return Buffer.from(response.data);
+  } catch (error) {
+    logger.error(`Error downloading media: ${error.message}`);
+    throw error;
+  }
+}
+
+
+const ensureWhatsAppFormat = (phoneNumber) => {
+  if (!phoneNumber) return null;
+    
+  if (phoneNumber.startsWith('whatsapp:')) {
+    return phoneNumber;
+  }
+    
+  return `whatsapp:${phoneNumber}`;
+};
+
+
+module.exports = {
+  convertTwilioToInternalFormat,
+  downloadMediaFromTwilio,
+  getMediaTypeFromContentType,
+  extractTitle,
+  isRecentMessage,
+  getLastMessages,
+  downloadMedia,
+  ensureWhatsAppFormat
+};

package/lib/helpers/whatsappHelper.js

@@ -0,0 +1,75 @@
+const moment = require('moment-timezone');
+
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+
+function formatCode(codeBase) {
+  console.log(`formatCode ${codeBase}`);
+
+  const [number, domain] = codeBase.split('@');
+    
+  if (!number || !domain) {
+    throw new Error('Invalid code format: missing number or domain');
+  }
+
+  if (domain !== 's.whatsapp.net') {
+    throw new Error('Invalid domain: must be s.whatsapp.net');
+  }
+
+  let formattedNumber = number;
+
+  if (formattedNumber.endsWith('-2')) {
+    formattedNumber = formattedNumber.slice(0, -2);
+  }
+
+  if (formattedNumber.length === 10) {
+    formattedNumber = '52' + formattedNumber;
+  }
+
+  if (formattedNumber.startsWith('52') && formattedNumber.length === 12) {
+    formattedNumber = formattedNumber.substring(0, 2) + '1' + formattedNumber.substring(2);
+  }
+  return `${formattedNumber}@s.whatsapp.net`;
+}
+
+
+function calculateDelay(sendTime, timeZone) {
+  if (sendTime !== undefined && timeZone !== undefined) {
+    const sendMoment = moment.tz(sendTime, timeZone);
+
+    if (!sendMoment.isValid()) {
+      return { error: 'Invalid time format' };
+    }
+
+    // Get the current time and calculate the difference
+    const now = moment().tz(timeZone);
+    const randomDelay = Math.floor(Math.random() * 15001) + 15000;
+    const delay = sendMoment.diff(now) + randomDelay;
+
+    // Log the calculated details for debugging
+    console.log(
+      'Scheduled Time:', sendMoment.format(), 
+      'Current Time:', now.format(), 
+      'Delay (minutes):', delay / 60000, 
+      'Remaining Seconds:', delay % 60000
+    );
+
+    if (delay <= 0) {
+      return 2500;
+    }
+
+    return delay;
+  } else {
+    return 2500;
+  }
+}
+
+
+module.exports = {
+  delay,
+  formatCode,
+  calculateDelay
+};