@peopl-health/nexus 1.1.5 → 1.1.7

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
+};

package/lib/models/templateModel.js

@@ -0,0 +1,72 @@
+const mongoose = require('mongoose');
+
+const TemplateSchema = new mongoose.Schema({
+  sid: {
+    type: String,
+    required: true,
+    unique: true
+  },
+  name: {
+    type: String,
+    required: true
+  },
+  friendlyName: String,
+  category: {
+    type: String,
+    default: 'UTILITY',
+    enum: ['UTILITY', 'MARKETING', 'AUTHENTICATION']
+  },
+  language: {
+    type: String,
+    default: 'es'
+  },
+  status: {
+    type: String,
+    default: 'DRAFT',
+    enum: ['DRAFT', 'PENDING', 'APPROVED', 'REJECTED', 'UNKNOWN']
+  },
+  body: String,
+  footer: String,
+  variables: [
+    {
+      name: String,
+      description: String,
+      example: String
+    }
+  ],
+  buttons: [
+    {
+      type: {
+        type: String,
+        enum: ['quick_reply', 'url']
+      },
+      text: String,
+      url: String
+    }
+  ],
+  approvalRequest: {
+    sid: String,
+    status: String,
+    dateSubmitted: Date,
+    dateUpdated: Date,
+    rejectionReason: String
+  },
+  dateCreated: {
+    type: Date,
+    default: Date.now
+  },
+  lastUpdated: {
+    type: Date,
+    default: Date.now
+  }
+});
+
+// Pre-save middleware to update lastUpdated
+TemplateSchema.pre('save', function(next) {
+  this.lastUpdated = new Date();
+  next();
+});
+
+const Template = mongoose.model('Template', TemplateSchema);
+
+module.exports = Template;

package/lib/routes/index.js

@@ -70,6 +70,8 @@ const conversationController = require('../controllers/conversationController');
 const mediaController = require('../controllers/mediaController');
 const messageController = require('../controllers/messageController');
 const templateController = require('../controllers/templateController');
+const templateFlowController = require('../controllers/templateFlowController');
+const uploadController = require('../controllers/uploadController');
 
 // Built-in controllers mapping
 const builtInControllers = {
@@ -95,7 +97,7 @@ const builtInControllers = {
   
   // Media controllers
   getMediaController: mediaController.getMediaController,
-  handleFileUpload: mediaController.handleFileUpload,
+  handleFileUpload: uploadController.handleFileUpload,
   
   // Message controllers
   sendMessageController: messageController.sendMessageController,
@@ -108,8 +110,8 @@ const builtInControllers = {
   getPredefinedTemplates: templateController.getPredefinedTemplates,
   getTemplate: templateController.getTemplate,
   getCompleteTemplate: templateController.getCompleteTemplate,
-  createFlow: templateController.createFlow,
-  deleteFlow: templateController.deleteFlow,
+  createFlow: templateFlowController.createFlow,
+  deleteFlow: templateFlowController.deleteFlow,
   submitForApproval: templateController.submitForApproval,
   checkApprovalStatus: templateController.checkApprovalStatus,
   deleteTemplate: templateController.deleteTemplate