mirror of
https://github.com/taobataoma/meanTorrent.git
synced 2026-01-16 20:32:21 +01:00
1322 lines
34 KiB
JavaScript
1322 lines
34 KiB
JavaScript
'use strict';
|
|
|
|
/**
|
|
* Module dependencies
|
|
*/
|
|
var path = require('path'),
|
|
config = require(path.resolve('./config/config')),
|
|
mongoose = require('mongoose'),
|
|
errorHandler = require(path.resolve('./modules/core/server/controllers/errors.server.controller')),
|
|
multer = require('multer'),
|
|
moment = require('moment'),
|
|
User = mongoose.model('User'),
|
|
Peer = mongoose.model('Peer'),
|
|
Subtitle = mongoose.model('Subtitle'),
|
|
Thumb = mongoose.model('Thumb'),
|
|
Torrent = mongoose.model('Torrent'),
|
|
Complete = mongoose.model('Complete'),
|
|
Forum = mongoose.model('Forum'),
|
|
Topic = mongoose.model('Topic'),
|
|
fs = require('fs'),
|
|
nt = require('nt'),
|
|
benc = require('bncode'),
|
|
scrape = require(path.resolve('./config/lib/scrape')),
|
|
async = require('async'),
|
|
validator = require('validator'),
|
|
tmdb = require('moviedb')(config.meanTorrentConfig.tmdbConfig.key),
|
|
traceLogCreate = require(path.resolve('./config/lib/tracelog')).create,
|
|
scoreUpdate = require(path.resolve('./config/lib/score')).update;
|
|
|
|
var traceConfig = config.meanTorrentConfig.trace;
|
|
var scoreConfig = config.meanTorrentConfig.score;
|
|
var thumbsUpScore = config.meanTorrentConfig.score.thumbsUpScore;
|
|
var ircConfig = config.meanTorrentConfig.ircAnnounce;
|
|
var vsprintf = require('sprintf-js').vsprintf;
|
|
|
|
var mtDebug = require(path.resolve('./config/lib/debug'));
|
|
|
|
const PEERSTATE_SEEDER = 'seeder';
|
|
const PEERSTATE_LEECHER = 'leecher';
|
|
|
|
/**
|
|
* get movie info from tmdb
|
|
*/
|
|
exports.movieinfo = function (req, res) {
|
|
mtDebug.debugGreen('------- API: movieinfo --------------------');
|
|
mtDebug.debugGreen(req.params);
|
|
|
|
tmdb.movieInfo({
|
|
id: req.params.tmdbid,
|
|
language: req.params.language,
|
|
append_to_response: 'credits,images,alternative_titles,release_dates',
|
|
include_image_language: req.params.language + ',null'
|
|
}, function (err, info) {
|
|
if (err) {
|
|
res.status(900).send(err);
|
|
} else {
|
|
res.json(info);
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* get tv info from tmdb
|
|
*/
|
|
exports.tvinfo = function (req, res) {
|
|
mtDebug.debugGreen('------- API: tvinfo --------------------');
|
|
mtDebug.debugGreen(req.params);
|
|
|
|
tmdb.tvInfo({
|
|
id: req.params.tmdbid,
|
|
language: req.params.language,
|
|
append_to_response: 'credits,images,alternative_titles',
|
|
include_image_language: req.params.language + ',null'
|
|
}, function (err, info) {
|
|
if (err) {
|
|
res.status(900).send(err);
|
|
} else {
|
|
res.json(info);
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* upload torrent file
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.upload = function (req, res) {
|
|
var user = req.user;
|
|
var createUploadFilename = require(path.resolve('./config/lib/multer')).createUploadFilename;
|
|
var getUploadDestination = require(path.resolve('./config/lib/multer')).getUploadDestination;
|
|
var fileFilter = require(path.resolve('./config/lib/multer')).torrentFileFilter;
|
|
var torrentinfo = null;
|
|
|
|
var storage = multer.diskStorage({
|
|
destination: getUploadDestination,
|
|
filename: createUploadFilename
|
|
});
|
|
|
|
var upload = multer({
|
|
storage: storage,
|
|
fileFilter: fileFilter,
|
|
limits: config.uploads.torrent.file.limits
|
|
}).single('newTorrentFile');
|
|
|
|
if (user) {
|
|
uploadFile()
|
|
.then(checkAnnounce)
|
|
.then(checkHash)
|
|
.then(function () {
|
|
res.status(200).send(torrentinfo);
|
|
})
|
|
.catch(function (err) {
|
|
res.status(422).send(err);
|
|
|
|
if (req.file && req.file.filename) {
|
|
var newfile = config.uploads.torrent.file.temp + req.file.filename;
|
|
if (fs.existsSync(newfile)) {
|
|
mtDebug.debugRed(err);
|
|
mtDebug.debugRed('ERROR: DELETE TEMP TORRENT FILE: ' + newfile);
|
|
fs.unlinkSync(newfile);
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
res.status(401).send({
|
|
message: 'User is not signed in'
|
|
});
|
|
}
|
|
|
|
function uploadFile() {
|
|
return new Promise(function (resolve, reject) {
|
|
upload(req, res, function (uploadError) {
|
|
if (uploadError) {
|
|
var message = errorHandler.getErrorMessage(uploadError);
|
|
|
|
if (uploadError.code === 'LIMIT_FILE_SIZE') {
|
|
message = 'Torrent file too large. Maximum size allowed is ' + (config.uploads.torrent.file.limits.fileSize / (1024 * 1024)).toFixed(2) + ' Mb files.';
|
|
}
|
|
|
|
reject(message);
|
|
} else {
|
|
resolve();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
function checkAnnounce() {
|
|
return new Promise(function (resolve, reject) {
|
|
mtDebug.debugGreen(req.file.filename);
|
|
var newfile = config.uploads.torrent.file.temp + req.file.filename;
|
|
nt.read(newfile, function (err, torrent) {
|
|
var message = '';
|
|
|
|
if (err) {
|
|
message = 'Read torrent file faild';
|
|
reject(message);
|
|
} else {
|
|
//if (config.meanTorrentConfig.announce.privateTorrentCmsMode) {
|
|
// if (torrent.metadata.announce !== config.meanTorrentConfig.announce.url) {
|
|
// mtDebug.debugGreen(torrent.metadata.announce);
|
|
// message = 'ANNOUNCE_URL_ERROR';
|
|
//
|
|
// reject(message);
|
|
// }
|
|
//}
|
|
torrentinfo = torrent.metadata;
|
|
torrentinfo.info_hash = torrent.infoHash();
|
|
torrentinfo.filename = req.file.filename;
|
|
resolve();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
function checkHash() {
|
|
return new Promise(function (resolve, reject) {
|
|
var message = '';
|
|
|
|
if (torrentinfo.info_hash === '' || !torrentinfo.info_hash) {
|
|
message = 'INFO_HASH_IS_EMPTY';
|
|
reject(message);
|
|
} else {
|
|
Torrent.findOne({
|
|
info_hash: torrentinfo.info_hash
|
|
}).exec(function (err, torrent) {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
if (torrent) {
|
|
message = 'INFO_HASH_ALREADY_EXISTS';
|
|
|
|
reject(message);
|
|
} else {
|
|
resolve();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* uploadTorrentCover
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.uploadTorrentCover = function (req, res) {
|
|
var user = req.user;
|
|
var createUploadCoverImageFilename = require(path.resolve('./config/lib/multer')).createUploadCoverImageFilename;
|
|
var getUploadCoverImageDestination = require(path.resolve('./config/lib/multer')).getUploadCoverImageDestination;
|
|
var fileFilter = require(path.resolve('./config/lib/multer')).imageFileFilter;
|
|
var coverInfo = {};
|
|
|
|
var storage = multer.diskStorage({
|
|
destination: getUploadCoverImageDestination,
|
|
filename: createUploadCoverImageFilename
|
|
});
|
|
|
|
var upload = multer({
|
|
storage: storage,
|
|
fileFilter: fileFilter,
|
|
limits: config.uploads.torrent.cover.limits
|
|
}).single('newTorrentCoverFile');
|
|
|
|
if (user) {
|
|
uploadFile()
|
|
.then(function () {
|
|
res.status(200).send(coverInfo);
|
|
})
|
|
.catch(function (err) {
|
|
res.status(422).send(err);
|
|
mtDebug.debugRed(err);
|
|
|
|
if (req.file && req.file.filename) {
|
|
var newfile = config.uploads.torrent.cover.temp + req.file.filename;
|
|
if (fs.existsSync(newfile)) {
|
|
mtDebug.debugRed(err);
|
|
mtDebug.debugRed('ERROR: DELETE TEMP COVER FILE: ' + newfile);
|
|
fs.unlinkSync(newfile);
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
res.status(401).send({
|
|
message: 'User is not signed in'
|
|
});
|
|
}
|
|
|
|
function uploadFile() {
|
|
return new Promise(function (resolve, reject) {
|
|
upload(req, res, function (uploadError) {
|
|
if (uploadError) {
|
|
var message = errorHandler.getErrorMessage(uploadError);
|
|
|
|
if (uploadError.code === 'LIMIT_FILE_SIZE') {
|
|
message = 'Cover image file too large. Maximum size allowed is ' + (config.uploads.torrent.cover.limits.fileSize / (1024 * 1024)).toFixed(2) + ' Mb files.';
|
|
}
|
|
|
|
reject(message);
|
|
} else {
|
|
coverInfo.filename = req.file.filename;
|
|
resolve();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* uploadTorrentImage
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.uploadTorrentImage = function (req, res) {
|
|
var user = req.user;
|
|
var createUploadTorrentImageFilename = require(path.resolve('./config/lib/multer')).createUploadTorrentImageFilename;
|
|
var getUploadTorrentImageDestination = require(path.resolve('./config/lib/multer')).getUploadTorrentImageDestination;
|
|
var fileFilter = require(path.resolve('./config/lib/multer')).imageFileFilter;
|
|
var imageInfo = {};
|
|
|
|
var storage = multer.diskStorage({
|
|
destination: getUploadTorrentImageDestination,
|
|
filename: createUploadTorrentImageFilename
|
|
});
|
|
|
|
var upload = multer({
|
|
storage: storage,
|
|
fileFilter: fileFilter,
|
|
limits: config.uploads.torrent.cover.limits
|
|
}).single('newTorrentImageFile');
|
|
|
|
if (user) {
|
|
uploadFile()
|
|
.then(function () {
|
|
res.status(200).send(imageInfo);
|
|
})
|
|
.catch(function (err) {
|
|
res.status(422).send(err);
|
|
mtDebug.debugRed(err);
|
|
|
|
if (req.file && req.file.filename) {
|
|
var newfile = config.uploads.torrent.image.temp + req.file.filename;
|
|
if (fs.existsSync(newfile)) {
|
|
mtDebug.debugRed(err);
|
|
mtDebug.debugRed('ERROR: DELETE TEMP TORRENT IMAGE FILE: ' + newfile);
|
|
fs.unlinkSync(newfile);
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
res.status(401).send({
|
|
message: 'User is not signed in'
|
|
});
|
|
}
|
|
|
|
function uploadFile() {
|
|
return new Promise(function (resolve, reject) {
|
|
upload(req, res, function (uploadError) {
|
|
if (uploadError) {
|
|
var message = errorHandler.getErrorMessage(uploadError);
|
|
|
|
if (uploadError.code === 'LIMIT_FILE_SIZE') {
|
|
message = 'Torrent image file too large. Maximum size allowed is ' + (config.uploads.torrent.image.limits.fileSize / (1024 * 1024)).toFixed(2) + ' Mb files.';
|
|
}
|
|
|
|
reject(message);
|
|
} else {
|
|
imageInfo.filename = req.file.filename;
|
|
resolve();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* announceEdit
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.announceEdit = function (req, res) {
|
|
var user = req.user;
|
|
var createUploadFilename = require(path.resolve('./config/lib/multer')).createUploadFilename;
|
|
var getUploadDestination = require(path.resolve('./config/lib/multer')).getUploadDestination;
|
|
var fileFilter = require(path.resolve('./config/lib/multer')).torrentFileFilter;
|
|
var torrent_data = null;
|
|
|
|
var storage = multer.diskStorage({
|
|
destination: getUploadDestination,
|
|
filename: createUploadFilename
|
|
});
|
|
|
|
var upload = multer({
|
|
storage: storage,
|
|
fileFilter: fileFilter,
|
|
limits: config.uploads.torrent.file.limits
|
|
}).single('newTorrentFile');
|
|
|
|
if (user) {
|
|
uploadFile()
|
|
.then(function () {
|
|
var filePath = config.uploads.torrent.file.temp + req.file.filename;
|
|
var stat = fs.statSync(filePath);
|
|
|
|
fs.exists(filePath, function (exists) {
|
|
if (exists) {
|
|
getTorrentFileData(filePath)
|
|
.then(function () {
|
|
res.set('Content-Type', 'application/x-bittorrent');
|
|
res.set('Content-Disposition', 'attachment; filename=' + encodeURI(req.file.filename));
|
|
res.set('Content-Length', stat.size);
|
|
|
|
res.send(benc.encode(torrent_data));
|
|
})
|
|
.catch(function (err) {
|
|
res.status(422).send(err);
|
|
});
|
|
} else {
|
|
res.status(422).send({
|
|
message: 'FILE_DOES_NOT_EXISTS'
|
|
});
|
|
}
|
|
});
|
|
})
|
|
.catch(function (err) {
|
|
|
|
res.status(422).send(err);
|
|
|
|
if (req.file && req.file.filename) {
|
|
var newfile = config.uploads.torrent.file.temp + req.file.filename;
|
|
if (fs.existsSync(newfile)) {
|
|
mtDebug.debugRed(err);
|
|
mtDebug.debugRed('ERROR: DELETE TEMP TORRENT FILE: ' + newfile);
|
|
fs.unlinkSync(newfile);
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
res.status(401).send({
|
|
message: 'User is not signed in'
|
|
});
|
|
}
|
|
|
|
function uploadFile() {
|
|
return new Promise(function (resolve, reject) {
|
|
upload(req, res, function (uploadError) {
|
|
if (uploadError) {
|
|
var message = errorHandler.getErrorMessage(uploadError);
|
|
|
|
if (uploadError.code === 'LIMIT_FILE_SIZE') {
|
|
message = 'Torrent file too large. Maximum size allowed is ' + (config.uploads.torrent.file.limits.fileSize / (1024 * 1024)).toFixed(2) + ' Mb files.';
|
|
}
|
|
|
|
reject(message);
|
|
} else {
|
|
resolve();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
function getTorrentFileData(file) {
|
|
return new Promise(function (resolve, reject) {
|
|
nt.read(file, function (err, torrent) {
|
|
var message = '';
|
|
|
|
if (err) {
|
|
message = 'Read torrent file faild';
|
|
reject(message);
|
|
} else {
|
|
var announce = config.meanTorrentConfig.announce.url;
|
|
torrent.metadata.announce = announce;
|
|
torrent.metadata.comment = req.query.comment;
|
|
torrent_data = torrent.metadata;
|
|
resolve();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* download a torrent file
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.download = function (req, res) {
|
|
var torrent_data = null;
|
|
var filePath = config.uploads.torrent.file.dest + req.torrent.torrent_filename;
|
|
var stat = fs.statSync(filePath);
|
|
|
|
fs.exists(filePath, function (exists) {
|
|
if (exists) {
|
|
getTorrentFileData(filePath)
|
|
.then(function () {
|
|
res.set('Content-Type', 'application/x-bittorrent');
|
|
res.set('Content-Disposition', 'attachment; filename=' + config.meanTorrentConfig.announce.announcePrefix + encodeURI(req.torrent.torrent_filename));
|
|
res.set('Content-Length', stat.size);
|
|
|
|
res.send(benc.encode(torrent_data));
|
|
})
|
|
.catch(function (err) {
|
|
mtDebug.debugRed(err);
|
|
res.status(422).send(err);
|
|
});
|
|
} else {
|
|
res.status(422).send({
|
|
message: 'FILE_DOES_NOT_EXISTS'
|
|
});
|
|
}
|
|
});
|
|
|
|
function getTorrentFileData(file) {
|
|
return new Promise(function (resolve, reject) {
|
|
nt.read(file, function (err, torrent) {
|
|
var message = '';
|
|
|
|
if (err) {
|
|
message = 'Read torrent file faild';
|
|
reject(message);
|
|
} else {
|
|
if (config.meanTorrentConfig.announce.privateTorrentCmsMode) {
|
|
var announce = config.meanTorrentConfig.announce.url + '/' + req.user.passkey;
|
|
torrent.metadata.announce = announce;
|
|
}
|
|
torrent_data = torrent.metadata;
|
|
resolve();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* create a torrent
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.create = function (req, res) {
|
|
var torrent = new Torrent(req.body);
|
|
mtDebug.debugGreen(req.body);
|
|
|
|
torrent.user = req.user;
|
|
|
|
//replace content path
|
|
var tmp = config.uploads.torrent.image.temp.substr(1);
|
|
var dst = config.uploads.torrent.image.dest.substr(1);
|
|
|
|
var regex = new RegExp(tmp, 'g');
|
|
torrent.resource_detail_info.overview = torrent.resource_detail_info.overview.replace(regex, dst);
|
|
|
|
mtDebug.debugGreen(torrent);
|
|
|
|
//move temp torrent file to dest directory
|
|
var oldPath = config.uploads.torrent.file.temp + req.body.torrent_filename;
|
|
var newPath = config.uploads.torrent.file.dest + req.body.torrent_filename;
|
|
move(oldPath, newPath, function (err) {
|
|
if (err) {
|
|
return res.status(422).send({
|
|
message: 'MOVE_TORRENT_FILE_ERROR'
|
|
});
|
|
} else {
|
|
//move temp cover image file to dest directory
|
|
var cv = req.body.resource_detail_info.cover;
|
|
var o = config.uploads.torrent.cover.temp + cv;
|
|
var n = config.uploads.torrent.cover.dest + cv;
|
|
move(o, n, function (err) {
|
|
if (err) {
|
|
mtDebug.debugRed(err);
|
|
}
|
|
});
|
|
//move temp torrent image file to dest directory
|
|
req.body._uImage.forEach(function (f) {
|
|
o = config.uploads.torrent.image.temp + f.filename;
|
|
n = config.uploads.torrent.image.dest + f.filename;
|
|
move(o, n, function (err) {
|
|
if (err) {
|
|
mtDebug.debugRed(err);
|
|
}
|
|
});
|
|
});
|
|
|
|
torrent.save(function (err) {
|
|
if (err) {
|
|
return res.status(422).send({
|
|
message: errorHandler.getErrorMessage(err)
|
|
});
|
|
} else {
|
|
res.json(torrent);
|
|
|
|
scoreUpdate(req, req.user, scoreConfig.action.uploadTorrent);
|
|
|
|
//update user uptotal fields
|
|
req.user.update({
|
|
$inc: {uptotal: 1}
|
|
}).exec();
|
|
|
|
//scrape torrent status info in public cms mode
|
|
if (!config.meanTorrentConfig.announce.privateTorrentCmsMode && config.meanTorrentConfig.scrapeTorrentStatus.onTorrentUpload) {
|
|
scrape.doScrape(torrent);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
function move(oldPath, newPath, callback) {
|
|
fs.rename(oldPath, newPath, function (err) {
|
|
if (err) {
|
|
if (err.code === 'EXDEV') {
|
|
copy();
|
|
} else {
|
|
callback(err);
|
|
}
|
|
return;
|
|
}
|
|
callback();
|
|
});
|
|
|
|
function copy() {
|
|
var readStream = fs.createReadStream(oldPath);
|
|
var writeStream = fs.createWriteStream(newPath);
|
|
|
|
readStream.on('error', callback);
|
|
writeStream.on('error', callback);
|
|
|
|
readStream.on('close', function () {
|
|
fs.unlink(oldPath, callback);
|
|
});
|
|
readStream.pipe(writeStream);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* read a torrent
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.read = function (req, res) {
|
|
// convert mongoose document to JSON
|
|
var torrent = req.torrent ? req.torrent.toJSON() : {};
|
|
|
|
// Add a custom field to the Article, for determining if the current User is the "owner".
|
|
// NOTE: This field is NOT persisted to the database, since it doesn't exist in the Article model.
|
|
torrent.isCurrentUserOwner = !!(req.user && torrent.user && torrent.user._id.toString() === req.user._id.toString());
|
|
|
|
res.json(torrent);
|
|
};
|
|
|
|
/**
|
|
* update a torrent
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.update = function (req, res) {
|
|
var torrent = req.torrent;
|
|
|
|
torrent.resource_detail_info = req.body.resource_detail_info;
|
|
|
|
torrent.save(function (err) {
|
|
if (err) {
|
|
return res.status(422).send({
|
|
message: errorHandler.getErrorMessage(err)
|
|
});
|
|
} else {
|
|
res.json(torrent);
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* scrape
|
|
* scrape torrent status info in public cms mode
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.scrape = function (req, res) {
|
|
if (!config.meanTorrentConfig.announce.privateTorrentCmsMode) {
|
|
scrape.doScrape(req.torrent, function (err, result) {
|
|
if (err) {
|
|
return res.status(422).send({
|
|
message: err
|
|
});
|
|
}
|
|
if (result && result.length === 1) {
|
|
res.json(result[0]);
|
|
}
|
|
});
|
|
} else {
|
|
return res.status(422).send({
|
|
message: 'privateTorrentCmsMode do not support scrape method'
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* toggleHnRStatus
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.toggleHnRStatus = function (req, res) {
|
|
var torrent = req.torrent;
|
|
|
|
torrent.torrent_hnr = !torrent.torrent_hnr;
|
|
|
|
torrent.save(function (err) {
|
|
if (err) {
|
|
return res.status(422).send({
|
|
message: errorHandler.getErrorMessage(err)
|
|
});
|
|
} else {
|
|
res.json(torrent);
|
|
|
|
//remove the complete data and update user`s warning number when the H&R prop to false
|
|
if (!torrent.torrent_hnr)
|
|
removeTorrentHnRWarning(torrent._id);
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* toggleVIPStatus
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.toggleVIPStatus = function (req, res) {
|
|
var torrent = req.torrent;
|
|
|
|
torrent.torrent_vip = !torrent.torrent_vip;
|
|
|
|
torrent.save(function (err) {
|
|
if (err) {
|
|
return res.status(422).send({
|
|
message: errorHandler.getErrorMessage(err)
|
|
});
|
|
} else {
|
|
res.json(torrent);
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* removeTorrentHnRWarning
|
|
* @param torrent
|
|
*/
|
|
function removeTorrentHnRWarning(tid) {
|
|
Complete.find({
|
|
torrent: tid
|
|
})
|
|
.populate('user')
|
|
.exec(function (err, cs) {
|
|
if (!err && cs) {
|
|
cs.forEach(function (c) {
|
|
if (c.hnr_warning) {
|
|
c.removeHnRWarning(c.user);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* thumbsUp
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.thumbsUp = function (req, res) {
|
|
var user = req.user;
|
|
var exist = false;
|
|
var torrent = req.torrent;
|
|
var thumb = new Thumb();
|
|
thumb.user = req.user;
|
|
thumb.score = thumbsUpScore.torrent;
|
|
|
|
//check if already exist
|
|
exist = false;
|
|
torrent._thumbs.forEach(function (sr) {
|
|
if (sr.user._id.equals(req.user._id)) {
|
|
exist = true;
|
|
}
|
|
});
|
|
if (exist) {
|
|
return res.status(422).send({
|
|
message: 'ALREADY_THUMBS_UP'
|
|
});
|
|
} else {
|
|
if (req.user.score >= thumbsUpScore.torrent) {
|
|
torrent._thumbs.push(thumb);
|
|
torrent.user.update({
|
|
$inc: {score: thumbsUpScore.torrent}
|
|
}).exec();
|
|
save();
|
|
} else {
|
|
return res.status(422).send({
|
|
message: 'SCORE_NOT_ENOUGH'
|
|
});
|
|
}
|
|
}
|
|
|
|
function save() {
|
|
torrent.save(function (err) {
|
|
if (err) {
|
|
return res.status(422).send({
|
|
message: errorHandler.getErrorMessage(err)
|
|
});
|
|
} else {
|
|
res.json(torrent);
|
|
}
|
|
});
|
|
|
|
user.update({
|
|
$inc: {score: -thumbsUpScore.torrent}
|
|
}).exec();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* setSaleType
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.setSaleType = function (req, res) {
|
|
var torrent = req.torrent;
|
|
|
|
if (req.params.saleType) {
|
|
var gbit = Math.ceil(torrent.torrent_size / config.meanTorrentConfig.torrentSalesType.expires.size);
|
|
torrent.torrent_sale_status = req.params.saleType;
|
|
torrent.torrent_sale_expires = Date.now() + gbit * config.meanTorrentConfig.torrentSalesType.expires.time;
|
|
|
|
torrent.save(function (err) {
|
|
if (err) {
|
|
return res.status(422).send({
|
|
message: errorHandler.getErrorMessage(err)
|
|
});
|
|
} else {
|
|
res.json(torrent);
|
|
|
|
//create trace log
|
|
traceLogCreate(req, traceConfig.action.AdminTorrentSetSaleType, {
|
|
torrent: torrent._id,
|
|
sale_status: req.params.saleType
|
|
});
|
|
}
|
|
});
|
|
} else {
|
|
return res.status(422).send({
|
|
message: 'params saleType error'
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* setRecommendLevel
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.setRecommendLevel = function (req, res) {
|
|
var torrent = req.torrent;
|
|
|
|
if (req.params.rlevel) {
|
|
torrent.torrent_recommended = req.params.rlevel;
|
|
torrent.orderedat = Date.now();
|
|
|
|
torrent.save(function (err) {
|
|
if (err) {
|
|
return res.status(422).send({
|
|
message: errorHandler.getErrorMessage(err)
|
|
});
|
|
} else {
|
|
res.json(torrent);
|
|
|
|
scoreUpdate(req, torrent.user, scoreConfig.action.uploadTorrentBeRecommend);
|
|
//create trace log
|
|
traceLogCreate(req, traceConfig.action.AdminTorrentSetRecommendLevel, {
|
|
torrent: torrent._id,
|
|
recommended: req.params.rlevel
|
|
});
|
|
}
|
|
});
|
|
} else {
|
|
return res.status(422).send({
|
|
message: 'params rlevel error'
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* setReviewedStatus
|
|
* @param req
|
|
* @param res
|
|
* @returns {*}
|
|
*/
|
|
exports.setReviewedStatus = function (req, res) {
|
|
var torrent = req.torrent;
|
|
|
|
torrent.torrent_status = 'reviewed';
|
|
|
|
torrent.save(function (err) {
|
|
if (err) {
|
|
return res.status(422).send({
|
|
message: errorHandler.getErrorMessage(err)
|
|
});
|
|
} else {
|
|
res.json(torrent);
|
|
|
|
//irc announce
|
|
if (ircConfig.enable) {
|
|
var msg = '';
|
|
var client = req.app.get('ircClient');
|
|
|
|
if (torrent.torrent_type === 'tvserial') {
|
|
msg = vsprintf(ircConfig.tvserialMsgFormat, [
|
|
torrent.user.displayName,
|
|
torrent.torrent_filename,
|
|
torrent.torrent_type,
|
|
torrent.torrent_size,
|
|
torrent.torrent_seasons,
|
|
torrent.torrent_episodes,
|
|
torrent.torrent_sale_status,
|
|
moment().format('YYYY-MM-DD HH:mm:ss')
|
|
]);
|
|
} else {
|
|
msg = vsprintf(ircConfig.defaultMsgFormat, [
|
|
torrent.user.displayName,
|
|
torrent.torrent_filename,
|
|
torrent.torrent_type,
|
|
torrent.torrent_size,
|
|
torrent.torrent_sale_status,
|
|
moment().format('YYYY-MM-DD HH:mm:ss')
|
|
]);
|
|
}
|
|
client.notice(ircConfig.channel, msg);
|
|
}
|
|
|
|
//create trace log
|
|
traceLogCreate(req, traceConfig.action.AdminTorrentSetReviewedStatus, {
|
|
torrent: torrent._id,
|
|
status: 'reviewed'
|
|
});
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* delete a torrent
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.delete = function (req, res) {
|
|
var torrent = req.torrent;
|
|
|
|
//DELETE the torrent file
|
|
var tfile = config.uploads.torrent.file.dest + req.torrent.torrent_filename;
|
|
fs.unlinkSync(tfile);
|
|
|
|
//update users seed/leech number
|
|
Peer.find({
|
|
torrent: torrent._id
|
|
})
|
|
.populate('user')
|
|
.exec(function (err, ps) {
|
|
ps.forEach(function (p) {
|
|
if (p.user && p.peer_status === PEERSTATE_SEEDER) {
|
|
p.user.update({
|
|
$inc: {seeded: -1}
|
|
}).exec();
|
|
}
|
|
if (p.user && p.peer_status === PEERSTATE_LEECHER) {
|
|
p.user.update({
|
|
$inc: {leeched: -1}
|
|
}).exec();
|
|
}
|
|
});
|
|
});
|
|
|
|
//remove all peers of the torrent
|
|
Peer.remove({
|
|
torrent: torrent._id
|
|
});
|
|
//remove all subtitle of the torrent
|
|
Subtitle.remove({
|
|
torrent: torrent._id
|
|
});
|
|
|
|
//update user uptotal fields
|
|
torrent.user.update({
|
|
$inc: {uptotal: -1}
|
|
}).exec();
|
|
|
|
//remove the complete data and update user`s warning number if the torrent has H&R prop
|
|
removeTorrentHnRWarning(torrent._id);
|
|
Complete.remove({
|
|
torrent: torrent._id
|
|
});
|
|
|
|
torrent.remove(function (err) {
|
|
if (err) {
|
|
return res.status(422).send({
|
|
message: errorHandler.getErrorMessage(err)
|
|
});
|
|
} else {
|
|
res.json(torrent);
|
|
|
|
scoreUpdate(req, torrent.user, scoreConfig.action.uploadTorrentBeDeleted);
|
|
//create trace log
|
|
traceLogCreate(req, traceConfig.action.AdminTorrentDelete, {
|
|
torrent: torrent._id
|
|
});
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* list all torrents
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.list = function (req, res) {
|
|
var skip = 0;
|
|
var limit = 0;
|
|
var status = 'reviewed';
|
|
var rlevel = 'none';
|
|
var stype = 'movie';
|
|
var newest = false;
|
|
var hnr = false;
|
|
var vip = undefined;
|
|
var release = undefined;
|
|
var userid = undefined;
|
|
var tagsA = [];
|
|
var keysA = [];
|
|
|
|
var sort = 'torrent_recommended -orderedat -createdat';
|
|
|
|
if (req.query.skip !== undefined) {
|
|
skip = parseInt(req.query.skip, 10);
|
|
}
|
|
if (req.query.limit !== undefined) {
|
|
limit = parseInt(req.query.limit, 10);
|
|
}
|
|
if (req.query.torrent_status !== undefined) {
|
|
status = req.query.torrent_status;
|
|
}
|
|
if (req.query.torrent_rlevel !== undefined) {
|
|
rlevel = req.query.torrent_rlevel;
|
|
}
|
|
if (req.query.torrent_type !== undefined) {
|
|
stype = req.query.torrent_type;
|
|
}
|
|
if (req.query.torrent_release !== undefined) {
|
|
release = req.query.torrent_release;
|
|
}
|
|
if (req.query.torrent_hnr !== undefined) {
|
|
hnr = req.query.torrent_hnr;
|
|
}
|
|
if (req.query.torrent_vip !== undefined) {
|
|
vip = req.query.torrent_vip;
|
|
}
|
|
if (req.query.newest !== undefined) {
|
|
newest = (req.query.newest === 'true');
|
|
}
|
|
if (req.query.userid !== undefined) {
|
|
userid = req.query.userid;
|
|
}
|
|
|
|
if (req.query.torrent_tags !== undefined) {
|
|
var tagsS = req.query.torrent_tags + '';
|
|
var tagsT = tagsS.split(',');
|
|
|
|
tagsT.forEach(function (it) {
|
|
tagsA.push(it + '');
|
|
});
|
|
}
|
|
if (req.query.keys !== undefined && req.query.keys.length > 0) {
|
|
var keysS = req.query.keys + '';
|
|
var keysT = keysS.split(' ');
|
|
|
|
keysT.forEach(function (it) {
|
|
if (!isNaN(it)) {
|
|
if (it > 1900 && it < 2050) {
|
|
release = it;
|
|
}
|
|
} else {
|
|
var ti = new RegExp(it, 'i');
|
|
keysA.push(ti);
|
|
}
|
|
});
|
|
}
|
|
|
|
var condition = {};
|
|
if (status !== 'all') {
|
|
condition.torrent_status = status;
|
|
}
|
|
if (rlevel !== 'none') {
|
|
condition.torrent_recommended = rlevel;
|
|
}
|
|
if (stype !== 'all') {
|
|
condition.torrent_type = stype;
|
|
}
|
|
if (hnr === 'true') {
|
|
condition.torrent_hnr = hnr;
|
|
}
|
|
if (vip === 'true') {
|
|
condition.torrent_vip = true;
|
|
} else if (vip === undefined) {
|
|
condition.torrent_vip = false;
|
|
}
|
|
|
|
if (tagsA.length > 0) {
|
|
condition.torrent_tags = {$all: tagsA};
|
|
}
|
|
if (release !== undefined) {
|
|
condition['resource_detail_info.release_date'] = release;
|
|
}
|
|
if (keysA.length > 0) {
|
|
condition.$or = [
|
|
{torrent_filename: {'$all': keysA}},
|
|
{'resource_detail_info.title': {'$all': keysA}},
|
|
{'resource_detail_info.original_title': {'$all': keysA}}
|
|
];
|
|
}
|
|
if (userid !== undefined) {
|
|
condition.user = userid;
|
|
}
|
|
|
|
mtDebug.debugGreen(JSON.stringify(condition));
|
|
|
|
if (newest) {
|
|
sort = '-createdat';
|
|
}
|
|
|
|
var countQuery = function (callback) {
|
|
Torrent.count(condition, function (err, count) {
|
|
if (err) {
|
|
callback(err, null);
|
|
} else {
|
|
callback(null, count);
|
|
}
|
|
});
|
|
};
|
|
|
|
var findQuery = function (callback) {
|
|
Torrent.find(condition)
|
|
.sort(sort)
|
|
.populate('user', 'username displayName isVip')
|
|
.skip(skip)
|
|
.limit(limit)
|
|
.exec(function (err, torrents) {
|
|
if (err) {
|
|
callback(err, null);
|
|
} else {
|
|
callback(null, torrents);
|
|
}
|
|
});
|
|
};
|
|
|
|
async.parallel([countQuery, findQuery], function (err, results) {
|
|
if (err) {
|
|
return res.status(422).send(err);
|
|
} else {
|
|
res.json({rows: results[1], total: results[0]});
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* siteInfo - get site torrent info, seeders/leechers/torrents count/users etc.
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.siteInfo = function (req, res) {
|
|
var countUsers = function (callback) {
|
|
User.count(function (err, count) {
|
|
if (err) {
|
|
callback(err, null);
|
|
} else {
|
|
callback(null, count);
|
|
}
|
|
});
|
|
};
|
|
|
|
var countTorrents = function (callback) {
|
|
Torrent.count(function (err, count) {
|
|
if (err) {
|
|
callback(err, null);
|
|
} else {
|
|
callback(null, count);
|
|
}
|
|
});
|
|
};
|
|
|
|
var totalUpDown = function (callback) {
|
|
User.aggregate({
|
|
$group: {
|
|
_id: null,
|
|
uploaded: {$sum: '$uploaded'},
|
|
downloaded: {$sum: '$downloaded'}
|
|
}
|
|
}).exec(function (err, total) {
|
|
if (err) {
|
|
callback(err, null);
|
|
} else {
|
|
callback(null, total);
|
|
}
|
|
});
|
|
};
|
|
|
|
var totalTorrentsSize = function (callback) {
|
|
Torrent.aggregate({
|
|
$group: {
|
|
_id: null,
|
|
size: {$sum: '$torrent_size'},
|
|
seeders: {$sum: '$torrent_seeds'},
|
|
leechers: {$sum: '$torrent_leechers'}
|
|
}
|
|
}).exec(function (err, total) {
|
|
if (err) {
|
|
callback(err, null);
|
|
} else {
|
|
callback(null, total);
|
|
}
|
|
});
|
|
};
|
|
|
|
var countForumTopics = function (callback) {
|
|
Topic.count(function (err, count) {
|
|
if (err) {
|
|
callback(err, null);
|
|
} else {
|
|
callback(null, count);
|
|
}
|
|
});
|
|
};
|
|
|
|
var totalForumReplies = function (callback) {
|
|
Topic.aggregate({
|
|
$group: {
|
|
_id: null,
|
|
replies: {$sum: '$replyCount'}
|
|
}
|
|
}).exec(function (err, total) {
|
|
if (err) {
|
|
callback(err, null);
|
|
} else {
|
|
callback(null, total);
|
|
}
|
|
});
|
|
};
|
|
|
|
async.parallel([countUsers, countTorrents, totalTorrentsSize, totalUpDown, countForumTopics, totalForumReplies], function (err, results) {
|
|
if (err) {
|
|
return res.status(422).send(err);
|
|
} else {
|
|
res.json({
|
|
totalUsers: results[0],
|
|
totalTorrents: results[1],
|
|
totalTorrentsSize: results[2][0].size,
|
|
totalSeeders: results[2][0].seeders,
|
|
totalLeechers: results[2][0].leechers,
|
|
totalUploaded: results[3][0].uploaded,
|
|
totalDownloaded: results[3][0].downloaded,
|
|
totalForumTopics: results[4],
|
|
totalForumReplies: results[5][0].replies
|
|
});
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Torrent middleware
|
|
*/
|
|
exports.torrentByID = function (req, res, next, id) {
|
|
|
|
if (!mongoose.Types.ObjectId.isValid(id)) {
|
|
return res.status(400).send({
|
|
message: 'TORRENT_ID_INVALID'
|
|
});
|
|
}
|
|
|
|
var findTorrents = function (callback) {
|
|
Torrent.findById(id)
|
|
.populate('user', 'username displayName profileImageURL isVip')
|
|
.populate('_thumbs.user', 'username displayName profileImageURL isVip uploaded downloaded')
|
|
.populate({
|
|
path: '_replies.user',
|
|
select: 'username displayName profileImageURL isVip uploaded downloaded',
|
|
model: 'User'
|
|
})
|
|
.populate({
|
|
path: '_replies._replies.user',
|
|
select: 'username displayName profileImageURL isVip uploaded downloaded',
|
|
model: 'User'
|
|
})
|
|
.populate({
|
|
path: '_subtitles',
|
|
populate: {
|
|
path: 'user',
|
|
select: 'username displayName profileImageURL isVip'
|
|
}
|
|
})
|
|
.populate({
|
|
path: '_peers',
|
|
populate: {
|
|
path: 'user',
|
|
select: 'username displayName profileImageURL isVip'
|
|
}
|
|
})
|
|
.exec(function (err, torrent) {
|
|
if (err) {
|
|
callback(err);
|
|
} else if (!torrent) {
|
|
callback(new Error('No torrent with that id has been found'));
|
|
}
|
|
callback(null, torrent);
|
|
});
|
|
};
|
|
|
|
var findOtherTorrents = function (torrent, callback) {
|
|
if (torrent.resource_detail_info.id) {
|
|
var condition = {
|
|
torrent_status: 'reviewed',
|
|
'resource_detail_info.id': torrent.resource_detail_info.id
|
|
};
|
|
|
|
mtDebug.debugGreen(condition);
|
|
|
|
var fields = 'user torrent_filename torrent_tags torrent_seeds torrent_leechers torrent_finished torrent_seasons torrent_episodes torrent_size torrent_sale_status torrent_type torrent_hnr torrent_vip torrent_sale_expires createdat';
|
|
|
|
Torrent.find(condition, fields)
|
|
.sort('-createdat')
|
|
.populate('user', 'username displayName isVip')
|
|
.exec(function (err, torrents) {
|
|
if (err) {
|
|
callback(err);
|
|
} else {
|
|
torrent._other_torrents.splice(0, torrent._other_torrents.length);
|
|
torrents.forEach(function (t) {
|
|
if (!t._id.equals(torrent._id)) {
|
|
torrent._other_torrents.push(t.toJSON());
|
|
}
|
|
});
|
|
callback(null, torrent);
|
|
}
|
|
});
|
|
} else {
|
|
callback(null, torrent);
|
|
}
|
|
};
|
|
|
|
async.waterfall([findTorrents, findOtherTorrents], function (err, torrent) {
|
|
if (err) {
|
|
next(err);
|
|
} else {
|
|
req.torrent = torrent;
|
|
next();
|
|
}
|
|
});
|
|
};
|