@ozdao/martyrs 0.2.564 → 0.2.566

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

@@ -0,0 +1,151 @@
+<template>
+  <div class="">
+    <canvas class="w-100 h-100" style="transform: rotate(-90deg)" id="audiowaves" ref="audiowaves"/>
+  </div>
+</template>
+
+
+<style lang="scss">
+</style>
+
+<script setup>
+import { ref, reactive,onMounted, onUnmounted, watchEffect } from 'vue';
+import { App } from '@capacitor/app';
+
+import * as radioStore from './radio.store.js';
+
+const props = defineProps({
+  options: {
+    type: Object,
+    default: {
+      position: false
+    }
+  }
+})
+
+const audiowaves = ref(null)
+const cleanupResources = ref([]);
+
+let audio, context, source, splitter, procNode, analChannel_0, analChannel_1;
+
+App.addListener('appStateChange', ({ isActive }) => {
+  isActive ? initFullPlayer() : removeFullPlayer()
+});
+
+const stopAudioAndContext = async () => {
+  if (source) await source.disconnect();
+  if (context) await context.close();
+};
+
+async function initFullPlayer () {
+  audio = await radioStore.getPlayerInstance()
+  context = await radioStore.getContextInstance()
+  source = await radioStore.getSourceInstance(context,audio)
+
+  let c = document.getElementById('audiowaves');
+
+  if (c) { 
+    let $ = c.getContext('2d');
+    let w = c.width = global.innerWidth;
+    let h = c.height = global.innerHeight;
+
+    //number of frequency bins to be displayed for each channel
+    let NUMBER_OF_COLUMNS = 1300;
+    let COLUMN_WIDTH = w / NUMBER_OF_COLUMNS;
+    let MIDDLE_HEIGHT = Math.round(h / 2);
+    let ANALYSERS_FFT_SIZE = 4096;
+    let HUE_STEP = Math.round(360 / 256);
+
+    let i, value;
+
+    //color step for frequency values
+    visualise(new Array(NUMBER_OF_COLUMNS), new Array(NUMBER_OF_COLUMNS));
+   
+    analChannel_0 = context.createAnalyser();
+    analChannel_1 = context.createAnalyser();
+
+    analChannel_0.fftSize = analChannel_1.fftSize = ANALYSERS_FFT_SIZE;
+
+    splitter = context.createChannelSplitter(2);
+    splitter.connect(analChannel_0, 0);
+    splitter.connect(analChannel_1, 1);
+
+    //processing node callback to be called every 1024 samples collected
+    procNode = context.createScriptProcessor(1024);
+    procNode.connect(context.destination);
+    procNode.onaudioprocess = function(event) {
+      let array0 = new Uint8Array(analChannel_0.frequencyBinCount);
+      analChannel_0.getByteFrequencyData(array0);
+      let array1 = new Uint8Array(analChannel_1.frequencyBinCount);
+      analChannel_1.getByteFrequencyData(array1);
+      
+      visualise(array0, array1);
+    }
+
+    source.connect(procNode);
+    source.connect(splitter);
+
+    cleanupResources.value.push(() => procNode.disconnect());
+    cleanupResources.value.push(() => splitter.disconnect());
+    cleanupResources.value.push(() => analChannel_0.disconnect());
+    cleanupResources.value.push(() => analChannel_1.disconnect());
+    cleanupResources.value.push(stopAudioAndContext);
+
+    
+    function visualise(array0, array1) {
+
+      $.clearRect(0, 0, w, h);
+      $.fillStyle = 'black';
+      $.fillRect(0, 0, w, h);
+
+
+      for (i = 0; i < NUMBER_OF_COLUMNS; i++) {
+          value = array0[i] * radioStore.state.volume || 1;
+          $.fillStyle = 'hsl(' + ((value * HUE_STEP) - 180) + ', 100%, 81%)'; // Adjusted saturation and lightness
+          $.fillRect(i * COLUMN_WIDTH, MIDDLE_HEIGHT - (value * 0.7 || 1), COLUMN_WIDTH, 256);
+      }
+
+      $.clearRect(0, h / 2, w, h / 2);
+      $.fillStyle = 'black';
+      $.fillRect(0, h / 2, w, h / 2);
+
+      for (i = 0; i < NUMBER_OF_COLUMNS; i++) {
+          value = array1[i] * radioStore.state.volume || 1;
+          $.fillStyle = 'hsl(' + ((value * HUE_STEP) - 180) + ', 100%, 81%)'; // Adjusted saturation and lightness
+          $.fillRect(i * COLUMN_WIDTH, MIDDLE_HEIGHT + 1, COLUMN_WIDTH, value * 0.7 || 1);
+      }
+    }
+  }
+}
+
+async function removeFullPlayer () {
+  cleanupResources.value.forEach(cleanup => cleanup());
+
+  audio = null
+  context = null
+  source = null
+
+  radioStore.state.context = null
+  radioStore.state.source = null
+  radioStore.state.gain = null
+  radioStore.state.player = null
+
+
+  let playerNew = radioStore.getPlayerInstance()
+  radioStore.state.player.volume = radioStore.state.volume;
+
+  if (radioStore.state.isPlaying) {
+    await playerNew.play()
+  }
+}
+
+onMounted(async() => {
+  await initFullPlayer()
+});
+
+onUnmounted(async() => {
+  await removeFullPlayer()
+  App.removeAllListeners()
+});
+
+</script>

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

