@ozdao/martyrs 0.2.477 → 0.2.479

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

@@ -1,65 +1,52 @@
-// index.js
-// Import controllers
-const NotificationsController = require('./controllers/notifications.controller.js');
-
-// Import routes
-const notificationsRoutes = require('./routes/notifications.routes.js');
-
-// Import models
-const NotificationModel = require('./models/notification.model.js');
-const UserDeviceModel = require('./models/user-device.model.js');
-const NotificationPreferenceModel = require('./models/notification-preference.model.js');
-const NotificationLogModel = require('./models/notification-log.model.js');
-
-// Import ABAC policies
-const initNotificationPolicies = require('./middlewares/notifications.abac.js');
-
-// Import services
-const NotificationService = require('./services/notification.service.js');
-
-const { getInstance } = require('@martyrs/src/modules/globals/controllers/classes/globals.abac.js');
-
+import globalsabac from '@martyrs/src/modules/globals/controllers/classes/globals.abac.js';
+import NotificationsController from './controllers/notifications.controller.js';
+import NotificationLogModel from './models/notification-log.model.js';
+import NotificationPreferenceModel from './models/notification-preference.model.js';
+import NotificationModel from './models/notification.model.js';
+import UserDeviceModel from './models/user-device.model.js';
+import notificationsRoutes from './routes/notifications.routes.js';
+import NotificationService from './services/notification.service.js';
+const { getInstance } = globalsabac;
 function initializeNotifications(app, db, wss, origins, publicPath) {
   // Set up models in the database object
   db.notification = NotificationModel(db);
   db.userDevice = UserDeviceModel(db);
   db.notificationPreference = NotificationPreferenceModel(db);
   db.notificationLog = NotificationLogModel(db);
-
   const abac = getInstance(db);
   // const notificationPolicies = initNotificationPolicies(abac, db);
-
   // Set up routes if app is provided
   if (app) {
     notificationsRoutes(app, db, wss, origins, publicPath);
   }
-  
   // 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
 }
-
-// Export initialization function, controllers, routes, and models
-module.exports = {
+export const models = {
+  NotificationModel,
+  UserDeviceModel,
+  NotificationPreferenceModel,
+  NotificationLogModel,
+};
+export const routes = {
+  notificationsRoutes,
+};
+export const controllers = {
+  NotificationsController,
+};
+export const services = {
+  NotificationService,
+};
+export { initializeNotifications as initialize };
+export default {
   initialize: initializeNotifications,
-  models: {
-    NotificationModel,
-    UserDeviceModel,
-    NotificationPreferenceModel,
-    NotificationLogModel
-  },
-  routes: {
-    notificationsRoutes
-  },
-  controllers: {
-    NotificationsController
-  },
-  services: {
-    NotificationService
-  }
-};
+  models,
+  routes,
+  controllers,
+  services,
+};

package/src/modules/notifications/router/notifications.router.js

@@ -1,6 +1,6 @@
+import NotificationsLayout from '../components/layouts/NotificationsLayout.vue';
 import Notifications from '../components/pages/Notifications.vue';
 import NotificationPreferences from '../components/sections/NotificationPreferences.vue';
-import NotificationsLayout from '../components/layouts/NotificationsLayout.vue';
 
 const nofitications = {
   path: '/notifications',
@@ -12,8 +12,8 @@ const nofitications = {
       component: Notifications,
       meta: {
         // requiresAuth: true,
-        title: 'Notifications'
-      }
+        title: 'Notifications',
+      },
     },
     {
       path: 'preferences',
@@ -21,10 +21,10 @@ const nofitications = {
       component: NotificationPreferences,
       meta: {
         // requiresAuth: true,
-        title: 'Notification Preferences'
-      }
-    }
-  ]
+        title: 'Notification Preferences',
+      },
+    },
+  ],
 };
 
-export default nofitications;
+export default nofitications;

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

