refactor: moved server content to /server

server/controllers/admin.js

@@ -0,0 +1,250 @@
+'use strict'
+
+var express = require('express')
+var router = express.Router()
+const Promise = require('bluebird')
+const validator = require('validator')
+const _ = require('lodash')
+const axios = require('axios')
+const path = require('path')
+const fs = Promise.promisifyAll(require('fs-extra'))
+
+/**
+ * Admin
+ */
+router.get('/', (req, res) => {
+  res.redirect('/admin/profile')
+})
+
+router.get('/profile', (req, res) => {
+  if (res.locals.isGuest) {
+    return res.render('error-forbidden')
+  }
+
+  res.render('pages/admin/profile', { adminTab: 'profile' })
+})
+
+router.post('/profile', (req, res) => {
+  if (res.locals.isGuest) {
+    return res.render('error-forbidden')
+  }
+
+  return db.User.findById(req.user.id).then((usr) => {
+    usr.name = _.trim(req.body.name)
+    if (usr.provider === 'local' && req.body.password !== '********') {
+      let nPwd = _.trim(req.body.password)
+      if (nPwd.length < 6) {
+        return Promise.reject(new Error('New Password too short!'))
+      } else {
+        return db.User.hashPassword(nPwd).then((pwd) => {
+          usr.password = pwd
+          return usr.save()
+        })
+      }
+    } else {
+      return usr.save()
+    }
+  }).then(() => {
+    return res.json({ msg: 'OK' })
+  }).catch((err) => {
+    res.status(400).json({ msg: err.message })
+  })
+})
+
+router.get('/stats', (req, res) => {
+  if (res.locals.isGuest) {
+    return res.render('error-forbidden')
+  }
+
+  Promise.all([
+    db.Entry.count(),
+    db.UplFile.count(),
+    db.User.count()
+  ]).spread((totalEntries, totalUploads, totalUsers) => {
+    return res.render('pages/admin/stats', {
+      totalEntries, totalUploads, totalUsers, adminTab: 'stats'
+    }) || true
+  }).catch((err) => {
+    throw err
+  })
+})
+
+router.get('/users', (req, res) => {
+  if (!res.locals.rights.manage) {
+    return res.render('error-forbidden')
+  }
+
+  db.User.find({})
+    .select('-password -rights')
+    .sort('name email')
+    .exec().then((usrs) => {
+      res.render('pages/admin/users', { adminTab: 'users', usrs })
+    })
+})
+
+router.get('/users/:id', (req, res) => {
+  if (!res.locals.rights.manage) {
+    return res.render('error-forbidden')
+  }
+
+  if (!validator.isMongoId(req.params.id)) {
+    return res.render('error-forbidden')
+  }
+
+  db.User.findById(req.params.id)
+    .select('-password -providerId')
+    .exec().then((usr) => {
+      let usrOpts = {
+        canChangeEmail: (usr.email !== 'guest' && usr.provider === 'local' && usr.email !== req.app.locals.appconfig.admin),
+        canChangeName: (usr.email !== 'guest'),
+        canChangePassword: (usr.email !== 'guest' && usr.provider === 'local'),
+        canChangeRole: (usr.email !== 'guest' && !(usr.provider === 'local' && usr.email === req.app.locals.appconfig.admin)),
+        canBeDeleted: (usr.email !== 'guest' && !(usr.provider === 'local' && usr.email === req.app.locals.appconfig.admin))
+      }
+
+      res.render('pages/admin/users-edit', { adminTab: 'users', usr, usrOpts })
+    })
+})
+
+/**
+ * Create / Authorize a new user
+ */
+router.post('/users/create', (req, res) => {
+  if (!res.locals.rights.manage) {
+    return res.status(401).json({ msg: 'Unauthorized' })
+  }
+
+  let nUsr = {
+    email: _.toLower(_.trim(req.body.email)),
+    provider: _.trim(req.body.provider),
+    password: req.body.password,
+    name: _.trim(req.body.name)
+  }
+
+  if (!validator.isEmail(nUsr.email)) {
+    return res.status(400).json({ msg: 'Invalid email address' })
+  } else if (!validator.isIn(nUsr.provider, ['local', 'google', 'windowslive', 'facebook', 'github', 'slack'])) {
+    return res.status(400).json({ msg: 'Invalid provider' })
+  } else if (nUsr.provider === 'local' && !validator.isLength(nUsr.password, { min: 6 })) {
+    return res.status(400).json({ msg: 'Password too short or missing' })
+  } else if (nUsr.provider === 'local' && !validator.isLength(nUsr.name, { min: 2 })) {
+    return res.status(400).json({ msg: 'Name is missing' })
+  }
+
+  db.User.findOne({ email: nUsr.email, provider: nUsr.provider }).then(exUsr => {
+    if (exUsr) {
+      return res.status(400).json({ msg: 'User already exists!' }) || true
+    }
+
+    let pwdGen = (nUsr.provider === 'local') ? db.User.hashPassword(nUsr.password) : Promise.resolve(true)
+    return pwdGen.then(nPwd => {
+      if (nUsr.provider !== 'local') {
+        nUsr.password = ''
+        nUsr.name = '-- pending --'
+      } else {
+        nUsr.password = nPwd
+      }
+
+      nUsr.rights = [{
+        role: 'read',
+        path: '/',
+        exact: false,
+        deny: false
+      }]
+
+      return db.User.create(nUsr).then(() => {
+        return res.json({ ok: true })
+      })
+    }).catch(err => {
+      winston.warn(err)
+      return res.status(500).json({ msg: err })
+    })
+  }).catch(err => {
+    winston.warn(err)
+    return res.status(500).json({ msg: err })
+  })
+})
+
+router.post('/users/:id', (req, res) => {
+  if (!res.locals.rights.manage) {
+    return res.status(401).json({ msg: 'Unauthorized' })
+  }
+
+  if (!validator.isMongoId(req.params.id)) {
+    return res.status(400).json({ msg: 'Invalid User ID' })
+  }
+
+  return db.User.findById(req.params.id).then((usr) => {
+    usr.name = _.trim(req.body.name)
+    usr.rights = JSON.parse(req.body.rights)
+    if (usr.provider === 'local' && req.body.password !== '********') {
+      let nPwd = _.trim(req.body.password)
+      if (nPwd.length < 6) {
+        return Promise.reject(new Error('New Password too short!'))
+      } else {
+        return db.User.hashPassword(nPwd).then((pwd) => {
+          usr.password = pwd
+          return usr.save()
+        })
+      }
+    } else {
+      return usr.save()
+    }
+  }).then(() => {
+    return res.json({ msg: 'OK' })
+  }).catch((err) => {
+    res.status(400).json({ msg: err.message })
+  })
+})
+
+/**
+ * Delete / Deauthorize a user
+ */
+router.delete('/users/:id', (req, res) => {
+  if (!res.locals.rights.manage) {
+    return res.status(401).json({ msg: 'Unauthorized' })
+  }
+
+  if (!validator.isMongoId(req.params.id)) {
+    return res.status(400).json({ msg: 'Invalid User ID' })
+  }
+
+  return db.User.findByIdAndRemove(req.params.id).then(() => {
+    return res.json({ msg: 'OK' })
+  }).catch((err) => {
+    res.status(500).json({ msg: err.message })
+  })
+})
+
+router.get('/settings', (req, res) => {
+  if (!res.locals.rights.manage) {
+    return res.render('error-forbidden')
+  }
+
+  fs.readJsonAsync(path.join(ROOTPATH, 'package.json')).then(packageObj => {
+    axios.get('https://api.github.com/repos/Requarks/wiki/releases/latest').then(resp => {
+      let sysversion = {
+        current: 'v' + packageObj.version,
+        latest: resp.data.tag_name,
+        latestPublishedAt: resp.data.published_at
+      }
+
+      res.render('pages/admin/settings', { adminTab: 'settings', sysversion })
+    }).catch(err => {
+      winston.warn(err)
+      res.render('pages/admin/settings', { adminTab: 'settings', sysversion: { current: 'v' + packageObj.version } })
+    })
+  })
+})
+
+router.post('/settings/install', (req, res) => {
+  if (!res.locals.rights.manage) {
+    return res.render('error-forbidden')
+  }
+
+  // let sysLib = require(path.join(ROOTPATH, 'libs/system.js'))
+  // sysLib.install('v1.0-beta.7')
+  res.status(400).send('Sorry, Upgrade/Re-Install via the web UI is not yet ready. You must use the npm upgrade method in the meantime.').end()
+})
+
+module.exports = router

