@ozdao/martyrs 0.2.470 → 0.2.472

package/src/modules/music/components/player/MusicPlayer.vue

@@ -0,0 +1,202 @@
+<!-- components/player/MusicPlayer.vue -->
+<template>
+  <div class="music-player pd-small flex-between flex-v-center flex bg-dark br-t br-solid br-dark-transp-20 t-white">
+    <!-- Current Track Info -->
+    <div class="player-track-info flex-v-center flex w-25r">
+      <div v-if="currentTrack" class="player-track-cover mn-r-small">
+        <Media 
+          :url="currentTrack.coverUrl || (currentTrack.album && currentTrack.album.coverUrl) || '/assets/placeholder-track.jpg'" 
+          class="w-3r h-3r object-fit-cover radius-small"
+        />
+      </div>
+      
+      <div class="player-track-details t-truncate">
+        <div class="player-track-title t-white t-medium t-truncate">
+          {{ currentTrack?.title || 'No track playing' }}
+        </div>
+        <div class="player-track-artist t-grey t-small t-truncate">
+          {{ getArtistName(currentTrack) }}
+        </div>
+      </div>
+      
+      <div class="player-favorite mn-l-small">
+        <Button 
+          @click="toggleFavorite" 
+          class="bg-transparent border-none pd-zero"
+          :showLoader="false" 
+          :showSucces="false"
+        >
+          <IconHeart class="i-small" :fill="isFavorite ? 'rgb(var(--main))' : 'rgb(var(--grey))'"/>
+        </Button>
+      </div>
+    </div>
+    
+    <!-- Player Controls -->
+    <div class="player-controls flex-1 flex flex-column items-center">
+      <div class="player-buttons flex-v-center flex gap-small">
+        <Button 
+          @click="toggleShuffle" 
+          class="bg-transparent border-none pd-zero"
+          :showLoader="false" 
+          :showSucces="false"
+        >
+          <IconShuffle class="i-small" :fill="shuffle ? 'rgb(var(--main))' : 'rgb(var(--grey))'"/>
+        </Button>
+        
+        <Button 
+          @click="playPrevious" 
+          class="bg-transparent border-none pd-zero"
+          :showLoader="false" 
+          :showSucces="false"
+        >
+          <IconPrevious class="i-small" fill="rgb(var(--white))"/>
+        </Button>
+        
+        <Button 
+          @click="togglePlay" 
+          class="play-pause-btn bg-white radius-round pd-micro flex-center flex"
+          :showLoader="false" 
+          :showSucces="false"
+        >
+          <IconPause v-if="isPlaying" class="i-medium" fill="rgb(var(--black))"/>
+          <IconPlay v-else class="i-medium" fill="rgb(var(--black))"/>
+        </Button>
+        
+        <Button 
+          @click="playNext" 
+          class="bg-transparent border-none pd-zero"
+          :showLoader="false" 
+          :showSucces="false"
+        >
+          <IconNext class="i-small" fill="rgb(var(--white))"/>
+        </Button>
+        
+        <Button 
+          @click="toggleRepeat" 
+          class="bg-transparent border-none pd-zero"
+          :showLoader="false" 
+          :showSucces="false"
+        >
+          <IconRepeat class="i-small" :fill="repeatIcon"/>
+        </Button>
+      </div>
+      
+      <TrackProgress class="w-100 mn-t-thin" />
+    </div>
+    
+    <!-- Volume Control -->
+    <div class="player-volume flex-v-center flex w-15r">
+      <Button 
+        @click="toggleMute" 
+        class="bg-transparent border-none pd-zero mn-r-small"
+        :showLoader="false" 
+        :showSucces="false"
+      >
+        <IconVolume v-if="!muted && volume > 0.5" class="i-small" fill="rgb(var(--white))"/>
+        <IconVolumeHalf v-else-if="!muted && volume > 0" class="i-small" fill="rgb(var(--white))"/>
+        <IconVolumeMute v-else class="i-small" fill="rgb(var(--white))"/>
+      </Button>
+      
+      <VolumeControl />
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { computed, ref } from 'vue';
+import Media from '@martyrs/src/components/Media/Media.vue';
+import Button from '@martyrs/src/components/Button/Button.vue';
+import TrackProgress from './TrackProgress.vue';
+import VolumeControl from './VolumeControl.vue';
+
+// Import icons
+import IconPlay from '@martyrs/src/modules/icons/navigation/IconPlay.vue';
+import IconPause from '@martyrs/src/modules/icons/navigation/IconPause.vue';
+import IconNext from '@martyrs/src/modules/icons/navigation/IconChevronRight.vue';
+import IconPrevious from '@martyrs/src/modules/icons/navigation/IconChevronLeft.vue';
+import IconShuffle from '@martyrs/src/modules/icons/navigation/IconShuffle.vue';
+import IconRepeat from '@martyrs/src/modules/icons/navigation/IconRefresh.vue';
+import IconHeart from '@martyrs/src/modules/icons/navigation/IconHeart.vue';
+import IconVolume from '@martyrs/src/modules/icons/navigation/IconVolume.vue';
+// import IconVolumeHalf from '@martyrs/src/modules/icons/navigation/IconVolume.vue'; // Using same icon but we'd style it differently
+import IconVolumeMute from '@martyrs/src/modules/icons/navigation/IconMute.vue';
+
+// Import player store
+import { state as playerState, actions as playerActions } from '../../store/player.js';
+
+// State
+const isFavorite = ref(false);
+
+// Computed properties
+const currentTrack = computed(() => playerState.currentTrack);
+const isPlaying = computed(() => playerState.isPlaying);
+const volume = computed(() => playerState.volume);
+const muted = computed(() => playerState.muted);
+const shuffle = computed(() => playerState.shuffle);
+const repeat = computed(() => playerState.repeat);
+
+const repeatIcon = computed(() => {
+  switch(repeat.value) {
+    case 'one':
+      return 'rgb(var(--main))';
+    case 'all':
+      return 'rgb(var(--main))';
+    default:
+      return 'rgb(var(--grey))';
+  }
+});
+
+// Methods
+const togglePlay = () => {
+  playerActions.togglePlay();
+};
+
+const playNext = () => {
+  playerActions.playNext();
+};
+
+const playPrevious = () => {
+  playerActions.playPrevious();
+};
+
+const toggleShuffle = () => {
+  playerActions.toggleShuffle();
+};
+
+const toggleRepeat = () => {
+  playerActions.toggleRepeat();
+};
+
+const toggleMute = () => {
+  playerActions.toggleMute();
+};
+
+const toggleFavorite = () => {
+  isFavorite.value = !isFavorite.value;
+  // Implement favorite track logic here
+};
+
+const getArtistName = (track) => {
+  if (!track) return 'Unknown Artist';
+  
+  if (track.artist) {
+    if (typeof track.artist === 'object') {
+      return track.artist.name || 'Unknown Artist';
+    }
+    return track.artist;
+  }
+  return 'Unknown Artist';
+};
+</script>
+
+<style scoped>
+.play-pause-btn {
+  width: 32px;
+  height: 32px;
+  transition: transform 0.2s ease;
+}
+
+.play-pause-btn:hover {
+  transform: scale(1.1);
+}
+</style>

