@ozdao/martyrs 0.2.470 → 0.2.472

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

@@ -58,6 +58,48 @@ const NotificationsController = (db, wss) => {
     }
   };
 
+  // controllers/notifications.controller.js (добавить к существующему контроллеру)
+
+  // Mark all notifications as read for a user
+  const markAllAsRead = async (req, res) => {
+    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() }
+      );
+      
+      // Get all updated notifications for logging
+      const updatedNotifications = await db.notification.find({
+        userId: userId,
+        status: 'read',
+        updatedAt: { $gte: new Date(Date.now() - 10000) } // Get notifications updated in the last 10 seconds
+      });
+      
+      // Log the read status for each notification
+      const logPromises = updatedNotifications.map(notification => {
+        return db.notificationLog.create({
+          notificationId: notification._id,
+          userId: userId,
+          channelType: 'web', // Assuming web as default
+          status: 'read',
+          readAt: Date.now()
+        });
+      });
+      
+      await Promise.all(logPromises);
+      
+      return res.json({ 
+        message: 'All notifications marked as read',
+        count: result.modifiedCount
+      });
+    } catch (err) {
+      return res.status(500).json({ message: err.message });
+    }
+  };
+
   // Register device for push notifications
   const registerDevice = async (req, res) => {
     try {
@@ -132,7 +174,8 @@ const NotificationsController = (db, wss) => {
     markAsRead,
     registerDevice,
     updatePreferences,
-    getUserPreferences
+    getUserPreferences,
+    markAllAsRead
   };
 };
 

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

@@ -20,7 +20,6 @@ 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);

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

@@ -10,6 +10,9 @@ const notificationsRoutes = (app, db, wss, origins, publicPath) => {
   
   // Mark notification as read
   app.put('/api/notifications/:id/read', controller.markAsRead);
+
+    // 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);

package/src/modules/orders/components/pages/OrderCreate.vue

@@ -4,8 +4,6 @@
 
 	<!-- Ask to login  -->
 	<AskToLogin class="mn-b-thin" v-if="auth.state.access.status === false" /> 
-	{{shopcart.state.organization}}
-	{{orderOrganization.value?._id}}
 	<!-- Order form -->
 	<div class="gap-small mn-b-thin cols-2">
 		<!-- Empty State   -->

package/src/modules/products/components/blocks/CardCategory.vue

@@ -1,7 +1,8 @@
 <template>
   <div class="flex-v-center bg-light pd-small radius-small flex-column flex">
-    <div class="w-100 flex-nowrap gap-thin flex">
-      <h4 class="my-handle mn-r-auto">{{category.name}}</h4>
+    <div class="w-100 flex-v-center flex-nowrap gap-thin flex">
+      <img v-if="category.photo" class="i-big radius-small object-fit-contain bg-white" :src="(FILE_SERVER_URL || '') + category.photo"/>
+      <h4 class="my-handle word-break t-truncate w-100 w-max-100 mn-r-auto">{{category.name}}</h4>
 
       <router-link
        :to="{
@@ -13,10 +14,10 @@
         }"
         class="
           i-semi
-          z-index-2
           cursor-pointer 
           card-page-actions
           radius-extra pd-micro bg-second
+          flex-child-default
         "
       >
         <IconEdit
@@ -29,10 +30,10 @@
         @click="deleteCategory(category)"
         class="
           i-semi
-          z-index-2
           cursor-pointer 
           card-page-actions
           radius-extra pd-micro bg-second
+          flex-child-default
         "
       >
         <IconDelete