server/controllers/auth.js

@@ -0,0 +1,114 @@
+'use strict'
+
+const Promise = require('bluebird')
+const express = require('express')
+const router = express.Router()
+const passport = require('passport')
+const ExpressBrute = require('express-brute')
+const ExpressBruteMongooseStore = require('express-brute-mongoose')
+const moment = require('moment')
+
+/**
+ * Setup Express-Brute
+ */
+const EBstore = new ExpressBruteMongooseStore(db.Bruteforce)
+const bruteforce = new ExpressBrute(EBstore, {
+  freeRetries: 5,
+  minWait: 60 * 1000,
+  maxWait: 5 * 60 * 1000,
+  refreshTimeoutOnRequest: false,
+  failCallback (req, res, next, nextValidRequestDate) {
+    req.flash('alert', {
+      class: 'error',
+      title: 'Too many attempts!',
+      message: "You've made too many failed attempts in a short period of time, please try again " + moment(nextValidRequestDate).fromNow() + '.',
+      iconClass: 'fa-times'
+    })
+    res.redirect('/login')
+  }
+})
+
+/**
+ * Login form
+ */
+router.get('/login', function (req, res, next) {
+  res.render('auth/login', {
+    usr: res.locals.usr
+  })
+})
+
+router.post('/login', bruteforce.prevent, function (req, res, next) {
+  new Promise((resolve, reject) => {
+    // [1] LOCAL AUTHENTICATION
+    passport.authenticate('local', function (err, user, info) {
+      if (err) { return reject(err) }
+      if (!user) { return reject(new Error('INVALID_LOGIN')) }
+      resolve(user)
+    })(req, res, next)
+  }).catch({ message: 'INVALID_LOGIN' }, err => {
+    if (appconfig.auth.ldap && appconfig.auth.ldap.enabled) {
+      // [2] LDAP AUTHENTICATION
+      return new Promise((resolve, reject) => {
+        passport.authenticate('ldapauth', function (err, user, info) {
+          if (err) { return reject(err) }
+          if (info && info.message) { return reject(new Error(info.message)) }
+          if (!user) { return reject(new Error('INVALID_LOGIN')) }
+          resolve(user)
+        })(req, res, next)
+      })
+    } else {
+      throw err
+    }
+  }).then((user) => {
+    // LOGIN SUCCESS
+    return req.logIn(user, function (err) {
+      if (err) { return next(err) }
+      req.brute.reset(function () {
+        return res.redirect('/')
+      })
+    }) || true
+  }).catch(err => {
+    // LOGIN FAIL
+    if (err.message === 'INVALID_LOGIN') {
+      req.flash('alert', {
+        title: 'Invalid login',
+        message: 'The email or password is invalid.'
+      })
+      return res.redirect('/login')
+    } else {
+      req.flash('alert', {
+        title: 'Login error',
+        message: err.message
+      })
+      return res.redirect('/login')
+    }
+  })
+})
+
+/**
+ * Social Login
+ */
+
+router.get('/login/ms', passport.authenticate('windowslive', { scope: ['wl.signin', 'wl.basic', 'wl.emails'] }))
+router.get('/login/google', passport.authenticate('google', { scope: ['profile', 'email'] }))
+router.get('/login/facebook', passport.authenticate('facebook', { scope: ['public_profile', 'email'] }))
+router.get('/login/github', passport.authenticate('github', { scope: ['user:email'] }))
+router.get('/login/slack', passport.authenticate('slack', { scope: ['identity.basic', 'identity.email'] }))
+router.get('/login/azure', passport.authenticate('azure_ad_oauth2'))
+
+router.get('/login/ms/callback', passport.authenticate('windowslive', { failureRedirect: '/login', successRedirect: '/' }))
+router.get('/login/google/callback', passport.authenticate('google', { failureRedirect: '/login', successRedirect: '/' }))
+router.get('/login/facebook/callback', passport.authenticate('facebook', { failureRedirect: '/login', successRedirect: '/' }))
+router.get('/login/github/callback', passport.authenticate('github', { failureRedirect: '/login', successRedirect: '/' }))
+router.get('/login/slack/callback', passport.authenticate('slack', { failureRedirect: '/login', successRedirect: '/' }))
+router.get('/login/azure/callback', passport.authenticate('azure_ad_oauth2', { failureRedirect: '/login', successRedirect: '/' }))
+
+/**
+ * Logout
+ */
+router.get('/logout', function (req, res) {
+  req.logout()
+  res.redirect('/')
+})
+
+module.exports = router

