Merge pull request #1999 from OneCommunityGlobal/messaging-backend

one-community · web-flow · commit 5a0e5b4b60d1 · 2026-04-19T14:41:27.000-07:00
uha FIX LB backend messaging
diff --git a/jest.config.js b/jest.config.js
@@ -42,6 +42,9 @@ module.exports = {
   transform: {
     '^.+\\.js$': 'babel-jest',
   },
+  moduleNameMapper: {
+    '^puppeteer$': '<rootDir>/src/test/mocks/puppeteer.js',
+  },
   setupFilesAfterEnv: ['<rootDir>/src/test/setup.js'],
   // Simple CI settings
   maxWorkers: 1, // Run tests sequentially
diff --git a/src/controllers/lbdashboard/lbuserPrefController.js b/src/controllers/lbdashboard/lbuserPrefController.js
@@ -1,29 +1,72 @@
+const mongoose = require('mongoose');
+
 const lbUserPrefController = function (UserPreferences, Notification) {
+  const normalizeObjectId = (value) => {
+    if (typeof value !== 'string') return null;
+
+    const trimmed = value.trim();
+    if (!mongoose.Types.ObjectId.isValid(trimmed)) return null;
+
+    return trimmed;
+  };
+
+  const normalizeObjectIdList = (values) => {
+    if (!Array.isArray(values)) return null;
+
+    const normalizedIds = values.map(normalizeObjectId);
+    return normalizedIds.every(Boolean) ? normalizedIds : null;
+  };
+
+  const normalizePhone = (phone) => {
+    if (!phone) return { normalized: '', last4: '' };
+    const trimmed = String(phone).trim();
+    const hasPlus = trimmed.startsWith('+');
+    const digits = trimmed.replace(/\D/g, '');
+    const normalized = hasPlus ? `+${digits}` : digits;
+    return { normalized, last4: digits.slice(-4) };
+  };
+
+  const maskPhone = (phone) => {
+    if (!phone) return '';
+    const digits = String(phone).replace(/\D/g, '');
+    if (digits.length <= 4) return digits;
+    return `***-***-${digits.slice(-4)}`;
+  };
   const getPreferences = async (req, res) => {
     try {
       const { userId, selectedUserId } = req.body;
+      const normalizedUserId = normalizeObjectId(userId);
+      const normalizedSelectedUserId = selectedUserId
+        ? normalizeObjectId(selectedUserId)
+        : null;
 
-      if (!userId) {
-        return res.status(400).json({ message: 'User ID is required.' });
+      if (!normalizedUserId) {
+        return res.status(400).json({ message: 'A valid user ID is required.' });
       }
 
-      const preferences = await UserPreferences.findOne({ user: userId }).populate(
+      if (selectedUserId && !normalizedSelectedUserId) {
+        return res.status(400).json({ message: 'Selected user ID must be a valid ID.' });
+      }
+
+      const preferences = await UserPreferences.findOne({ user: normalizedUserId }).populate(
         'users.userNotifyingFor',
       );
 
       if (!preferences) {
         return res.status(404).json({ message: 'Preferences not found for the user.' });
       }
 
-      if (selectedUserId) {
+      if (normalizedSelectedUserId) {
         const selectedUserPref = preferences.users.find(
-          (pref) => pref.userNotifyingFor._id.toString() === selectedUserId,
+          (pref) => pref.userNotifyingFor._id.toString() === normalizedSelectedUserId,
         );
 
         return res.status(200).json(selectedUserPref || { notifyInApp: false, notifyEmail: false });
       }
 
-      res.status(200).json(preferences);
+      const response = preferences.toObject();
+      response.smsPhoneMasked = maskPhone(preferences.smsPhone);
+      res.status(200).json(response);
     } catch (error) {
       console.error('Error fetching preferences:', error);
       res.status(500).json({ message: 'Error fetching preferences', error: error.message });
@@ -32,43 +75,69 @@ const lbUserPrefController = function (UserPreferences, Notification) {
 
   const updatePreferences = async (req, res) => {
     try {
-      const { userId, selectedUserId, notifyInApp, notifyEmail } = req.body;
+      const { userId, selectedUserId, notifyInApp, notifyEmail, notifySms, smsPhone } = req.body;
+      const normalizedUserId = normalizeObjectId(userId);
+      const normalizedSelectedUserId = selectedUserId
+        ? normalizeObjectId(selectedUserId)
+        : null;
+
+      if (!normalizedUserId) {
+        return res.status(400).json({ message: 'A valid user ID is required.' });
+      }
 
-      if (!userId || !selectedUserId) {
-        return res.status(400).json({ message: 'User ID and Selected User ID are required.' });
+      if (selectedUserId && !normalizedSelectedUserId) {
+        return res.status(400).json({ message: 'Selected user ID must be a valid ID.' });
       }
 
-      const preferences = await UserPreferences.findOne({ user: userId });
+      let preferences = await UserPreferences.findOne({ user: normalizedUserId });
 
       if (!preferences) {
-        const newPreferences = new UserPreferences({
-          user: userId,
-          users: [
-            {
-              userNotifyingFor: selectedUserId,
-              notifyInApp: notifyInApp !== undefined ? notifyInApp : false,
-              notifyEmail: notifyEmail !== undefined ? notifyEmail : false,
-            },
-          ],
-        });
-
-        await newPreferences.save();
-        return res.status(200).json(newPreferences);
+        preferences = new UserPreferences({ user: normalizedUserId, users: [] });
       }
 
-      const userIndex = preferences.users.findIndex(
-        (user) => user.userNotifyingFor.toString() === selectedUserId,
-      );
+      if (normalizedSelectedUserId) {
+        const userIndex = preferences.users.findIndex(
+          (user) => user.userNotifyingFor.toString() === normalizedSelectedUserId,
+        );
+
+        if (userIndex === -1) {
+          preferences.users.push({
+            userNotifyingFor: normalizedSelectedUserId,
+            notifyInApp: notifyInApp !== undefined ? notifyInApp : false,
+            notifyEmail: notifyEmail !== undefined ? notifyEmail : false,
+          });
+        } else {
+          preferences.users[userIndex].notifyInApp =
+            notifyInApp !== undefined ? notifyInApp : false;
+          preferences.users[userIndex].notifyEmail =
+            notifyEmail !== undefined ? notifyEmail : false;
+        }
+      } else if (notifyInApp !== undefined || notifyEmail !== undefined) {
+        if (notifyInApp !== undefined) {
+          preferences.notifyInApp = notifyInApp;
+        }
+        if (notifyEmail !== undefined) {
+          preferences.notifyEmail = notifyEmail;
+        }
+      }
 
-      if (userIndex === -1) {
-        preferences.users.push({
-          userNotifyingFor: selectedUserId,
-          notifyInApp: notifyInApp !== undefined ? notifyInApp : false,
-          notifyEmail: notifyEmail !== undefined ? notifyEmail : false,
-        });
-      } else {
-        preferences.users[userIndex].notifyInApp = notifyInApp !== undefined ? notifyInApp : false;
-        preferences.users[userIndex].notifyEmail = notifyEmail !== undefined ? notifyEmail : false;
+      if (notifySms !== undefined || smsPhone !== undefined) {
+        const { normalized, last4 } = normalizePhone(smsPhone);
+        const digits = normalized.replace(/\D/g, '');
+        const existingDigits = String(preferences.smsPhone || '').replace(/\D/g, '');
+        if (notifySms && digits.length === 0 && existingDigits.length === 0) {
+          return res.status(400).json({ message: 'SMS phone number is required.' });
+        }
+        if (digits.length > 0 && (digits.length < 8 || digits.length > 15)) {
+          return res.status(400).json({ message: 'Invalid phone number format.' });
+        }
+        if (notifySms !== undefined) {
+          preferences.notifySms = notifySms;
+        }
+        if (smsPhone !== undefined && digits.length > 0) {
+          preferences.smsPhone = normalized;
+          preferences.smsPhoneLast4 = last4;
+        }
       }
 
       const updatedPreferences = await preferences.save();
@@ -82,15 +151,17 @@ const lbUserPrefController = function (UserPreferences, Notification) {
   const storeNotification = async (req, res) => {
     try {
       const { userId, senderId, message } = req.body;
+      const normalizedUserId = normalizeObjectId(userId);
+      const normalizedSenderId = normalizeObjectId(senderId);
 
-      if (!userId || !senderId || !message) {
+      if (!normalizedUserId || !normalizedSenderId || !message) {
         return res.status(400).json({ message: 'User ID, Sender ID, and Message are required.' });
       }
 
       const notification = new Notification({
         message,
-        sender: senderId,
-        recipient: userId,
+        sender: normalizedSenderId,
+        recipient: normalizedUserId,
         isSystemGenerated: false,
       });
 
@@ -105,13 +176,14 @@ const lbUserPrefController = function (UserPreferences, Notification) {
   const getUnreadNotifications = async (req, res) => {
     try {
       const { userId } = req.params;
+      const normalizedUserId = normalizeObjectId(userId);
 
-      if (!userId) {
+      if (!normalizedUserId) {
         console.error('❌ User ID is missing in the request.');
-        return res.status(400).json({ message: 'User ID is required.' });
+        return res.status(400).json({ message: 'A valid user ID is required.' });
       }
 
-      const notifications = await Notification.find({ recipient: userId, isRead: false })
+      const notifications = await Notification.find({ recipient: normalizedUserId, isRead: false })
         .sort({ createdTimeStamps: -1 })
         .populate('sender', 'firstName lastName'); // Include sender's name
 
@@ -127,12 +199,13 @@ const lbUserPrefController = function (UserPreferences, Notification) {
   const markNotificationsAsRead = async (req, res) => {
     try {
       const { notificationIds } = req.body;
+      const normalizedNotificationIds = normalizeObjectIdList(notificationIds);
 
-      if (!notificationIds || !Array.isArray(notificationIds)) {
+      if (!normalizedNotificationIds) {
         return res.status(400).json({ message: 'Invalid notification IDs.' });
       }
       const result = await Notification.updateMany(
-        { _id: { $in: notificationIds } },
+        { _id: { $in: normalizedNotificationIds } },
         { isRead: true },
       );
 
diff --git a/src/models/lbdashboard/userPreferences.js b/src/models/lbdashboard/userPreferences.js
@@ -2,6 +2,11 @@ const mongoose = require('mongoose');
 
 const userPreferencesSchema = new mongoose.Schema({
   user: { type: mongoose.Schema.Types.ObjectId, ref: 'userProfile', required: true },
+  notifyInApp: { type: Boolean, default: false },
+  notifyEmail: { type: Boolean, default: false },
+  notifySms: { type: Boolean, default: false },
+  smsPhone: { type: String, default: '' },
+  smsPhoneLast4: { type: String, default: '' },
   users: [
     {
       userNotifyingFor: {
diff --git a/src/test/mocks/puppeteer.js b/src/test/mocks/puppeteer.js
@@ -0,0 +1 @@
+module.exports = {};
diff --git a/src/utilities/smsQueue.js b/src/utilities/smsQueue.js
@@ -0,0 +1,58 @@
+const { twilioSendSMS, TextbeltSMS, TelesignSMS } = require('./SMSSender');
+
+const queue = [];
+let processing = false;
+
+const getProvider = () => (process.env.SMS_PROVIDER || 'telesign').toLowerCase();
+
+const sendSmsViaProvider = async (message, to) => {
+  const provider = getProvider();
+  if (!to) {
+    throw new Error('SMS recipient is required.');
+  }
+
+  switch (provider) {
+    case 'twilio': {
+      const from = process.env.TWILIO_FROM_NUMBER;
+      if (!from) {
+        throw new Error('TWILIO_FROM_NUMBER is not configured.');
+      }
+      return twilioSendSMS(message, from, to);
+    }
+    case 'textbelt':
+      return TextbeltSMS(message, to);
+    case 'telesign':
+    default:
+      return TelesignSMS(message, to);
+  }
+};
+
+const processQueue = async () => {
+  if (processing || queue.length === 0) return;
+  processing = true;
+
+  while (queue.length > 0) {
+    const item = queue.shift();
+    if (!item) continue;
+    try {
+      const response = await Promise.resolve(sendSmsViaProvider(item.message, item.to));
+      if (process.env.SMS_LOG_RESPONSES === 'true') {
+        console.log('SMS send response:', response?.data || response);
+      }
+    } catch (error) {
+      console.error('Failed to send SMS:', error?.response?.data || error.message);
+    }
+  }
+
+  processing = false;
+};
+
+const queueSmsNotification = ({ to, message }) => {
+  if (!to || !message) return;
+  queue.push({ to, message });
+  setImmediate(() => {
+    processQueue().catch((error) => console.error('SMS queue error:', error.message));
+  });
+};
+
+module.exports = { queueSmsNotification };
diff --git a/src/websockets/lbMessaging/messagingSocket.js b/src/websockets/lbMessaging/messagingSocket.js
