@ozdao/martyrs 0.2.469 → 0.2.471

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

@@ -1,256 +0,0 @@
-  import { watch, toRefs } from "vue";
-import routerNotifications from './router/notifications.router.js';
-import * as storeNotifications from './store/notifications.store.js';
-import * as auth from '@martyrs/src/modules/auth/views/store/auth';
-import globalWebSocket from '@martyrs/src/modules/globals/views/classes/globals.websocket.js';
-import NotificationsLayout from './components/layouts/NotificationsLayout.vue';
-import NotificationsList from './components/sections/NotificationsList.vue';
-import NotificationPreferences from './components/sections/NotificationPreferences.vue';
-import Notifications from './components/pages/Notifications.vue';
-import NotificationBadge from './components/elements/NotificationBadge.vue';
-import NotificationItem from './components/blocks/NotificationItem.vue';
-
-// WebSocket notification handlers
-const wsNotificationHandlers = {
-  connect: (store, userId, options = {}) => {
-    if (typeof window === 'undefined' || !userId) return Promise.resolve(false);
-    
-    return globalWebSocket.connect(userId).then(() => {
-      const moduleName = 'notifications';
-      const listeners = [];
-
-      const addListener = (event, handler) => {
-        listeners.push(globalWebSocket.addEventListener(event, handler, { module: moduleName }));
-      };
-
-      addListener('notification', (data) => {
-        if (!data || !data.data) return;
-        const notification = data.data;
-        
-        store.notifications.actions.addLocalNotification({
-          _id: notification._id,
-          title: notification.title,
-          body: notification.body,
-          type: notification.type || 'info',
-          metadata: notification.metadata || {},
-          status: 'unread',
-          createdAt: notification.createdAt || new Date().toISOString(),
-          updatedAt: notification.updatedAt || new Date().toISOString()
-        });
-      });
-
-      addListener('notification_read', (data) => {
-        store.notifications.actions.syncNotificationStatus(data.notificationId, 'read');
-      });
-
-      return { listeners, moduleName };
-    });
-  },
-
-  disconnect: (moduleName, listeners) => {
-    if (listeners) {
-      globalWebSocket.removeModuleListeners(moduleName);
-    }
-  }
-};
-
-// Capacitor Push Notification handlers
-const pushNotificationHandlers = {
-  initialize: async () => {
-    if (typeof window === 'undefined') return false;
-
-    try {
-      const { Capacitor } = await import('@capacitor/core');
-      const { PushNotifications } = await import('@capacitor/push-notifications');
-      const { Device } = await import('@capacitor/device');
-
-      if (!Capacitor.isNativePlatform()) return false;
-
-      return { pushNotifications: PushNotifications, device: Device };
-    } catch (error) {
-      console.error('Error importing Capacitor plugins:', error);
-      return false;
-    }
-  },
-
-  requestPermissions: async (store) => {
-    if (typeof window === 'undefined') return false;
-
-    const plugins = await pushNotificationHandlers.initialize();
-    if (!plugins) return false;
-
-    const { pushNotifications, device } = plugins;
-
-    const permissionResult = await pushNotifications.requestPermissions();
-    if (permissionResult.receive !== 'granted') {
-      console.log('Push notification permission denied');
-      return false;
-    }
-
-    const setupListeners = () => {
-      pushNotifications.addListener('registration', async (token) => {
-        try {
-          const deviceInfo = await device.getInfo();
-          const deviceId = await device.getId();
-
-          const deviceData = {
-            deviceId: deviceId.uuid,
-            deviceType: deviceInfo.platform.toLowerCase(),
-            deviceToken: token.value
-          };
-
-          await store.notifications.actions.registerDevice(deviceData);
-        } catch (error) {
-          console.error('Error handling push registration:', error);
-        }
-      });
-
-      pushNotifications.addListener('pushNotificationReceived', (notification) => {
-        store.notifications.actions.addLocalNotification({
-          title: notification.title,
-          body: notification.body,
-          data: notification.data || {}
-        });
-      });
-
-      pushNotifications.addListener('pushNotificationActionPerformed', (actionData) => {
-        if (actionData.notification && actionData.notification.data) {
-          store.notifications.actions.handleNotificationAction(actionData.notification.data);
-        }
-      });
-    };
-
-    setupListeners();
-    await pushNotifications.register();
-    return true;
-  },
-
-  removeListeners: (pushNotifications) => {
-    if (typeof window === 'undefined' || !pushNotifications) return;
-    pushNotifications.removeAllListeners();
-  }
-};
-
-// Notification utilities
-const notificationUtils = {
-  initialize: async (store, options = {}) => {
-    if (typeof window === 'undefined') return;
-
-    const userId = store.auth.state.user?._id;
-    if (!userId) {
-      console.warn('Cannot initialize notifications: No user ID found in auth store');
-      return;
-    }
-
-    let wsListeners = null;
-    if (options.enablePush !== false) {
-      await pushNotificationHandlers.requestPermissions(store);
-    }
-
-    wsListeners = await wsNotificationHandlers.connect(store, userId, options);
-
-    await store.notifications.actions.getNotifications(userId);
-
-    return {
-      disconnect: () => {
-        wsNotificationHandlers.disconnect(wsListeners?.moduleName, wsListeners?.listeners);
-        pushNotificationHandlers.removeListeners(globalThis.pushNotifications);
-      }
-    };
-  },
-
-  prefetchForSSR: async (store, context) => {
-    try {
-      const userId = store.auth.state.user?._id;
-      if (userId) {
-        await store.notifications.actions.getNotifications(userId);
-      }
-    } catch (error) {
-      console.error('Error pre-fetching notifications for SSR:', error);
-    }
-  }
-};
-
-// Main initialization function
-const initializeNotifications = (app, store, router, options = {}) => {
-  const route = options.route || 'User Profile Root';
-  router.addRoute(route, routerNotifications);
-  store.addStore('notifications', storeNotifications);
-
-  if (options.wsUrl) {
-    globalWebSocket.initialize({ wsUrl: options.wsUrl });
-  }
-
-  const isServer = typeof window === 'undefined';
-  const autoInit = !isServer && options.autoInit !== false;
-
-  let notificationManager = null;
-
-  if (autoInit) {
-    const initNotifications = async () => {
-      if (store.auth.state.isAuthenticated && store.auth.state.user?._id) {
-        notificationManager = await notificationUtils.initialize(store, {
-          enablePush: options.enablePush !== false,
-          maxReconnectAttempts: options.maxReconnectAttempts || 5,
-          reconnectDelay: options.reconnectDelay || 3000,
-          pingInterval: options.pingInterval || 30000
-        });
-      }
-    };
-
-    watch(() => store.auth.state.isAuthenticated, (isAuthenticated) => {
-      if (isAuthenticated) {
-        initNotifications();
-      } else if (notificationManager) {
-        notificationManager.disconnect();
-        store.notifications.mutations.resetNotifications();
-        notificationManager = null;
-      }
-    });
-
-    if (store.auth.state.isAuthenticated) {
-      initNotifications();
-    }
-  }
-
-  app.provide('useNotifications', () => ({
-    ...toRefs(store.notifications.state),
-    ...store.notifications.actions,
-    ...store.notifications.mutations,
-    init: () => notificationUtils.initialize(store, options),
-    disconnect: () => notificationManager?.disconnect(),
-    isServer
-  }));
-
-  return {
-    SSR: { prefetchNotifications: notificationUtils.prefetchForSSR }
-  };
-};
-
-const ModuleNotifications = {
-  initialize: initializeNotifications,
-  views: {
-    store: { storeNotifications },
-    router: { routerNotifications },
-    components: {
-      NotificationBadge,
-      NotificationItem,
-      NotificationsList,
-      NotificationPreferences,
-      Notifications,
-      NotificationsLayout
-    }
-  }
-};
-
-export {
-  NotificationBadge,
-  NotificationItem,
-  NotificationsList,
-  NotificationPreferences,
-  Notifications,
-  NotificationsLayout,
-  notificationUtils as SSRUtils
-};
-
-export default ModuleNotifications;

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