package/src/modules/music/components/player/TrackProgress.vue

@@ -0,0 +1,110 @@
+<!-- components/player/TrackProgress.vue -->
+<template>
+  <div class="track-progress flex flex-v-center gap-small">
+    <div class="current-time t-grey t-small">{{ formatTime(currentTime) }}</div>
+    
+    <div 
+      ref="progressBarContainer"
+      class="progress-bar-container flex-1 h-thin bg-grey radius-extra pos-relative cursor-pointer"
+      @click="seek"
+      @mousedown="startSeek"
+      @mousemove="updateSeekPosition"
+      @mouseup="endSeek"
+      @mouseleave="endSeek"
+    >
+      <div 
+        class="progress-bar h-100 bg-white radius-extra" 
+        :style="{ width: progressPercentage + '%' }"
+      ></div>
+      <div 
+        class="progress-handle w-thin h-thin bg-white radius-round pos-absolute pos-t-50 pos-l-0"
+        :style="{ left: `calc(${progressPercentage}% - 4px)`, transform: 'translateY(-50%)' }"
+      ></div>
+    </div>
+    
+    <div class="total-time t-grey t-small">{{ formatTime(duration) }}</div>
+  </div>
+</template>
+
+<script setup>
+import { ref, computed, onMounted, onUnmounted } from 'vue';
+
+// Import player store
+import { state as playerState, actions as playerActions } from '../../store/player.js';
+
+// Refs
+const progressBarContainer = ref(null);
+const isSeeking = ref(false);
+const seekPosition = ref(0);
+
+// Computed properties
+const currentTime = computed(() => playerState.currentTime);
+const duration = computed(() => playerState.duration);
+const progressPercentage = computed(() => {
+  if (!duration.value) return 0;
+  return Math.min(100, (currentTime.value / duration.value) * 100);
+});
+
+// Methods
+const formatTime = (seconds) => {
+  if (!seconds) return '0:00';
+  
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = Math.floor(seconds % 60);
+  
+  return `${minutes}:${remainingSeconds.toString().padStart(2, '0')}`;
+};
+
+const calculateSeekTime = (event) => {
+  if (!progressBarContainer.value || !duration.value) return 0;
+  
+  const rect = progressBarContainer.value.getBoundingClientRect();
+  const offsetX = event.clientX - rect.left;
+  const percentage = Math.max(0, Math.min(1, offsetX / rect.width));
+  
+  return percentage * duration.value;
+};
+
+const seek = (event) => {
+  const seekTime = calculateSeekTime(event);
+  playerActions.seek(seekTime);
+};
+
+const startSeek = (event) => {
+  isSeeking.value = true;
+  seekPosition.value = calculateSeekTime(event);
+};
+
+const updateSeekPosition = (event) => {
+  if (isSeeking.value) {
+    seekPosition.value = calculateSeekTime(event);
+  }
+};
+
+const endSeek = () => {
+  if (isSeeking.value) {
+    isSeeking.value = false;
+    playerActions.seek(seekPosition.value);
+  }
+};
+
+// Clean up event listeners when component is unmounted
+onUnmounted(() => {
+  isSeeking.value = false;
+});
+</script>
+
+<style scoped>
+.progress-bar-container:hover .progress-bar {
+  background-color: rgb(var(--main));
+}
+
+.progress-handle {
+  display: none;
+}
+
+.progress-bar-container:hover .progress-handle {
+  display: block;
+  transform: translateY(-50%) scale(1.3);
+}
+</style>