server/controllers/pages.js

@@ -0,0 +1,247 @@
+'use strict'
+
+const express = require('express')
+const router = express.Router()
+const _ = require('lodash')
+
+// ==========================================
+// EDIT MODE
+// ==========================================
+
+/**
+ * Edit document in Markdown
+ */
+router.get('/edit/*', (req, res, next) => {
+  if (!res.locals.rights.write) {
+    return res.render('error-forbidden')
+  }
+
+  let safePath = entries.parsePath(_.replace(req.path, '/edit', ''))
+
+  entries.fetchOriginal(safePath, {
+    parseMarkdown: false,
+    parseMeta: true,
+    parseTree: false,
+    includeMarkdown: true,
+    includeParentInfo: false,
+    cache: false
+  }).then((pageData) => {
+    if (pageData) {
+      res.render('pages/edit', { pageData })
+    } else {
+      throw new Error('Invalid page path.')
+    }
+    return true
+  }).catch((err) => {
+    res.render('error', {
+      message: err.message,
+      error: {}
+    })
+  })
+})
+
+router.put('/edit/*', (req, res, next) => {
+  if (!res.locals.rights.write) {
+    return res.json({
+      ok: false,
+      error: 'Forbidden'
+    })
+  }
+
+  let safePath = entries.parsePath(_.replace(req.path, '/edit', ''))
+
+  entries.update(safePath, req.body.markdown, req.user).then(() => {
+    return res.json({
+      ok: true
+    }) || true
+  }).catch((err) => {
+    res.json({
+      ok: false,
+      error: err.message
+    })
+  })
+})
+
+// ==========================================
+// CREATE MODE
+// ==========================================
+
+router.get('/create/*', (req, res, next) => {
+  if (!res.locals.rights.write) {
+    return res.render('error-forbidden')
+  }
+
+  if (_.some(['create', 'edit', 'account', 'source', 'history', 'mk', 'all'], (e) => { return _.startsWith(req.path, '/create/' + e) })) {
+    return res.render('error', {
+      message: 'You cannot create a document with this name as it is reserved by the system.',
+      error: {}
+    })
+  }
+
+  let safePath = entries.parsePath(_.replace(req.path, '/create', ''))
+
+  entries.exists(safePath).then((docExists) => {
+    if (!docExists) {
+      return entries.getStarter(safePath).then((contents) => {
+        let pageData = {
+          markdown: contents,
+          meta: {
+            title: _.startCase(safePath),
+            path: safePath
+          }
+        }
+        res.render('pages/create', { pageData })
+
+        return true
+      }).catch((err) => {
+        winston.warn(err)
+        throw new Error('Could not load starter content!')
+      })
+    } else {
+      throw new Error('This entry already exists!')
+    }
+  }).catch((err) => {
+    res.render('error', {
+      message: err.message,
+      error: {}
+    })
+  })
+})
+
+router.put('/create/*', (req, res, next) => {
+  if (!res.locals.rights.write) {
+    return res.json({
+      ok: false,
+      error: 'Forbidden'
+    })
+  }
+
+  let safePath = entries.parsePath(_.replace(req.path, '/create', ''))
+
+  entries.create(safePath, req.body.markdown, req.user).then(() => {
+    return res.json({
+      ok: true
+    }) || true
+  }).catch((err) => {
+    return res.json({
+      ok: false,
+      error: err.message
+    })
+  })
+})
+
+// ==========================================
+// LIST ALL PAGES
+// ==========================================
+
+/**
+ * View tree view of all pages
+ */
+router.use((req, res, next) => {
+  if (_.endsWith(req.url, '/all')) {
+    res.render('pages/all')
+  } else {
+    next()
+  }
+})
+
+// ==========================================
+// VIEW MODE
+// ==========================================
+
+/**
+ * View source of a document
+ */
+router.get('/source/*', (req, res, next) => {
+  let safePath = entries.parsePath(_.replace(req.path, '/source', ''))
+
+  entries.fetchOriginal(safePath, {
+    parseMarkdown: false,
+    parseMeta: true,
+    parseTree: false,
+    includeMarkdown: true,
+    includeParentInfo: false,
+    cache: false
+  }).then((pageData) => {
+    if (pageData) {
+      res.render('pages/source', { pageData })
+    } else {
+      throw new Error('Invalid page path.')
+    }
+    return true
+  }).catch((err) => {
+    res.render('error', {
+      message: err.message,
+      error: {}
+    })
+  })
+})
+
+/**
+ * View document
+ */
+router.get('/*', (req, res, next) => {
+  let safePath = entries.parsePath(req.path)
+
+  entries.fetch(safePath).then((pageData) => {
+    if (pageData) {
+      res.render('pages/view', { pageData })
+    } else {
+      res.render('error-notexist', {
+        newpath: safePath
+      })
+    }
+    return true
+  }).error((err) => {
+    if (safePath === 'home') {
+      res.render('pages/welcome')
+    } else {
+      res.render('error-notexist', {
+        message: err.message,
+        newpath: safePath
+      })
+    }
+    return true
+  }).catch((err) => {
+    res.render('error', {
+      message: err.message,
+      error: {}
+    })
+  })
+})
+
+/**
+ * Move document
+ */
+router.put('/*', (req, res, next) => {
+  if (!res.locals.rights.write) {
+    return res.json({
+      ok: false,
+      error: 'Forbidden'
+    })
+  }
+
+  let safePath = entries.parsePath(req.path)
+
+  if (_.isEmpty(req.body.move)) {
+    return res.json({
+      ok: false,
+      error: 'Invalid document action call.'
+    })
+  }
+
+  let safeNewPath = entries.parsePath(req.body.move)
+
+  entries.move(safePath, safeNewPath, req.user).then(() => {
+    res.json({
+      ok: true
+    })
+  }).catch((err) => {
+    res.json({
+      ok: false,
+      error: err.message
+    })
+  })
+})
+
+module.exports = router