@@ -1,27 +1,20 @@
+import notifications from '../controllers/notifications.controller.js';
 // routes/notifications.routes.js
 const notificationsRoutes = (app, db, wss, origins, publicPath) => {
-  const controller = require('../controllers/notifications.controller')(db, wss);
-  
+  const controller = notifications(db, wss);
   // Get notifications for a user
   app.get('/api/notifications/user/:userId', controller.getUserNotifications);
-  
   // Create a new notification
   app.post('/api/notifications', controller.create);
-  
   // Mark notification as read
   app.put('/api/notifications/:id/read', controller.markAsRead);
-
-    // Mark all notifications as read for a user
+  // Mark all notifications as read for a user
   app.put('/api/notifications/user/:userId/read-all', controller.markAllAsRead);
-  
   // Register a device for push notifications
   app.post('/api/notifications/devices/register', controller.registerDevice);
-
   // Add this to routes/notifications.routes.js
   app.get('/api/notifications/preferences/:userId', controller.getUserPreferences);
-  
   // Update notification preferences
   app.put('/api/notifications/preferences', controller.updatePreferences);
 };
-
-module.exports = notificationsRoutes;
+export default notificationsRoutes;

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

@@ -1,8 +1,5 @@
-// services/push/apns.service.js
-const apn = require('apn');
-
+import apn from 'apn';
 let apnProvider = null;