@@ -1,28 +1,42 @@
 <!-- components/player/VolumeControl.vue -->
 <template>
-  <div class="volume-control">
-    <div 
-      ref="volumeBarContainer"
-      class="volume-bar-container"
-      @click="setVolume"
-      @mousedown="startVolumeChange"
-      @mousemove="updateVolumePosition"
-      @mouseup="endVolumeChange"
-      @mouseleave="endVolumeChange"
+  <div class="volume-section">
+    <Button
+      @click="playerActions.toggleMute()"
+      class="volume-btn"
+      :showLoader="false"
+      :showSucces="false"
     >
-      <div 
-        class="volume-track"
-        :style="{ 
-          background: `linear-gradient(to right, rgb(var(--black)) 0%, rgb(var(--black)) ${volumePercentage}%, rgb(var(--grey)) ${volumePercentage}%, rgb(var(--grey)) 100%)`
-        }"
-      >
-        <div 
-          class="volume-thumb"
-          :style="{ 
-            left: `${volumePercentage}%`,
-            opacity: muted ? 0 : 1
-          }"
-        ></div>
+      <IconMute v-if="muted || volume < 0.005" fill="rgb(var(--black))" class="volume-icon"/>
+      <IconUnMute v-else fill="rgb(var(--black))" class="volume-icon"/>
+    </Button>
+
+    <div class="volume-slider">
+      <div class="volume-control">
+        <div
+          ref="volumeBarContainer"
+          class="volume-bar-container"
+          @click="setVolume"
+          @mousedown="startVolumeChange"
+          @mousemove="updateVolumePosition"
+          @mouseup="endVolumeChange"
+          @mouseleave="endVolumeChange"
+        >
+          <div
+            class="volume-track"
+            :style="{
+              background: `linear-gradient(to right, rgb(var(--black)) 0%, rgb(var(--black)) ${volumePercentage}%, rgb(var(--grey)) ${volumePercentage}%, rgb(var(--grey)) 100%)`
+            }"
+          >
+            <div
+              class="volume-thumb"
+              :style="{
+                left: `${volumePercentage}%`,
+                opacity: muted ? 0 : 1
+              }"
+            ></div>
+          </div>
+        </div>
       </div>
     </div>
   </div>
@@ -30,6 +44,9 @@
 
 <script setup>
 import { ref, computed } from 'vue';
+import Button from '@martyrs/src/components/Button/Button.vue';
+import IconMute from '@martyrs/src/modules/icons/navigation/IconMute.vue';
+import IconUnMute from '@martyrs/src/modules/icons/navigation/IconUnMute.vue';
 
 // Import player store
 import { state as playerState, actions as playerActions } from '../../store/player.js';
