@ozdao/martyrs 0.2.468 → 0.2.470

package/src/modules/globals/views/classes/globals.websocket.js

@@ -1,7 +1,3 @@
-/**
- * Global WebSocket handler for centralized WebSocket connections
- * @martyrs/src/modules/globals/views/classes/globals.websocket.js
- */
 class GlobalWebSocket {
   constructor() {
     this.socket = null;
@@ -11,16 +7,13 @@ class GlobalWebSocket {
     this.reconnectDelay = 3000;
     this.baseUrl = null;
     this.pingInterval = null;
-    this.pingIntervalTime = 30000; // 30 seconds
+    this.pingIntervalTime = 30000;
     this.listeners = {};
     this.userId = null;
     this.connectPromise = null;
+    this.subscribedModules = new Set(); // <--- ключевое изменение
   }
 
-  /**
-   * Initialize WebSocket with configuration options
-   * @param {Object} options - Configuration options
-   */
   initialize(options = {}) {
     this.maxReconnectAttempts = options.maxReconnectAttempts || this.maxReconnectAttempts;
     this.reconnectDelay = options.reconnectDelay || this.reconnectDelay;
@@ -28,67 +21,39 @@ class GlobalWebSocket {
     this.pingIntervalTime = options.pingInterval || this.pingIntervalTime;
   }
 
-  /**
-   * Get default WebSocket URL based on current HTTP URL
-   * @returns {String} WebSocket URL
-   */
   _getDefaultWsUrl() {
-    // Check if window exists (for SSR compatibility)
-    if (typeof window === 'undefined') {
-      return '/api/ws'; // Default fallback for SSR
-    }
-    
+    if (typeof window === 'undefined') return '/api/ws';
     const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
     const host = window.location.host;
     return `${protocol}//${host}/api/ws`;
   }
 
-  /**
-   * Connect to WebSocket server
-   * @param {String} userId - User ID for authentication
-   * @returns {Promise} Promise that resolves when connection is established
-   */
   connect(userId) {
-    // Skip if running in SSR
-    if (typeof window === 'undefined') {
-      return Promise.resolve(false);
-    }
-
-    // Always update userId before any connection logic
+    if (typeof window === 'undefined') return Promise.resolve(false);
     this.userId = userId;
 
-    // If already connected with the same user and socket is valid, return the existing connection
-    if (this.isConnected && this.socket && this.socket.readyState === WebSocket.OPEN) {
+    if (this.isConnected && this.socket?.readyState === WebSocket.OPEN) {
       return Promise.resolve(this.socket);
     }
 
-    // Clear any existing connection promise to avoid conflicts
-    this.connectPromise = null;
-
-    // Create new connection promise
     this.connectPromise = new Promise((resolve, reject) => {
-      // Close existing connection if any
       this.disconnect();
 
-      // Create new WebSocket connection with user ID
       const wsUrl = userId ? `${this.baseUrl}?userId=${encodeURIComponent(userId)}` : this.baseUrl;
       this.socket = new WebSocket(wsUrl);
 
-      // Setup event handlers
       this.socket.onopen = () => {
         this._handleOpen();
         resolve(this.socket);
       };
-      
+
       this.socket.onmessage = this._handleMessage.bind(this);
-      this.socket.onerror = (error) => {
-        this._handleError(error);
-        reject(error);
+      this.socket.onerror = (err) => {
+        this._handleError(err);
+        reject(err);
       };
-      
       this.socket.onclose = this._handleClose.bind(this);
 
-      // Timeout for connection
       setTimeout(() => {
         if (!this.isConnected) {
           reject(new Error('WebSocket connection timeout'));
@@ -101,32 +66,20 @@ class GlobalWebSocket {
     return this.connectPromise;
   }
 
-  /**
-   * Disconnect from WebSocket server
-   */
   disconnect() {
-    // Skip if running in SSR
-    if (typeof window === 'undefined') {
-      return;
-    }
+    if (typeof window === 'undefined') return;
 
     if (this.socket) {
-      // Remove event listeners
       this.socket.onopen = null;
       this.socket.onmessage = null;
       this.socket.onerror = null;
       this.socket.onclose = null;
-      
-      // Close connection
-      if (this.socket.readyState === WebSocket.OPEN || 
-          this.socket.readyState === WebSocket.CONNECTING) {
+      if (this.socket.readyState === WebSocket.OPEN || this.socket.readyState === WebSocket.CONNECTING) {
         this.socket.close();
       }
-      
       this.socket = null;
     }
 
-    // Clear ping interval
     if (this.pingInterval) {
       clearInterval(this.pingInterval);
       this.pingInterval = null;
@@ -136,11 +89,6 @@ class GlobalWebSocket {
     this.userId = null;
   }
 
-  /**
-   * Send data through WebSocket
-   * @param {Object|String} data - Data to send
-   * @returns {Boolean} Success status
-   */
   async send(data) {
     if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
       console.error('Cannot send message: WebSocket is not connected');
@@ -148,51 +96,29 @@ class GlobalWebSocket {
     }
 
     try {
-      const message = typeof data === 'string' ? data : JSON.stringify(data);
-      await this.socket.send(message);
+      const msg = typeof data === 'string' ? data : JSON.stringify(data);
+      this.socket.send(msg);
       return true;
-    } catch (error) {
-      console.error('Error sending WebSocket message:', error);
+    } catch (err) {
+      console.error('Error sending message:', err);
       return false;
     }
   }
 
-  /**
-   * Register an event listener
-   * @param {String} eventType - Event type to listen for
-   * @param {Function} callback - Callback function
-   * @param {Object} options - Additional options like module name for namespacing
-   * @returns {String} Listener ID for unregistering
-   */
   addEventListener(eventType, callback, options = {}) {
     const listenerId = `${options.module || 'global'}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    
-    if (!this.listeners[eventType]) {
-      this.listeners[eventType] = {};
-    }
-    
+    if (!this.listeners[eventType]) this.listeners[eventType] = {};
     this.listeners[eventType][listenerId] = callback;
     return listenerId;
   }
 
-  /**
-   * Remove an event listener
-   * @param {String} eventType - Event type
-   * @param {String} listenerId - Listener ID returned from addEventListener
-   */
   removeEventListener(eventType, listenerId) {
-    if (this.listeners[eventType] && this.listeners[eventType][listenerId]) {
+    if (this.listeners[eventType]?.[listenerId]) {
       delete this.listeners[eventType][listenerId];
     }
   }
 
-  /**
-   * Remove all listeners for a module
-   * @param {String} moduleName - Module name to remove listeners for
-   */
   removeModuleListeners(moduleName) {
-    if (!moduleName) return;
-    
     Object.keys(this.listeners).forEach(eventType => {
       Object.keys(this.listeners[eventType]).forEach(listenerId => {
         if (listenerId.startsWith(`${moduleName}_`)) {
@@ -202,111 +128,85 @@ class GlobalWebSocket {
     });
   }
 
-  /**
-   * Handle WebSocket open event
-   */
+  async subscribeModule(moduleName) {
+    if (!moduleName || this.subscribedModules.has(moduleName)) return;
+    const success = await this.send({ type: 'subscribe', module: moduleName });
+    if (success) {
+      this.subscribedModules.add(moduleName);
+    }
+  }
+
+  _resubscribeAllModules() {
+    for (const moduleName of this.subscribedModules) {
+      this.send({ type: 'subscribe', module: moduleName });
+    }
+  }
+
   _handleOpen() {
     this.isConnected = true;
     this.reconnectAttempts = 0;
-    
-    // Setup ping interval to keep connection alive
+
     this.pingInterval = setInterval(() => {
-      if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+      if (this.socket?.readyState === WebSocket.OPEN) {
         this.socket.send(JSON.stringify({ type: 'ping' }));
       }
     }, this.pingIntervalTime);
 
-    // Notify listeners
+    this._resubscribeAllModules(); // <--- ВАЖНО
     this._notifyListeners('open', { isConnected: true });
   }
 
-  /**
-   * Handle WebSocket message event
-   * @param {Event} event - WebSocket message event
-   */
   _handleMessage(event) {
     try {
       const data = JSON.parse(event.data);
-      
-      // Generic event notifications
       this._notifyListeners('message', data);
-      
-      // Specific event type notifications
       if (data.type) {
         this._notifyListeners(data.type, data);
       }
-      
-    } catch (error) {
-      console.error('Error processing WebSocket message:', error);
+    } catch (err) {
+      console.error('WebSocket message error:', err);
     }
   }
 
-  /**
-   * Handle WebSocket error
-   * @param {Error} error - WebSocket error
-   */
   _handleError(error) {
     console.error('WebSocket error:', error);
     this._notifyListeners('error', { error });
   }
 
-  /**
-   * Handle WebSocket close event
-   * @param {Event} event - WebSocket close event
-   */
   _handleClose(event) {
     this.isConnected = false;
-    
-    // Clear ping interval
     if (this.pingInterval) {
       clearInterval(this.pingInterval);
       this.pingInterval = null;
     }
-    
+
     this._notifyListeners('close', { code: event.code, reason: event.reason });
-    
-    // Attempt to reconnect if not a normal closure and we have a userId
+
     if (event.code !== 1000 && this.userId && this.reconnectAttempts < this.maxReconnectAttempts) {
       this.reconnectAttempts++;
       const delay = this.reconnectDelay * this.reconnectAttempts;
-      
       setTimeout(() => {
-        if (this.userId) {
-          this.connect(this.userId).catch(error => {
-            console.error('Reconnection failed:', error);
-          });
-        }
+        this.connect(this.userId).catch(err => {
+          console.error('Reconnection failed:', err);
+        });
       }, delay);
     }
   }
 
-  /**
-   * Notify event listeners
-   * @param {String} eventType - Event type
-   * @param {Object} data - Event data
-   */
   _notifyListeners(eventType, data) {
-    if (!this.listeners[eventType]) return;
-    
-    Object.values(this.listeners[eventType]).forEach(callback => {
+    Object.values(this.listeners[eventType] || {}).forEach(fn => {
       try {
-        callback(data);
-      } catch (error) {
-        console.error(`Error in WebSocket ${eventType} listener:`, error);
+        fn(data);
+      } catch (err) {
+        console.error(`Listener for ${eventType} failed:`, err);
       }
     });
   }
 
-  /**
-   * Get connection status
-   * @returns {Boolean} Connection status
-   */
   isSocketConnected() {
     return this.isConnected && this.socket?.readyState === WebSocket.OPEN;
   }
 }
 
-// Create singleton instance
 const globalWebSocket = new GlobalWebSocket();
-
-export default globalWebSocket;
+export default globalWebSocket;

package/src/modules/icons/skeletons/SkeletonBlogpost.vue

@@ -1,7 +1,7 @@
 <template>
   <svg width="100%" height="20rem" xmlns="http://www.w3.org/2000/svg">
     <!-- Фоновый прямоугольник для всей карточки -->
-    <rect x="0" y="0" rx="5" ry="5" width="100%" height="100%" fill="rgb(var(--white))"/>
+    <rect x="0" y="0" rx="5" ry="5" width="100%" height="100%" fill="rgb(var(--light))"/>
     
     <!-- Имитация шапки карточки -->
     <rect x="15" y="15" rx="4" ry="4" width="40%" height="20" fill="rgba(var(--black),0.05)"></rect>
@@ -14,7 +14,7 @@
     <rect x="15" y="130" rx="3" ry="3" width="70%" height="6" fill="rgba(var(--black),0.05)"></rect>
     
     <!-- Блик с анимацией движения -->
-    <rect x="-25%" y="0" width="25%" height="100%" fill="rgb(var(--white))" mask="url(#myMask)" opacity="0.3">
+    <rect x="-25%" y="0" width="25%" height="100%" fill="rgb(var(--light))" mask="url(#myMask)" opacity="0.3">
       <animate attributeName="x" from="-25%" to="100%" dur="2s" repeatCount="indefinite"></animate>
     </rect>
   </svg>

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

@@ -1,12 +1,12 @@
 // controllers/notifications.controller.js
-const NotificationsController = (db) => {
+const NotificationsController = (db, wss) => {
   // Create a new notification
   const create = async (req, res) => {
     try {
       const notification = await db.notification.create(req.body);
       
       // Trigger notification sending process
-      const notificationService = require('../services/notification.service')(db);
+      const notificationService = require('../services/notification.service')(db, wss);
       notificationService.processNotification(notification);
       
       return res.status(201).json(notification);

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

@@ -178,6 +178,7 @@ class CapacitorPushHandler {
 /**
  * Notification Manager for coordinating WebSocket and Push notifications
  */
+
 class NotificationManager {
   constructor(store, options = {}) {
     this.store = store;
@@ -187,45 +188,82 @@ class NotificationManager {
     this.isServer = typeof window === 'undefined';
   }
 
-  /**
-   * Initialize notifications
-   */
+  async registerWebPush(store) {
+    if (!('Notification' in window) || !('serviceWorker' in navigator) || !('PushManager' in window)) {
+      console.warn('Web Push не поддерживается в браузере');
+      return;
+    }
+
+    const permission = await Notification.requestPermission();
+    if (permission !== 'granted') {
+      console.warn('Разрешение на уведомления не получено');
+      return;
+    }
+
+    const registration = await navigator.serviceWorker.register('/sw.js');
+    const subscription = await registration.pushManager.subscribe({
+      userVisibleOnly: true,
+      applicationServerKey: 'BJtNnRrx05VQS0abnkHC-8gHJWpnmoqC_iQveENCmZOZIs-adWzqAiqFCdGVVd7CbiaLW-Q5iuIBDRgM9G-VnKg'
+    });
+
+    console.log('New subscription:', JSON.stringify(subscription));
+
+    // Отправь подписку на сервер
+    await store.notifications.actions.registerDevice({
+      deviceToken: JSON.stringify(subscription),
+      deviceType: 'web'
+    });
+  }
+
   async initialize() {
     if (this.initialized || this.isServer) return;
-    
-    // Get current user ID from auth store instead of localStorage
+
     const userId = this.store.auth.state.user?._id;
     if (!userId) {
       console.warn('Cannot initialize notifications: No user ID found in auth store');
       return;
     }
-    
-    // Initialize WebSocket for realtime notifications
+
+    console.log('Connecting to websockets via notifications')
     await globalWebSocket.connect(userId);
-    
-    // Initialize push notifications for mobile if enabled
+
+    globalWebSocket.removeModuleListeners('notification');
+
+    await globalWebSocket.subscribeModule('notification');
+
+    globalWebSocket.addEventListener(
+      'notification',
+      (data) => {
+        this.store.notifications.actions.addLocalNotification(data.data);
+      },
+      { module: 'notification' }
+    );
+
+
+
+    // 🎯 Опционально включаем push
     if (this.options.enablePush !== false) {
       await this.pushHandler.requestPermissions();
+      await this.registerWebPush(this.store)
     }
-    
+
     this.initialized = true;
-    
-    // Fetch existing notifications
+
+    // ✅ Загружаем список уведомлений из API
     await this.store.notifications.actions.getNotifications(userId);
   }
 
-  /**
-   * Disconnect and clean up
-   */
   disconnect() {
     if (this.isServer) return;
-    
-    globalWebSocket.removeModuleListeners('notifications');
+
+    globalWebSocket.removeModuleListeners('notification');
     this.pushHandler.removeListeners();
     this.initialized = false;
   }
 }
 
+
+
 /**
  * Server-side utility for pre-fetching notification data
  */
@@ -283,7 +321,7 @@ function initializeNotifications(app, store, router, options = {}) {
   
   if (autoInit) {
     // Initialize after auth is confirmed
-    const isAuthenticated = store.auth.state.isAuthenticated;
+    const isAuthenticated = store.auth.state.access.status;
     const userId = store.auth.state.user?._id;
     
     if (isAuthenticated && userId) {
@@ -291,7 +329,7 @@ function initializeNotifications(app, store, router, options = {}) {
     }
     
     // Watch for user login/logout using auth store
-    watch(() => store.auth.state.isAuthenticated, (isAuthenticated) => {
+    watch(() => store.auth.state.access.status, (isAuthenticated) => {
       if (isAuthenticated) {
         notificationManager.initialize();
       } else {

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

@@ -20,6 +20,7 @@ const NotificationService = require('./services/notification.service.js');
 const { getInstance } = require('@martyrs/src/modules/globals/controllers/classes/globals.abac.js');
 
 function initializeNotifications(app, db, wss, origins, publicPath) {
+  console.log('wss init is', wss)
   // Set up models in the database object
   db.notification = NotificationModel(db);
   db.userDevice = UserDeviceModel(db);
@@ -31,11 +32,12 @@ function initializeNotifications(app, db, wss, origins, publicPath) {
 
   // Set up routes if app is provided
   if (app) {
-    notificationsRoutes(app, db, origins, publicPath);
+    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(() => {

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

@@ -1,6 +1,6 @@
 // routes/notifications.routes.js
-const notificationsRoutes = (app, db, origins, publicPath) => {
-  const controller = require('../controllers/notifications.controller')(db);
+const notificationsRoutes = (app, db, wss, origins, publicPath) => {
+  const controller = require('../controllers/notifications.controller')(db, wss);
   
   // Get notifications for a user
   app.get('/api/notifications/user/:userId', controller.getUserNotifications);

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

@@ -1,18 +1,33 @@
-// services/notification.service.js
-const NotificationService = (db, wss) => {
+const ObjectId = require('mongoose').Types.ObjectId;
+
+module.exports = 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) => {
     try {
-      const userId = notification.userId;
+      const userId = notification.userId.toString();
       
       // Get user preferences
       const preferences = await db.notificationPreference.find({ 
-        userId,
-        notificationType: notification.type
+        userId: userId,
+        // notificationType: notification.type
       });
 
+      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(userId);
+      const user = await db.mongoose.model('User').findById(new ObjectId(userId));
+
       if (!user) {
         throw new Error(`User not found: ${userId}`);
       }
@@ -53,6 +68,9 @@ const NotificationService = (db, wss) => {
           .map(pref => pref.channelType);
       }
 
+
+      console.log('channels', channels)
+
       // Send to each enabled channel
       for (const channel of channels) {
         const sendFunc = channelRouters[channel];
@@ -107,20 +125,23 @@ const NotificationService = (db, wss) => {
     }
   };
 
-  // Send web notification (for real-time notifications via WebSocket/SSE)
-  // const webSocketService = require('./websocket.service')(wss);
-  
+   // Send websocket notifications
   const sendWebNotification = async (notification, user) => {
-    return wss.sendToUserInModule('notification', user._id, {
+    console.log(`[WebSocket][notification] sending to user ${user._id}`);
+    const result = await wss.sendToUserInModule('notification', user._id, {
       type: '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) => {
-    // Implementation would depend on your push notification provider (Firebase, APN, etc.)
+
     const pushService = getPushServiceByDeviceType(device.deviceType);
+    
     return pushService.send({
       token: device.deviceToken,
       title: notification.title,
@@ -136,7 +157,7 @@ const NotificationService = (db, wss) => {
     } else if (deviceType === 'android') {
       return require('./fcm.service');
     } else {
-      // return require('./web-push.service');
+      return require('./web-push.service');
     }
   };
 
@@ -198,6 +219,4 @@ const NotificationService = (db, wss) => {
     processNotification,
     processPendingNotifications
   };
-};
-
-module.exports = NotificationService;
+};

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

@@ -13,21 +13,22 @@ const WebPushService = {
     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)
       // Prepare the notification payload
       const payload = JSON.stringify({
-        notification: {
           title: title,
           body: body,
           icon: process.env.NOTIFICATION_ICON_URL || '/favicon.ico',
-          badge: process.env.NOTIFICATION_BADGE_URL,
+          badge: process.env.NOTIFICATION_BADGE_URL || '/favicon.ico',
           data: data
-        }
       });
-      
+      console.log('payload is', payload)
+
       // Send the notification
       const result = await webpush.sendNotification(subscription, payload);
-      
+      console.log('web push is', result)
       return { success: true, statusCode: result.statusCode };
     } catch (error) {
       console.error('Web Push service error:', error);