server/controllers/uploads.js

@@ -0,0 +1,160 @@
+'use strict'
+
+const express = require('express')
+const router = express.Router()
+
+const readChunk = require('read-chunk')
+const fileType = require('file-type')
+const Promise = require('bluebird')
+const fs = Promise.promisifyAll(require('fs-extra'))
+const path = require('path')
+const _ = require('lodash')
+
+const validPathRe = new RegExp('^(([a-z0-9/-]|' + appdata.regex.cjk.source + ')+\\.[a-z0-9]+)$')
+const validPathThumbsRe = new RegExp('^([a-z0-9]+\\.png)$')
+
+// ==========================================
+// SERVE UPLOADS FILES
+// ==========================================
+
+router.get('/t/*', (req, res, next) => {
+  let fileName = req.params[0]
+  if (!validPathThumbsRe.test(fileName)) {
+    return res.sendStatus(404).end()
+  }
+
+  // todo: Authentication-based access
+
+  res.sendFile(fileName, {
+    root: lcdata.getThumbsPath(),
+    dotfiles: 'deny'
+  }, (err) => {
+    if (err) {
+      res.status(err.status).end()
+    }
+  })
+})
+
+router.post('/img', lcdata.uploadImgHandler, (req, res, next) => {
+  let destFolder = _.chain(req.body.folder).trim().toLower().value()
+
+  upl.validateUploadsFolder(destFolder).then((destFolderPath) => {
+    if (!destFolderPath) {
+      res.json({ ok: false, msg: 'Invalid Folder' })
+      return true
+    }
+
+    Promise.map(req.files, (f) => {
+      let destFilename = ''
+      let destFilePath = ''
+
+      return lcdata.validateUploadsFilename(f.originalname, destFolder, true).then((fname) => {
+        destFilename = fname
+        destFilePath = path.resolve(destFolderPath, destFilename)
+
+        return readChunk(f.path, 0, 262)
+      }).then((buf) => {
+        // -> Check MIME type by magic number
+
+        let mimeInfo = fileType(buf)
+        if (!_.includes(['image/png', 'image/jpeg', 'image/gif', 'image/webp'], mimeInfo.mime)) {
+          return Promise.reject(new Error('Invalid file type.'))
+        }
+        return true
+      }).then(() => {
+        // -> Move file to final destination
+
+        return fs.moveAsync(f.path, destFilePath, { clobber: false })
+      }).then(() => {
+        return {
+          ok: true,
+          filename: destFilename,
+          filesize: f.size
+        }
+      }).reflect()
+    }, {concurrency: 3}).then((results) => {
+      let uplResults = _.map(results, (r) => {
+        if (r.isFulfilled()) {
+          return r.value()
+        } else {
+          return {
+            ok: false,
+            msg: r.reason().message
+          }
+        }
+      })
+      res.json({ ok: true, results: uplResults })
+      return true
+    }).catch((err) => {
+      res.json({ ok: false, msg: err.message })
+      return true
+    })
+  })
+})
+
+router.post('/file', lcdata.uploadFileHandler, (req, res, next) => {
+  let destFolder = _.chain(req.body.folder).trim().toLower().value()
+
+  upl.validateUploadsFolder(destFolder).then((destFolderPath) => {
+    if (!destFolderPath) {
+      res.json({ ok: false, msg: 'Invalid Folder' })
+      return true
+    }
+
+    Promise.map(req.files, (f) => {
+      let destFilename = ''
+      let destFilePath = ''
+
+      return lcdata.validateUploadsFilename(f.originalname, destFolder, false).then((fname) => {
+        destFilename = fname
+        destFilePath = path.resolve(destFolderPath, destFilename)
+
+        // -> Move file to final destination
+
+        return fs.moveAsync(f.path, destFilePath, { clobber: false })
+      }).then(() => {
+        return {
+          ok: true,
+          filename: destFilename,
+          filesize: f.size
+        }
+      }).reflect()
+    }, {concurrency: 3}).then((results) => {
+      let uplResults = _.map(results, (r) => {
+        if (r.isFulfilled()) {
+          return r.value()
+        } else {
+          return {
+            ok: false,
+            msg: r.reason().message
+          }
+        }
+      })
+      res.json({ ok: true, results: uplResults })
+      return true
+    }).catch((err) => {
+      res.json({ ok: false, msg: err.message })
+      return true
+    })
+  })
+})
+
+router.get('/*', (req, res, next) => {
+  let fileName = req.params[0]
+  if (!validPathRe.test(fileName)) {
+    return res.sendStatus(404).end()
+  }
+
+  // todo: Authentication-based access
+
+  res.sendFile(fileName, {
+    root: git.getRepoPath() + '/uploads/',
+    dotfiles: 'deny'
+  }, (err) => {
+    if (err) {
+      res.status(err.status).end()
+    }
+  })
+})
+
+module.exports = router

