@ozdao/martyrs 0.2.469 → 0.2.471

package/src/modules/music/store/search.js

@@ -0,0 +1,126 @@
+// store/search.js
+import { reactive } from 'vue';
+
+// State
+export const state = reactive({
+  query: '',
+  results: {
+    tracks: [],
+    albums: [],
+    artists: [],
+    playlists: [],
+    genres: []
+  },
+  isLoading: false,
+  error: null,
+  activeFilter: 'all' // 'all', 'tracks', 'albums', 'artists', 'playlists', 'genres'
+});
+
+// Actions
+export const actions = {
+  async search(query, type = null, limit = 10) {
+    if (!query || query.length < 2) {
+      // Reset results if query is too short
+      state.results = {
+        tracks: [],
+        albums: [],
+        artists: [],
+        playlists: [],
+        genres: []
+      };
+      state.error = "Search query must be at least 2 characters";
+      return;
+    }
+    
+    state.query = query;
+    state.isLoading = true;
+    state.error = null;
+    
+    try {
+      const queryParams = new URLSearchParams({
+        query,
+        limit
+      });
+      
+      if (type) {
+        queryParams.append('type', type);
+      }
+      
+      const response = await fetch(`${process.env.API_URL}/api/music/search?${queryParams.toString()}`);
+      
+      if (!response.ok) {
+        throw new Error('Search request failed');
+      }
+      
+      const data = await response.json();
+      
+      // Update state with results
+      state.results = {
+        tracks: data.tracks || [],
+        albums: data.albums || [],
+        artists: data.artists || [],
+        playlists: data.playlists || [],
+        genres: data.genres || []
+      };
+    } catch (error) {
+      console.error('Search error:', error);
+      state.error = error.message;
+      // Clear results on error
+      state.results = {
+        tracks: [],
+        albums: [],
+        artists: [],
+        playlists: [],
+        genres: []
+      };
+    } finally {
+      state.isLoading = false;
+    }
+  },
+  
+  setFilter(filter) {
+    state.activeFilter = filter;
+  },
+  
+  clearSearch() {
+    state.query = '';
+    state.results = {
+      tracks: [],
+      albums: [],
+      artists: [],
+      playlists: [],
+      genres: []
+    };
+    state.error = null;
+    state.isLoading = false;
+  }
+};
+
+// Computed values
+export const computed = {
+  hasResults: () => {
+    return Object.values(state.results).some(arr => arr.length > 0);
+  },
+  
+  filteredResults: () => {
+    if (state.activeFilter === 'all') {
+      return state.results;
+    }
+    
+    // Return only the filtered category
+    const filtered = {
+      tracks: [],
+      albums: [],
+      artists: [],
+      playlists: [],
+      genres: []
+    };
+    
+    filtered[state.activeFilter] = state.results[state.activeFilter];
+    return filtered;
+  },
+  
+  totalResultsCount: () => {
+    return Object.values(state.results).reduce((sum, arr) => sum + arr.length, 0);
+  }
+};

package/src/modules/music/store/tracks.js

