@peopl-health/nexus 1.1.1 → 1.1.4

package/lib/services/airtableService.js

@@ -0,0 +1,82 @@
+const { airtable } = require('../config/airtableConfig');
+
+
+async function addRecord(baseID, tableName, fields) {
+  try {
+    const base = airtable.base(baseID);
+    const record = await base(tableName).create(fields);
+    console.log('Record added at', tableName);
+    return record;
+  } catch (error) {
+    console.error('Error adding record:', error);
+    throw error; 
+  }
+}
+
+
+async function getRecords(baseID, tableName) {
+  try {
+    const records = [];
+    const base = airtable.base(baseID);
+    await base(tableName).select({
+      maxRecords: 3
+    }).eachPage((pageRecords, fetchNextPage) => {
+      pageRecords.forEach(record => {
+        records.push(record.fields);
+      });
+      fetchNextPage();
+    });
+    return records;
+  } catch (error) {
+    console.error('Error fetching records:', error);
+  }
+}
+
+
+async function getRecordByFilter(baseID, tableName, filter, view = 'Grid view') {
+  try {
+    const records = [];
+    const base = airtable.base(baseID);
+    await base(tableName).select({
+      filterByFormula: `${filter}`,
+      view: view
+    }).eachPage((pageRecords, fetchNextPage) => {
+      pageRecords.forEach(record => {
+        records.push(record.fields);
+      });
+      fetchNextPage();
+    });
+    return records;
+  } catch (error) {
+    console.error(`Error fetching records by ${filter}:`, error);
+  }
+}
+
+
+async function updateRecordByFilter(baseID, tableName, filter, updateFields) {
+  try {
+    const base = airtable.base(baseID);
+    const updatedRecords = [];
+        
+    await base(tableName).select({
+      filterByFormula: `${filter}`
+    }).eachPage(async (pageRecords, fetchNextPage) => {
+      for (const record of pageRecords) {
+        const updatedRecord = await base(tableName).update(record.id, updateFields);
+        updatedRecords.push(updatedRecord);
+      }
+      fetchNextPage();
+    });
+        
+    return updatedRecords;
+  } catch (error) {
+    console.error(`Error updating records by ${filter}:`, error);
+  }
+}
+
+module.exports = {
+  addRecord,
+  getRecords,
+  getRecordByFilter,
+  updateRecordByFilter
+};

package/lib/services/appointmentService.js

@@ -0,0 +1,55 @@
+const { Calendar_ID } = require('../config/airtableConfig.js');
+
+const { ISO_DATE, parseStartTime, addDays } = require('../utils/dateUtils.js');
+const { dateAndTimeFromStart } = require('../utils/dateUtils.js');
+
+const { getRecordByFilter, updateRecordByFilter } = require('../services/airtableService.js');
+
+
+const getNextAppointmentForPatient = async (name, after = new Date()) => {
+  const filter = `AND(patient_name = "${name}", start_time >= '${ISO_DATE(after)}')`;
+  const rows   = await getRecordByFilter(Calendar_ID, 'calendar_quimio', filter);
+  if (!rows?.length) return null;
+  return rows.sort((a, b) => new Date(a.start_time) - new Date(b.start_time))[0];
+};
+
+const getAppointmentsBetween = async (start, end) => {
+  const filter = `AND(start_time >= '${ISO_DATE(start)}', start_time < '${ISO_DATE(end)}')`;
+  return getRecordByFilter(Calendar_ID, 'calendar_quimio', filter);
+};
+
+const updateAppointmentById = async (recordId, data) => {
+  return updateRecordByFilter(
+    Calendar_ID,
+    'calendar_quimio',
+    `REGEX_MATCH({record_id}, '${recordId}')`,
+    data
+  );
+};
+
+const buildAvailabilityWindow = async originalDate => {
+  const start = addDays(originalDate, 1);
+  const end = addDays(originalDate, 7);
+  
+  const allSlots = await getAppointmentsBetween(start, addDays(end, 1));
+  const availableSlots = allSlots.filter(row => !row.patient);
+  
+  const result = {};
+  availableSlots.forEach(row => {
+    const { date, time } = dateAndTimeFromStart(row.start_time);
+    if (!result[date]) result[date] = [];
+    result[date].push({ time, availableSpots: 1 });
+  });
+  
+  return result;
+};
+
+const parseStart = parseStartTime;
+
+module.exports = {
+  getNextAppointmentForPatient,
+  getAppointmentsBetween,
+  updateAppointmentById,
+  parseStart,
+  buildAvailabilityWindow
+};

