Finished basic upload handling code

Author: pendo324

api/upload.js

@@ -4,24 +4,28 @@ const bencode = require('bencode');
 const crypto = require('crypto');
 const db = require('./../db.js');
 const fs = require('fs');
+const _ = require('lodash');
 
 const app = express.Router();
 
 const util = require('util');
 
-/*const storage = multer.diskStorage({
-  destination: (req, file, cb) => {
-    const now = new Date();
-    const month = now.getMonth() + 1;
-    const year = now.getFullYear();
-    console.log(util.inspect(file));
-
-    cb(null, `${process.env.TORRENT_DIR}${year}/${month}/`);
+const verificationTypes = {
+  group: {
+    album: {
+      required: ['artist', 'album', 'original_release_year'],
+      allowed: ['artist', 'album', 'original_release_year'],
+      errorMessage: 'Album group is missing information.'
+    }
   },
-  filename: (req, file, cb) => {
-    cb(null, `${file.hash}.torrent`);
+  release: {
+    album: {
+      required: ['release_type', 'format', 'bitrate', 'media'],
+      allowed: ['release_type', 'format', 'bitrate', 'media'],
+      errorMessage: 'Album is missing information.'
+    }
   }
-});*/
+};
 
 const saveToDisk = torrent => {
   const now = new Date();
@@ -44,10 +48,22 @@ const storage = multer.memoryStorage();
 
 const upload = multer({ storage });
 
-const stripTrackers = torrentBuffer => {
-  const torrent = bencode.decode(torrentBuffer);
-  delete torrent['announce'];
-  return bencode.encode(torrent);
+const processTorrent = torrent => {
+  const decodedTorrent = bencode.decode(torrent.buffer);
+  const processedTorrent = _.cloneDeep(torrent);
+
+  delete decodedTorrent['announce'];
+
+  processedTorrent.fileList = [];
+  processedTorrent.totalFileSize = decodedTorrent.info.files.reduce((total, file) => {
+    processedTorrent.fileList.push({ fileName: file.path, fileSize: file.length });
+    return total += file.length;
+  }, 0);
+
+  processedTorrent.buffer = bencode.encode(decodedTorrent);
+  processedTorrent.hash = hashTorrent(processedTorrent.buffer);
+
+  return Promise.resolve(processedTorrent);
 };
 
 const hashTorrent = torrentBuffer => {
@@ -57,28 +73,28 @@ const hashTorrent = torrentBuffer => {
   return hash.digest('hex');
 };
 
-const verifyAlbum = group => {
-  const requiredFields = ['artist', 'album', 'year', 'release_type', 'format', 'bitrate', 'media'];
-  const allowedFields = ['artist', 'album', 'year', 'release_type', 'format', 'bitrate', 'media'];
+const verify = (input, type) => {
+  const required = type.required;
+  const allowed = type.allowed;
+  const errMsg = type.errorMessage || 'Missing required fields.';
 
-  const verifiedGroup = new Map();
-
-  Object.entries(group).forEach(entry => {
+  const verified = new Map();
+  Object.entries(input).forEach(entry => {
     let key = entry[0];
     let value = entry[1];
 
-    if (allowedFields.includes(key)) {
-      verifiedGroup.set(key, value);
+    if (allowed.includes(key)) {
+      verified.set(key, value);
     }
   });
 
-  requiredFields.forEach(field => {
-    if (!verifiedGroup.has(field)) {
-      return Promise.reject(new Error('Missing required fields.'));
+  required.forEach(field => {
+    if (!verified.has(field)) {
+      return Promise.reject(new Error(errMsg));
     }
-  })
+  });
 
-  return Promise.resolve(verifiedGroup);
+  return Promise.resolve(verified);
 };
 
 const upTo = to => {
@@ -89,46 +105,56 @@ const upTo = to => {
   return upToArray.toString();
 };
 
-const createGroup = group => {
-  return verifyAlbum(group).then(verifiedGroup => {
+const getGroup = group => {
+  if (typeof (group) === 'number') return Promise.resolve(group);
+  return verify(group, verificationTypes.group.album).then(verifiedGroup => {
     const keys = verifiedGroup.keys();
     const values = verifiedGroup.values();
     const length = verifiedGroup.size;
 
-    return db.query(`insert into tracker.groups (${keys.toString()}) values (${upTo(length)}) return id`, values);
+    return db.query(`insert into tracker.groups (${[...keys].toString()}) values (${upTo(length)}) returning id`, [...values])
+      .then(result => {
+        group = result.rows[0].id;
+        return group;
+      });
   });
 };
 
-const store = (torrent, group) => {
-  return db.query('insert into tracker.torrents (hash, path, group) values ($1, $2, $3)', [torrent.hash, torrent.path, group]);
+const store = (torrent, group, releaseInfo) => {
+  return verify(releaseInfo, verificationTypes.release.album).then(verifiedRelease => {
+    // Add more information to the verified user input
+    verifiedRelease.set('group_id', group);
+    verifiedRelease.set('file_size', torrent.totalFileSize);
+    verifiedRelease.set('original_file_name', torrent.originalname);
+    verifiedRelease.set('file_path', torrent.path);
+    verifiedRelease.set('files', JSON.stringify(torrent.fileList));
+
+    const keys = verifiedRelease.keys();
+    const values = verifiedRelease.values();
+    const length = verifiedRelease.size;
+
+    return db.query(`insert into tracker.torrents (${[...keys].toString()}) values (${upTo(length)}) returning id, group_id`, [...values]);
+  })
 };
 
 const torrentUpload = upload.fields([{ name: 'torrent', maxCount: 1 }]);
 
 app.post('/upload', torrentUpload, (req, res) => {
-  //app.post('/upload', upload.single('torrent'), (req, res) => {
-  const torrent = stripTrackers(req.files.torrent[0].buffer);
+  const torrent = req.files.torrent[0];
   const group = JSON.parse(req.body.group);
-
-  torrent.hash = hashTorrent(torrent.buffer);
-  
-  saveToDisk(torrent).then(torrent => {
-    if (typeof (group) !== 'Number') {
-      return createGroup(group).then(result => {
-        group = result.rows[0].id;
-        return group
-      }).then(group => {
-        return store(torrent, group).then(result => {
-          const torrentId = result.rows[0].id;
-          if (torrentId) {
-            res.send(200, { id: torrentId });
-          }
-        });
-      })
-    }
+  const releaseInfo = JSON.parse(req.body.info);
+
+  processTorrent(torrent).then(saveToDisk).then(torrent => {
+    return getGroup(group).then(group => {
+      return store(torrent, group, releaseInfo).then(result => {
+        const torrentId = result.rows[0].id;
+        if (torrentId) {
+          res.send(200, { id: result.rows[0].group_id });
+        }
+      });
+    });
   }).catch(err => {
     console.log(err);
-    res.sendStatus(500);
   });
 });