-
 const getApnProvider = () => {
   if (!apnProvider) {
     apnProvider = new apn.Provider({
@@ -16,37 +13,31 @@ const getApnProvider = () => {
   }
   return apnProvider;
 };
-
 const ApnsService = {
   send: async ({ token, title, body, data = {} }) => {
     try {
       const provider = getApnProvider();
-      
       const notification = new apn.Notification();
       notification.expiry = Math.floor(Date.now() / 1000) + 3600; // Expires in 1 hour
       notification.badge = 1;
-      notification.sound = "ping.aiff";
+      notification.sound = 'ping.aiff';
       notification.alert = {
         title: title,
         body: body,
       };
       notification.topic = process.env.APN_BUNDLE_ID;
       notification.payload = data;
-      
       const result = await provider.send(notification, token);
-      
       // Check for sent/failed
       if (result.failed.length > 0) {
         const error = result.failed[0].response;
         throw new Error(`APNS send failed: ${error.reason}`);
       }
-      
       return { success: true, messageId: result.sent[0].headers['apns-id'] };
     } catch (error) {
       console.error('APNS service error:', error);
       throw error;
     }
-  }
+  },
 };
-
-module.exports = ApnsService;
+export default ApnsService;

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

@@ -1,25 +1,21 @@
+import mailing from '@martyrs/src/modules/globals/controllers/utils/mailing.js';
 // services/email.service.js
-const { sendEmail } = require('@martyrs/src/modules/globals/controllers/utils/mailing');
-
+const { sendEmail } = mailing;
 const EmailService = {
   send: async ({ to, subject, text, html, metadata = {} }) => {
     try {
       // Convert any attachments from metadata if present
       const files = metadata.attachments || [];
-      
       // Send email using the utility function
       const result = await sendEmail(to, subject, text, files);
-      
       if (!result) {
         throw new Error('Failed to send email');
       }
-      
       return { success: true, messageId: Date.now().toString() };
     } catch (error) {
       console.error('Email service error:', error);
       throw error;
     }
-  }
+  },
 };
-
-module.exports = EmailService;
+export default EmailService;

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

@@ -1,7 +1,5 @@
-// services/push/fcm.service.js
-const admin = require('firebase-admin');
-const path = require('path');
-
+import admin from 'firebase-admin';
+import path from 'path';
 // Initialize Firebase Admin SDK if not already initialized
 if (!admin.apps.length) {
   admin.initializeApp({
@@ -12,7 +10,6 @@ if (!admin.apps.length) {
     // Optional: databaseURL, storageBucket, etc.
   });
 }
-
 const FcmService = {
   send: async ({ token, title, body, data = {} }) => {
     try {
@@ -28,7 +25,6 @@ const FcmService = {
         }, {}),
         token,
       };
-
       const response = await admin.messaging().send(message);
       return { success: true, messageId: response };
     } catch (error) {
@@ -36,7 +32,6 @@ const FcmService = {
       throw error;
     }
   },
-  
   sendMulticast: async ({ tokens, title, body, data = {} }) => {
     try {
       const message = {
@@ -51,7 +46,6 @@ const FcmService = {
         }, {}),
         tokens,
       };
-
       const response = await admin.messaging().sendMulticast(message);
       return {
         success: true,
@@ -63,7 +57,6 @@ const FcmService = {
       console.error('FCM multicast service error:', error);
       throw error;
     }
-  }
+  },
 };
-
-module.exports = FcmService;
+export default FcmService;

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

@@ -1,37 +1,34 @@
-const ObjectId = require('mongoose').Types.ObjectId;
-
-module.exports = function(db, wss) {
+import { Types } from 'mongoose';
+import apns from './apns.service.js';
+import emailService from './email.service.js';
+import fcm from './fcm.service.js';
+import smsService from './sms.service.js';
+import telegramService from './telegram.service.js';
+import webPush from './web-push.service.js';
+import whatsappService from './whatsapp.service.js';
+const ObjectId = { Types }.Types.ObjectId;
+export default (function (db, wss) {
   wss.registerModule('notification', async (ws, msg) => {
     console.log('[WebSocket][notification] msg:', msg);
   });
-
-
   // Process and route notification to appropriate channels
-  const processNotification = async (notification) => {
+  const processNotification = async notification => {
     try {
       const userId = notification.userId.toString();
-      
       // Get user preferences
-      const preferences = await db.notificationPreference.find({ 
+      const preferences = await db.notificationPreference.find({
         userId: userId,
         // notificationType: notification.type
       });
-
-      console.log('userId', userId)
-
-      console.log('preferences', preferences)
-
-      console.log('notificationType', notification.type)
-
-      console.log('notification', notification)
-
+      console.log('userId', userId);
+      console.log('preferences', preferences);
+      console.log('notificationType', notification.type);
+      console.log('notification', notification);
       // Get user data
       const user = await db.mongoose.model('User').findById(new ObjectId(userId));
-
       if (!user) {
         throw new Error(`User not found: ${userId}`);
       }
-
       // Create a channel router map
       const channelRouters = {
         web: sendWebNotification,
@@ -41,36 +38,26 @@ module.exports = function(db, wss) {
         // telegram: sendTelegramNotification,
         // whatsapp: sendWhatsAppNotification
       };
-
       // Get all active devices for push notifications
-      const userDevices = await db.userDevice.find({ 
-        userId, 
-        isActive: true 
+      const userDevices = await db.userDevice.find({
+        userId,
+        isActive: true,
       });
-
       // Default channels if no preferences set
       let channels = ['web']; // Web is always on by default
-      
       // If user has email, add it to default channels
       if (user.email) {
         channels.push('email');
       }
-      
       // If user has phone, add SMS to default channels
       if (user.phoneNumber) {
         channels.push('sms');
       }
-
       // Override with user preferences if they exist
       if (preferences.length > 0) {
-        channels = preferences
-          .filter(pref => pref.isEnabled)
-          .map(pref => pref.channelType);
+        channels = preferences.filter(pref => pref.isEnabled).map(pref => pref.channelType);
       }
-
-
-      console.log('channels', channels)
-
+      console.log('channels', channels);
       // Send to each enabled channel
       for (const channel of channels) {
         const sendFunc = channelRouters[channel];
@@ -84,24 +71,21 @@ module.exports = function(db, wss) {
             } else {
               await sendFunc(notification, user);
             }
-            
             // Update notification status
-            await db.notification.findByIdAndUpdate(
-              notification._id,
-              { status: 'sent', updatedAt: Date.now() }
-            );
-            
+            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()
+              sentAt: Date.now(),
             });
           } catch (error) {
             console.error(`Error sending ${channel} notification:`, error);
-            
             // Log the failed notification
             await db.notificationLog.create({
               notificationId: notification._id,
@@ -109,114 +93,95 @@ module.exports = function(db, wss) {
               channelType: channel,
               status: 'failed',
               error: error.message,
-              sentAt: Date.now()
+              sentAt: Date.now(),
             });
           }
         }
       }
     } catch (error) {
       console.error('Error processing notification:', error);
-      
       // Update notification status to failed
-      await db.notification.findByIdAndUpdate(
-        notification._id,
-        { status: 'failed', updatedAt: Date.now() }
-      );
+      await db.notification.findByIdAndUpdate(notification._id, {
+        status: 'failed',
+        updatedAt: Date.now(),
+      });
     }
   };
-
-   // Send websocket notifications
+  // Send websocket notifications
   const sendWebNotification = async (notification, user) => {
     console.log(`[WebSocket][notification] sending to user ${user._id}`);
     const result = await wss.sendToUserInModule('notification', user._id, {
       type: 'notification',
-      data: notification
+      data: notification,
     });
     if (!result) {
       console.log(`Failed to send web notification to user ${user._id}`);
     }
   };
-  
   // Send push notification to mobile device
   const sendPushNotification = async (notification, user, device) => {
-
     const pushService = getPushServiceByDeviceType(device.deviceType);
-    
     return pushService.send({
       token: device.deviceToken,
       title: notification.title,
       body: notification.body,
-      data: notification.metadata
+      data: notification.metadata,
     });
   };
-
   // Get the appropriate push service based on device type
-  const getPushServiceByDeviceType = (deviceType) => {
+  const getPushServiceByDeviceType = deviceType => {
     if (deviceType === 'ios') {
-      return require('./apns.service');
+      return apns;
     } else if (deviceType === 'android') {
-      return require('./fcm.service');
+      return fcm;
     } else {
-      return require('./web-push.service');
+      return webPush;
     }
   };
-
   // Send email notification
   const sendEmailNotification = async (notification, user) => {
-    // Implementation would depend on your email service provider
-    const emailService = require('./email.service');
     return emailService.send({
       to: user.email,
       subject: notification.title,
       text: notification.body,
       html: `<h1>${notification.title}</h1><p>${notification.body}</p>`,
-      metadata: notification.metadata
+      metadata: notification.metadata,
     });
   };
-
   // Send SMS notification
   const sendSmsNotification = async (notification, user) => {
-    // Implementation would depend on your SMS service provider
-    const smsService = require('./sms.service');
     return smsService.send({
       to: user.phoneNumber,
-      message: `${notification.title}: ${notification.body}`
+      message: `${notification.title}: ${notification.body}`,
     });
   };
-
   // Send Telegram notification (for future expansion)
   const sendTelegramNotification = async (notification, user) => {
-    // Implementation would depend on your Telegram Bot setup
-    const telegramService = require('./telegram.service');
     return telegramService.send({
       chatId: user.telegramChatId,
-      message: `${notification.title}\n\n${notification.body}`
+      message: `${notification.title}\n\n${notification.body}`,
     });
   };
-
   // Send WhatsApp notification (for future expansion)
   const sendWhatsAppNotification = async (notification, user) => {
-    // Implementation would depend on your WhatsApp Business API setup
-    const whatsappService = require('./whatsapp.service');
     return whatsappService.send({
       to: user.phoneNumber,
-      message: `${notification.title}\n\n${notification.body}`
+      message: `${notification.title}\n\n${notification.body}`,
     });
   };
-
   // Batch process pending notifications
   const processPendingNotifications = async () => {
-    const pendingNotifications = await db.notification.find({
-      status: 'pending'
-    }).limit(100);
-    
+    const pendingNotifications = await db.notification
+      .find({
+        status: 'pending',
+      })
+      .limit(100);
     for (const notification of pendingNotifications) {
       await processNotification(notification);
     }
   };
-
   return {
     processNotification,
-    processPendingNotifications
+    processPendingNotifications,
   };
-};
+});

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

@@ -1,22 +1,19 @@
+import mailing from '@martyrs/src/modules/globals/controllers/utils/mailing.js';
 // services/sms.service.js
-const { sendSms } = require('@martyrs/src/modules/globals/controllers/utils/mailing');
-
+const { sendSms } = mailing;
 const SmsService = {
   send: async ({ to, message }) => {
     try {
       // Send SMS using the utility function
       const result = await sendSms(to, message);
-      
       if (!result) {
         throw new Error('Failed to send SMS');
       }
-      
       return { success: true, messageId: Date.now().toString() };
     } catch (error) {
       console.error('SMS service error:', error);
       throw error;
     }
-  }
+  },
 };
-
-module.exports = SmsService;
+export default SmsService;

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

@@ -1,23 +1,20 @@
+import mailing from '@martyrs/src/modules/globals/controllers/utils/mailing.js';
 // services/telegram.service.js
-const { sendChatMessageTelegram } = require('@martyrs/src/modules/globals/controllers/utils/mailing');
-
+const { sendChatMessageTelegram } = mailing;
 const TelegramService = {
   send: async ({ chatId, message }) => {
     try {
       // Send Telegram message using the utility function
       // Note: our utility expects an array of chatIds
       const result = await sendChatMessageTelegram([chatId], message);
-      
       if (!result) {
         throw new Error('Failed to send Telegram message');
       }
-      
       return { success: true, messageId: Date.now().toString() };
     } catch (error) {
       console.error('Telegram service error:', error);
       throw error;
     }
-  }
+  },
 };
-
-module.exports = TelegramService;
+export default TelegramService;

package/src/modules/notifications/services/web-push.service.js

@@ -1,40 +1,31 @@
-// services/push/web-push.service.js
-const webpush = require('web-push');
-
+import webpush from 'web-push';
 // Configure web push with VAPID keys
-webpush.setVapidDetails(
-  `mailto:${process.env.VAPID_EMAIL}`,
-  process.env.VAPID_PUBLIC_KEY,
-  process.env.VAPID_PRIVATE_KEY
-);
-
+webpush.setVapidDetails(`mailto:${process.env.VAPID_EMAIL}`, process.env.VAPID_PUBLIC_KEY, process.env.VAPID_PRIVATE_KEY);
 const WebPushService = {
   send: async ({ token, title, body, data = {} }) => {
     try {
       // Parse the subscription object from the token
       const subscription = JSON.parse(token);
-          console.log('title is', title)
-          console.log('body is', body)
-             console.log('data is', data)
+      console.log('title is', title);
+      console.log('body is', body);
+      console.log('data is', data);
       // Prepare the notification payload
       const payload = JSON.stringify({
-          title: title,
-          body: body,
-          icon: process.env.NOTIFICATION_ICON_URL || '/favicon.ico',
-          badge: process.env.NOTIFICATION_BADGE_URL || '/favicon.ico',
-          data: data
+        title: title,
+        body: body,
+        icon: process.env.NOTIFICATION_ICON_URL || '/favicon.ico',
+        badge: process.env.NOTIFICATION_BADGE_URL || '/favicon.ico',
+        data: data,
       });
-      console.log('payload is', payload)
-
+      console.log('payload is', payload);
       // Send the notification
       const result = await webpush.sendNotification(subscription, payload);
-      console.log('web push is', result)
+      console.log('web push is', result);
       return { success: true, statusCode: result.statusCode };
     } catch (error) {
       console.error('Web Push service error:', error);
       throw error;
     }
-  }
+  },
 };
-
-module.exports = WebPushService;
+export default WebPushService;