package/lib/services/assistantService.js

@@ -0,0 +1,296 @@
+const { Historial_Clinico_ID } = require('../config/airtableConfig.js');
+const { SALES_ASST, QUMIO_REMINDERS_ASST, DOCTOR_SCHEDULE_ASST, PATIENT_SCHEDULE_ASST } = require('../config/assistantConfig.js');
+const { openaiClient } = require('../config/llmConfig.js');
+
+const { Message, formatTimestamp } = require('../models/messageModel.js');
+const { Thread } = require('../models/threadModel.js');
+
+const { checkRunStatus, getCurRow } = require('../helpers/assistantHelper.js');
+const { processMessage, getLastMessages } = require('../helpers/assistantHelper.js');
+const { delay } = require('../helpers/whatsappHelper.js');
+
+const { GeneralAssistant } = require('../assistants/generalAssistant.js');
+const { SalesAssistant } = require('../assistants/salesAssistant.js');
+const { QumioRemindersAssistant } = require('../assistants/qumioRemindersAssistant.js');
+const { DoctorScheduleAssistant } = require('../assistants/doctorScheduleAssistant.js');
+const { PatientScheduleAssistant } = require('../assistants/patientScheduleAssistant.js');
+
+
+const getAssistantById = (assistant_id, thread) => {
+  switch (assistant_id) {
+  case SALES_ASST:
+    return new SalesAssistant(thread);
+  case QUMIO_REMINDERS_ASST:
+    return new QumioRemindersAssistant(thread);
+  case DOCTOR_SCHEDULE_ASST:
+    return new DoctorScheduleAssistant(thread);
+  case PATIENT_SCHEDULE_ASST:
+    return new PatientScheduleAssistant(thread);
+  default:
+    return new GeneralAssistant(thread);
+  }
+};
+
+
+const createAssistant = async (code, assistant_id, messages=[], prevThread=null) => {
+  // If thread already exists, update it
+  const findThread = await Thread.findOne({ code: code });
+  if (findThread) {
+    await Thread.updateOne({ code: code }, { $set: { active: true, stopped: false, assistant_id: assistant_id } });
+    return findThread;
+  }
+  
+  const curRow = await getCurRow(Historial_Clinico_ID, code);
+  console.log('curRow', curRow[0]);
+  const nombre = curRow?.[0]?.['name'] || null;
+  const patientId = curRow?.[0]?.['record_id'] || null;
+
+  const assistant = getAssistantById(assistant_id, null);
+  const initialThread = await assistant.create(code, curRow[0]);
+
+  // Add new messages to memory
+  for (const message of messages) {
+    await openaiClient.beta.threads.messages.create(
+      initialThread.id, { role: 'assistant', content: message }
+    );
+  }
+    
+  // Define new thread data
+  const thread = {
+    code: code,
+    assistant_id: assistant_id,
+    thread_id: initialThread.id,
+    patient_id: patientId,
+    run_id: null,
+    nombre: nombre,
+    active: true
+  };
+
+  const condition = { thread_id: prevThread?.thread_id };
+  const options = { new: true, upsert: true };
+  const updatedThread = await Thread.findOneAndUpdate(condition, thread, options);
+  console.log('Updated thread:', updatedThread);
+
+  // Delete previous thread
+  if (prevThread) {
+    await openaiClient.beta.threads.del(prevThread.thread_id);
+  }
+
+  return thread;
+};
+
+const addMsgAssistant = async (code, inMessages, reply = false) => {
+  try {
+    const thread = await Thread.findOne({ code: code });
+    console.log(thread);
+    if (thread === null) return null;
+
+    for (const message of inMessages) {
+      console.log(message);
+      await openaiClient.beta.threads.messages.create(
+        thread.thread_id, { role: 'assistant', content: message }
+      );
+    }
+
+    if (!reply) return null;
+
+    const assistant = getAssistantById(thread.assistant_id, thread);
+    const run = await openaiClient.beta.threads.runs.create(
+      thread.thread_id, 
+      { 
+        assistant_id: thread.assistant_id
+      }
+    );
+
+    await Thread.updateOne({ code: thread.code, active: true }, { $set: { run_id: run.id } });  
+    await checkRunStatus(assistant, run.thread_id, run.id);
+    await Thread.updateOne({ code: thread.code, active: true }, { $set: { run_id: null } });  
+
+    const messages = await openaiClient.beta.threads.messages.list(run.thread_id, { run_id: run.id });
+    const ans = messages.data[0].content[0].text.value;
+    console.log('THE ANS IS', ans);
+        
+    return ans;
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const addInsAssistant = async (code, instruction) => {
+  try {
+    const thread = await Thread.findOne({ code: code });
+    console.log(thread);
+    if (thread === null) return null;
+
+    const assistant = getAssistantById(thread.assistant_id, thread);
+    const run = await openaiClient.beta.threads.runs.create(
+      thread.thread_id, { 
+        assistant_id: thread.assistant_id,
+        additional_instructions: instruction,
+        additional_messages: [
+          { role: 'user', content: instruction }
+        ]
+      }
+    );
+
+    await Thread.updateOne({ code: thread.code, active: true }, { $set: { run_id: run.id } });  
+    await checkRunStatus(assistant, run.thread_id, run.id);
+    await Thread.updateOne({ code: thread.code, active: true }, { $set: { run_id: null } });  
+
+    const messages = await openaiClient.beta.threads.messages.list(run.thread_id, { run_id: run.id });
+    console.log(messages.data[0].content);
+    const ans = messages.data[0].content[0].text.value;
+        
+    return ans;
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const getThread = async (code, message = null) => {
+  try {
+    let thread = await Thread.findOne({ code: code });
+    console.log('GET THREAD');
+    console.log(thread);
+
+    if (thread === null) {
+      if (message != null) {
+        const timestamp = formatTimestamp(message.messageTimestamp);
+        await Message.updateOne({ message_id: message.key.id, timestamp: timestamp }, { $set: { processed: true } });
+        
+      }
+      return null;
+    }
+
+    while (thread && thread.run_id) {
+      console.log(`Wait for ${thread.run_id} to be executed`);
+      const run = await openaiClient.beta.threads.runs.retrieve(thread.thread_id, thread.run_id);
+      if (run.status === 'cancelled' || run.status === 'expired' || run.status === 'completed') {
+        await Thread.updateOne({ code: code }, { $set: { run_id: null } });
+      }
+      thread = await Thread.findOne({ code: code, active: true });
+      await delay(5000);
+    }
+
+    return thread;
+  } catch (error) {
+    console.error('Error in getThread:', error.message || error);
+    return null;
+  }
+};
+
+const getThreadInfo = async (code) => {
+  try {
+    let thread = await Thread.findOne({ code: code, active: true });
+    return thread;
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const replyAssistant = async function (code, message_ = null, thread_ = null, runOptions = {}) {
+  try {
+    let thread = thread_ || await getThread(code);
+    console.log('THREAD STOPPED', code, thread?.active);
+    if (!thread || !thread.active) return null;
+
+    const patientReply = message_ ? [message_] : await getLastMessages(code);
+    console.log('UNREAD DATA', patientReply);
+    if (!patientReply) {
+      console.log('No relevant data found for this assistant.');
+      return null;
+    }
+
+    let activeRuns = await openaiClient.beta.threads.runs.list(thread.thread_id);
+    console.log('ACTIVE RUNS:', activeRuns.length);
+    while (activeRuns.length > 0) {
+      console.log(`ACTIVE RUNS ${thread.thread_id}`);
+      activeRuns = await openaiClient.beta.threads.runs.list(thread.thread_id);
+      await delay(5000);
+    }
+
+    let patientMsg = false;
+    let urls = [];
+    for (const reply of patientReply) {
+      const { isNotAssistant, url } = await processMessage(code, reply, thread);
+      console.log(`isNotAssistant ${isNotAssistant} ${url}`);
+      patientMsg = patientMsg || isNotAssistant;
+      if (url) urls.push({ 'url': url });
+    }
+       
+    if (urls.length > 0) {
+      console.log('urls', urls);
+      /*for (const url of urls) {
+        console.log("url", url);
+        await addRecord(Monitoreo_ID, 'estudios', [{"fields": {"estudios": urls, 
+          "combined_estudios": [ { "url": url} ], "patient_id": [thread.patient_id]}}]);
+      }
+      const { pdfBuffer, processedFiles } = await combineImagesToPDF(code);
+      console.log("AFTER COMBINED IN BUFFER", processedFiles);
+      const key = `${code}-${Date.now()}-combined.pdf`;
+      await AWS.uploadBufferToS3(pdfBuffer, bucketName, key, "application/pdf");
+      const url = await AWS.generatePresignedUrl(bucketName, key);
+      console.log("New record", {"estudios": urls, "combined_estudios": 
+        [ { "url": url} ], "patient_id": [thread.patient_id]});
+      await addRecord(Monitoreo_ID, 'estudios', [{"fields": {"estudios": urls, 
+        "combined_estudios": [ { "url": url} ], "patient_id": [thread.patient_id]}}]);
+      await cleanupFiles(processedFiles);*/
+    }
+
+    thread = await getThread(code);
+    console.log('THREAD STOPPED', code, thread?.stopped);
+    if (!patientMsg || !thread || thread?.stopped) return null;
+
+    const assistant = getAssistantById(thread.assistant_id, thread);
+    const run = await openaiClient.beta.threads.runs.create(
+      thread.thread_id, 
+      { 
+        assistant_id: thread.assistant_id,
+        ...runOptions
+      }
+    );
+    console.log('RUN LAST ERROR:', run.last_error);
+
+    assistant.set_replies(patientReply);
+        
+    await Thread.updateOne({ code: thread.code, active: true }, { $set: { run_id: run.id } });  
+    const runStatus = await checkRunStatus(assistant, run.thread_id, run.id);
+    console.log('RUN STATUS', runStatus);
+    await Thread.updateOne({ code: thread.code, active: true }, { $set: { run_id: null } });  
+
+    const messages = await openaiClient.beta.threads.messages.list(run.thread_id, { run_id: run.id });
+    const reply = messages.data?.[0]?.content?.[0]?.text?.value || '';
+    console.log(reply);
+
+    return reply;
+  } catch (err) {
+    console.log(`Error inside reply assistant ${err} ${code}`);
+  }
+}; 
+
+const switchAssistant = async (code, assistant_id) => {
+  try {
+    const thread = await Thread.findOne({ code: code });
+    console.log('Inside thread', thread);
+    if (thread === null) return;
+
+    await Thread.updateOne({ code }, { $set: { assistant_id: assistant_id, active: true, stopped: false } });  
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+module.exports = {
+  getThread,
+  getThreadInfo,
+  getAssistantById,
+  createAssistant,
+  replyAssistant,
+  addMsgAssistant,
+  addInsAssistant,
+  switchAssistant
+};

package/lib/services/conversationService.js

@@ -0,0 +1,274 @@
+const { Message } = require('../models/messageModel');
+const { Historial_Clinico_ID } = require('../config/airtableConfig');
+const { getRecordByFilter } = require('./airtableService');
+
+
+const fetchConversationData = async (filter, skip, limit) => {
+  let filterConditions = { is_group: false };
+  
+  switch (filter) {
+  case 'unread':
+    filterConditions = { 
+      is_group: false,
+      from_me: false,
+      $or: [
+        { read: false },
+        { read: { $exists: false } }
+      ]
+    };
+    console.log('Applying unread filter');
+    break;
+
+  case 'no-response':
+    console.log('Applying no-response filter');
+    break;
+
+  case 'recent': {
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    filterConditions = { 
+      is_group: false,
+      createdAt: { $gt: yesterday }
+    };
+    console.log('Applying recent filter (last 24 hours)');
+    break;
+  }
+
+  case 'all':
+  default:
+    filterConditions = { is_group: false };
+    console.log('Applying all conversations filter');
+    break;
+  }
+
+  console.log('Executing aggregation pipeline...');
+  const aggregationStartTime = Date.now();
+  
+  let aggregationPipeline = [
+    { $match: filterConditions },
+    { $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 } }
+  ];
+
+  if (filter === 'no-response') {
+    aggregationPipeline.splice(-1, 0, { $match: { 'latestMessage.from_me': false } });
+  }
+
+  aggregationPipeline.push(
+    { $skip: skip },
+    { $limit: limit }
+  );
+
+  const conversations = await Message.aggregate(aggregationPipeline);
+
+  const aggregationTime = Date.now() - aggregationStartTime;
+  console.log(`Aggregation completed in ${aggregationTime}ms, found ${conversations.length} conversations`);
+
+  // Fetch names from Airtable and WhatsApp
+  const phoneNumbers = conversations.map(conv => conv._id).filter(Boolean);
+  const formula = 'OR(' +
+    phoneNumbers.map(p => `{whatsapp_id} = "${p}"`).join(', ') +
+    ')';
+  const patientTable = await getRecordByFilter(Historial_Clinico_ID, 'estado_general', formula);
+  const airtableNameMap = patientTable.reduce((map, patient) => {
+    map[patient.whatsapp_id] = patient.name;
+    return map;
+  }, {});
+  console.log(`Found ${Object.keys(airtableNameMap).length} names in Airtable`);
+
+  const contactNames = await Message.aggregate([
+    { $match: { is_group: false, from_me: false } },
+    { $sort: { createdAt: -1 } },
+    { $group: {
+      _id: '$numero',
+      name: { $first: '$nombre_whatsapp' }
+    }}
+  ]);
+      
+  const nameMap = contactNames?.reduce((map, contact) => {
+    if (contact && contact._id) {
+      if (!airtableNameMap[contact._id]) {
+        map[contact._id] = contact.name || 'Unknown';
+      }
+    }
+    return map;
+  }, {...airtableNameMap}) || airtableNameMap || {};
+      
+  // Fetch unread counts
+  console.log('Fetching unread counts using Message.aggregate');
+  const unreadCounts = await Message.aggregate([
+    { 
+      $match: { 
+        is_group: false, 
+        from_me: false, 
+        $or: [
+          { read: false },
+          { read: { $exists: false } }
+        ]
+      } 
+    },
+    { $group: {
+      _id: '$numero',
+      unreadCount: { $sum: 1 }
+    }}
+  ]);
+      
+  const unreadMap = unreadCounts?.reduce((map, item) => {
+    if (item && item._id) {
+      map[item._id] = item.unreadCount || 0;
+    }
+    return map;
+  }, {}) || {};
+  console.log('unreadMap', JSON.stringify(unreadMap));
+  console.log('Number of conversations found:', conversations?.length || 0);
+      
+  // Calculate total count for pagination
+  let totalFilterConditions = { is_group: false };
+
+  if (filter === 'unread') {
+    totalFilterConditions = { 
+      is_group: false,
+      from_me: false,
+      $or: [
+        { read: false },
+        { read: { $exists: false } }
+      ]
+    };
+  } else if (filter === 'recent') {
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    totalFilterConditions = { 
+      is_group: false,
+      createdAt: { $gt: yesterday }
+    };
+  }
+
+  let totalAggregationPipeline = [
+    { $match: totalFilterConditions },
+    { $group: { _id: '$numero' } },
+    { $count: 'total' }
+  ];
+
+  if (filter === 'no-response') {
+    totalAggregationPipeline = [
+      { $match: { is_group: false } },
+      { $project: {
+        numero: 1,
+        from_me: 1,
+        createdAt: 1
+      }},
+      { $group: {
+        _id: '$numero',
+        latestMessage: { $first: '$$ROOT' }
+      }},
+      { $match: { 'latestMessage.from_me': false } },
+      { $count: 'total' }
+    ];
+  }
+
+  const totalConversations = await Message.aggregate(totalAggregationPipeline, { allowDiskUse: true });
+  const total = totalConversations[0]?.total || 0;
+
+  return { conversations, total, nameMap, unreadMap };
+};
+
+/**
+ * Processes conversations to prepare them for the response
+ */
+const processConversations = async (conversations, nameMap, unreadMap) => {
+  console.log('Processing conversations for response...');
+
+  let processedConversations = [];
+  try {
+    processedConversations = (conversations || []).map((conv, index) => {
+      try {
+        if (!conv || !conv.latestMessage) {
+          console.warn(`Conversation ${index} missing latestMessage:`, conv?._id || 'unknown');
+          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: nameMap[conv._id] || conv?.latestMessage?.nombre_whatsapp || 'Unknown',
+          lastMessage: conv?.latestMessage?.body || '',
+          lastMessageTime: conv?.latestMessage?.createdAt || conv?.latestMessage?.timestamp || new Date(),
+          messageCount: conv.messageCount || 0,
+          unreadCount: unreadMap[conv._id] || 0,
+          isLastMessageMedia: isMedia || false,
+          lastMessageType: mediaType || null,
+          lastMessageFromMe: conv?.latestMessage?.from_me || false
+        };
+      } catch (convError) {
+        console.error(`Error processing conversation ${index}:`, convError);
+        return {
+          phoneNumber: conv?._id || `error_${index}`,
+          name: 'Error Processing',
+          lastMessage: 'Error processing conversation',
+          lastMessageTime: new Date(),
+          messageCount: 0,
+          unreadCount: 0,
+          isLastMessageMedia: false,
+          lastMessageType: null,
+          lastMessageFromMe: false
+        };
+      }
+    });
+
+    console.log(`Successfully processed ${processedConversations.length} conversations`);
+  
+  } catch (mappingError) {
+    console.error('Error in conversation mapping:', mappingError);
+    // Return empty conversations if mapping fails
+    processedConversations = [];
+  }
+
+  return processedConversations;
+};
+
+module.exports = {
+  fetchConversationData,
+  processConversations
+};