427 lines
16 KiB
JavaScript
427 lines
16 KiB
JavaScript
require('../connections/mysql-server');
|
|
require('../helpers/CheckToken');
|
|
require('../helpers/config');
|
|
const formidable = require('formidable');
|
|
const express = require('express');
|
|
const router = express.Router();
|
|
const bodyParser = require('body-parser');
|
|
|
|
var accessToken = "b78050152a551b71665045f03a2161fa";
|
|
var clientSecret = "VumfHSuZcTIAe6hyvHgrRGv+UVX9xEQlX1HqFgiA+7DDhLIIXt1hjy2mP3Ht/MQyYs++ja8Ok5+aWabRRJ5uGY+dQDIlmZGeWpplffT6VowLOLe6JEYH4OLdmv5sNQtR";
|
|
var clientIDVimeo = "addbd91428cb667f7c5d50e47626ddb8554170cb";
|
|
|
|
router.use(bodyParser.urlencoded({
|
|
parameterLimit: 100000,
|
|
limit: '2000mb',
|
|
extended: true
|
|
}));
|
|
router.use(bodyParser.json({
|
|
parameterLimit: 100000,
|
|
limit: '2000mb',
|
|
extended: true
|
|
}));
|
|
|
|
const routes = function () {
|
|
|
|
router.get('/', verifyJWT, (req, res) => {
|
|
execSQLQuery(`SELECT
|
|
*
|
|
FROM media;`, res, req.originalUrl);
|
|
});
|
|
|
|
router.get('/getAllMedia', (req, res) => {
|
|
execSQLQuery(`SELECT
|
|
*
|
|
FROM media;`, res, req.originalUrl);
|
|
});
|
|
|
|
router.get('/getMedia/:idmedia', verifyJWT, (req, res) => {
|
|
const idmedia = parseInt(req.params.idmedia);
|
|
execSQLQuery(`SELECT
|
|
*
|
|
FROM media
|
|
WHERE idmedia = ${idmedia};`, res, req.originalUrl);
|
|
});
|
|
|
|
router.get('/viewvideo/:_key', (req, res) => {
|
|
var _key = req.params._key;
|
|
execSQLQueryVideo(`SELECT * FROM videoaccess WHERE _key = '${_key}' AND expired = 0`, res, req.originalUrl);
|
|
});
|
|
|
|
router.post('/insertVA', verifyJWT, (req, res) => {
|
|
const idvideoaccess = req.body.idvideoaccess;
|
|
const _key = (req.body._key).trim();
|
|
const expired = req.body.expired ? 1 : 0;
|
|
const url = req.body.url;
|
|
const tag = req.body.tag;
|
|
|
|
execSQLQuery(`INSERT INTO videoaccess(_key, expired, url, tag)
|
|
VALUES (?, ?, ?, ?);`, res, req.originalUrl, [_key, expired, url, tag]);
|
|
});
|
|
|
|
router.patch('/updateVA', verifyJWT, (req, res) => {
|
|
const idvideoaccess = req.body.idvideoaccess;
|
|
const _key = (req.body._key).trim();
|
|
const expired = req.body.expired ? 1 : 0;
|
|
const url = req.body.url;
|
|
execSQLQuery(`UPDATE videoaccess SET
|
|
_key = ?,
|
|
expired = ?,
|
|
url = ?
|
|
WHERE idvideoaccess = ?;`, res, req.originalUrl, [_key, expired, url, idvideoaccess]);
|
|
});
|
|
|
|
router.get('/getVA/:tag', verifyJWT, (req, res) => {
|
|
const tag = req.params.tag;
|
|
execSQLQuery(`SELECT * FROM videoaccess WHERE tag = '${tag}' AND expired = 0;`, res, req.originalUrl);
|
|
});
|
|
|
|
router.post('/insertMedia', verifyJWT, (req, res) => {
|
|
const idmedia = req.body.idmedia;
|
|
const description = req.body.description;
|
|
const publishid = req.body.publishid;
|
|
const type = req.body.type;
|
|
execSQLQuery(`INSERT INTO media(description, publishid, type)
|
|
VALUES (?, ?, ?);`, res, req.originalUrl, [description, publishid, type]);
|
|
});
|
|
|
|
router.patch('/updateMedia', verifyJWT, (req, res) => {
|
|
const idmedia = req.body.idmedia;
|
|
const description = req.body.description;
|
|
const publishid = req.body.publishid;
|
|
const type = req.body.type;
|
|
execSQLQuery(`UPDATE media SET
|
|
description = ?,
|
|
publishid = ?,
|
|
type = ?
|
|
WHERE idmedia = ?;`, res, req.originalUrl, [description, publishid, type, idmedia]);
|
|
});
|
|
|
|
router.get('/backVideo/:idvideo/:Online', (req, res) => {
|
|
var idvideos = req.params.idvideo;
|
|
var dir = Variables('src_media') + 'videos/tmp/var/www/html/videos/' + idvideos + '.mp4';
|
|
const fs = require('fs');
|
|
|
|
if (fs.existsSync(dir)) {
|
|
console.log("Requisição de vídeo: " + idvideos);
|
|
res.send(true);
|
|
}
|
|
else {
|
|
const shell = require('shelljs');
|
|
shell.exec(`unzip -o -P "${Variables('passdecrypt')}" ${Variables('src_media')}videos/${idvideos}.zip -d ${Variables('src_media')}videos/tmp/`, function (ResExtract) {
|
|
console.log("RESULTADO: " + ResExtract);
|
|
if (ResExtract == 0) { // EXTRAIDO COM SUCESSO
|
|
shell.exec(`chmod -R 777 ${Variables('src_media')}videos/tmp/`);
|
|
if (fs.existsSync(dir)) {
|
|
console.log("Requisição de vídeo: " + idvideos);
|
|
res.send(true);
|
|
}
|
|
else {
|
|
res.send(false);
|
|
}
|
|
}
|
|
else { // ERRO AO EXTRAIR ( BAIXA O ARQUIVO DO SERVIDOR E REPRODUZ NO VIMEO )
|
|
shell.exec('cd ' + Variables('src_media') + 'videos/;wget http://18.228.91.135/videos/' + idvideos + '.zip', function (sucesso) {
|
|
console.log(sucesso);
|
|
});
|
|
res.send(false);
|
|
}
|
|
});
|
|
/*require('all-unpacker').unpack(Variables('src_media') + 'videos/' + idvideos + '.zip', {
|
|
targetDir: Variables('src_media') + 'videos/tmp/',
|
|
password: Variables('passdecrypt'),
|
|
forceOverwrite: true,
|
|
}, function(err, files, text) {
|
|
if (err) {
|
|
console.error(err);
|
|
shell.exec('cd ' + Variables('src_media') + 'videos/;wget http://18.228.91.135/videos/' + idvideos + '.zip', function (sucesso) {
|
|
console.log(sucesso);
|
|
});
|
|
if (check == 0) {
|
|
res.redirect("https://player.vimeo.com/video/" + idvideos);
|
|
}
|
|
else {
|
|
res.send(false);
|
|
}
|
|
}
|
|
if (files) console.log('files', files);
|
|
if (text) {
|
|
console.log('text', text);
|
|
fs.readFile(dir, (err, data) => {
|
|
if (err) throw err;
|
|
console.log("Requisição de vídeo: " + idvideos);
|
|
if (check == 0) {
|
|
res.setHeader('Content-Type', 'video/mp4');
|
|
res.send(data);
|
|
}
|
|
else {
|
|
res.send(true);
|
|
}
|
|
});
|
|
//res.redirect(dir);
|
|
};
|
|
});*/
|
|
}
|
|
});
|
|
|
|
router.get('/deleteVideo/:publishid', verifyJWT, (req, res) => {
|
|
const publishid = req.params.publishid;
|
|
let Vimeo = require('vimeo').Vimeo;
|
|
let client = new Vimeo(clientIDVimeo, clientSecret, accessToken);
|
|
client.request({
|
|
method: 'DELETE',
|
|
path: '/videos/' + publishid,
|
|
}, function (error, body, status_code, headers) {
|
|
mysqlConnection.query(`DELETE FROM media WHERE publishid = '${publishid}';`, function (error, results, fields) {
|
|
const fs = require('fs');
|
|
fs.unlink(Variables('src_media') + 'videos/' + publishid + '.zip', function(Sucesso) {
|
|
res.send(JSON.stringify({
|
|
"status": 200,
|
|
"error": error,
|
|
"response": results
|
|
}));
|
|
console.log(req.originalUrl + "/ success 200");
|
|
});
|
|
});
|
|
});
|
|
})
|
|
|
|
let uploads = {};
|
|
|
|
router.post('/uploadwithProgress', verifyJWT, (req, res, next) => {
|
|
let fs = require('fs');
|
|
let fileId = req.headers['x-file-id'];
|
|
let startByte = parseInt(req.headers['x-start-byte'], 10);
|
|
let name = req.headers['name'];
|
|
let fileSize = parseInt(req.headers['size'], 10);
|
|
let Copiar = req.headers['Copiar'] || "1";
|
|
let ext = '.mp4';
|
|
console.log('file Size', fileSize, fileId, startByte);
|
|
if (uploads[fileId] && fileSize == uploads[fileId].bytesReceived) {
|
|
res.end();
|
|
return;
|
|
}
|
|
console.log(fileSize);
|
|
|
|
if (!fileId) {
|
|
res.writeHead(400, "No file id");
|
|
res.end(400);
|
|
}
|
|
console.log(uploads[fileId]);
|
|
if (!uploads[fileId])
|
|
uploads[fileId] = {};
|
|
|
|
let upload = uploads[fileId]; //Bytes of file already present
|
|
|
|
let fileStream;
|
|
|
|
let Caminho = `${Variables('src_media')}videos/`;
|
|
let dir = `${Caminho}${name}`;
|
|
|
|
//checking bytes of file uploaded and sending to server
|
|
if (!startByte) {
|
|
upload.bytesReceived = 0;
|
|
let name = req.headers['name'];
|
|
fileStream = fs.createWriteStream(dir + ext, {
|
|
flags: 'w' //with "w"(write stream ) it keeps on adding data
|
|
});
|
|
} else {
|
|
if (upload.bytesReceived != startByte) {//if same name file is sent with different size it will not upload
|
|
res.writeHead(400, "Wrong start byte");
|
|
res.end(upload.bytesReceived);
|
|
return;
|
|
}
|
|
// append to existing file
|
|
fileStream = fs.createWriteStream(dir + ext, {
|
|
flags: 'a'
|
|
});
|
|
}
|
|
req.on('data', function (data) {
|
|
upload.bytesReceived += data.length; //adding length of data we are adding
|
|
});
|
|
req.pipe(fileStream);
|
|
// when the request is finished, and all its data is written
|
|
fileStream.on('close', function () {
|
|
console.log(upload.bytesReceived, fileSize);
|
|
if (upload.bytesReceived == fileSize) {
|
|
console.log("Upload finished");
|
|
delete uploads[fileId];
|
|
|
|
// can do something else with the uploaded file here
|
|
|
|
UploadVimeo(name, dir + ext, function(URI) {
|
|
if (URI == false) {
|
|
// ERRO
|
|
fs.unlink(dir + ext, function(Sucesso) {
|
|
res.send({ 'status': 'falhou' });
|
|
res.end();
|
|
})
|
|
}
|
|
else {
|
|
// SUCESSO
|
|
let novoNome = URI.split('/')[2];
|
|
if (Copiar == "1") {
|
|
fs.rename(dir + ext, Caminho + novoNome + ext, function(Sucesso) {
|
|
zipVideoSync(novoNome, Caminho + novoNome, function(Sucesso) {
|
|
res.send({ 'status': 'uploaded', 'uri': URI });
|
|
res.end();
|
|
});
|
|
})
|
|
}
|
|
else {
|
|
fs.unlink(dir + ext, function(Sucesso) {
|
|
res.send({ 'status': 'uploaded', 'uri': URI });
|
|
res.end();
|
|
})
|
|
}
|
|
}
|
|
})
|
|
|
|
} else {
|
|
// connection lost, leave the unfinished file around
|
|
console.log("File unfinished, stopped at " + upload.bytesReceived);
|
|
res.writeHead(500, "Server Error");
|
|
res.end();
|
|
}
|
|
});
|
|
|
|
// in case of I/O error - finish the request
|
|
fileStream.on('error', function (err) {
|
|
console.log("fileStream error", err);
|
|
res.writeHead(500, "File error");
|
|
res.end();
|
|
});
|
|
|
|
});
|
|
|
|
router.get('/status', verifyJWT, (req, res) => {
|
|
//console.log('Successfully came');
|
|
//From GET request 3 parameters below and store in variable
|
|
let fileId = req.headers['x-file-id'];
|
|
let name = req.headers['name'];
|
|
let fileSize = parseInt(req.headers['size'], 10);
|
|
console.log(name);
|
|
if (name) {
|
|
try {
|
|
let stats = fs.statSync(`${Variables('src_media')}videos/${name}`); //grabs file information and returns
|
|
//checking file exists or not
|
|
if (stats.isFile()) {
|
|
console.log(`fileSize is ${fileSize} and already uploaded file size ${stats.size}`);
|
|
if (fileSize == stats.size) {
|
|
res.send({ 'status': 'file is present' }) //returns if file exists
|
|
return;
|
|
}
|
|
if (!uploads[fileId])
|
|
uploads[fileId] = {}
|
|
console.log(uploads[fileId]);
|
|
uploads[fileId]['bytesReceived'] = stats.size;//checks total amount of file uploaded
|
|
console.log(uploads[fileId], stats.size);
|
|
}
|
|
} catch (er) {
|
|
|
|
}
|
|
|
|
}
|
|
let upload = uploads[fileId];
|
|
if (upload)
|
|
res.send({ "uploaded": upload.bytesReceived });//returns to FrontEnd amout of bytes uploaded
|
|
else
|
|
res.send({ "uploaded": 0 });
|
|
|
|
});
|
|
|
|
router.get('/SolucaoProblemas/:publishid/:tentativa', verifyJWT, (req, res) => {
|
|
const publishid = req.params.publishid;
|
|
const tentativa = parseInt(req.params.tentativa);
|
|
const fs = require('fs');
|
|
if (tentativa == 1) {
|
|
fs.unlink(Variables('src_media') + 'videos/tmp/var/www/html/videos/' + publishid + '.mp4', function(Sucesso) {
|
|
console.log("Video MP4 excluido com sucesso!");
|
|
res.send(true);
|
|
});
|
|
}
|
|
else {
|
|
fs.unlink(Variables('src_media') + 'videos/' + publishid + '.zip', function(Sucesso) {
|
|
console.log("Video ZIP excluido com sucesso!");
|
|
fs.unlink(Variables('src_media') + 'videos/tmp/var/www/html/videos/' + publishid + '.mp4', function(Sucesso) {
|
|
console.log("Video MP4 excluido com sucesso!");
|
|
res.send(true);
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|
|
return router;
|
|
};
|
|
|
|
function UploadVimeo(description, oldpath, callback) {
|
|
let Vimeo = require('vimeo').Vimeo;
|
|
let client = new Vimeo(clientIDVimeo, clientSecret, accessToken);
|
|
client.upload(
|
|
oldpath,
|
|
{
|
|
'name': description,
|
|
'description': description
|
|
},
|
|
function (uri) {
|
|
console.log('Your video URI is: ' + uri);
|
|
callback(uri);
|
|
},
|
|
function (bytes_uploaded, bytes_total) {
|
|
var percentage = (bytes_uploaded / bytes_total * 100).toFixed(2)
|
|
console.log(bytes_uploaded, bytes_total, percentage + '%')
|
|
},
|
|
function (error) {
|
|
console.log('Failed because: ' + error)
|
|
callback(false);
|
|
})
|
|
}
|
|
|
|
function zipVideoSync(name, dir, callback) {
|
|
const fs = require('fs');
|
|
require('all-unpacker').pack(Variables('src_media') + 'videos/' + name + '.zip', {
|
|
targetDir: Variables('src_media') + 'videos/' + name + '.mp4',
|
|
password: Variables('passdecrypt'),
|
|
}, function(err, files, text) {
|
|
if (err) return console.error(err);
|
|
if (files) console.log('files', files);
|
|
if (text) {
|
|
console.log('text', text);
|
|
if(fs.unlinkSync(dir + '.mp4'))
|
|
console.log("Falha ao excluir");
|
|
else
|
|
console.log("Excluído com sucesso!");
|
|
callback(true);
|
|
};
|
|
});
|
|
}
|
|
|
|
module.exports = routes;
|
|
|
|
/*
|
|
//função pack - inserida no index.js da biblioteca all-unpacker//
|
|
|
|
unpackAll.pack = function pack(archiveFile, options, callback) {
|
|
if (!callback) return new Error('No callback function');
|
|
if (!archiveFile) archiveFile = options.archiveFile;
|
|
if (!archiveFile) return callback(Error("Error: archiveFile or options.archiveFile missing."), null);
|
|
if (!options) options = {};
|
|
|
|
var unar = options.unar;
|
|
if (!unar) unar = (process.platform != "linux") ? path.join(__dirname,'zip') : 'zip';
|
|
var ar = [unar];
|
|
|
|
if (options.password) {
|
|
ar.push('-P');
|
|
ar.push(options.password);
|
|
}
|
|
|
|
ar.push('SOURCEFILE');
|
|
|
|
var targetDir = options.targetDir;
|
|
ar.push(targetDir);
|
|
|
|
var cmd = quote(ar).replace('SOURCEFILE', archiveFile);
|
|
exec_unar(cmd, targetDir, callback);
|
|
};
|
|
*/ |