@ozdao/martyrs 0.2.486 → 0.2.487

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

@@ -0,0 +1,31 @@
+// router/tracks.js
+export default [
+  {
+    path: 'tracks/create',
+    name: 'track-create',
+    component: () => import('../components/pages/TrackCreate.vue'),
+    meta: {
+      title: 'Create Track',
+      requiresAuth: true,
+    },
+  },
+  {
+    path: 'tracks/:url/edit',
+    name: 'track-edit',
+    component: () => import('../components/pages/TrackEdit.vue'),
+    props: true,
+    meta: {
+      title: 'Edit Track',
+      requiresAuth: true,
+    },
+  },
+  {
+    path: 'tracks/:url',
+    name: 'track',
+    component: () => import('../components/pages/Track.vue'),
+    props: true,
+    meta: {
+      title: 'Track',
+    },
+  },
+];

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

@@ -0,0 +1,126 @@
+// @martyrs/src/modules/music/routes/albums.routes.js
+import CRUD from '@martyrs/src/modules/globals/controllers/classes/crud/crud.js';
+import ABAC from '@martyrs/src/modules/globals/controllers/classes/abac/abac.js';
+import albumsVerifierFactory from '../middlewares/albums.verifier.js';
+
+const { getInstance } = ABAC;
+
+export default function setupAlbumsRoutes(app, db) {
+  const abac = getInstance(db);
+  const verifier = albumsVerifierFactory(db);
+
+  // Основной CRUD для albums
+  const albumsCRUD = new CRUD({
+    app,
+    db,
+    model: db.album,
+    modelName: 'album',
+    basePath: '/api/albums',
+    
+    auth: true,
+    
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    
+    abac: abac,
+    
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ['albums', 'music']
+    },
+    
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+
+  // Перенос кастомных роутов через addAction для обратной совместимости
+
+  // Get album by URL - /api/albums/url/:url
+  albumsCRUD.addAction('get-by-url', {
+    method: 'get',
+    path: '/url/:url',
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const album = await db.album
+          .findOne({ url: req.params.url })
+          .populate('artists', 'name url');
+        
+        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 });
+      }
+    }
+  });
+
+  // Get album tracks - /api/albums/:albumId/tracks
+  albumsCRUD.addAction('album-tracks', {
+    method: 'get',
+    path: '/:albumId/tracks',
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const { albumId } = req.params;
+        
+        const tracks = await db.track
+          .find({ 
+            album: albumId,
+            status: 'published',
+            isPublic: true
+          })
+          .populate('artist', 'name url')
+          .populate('genre', 'name')
+          .sort({ trackNumber: 1, createdAt: 1 });
+        
+        res.json(tracks);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  // Get featured albums - /api/albums/featured
+  albumsCRUD.addAction('featured', {
+    method: 'get',
+    path: '/featured',
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const limit = parseInt(req.query.limit) || 10;
+        
+        // Получаем рекомендуемые альбомы (можно добавить поле featured в модель)
+        // Пока используем популярные недавние альбомы
+        const featuredAlbums = await db.album
+          .find({ 
+            status: 'published',
+            releaseDate: { 
+              $gte: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000) // последние 90 дней
+            }
+          })
+          .populate('artists', 'name url')
+          .sort({ createdAt: -1 })
+          .limit(limit);
+        
+        res.json(featuredAlbums);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  return albumsCRUD;
+}

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

@@ -0,0 +1,171 @@
+// @martyrs/src/modules/music/routes/artists.routes.js
+import CRUD from '@martyrs/src/modules/globals/controllers/classes/crud/crud.js';
+import ABAC from '@martyrs/src/modules/globals/controllers/classes/abac/abac.js';
+import artistsVerifierFactory from '../middlewares/artists.verifier.js';
+
+const { getInstance } = ABAC;
+
+export default function setupArtistsRoutes(app, db) {
+  const abac = getInstance(db);
+  const verifier = artistsVerifierFactory(db);
+
+  // Основной CRUD для artists
+  const artistsCRUD = new CRUD({
+    app,
+    db,
+    model: db.artist,
+    modelName: 'artist',
+    basePath: '/api/artists',
+    
+    auth: true,
+    
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    
+    abac: abac,
+    
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ['artists', 'music']
+    },
+    
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+
+  // Перенос кастомных роутов через addAction для обратной совместимости
+
+  // Get artist by URL - /api/artists/url/:url
+  artistsCRUD.addAction('get-by-url', {
+    method: 'get',
+    path: '/url/:url',
+    auth: false,
+    handler: 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 });
+      }
+    }
+  });
+
+  // Get artist discography - /api/artists/:artistId/discography
+  artistsCRUD.addAction('discography', {
+    method: 'get',
+    path: '/:artistId/discography',
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const { artistId } = req.params;
+        
+        // Получаем альбомы артиста
+        const albums = await db.album
+          .find({ artists: artistId })
+          .populate('artists', 'name')
+          .sort({ releaseDate: -1 });
+        
+        // Получаем треки артиста (включая те, которые не в альбомах)
+        const tracks = await db.track
+          .find({ 
+            artist: artistId,
+            status: 'published',
+            isPublic: true 
+          })
+          .populate('album', 'title')
+          .sort({ releaseDate: -1 });
+        
+        res.json({
+          albums,
+          tracks,
+          artist: artistId
+        });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  // Verify artist (admin only) - /api/artists/:artistId/verify
+  artistsCRUD.addAction('verify-artist', {
+    method: 'put',
+    path: '/:artistId/verify',
+    auth: true,
+    abac: {
+      resource: 'artists',
+      action: 'verify',
+      strict: true
+    },
+    handler: async (req, res) => {
+      try {
+        const { artistId } = req.params;
+        
+        const artist = await db.artist.findByIdAndUpdate(
+          artistId,
+          { isVerified: true },
+          { new: true }
+        );
+        
+        if (!artist) {
+          return res.status(404).json({ error: 'Artist not found' });
+        }
+        
+        res.json({ 
+          message: 'Artist verified successfully',
+          artist
+        });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  // Get related artists - /api/artists/:artistId/related
+  artistsCRUD.addAction('related-artists', {
+    method: 'get',
+    path: '/:artistId/related',
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const { artistId } = req.params;
+        const limit = parseInt(req.query.limit) || 10;
+        
+        // Получаем артиста для поиска по жанрам
+        const artist = await db.artist.findById(artistId);
+        if (!artist) {
+          return res.status(404).json({ error: 'Artist not found' });
+        }
+        
+        // Ищем похожих артистов по жанрам
+        const relatedArtists = await db.artist
+          .find({
+            _id: { $ne: artistId }, // исключаем самого артиста
+            genre: { $in: artist.genre }, // общие жанры
+            status: 'published'
+          })
+          .limit(limit)
+          .sort({ popularity: -1 });
+        
+        res.json(relatedArtists);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  return artistsCRUD;
+}

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

@@ -0,0 +1,118 @@
+// @martyrs/src/modules/music/routes/genres.routes.js
+import CRUD from '@martyrs/src/modules/globals/controllers/classes/crud/crud.js';
+import ABAC from '@martyrs/src/modules/globals/controllers/classes/abac/abac.js';
+import genresVerifierFactory from '../middlewares/genres.verifier.js';
+
+const { getInstance } = ABAC;
+
+export default function setupGenresRoutes(app, db) {
+  const abac = getInstance(db);
+  const verifier = genresVerifierFactory(db);
+
+  // Основной CRUD для genres
+  const genresCRUD = new CRUD({
+    app,
+    db,
+    model: db.genre,
+    modelName: 'genre',
+    basePath: '/api/genres',
+    
+    auth: true,
+    
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    
+    abac: abac,
+    
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ['genres', 'music']
+    },
+    
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+
+  // Перенос кастомных роутов через addAction для обратной совместимости
+
+  // Get genre by URL - /api/genres/url/:url
+  genresCRUD.addAction('get-by-url', {
+    method: 'get',
+    path: '/url/:url',
+    auth: false,
+    handler: 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 });
+      }
+    }
+  });
+
+  // Get tracks by genre - /api/genres/:genreId/tracks
+  genresCRUD.addAction('genre-tracks', {
+    method: 'get',
+    path: '/:genreId/tracks',
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const { genreId } = req.params;
+        const limit = parseInt(req.query.limit) || 50;
+        const skip = parseInt(req.query.skip) || 0;
+        
+        const tracks = await db.track
+          .find({
+            genre: genreId,
+            status: 'published',
+            isPublic: true
+          })
+          .populate('artist', 'name url')
+          .populate('album', 'title url')
+          .sort({ playCount: -1, releaseDate: -1 })
+          .skip(skip)
+          .limit(limit);
+        
+        res.json(tracks);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  // Get popular genres - /api/genres/popular
+  genresCRUD.addAction('popular', {
+    method: 'get',
+    path: '/popular',
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const limit = parseInt(req.query.limit) || 20;
+        
+        const popularGenres = await db.genre
+          .find({ status: 'published' })
+          .sort({ popularity: -1 })
+          .limit(limit);
+        
+        res.json(popularGenres);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  return genresCRUD;
+}

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

@@ -0,0 +1,239 @@
+// @martyrs/src/modules/music/routes/playlists.routes.js
+import CRUD from '@martyrs/src/modules/globals/controllers/classes/crud/crud.js';
+import ABAC from '@martyrs/src/modules/globals/controllers/classes/abac/abac.js';
+import playlistsVerifierFactory from '../middlewares/playlists.verifier.js';
+
+const { getInstance } = ABAC;
+
+export default function setupPlaylistsRoutes(app, db) {
+  const abac = getInstance(db);
+  const verifier = playlistsVerifierFactory(db);
+
+  // Основной CRUD для playlists
+  const playlistsCRUD = new CRUD({
+    app,
+    db,
+    model: db.playlist,
+    modelName: 'playlist',
+    basePath: '/api/playlists',
+    
+    auth: true,
+    
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    
+    abac: abac,
+    
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ['playlists', 'music']
+    },
+    
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+
+  // Перенос кастомных роутов через addAction для обратной совместимости
+
+  // Get playlist by URL - /api/playlists/url/:url
+  playlistsCRUD.addAction('get-by-url', {
+    method: 'get',
+    path: '/url/:url',
+    auth: false,
+    handler: 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) {
+          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 });
+      }
+    }
+  });
+
+  // Get user playlists - /api/playlists/user/:userId?
+  playlistsCRUD.addAction('user-playlists', {
+    method: 'get',
+    path: '/user/:userId?',
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const userId = req.params.userId || req.userId;
+        
+        // Если запрашивают чужие плейлисты, показываем только публичные
+        const query = { 'owner.target': userId };
+        if (userId !== req.userId) {
+          query.isPublic = true;
+        }
+        
+        const playlists = await db.playlist
+          .find(query)
+          .populate('tracks.track', 'title artist')
+          .sort({ updatedAt: -1 });
+        
+        res.json(playlists);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  // Add track to playlist - /api/playlists/:playlistId/tracks/:trackId
+  playlistsCRUD.addAction('add-track', {
+    method: 'post',
+    path: '/:playlistId/tracks/:trackId',
+    auth: true,
+    abac: {
+      resource: 'playlists',
+      action: 'update'
+    },
+    handler: async (req, res) => {
+      try {
+        const { playlistId, trackId } = req.params;
+        
+        // Проверяем существование трека
+        const track = await db.track.findById(trackId);
+        if (!track) {
+          return res.status(404).json({ error: 'Track not found' });
+        }
+        
+        // Проверяем, есть ли уже этот трек в плейлисте
+        const playlist = await db.playlist.findById(playlistId);
+        if (!playlist) {
+          return res.status(404).json({ error: 'Playlist not found' });
+        }
+        
+        const trackExists = playlist.tracks.some(t => t.track.toString() === trackId);
+        if (trackExists) {
+          return res.status(400).json({ error: 'Track already in playlist' });
+        }
+        
+        // Добавляем трек
+        playlist.tracks.push({
+          track: trackId,
+          addedAt: new Date()
+        });
+        
+        await playlist.save();
+        
+        res.json({ 
+          message: 'Track added to playlist successfully',
+          playlist
+        });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  // Remove track from playlist - /api/playlists/:playlistId/tracks/:trackId
+  playlistsCRUD.addAction('remove-track', {
+    method: 'delete',
+    path: '/:playlistId/tracks/:trackId',
+    auth: true,
+    abac: {
+      resource: 'playlists',
+      action: 'update'
+    },
+    handler: async (req, res) => {
+      try {
+        const { playlistId, trackId } = req.params;
+        
+        const playlist = await db.playlist.findById(playlistId);
+        if (!playlist) {
+          return res.status(404).json({ error: 'Playlist not found' });
+        }
+        
+        // Удаляем трек из плейлиста
+        playlist.tracks = playlist.tracks.filter(
+          t => t.track.toString() !== trackId
+        );
+        
+        await playlist.save();
+        
+        res.json({ 
+          message: 'Track removed from playlist successfully',
+          playlist
+        });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  // Add collaborator to playlist - /api/playlists/:playlistId/collaborators/:userId
+  playlistsCRUD.addAction('add-collaborator', {
+    method: 'post',
+    path: '/:playlistId/collaborators/:userId',
+    auth: true,
+    abac: {
+      resource: 'playlists',
+      action: 'update'
+    },
+    handler: async (req, res) => {
+      try {
+        const { playlistId, userId } = req.params;
+        
+        const playlist = await db.playlist.findById(playlistId);
+        if (!playlist) {
+          return res.status(404).json({ error: 'Playlist not found' });
+        }
+        
+        // Проверяем, не является ли пользователь уже коллабором
+        if (playlist.collaborators.includes(userId)) {
+          return res.status(400).json({ error: 'User is already a collaborator' });
+        }
+        
+        // Добавляем коллаборатора
+        playlist.collaborators.push(userId);
+        playlist.isCollaborative = true;
+        
+        await playlist.save();
+        
+        res.json({ 
+          message: 'Collaborator added successfully',
+          playlist
+        });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  return playlistsCRUD;
+}