@@ -0,0 +1,230 @@
+// store/tracks.js
+import { reactive } from 'vue';
+import Store from '@martyrs/src/modules/globals/views/classes/globals.store';
+
+// Create store instance
+const trackStore = new Store(`${process.env.API_URL}/api/tracks`);
+
+// State
+export const state = reactive({
+  tracks: [],
+  popular: [],
+  recent: [],
+  featured: [],
+  userTracks: [],
+  currentTrack: null,
+  isLoading: false,
+  loadingPopular: false,
+  loadingRecent: false,
+  loadingFeatured: false
+});
+
+// Actions
+export const actions = {
+  async fetchTracks(options = {}) {
+    state.isLoading = true;
+    try {
+      const tracks = await trackStore.read(options);
+      state.tracks = tracks;
+      return tracks;
+    } catch (error) {
+      console.error('Error fetching tracks:', error);
+      return [];
+    } finally {
+      state.isLoading = false;
+    }
+  },
+  
+  async fetchPopularTracks(limit = 10) {
+    state.loadingPopular = true;
+    try {
+      const response = await fetch(`${process.env.API_URL}/api/tracks/popular?limit=${limit}`);
+      const tracks = await response.json();
+      state.popular = tracks;
+      return tracks;
+    } catch (error) {
+      console.error('Error fetching popular tracks:', error);
+      return [];
+    } finally {
+      state.loadingPopular = false;
+    }
+  },
+  
+  async fetchRecentTracks(limit = 10) {
+    state.loadingRecent = true;
+    try {
+      const response = await fetch(`${process.env.API_URL}/api/tracks/recent?limit=${limit}`);
+      const tracks = await response.json();
+      state.recent = tracks;
+      return tracks;
+    } catch (error) {
+      console.error('Error fetching recent tracks:', error);
+      return [];
+    } finally {
+      state.loadingRecent = false;
+    }
+  },
+  
+  async fetchTracksByGenre(genreId, limit = 20) {
+    try {
+      const response = await fetch(`${process.env.API_URL}/api/tracks/genre/${genreId}?limit=${limit}`);
+      return await response.json();
+    } catch (error) {
+      console.error('Error fetching tracks by genre:', error);
+      return [];
+    }
+  },
+  
+  async fetchTrackByUrl(url) {
+    try {
+      const response = await fetch(`${process.env.API_URL}/api/tracks/url/${url}`);
+      const track = await response.json();
+      state.currentTrack = track;
+      return track;
+    } catch (error) {
+      console.error('Error fetching track by URL:', error);
+      return null;
+    }
+  },
+  
+  // Improved createTrack action with better error handling
+  async createTrack(trackData) {
+    console.log('Creating track with data:', trackData);
+    
+    // Validate required fields to prevent silent failures
+    const requiredFields = ['title', 'artist', 'genre', 'fileUrl'];
+    const missingFields = requiredFields.filter(field => !trackData[field]);
+    
+    if (missingFields.length > 0) {
+      const error = new Error(`Missing required fields: ${missingFields.join(', ')}`);
+      console.error(error);
+      throw error;
+    }
+    
+    // Ensure proper structure for owner and creator fields
+    if (!trackData.owner || !trackData.owner.target || !trackData.owner.type) {
+      console.error('Track data missing owner information');
+      throw new Error('Owner information is required');
+    }
+    
+    if (!trackData.creator || !trackData.creator.target || !trackData.creator.type) {
+      console.error('Track data missing creator information');
+      throw new Error('Creator information is required');
+    }
+    
+    try {
+      console.log('Calling API to create track...');
+      
+      // Check what API URL we're using
+      console.log('API URL:', trackStore.apiUrl);
+      
+      // Use a timeout to detect hanging requests
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error('Request timed out after 15 seconds')), 15000);
+      });
+      
+      // Race between the actual request and the timeout
+      const createdTrack = await Promise.race([
+        trackStore.create(trackData),
+        timeoutPromise
+      ]);
+      
+      console.log('Track created successfully, server response:', createdTrack);
+      
+      // Check if the response is what we expect
+      if (!createdTrack || !createdTrack._id) {
+        console.error('API returned success but without expected track data:', createdTrack);
+        throw new Error('Invalid response from server');
+      }
+      
+      // Update local state
+      state.tracks.unshift(createdTrack);
+      state.userTracks.unshift(createdTrack);
+      
+      console.log('Local state updated with new track');
+      return createdTrack;
+    } catch (error) {
+      console.error('Error creating track:', error);
+      
+      // Enhanced error logging
+      if (error.response) {
+        console.error('Error response:', error.response);
+      }
+      
+      // Format the error for better user feedback
+      const formattedError = new Error(
+        error.message || 'Failed to create track. Please try again.'
+      );
+      formattedError.originalError = error;
+      
+      // Set a global error
+      setError({
+        message: formattedError.message,
+        errorCode: error.errorCode || 'TRACK_CREATE_FAILED'
+      });
+      
+      throw formattedError;
+    }
+  },
+  
+  async updateTrack(trackData) {
+    try {
+      const updatedTrack = await trackStore.update(trackData);
+      
+      // Update local state
+      const index = state.tracks.findIndex(t => t._id === updatedTrack._id);
+      if (index !== -1) {
+        state.tracks[index] = updatedTrack;
+      }
+      
+      const userIndex = state.userTracks.findIndex(t => t._id === updatedTrack._id);
+      if (userIndex !== -1) {
+        state.userTracks[userIndex] = updatedTrack;
+      }
+      
+      if (state.currentTrack && state.currentTrack._id === updatedTrack._id) {
+        state.currentTrack = updatedTrack;
+      }
+      
+      return updatedTrack;
+    } catch (error) {
+      console.error('Error updating track:', error);
+      throw error;
+    }
+  },
+  
+  async deleteTrack(trackId) {
+    try {
+      await trackStore.delete({ _id: trackId });
+      
+      // Update local state
+      state.tracks = state.tracks.filter(t => t._id !== trackId);
+      state.userTracks = state.userTracks.filter(t => t._id !== trackId);
+      
+      if (state.currentTrack && state.currentTrack._id === trackId) {
+        state.currentTrack = null;
+      }
+      
+      return true;
+    } catch (error) {
+      console.error('Error deleting track:', error);
+      throw error;
+    }
+  },
+  
+  async fetchUserTracks(userId) {
+    try {
+      const options = {
+        creator: userId,
+        limit: 100
+      };
+      console.log('fetchUserTracks', userId)
+      const tracks = await trackStore.read(options);
+      state.userTracks = tracks;
+      return tracks;
+    } catch (error) {
+      console.error('Error fetching user tracks:', error);
+      return [];
+    }
+  }
+};