@@ -1,100 +0,0 @@
-// services/websocket.service.js
-const WebSocketService = (wss) => {
-  const connections = new Map();
-  
-  // Добавление соединения
-  const addConnection = (userId, ws) => {
-    if (!connections.has(userId)) {
-      connections.set(userId, new Set());
-    }
-    connections.get(userId).add(ws);
-    
-    // Отслеживаем закрытие соединения
-    ws.on('close', () => {
-      removeConnection(userId, ws);
-    });
-  };
-  
-  // Удаление соединения
-  const removeConnection = (userId, ws) => {
-    if (connections.has(userId)) {
-      connections.get(userId).delete(ws);
-      if (connections.get(userId).size === 0) {
-        connections.delete(userId);
-      }
-    }
-  };
-  
-  // Отправка сообщения конкретному пользователю
-  const sendToUser = (userId, data) => {
-    return new Promise((resolve) => {
-      try {
-        if (!connections.has(userId)) {
-          // Пользователь не подключен
-          return resolve({ delivered: false, reason: 'user-not-connected' });
-        }
-        
-        const userSockets = connections.get(userId);
-        let delivered = 0;
-        
-        userSockets.forEach((ws) => {
-          if (ws.readyState === 1) { // 1 = OPEN
-            ws.send(JSON.stringify({
-              type: 'notification',
-              data
-            }));
-            delivered++;
-          }
-        });
-
-        console.log(userSockets)
-        
-        resolve({ delivered: delivered > 0, connections: delivered });
-      } catch (error) {
-        console.error('Ошибка отправки уведомления:', error);
-        resolve({ delivered: false, reason: 'error', error: error.message });
-      }
-    });
-  };
-  
-  // Рассылка всем подключенным клиентам
-  const broadcast = (data) => {
-    return new Promise((resolve) => {
-      let count = 0;
-      
-      wss.clients.forEach((ws) => {
-        if (ws.readyState === 1) { // 1 = OPEN
-          try {
-            ws.send(JSON.stringify({
-              type: 'notification',
-              data
-            }));
-            count++;
-          } catch (e) {
-            console.error('Ошибка рассылки клиенту:', e);
-          }
-        }
-      });
-      
-      resolve({ delivered: count > 0, connections: count });
-    });
-  };
-  
-  // Настраиваем обработчик подключений для нашего сервиса
-  wss.on('connection', (ws, req) => {
-    // Если у соединения есть userId (аутентифицированный пользователь)
-    if (req.userId) {
-      // Просто добавляем соединение в наш трекер
-      addConnection(req.userId, ws);
-    }
-  });
-  
-  return {
-    addConnection,
-    removeConnection,
-    sendToUser,
-    broadcast
-  };
-};
-
-module.exports = WebSocketService;