@ozdao/martyrs 0.2.488 → 0.2.491

package/src/modules/notifications/components/pages/Notifications.vue

@@ -1,19 +1,14 @@
 <template>
   <div class="notifications-page pd-small">
-    <div class="tabs">
-      <button 
-        :class="{ active: activeTab === 'all' }" 
-        @click="activeTab = 'all'"
-      >
-        All Notifications {{ unreadCount > 0 ? `(${unreadCount})` : '' }}
-      </button>
-      <button 
-        :class="{ active: activeTab === 'preferences' }" 
-        @click="activeTab = 'preferences'"
-      >
-        Notification Settings
-      </button>
-    </div>
+    <Tab
+      v-model:selected="activeTab"
+      :tabs="[
+        { label: `All Notifications${unreadCount > 0 ? ` (${unreadCount})` : ''}`, value: 'all' },
+        { label: 'Notification Settings', value: 'preferences' }
+      ]"
+      class="flex-child-default gap-micro scroll-hide bg-light radius-medium h-max pd-thin mn-b-thin o-x-scroll"
+      classTab="bg-white"
+    />
     
     <div class="tab-content">
       <notifications-list v-if="activeTab === 'all'" />
@@ -25,6 +20,7 @@
 <script setup>
 import { ref, inject } from 'vue';
 import { useRoute } from 'vue-router';
+import Tab from "@martyrs/src/components/Tab/Tab.vue";
 import NotificationsList from '../sections/NotificationsList.vue';
 import NotificationPreferences from '../sections/NotificationPreferences.vue';
 
@@ -37,41 +33,4 @@ const activeTab = ref(route.query.tab || 'all');
 </script>
 
 <style scoped>
-.notifications-page {
-}
-
-.tabs {
-  display: flex;
-  margin-bottom: 24px;
-  border-bottom: 1px solid #e0e0e0;
-}
-
-.tabs button {
-  background: none;
-  border: none;
-  padding: 12px 24px;
-  font-size: 1rem;
-  cursor: pointer;
-  position: relative;
-  color: #666;
-}
-
-.tabs button.active {
-  color: #2196F3;
-  font-weight: 500;
-}
-
-.tabs button.active::after {
-  content: '';
-  position: absolute;
-  bottom: -1px;
-  left: 0;
-  width: 100%;
-  height: 2px;
-  background-color: #2196F3;
-}
-
-.tab-content {
-  padding: 16px 0;
-}
 </style>

package/src/modules/notifications/components/sections/NotificationPreferences.vue

@@ -1,6 +1,6 @@
 <template>
   <div class="notification-preferences">
-    <h2>Notification Preferences</h2>
+    <h2 class="mn-b-small">Notification Preferences</h2>
     <p class="description">Choose how you want to receive notifications</p>
     
     <div v-if="loading" class="preferences-loading">
