589 lines
14 KiB
JavaScript
589 lines
14 KiB
JavaScript
const path = require('path');
|
|
const fs = require('fs');
|
|
const { v4: uuidv4 } = require('uuid');
|
|
|
|
class VideoController {
|
|
constructor(baseUploadPath = 'uploads/videos') {
|
|
this.basePath = path.resolve(baseUploadPath);
|
|
this._ensureDirectory(this.basePath);
|
|
}
|
|
|
|
// ============ PRIVATE METHODS ============
|
|
|
|
_ensureDirectory(dir) {
|
|
if (!fs.existsSync(dir)) {
|
|
fs.mkdirSync(dir, { recursive: true });
|
|
}
|
|
}
|
|
|
|
_isVideoFile(filename) {
|
|
return /\.(mp4|webm|ogg|mov|avi|mkv)$/i.test(filename);
|
|
}
|
|
|
|
_getFileInfo(filePath, relativePath = '') {
|
|
const stat = fs.statSync(filePath);
|
|
const filename = path.basename(filePath);
|
|
|
|
return {
|
|
id: uuidv4(),
|
|
filename,
|
|
folder: relativePath,
|
|
path: `/videos/${relativePath ? relativePath + '/' : ''}${filename}`,
|
|
size: stat.size,
|
|
createdAt: stat.birthtime.toISOString(),
|
|
modifiedAt: stat.mtime.toISOString(),
|
|
};
|
|
}
|
|
|
|
_scanFolders(dir, relativePath = '') {
|
|
const folders = [];
|
|
|
|
if (!fs.existsSync(dir)) return folders;
|
|
|
|
const items = fs.readdirSync(dir);
|
|
|
|
items.forEach((item) => {
|
|
const fullPath = path.join(dir, item);
|
|
const relPath = relativePath ? `${relativePath}/${item}` : item;
|
|
|
|
if (fs.statSync(fullPath).isDirectory()) {
|
|
folders.push({
|
|
name: item,
|
|
path: relPath,
|
|
level: relPath.split('/').length,
|
|
});
|
|
// Ricorsione per sottocartelle
|
|
folders.push(...this._scanFolders(fullPath, relPath));
|
|
}
|
|
});
|
|
|
|
return folders;
|
|
}
|
|
|
|
// ============ FOLDER METHODS ============
|
|
|
|
/**
|
|
* Ottiene tutte le cartelle
|
|
*/
|
|
getFolders = async (req, res) => {
|
|
try {
|
|
const folders = this._scanFolders(this.basePath);
|
|
|
|
res.json({
|
|
success: true,
|
|
data: { folders },
|
|
message: 'Cartelle recuperate con successo',
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Crea una nuova cartella
|
|
*/
|
|
createFolder = async (req, res) => {
|
|
try {
|
|
const { folderName, parentPath = '' } = req.body;
|
|
|
|
if (!folderName || !folderName.trim()) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: 'Nome cartella richiesto',
|
|
});
|
|
}
|
|
|
|
// Sanitizza il nome cartella
|
|
const sanitizedName = folderName.replace(/[<>:"/\\|?*]/g, '_').trim();
|
|
|
|
const basePath = parentPath ? path.join(this.basePath, parentPath) : this.basePath;
|
|
|
|
const newFolderPath = path.join(basePath, sanitizedName);
|
|
|
|
if (fs.existsSync(newFolderPath)) {
|
|
return res.status(409).json({
|
|
success: false,
|
|
error: 'La cartella esiste già',
|
|
});
|
|
}
|
|
|
|
fs.mkdirSync(newFolderPath, { recursive: true });
|
|
|
|
const folderData = {
|
|
name: sanitizedName,
|
|
path: parentPath ? `${parentPath}/${sanitizedName}` : sanitizedName,
|
|
createdAt: new Date().toISOString(),
|
|
};
|
|
|
|
res.status(201).json({
|
|
success: true,
|
|
data: { folder: folderData },
|
|
message: 'Cartella creata con successo',
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Rinomina una cartella
|
|
*/
|
|
renameFolder = async (req, res) => {
|
|
try {
|
|
const { folderPath } = req.params;
|
|
const { newName } = req.body;
|
|
|
|
if (!newName || !newName.trim()) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: 'Nuovo nome richiesto',
|
|
});
|
|
}
|
|
|
|
const sanitizedName = newName.replace(/[<>:"/\\|?*]/g, '_').trim();
|
|
const oldPath = path.join(this.basePath, folderPath);
|
|
const parentDir = path.dirname(oldPath);
|
|
const newPath = path.join(parentDir, sanitizedName);
|
|
|
|
if (!fs.existsSync(oldPath)) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
error: 'Cartella non trovata',
|
|
});
|
|
}
|
|
|
|
if (fs.existsSync(newPath)) {
|
|
return res.status(409).json({
|
|
success: false,
|
|
error: 'Una cartella con questo nome esiste già',
|
|
});
|
|
}
|
|
|
|
fs.renameSync(oldPath, newPath);
|
|
|
|
res.json({
|
|
success: true,
|
|
message: 'Cartella rinominata con successo',
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Elimina una cartella
|
|
*/
|
|
deleteFolder = async (req, res) => {
|
|
try {
|
|
const { folderPath } = req.params;
|
|
const fullPath = path.join(this.basePath, folderPath);
|
|
|
|
if (!fs.existsSync(fullPath)) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
error: 'Cartella non trovata',
|
|
});
|
|
}
|
|
|
|
// Verifica che sia una directory
|
|
if (!fs.statSync(fullPath).isDirectory()) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: 'Il percorso non è una cartella',
|
|
});
|
|
}
|
|
|
|
fs.rmSync(fullPath, { recursive: true, force: true });
|
|
|
|
res.json({
|
|
success: true,
|
|
message: 'Cartella eliminata con successo',
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
// ============ VIDEO METHODS ============
|
|
|
|
/**
|
|
* Ottiene i video di una cartella
|
|
*/
|
|
getVideos = async (req, res) => {
|
|
try {
|
|
const folder = req.query.folder || '';
|
|
const targetPath = folder ? path.join(this.basePath, folder) : this.basePath;
|
|
|
|
if (!fs.existsSync(targetPath)) {
|
|
return res.json({
|
|
success: true,
|
|
data: {
|
|
videos: [],
|
|
folders: [],
|
|
currentPath: folder,
|
|
},
|
|
});
|
|
}
|
|
|
|
const items = fs.readdirSync(targetPath);
|
|
const videos = [];
|
|
const subfolders = [];
|
|
|
|
items.forEach((item) => {
|
|
const itemPath = path.join(targetPath, item);
|
|
const stat = fs.statSync(itemPath);
|
|
|
|
if (stat.isDirectory()) {
|
|
subfolders.push({
|
|
name: item,
|
|
path: folder ? `${folder}/${item}` : item,
|
|
});
|
|
} else if (stat.isFile() && this._isVideoFile(item)) {
|
|
videos.push(this._getFileInfo(itemPath, folder));
|
|
}
|
|
});
|
|
|
|
// Ordina per data di creazione (più recenti prima)
|
|
videos.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
|
|
|
|
res.json({
|
|
success: true,
|
|
data: {
|
|
videos,
|
|
folders: subfolders,
|
|
currentPath: folder,
|
|
totalVideos: videos.length,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Upload singolo video
|
|
*/
|
|
uploadVideo = async (req, res) => {
|
|
try {
|
|
if (!req.file) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: 'Nessun file caricato',
|
|
});
|
|
}
|
|
|
|
// ✅ Legge da query parameter
|
|
const folder = req.query.folder || 'default';
|
|
|
|
const videoInfo = {
|
|
id: uuidv4(),
|
|
originalName: req.file.originalname,
|
|
filename: req.file.filename,
|
|
folder: folder,
|
|
path: `/videos/${folder}/${req.file.filename}`,
|
|
size: req.file.size,
|
|
mimetype: req.file.mimetype,
|
|
uploadedAt: new Date().toISOString(),
|
|
};
|
|
|
|
res.status(201).json({
|
|
success: true,
|
|
data: { video: videoInfo },
|
|
message: 'Video caricato con successo',
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Upload multiplo video
|
|
*/
|
|
uploadVideos = async (req, res) => {
|
|
try {
|
|
if (!req.files || req.files.length === 0) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: 'Nessun file caricato',
|
|
});
|
|
}
|
|
|
|
// ✅ Legge da query parameter
|
|
const folder = req.query.folder || 'default';
|
|
|
|
const videos = req.files.map((file) => ({
|
|
id: uuidv4(),
|
|
originalName: file.originalname,
|
|
filename: file.filename,
|
|
folder: folder,
|
|
path: `/videos/${folder}/${file.filename}`,
|
|
size: file.size,
|
|
mimetype: file.mimetype,
|
|
uploadedAt: new Date().toISOString(),
|
|
}));
|
|
|
|
res.status(201).json({
|
|
success: true,
|
|
data: { videos },
|
|
message: `${videos.length} video caricati con successo`,
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Ottiene info di un singolo video
|
|
*/
|
|
getVideo = async (req, res) => {
|
|
try {
|
|
const { folder, filename } = req.params;
|
|
const videoPath = path.join(this.basePath, folder, filename);
|
|
|
|
if (!fs.existsSync(videoPath)) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
error: 'Video non trovato',
|
|
});
|
|
}
|
|
|
|
const videoInfo = this._getFileInfo(videoPath, folder);
|
|
|
|
res.json({
|
|
success: true,
|
|
data: { video: videoInfo },
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Rinomina un video
|
|
*/
|
|
renameVideo = async (req, res) => {
|
|
try {
|
|
const { folder, filename } = req.params;
|
|
const { newFilename } = req.body;
|
|
|
|
if (!newFilename || !newFilename.trim()) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: 'Nuovo nome file richiesto',
|
|
});
|
|
}
|
|
|
|
const oldPath = path.join(this.basePath, folder, filename);
|
|
const newPath = path.join(this.basePath, folder, newFilename);
|
|
|
|
if (!fs.existsSync(oldPath)) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
error: 'Video non trovato',
|
|
});
|
|
}
|
|
|
|
if (fs.existsSync(newPath)) {
|
|
return res.status(409).json({
|
|
success: false,
|
|
error: 'Un file con questo nome esiste già',
|
|
});
|
|
}
|
|
|
|
fs.renameSync(oldPath, newPath);
|
|
|
|
res.json({
|
|
success: true,
|
|
message: 'Video rinominato con successo',
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Sposta un video in un'altra cartella
|
|
*/
|
|
moveVideo = async (req, res) => {
|
|
try {
|
|
const { folder, filename } = req.params;
|
|
const { destinationFolder } = req.body;
|
|
|
|
const sourcePath = path.join(this.basePath, folder, filename);
|
|
const destDir = path.join(this.basePath, destinationFolder);
|
|
const destPath = path.join(destDir, filename);
|
|
|
|
if (!fs.existsSync(sourcePath)) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
error: 'Video non trovato',
|
|
});
|
|
}
|
|
|
|
this._ensureDirectory(destDir);
|
|
|
|
if (fs.existsSync(destPath)) {
|
|
return res.status(409).json({
|
|
success: false,
|
|
error: 'Un file con questo nome esiste già nella destinazione',
|
|
});
|
|
}
|
|
|
|
fs.renameSync(sourcePath, destPath);
|
|
|
|
res.json({
|
|
success: true,
|
|
message: 'Video spostato con successo',
|
|
data: {
|
|
newPath: `/videos/${destinationFolder}/${filename}`,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Elimina un video
|
|
*/
|
|
deleteVideo = async (req, res) => {
|
|
try {
|
|
const { folder, filename } = req.params;
|
|
const videoPath = path.join(this.basePath, folder, filename);
|
|
|
|
if (!fs.existsSync(videoPath)) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
error: 'Video non trovato',
|
|
});
|
|
}
|
|
|
|
fs.unlinkSync(videoPath);
|
|
|
|
res.json({
|
|
success: true,
|
|
message: 'Video eliminato con successo',
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Stream video (per player)
|
|
*/
|
|
streamVideo = async (req, res) => {
|
|
try {
|
|
const { folder, filename } = req.params;
|
|
const videoPath = path.join(this.basePath, folder, filename);
|
|
|
|
if (!fs.existsSync(videoPath)) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
error: 'Video non trovato',
|
|
});
|
|
}
|
|
|
|
const stat = fs.statSync(videoPath);
|
|
const fileSize = stat.size;
|
|
const range = req.headers.range;
|
|
|
|
if (range) {
|
|
const parts = range.replace(/bytes=/, '').split('-');
|
|
const start = parseInt(parts[0], 10);
|
|
const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
|
|
const chunkSize = end - start + 1;
|
|
|
|
const file = fs.createReadStream(videoPath, { start, end });
|
|
const headers = {
|
|
'Content-Range': `bytes ${start}-${end}/${fileSize}`,
|
|
'Accept-Ranges': 'bytes',
|
|
'Content-Length': chunkSize,
|
|
'Content-Type': 'video/mp4',
|
|
};
|
|
|
|
res.writeHead(206, headers);
|
|
file.pipe(res);
|
|
} else {
|
|
const headers = {
|
|
'Content-Length': fileSize,
|
|
'Content-Type': 'video/mp4',
|
|
};
|
|
|
|
res.writeHead(200, headers);
|
|
fs.createReadStream(videoPath).pipe(res);
|
|
}
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
// ============ ERROR HANDLER MIDDLEWARE ============
|
|
|
|
static errorHandler = (error, req, res, next) => {
|
|
if (error.code === 'LIMIT_FILE_SIZE') {
|
|
return res.status(413).json({
|
|
success: false,
|
|
error: 'File troppo grande. Dimensione massima: 500MB',
|
|
});
|
|
}
|
|
|
|
if (error.code === 'LIMIT_FILE_COUNT') {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: 'Troppi file. Massimo 10 file per upload',
|
|
});
|
|
}
|
|
|
|
if (error.message.includes('Tipo file non supportato')) {
|
|
return res.status(415).json({
|
|
success: false,
|
|
error: error.message,
|
|
});
|
|
}
|
|
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message || 'Errore interno del server',
|
|
});
|
|
};
|
|
}
|
|
|
|
module.exports = VideoController;
|