server/controllers/ws.js

@@ -0,0 +1,110 @@
+'use strict'
+
+/* eslint-disable standard/no-callback-literal */
+
+const _ = require('lodash')
+
+module.exports = (socket) => {
+  // -----------------------------------------
+  // SEARCH
+  // -----------------------------------------
+
+  if (appconfig.public || socket.request.user.logged_in) {
+    socket.on('search', (data, cb) => {
+      cb = cb || _.noop
+      search.find(data.terms).then((results) => {
+        return cb(results) || true
+      })
+    })
+  }
+
+  // -----------------------------------------
+  // TREE VIEW (LIST ALL PAGES)
+  // -----------------------------------------
+
+  if (socket.request.user.logged_in) {
+    socket.on('treeFetch', (data, cb) => {
+      cb = cb || _.noop
+      entries.getFromTree(data.basePath).then((f) => {
+        return cb(f) || true
+      })
+    })
+  }
+
+  // -----------------------------------------
+  // UPLOADS
+  // -----------------------------------------
+
+  if (socket.request.user.logged_in) {
+    socket.on('uploadsGetFolders', (data, cb) => {
+      cb = cb || _.noop
+      upl.getUploadsFolders().then((f) => {
+        return cb(f) || true
+      })
+    })
+
+    socket.on('uploadsCreateFolder', (data, cb) => {
+      cb = cb || _.noop
+      upl.createUploadsFolder(data.foldername).then((f) => {
+        return cb(f) || true
+      })
+    })
+
+    socket.on('uploadsGetImages', (data, cb) => {
+      cb = cb || _.noop
+      upl.getUploadsFiles('image', data.folder).then((f) => {
+        return cb(f) || true
+      })
+    })
+
+    socket.on('uploadsGetFiles', (data, cb) => {
+      cb = cb || _.noop
+      upl.getUploadsFiles('binary', data.folder).then((f) => {
+        return cb(f) || true
+      })
+    })
+
+    socket.on('uploadsDeleteFile', (data, cb) => {
+      cb = cb || _.noop
+      upl.deleteUploadsFile(data.uid).then((f) => {
+        return cb(f) || true
+      })
+    })
+
+    socket.on('uploadsFetchFileFromURL', (data, cb) => {
+      cb = cb || _.noop
+      upl.downloadFromUrl(data.folder, data.fetchUrl).then((f) => {
+        return cb({ ok: true }) || true
+      }).catch((err) => {
+        return cb({
+          ok: false,
+          msg: err.message
+        }) || true
+      })
+    })
+
+    socket.on('uploadsRenameFile', (data, cb) => {
+      cb = cb || _.noop
+      upl.moveUploadsFile(data.uid, data.folder, data.filename).then((f) => {
+        return cb({ ok: true }) || true
+      }).catch((err) => {
+        return cb({
+          ok: false,
+          msg: err.message
+        }) || true
+      })
+    })
+
+    socket.on('uploadsMoveFile', (data, cb) => {
+      cb = cb || _.noop
+      upl.moveUploadsFile(data.uid, data.folder).then((f) => {
+        return cb({ ok: true }) || true
+      }).catch((err) => {
+        return cb({
+          ok: false,
+          msg: err.message
+        }) || true
+      })
+    })
+  }
+}