@@ -155,16 +155,6 @@ onMounted(async () => {
 </script>
 
 <style scoped>
-.notification-preferences {
-  max-width: 800px;
-  margin: 0 auto;
-  padding: 24px;
-}
-
-h2 {
-  margin-top: 0;
-  margin-bottom: 8px;
-}
 
 .description {
   color: #666;

package/src/modules/notifications/components/sections/NotificationsList.vue

@@ -154,7 +154,7 @@ const formatTime = (timestamp) => {
 // Lifecycle
 onMounted(() => {
   const userId = auth.state.user._id;
-  if (userId && notifications.value.length === 0) {
+  if (userId && notifications.value.length === 0 && !loading.value) {
     getNotifications(userId);
   }
 });

package/src/modules/notifications/controllers/notifications.controller.js

@@ -1,17 +1,61 @@
 // controllers/notifications.controller.js
-const NotificationsController = (db, wss) => {
+const NotificationsController = (db, wss, notificationService) => {
   // Create a new notification
   const create = async (req, res) => {
     try {
       const notification = await db.notification.create(req.body);
       // Trigger notification sending process
-      const notificationService = notification(db, wss);
-      notificationService.processNotification(notification);
+      await notificationService.processNotification(notification);
       return res.status(201).json(notification);
     } catch (err) {
       return res.status(500).json({ message: err.message });
     }
   };
+  
+  // Create multiple notifications at once
+  const createBatch = async (req, res) => {
+    console.log('=== Batch notifications endpoint ===');
+    console.log('Request body:', JSON.stringify(req.body, null, 2));
+    
+    try {
+      const { notifications } = req.body;
+      
+      if (!notifications || !Array.isArray(notifications)) {
+        console.error('Invalid request: notifications array is required');
+        return res.status(400).json({ message: 'notifications array is required' });
+      }
+
+      console.log('Creating notifications count:', notifications.length);
+
+      // Create all notifications
+      const createdNotifications = await db.notification.insertMany(notifications);
+      console.log('Created notifications:', createdNotifications.map(n => n._id));
+      
+      // Fire and forget with error tracking
+      setImmediate(() => {
+        Promise.allSettled(createdNotifications.map(notif =>
+          notificationService.processNotification(notif)
+        )).then(results => {
+          const failures = results.filter(r => r.status === 'rejected');
+          if (failures.length > 0) {
+            console.error('Batch notification processing errors:', 
+              failures.map(f => f.reason?.message || f.reason));
+          }
+          console.log(`Batch processing complete: ${results.length - failures.length}/${results.length} successful`);
+        });
+      });
+      
+      return res.status(201).json({ 
+        message: 'Batch notifications created',
+        count: createdNotifications.length 
+      });
+    } catch (err) {
+      console.error('=== Batch notifications error ===');
+      console.error('Error:', err.message);
+      console.error('Stack:', err.stack);
+      return res.status(500).json({ message: err.message });
+    }
+  };
   // Get all notifications for a user
   const getUserNotifications = async (req, res) => {
     try {
@@ -53,7 +97,7 @@ const NotificationsController = (db, wss) => {
     try {
       const userId = req.params.userId;
       // Update all unread notifications for this user
-      const result = await db.notification.updateMany({ userId: userId, status: 'unread' }, { status: 'read', updatedAt: Date.now() });
+      const result = await db.notification.updateMany({ userId: userId, status: { $in: ['sent', 'unread'] } }, { status: 'read', updatedAt: Date.now() });
       // Get all updated notifications for logging
       const updatedNotifications = await db.notification.find({
         userId: userId,
@@ -139,8 +183,10 @@ const NotificationsController = (db, wss) => {
       return res.status(500).json({ message: err.message });
     }
   };
+
   return {
     create,
+    createBatch,
     getUserNotifications,
     markAsRead,
     registerDevice,

package/src/modules/notifications/notifications.client.js

@@ -191,7 +191,7 @@ class NotificationManager {
       return;
     }
 
-    const registration = await navigator.serviceWorker.register('/sw.js');
+    const registration = await navigator.serviceWorker.ready;
     const subscription = await registration.pushManager.subscribe({
       userVisibleOnly: true,
       applicationServerKey: 'BJtNnRrx05VQS0abnkHC-8gHJWpnmoqC_iQveENCmZOZIs-adWzqAiqFCdGVVd7CbiaLW-Q5iuIBDRgM9G-VnKg',

package/src/modules/notifications/notifications.server.js

@@ -15,17 +15,28 @@ function initializeNotifications(app, db, wss, origins, publicPath) {
   db.notificationLog = NotificationLogModel(db);
   const abac = getInstance(db);
   // const notificationPolicies = initNotificationPolicies(abac, db);
+  // Initialize notification service and related background tasks
+  const notificationService = NotificationService(db, wss);
   // Set up routes if app is provided
   if (app) {
-    notificationsRoutes(app, db, wss, origins, publicPath);
+    notificationsRoutes(app, db, wss, origins, publicPath, notificationService);
   }
-  // Initialize notification service and related background tasks
-  const notificationService = NotificationService(db, wss);
   console.log('[DEBUG] WSS in notification init:', wss);
-  // Set up a scheduler to process pending notifications
-  setInterval(() => {
-    notificationService.processPendingNotifications();
-  }, 60000); // Every minute
+  // Set up a scheduler to process pending notifications with overlap protection
+  let isProcessing = false;
+
+  setInterval(async () => {
+    if (isProcessing) return;
+    isProcessing = true;
+
+    try {
+      await notificationService.processPendingNotifications();
+    } catch (error) {
+      console.error('Error in processPendingNotifications:', error);
+    } finally {
+      isProcessing = false;
+    }
+  }, 10000); // Every 10 seconds
 }
 export const models = {
   NotificationModel,

package/src/modules/notifications/routes/notifications.routes.js

@@ -1,11 +1,13 @@
 import notifications from '../controllers/notifications.controller.js';
 // routes/notifications.routes.js
-const notificationsRoutes = (app, db, wss, origins, publicPath) => {
-  const controller = notifications(db, wss);
+const notificationsRoutes = (app, db, wss, origins, publicPath, notificationService) => {
+  const controller = notifications(db, wss, notificationService);
   // Get notifications for a user
   app.get('/api/notifications/user/:userId', controller.getUserNotifications);
   // Create a new notification
   app.post('/api/notifications', controller.create);
+  // Create multiple notifications at once
+  app.post('/api/notifications/batch', controller.createBatch);
   // Mark notification as read
   app.put('/api/notifications/:id/read', controller.markAsRead);
   // Mark all notifications as read for a user

package/src/modules/notifications/services/notification.service.js

@@ -17,7 +17,7 @@ export default (function (db, wss) {
       const userId = notification.userId.toString();
       // Get user preferences
       const preferences = await db.notificationPreference.find({
-        userId: userId,
+        userId: new ObjectId(userId),
         // notificationType: notification.type
       });
       console.log('userId', userId);
@@ -40,64 +40,135 @@ export default (function (db, wss) {
       };
       // Get all active devices for push notifications
       const userDevices = await db.userDevice.find({
-        userId,
+        userId: new ObjectId(userId),
         isActive: true,
       });
+      console.log('=== CHANNEL SELECTION DEBUG ===');
+      console.log('userDevices found:', userDevices.length);
+      console.log('userDevices:', userDevices);
+      console.log('user.email:', user.email);
+      console.log('user.phoneNumber:', user.phoneNumber);
+      console.log('preferences.length:', preferences.length);
+      
       // Default channels if no preferences set
       let channels = ['web']; // Web is always on by default
+      
+      // If user has devices, add push to default channels
+      if (userDevices.length > 0) {
+        channels.push('push');
+        console.log('Added push channel - devices found');
+      } else {
+        console.log('No push channel - no devices found');
+      }
+      
       // If user has email, add it to default channels
       if (user.email) {
         channels.push('email');
+        console.log('Added email channel');
       }
       // If user has phone, add SMS to default channels
       if (user.phoneNumber) {
         channels.push('sms');
+        console.log('Added SMS channel');
       }
       // Override with user preferences if they exist
       if (preferences.length > 0) {
         channels = preferences.filter(pref => pref.isEnabled).map(pref => pref.channelType);
+        console.log('Overridden with user preferences:', channels);
       }
-      console.log('channels', channels);
-      // Send to each enabled channel
+      console.log('=== FINAL CHANNELS ===', channels);
+      // Send to each enabled channel - parallel processing
+      const channelPromises = [];
+
       for (const channel of channels) {
+        console.log(`=== PREPARING CHANNEL: ${channel} ===`);
         const sendFunc = channelRouters[channel];
-        if (sendFunc) {
-          try {
-            // For push notifications, we need to send to all devices
-            if (channel === 'push') {
-              for (const device of userDevices) {
-                await sendFunc(notification, user, device);
-              }
-            } else {
-              await sendFunc(notification, user);
-            }
-            // Update notification status
-            await db.notification.findByIdAndUpdate(notification._id, {
-              status: 'sent',
-              updatedAt: Date.now(),
-            });
-            // Log the sent notification
-            await db.notificationLog.create({
-              notificationId: notification._id,
-              userId: notification.userId,
-              channelType: channel,
-              status: 'sent',
-              sentAt: Date.now(),
-            });
-          } catch (error) {
-            console.error(`Error sending ${channel} notification:`, error);
-            // Log the failed notification
-            await db.notificationLog.create({
-              notificationId: notification._id,
-              userId: notification.userId,
-              channelType: channel,
-              status: 'failed',
-              error: error.message,
-              sentAt: Date.now(),
-            });
+        if (!sendFunc) {
+          channelPromises.push(Promise.resolve({
+            channel,
+            success: false,
+            error: 'No send function'
+          }));
+          continue;
+        }
+
+        if (channel === 'push') {
+          console.log(`Preparing push to ${userDevices.length} devices`);
+          // Each device as separate promise for true parallelism
+          for (const device of userDevices) {
+            channelPromises.push(
+              sendFunc(notification, user, device)
+                .then(() => {
+                  console.log(`Push sent successfully to device ${device.deviceId}`);
+                  return { channel: 'push', deviceId: device.deviceId, success: true };
+                })
+                .catch(err => {
+                  console.error(`Push failed for device ${device.deviceId}:`, err);
+                  return { channel: 'push', deviceId: device.deviceId, success: false, error: err.message };
+                })
+            );
+          }
+        } else {
+          channelPromises.push(
+            sendFunc(notification, user)
+              .then(() => {
+                console.log(`${channel} notification sent successfully`);
+                return { channel, success: true };
+              })
+              .catch(err => {
+                console.error(`${channel} notification failed:`, err);
+                return { channel, success: false, error: err.message };
+              })
+          );
+        }
+      }
+
+      console.log(`=== PROCESSING ${channelPromises.length} PARALLEL OPERATIONS ===`);
+      const results = await Promise.allSettled(channelPromises);
+      
+      // Process results and create batch logs
+      const logs = [];
+      const channelSuccessMap = new Map();
+
+      results.forEach(({ status, value }) => {
+        if (status === 'fulfilled' && value) {
+          const logEntry = {
+            notificationId: notification._id,
+            userId: notification.userId,
+            channelType: value.channel,
+            status: value.success ? 'sent' : 'failed',
+            sentAt: Date.now()
+          };
+          
+          if (!value.success) {
+            logEntry.error = value.error;
+          }
+          
+          logs.push(logEntry);
+          
+          // Mark channel success
+          if (value.success) {
+            channelSuccessMap.set(value.channel, true);
           }
         }
+      });
+
+      // Fire and forget batch log insertion
+      if (logs.length > 0) {
+        setImmediate(() => db.notificationLog.insertMany(logs).catch(console.error));
+        console.log(`Scheduled ${logs.length} logs for batch insertion`);
       }
+
+      const hasSuccessfulSend = channelSuccessMap.size > 0;
+      console.log(`=== PROCESSING COMPLETE - Success: ${hasSuccessfulSend} ===`);
+      
+      // Fire and forget status update
+      setImmediate(() => {
+        db.notification.findByIdAndUpdate(notification._id, {
+          status: hasSuccessfulSend ? 'sent' : 'failed',
+          updatedAt: Date.now(),
+        }).catch(console.error);
+      });
     } catch (error) {
       console.error('Error processing notification:', error);
       // Update notification status to failed

package/src/modules/notifications/services/telegram.service.js

@@ -18,3 +18,4 @@ const TelegramService = {
   },
 };
 export default TelegramService;
+

package/src/modules/notifications/services/whatsapp.service.js

@@ -23,3 +23,4 @@ const WhatsAppService = {
   },
 };
 export default WhatsAppService;
+

package/src/modules/notifications/store/notifications.store.js

@@ -237,24 +237,26 @@ const actions = {
   handleNotificationAction(data) {
     // Mark notification as read if ID is provided
     if (data.notificationId) {
-      this.markAsRead(data.notificationId);
+      actions.markAsRead(data.notificationId);
     }
 
-    // Navigate based on notification type and metadata
-    if (data.route) {
-      // router.push(data.route);
-      alert('1');
-    } else if (data.type === 'order') {
-      // router.push(`/orders/${data.orderId}`);
-      alert('2');
-    } else if (data.type === 'message') {
-      // router.push('/messages');
-      alert('3');
-    } else {
-      // Default to notifications page
-      // router.push('/notifications');
-      alert('4');
-    }
+    return true
+
+    // // Navigate based on notification type and metadata
+    // if (data.route) {
+    //   // router.push(data.route);
+    //   alert('1');
+    // } else if (data.type === 'order') {
+    //   // router.push(`/orders/${data.orderId}`);
+    //   alert('2');
+    // } else if (data.type === 'message') {
+    //   // router.push('/messages');
+    //   alert('3');
+    // } else {
+    //   // Default to notifications page
+    //   // router.push('/notifications');
+    //   alert('4');
+    // }
   },
 
   /**
@@ -268,7 +270,13 @@ const actions = {
         return;
       }
 
+      console.log('=== markAllAsRead API call ===');
+      console.log('URL:', `/api/notifications/user/${userId}/read-all`);
+      
       const response = await $axios.put(`/api/notifications/user/${userId}/read-all`);
+      
+      console.log('markAllAsRead response status:', response.status);
+      console.log('markAllAsRead response data:', response.data);
 
       // Update all notifications in local state
       state.notifications.forEach(notification => {
@@ -277,6 +285,7 @@ const actions = {
       });
 
       updateUnreadCount();
+      console.log('Local state updated, unread count:', state.unreadCount);
       return response.data;
     } catch (error) {
       setError(error);

package/src/modules/orders/components/partials/ShopCart.vue

@@ -17,7 +17,6 @@
       <!-- Empty State -->
       <p v-if="!(shopcart.state.positions.length > 0)" class="mn-t-medium"><i>{{t('emptystate')}}</i></p>
       <!-- Shopcart positions -->
-      <pre>{{shopcart.state.positions}}</pre>
       <CardOrderItem 
         v-for="(product, index) in shopcart.state.positions" 
         :key="`${product._id}_${product.variant || 'no-variant'}_${index}`"