@ozdao/martyrs 0.2.485 → 0.2.487

package/src/modules/music/components/pages/ArtistManager.vue

@@ -1,277 +0,0 @@
-<template>
-  <div class="pd-medium">
-    <div class="flex flex-justify-between flex-v-center mn-b-medium">
-      <h2 class="h2">Manage Artists</h2>
-      <Button
-        :submit="() => router.push({ name: 'artist-create' })"
-        class="bg-main t-white"
-        :showSucces="false"
-        :showLoader="false"
-      >
-        Create Artist
-      </Button>
-    </div>
-    
-    <div class="mn-b-medium">
-      <Field
-        v-model:field="search"
-        placeholder="Search artists..."
-        class="w-m-40r"
-        @update:field="handleSearch"
-      >
-        <IconSearch class="i-medium mn-r-small" />
-      </Field>
-    </div>
-    
-    <!-- Loading state -->
-    <div v-if="isLoading" class="flex-center flex mn-medium">
-      <Loader />
-    </div>
-    
-    <!-- Empty state -->
-    <div v-else-if="userArtists.length === 0" class="bg-light pd-medium radius-medium t-center">
-      <p class="mn-b-small p-medium">You haven't created any artists yet</p>
-      <p class="p-small t-transp mn-b-medium">Start by creating your first artist profile</p>
-      <Button
-        :submit="() => router.push({ name: 'artist-create' })"
-        class="bg-main t-white"
-        :showSucces="false"
-        :showLoader="false"
-      >
-        Create Artist
-      </Button>
-    </div>
-    
-    <!-- Artist list -->
-    <div v-else class="cols-1 gap-small">
-      <div
-        v-for="artist in userArtists"
-        :key="artist._id"
-        class="bg-light pd-medium radius-medium flex-v-center flex flex-justify-between hover-bg-light mobile:flex-column"
-      >
-        <div class="flex-v-center flex mobile:w-100 mobile:mn-b-small">
-          <div class="w-4r h-4r radius-medium o-hidden mn-r-medium mobile:mn-r-small">
-            <img
-              v-if="artist.photoUrl"
-              :src="FILE_SERVER_URL + artist.photoUrl"
-              alt="Artist photo"
-              class="w-100 h-100 object-fit-cover"
-            />
-            <div v-else class="w-100 h-100 bg-second-nano flex-center flex">
-              <span>{{ artist.name }}</span>
-            </div>
-          </div>
-          
-          <div>
-            <h3 class="h5 mn-b-thin">{{ artist.name }}</h3>
-            <p class="p-small t-transp">
-              {{getStatusLabel(artist.status)}}
-              <span v-if="artist.isVerified" class="bg-second-nano pd-micro radius-small">
-                Verified
-              </span>
-            </p>
-          </div>
-        </div>
-        
-        <div class="flex flex-nowrap gap-small mobile:w-100 mobile:flex-justify-between">
-          <Button
-            :submit="() => viewArtist(artist)"
-            class="bg-grey-nano t-black"
-            :showSucces="false"
-            :showLoader="false"
-          >
-            View
-          </Button>
-          
-          <Button
-            :submit="() => editArtist(artist)"
-            class="bg-main t-white"
-            :showSucces="false"
-            :showLoader="false"
-          >
-            Edit
-          </Button>
-          
-          <Button
-            :submit="() => confirmDelete(artist)"
-            class="bg-fourth t-white"
-            :showSucces="false"
-            :showLoader="false"
-          >
-            Delete
-          </Button>
-        </div>
-      </div>
-    </div>
-    
-    <!-- Confirmation popup -->
-    <Popup
-      :isPopupOpen="showDeleteConfirm"
-      @close-popup="showDeleteConfirm = false"
-      class="bg-white pd-medium radius-medium w-m-33r"
-    >
-      <h3 class="h3 mn-b-medium">Delete Artist</h3>
-      <p class="p-medium mn-b-medium">
-        Are you sure you want to delete <b>{{ selectedArtist?.name }}</b>?
-      </p>
-      <p class="p-small t-transp mn-b-medium">
-        This action cannot be undone and will remove all artist data.
-      </p>
-      
-      <div class="flex flex-justify-between">
-        <Button
-          :submit="() => showDeleteConfirm = false"
-          class="bg-grey-nano t-black"
-          :showSucces="false"
-          :showLoader="false"
-        >
-          Cancel
-        </Button>
-        
-        <Button
-          :submit="deleteArtist"
-          class="bg-fourth t-white"
-        >
-          Confirm Delete
-        </Button>
-      </div>
-    </Popup>
-  </div>
-</template>
-
-<script setup>
-import { ref, onMounted, computed } from 'vue';
-import { useRouter } from 'vue-router';
-
-// Import Martyrs components
-import Field from '@martyrs/src/components/Field/Field.vue';
-import Button from '@martyrs/src/components/Button/Button.vue';
-import Loader from '@martyrs/src/components/Loader/Loader.vue';
-import Status from '@martyrs/src/components/Status/Status.vue';
-import Popup from '@martyrs/src/components/Popup/Popup.vue';
-import IconSearch from '@martyrs/src/modules/icons/navigation/IconSearch.vue';
-
-// Import store
-import * as artistsStore from '../../store/artists';
-import * as auth from '@martyrs/src/modules/auth/views/store/auth.js';
-import * as globals from '@martyrs/src/modules/globals/views/store/globals.js';
-
-// Router
-const router = useRouter();
-
-// State
-const search = ref('');
-const isLoading = ref(false);
-const showDeleteConfirm = ref(false);
-const selectedArtist = ref(null);
-
-// Computed
-const userArtists = computed(() => {
-  return artistsStore.state.userArtists;
-});
-
-// Methods
-const loadUserArtists = async () => {
-  isLoading.value = true;
-  try {
-    await artistsStore.actions.fetchUserArtists(auth.state.user._id);
-  } catch (error) {
-    console.error('Error loading artists:', error);
-    globals.actions.setError({
-      message: 'Failed to load your artists'
-    });
-  } finally {
-    isLoading.value = false;
-  }
-};
-
-const handleSearch = async (value) => {
-  if (!value.trim()) {
-    // If search is empty, load all user artists
-    await loadUserArtists();
-    return;
-  }
-  
-  isLoading.value = true;
-  try {
-    // Search only within user's artists
-    const options = {
-      creator: auth.state.user._id,
-      search: value
-    };
-    await artistsStore.actions.fetchArtists(options);
-    // Update userArtists (assuming the store is correctly updating userArtists)
-  } catch (error) {
-    console.error('Error searching artists:', error);
-  } finally {
-    isLoading.value = false;
-  }
-};
-
-const viewArtist = (artist) => {
-  router.push({
-    name: 'artist-detail',
-    params: { url: artist.url }
-  });
-};
-
-const editArtist = (artist) => {
-  router.push({
-    name: 'artist-edit',
-    params: { url: artist.url }
-  });
-};
-
-const confirmDelete = (artist) => {
-  selectedArtist.value = artist;
-  showDeleteConfirm.value = true;
-};
-
-const deleteArtist = async () => {
-  if (!selectedArtist.value) return;
-  
-  try {
-    await artistsStore.actions.deleteArtist(selectedArtist.value._id);
-    showDeleteConfirm.value = false;
-    selectedArtist.value = null;
-    
-    // Show success message
-    globals.actions.setError({
-      message: 'Artist deleted successfully',
-      status: 'success'
-    });
-  } catch (error) {
-    console.error('Error deleting artist:', error);
-    globals.actions.setError({
-      message: 'Failed to delete artist'
-    });
-  }
-};
-
-const getStatusLabel = (status) => {
-  const statusMap = {
-    'draft': {
-      text: 'Draft',
-      color: '#888888'
-    },
-    'published': {
-      text: 'Published',
-      color: '#10FA7D' // main color
-    },
-    'archived': {
-      text: 'Archived',
-      color: '#FF0A54' // fourth color
-    }
-  };
-  
-  return statusMap[status] || {
-    text: status,
-    color: '#888888'
-  };
-};
-
-// Lifecycle hooks
-onMounted(async () => {
-  await loadUserArtists();
-});
-</script>