package/src/modules/music/websocket/streaming.handler.js

@@ -0,0 +1,151 @@
+// websocket/streaming.handler.js (continued)
+module.exports = function(db) {
+  const Logger = require('@martyrs/src/modules/globals/controllers/classes/globals.logger');
+  const logger = new Logger(db);
+  
+  return {
+    // Handle WebSocket messages for music streaming
+    handleStreamingMessage: async (ws, message) => {
+      try {
+        const { action, data } = message;
+        
+        switch (action) {
+          case 'startPlaying':
+            // Log play event
+            if (ws.userId && data.trackId) {
+              await db.playHistory.create({
+                user: ws.userId,
+                track: data.trackId,
+                playedAt: new Date(),
+                deviceInfo: data.deviceInfo || 'Unknown',
+                playedFrom: data.from || 'other',
+                contextId: data.contextId || null
+              });
+              
+              // Increment play count
+              await db.track.findByIdAndUpdate(data.trackId, { $inc: { playCount: 1 } });
+              
+              // Acknowledge
+              ws.send(JSON.stringify({
+                type: 'playAcknowledged',
+                trackId: data.trackId
+              }));
+            }
+            break;
+            
+          case 'syncPosition':
+            // Track playback position for potential resume later
+            if (ws.userId && data.trackId && data.position) {
+              // Find the latest play history entry
+              const latestPlay = await db.playHistory.findOne({
+                user: ws.userId,
+                track: data.trackId
+              }).sort({ playedAt: -1 });
+              
+              if (latestPlay) {
+                latestPlay.playDuration = data.position;
+                await latestPlay.save();
+              }
+            }
+            break;
+            
+          case 'getRecommendations':
+            // Generate personalized recommendations
+            if (ws.userId) {
+              // Get user's recently played tracks
+              const recentTracks = await db.playHistory.find({
+                user: ws.userId
+              })
+              .sort({ playedAt: -1 })
+              .limit(10)
+              .populate('track');
+              
+              // Extract genres and artists from recently played
+              const recentGenres = new Set();
+              const recentArtists = new Set();
+              
+              recentTracks.forEach(history => {
+                if (history.track) {
+                  if (history.track.genre) {
+                    history.track.genre.forEach(g => recentGenres.add(g.toString()));
+                  }
+                  if (history.track.artist) {
+                    recentArtists.add(history.track.artist.toString());
+                  }
+                }
+              });
+              
+              // Find recommendations based on genres and artists
+              const recommendations = await db.track.find({
+                $or: [
+                  { genre: { $in: Array.from(recentGenres) } },
+                  { artist: { $in: Array.from(recentArtists) } }
+                ],
+                _id: { $nin: recentTracks.map(h => h.track._id) }, // Exclude recently played
+                status: 'published',
+                isPublic: true
+              })
+              .limit(10)
+              .populate('artist', 'name')
+              .populate('album', 'title coverUrl');
+              
+              // Send recommendations to the client
+              ws.send(JSON.stringify({
+                type: 'recommendations',
+                tracks: recommendations
+              }));
+            }
+            break;
+            
+          case 'joinListeningParty':
+            // Implement a shared listening experience
+            if (ws.userId && data.partyId) {
+              // Join a room based on the party ID
+              ws.listeningParty = data.partyId;
+              
+              // Broadcast to all users in the party that a new user joined
+              global.webSocketManager.broadcastToModuleWithFilter(
+                'music-streaming',
+                (socket) => socket.listeningParty === data.partyId,
+                {
+                  type: 'partyMemberJoined',
+                  userId: ws.userId,
+                  partyId: data.partyId
+                }
+              );
+            }
+            break;
+            
+          case 'syncPartyPlayback':
+            // Synchronize playback for listening party members
+            if (ws.userId && ws.listeningParty && data.trackId && data.position) {
+              // Broadcast current position to all users in the party
+              global.webSocketManager.broadcastToModuleWithFilter(
+                'music-streaming',
+                (socket) => socket.listeningParty === ws.listeningParty && socket !== ws,
+                {
+                  type: 'partyPlaybackSync',
+                  trackId: data.trackId,
+                  position: data.position,
+                  isPlaying: data.isPlaying,
+                  timestamp: Date.now()
+                }
+              );
+            }
+            break;
+            
+          default:
+            logger.info(`Unknown streaming action: ${action}`);
+        }
+      } catch (error) {
+        logger.error(`Error in streaming handler: ${error.message}`);
+        
+        // Send error to client
+        ws.send(JSON.stringify({
+          type: 'error',
+          message: 'An error occurred while processing your request'
+        }));
+      }
+    }
+  };
+};

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);