679 lines
21 KiB
JavaScript
679 lines
21 KiB
JavaScript
const Song = require('../models/song.model');
|
|
|
|
const Category = require('../models/categories.model');
|
|
const Subcategory = require('../models/subcategories.model');
|
|
const Album = require('../models/album.model');
|
|
const Artist = require('../models/artist.model')
|
|
const Language = require('../models/language.model')
|
|
|
|
|
|
// const createSong = async (req, res) => {
|
|
// try {
|
|
// const {
|
|
// categoryId,
|
|
// subcategoryId,
|
|
// albumId,
|
|
// artistId,
|
|
// title,
|
|
// musicLink,
|
|
// trackerID,
|
|
// lyrics,
|
|
// languageId
|
|
// } = req.body;
|
|
|
|
// const { coverArtImage, musicFile } = req.files;
|
|
// const [category, subcategory, album, artist, language] = await Promise.all([
|
|
// Category.findById(categoryId),
|
|
// Subcategory.findById(subcategoryId),
|
|
// Album.findById(albumId),
|
|
// Artist.findById(artistId),
|
|
// Language.findById(languageId)
|
|
// ]);
|
|
|
|
// if (!category || !subcategory || !album || !artist || !language) {
|
|
// const missingEntities = [];
|
|
// if (!category) missingEntities.push('Category');
|
|
// if (!subcategory) missingEntities.push('Subcategory');
|
|
// if (!album) missingEntities.push('Album');
|
|
// if (!artist) missingEntities.push('Artist');
|
|
// if (!language) missingEntities.push('Language');
|
|
// const errorMessage = `The following entities were not found: ${missingEntities.join(', ')}.`;
|
|
// return res.status(404).json({ error_code: 404, message: errorMessage });
|
|
// }
|
|
// const coverArtImagePath = coverArtImage[0].path;
|
|
// const musicFilePath = musicFile[0].path;
|
|
|
|
// const baseUrl = `${req.protocol}://${req.get('host')}`;
|
|
// const coverArtImageUrl = `${baseUrl}/${coverArtImagePath}`;
|
|
// const newSong = await Song.create({
|
|
// categoryId,
|
|
// subcategoryId,
|
|
// albumId,
|
|
// artistId,
|
|
// title,
|
|
// musicLink,
|
|
// trackerID,
|
|
// lyrics,
|
|
// languageId,
|
|
// coverArtImage: {
|
|
// filename: coverArtImage[0].filename,
|
|
// fileAddress: coverArtImagePath,
|
|
// imageUrl: coverArtImageUrl
|
|
// },
|
|
// musicFile: {
|
|
// filename: musicFile[0].filename,
|
|
// fileAddress: musicFilePath
|
|
// }
|
|
// });
|
|
// return res.status(201).json({
|
|
// error_code: 200,
|
|
// message: 'Song created successfully',
|
|
// song: newSong
|
|
// });
|
|
// } catch (err) {
|
|
// console.error('Error inside createSong:', err);
|
|
// return res.status(500).json({ error_code: 500, message: 'Internal Server Error' });
|
|
// }
|
|
// };
|
|
|
|
// const createSong = async (req, res) => {
|
|
// try {
|
|
// const {
|
|
// categoryId,
|
|
// subcategoryId,
|
|
// albumId,
|
|
// artistId,
|
|
// title,
|
|
// languageId,
|
|
// type,
|
|
// musicLink,
|
|
// trackerID,
|
|
// lyrics
|
|
// } = req.body;
|
|
|
|
// if (!type || !['1', '2'].includes(type)) {
|
|
// return res.status(400).json({ error_code: 400, message: 'Invalid or missing type parameter' });
|
|
// }
|
|
|
|
// let musicFilePath;
|
|
// let musicFileUrl; // Define a variable to store the URL of the music file
|
|
|
|
// if (type === '1') {
|
|
// if (!musicLink || !trackerID) {
|
|
// return res.status(400).json({ error_code: 400, message: 'Music link and tracker ID are required for type 1' });
|
|
// }
|
|
// } else if (type === '2') {
|
|
// if (!req.files || !req.files.musicFile) {
|
|
// return res.status(400).json({ error_code: 400, message: 'Music file is required' });
|
|
// }
|
|
|
|
// if (!Array.isArray(req.files.musicFile) || req.files.musicFile.length === 0) {
|
|
// return res.status(400).json({ error_code: 400, message: 'Invalid music file provided' });
|
|
// }
|
|
// musicFilePath = req.files.musicFile[0].path;
|
|
// musicFileUrl = `${req.protocol}://${req.get('host')}/${musicFilePath}`; // Construct the URL of the music file
|
|
// }
|
|
|
|
// const { coverArtImage } = req.files;
|
|
|
|
// const coverArtImagePath = coverArtImage[0].path;
|
|
// const coverArtImageUrl = `${req.protocol}://${req.get('host')}/${coverArtImagePath}`;
|
|
|
|
// const [category, subcategory, album, artist, language] = await Promise.all([
|
|
// Category.findById(categoryId),
|
|
// Subcategory.findById(subcategoryId),
|
|
// Album.findById(albumId),
|
|
// Artist.findById(artistId),
|
|
// Language.findById(languageId)
|
|
// ]);
|
|
|
|
// if (![category, subcategory, album, artist, language].every(entity => entity)) {
|
|
// const missingEntities = ['Category', 'Subcategory', 'Album', 'Artist', 'Language']
|
|
// .filter((entity, index) => ![category, subcategory, album, artist, language][index]);
|
|
// const errorMessage = `The following entities were not found: ${missingEntities.join(', ')}.`;
|
|
// return res.status(404).json({ error_code: 404, message: errorMessage });
|
|
// }
|
|
|
|
// let newSong;
|
|
|
|
// if (type === '1') {
|
|
// newSong = await Song.create({
|
|
// categoryId,
|
|
// subcategoryId,
|
|
// albumId,
|
|
// artistId,
|
|
// title,
|
|
// languageId,
|
|
// musicLink,
|
|
// trackerID,
|
|
// coverArtImage: {
|
|
// filename: coverArtImage[0].filename,
|
|
// fileAddress: coverArtImagePath,
|
|
// imageUrl: coverArtImageUrl
|
|
// },
|
|
// });
|
|
// } else if (type === '2') {
|
|
// newSong = await Song.create({
|
|
// categoryId,
|
|
// subcategoryId,
|
|
// albumId,
|
|
// artistId,
|
|
// title,
|
|
// languageId,
|
|
// lyrics,
|
|
// coverArtImage: {
|
|
// filename: coverArtImage[0].filename,
|
|
// fileAddress: coverArtImagePath,
|
|
// imageUrl: coverArtImageUrl
|
|
// },
|
|
// musicFile: {
|
|
// filename: req.files.musicFile[0].filename,
|
|
// fileAddress: musicFilePath,
|
|
// url: musicFileUrl // Include the URL of the music file in the database
|
|
// }
|
|
// });
|
|
// }
|
|
|
|
// return res.status(201).json({
|
|
// error_code: 200,
|
|
// message: 'Song created successfully',
|
|
// song: newSong
|
|
// });
|
|
// } catch (err) {
|
|
// console.error('Error inside createSong:', err);
|
|
// return res.status(500).json({ error_code: 500, message: 'Internal Server Error' });
|
|
// }
|
|
// };
|
|
|
|
const createSong = async (req, res) => {
|
|
try {
|
|
console.log(req.body,"ehjyqgfe")
|
|
const {
|
|
categoryId,
|
|
subcategoryId,
|
|
albumId,
|
|
artistId,
|
|
title,
|
|
languageId,
|
|
type,
|
|
musicLink,
|
|
trackerID,
|
|
lyrics
|
|
} = req.body;
|
|
|
|
if (!type || !['1', '2'].includes(type)) {
|
|
return res.status(400).json({ error_code: 400, message: 'Invalid or missing type parameter' });
|
|
}
|
|
|
|
let musicFilePath;
|
|
let musicFileUrl;
|
|
|
|
if (type === '1') {
|
|
if (!musicLink || !trackerID) {
|
|
return res.status(400).json({ error_code: 400, message: 'Music link and tracker ID are required for type 1' });
|
|
}
|
|
} else if (type === '2') {
|
|
if (!req.files || !req.files.musicFile) {
|
|
return res.status(400).json({ error_code: 400, message: 'Music file is required' });
|
|
}
|
|
|
|
if (!Array.isArray(req.files.musicFile) || req.files.musicFile.length === 0) {
|
|
return res.status(400).json({ error_code: 400, message: 'Invalid music file provided' });
|
|
}
|
|
musicFilePath = req.files.musicFile[0].path;
|
|
musicFileUrl = `${req.protocol}://${req.get('host')}/${musicFilePath}`;
|
|
}
|
|
|
|
console.log("🚀 ~ createSong ~ musicFilePath:", musicFilePath)
|
|
const { coverArtImage } = req.files;
|
|
|
|
const coverArtImagePath = coverArtImage[0].path;
|
|
const coverArtImageUrl = `${req.protocol}://${req.get('host')}/${coverArtImagePath}`;
|
|
|
|
const [category, subcategory, album, language] = await Promise.all([
|
|
Category.findById(categoryId),
|
|
Subcategory.findById(subcategoryId),
|
|
Album.findById(albumId),
|
|
Language.findById(languageId)
|
|
]);
|
|
|
|
if (![category, subcategory, album, language].every(entity => entity)) {
|
|
const missingEntities = ['Category', 'Subcategory', 'Album', 'Language']
|
|
.filter((entity, index) => ![category, subcategory, album, language][index]);
|
|
const errorMessage = `The following entities were not found: ${missingEntities.join(', ')}.`;
|
|
return res.status(402 ).json({ error_code: 402, message: errorMessage });
|
|
}
|
|
|
|
const artistIdsArray = artistId.split(',').map(id => id.trim());
|
|
console.log("🚀 ~ createSong ~ artistIdsArray:", artistIdsArray)
|
|
|
|
let newSong;
|
|
|
|
if (type === '1') {
|
|
newSong = await Song.create({
|
|
categoryId,
|
|
subcategoryId,
|
|
albumId,
|
|
artistId: artistIdsArray,
|
|
title,
|
|
languageId,
|
|
musicLink,
|
|
trackerID,
|
|
coverArtImage: {
|
|
filename: coverArtImage[0].filename,
|
|
fileAddress: coverArtImagePath,
|
|
imageUrl: coverArtImageUrl
|
|
},
|
|
});
|
|
} else if (type === '2') {
|
|
newSong = await Song.create({
|
|
categoryId,
|
|
subcategoryId,
|
|
albumId,
|
|
artistId: artistIdsArray,
|
|
title,
|
|
languageId,
|
|
lyrics,
|
|
coverArtImage: {
|
|
filename: coverArtImage[0].filename,
|
|
fileAddress: coverArtImagePath,
|
|
imageUrl: coverArtImageUrl
|
|
},
|
|
musicFile: {
|
|
filename: req.files.musicFile[0].filename,
|
|
fileAddress: musicFilePath,
|
|
url: musicFileUrl // Include the URL of the music file in the database
|
|
}
|
|
});
|
|
}
|
|
console.log("🚀 ~ createSong ~ newSong:", newSong)
|
|
|
|
|
|
return res.status(200).json({
|
|
error_code: 200,
|
|
message: 'Song created successfully',
|
|
song: newSong
|
|
});
|
|
} catch (err) {
|
|
console.error('Error inside createSong:', err);
|
|
return res.status(500).json({ error_code: 500, message: 'Internal Server Error' });
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// const updateSong = async (req, res) => {
|
|
// try {
|
|
// const { id } = req.params;
|
|
// const updatedSong = await Song.findByIdAndUpdate(id, req.body, { new: true });
|
|
// if (!updatedSong) {
|
|
// return res.status(404).json({ error_code: 404, message: 'Song not found' });
|
|
// }
|
|
// return res.status(200).json({ error_code: 200, message: 'Song updated successfully', song: updatedSong });
|
|
// } catch (err) {
|
|
// console.error('Error inside updateSong:', err);
|
|
// return res.status(500).json({ error_code: 500, message: 'Internal Server Error' });
|
|
// }
|
|
// };
|
|
|
|
const updateSong = async (req, res) => {
|
|
try {
|
|
console.log(req.params,"dshgudgf")
|
|
const {_id} = req.params;
|
|
// console.log("🚀 ~ updateSong ~ songId:", songId)
|
|
const song = await Song.findById(_id);
|
|
console.log("🚀 ~ updateSong ~ song:", song)
|
|
|
|
if (!song) {
|
|
return res.status(404).json({ error_code: 404, message: 'Song not found' });
|
|
}
|
|
|
|
const {
|
|
categoryId,
|
|
subcategoryId,
|
|
albumId,
|
|
artistId,
|
|
title,
|
|
languageId,
|
|
type,
|
|
musicLink,
|
|
trackerID,
|
|
lyrics
|
|
} = req.body;
|
|
|
|
const updates = {};
|
|
|
|
// Input validation
|
|
if (categoryId) updates.categoryId = categoryId;
|
|
if (subcategoryId) updates.subcategoryId = subcategoryId;
|
|
if (albumId) updates.albumId = albumId;
|
|
if (artistId) {
|
|
updates.artistId = artistId.split(',').map(id => id.trim());
|
|
}
|
|
if (title) updates.title = title;
|
|
if (languageId) updates.languageId = languageId;
|
|
if (type) {
|
|
if (!['1', '2'].includes(type)) {
|
|
return res.status(400).json({ error_code: 400, message: 'Invalid type parameter' });
|
|
}
|
|
updates.type = type;
|
|
if (type === '1') {
|
|
if (!musicLink || !trackerID) {
|
|
return res.status(400).json({ error_code: 400, message: 'Music link and tracker ID are required for type 1' });
|
|
}
|
|
updates.musicLink = musicLink;
|
|
updates.trackerID = trackerID;
|
|
} else if (type === '2') {
|
|
// if (!req.files || !req.files.musicFile) {
|
|
// return res.status(400).json({ error_code: 400, message: 'Music file is required' });
|
|
// }
|
|
if (req.files && req.files.musicFile) {
|
|
const musicFilePath = req.files.musicFile[0].path;
|
|
const musicFileUrl = `${req.protocol}://${req.get('host')}/uploads/${musicFilePath}`;
|
|
updates.musicFile = {
|
|
filename: req.files.musicFile[0].filename,
|
|
fileAddress: musicFilePath,
|
|
url: musicFileUrl
|
|
};
|
|
}
|
|
}
|
|
}
|
|
if (lyrics !== undefined) updates.lyrics = lyrics;
|
|
|
|
// Update cover art image if provided
|
|
if (req.files && req.files.coverArtImage) {
|
|
const coverArtImage = req.files.coverArtImage[0];
|
|
const coverArtImagePath = coverArtImage.path;
|
|
const coverArtImageUrl = `${req.protocol}://${req.get('host')}/uploads/${coverArtImagePath}`;
|
|
updates.coverArtImage = {
|
|
filename: coverArtImage.filename,
|
|
fileAddress: coverArtImagePath,
|
|
imageUrl: coverArtImageUrl
|
|
};
|
|
}
|
|
|
|
// Perform the update and return the updated song
|
|
const updatedSong = await Song.findByIdAndUpdate(_id, updates, { new: true });
|
|
|
|
if (!updatedSong) {
|
|
return res.status(404).json({ error_code: 404, message: 'Song not found' });
|
|
}
|
|
|
|
return res.status(200).json({
|
|
error_code: 200,
|
|
message: 'Song updated successfully',
|
|
song: updatedSong
|
|
});
|
|
} catch (err) {
|
|
console.error('Error inside updateSong:', err);
|
|
return res.status(500).json({ error_code: 500, message: 'Internal Server Error' });
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
const deleteSong = async (req, res) => {
|
|
try {
|
|
const { id } = req.params;
|
|
const deletedSong = await Song.findByIdAndDelete(id);
|
|
if (!deletedSong) {
|
|
return res.status(404).json({ error_code: 404, message: 'Song not found' });
|
|
}
|
|
return res.status(200).json({ error_code: 200, message: 'Song deleted successfully' });
|
|
} catch (err) {
|
|
console.error('Error inside deleteSong:', err);
|
|
return res.status(500).json({ error_code: 500, message: 'Internal Server Error' });
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
// const getSong = async (req, res) => {
|
|
// try {
|
|
// const { id } = req.params;
|
|
// const song = await Song.findById(id)
|
|
// .populate('languageId', 'name')
|
|
// .populate('artistId', 'ArtistName')
|
|
// .select('title musicLink trackerID lyrics coverArtImage');
|
|
|
|
// if (!song) {
|
|
// return res.status(404).json({ error_code: 404, message: 'Song not found' });
|
|
// }
|
|
|
|
// const { languageId, artistId, musicLink, trackerID, lyrics } = song;
|
|
// const languageName = languageId ? languageId.name : null;
|
|
|
|
// const artistName = artistId ? artistId.ArtistName : null;
|
|
// const imageUrl = song.coverArtImage ? song.coverArtImage.imageUrl : null;
|
|
|
|
// const songData = {
|
|
// languageName: languageName,
|
|
// artistName: artistName,
|
|
// musicLink: musicLink || null,
|
|
// trackerID: trackerID || null,
|
|
// lyrics: lyrics || null,
|
|
// imageUrl: imageUrl
|
|
// };
|
|
|
|
// return res.status(200).json({
|
|
// error_code: 200,
|
|
// message: 'Song retrieved successfully',
|
|
// song: songData
|
|
// });
|
|
// } catch (err) {
|
|
// console.error('Error inside getSong:', err);
|
|
// return res.status(500).json({ error_code: 500, message: 'Internal Server Error' });
|
|
// }
|
|
// };
|
|
|
|
const getSong = async (req, res) => {
|
|
try {
|
|
const { id } = req.params;
|
|
const song = await Song.findById(id)
|
|
.populate('languageId', 'name')
|
|
.populate('artistId', 'ArtistName')
|
|
.select('title musicLink trackerID lyrics coverArtImage musicFile');
|
|
|
|
if (!song) {
|
|
return res.status(404).json({ error_code: 404, message: 'Song not found' });
|
|
}
|
|
|
|
const { languageId, artistId, musicLink, trackerID, lyrics, coverArtImage, musicFile } = song;
|
|
const languageName = languageId ? languageId.name : 'Language not available';
|
|
const artistNames = artistId.map(artist => artist.ArtistName);
|
|
const imageUrl = coverArtImage ? coverArtImage.imageUrl : 'Image not available';
|
|
const url = musicFile ? musicFile.url : 'Music file not available';
|
|
|
|
const songData = {
|
|
languageName: languageName,
|
|
artistNames: artistNames,
|
|
musicLink: musicLink || 'Music link not available',
|
|
trackerID: trackerID || 'Tracker ID not available',
|
|
lyrics: lyrics || 'Lyrics not available',
|
|
imageUrl: imageUrl,
|
|
url: url
|
|
};
|
|
|
|
return res.status(200).json({
|
|
error_code: 200,
|
|
message: 'Song retrieved successfully',
|
|
song: songData
|
|
});
|
|
} catch (err) {
|
|
console.error('Error inside getSong:', err);
|
|
return res.status(500).json({ error_code: 500, message: 'Internal Server Error' });
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
const changeSongStatus = async (req, res) => {
|
|
try {
|
|
const { id } = req.params;
|
|
const songData = await Song.findById(id);
|
|
if (!songData) {
|
|
return res.status(400).send({
|
|
error_code: 400,
|
|
message: 'song not found'
|
|
});
|
|
}
|
|
|
|
songData.status = songData.status === 'activate' ? 'deactivate' : 'activate';
|
|
|
|
await songData.save();
|
|
res.status(200).send({
|
|
message: `song status toggled successfully to ${songData.status}`,
|
|
songData: songData
|
|
});
|
|
} catch (err) {
|
|
console.error('Error inside update admin', err);
|
|
res.status(500).send({
|
|
error_code: 500,
|
|
message: 'Internal Server Error'
|
|
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
const getAllSongs = async (req, res) => {
|
|
try {
|
|
const { title, artist, category, page, limit } = req.query;
|
|
|
|
// Build match stage for filtering based on search fields
|
|
const matchStage = {};
|
|
['title', 'artist', 'category'].forEach(field => {
|
|
if (req.query[field]) {
|
|
matchStage[field] = { $regex: req.query[field], $options: 'i' };
|
|
}
|
|
});
|
|
|
|
const pageNumber = Math.max(1, parseInt(page) || 1);
|
|
const pageSize = Math.max(1, parseInt(limit) || 5);
|
|
|
|
const pipeline = [
|
|
{ $match: matchStage },
|
|
{
|
|
$lookup: {
|
|
from: 'categories',
|
|
localField: 'categoryId',
|
|
foreignField: '_id',
|
|
as: 'category'
|
|
}
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'albums',
|
|
localField: 'albumId',
|
|
foreignField: '_id',
|
|
as: 'album'
|
|
}
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'subcategories',
|
|
localField: 'subcategoryId',
|
|
foreignField: '_id',
|
|
as: 'subcategory'
|
|
}
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'artists',
|
|
localField: 'artistId',
|
|
foreignField: '_id',
|
|
as: 'artist'
|
|
}
|
|
},
|
|
{
|
|
$project: {
|
|
title: 1,
|
|
category: { $arrayElemAt: ['$category.name', 0] },
|
|
subcategory: { $arrayElemAt: ['$subcategory.SubCategoriesName', 0] },
|
|
artist: { $arrayElemAt: ['$artist.ArtistName', 0] },
|
|
album: { $arrayElemAt: ['$album.albumName', 0] },
|
|
status: '$status'
|
|
}
|
|
},
|
|
{ $sort: { title: 1 } },
|
|
{ $skip: (pageNumber - 1) * pageSize },
|
|
{ $limit: pageSize }
|
|
];
|
|
|
|
const totalCount = await Song.countDocuments(matchStage);
|
|
const totalPages = Math.ceil(totalCount / pageSize);
|
|
|
|
const songs = await Song.aggregate(pipeline);
|
|
return res.status(200).json({
|
|
error_code: 200,
|
|
message: 'Songs retrieved successfully',
|
|
songs,
|
|
// page:pageNumber,
|
|
// limit:pageSize,
|
|
total_count:totalCount,
|
|
total_pages: totalPages,
|
|
current_page: pageNumber
|
|
});
|
|
} catch (err) {
|
|
console.error('Error inside getAllSongs:', err);
|
|
return res.status(500).json({ error_code: 500, message: 'Internal server error' });
|
|
}
|
|
};
|
|
|
|
// const getAllSongs = async (req, res) => {
|
|
// try {
|
|
// const songs = await Song.find()
|
|
// .populate('languageId', 'name')
|
|
// .populate('artistId', 'ArtistName')
|
|
// .select('title musicLink trackerID lyrics coverArtImage');
|
|
|
|
// if (!songs || songs.length === 0) {
|
|
// return res.status(404).json({ error_code: 404, message: 'Songs not found' });
|
|
// }
|
|
|
|
// const songData = songs.map(song => {
|
|
// const { languageId, artistId, musicLink, trackerID, lyrics, coverArtImage } = song;
|
|
// const languageName = languageId ? languageId.name : null;
|
|
// const artistNames = artistId ? artistId.map(artist => artist.ArtistName) : null;
|
|
// const imageUrl = coverArtImage ? coverArtImage.imageUrl : null;
|
|
|
|
// return {
|
|
// languageName: languageName,
|
|
// artistNames: artistNames,
|
|
// musicLink: musicLink || null,
|
|
// trackerID: trackerID || null,
|
|
// lyrics: lyrics || null,
|
|
// imageUrl: imageUrl
|
|
// };
|
|
// });
|
|
|
|
// return res.status(200).json({
|
|
// error_code: 200,
|
|
// message: 'Songs retrieved successfully',
|
|
// songs: songData
|
|
// });
|
|
// } catch (err) {
|
|
// console.error('Error inside getAllSongs:', err);
|
|
// return res.status(500).json({ error_code: 500, message: 'Internal Server Error' });
|
|
// }
|
|
// };
|
|
|
|
|
|
|
|
|
|
|
|
module.exports = {
|
|
createSong,
|
|
updateSong,
|
|
deleteSong,
|
|
getSong,
|
|
getAllSongs,
|
|
changeSongStatus
|
|
};
|
|
|