@ozdao/martyrs 0.2.470 → 0.2.472

package/src/modules/music/router/music.js

@@ -0,0 +1,77 @@
+// router/music.js
+export default {
+  path: 'music',
+  component: () => import('../components/layouts/MusicLayout.vue'),
+  children: [
+    {
+      path: '',
+      name: 'music-home',
+      component: () => import('../components/pages/MusicHome.vue'),
+      meta: {
+        title: 'Music Home'
+      }
+    },
+    {
+      path: 'search',
+      name: 'music-search',
+      component: () => import('../components/pages/SearchResults.vue'),
+      meta: {
+        title: 'Search Music'
+      }
+    },
+    {
+      path: 'library',
+      name: 'music-library',
+      component: () => import('../components/pages/MusicLibrary.vue'),
+      meta: {
+        title: 'My Library',
+        requiresAuth: true
+      }
+    },
+    {
+      path: 'upload',
+      name: 'music-upload',
+      component: () => import('../components/pages/MusicUpload.vue'),
+      meta: {
+        title: 'Upload Music',
+        requiresAuth: true
+      }
+    },
+    {
+      path: 'artists/:url',
+      name: 'artist-detail',
+      component: () => import('../components/pages/ArtistDetail.vue'),
+      props: true,
+      meta: {
+        title: 'Artist Details'
+      }
+    },
+    {
+      path: 'albums/:url',
+      name: 'album-detail',
+      component: () => import('../components/pages/AlbumDetail.vue'),
+      props: true,
+      meta: {
+        title: 'Album Details'
+      }
+    },
+    {
+      path: 'playlists/:url',
+      name: 'playlist-detail',
+      component: () => import('../components/pages/PlaylistDetail.vue'),
+      props: true,
+      meta: {
+        title: 'Playlist Details'
+      }
+    },
+    {
+      path: 'tracks/:url',
+      name: 'track-detail',
+      component: () => import('../components/pages/TrackDetail.vue'),
+      props: true,
+      meta: {
+        title: 'Track Details'
+      }
+    }
+  ]
+};

package/src/modules/music/routes/album.routes.js

