@ozdao/martyrs 0.2.485 → 0.2.487

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

@@ -0,0 +1,149 @@
+// @martyrs/src/modules/music/routes/tracks.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 tracksVerifierFactory from '../middlewares/tracks.verifier.js';
+
+const { getInstance } = ABAC;
+
+export default function setupTracksRoutes(app, db) {
+  const abac = getInstance(db);
+  const verifier = tracksVerifierFactory(db);
+
+  // Основной CRUD для tracks
+  const tracksCRUD = new CRUD({
+    app,
+    db,
+    model: db.track,
+    modelName: 'track',
+    basePath: '/api/tracks',
+    
+    auth: true,
+    
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    
+    abac: abac,
+    
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ['tracks', 'music']
+    },
+    
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+
+  // Перенос кастомных роутов через addAction для обратной совместимости
+
+  // Get track by URL - /api/tracks/url/:url
+  tracksCRUD.addAction('get-by-url', {
+    method: 'get',
+    path: '/url/:url',
+    auth: false,
+    handler: 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 - /api/tracks/recent
+  tracksCRUD.addAction('recent', {
+    method: 'get',
+    path: '/recent',
+    auth: false,
+    handler: 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 - /api/tracks/popular
+  tracksCRUD.addAction('popular', {
+    method: 'get',
+    path: '/popular',
+    auth: false,
+    handler: 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 - /api/tracks/genre/:genreId
+  tracksCRUD.addAction('by-genre', {
+    method: 'get',
+    path: '/genre/:genreId',
+    auth: false,
+    handler: 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 });
+      }
+    }
+  });
+
+  return tracksCRUD;
+}

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

@@ -36,18 +36,28 @@ export const actions = {
     }
   },
 
-  async fetchTopArtists(limit = 10) {
+  async fetchTopArtists(options = {}) {
     state.loadingTopArtists = true;
     try {
-      // Assuming the backend sorts by popularity
-      const options = {
-        limit,
-        sortParam: 'popularity',
-        sortOrder: 'desc',
+      // Обрабатываем options от Feed компонента
+      const queryOptions = {
+        limit: options.limit || 10,
+        sortParam: options.sortParam || 'popularity',
+        sortOrder: options.sortOrder || 'desc',
         status: 'published',
       };
+      
+      // Добавляем дополнительные параметры если есть
+      if (options.skip) queryOptions.skip = options.skip;
+      if (options.search) queryOptions.search = options.search;
+      
+      // Если указан top=true, используем сортировку по популярности
+      if (options.top) {
+        queryOptions.sortParam = 'popularity';
+        queryOptions.sortOrder = 'desc';
+      }
 
-      const artists = await artistStore.read(options);
+      const artists = await artistStore.read(queryOptions);
       state.topArtists = artists;
       return artists;
     } catch (error) {

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

@@ -0,0 +1,150 @@
+// store/genres.js
+import Store from '@martyrs/src/modules/globals/views/classes/globals.store.js';
+import { reactive } from 'vue';
+
+// Create store instance
+const genreStore = new Store(`${process.env.API_URL}/api/genres`);
+
+// State
+export const state = reactive({
+  genres: [],
+  popularGenres: [],
+  currentGenre: null,
+  genreTracks: [],
+  isLoading: false,
+  loadingPopular: false,
+});
+
+// Actions
+export const actions = {
+  async fetchGenres(options = {}) {
+    state.isLoading = true;
+    try {
+      const genres = await genreStore.read(options);
+      state.genres = genres;
+      return genres;
+    } catch (error) {
+      console.error('Error fetching genres:', error);
+      return [];
+    } finally {
+      state.isLoading = false;
+    }
+  },
+
+  async fetchPopularGenres(options = {}) {
+    state.loadingPopular = true;
+    try {
+      // Обрабатываем options от Feed компонента
+      const queryOptions = {
+        limit: options.limit || 10,
+        sortParam: options.sortParam || 'popularity',
+        sortOrder: options.sortOrder || 'desc',
+        status: 'published',
+      };
+      
+      // Добавляем дополнительные параметры если есть
+      if (options.skip) queryOptions.skip = options.skip;
+      if (options.search) queryOptions.search = options.search;
+      
+      // Если указан popular=true, используем сортировку по популярности
+      if (options.popular) {
+        queryOptions.sortParam = 'popularity';
+        queryOptions.sortOrder = 'desc';
+      }
+
+      const genres = await genreStore.read(queryOptions);
+      state.popularGenres = genres;
+      return genres;
+    } catch (error) {
+      console.error('Error fetching popular genres:', error);
+      return [];
+    } finally {
+      state.loadingPopular = false;
+    }
+  },
+
+  async fetchGenreByUrl(url) {
+    try {
+      const response = await fetch(`${process.env.API_URL}/api/genres/url/${url}`);
+      const genre = await response.json();
+      state.currentGenre = genre;
+
+      // Fetch genre tracks
+      await this.fetchGenreTracks(genre._id);
+
+      return genre;
+    } catch (error) {
+      console.error('Error fetching genre by URL:', error);
+      return null;
+    }
+  },
+
+  async fetchGenreTracks(genreId) {
+    try {
+      const response = await fetch(`${process.env.API_URL}/api/genres/${genreId}/tracks`);
+      const tracks = await response.json();
+      state.genreTracks = tracks;
+      return tracks;
+    } catch (error) {
+      console.error('Error fetching genre tracks:', error);
+      return [];
+    }
+  },
+
+  async createGenre(genreData) {
+    try {
+      const createdGenre = await genreStore.create(genreData);
+      // Update local state
+      state.genres.unshift(createdGenre);
+      return createdGenre;
+    } catch (error) {
+      console.error('Error creating genre:', error);
+      throw error;
+    }
+  },
+
+  async updateGenre(genreData) {
+    try {
+      const updatedGenre = await genreStore.update(genreData);
+
+      // Update local state
+      const index = state.genres.findIndex(g => g._id === updatedGenre._id);
+      if (index !== -1) {
+        state.genres[index] = updatedGenre;
+      }
+
+      const popularIndex = state.popularGenres.findIndex(g => g._id === updatedGenre._id);
+      if (popularIndex !== -1) {
+        state.popularGenres[popularIndex] = updatedGenre;
+      }
+
+      if (state.currentGenre && state.currentGenre._id === updatedGenre._id) {
+        state.currentGenre = updatedGenre;
+      }
+
+      return updatedGenre;
+    } catch (error) {
+      console.error('Error updating genre:', error);
+      throw error;
+    }
+  },
+
+  async deleteGenre(genreId) {
+    try {
+      await genreStore.delete({ _id: genreId });
+
+      // Update local state
+      state.genres = state.genres.filter(g => g._id !== genreId);
+      state.popularGenres = state.popularGenres.filter(g => g._id !== genreId);
+
+      if (state.currentGenre && state.currentGenre._id === genreId) {
+        state.currentGenre = null;
+      }
+
+      return true;
+    } catch (error) {
+      console.error('Error deleting genre:', error);
+      throw error;
+    }
+  },
+};

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

@@ -32,17 +32,30 @@ export const actions = {
     }
   },
 
-  async fetchFeaturedPlaylists(limit = 10) {
+  async fetchFeaturedPlaylists(options = {}) {
     state.loadingFeatured = true;
     try {
-      // Assuming there's a status field for featured playlists
-      const options = {
-        status: 'featured',
+      // Обрабатываем options от Feed компонента
+      const queryOptions = {
+        limit: options.limit || 10,
         isPublic: true,
-        limit,
       };
+      
+      // Добавляем дополнительные параметры если есть
+      if (options.skip) queryOptions.skip = options.skip;
+      if (options.search) queryOptions.search = options.search;
+      if (options.sortParam) queryOptions.sortParam = options.sortParam;
+      if (options.sortOrder) queryOptions.sortOrder = options.sortOrder;
+      
+      // Если указан featured=true, добавляем соответствующий фильтр
+      if (options.featured) {
+        queryOptions.status = 'featured';
+        // Или можно использовать sortParam для featured плейлистов
+        queryOptions.sortParam = queryOptions.sortParam || 'followers';
+        queryOptions.sortOrder = queryOptions.sortOrder || 'desc';
+      }
 
-      const playlists = await playlistStore.read(options);
+      const playlists = await playlistStore.read(queryOptions);
       state.featuredPlaylists = playlists;
       return playlists;
     } catch (error) {

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

@@ -35,10 +35,17 @@ export const actions = {
     }
   },
 
-  async fetchPopularTracks(limit = 10) {
+  async fetchPopularTracks(options = {}) {
     state.loadingPopular = true;
     try {
-      const response = await fetch(`${process.env.API_URL}/api/tracks/popular?limit=${limit}`);
+      // Обрабатываем options от Feed компонента
+      const queryParams = new URLSearchParams();
+      queryParams.append('limit', options.limit || 10);
+      
+      if (options.skip) queryParams.append('skip', options.skip);
+      if (options.search) queryParams.append('search', options.search);
+      
+      const response = await fetch(`${process.env.API_URL}/api/tracks/popular?${queryParams.toString()}`);
       const tracks = await response.json();
       state.popular = tracks;
       return tracks;

package/src/modules/products/components/pages/Product.vue

@@ -122,7 +122,7 @@ import * as shopcart from '@martyrs/src/modules/orders/store/shopcart.js'
 import Button from '@martyrs/src/components/Button/Button.vue'
 import Popup from '@martyrs/src/components/Popup/Popup.vue'
 import Tab from '@martyrs/src/components/Tab/Tab.vue'
-import Calendar from '@martyrs/src/components/DatePicker/Calendar.vue'
+import Calendar from '@martyrs/src/components/Calendar/Calendar.vue'
 
 import IconEdit from '@martyrs/src/modules/icons/navigation/IconEdit.vue'
 import IconInfo from '@martyrs/src/modules/icons/navigation/IconInfo.vue'

package/dist/Media-ByPHBvAU.cjs

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("vue"),V=require("./main-137vO86w.cjs"),C={class:"media-container"},M=["src","data-src","alt"],j=["controls","loop","muted","autoplay","playsinline","preload"],N=["src","type"],O={key:2,class:"media-placeholder"},P={key:3,class:"media-error"},S={__name:"Media",props:{url:{type:String,required:!0},options:{type:Object,default:()=>({muted:!0,loop:!0,playsinline:!0,preload:"metadata"})}},setup(t){const m=t,l=e.ref(null),p=e.ref(null),s=e.ref(!1),u=e.ref(null),v=e.ref(!1);let i=null,f=!1;const d=e.computed(()=>{var o,a,n;return(n=(a=(o=m.url)==null?void 0:o.split("."))==null?void 0:a.pop())==null?void 0:n.toLowerCase()}),g=e.computed(()=>["jpg","jpeg","png","gif","webp","svg","avif"].includes(d.value)),y=e.computed(()=>["mp4","webm","ogg"].includes(d.value)),x=e.computed(()=>({mp4:"video/mp4",webm:"video/webm",ogg:"video/ogg"})[d.value]||"");function E(){s.value=!0}function I(o){u.value=`Ошибка загрузки медиа: ${o.message}`,s.value=!1}async function w(){if(l.value)try{l.value.paused&&!f&&(await l.value.play(),f=!0)}catch(o){I(o)}}function L(){const o={root:null,rootMargin:"50px",threshold:.1};i=new IntersectionObserver(n=>{n.forEach(r=>{var c;v.value=r.isIntersecting,r.isIntersecting&&(y.value&&((c=m.options)!=null&&c.autoplay)&&w(),i.disconnect())})},o);const a=g.value?p.value:l.value;a&&i.observe(a)}return e.onMounted(()=>{L()}),e.onUnmounted(()=>{i&&i.disconnect()}),(o,a)=>{var n,r,c,k,h,b,B;return e.openBlock(),e.createElementBlock("div",C,[g.value?(e.openBlock(),e.createElementBlock("img",e.mergeProps({key:0,src:v.value?t.url:"","data-src":t.url,alt:((n=t.options)==null?void 0:n.alt)||"Image",class:["media-item",{loading:!s.value}],loading:"lazy",onLoad:E},t.options,{ref_key:"imageElement",ref:p}),null,16,M)):y.value?(e.openBlock(),e.createElementBlock("video",e.mergeProps({key:1,ref_key:"videoElement",ref:l,class:[{loading:!s.value},"media-item"],controls:!((r=t.options)!=null&&r.hideControls),loop:((c=t.options)==null?void 0:c.loop)!==!1,muted:((k=t.options)==null?void 0:k.muted)!==!1,autoplay:(h=t.options)==null?void 0:h.autoplay,playsinline:((b=t.options)==null?void 0:b.playsinline)!==!1,preload:((B=t.options)==null?void 0:B.preload)||"metadata",onLoadeddata:E},t.options),[e.createElementVNode("source",{src:t.url,type:x.value},null,8,N)],16,j)):e.createCommentVNode("",!0),s.value?e.createCommentVNode("",!0):(e.openBlock(),e.createElementBlock("div",O," Loading... ")),u.value?(e.openBlock(),e.createElementBlock("div",P,e.toDisplayString(u.value),1)):e.createCommentVNode("",!0)])}}},q=V._export_sfc(S,[["__scopeId","data-v-1f94a0e9"]]);exports.default=q;