package/src/modules/music/components/pages/MusicUpload.vue

@@ -1,44 +0,0 @@
-<!-- components/pages/MusicUpload.vue -->
-<template>
-  <div class="music-upload-page">
-    <h1 class="t-white mn-b-medium">Upload Music</h1>
-    
-    <div class="upload-container bg-dark-transp-10 radius-medium pd-medium">
-      <div v-if="!authState.access.status" class="t-center pd-big">
-        <h2 class="t-white mn-b-small">Sign in to upload</h2>
-        <p class="t-grey t-medium mn-b-medium">You need to be signed in to upload tracks</p>
-        <Button 
-          @click="$router.push({ name: 'Sign In', query: { redirect: $route.fullPath } })"
-          class="bg-main t-white radius-small pd-small hover-scale-1"
-          :showLoader="false" 
-          :showSucces="false"
-        >
-          Sign In
-        </Button>
-      </div>
-      
-      <div v-else>
-        <h2 class="t-white mn-b-medium">Upload a Track</h2>
-        
-        <UploadForm @uploaded="onTrackUploaded" />
-      </div>
-    </div>
-  </div>
-</template>
-
-<script setup>
-import { ref } from 'vue';
-import { useRouter } from 'vue-router';
-import Button from '@martyrs/src/components/Button/Button.vue';
-import UploadForm from '../forms/UploadForm.vue';
-
-// Import auth store
-import { state as authState } from '@martyrs/src/modules/auth/views/store/auth.js';
-
-const router = useRouter();
-
-const onTrackUploaded = (track) => {
-  // Navigate to the uploaded track's detail page
-  router.push({ name: 'track-detail', params: { url: track.url } });
-};
-</script>

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

@@ -1,82 +0,0 @@
-import music from './music.controller.js';
-export default (function (app, db) {
-  const { MusicController } = music(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

@@ -1,99 +0,0 @@
-import music from './music.controller.js';
-export default (function (app, db) {
-  const { MusicController } = music(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

@@ -1,63 +0,0 @@
-import music from './music.controller.js';
-export default (function (app, db) {
-  const { MusicController } = music(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),
-  };
-});