@@ -0,0 +1,62 @@
+// routes/album.routes.js
+module.exports = function(app, db, origins, publicPath) {
+  const controller = require('../controllers/album.controller')(app,db);
+  const middlewareFactoryAuth = require('@martyrs/src/modules/auth/controllers/middlewares');
+  const { authJwt } = middlewareFactoryAuth(db);
+  
+  // CRUD operations for albums
+  app.post(
+    '/api/albums/create',
+    [authJwt.verifyToken],
+    controller.create
+  );
+  
+  app.get(
+    '/api/albums/read',
+    controller.read
+  );
+  
+  app.put(
+    '/api/albums/update',
+    [authJwt.verifyToken],
+    controller.update
+  );
+  
+  app.delete(
+    '/api/albums/delete',
+    [authJwt.verifyToken],
+    controller.delete
+  );
+  
+  // Get album tracks
+  app.get(
+    '/api/albums/:albumId/tracks',
+    controller.getAlbumTracks
+  );
+  
+  // Get featured albums
+  app.get(
+    '/api/albums/featured',
+    controller.getFeaturedAlbums
+  );
+  
+  // Get album by URL
+  app.get(
+    '/api/albums/url/:url',
+    async (req, res) => {
+      try {
+        const album = await db.album.findOne({ url: req.params.url })
+          .populate('artist');
+          
+        if (!album) {
+          return res.status(404).json({ error: 'Album not found' });
+        }
+        
+        res.json(album);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  );
+};

package/src/modules/music/routes/artist.routes.js

@@ -0,0 +1,67 @@
+// routes/artist.routes.js
+module.exports = function(app, db, origins, publicPath) {
+  const controller = require('../controllers/artist.controller')(app,db);
+  const middlewareFactoryAuth = require('@martyrs/src/modules/auth/controllers/middlewares');
+  const { authJwt } = middlewareFactoryAuth(db);
+  
+  // CRUD operations for artists
+  app.post(
+    '/api/artists/create',
+    [authJwt.verifyToken],
+    controller.create
+  );
+  
+  app.get(
+    '/api/artists/read',
+    controller.read
+  );
+  
+  app.put(
+    '/api/artists/update',
+    [authJwt.verifyToken],
+    controller.update
+  );
+  
+  app.delete(
+    '/api/artists/delete',
+    [authJwt.verifyToken],
+    controller.delete
+  );
+  
+  // Get artist discography
+  app.get(
+    '/api/artists/:artistId/discography',
+    controller.getDiscography
+  );
+  
+  // Verify artist (admin only)
+  app.put(
+    '/api/artists/:artistId/verify',
+    [authJwt.verifyToken, authJwt.isAdmin],
+    controller.verifyArtist
+  );
+  
+  // Get related artists
+  app.get(
+    '/api/artists/:artistId/related',
+    controller.getRelatedArtists
+  );
+  
+  // Get artist by URL
+  app.get(
+    '/api/artists/url/:url',
+    async (req, res) => {
+      try {
+        const artist = await db.artist.findOne({ url: req.params.url });
+        if (!artist) {
+          return res.status(404).json({ error: 'Artist not found' });
+        }
+        
+        res.json(artist);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  );
+};

package/src/modules/music/routes/genre.routes.js

@@ -0,0 +1,60 @@
+// routes/genre.routes.js
+module.exports = function(app, db, origins, publicPath) {
+  const controller = require('../controllers/genre.controller')(app,db);
+  const middlewareFactoryAuth = require('@martyrs/src/modules/auth/controllers/middlewares');
+  const { authJwt } = middlewareFactoryAuth(db);
+  
+  // CRUD operations for genres
+  app.post(
+    '/api/genres/create',
+    [authJwt.verifyToken, authJwt.isAdmin],
+    controller.create
+  );
+  
+  app.get(
+    '/api/genres/read',
+    controller.read
+  );
+  
+  app.put(
+    '/api/genres/update',
+    [authJwt.verifyToken, authJwt.isAdmin],
+    controller.update
+  );
+  
+  app.delete(
+    '/api/genres/delete',
+    [authJwt.verifyToken, authJwt.isAdmin],
+    controller.delete
+  );
+  
+  // Get tracks by genre
+  app.get(
+    '/api/genres/:genreId/tracks',
+    controller.getGenreTracks
+  );
+  
+  // Get popular genres
+  app.get(
+    '/api/genres/popular',
+    controller.getPopularGenres
+  );
+  
+  // Get genre by URL
+  app.get(
+    '/api/genres/url/:url',
+    async (req, res) => {
+      try {
+        const genre = await db.genre.findOne({ url: req.params.url });
+        if (!genre) {
+          return res.status(404).json({ error: 'Genre not found' });
+        }
+        
+        res.json(genre);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  );
+};

package/src/modules/music/routes/music.routes.js

@@ -0,0 +1,145 @@
+// routes/music.routes.js
+// Factories
+const controllerFactory = require('../controllers/music.controller');
+// Middlewares
+const middlewareFactoryAuth = require('@martyrs/src/modules/auth/controllers/middlewares');
+// ABAC
+const { getInstance } = require('@martyrs/src/modules/globals/controllers/classes/globals.abac.js');
+
+module.exports = function(app, db, origins, publicPath) {
+  const { MusicController } = controllerFactory(app, db);
+  const { authJwt } = middlewareFactoryAuth(db);
+
+  const controller = new MusicController('/api/tracks', app, db, db.track, {disableDefaultRoutes: true}); 
+  const abac = getInstance(db);
+
+  
+  // CRUD operations for tracks
+
+  app.post(
+    '/api/tracks/create',
+    [authJwt.verifyToken(), // Auth middleware
+    (req, res, next) => {
+      // Debugging middleware
+      console.log('[Route] /api/tracks/create - Request received');
+      console.log('[Route] User ID from token:', req.userId);
+      next();
+    },
+    ],
+    controller.create.bind(controller) // Bind to ensure 'this' context
+  );
+  
+  app.get(
+    '/api/tracks/read',
+     controller.read.bind(controller)
+  );
+  
+  app.put(
+    '/api/tracks/update',
+    [authJwt.verifyToken],
+     controller.update.bind(controller)
+  );
+  
+  app.delete(
+    '/api/tracks/delete',
+    [authJwt.verifyToken],
+    controller.delete.bind(controller)
+  );
+  
+  // Get track by URL
+  app.get(
+    '/api/tracks/url/:url',
+    async (req, res) => {
+      try {
+        const track = await db.track.findOne({ url: req.params.url });
+        if (!track) {
+          return res.status(404).json({ error: 'Track not found' });
+        }
+        
+        // Check access using ABAC
+        const accessResult = await abac.checkAccess({
+          user: req.userId,
+          resource: 'tracks',
+          action: 'read',
+          currentResource: track
+        });
+        
+        if (!accessResult.allowed && !track.isPublic) {
+          return res.status(403).json({ 
+            errorCode: accessResult.reason,
+            message: 'Access Denied'
+          });
+        }
+        
+        res.json(track);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  );
+  
+  // Get recent tracks
+  app.get(
+    '/api/tracks/recent',
+    async (req, res) => {
+      try {
+        const limit = parseInt(req.query.limit) || 10;
+        
+        const recentTracks = await db.track.find({
+          status: 'published',
+          isPublic: true
+        })
+        .sort({ createdAt: -1 })
+        .limit(limit);
+        
+        res.json(recentTracks);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  );
+  
+  // Get popular tracks
+  app.get(
+    '/api/tracks/popular',
+    async (req, res) => {
+      try {
+        const limit = parseInt(req.query.limit) || 10;
+        
+        const popularTracks = await db.track.find({
+          status: 'published',
+          isPublic: true
+        })
+        .sort({ playCount: -1 })
+        .limit(limit);
+        
+        res.json(popularTracks);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  );
+  
+  // Get tracks by genre
+  app.get(
+    '/api/tracks/genre/:genreId',
+    async (req, res) => {
+      try {
+        const tracks = await db.track.find({
+          genre: req.params.genreId,
+          status: 'published',
+          isPublic: true
+        })
+        .sort({ releaseDate: -1 });
+        
+        res.json(tracks);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  );
+};

package/src/modules/music/routes/playlist.routes.js

@@ -0,0 +1,99 @@
+// routes/playlist.routes.js
+module.exports = function(app, db, origins, publicPath) {
+  const controller = require('../controllers/playlist.controller')(app,db);
+
+  const middlewareFactoryAuth = require('@martyrs/src/modules/auth/controllers/middlewares');
+  const { authJwt } = middlewareFactoryAuth(db);
+  
+  // CRUD operations for playlists
+  app.post(
+    '/api/playlists/create',
+    [authJwt.verifyToken],
+    controller.create
+  );
+  
+  app.get(
+    '/api/playlists/read',
+    controller.read
+  );
+  
+  app.put(
+    '/api/playlists/update',
+    [authJwt.verifyToken],
+    controller.update
+  );
+  
+  app.delete(
+    '/api/playlists/delete',
+    [authJwt.verifyToken],
+    controller.delete
+  );
+  
+  // Get user playlists
+  app.get(
+    '/api/playlists/user/:userId?',
+    [authJwt.verifyToken],
+    controller.getUserPlaylists
+  );
+  
+  // Add track to playlist
+  app.post(
+    '/api/playlists/:playlistId/tracks/:trackId',
+    [authJwt.verifyToken],
+    controller.addTrack
+  );
+  
+  // Remove track from playlist
+  app.delete(
+    '/api/playlists/:playlistId/tracks/:trackId',
+    [authJwt.verifyToken],
+    controller.removeTrack
+  );
+  
+  // Add collaborator to playlist
+  app.post(
+    '/api/playlists/:playlistId/collaborators/:userId',
+    [authJwt.verifyToken],
+    controller.addCollaborator
+  );
+  
+  // Get playlist by URL
+  app.get(
+    '/api/playlists/url/:url',
+    async (req, res) => {
+      try {
+        const playlist = await db.playlist.findOne({ url: req.params.url })
+          .populate({
+            path: 'tracks.track',
+            select: '-lyrics'
+          });
+          
+        if (!playlist) {
+          return res.status(404).json({ error: 'Playlist not found' });
+        }
+        
+        // If not public, check permissions
+        if (!playlist.isPublic) {
+          // Only owner and collaborators can see private playlists
+          if (!req.userId) {
+            return res.status(403).json({ error: 'Access denied to private playlist' });
+          }
+          
+          const isOwner = playlist.owner.target.toString() === req.userId;
+          const isCollaborator = playlist.collaborators.some(
+            collab => collab.toString() === req.userId
+          );
+          
+          if (!isOwner && !isCollaborator) {
+            return res.status(403).json({ error: 'Access denied to private playlist' });
+          }
+        }
+        
+        res.json(playlist);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  );
+};

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

@@ -0,0 +1,10 @@
+// routes/search.routes.js
+module.exports = function(app, db, origins, publicPath) {
+  const controller = require('../controllers/search.controller')(app,db);
+  
+  // Search API endpoint
+  app.get(
+    '/api/music/search',
+    controller.search
+  );
+};

package/src/modules/music/routes/stream.routes.js

@@ -0,0 +1,38 @@
+// routes/stream.routes.js
+module.exports = function(app, db, origins, publicPath) {
+  console.log('rouus publioc is', publicPath)
+  const controller = require('../controllers/stream.controller')(app,db,publicPath);
+  
+  // Stream audio
+  app.get(
+    '/api/stream/:trackId',
+    controller.streamAudio
+  );
+  
+  // WaveForm data for visualization
+  app.get(
+    '/api/waveform/:trackId',
+    async (req, res) => {
+      try {
+        const track = await db.track.findById(req.params.trackId);
+        if (!track) {
+          return res.status(404).json({ error: 'Track not found' });
+        }
+        
+        // Check if waveform data exists (assuming it's preprocessed)
+        const waveformPath = path.join(process.env.FILE_STORAGE_PATH || './uploads', `waveforms/${track._id}.json`);
+        
+        if (fs.existsSync(waveformPath)) {
+          const waveformData = JSON.parse(fs.readFileSync(waveformPath, 'utf8'));
+          return res.json(waveformData);
+        }
+        
+        // If no waveform data, return error
+        res.status(404).json({ error: 'Waveform data not found' });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  );
+};