package/src/modules/music/components/player/VolumeControl.vue

@@ -0,0 +1,98 @@
+<!-- components/player/VolumeControl.vue -->
+<template>
+  <div 
+    ref="volumeBarContainer"
+    class="volume-bar-container w-100 h-thin bg-grey-transp-50 radius-extra pos-relative cursor-pointer"
+    @click="setVolume"
+    @mousedown="startVolumeChange"
+    @mousemove="updateVolumePosition"
+    @mouseup="endVolumeChange"
+    @mouseleave="endVolumeChange"
+  >
+    <div 
+      class="volume-bar h-100 bg-white radius-extra" 
+      :style="{ width: volumePercentage + '%' }"
+      :class="{ 'muted': muted }"
+    ></div>
+    <div 
+      class="volume-handle w-thin h-thin bg-white radius-round pos-absolute pos-t-50 pos-l-0"
+      :style="{ 
+        left: `calc(${volumePercentage}% - 4px)`, 
+        transform: 'translateY(-50%)',
+        opacity: muted ? 0 : 1
+      }"
+    ></div>
+  </div>
+</template>
+
+<script setup>
+import { ref, computed } from 'vue';
+
+// Import player store
+import { state as playerState, actions as playerActions } from '../../store/player.js';
+
+// Refs
+const volumeBarContainer = ref(null);
+const isChangingVolume = ref(false);
+
+// Computed properties
+const volume = computed(() => playerState.volume);
+const muted = computed(() => playerState.muted);
+const volumePercentage = computed(() => {
+  if (muted.value) return 0;
+  return volume.value * 100;
+});
+
+// Methods
+const calculateVolume = (event) => {
+  if (!volumeBarContainer.value) return 0;
+  
+  const rect = volumeBarContainer.value.getBoundingClientRect();
+  const offsetX = event.clientX - rect.left;
+  
+  return Math.max(0, Math.min(1, offsetX / rect.width));
+};
+
+const setVolume = (event) => {
+  const newVolume = calculateVolume(event);
+  playerActions.setVolume(newVolume);
+  
+  // Unmute if was muted
+  if (muted.value && newVolume > 0) {
+    playerActions.toggleMute();
+  }
+};
+
+const startVolumeChange = (event) => {
+  isChangingVolume.value = true;
+  setVolume(event);
+};
+
+const updateVolumePosition = (event) => {
+  if (isChangingVolume.value) {
+    setVolume(event);
+  }
+};
+
+const endVolumeChange = () => {
+  isChangingVolume.value = false;
+};
+</script>
+
+<style scoped>
+.volume-bar-container:hover .volume-bar:not(.muted) {
+  background-color: rgb(var(--main));
+}
+
+.volume-handle {
+  display: none;
+}
+
+.volume-bar-container:hover .volume-handle {
+  display: block;
+}
+
+.muted {
+  opacity: 0.5;
+}
+</style>