@@ -83,6 +100,41 @@ const endVolumeChange = () => {
 </script>
 
 <style scoped>
+.volume-section {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  justify-content: center;
+  width: 100%;
+}
+
+.volume-btn {
+  background: none;
+  border: none;
+  color: rgb(var(--black));
+  cursor: pointer;
+  padding: 8px;
+  border-radius: 50%;
+  transition: all 0.2s ease;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+}
+
+.volume-icon {
+  width: 16px;
+  height: 16px;
+}
+
+.volume-btn:hover {
+  background: rgba(var(--black),0.1);
+}
+
+.volume-slider {
+  flex: 1;
+}
+
 .volume-control {
   width: 100%;
 }
@@ -109,7 +161,7 @@ const endVolumeChange = () => {
   top: 50%;
   width: 12px;
   height: 12px;
-   background: rgb(var(--black));
+  background: rgb(var(--black));
   border: 1px solid rgba(var(--white),0.1);
   border-radius: 50%;
   transform: translate(-50%, -50%);

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

@@ -1,4 +1,4 @@
-import coreabac from '@martyrs/src/modules/core/controllers/classes/core.abac.js';
+import coreabac from '@martyrs/src/modules/core/controllers/classes/abac/abac.js';
 import Logger from '@martyrs/src/modules/core/controllers/classes/core.logger.js';
 import fs from 'fs';
 import path from 'path';

package/src/modules/music/music.server.js

@@ -1,4 +1,4 @@
-import coreabac from '@martyrs/src/modules/core/controllers/classes/core.abac.js';
+import coreabac from '@martyrs/src/modules/core/controllers/classes/abac/abac.js';
 import Cache from '@martyrs/src/modules/core/controllers/classes/core.cache.js';
 import Logger from '@martyrs/src/modules/core/controllers/classes/core.logger.js';
 

package/src/modules/music/policies/music.policies.js

@@ -10,8 +10,9 @@ export default (function initializeMusicPolicies(abacAccessControl) {
     // For create actions, verify ownership
     if (action === 'create') {
       // Ensure that creator.target matches the authenticated user
-      if (context.data.creator && context.data.creator.target) {
-        return context.data.creator.target.toString() === user.toString();
+      const creator = context.data.body?.creator;
+      if (creator?.target) {
+        return creator.target.toString() === user.toString();
       }
       return false;
     }

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

@@ -0,0 +1,26 @@
+export function getRoutes(options = {}) {
+  const route = options.route || 'Home';
+  const routes = [];
+
+  routes.push({
+    parentName: route,
+    config: {
+      basePath: 'music',
+      routes: [
+        {
+          path: 'library',
+          name: 'music-library',
+          component: () => import(/* webpackChunkName: 'music-library' */ '../components/pages/MusicLibrary.vue'),
+          meta: {
+            title: 'My Library',
+            requiresAuth: true,
+          },
+        },
+      ],
+    },
+  });
+
+  return routes;
+}
+
+export default { getRoutes };

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

@@ -0,0 +1,176 @@
+function createArtistRoutes() {
+  return [
+    {
+      path: 'artists/create',
+      name: 'artist-create',
+      component: () => import(/* webpackChunkName: 'music-artist-create' */ '../components/pages/ArtistCreate.vue'),
+      meta: {
+        title: 'Create Artist',
+        requiresAuth: true,
+      },
+    },
+    {
+      path: 'artists/:url/edit',
+      name: 'artist-edit',
+      component: () => import(/* webpackChunkName: 'music-artist-edit' */ '../components/pages/ArtistEdit.vue'),
+      props: true,
+      meta: {
+        title: 'Edit Artist',
+        requiresAuth: true,
+      },
+    },
+    {
+      path: 'artists/:url',
+      name: 'artist',
+      component: () => import(/* webpackChunkName: 'music-artist' */ '../components/pages/Artist.vue'),
+      props: true,
+      meta: {
+        title: 'Artist',
+      },
+    },
+  ];
+}
+
+function createAlbumRoutes() {
+  return [
+    {
+      path: 'albums/create',
+      name: 'album-create',
+      component: () => import(/* webpackChunkName: 'music-album-create' */ '../components/pages/AlbumCreate.vue'),
+      meta: {
+        title: 'Create Album',
+        requiresAuth: true,
+      },
+    },
+    {
+      path: 'albums/:url/edit',
+      name: 'album-edit',
+      component: () => import(/* webpackChunkName: 'music-album-edit' */ '../components/pages/AlbumEdit.vue'),
+      props: true,
+      meta: {
+        title: 'Edit Album',
+        requiresAuth: true,
+      },
+    },
+    {
+      path: 'albums/:url',
+      name: 'album',
+      component: () => import(/* webpackChunkName: 'music-album' */ '../components/pages/Album.vue'),
+      props: true,
+      meta: {
+        title: 'Album',
+      },
+    },
+  ];
+}
+
+function createTrackRoutes() {
+  return [
+    {
+      path: 'tracks/create',
+      name: 'track-create',
+      component: () => import(/* webpackChunkName: 'music-track-create' */ '../components/pages/TrackCreate.vue'),
+      meta: {
+        title: 'Create Track',
+        requiresAuth: true,
+      },
+    },
+    {
+      path: 'tracks/:url/edit',
+      name: 'track-edit',
+      component: () => import(/* webpackChunkName: 'music-track-edit' */ '../components/pages/TrackEdit.vue'),
+      props: true,
+      meta: {
+        title: 'Edit Track',
+        requiresAuth: true,
+      },
+    },
+    {
+      path: 'tracks/:url',
+      name: 'track',
+      component: () => import(/* webpackChunkName: 'music-track' */ '../components/pages/Track.vue'),
+      props: true,
+      meta: {
+        title: 'Track',
+      },
+    },
+  ];
+}
+
+function createPlaylistRoutes() {
+  return [
+    {
+      path: 'playlists/create',
+      name: 'playlist-create',
+      component: () => import(/* webpackChunkName: 'music-playlist-create' */ '../components/pages/PlaylistCreate.vue'),
+      meta: {
+        title: 'Create Playlist',
+        requiresAuth: true,
+      },
+    },
+    {
+      path: 'playlists/:url/edit',
+      name: 'playlist-edit',
+      component: () => import(/* webpackChunkName: 'music-playlist-edit' */ '../components/pages/PlaylistEdit.vue'),
+      props: true,
+      meta: {
+        title: 'Edit Playlist',
+        requiresAuth: true,
+      },
+    },
+    {
+      path: 'playlists/:url',
+      name: 'playlist',
+      component: () => import(/* webpackChunkName: 'music-playlist' */ '../components/pages/Playlist.vue'),
+      props: true,
+      meta: {
+        title: 'Playlist',
+      },
+    },
+  ];
+}
+
+function buildMusicRoutes() {
+  return [
+    {
+      path: '',
+      name: 'music-home',
+      component: () => import(/* webpackChunkName: 'music-home' */ '../components/pages/MusicHome.vue'),
+      meta: {
+        title: 'Music Home',
+      },
+    },
+    {
+      path: 'search',
+      name: 'music-search',
+      component: () => import(/* webpackChunkName: 'music-search' */ '../components/pages/SearchResults.vue'),
+      meta: {
+        title: 'Search Music',
+      },
+    },
+    ...createArtistRoutes(),
+    ...createAlbumRoutes(),
+    ...createTrackRoutes(),
+    ...createPlaylistRoutes(),
+  ];
+}
+
+export function getRoutes(options = {}) {
+  const route = options.route || 'Home';
+  const routes = [];
+
+  routes.push({
+    parentName: route,
+    config: {
+      basePath: options.basePath || 'music',
+      meta: {
+        player: options.playerComponent || (() => import(/* webpackChunkName: 'music-bottom-player' */ '../components/layouts/MusicBottomPlayer.vue')),
+      },
+      routes: buildMusicRoutes(options),
+    },
+  });
+
+  return routes;
+}
+
+export default { getRoutes };

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

@@ -119,33 +119,34 @@ export default function setupAlbumsRoutes(app, db) {
     handler: async (req, res) => {
       try {
         const limit = parseInt(req.query.limit) || 10;
-        
-        // Получаем рекомендуемые альбомы (можно добавить поле featured в модель)
-        // Пока используем популярные недавние альбомы
+        const skip = parseInt(req.query.skip) || 0;
+        const sortParam = req.query.sortParam || 'releaseDate';
+        const sortOrder = req.query.sortOrder === 'asc' ? 1 : -1;
+
+        const sortObject = { [sortParam]: sortOrder };
+
         const featuredAlbums = await db.album
-          .find({ 
-            status: 'published',
-            releaseDate: { 
-              $gte: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000) // последние 90 дней
-            }
+          .find({
+            status: 'published'
           })
           .populate('artists', 'name url photoUrl isVerified')
-          .sort({ createdAt: -1 })
+          .sort(sortObject)
+          .skip(skip)
           .limit(limit);
 
         // Update totalTracks count for each album
         for (const album of featuredAlbums) {
-          const trackCount = await db.track.countDocuments({ 
+          const trackCount = await db.track.countDocuments({
             album: album._id,
             status: 'published'
           });
-          
+
           if (album.totalTracks !== trackCount) {
             album.totalTracks = trackCount;
             await album.save();
           }
         }
-        
+
         res.json(featuredAlbums);
       } catch (error) {
         console.error(error);

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

@@ -49,6 +49,7 @@ export default function setupTracksRoutes(app, db) {
   tracksCRUD.policies.disableForAction('recent');
   tracksCRUD.policies.disableForAction('popular');
   tracksCRUD.policies.disableForAction('by-genre');
+  tracksCRUD.policies.disableForAction('related');
 
   // Перенос кастомных роутов через addAction для обратной совместимости
 
@@ -170,5 +171,43 @@ export default function setupTracksRoutes(app, db) {
     }
   });
 
+  // Get related tracks by track URL - /api/tracks/related/:trackUrl
+  tracksCRUD.addAction('related', {
+    method: 'get',
+    path: '/related/:trackUrl',
+    auth: false,
+    abac: { enabled: false },
+    handler: async (req, res) => {
+      try {
+        // Найти трек по URL
+        const track = await db.track.findOne({ url: req.params.trackUrl });
+
+        if (!track) {
+          return res.status(404).json({ error: 'Track not found' });
+        }
+
+        const limit = parseInt(req.query.limit) || 10;
+
+        // Получить другие треки этого же артиста
+        const relatedTracks = await db.track
+          .find({
+            artist: track.artist,
+            _id: { $ne: track._id }, // Исключить текущий трек
+            status: 'published',
+            isPublic: true,
+          })
+          .populate('artist', 'name url photoUrl isVerified')
+          .populate('album', 'title url coverArt')
+          .sort({ playCount: -1, releaseDate: -1 })
+          .limit(limit);
+
+        res.json(relatedTracks);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
   return tracksCRUD;
 }

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

@@ -32,10 +32,18 @@ export const actions = {
     }
   },
 
-  async fetchFeaturedAlbums() {
+  async fetchFeaturedAlbums(options = {}) {
     state.loadingFeatured = true;
     try {
-      const response = await fetch(`${process.env.API_URL}/api/albums/featured`);
+      const queryParams = new URLSearchParams();
+
+      if (options.limit) queryParams.append('limit', options.limit);
+      if (options.skip) queryParams.append('skip', options.skip);
+      if (options.sortParam) queryParams.append('sortParam', options.sortParam);
+      if (options.sortOrder) queryParams.append('sortOrder', options.sortOrder);
+
+      const url = `${process.env.API_URL}/api/albums/featured${queryParams.toString() ? '?' + queryParams.toString() : ''}`;
+      const response = await fetch(url);
       const albums = await response.json();
       state.featured = albums;
       return albums;