@ozdao/martyrs 0.2.511 → 0.2.513

package/dist/notifications.server.js

@@ -114,18 +114,45 @@ const NotificationsController = (db, wss, notificationService) => {
   };
   const registerDevice = async (req, res) => {
     try {
-      const { userId, deviceId, deviceType, deviceToken } = req.body;
-      const device = await db.userDevice.findOneAndUpdate(
-        { userId, deviceId },
-        {
+      const { userId, anonymousId, deviceId, deviceType, deviceToken } = req.body;
+      if (!userId && !anonymousId) {
+        return res.status(400).json({ message: "Either userId or anonymousId is required" });
+      }
+      const isAnonymous = !userId;
+      let query, updateData;
+      if (isAnonymous) {
+        query = { anonymousId, deviceId };
+        updateData = {
+          anonymousId,
+          deviceId,
+          deviceType,
+          deviceToken,
+          isActive: true,
+          isAnonymous: true,
+          lastActive: Date.now()
+        };
+      } else {
+        await db.userDevice.deleteMany({
+          $or: [
+            { deviceId, isAnonymous: true },
+            { deviceToken, isAnonymous: true }
+          ]
+        });
+        query = { userId, deviceId };
+        updateData = {
           userId,
           deviceId,
           deviceType,
           deviceToken,
           isActive: true,
+          isAnonymous: false,
           lastActive: Date.now()
-        },
-        { upsert: true, new: true }
+        };
+      }
+      const device = await db.userDevice.findOneAndUpdate(
+        query,
+        { $set: updateData },
+        { upsert: true, new: true, setDefaultsOnInsert: true }
       );
       return res.status(201).json(device);
     } catch (err) {
@@ -166,6 +193,87 @@ const NotificationsController = (db, wss, notificationService) => {
       return res.status(500).json({ message: err.message });
     }
   };
+  const sendToTokens = async (req, res) => {
+    try {
+      const { tokens, title, body, data = {} } = req.body;
+      if (!tokens || !Array.isArray(tokens) || tokens.length === 0) {
+        return res.status(400).json({ message: "tokens array is required" });
+      }
+      if (!title || !body) {
+        return res.status(400).json({ message: "title and body are required" });
+      }
+      const devices = await db.userDevice.find({
+        deviceToken: { $in: tokens },
+        isActive: true
+      });
+      const results = [];
+      for (const device of devices) {
+        try {
+          await notificationService.sendToDeviceToken({
+            deviceToken: device.deviceToken,
+            deviceType: device.deviceType,
+            title,
+            body,
+            data
+          });
+          results.push({ token: device.deviceToken, success: true });
+        } catch (error) {
+          results.push({ token: device.deviceToken, success: false, error: error.message });
+        }
+      }
+      return res.json({
+        message: "Notifications sent",
+        results,
+        total: tokens.length,
+        found: devices.length
+      });
+    } catch (err) {
+      return res.status(500).json({ message: err.message });
+    }
+  };
+  const sendToAnonymous = async (req, res) => {
+    try {
+      const { anonymousIds, title, body, data = {} } = req.body;
+      if (!title || !body) {
+        return res.status(400).json({ message: "title and body are required" });
+      }
+      let devices;
+      if (anonymousIds && Array.isArray(anonymousIds)) {
+        devices = await db.userDevice.find({
+          anonymousId: { $in: anonymousIds },
+          isAnonymous: true,
+          isActive: true
+        });
+      } else {
+        devices = await db.userDevice.find({
+          isAnonymous: true,
+          isActive: true
+        });
+      }
+      const results = [];
+      for (const device of devices) {
+        try {
+          await notificationService.sendToDeviceToken({
+            deviceToken: device.deviceToken,
+            deviceType: device.deviceType,
+            title,
+            body,
+            data
+          });
+          results.push({ anonymousId: device.anonymousId, deviceToken: device.deviceToken, success: true });
+        } catch (error) {
+          results.push({ anonymousId: device.anonymousId, deviceToken: device.deviceToken, success: false, error: error.message });
+        }
+      }
+      return res.json({
+        message: "Notifications sent to anonymous devices",
+        results,
+        devicesFound: devices.length
+      });
+    } catch (err) {
+      return res.status(500).json({ message: err.message });
+    }
+  };
   return {
     create,
     createBatch,
@@ -174,7 +282,9 @@ const NotificationsController = (db, wss, notificationService) => {
     registerDevice,
     updatePreferences,
     getUserPreferences,
-    markAllAsRead
+    markAllAsRead,
+    sendToTokens,
+    sendToAnonymous
   };
 };
 const NotificationLogModel = (db, additionalFields = {}) => {
@@ -226,15 +336,22 @@ const NotificationModel = (db, additionalFields = {}) => {
 };
 const UserDeviceModel = (db, additionalFields = {}) => {
   const schema = new db.mongoose.Schema({
-    userId: { type: db.mongoose.Schema.Types.ObjectId, ref: "User", required: true },
+    userId: { type: db.mongoose.Schema.Types.ObjectId, ref: "User", required: false },
+    anonymousId: { type: String, required: false },
+    // For anonymous users
     deviceId: { type: String, required: true },
     deviceType: { type: String, enum: ["ios", "android", "web"], required: true },
     deviceToken: { type: String, required: true },
     // Push token for mobile, or web token
     isActive: { type: Boolean, default: true },
-    lastActive: { type: Date, default: Date.now }
+    lastActive: { type: Date, default: Date.now },
+    isAnonymous: { type: Boolean, default: false }
+    // Flag to identify anonymous devices
   });
-  schema.index({ userId: 1, deviceId: 1 }, { unique: true });
+  schema.index({ userId: 1, deviceId: 1 }, { unique: true, sparse: true });
+  schema.index({ anonymousId: 1, deviceId: 1 }, { unique: true, sparse: true });
+  schema.index({ deviceToken: 1 }, { unique: true });
+  schema.index({ isAnonymous: 1, isActive: 1 });
   return db.mongoose.model("UserDevice", schema);
 };
 const notificationsRoutes = (app, db, wss, origins, publicPath, notificationService) => {
@@ -247,6 +364,8 @@ const notificationsRoutes = (app, db, wss, origins, publicPath, notificationServ
   app.post("/api/notifications/devices/register", controller.registerDevice);
   app.get("/api/notifications/preferences/:userId", controller.getUserPreferences);
   app.put("/api/notifications/preferences", controller.updatePreferences);
+  app.post("/api/notifications/send-to-tokens", controller.sendToTokens);
+  app.post("/api/notifications/send-to-anonymous", controller.sendToAnonymous);
 };
 let apnProvider = null;
 const getApnProvider = () => {
@@ -588,9 +707,84 @@ const NotificationService = function(db, wss) {
       await processNotification(notification);
     }
   };
+  const sendToDeviceToken = async ({ deviceToken, deviceType, title, body, data = {} }) => {
+    const pushService = getPushServiceByDeviceType(deviceType);
+    return pushService.send({
+      token: deviceToken,
+      title,
+      body,
+      data
+    });
+  };
+  const sendToDeviceTokens = async ({ tokens, title, body, data = {} }) => {
+    const results = [];
+    for (const token of tokens) {
+      try {
+        const device = await db.userDevice.findOne({ deviceToken: token, isActive: true });
+        if (!device) {
+          results.push({ token, success: false, error: "Device not found" });
+          continue;
+        }
+        await sendToDeviceToken({
+          deviceToken: token,
+          deviceType: device.deviceType,
+          title,
+          body,
+          data
+        });
+        results.push({ token, success: true });
+      } catch (error) {
+        results.push({ token, success: false, error: error.message });
+      }
+    }
+    return results;
+  };
+  const sendToAnonymousDevices = async ({ anonymousIds = null, title, body, data = {} }) => {
+    let devices;
+    if (anonymousIds && Array.isArray(anonymousIds)) {
+      devices = await db.userDevice.find({
+        anonymousId: { $in: anonymousIds },
+        isAnonymous: true,
+        isActive: true
+      });
+    } else {
+      devices = await db.userDevice.find({
+        isAnonymous: true,
+        isActive: true
+      });
+    }
+    const results = [];
+    for (const device of devices) {
+      try {
+        await sendToDeviceToken({
+          deviceToken: device.deviceToken,
+          deviceType: device.deviceType,
+          title,
+          body,
+          data
+        });
+        results.push({
+          anonymousId: device.anonymousId,
+          deviceToken: device.deviceToken,
+          success: true
+        });
+      } catch (error) {
+        results.push({
+          anonymousId: device.anonymousId,
+          deviceToken: device.deviceToken,
+          success: false,
+          error: error.message
+        });
+      }
+    }
+    return results;
+  };
   return {
     processNotification,
-    processPendingNotifications
+    processPendingNotifications,
+    sendToDeviceToken,
+    sendToDeviceTokens,
+    sendToAnonymousDevices
   };
 };
 const { getInstance } = globalsabac;