package/src/modules/music/controllers/album.controller.js

@@ -0,0 +1,98 @@
+// controllers/album.controller.js
+const globalsQuery = require('@martyrs/src/modules/globals/controllers/utils/queryProcessor');
+
+module.exports = function(app,db) {
+  const { MusicController } = require('./music.controller')(app,db);
+  
+  class AlbumController extends MusicController {
+    constructor(app) {
+      super('/api/albums', app, db, db.album);
+    }
+    
+    // Get tracks for a specific album
+    async getAlbumTracks(req, res) {
+      try {
+        const albumId = req.params.albumId;
+        
+        // Check if album exists and user has access
+        const album = await db.album.findById(albumId);
+        if (!album) {
+          return res.status(404).json({ error: 'Album not found' });
+        }
+        
+        // Check access using ABAC
+        const accessResult = await this.abac.checkAccess({
+          user: req.userId,
+          resource: 'albums',
+          action: 'read',
+          currentResource: album
+        });
+        
+        if (!accessResult.allowed && !album.isPublic) {
+          return res.status(403).json({ 
+            errorCode: accessResult.reason,
+            message: 'Access Denied'
+          });
+        }
+        
+        // Find tracks for this album
+        const tracks = await db.track.find({ album: albumId, status: 'published' })
+          .sort({ releaseDate: -1 });
+        
+        res.json(tracks);
+      } catch (error) {
+        this.logger.error(`Error getting album tracks: ${error.message}`);
+        res.status(500).json({ error: error.message });
+      }
+    }
+    
+    // Get featured albums
+    async getFeaturedAlbums(req, res) {
+      try {
+        const cacheKey = 'featured-albums';
+        let featuredAlbums = await this.cache.get(cacheKey);
+        
+        if (!featuredAlbums) {
+          // Get featured albums with track counts
+          featuredAlbums = await db.album.aggregate([
+            { $match: { status: 'featured', isPublic: true } },
+            {
+              $lookup: {
+                from: 'tracks',
+                localField: '_id',
+                foreignField: 'album',
+                as: 'tracks'
+              }
+            },
+            {
+              $addFields: {
+                trackCount: { $size: '$tracks' }
+              }
+            },
+            { $project: { tracks: 0 } },
+            { $sort: { releaseDate: -1 } },
+            { $limit: 10 }
+          ]);
+          
+          await this.cache.set(cacheKey, featuredAlbums, 3600); // Cache for 1 hour
+        }
+        
+        res.json(featuredAlbums);
+      } catch (error) {
+        this.logger.error(`Error getting featured albums: ${error.message}`);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  }
+  
+  const albumController = new AlbumController(app,db); // Pass app in actual implementation
+  
+  return {
+    create: albumController.create.bind(albumController),
+    read: albumController.read.bind(albumController),
+    update: albumController.update.bind(albumController),
+    delete: albumController.delete.bind(albumController),
+    getAlbumTracks: albumController.getAlbumTracks.bind(albumController),
+    getFeaturedAlbums: albumController.getFeaturedAlbums.bind(albumController)
+  };
+};

package/src/modules/music/controllers/artist.controller.js

@@ -0,0 +1,111 @@
+// controllers/artist.controller.js (continued)
+module.exports = function(app,db) {
+  const { MusicController } = require('./music.controller')(app,db);
+  
+  class ArtistController extends MusicController {
+    constructor(app) {
+      super('/api/artists', app, db, db.artist);
+    }
+    
+    // Get artist discography
+    async getDiscography(req, res) {
+      try {
+        const artistId = req.params.artistId;
+        
+        // Verify artist exists
+        const artist = await db.artist.findById(artistId);
+        if (!artist) {
+          return res.status(404).json({ error: 'Artist not found' });
+        }
+        
+        // Get all albums by this artist
+        const albums = await db.album.find({
+          artist: artistId,
+          status: 'published',
+          isPublic: true
+        }).sort({ releaseDate: -1 });
+        
+        // Get all tracks not in albums
+        const singleTracks = await db.track.find({
+          artist: artistId,
+          album: { $exists: false },
+          status: 'published',
+          isPublic: true
+        }).sort({ releaseDate: -1 });
+        
+        res.json({
+          artist,
+          albums,
+          singles: singleTracks
+        });
+      } catch (error) {
+        this.logger.error(`Error getting artist discography: ${error.message}`);
+        res.status(500).json({ error: error.message });
+      }
+    }
+    
+    // Verify an artist (admin only)
+    async verifyArtist(req, res) {
+      try {
+        const artistId = req.params.artistId;
+        
+        // Check if user is admin
+        if (!req.userRoles.includes('ROLE_ADMIN')) {
+          return res.status(403).json({ error: 'Only administrators can verify artists' });
+        }
+        
+        const artist = await db.artist.findById(artistId);
+        if (!artist) {
+          return res.status(404).json({ error: 'Artist not found' });
+        }
+        
+        artist.isVerified = true;
+        await artist.save();
+        
+        await this.cache.flush();
+        
+        res.json({ success: true, artist });
+      } catch (error) {
+        this.logger.error(`Error verifying artist: ${error.message}`);
+        res.status(500).json({ error: error.message });
+      }
+    }
+    
+    // Get related artists
+    async getRelatedArtists(req, res) {
+      try {
+        const artistId = req.params.artistId;
+        
+        // Find genres of this artist
+        const artist = await db.artist.findById(artistId);
+        if (!artist) {
+          return res.status(404).json({ error: 'Artist not found' });
+        }
+        
+        // Get artists with similar genres
+        const relatedArtists = await db.artist.find({
+          _id: { $ne: artistId },
+          genre: { $in: artist.genre },
+          status: 'published'
+        }).limit(5);
+        
+        res.json(relatedArtists);
+      } catch (error) {
+        this.logger.error(`Error getting related artists: ${error.message}`);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  }
+  
+  const artistController = new ArtistController(app,db);
+  
+  return {
+    create: artistController.create.bind(artistController),
+    read: artistController.read.bind(artistController),
+    update: artistController.update.bind(artistController),
+    delete: artistController.delete.bind(artistController),
+    getDiscography: artistController.getDiscography.bind(artistController),
+    verifyArtist: artistController.verifyArtist.bind(artistController),
+    getRelatedArtists: artistController.getRelatedArtists.bind(artistController)
+  };
+};

package/src/modules/music/controllers/genre.controller.js

@@ -0,0 +1,71 @@
+// controllers/genre.controller.js
+module.exports = function(app,db) {
+  const { MusicController } = require('./music.controller')(app,db);
+  
+  class GenreController extends MusicController {
+    constructor(app) {
+      super('/api/genres', app, db, db.genre);
+    }
+    
+    // Get tracks by genre
+    async getGenreTracks(req, res) {
+      try {
+        const genreId = req.params.genreId;
+        
+        // Verify genre exists
+        const genre = await db.genre.findById(genreId);
+        if (!genre) {
+          return res.status(404).json({ error: 'Genre not found' });
+        }
+        
+        // Get tracks from this genre
+        const tracks = await db.track.find({
+          genre: genreId,
+          status: 'published',
+          isPublic: true
+        })
+        .sort({ releaseDate: -1 })
+        .limit(50)
+        .populate('artist', 'name')
+        .populate('album', 'title coverUrl');
+        
+        res.json({
+          genre,
+          tracks
+        });
+      } catch (error) {
+        this.logger.error(`Error getting genre tracks: ${error.message}`);
+        res.status(500).json({ error: error.message });
+      }
+    }
+    
+    // Get popular genres
+    async getPopularGenres(req, res) {
+      try {
+        const limit = parseInt(req.query.limit) || 10;
+        
+        const genres = await db.genre.find({
+          status: 'published'
+        })
+        .sort({ popularity: -1 })
+        .limit(limit);
+        
+        res.json(genres);
+      } catch (error) {
+        this.logger.error(`Error getting popular genres: ${error.message}`);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  }
+  
+  const genreController = new GenreController(app,db);
+  
+  return {
+    create: genreController.create.bind(genreController),
+    read: genreController.read.bind(genreController),
+    update: genreController.update.bind(genreController),
+    delete: genreController.delete.bind(genreController),
+    getGenreTracks: genreController.getGenreTracks.bind(genreController),
+    getPopularGenres: genreController.getPopularGenres.bind(genreController)
+  };
+};