First typescript iteration

17 files changed, 550 insertions, 488 deletions

diff --git a/server/controllers/api/clients.js b/server/controllers/api/clients.ts
index cf83cb835..902f62995 100644
--- a/server/controllers/api/clients.js
+++ b/server/controllers/api/clients.ts
@@ -1,19 +1,17 @@
-'use strict'
+import express = require('express')
 
-const express = require('express')
-
-const constants = require('../../initializers/constants')
+import { CONFIG } from '../../initializers';
+import { logger } from '../../helpers'
 const db = require('../../initializers/database')
-const logger = require('../../helpers/logger')
 
-const router = express.Router()
+const clientsRouter = express.Router()
 
-router.get('/local', getLocalClient)
+clientsRouter.get('/local', getLocalClient)
 
 // Get the client credentials for the PeerTube front end
 function getLocalClient (req, res, next) {
-  const serverHostname = constants.CONFIG.WEBSERVER.HOSTNAME
-  const serverPort = constants.CONFIG.WEBSERVER.PORT
+  const serverHostname = CONFIG.WEBSERVER.HOSTNAME
+  const serverPort = CONFIG.WEBSERVER.PORT
   let headerHostShouldBe = serverHostname
   if (serverPort !== 80 && serverPort !== 443) {
     headerHostShouldBe += ':' + serverPort
@@ -38,4 +36,6 @@ function getLocalClient (req, res, next) {
 
 // ---------------------------------------------------------------------------
 
-module.exports = router
+export {
+  clientsRouter
+}
diff --git a/server/controllers/api/config.js b/server/controllers/api/config.js
deleted file mode 100644
index 8154b6ad0..000000000
--- a/server/controllers/api/config.js
+++ /dev/null
@@ -1,22 +0,0 @@
-'use strict'
-
-const express = require('express')
-
-const constants = require('../../initializers/constants')
-
-const router = express.Router()
-
-router.get('/', getConfig)
-
-// Get the client credentials for the PeerTube front end
-function getConfig (req, res, next) {
-  res.json({
-    signup: {
-      enabled: constants.CONFIG.SIGNUP.ENABLED
-    }
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-module.exports = router
diff --git a/server/controllers/api/config.ts b/server/controllers/api/config.ts
new file mode 100644
index 000000000..8f3fa2473
--- /dev/null
+++ b/server/controllers/api/config.ts
@@ -0,0 +1,22 @@
+import express = require('express')
+
+import { CONFIG } from '../../initializers';
+
+const configRouter = express.Router()
+
+configRouter.get('/', getConfig)
+
+// Get the client credentials for the PeerTube front end
+function getConfig (req, res, next) {
+  res.json({
+    signup: {
+      enabled: CONFIG.SIGNUP.ENABLED
+    }
+  })
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  configRouter
+}
diff --git a/server/controllers/api/index.js b/server/controllers/api/index.js
deleted file mode 100644
index 6edc089f4..000000000
--- a/server/controllers/api/index.js
+++ /dev/null
@@ -1,35 +0,0 @@
-'use strict'
-
-const express = require('express')
-
-const utils = require('../../helpers/utils')
-
-const router = express.Router()
-
-const clientsController = require('./clients')
-const configController = require('./config')
-const podsController = require('./pods')
-const remoteController = require('./remote')
-const requestsController = require('./requests')
-const usersController = require('./users')
-const videosController = require('./videos')
-
-router.use('/clients', clientsController)
-router.use('/config', configController)
-router.use('/pods', podsController)
-router.use('/remote', remoteController)
-router.use('/requests', requestsController)
-router.use('/users', usersController)
-router.use('/videos', videosController)
-router.use('/ping', pong)
-router.use('/*', utils.badRequest)
-
-// ---------------------------------------------------------------------------
-
-module.exports = router
-
-// ---------------------------------------------------------------------------
-
-function pong (req, res, next) {
-  return res.send('pong').status(200).end()
-}
diff --git a/server/controllers/api/index.ts b/server/controllers/api/index.ts
new file mode 100644
index 000000000..18bef2d3d
--- /dev/null
+++ b/server/controllers/api/index.ts
@@ -0,0 +1,33 @@
+import express = require('express')
+
+import { badRequest } from '../../helpers'
+
+import { clientsRouter } from './clients'
+import { configRouter } from './config'
+import { podsRouter } from './pods'
+import { remoteRouter } from './remote'
+import { requestsRouter } from './requests'
+import { usersRouter } from './users'
+import { videosRouter } from './videos'
+
+const apiRouter = express.Router()
+
+apiRouter.use('/clients', clientsRouter)
+apiRouter.use('/config', configRouter)
+apiRouter.use('/pods', podsRouter)
+apiRouter.use('/remote', remoteRouter)
+apiRouter.use('/requests', requestsRouter)
+apiRouter.use('/users', usersRouter)
+apiRouter.use('/videos', videosRouter)
+apiRouter.use('/ping', pong)
+apiRouter.use('/*', badRequest)
+
+// ---------------------------------------------------------------------------
+
+export { apiRouter }
+
+// ---------------------------------------------------------------------------
+
+function pong (req, res, next) {
+  return res.send('pong').status(200).end()
+}
diff --git a/server/controllers/api/pods.js b/server/controllers/api/pods.js
deleted file mode 100644
index ab5763cf6..000000000
--- a/server/controllers/api/pods.js
+++ /dev/null
@@ -1,109 +0,0 @@
-'use strict'
-
-const express = require('express')
-const waterfall = require('async/waterfall')
-
-const db = require('../../initializers/database')
-const constants = require('../../initializers/constants')
-const logger = require('../../helpers/logger')
-const peertubeCrypto = require('../../helpers/peertube-crypto')
-const utils = require('../../helpers/utils')
-const friends = require('../../lib/friends')
-const middlewares = require('../../middlewares')
-const admin = middlewares.admin
-const oAuth = middlewares.oauth
-const podsMiddleware = middlewares.pods
-const validators = middlewares.validators.pods
-
-const router = express.Router()
-
-router.get('/', listPods)
-router.post('/',
-  podsMiddleware.setBodyHostPort, // We need to modify the host before running the validator!
-  validators.podsAdd,
-  addPods
-)
-router.post('/makefriends',
-  oAuth.authenticate,
-  admin.ensureIsAdmin,
-  validators.makeFriends,
-  podsMiddleware.setBodyHostsPort,
-  makeFriends
-)
-router.get('/quitfriends',
-  oAuth.authenticate,
-  admin.ensureIsAdmin,
-  quitFriends
-)
-
-// ---------------------------------------------------------------------------
-
-module.exports = router
-
-// ---------------------------------------------------------------------------
-
-function addPods (req, res, next) {
-  const informations = req.body
-
-  waterfall([
-    function addPod (callback) {
-      const pod = db.Pod.build(informations)
-      pod.save().asCallback(function (err, podCreated) {
-        // Be sure about the number of parameters for the callback
-        return callback(err, podCreated)
-      })
-    },
-
-    function sendMyVideos (podCreated, callback) {
-      friends.sendOwnedVideosToPod(podCreated.id)
-
-      callback(null)
-    },
-
-    function fetchMyCertificate (callback) {
-      peertubeCrypto.getMyPublicCert(function (err, cert) {
-        if (err) {
-          logger.error('Cannot read cert file.')
-          return callback(err)
-        }
-
-        return callback(null, cert)
-      })
-    }
-  ], function (err, cert) {
-    if (err) return next(err)
-
-    return res.json({ cert: cert, email: constants.CONFIG.ADMIN.EMAIL })
-  })
-}
-
-function listPods (req, res, next) {
-  db.Pod.list(function (err, podsList) {
-    if (err) return next(err)
-
-    res.json(utils.getFormatedObjects(podsList, podsList.length))
-  })
-}
-
-function makeFriends (req, res, next) {
-  const hosts = req.body.hosts
-
-  friends.makeFriends(hosts, function (err) {
-    if (err) {
-      logger.error('Could not make friends.', { error: err })
-      return
-    }
-
-    logger.info('Made friends!')
-  })
-
-  res.type('json').status(204).end()
-}
-
-function quitFriends (req, res, next) {
-  friends.quitFriends(function (err) {
-    if (err) return next(err)
-
-    res.type('json').status(204).end()
-  })
-}
diff --git a/server/controllers/api/pods.ts b/server/controllers/api/pods.ts
new file mode 100644
index 000000000..06dfd8295
--- /dev/null
+++ b/server/controllers/api/pods.ts
@@ -0,0 +1,118 @@
+import express = require('express')
+import { waterfall } from 'async'
+
+const db = require('../../initializers/database')
+import { CONFIG } from '../../initializers'
+import {
+  logger,
+  getMyPublicCert,
+  getFormatedObjects
+} from '../../helpers'
+import {
+  sendOwnedVideosToPod,
+  makeFriends,
+  quitFriends
+} from '../../lib'
+import {
+  podsAddValidator,
+  authenticate,
+  ensureIsAdmin,
+  makeFriendsValidator,
+  setBodyHostPort,
+  setBodyHostsPort
+} from '../../middlewares'
+
+const podsRouter = express.Router()
+
+podsRouter.get('/', listPods)
+podsRouter.post('/',
+  setBodyHostPort, // We need to modify the host before running the validator!
+  podsAddValidator,
+  addPods
+)
+podsRouter.post('/makefriends',
+  authenticate,
+  ensureIsAdmin,
+  makeFriendsValidator,
+  setBodyHostsPort,
+  makeFriends
+)
+podsRouter.get('/quitfriends',
+  authenticate,
+  ensureIsAdmin,
+  quitFriends
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+  podsRouter
+}
+
+// ---------------------------------------------------------------------------
+
+function addPods (req, res, next) {
+  const informations = req.body
+
+  waterfall([
+    function addPod (callback) {
+      const pod = db.Pod.build(informations)
+      pod.save().asCallback(function (err, podCreated) {
+        // Be sure about the number of parameters for the callback
+        return callback(err, podCreated)
+      })
+    },
+
+    function sendMyVideos (podCreated, callback) {
+      sendOwnedVideosToPod(podCreated.id)
+
+      callback(null)
+    },
+
+    function fetchMyCertificate (callback) {
+      getMyPublicCert(function (err, cert) {
+        if (err) {
+          logger.error('Cannot read cert file.')
+          return callback(err)
+        }
+
+        return callback(null, cert)
+      })
+    }
+  ], function (err, cert) {
+    if (err) return next(err)
+
+    return res.json({ cert: cert, email: CONFIG.ADMIN.EMAIL })
+  })
+}
+
+function listPods (req, res, next) {
+  db.Pod.list(function (err, podsList) {
+    if (err) return next(err)
+
+    res.json(getFormatedObjects(podsList, podsList.length))
+  })
+}
+
+function makeFriendsController (req, res, next) {
+  const hosts = req.body.hosts
+
+  makeFriends(hosts, function (err) {
+    if (err) {
+      logger.error('Could not make friends.', { error: err })
+      return
+    }
+
+    logger.info('Made friends!')
+  })
+
+  res.type('json').status(204).end()
+}
+
+function quitFriendsController (req, res, next) {
+  quitFriends(function (err) {
+    if (err) return next(err)
+
+    res.type('json').status(204).end()
+  })
+}
diff --git a/server/controllers/api/remote/index.js b/server/controllers/api/remote/index.js
deleted file mode 100644
index 6106850ab..000000000
--- a/server/controllers/api/remote/index.js
+++ /dev/null
@@ -1,18 +0,0 @@
-'use strict'
-
-const express = require('express')
-
-const utils = require('../../../helpers/utils')
-
-const router = express.Router()
-
-const podsRemoteController = require('./pods')
-const videosRemoteController = require('./videos')
-
-router.use('/pods', podsRemoteController)
-router.use('/videos', videosRemoteController)
-router.use('/*', utils.badRequest)
-
-// ---------------------------------------------------------------------------
-
-module.exports = router
diff --git a/server/controllers/api/remote/index.ts b/server/controllers/api/remote/index.ts
new file mode 100644
index 000000000..b11439204
--- /dev/null
+++ b/server/controllers/api/remote/index.ts
@@ -0,0 +1,18 @@
+import express = require('express')
+
+import { badRequest } from '../../../helpers'
+
+import { remotePodsRouter } from './pods'
+import { remoteVideosRouter } from './videos'
+
+const remoteRouter = express.Router()
+
+remoteRouter.use('/pods', remotePodsRouter)
+remoteRouter.use('/videos', remoteVideosRouter)
+remoteRouter.use('/*', badRequest)
+
+// ---------------------------------------------------------------------------
+
+export {
+  remoteRouter
+}
diff --git a/server/controllers/api/remote/pods.js b/server/controllers/api/remote/pods.ts
index 0343bc62e..85ef7bb42 100644
--- a/server/controllers/api/remote/pods.js
+++ b/server/controllers/api/remote/pods.ts
@@ -1,25 +1,23 @@
-'use strict'
-
-const express = require('express')
-const waterfall = require('async/waterfall')
+import express = require('express')
+import { waterfall } from 'async/waterfall'
 
 const db = require('../../../initializers/database')
-const middlewares = require('../../../middlewares')
-const checkSignature = middlewares.secure.checkSignature
-const signatureValidator = middlewares.validators.remote.signature
+import { checkSignature, signatureValidator } from '../../../middlewares'
 
-const router = express.Router()
+const remotePodsRouter = express.Router()
 
 // Post because this is a secured request
-router.post('/remove',
-  signatureValidator.signature,
+remotePodsRouter.post('/remove',
+  signatureValidator,
   checkSignature,
   removePods
 )
 
 // ---------------------------------------------------------------------------
 
-module.exports = router
+export {
+  remotePodsRouter
+}
 
 // ---------------------------------------------------------------------------
 
diff --git a/server/controllers/api/remote/videos.js b/server/controllers/api/remote/videos.ts
index e54793628..df4ba8309 100644
--- a/server/controllers/api/remote/videos.js
+++ b/server/controllers/api/remote/videos.ts
@@ -1,20 +1,30 @@
-'use strict'
-
-const eachSeries = require('async/eachSeries')
-const express = require('express')
-const waterfall = require('async/waterfall')
+import express = require('express')
+import { eachSeries, waterfall } from 'async'
 
 const db = require('../../../initializers/database')
-const constants = require('../../../initializers/constants')
-const middlewares = require('../../../middlewares')
-const secureMiddleware = middlewares.secure
-const videosValidators = middlewares.validators.remote.videos
-const signatureValidators = middlewares.validators.remote.signature
-const logger = require('../../../helpers/logger')
-const friends = require('../../../lib/friends')
-const databaseUtils = require('../../../helpers/database-utils')
-
-const ENDPOINT_ACTIONS = constants.REQUEST_ENDPOINT_ACTIONS[constants.REQUEST_ENDPOINTS.VIDEOS]
+import {
+  REQUEST_ENDPOINT_ACTIONS,
+  REQUEST_ENDPOINTS,
+  REQUEST_VIDEO_EVENT_TYPES,
+  REQUEST_VIDEO_QADU_TYPES
+} from '../../../initializers'
+import {
+  checkSignature,
+  signatureValidator,
+  remoteVideosValidator,
+  remoteQaduVideosValidator,
+  remoteEventsVideosValidator
+} from '../../../middlewares'
+import {
+  logger,
+  commitTransaction,
+  retryTransactionWrapper,
+  rollbackTransaction,
+  startSerializableTransaction
+} from '../../../helpers'
+import { quickAndDirtyUpdatesVideoToFriends } from '../../../lib'
+
+const ENDPOINT_ACTIONS = REQUEST_ENDPOINT_ACTIONS[REQUEST_ENDPOINTS.VIDEOS]
 
 // Functions to call when processing a remote request
 const functionsHash = {}
@@ -23,32 +33,34 @@ functionsHash[ENDPOINT_ACTIONS.UPDATE] = updateRemoteVideoRetryWrapper
 functionsHash[ENDPOINT_ACTIONS.REMOVE] = removeRemoteVideo
 functionsHash[ENDPOINT_ACTIONS.REPORT_ABUSE] = reportAbuseRemoteVideo
 
-const router = express.Router()
+const remoteVideosRouter = express.Router()
 
-router.post('/',
-  signatureValidators.signature,
-  secureMiddleware.checkSignature,
-  videosValidators.remoteVideos,
+remoteVideosRouter.post('/',
+  signatureValidator,
+  checkSignature,
+  remoteVideosValidator,
   remoteVideos
 )
 
-router.post('/qadu',
-  signatureValidators.signature,
-  secureMiddleware.checkSignature,
-  videosValidators.remoteQaduVideos,
+remoteVideosRouter.post('/qadu',
+  signatureValidator,
+  checkSignature,
+  remoteQaduVideosValidator,
   remoteVideosQadu
 )
 
-router.post('/events',
-  signatureValidators.signature,
-  secureMiddleware.checkSignature,
-  videosValidators.remoteEventsVideos,
+remoteVideosRouter.post('/events',
+  signatureValidator,
+  checkSignature,
+  remoteEventsVideosValidator,
   remoteVideosEvents
 )
 
 // ---------------------------------------------------------------------------
 
-module.exports = router
+export {
+  remoteVideosRouter
+}
 
 // ---------------------------------------------------------------------------
 
@@ -58,7 +70,7 @@ function remoteVideos (req, res, next) {
 
   // We need to process in the same order to keep consistency
   // TODO: optimization
-  eachSeries(requests, function (request, callbackEach) {
+  eachSeries(requests, function (request: any, callbackEach) {
     const data = request.data
 
     // Get the function we need to call in order to process the request
@@ -81,7 +93,7 @@ function remoteVideosQadu (req, res, next) {
   const requests = req.body.data
   const fromPod = res.locals.secure.pod
 
-  eachSeries(requests, function (request, callbackEach) {
+  eachSeries(requests, function (request: any, callbackEach) {
     const videoData = request.data
 
     quickAndDirtyUpdateVideoRetryWrapper(videoData, fromPod, callbackEach)
@@ -96,7 +108,7 @@ function remoteVideosEvents (req, res, next) {
   const requests = req.body.data
   const fromPod = res.locals.secure.pod
 
-  eachSeries(requests, function (request, callbackEach) {
+  eachSeries(requests, function (request: any, callbackEach) {
     const eventData = request.data
 
     processVideosEventsRetryWrapper(eventData, fromPod, callbackEach)
@@ -113,12 +125,12 @@ function processVideosEventsRetryWrapper (eventData, fromPod, finalCallback) {
     errorMessage: 'Cannot process videos events with many retries.'
   }
 
-  databaseUtils.retryTransactionWrapper(processVideosEvents, options, finalCallback)
+  retryTransactionWrapper(processVideosEvents, options, finalCallback)
 }
 
 function processVideosEvents (eventData, fromPod, finalCallback) {
   waterfall([
-    databaseUtils.startSerializableTransaction,
+    startSerializableTransaction,
 
     function findVideo (t, callback) {
       fetchOwnedVideo(eventData.remoteId, function (err, videoInstance) {
@@ -133,19 +145,19 @@ function processVideosEvents (eventData, fromPod, finalCallback) {
       let qaduType
 
       switch (eventData.eventType) {
-        case constants.REQUEST_VIDEO_EVENT_TYPES.VIEWS:
+        case REQUEST_VIDEO_EVENT_TYPES.VIEWS:
           columnToUpdate = 'views'
-          qaduType = constants.REQUEST_VIDEO_QADU_TYPES.VIEWS
+          qaduType = REQUEST_VIDEO_QADU_TYPES.VIEWS
           break
 
-        case constants.REQUEST_VIDEO_EVENT_TYPES.LIKES:
+        case REQUEST_VIDEO_EVENT_TYPES.LIKES:
           columnToUpdate = 'likes'
-          qaduType = constants.REQUEST_VIDEO_QADU_TYPES.LIKES
+          qaduType = REQUEST_VIDEO_QADU_TYPES.LIKES
           break
 
-        case constants.REQUEST_VIDEO_EVENT_TYPES.DISLIKES:
+        case REQUEST_VIDEO_EVENT_TYPES.DISLIKES:
           columnToUpdate = 'dislikes'
-          qaduType = constants.REQUEST_VIDEO_QADU_TYPES.DISLIKES
+          qaduType = REQUEST_VIDEO_QADU_TYPES.DISLIKES
           break
 
         default:
@@ -168,17 +180,17 @@ function processVideosEvents (eventData, fromPod, finalCallback) {
         }
       ]
 
-      friends.quickAndDirtyUpdatesVideoToFriends(qadusParams, t, function (err) {
+      quickAndDirtyUpdatesVideoToFriends(qadusParams, t, function (err) {
         return callback(err, t)
       })
     },
 
-    databaseUtils.commitTransaction
+    commitTransaction
 
   ], function (err, t) {
     if (err) {
       logger.debug('Cannot process a video event.', { error: err })
-      return databaseUtils.rollbackTransaction(err, t, finalCallback)
+      return rollbackTransaction(err, t, finalCallback)
     }
 
     logger.info('Remote video event processed for video %s.', eventData.remoteId)
@@ -192,14 +204,14 @@ function quickAndDirtyUpdateVideoRetryWrapper (videoData, fromPod, finalCallback
     errorMessage: 'Cannot update quick and dirty the remote video with many retries.'
   }
 
-  databaseUtils.retryTransactionWrapper(quickAndDirtyUpdateVideo, options, finalCallback)
+  retryTransactionWrapper(quickAndDirtyUpdateVideo, options, finalCallback)
 }
 
 function quickAndDirtyUpdateVideo (videoData, fromPod, finalCallback) {
   let videoName
 
   waterfall([
-    databaseUtils.startSerializableTransaction,
+    startSerializableTransaction,
 
     function findVideo (t, callback) {
       fetchRemoteVideo(fromPod.host, videoData.remoteId, function (err, videoInstance) {
@@ -229,12 +241,12 @@ function quickAndDirtyUpdateVideo (videoData, fromPod, finalCallback) {
       })
     },
 
-    databaseUtils.commitTransaction
+    commitTransaction
 
   ], function (err, t) {
     if (err) {
       logger.debug('Cannot quick and dirty update the remote video.', { error: err })
-      return databaseUtils.rollbackTransaction(err, t, finalCallback)
+      return rollbackTransaction(err, t, finalCallback)
     }
 
     logger.info('Remote video %s quick and dirty updated', videoName)
@@ -249,7 +261,7 @@ function addRemoteVideoRetryWrapper (videoToCreateData, fromPod, finalCallback)
     errorMessage: 'Cannot insert the remote video with many retries.'
   }
 
-  databaseUtils.retryTransactionWrapper(addRemoteVideo, options, finalCallback)
+  retryTransactionWrapper(addRemoteVideo, options, finalCallback)
 }
 
 function addRemoteVideo (videoToCreateData, fromPod, finalCallback) {
@@ -257,7 +269,7 @@ function addRemoteVideo (videoToCreateData, fromPod, finalCallback) {
 
   waterfall([
 
-    databaseUtils.startSerializableTransaction,
+    startSerializableTransaction,
 
     function assertRemoteIdAndHostUnique (t, callback) {
       db.Video.loadByHostAndRemoteId(fromPod.host, videoToCreateData.remoteId, function (err, video) {
@@ -345,13 +357,13 @@ function addRemoteVideo (videoToCreateData, fromPod, finalCallback) {
       })
     },
 
-    databaseUtils.commitTransaction
+    commitTransaction
 
   ], function (err, t) {
     if (err) {
       // This is just a debug because we will retry the insert
       logger.debug('Cannot insert the remote video.', { error: err })
-      return databaseUtils.rollbackTransaction(err, t, finalCallback)
+      return rollbackTransaction(err, t, finalCallback)
     }
 
     logger.info('Remote video %s inserted.', videoToCreateData.name)
@@ -366,7 +378,7 @@ function updateRemoteVideoRetryWrapper (videoAttributesToUpdate, fromPod, finalC
     errorMessage: 'Cannot update the remote video with many retries'
   }
 
-  databaseUtils.retryTransactionWrapper(updateRemoteVideo, options, finalCallback)
+  retryTransactionWrapper(updateRemoteVideo, options, finalCallback)
 }
 
 function updateRemoteVideo (videoAttributesToUpdate, fromPod, finalCallback) {
@@ -374,7 +386,7 @@ function updateRemoteVideo (videoAttributesToUpdate, fromPod, finalCallback) {
 
   waterfall([
 
-    databaseUtils.startSerializableTransaction,
+    startSerializableTransaction,
 
     function findVideo (t, callback) {
       fetchRemoteVideo(fromPod.host, videoAttributesToUpdate.remoteId, function (err, videoInstance) {
@@ -421,13 +433,13 @@ function updateRemoteVideo (videoAttributesToUpdate, fromPod, finalCallback) {
       })
     },
 
-    databaseUtils.commitTransaction
+    commitTransaction
 
   ], function (err, t) {
     if (err) {
       // This is just a debug because we will retry the insert
       logger.debug('Cannot update the remote video.', { error: err })
-      return databaseUtils.rollbackTransaction(err, t, finalCallback)
+      return rollbackTransaction(err, t, finalCallback)
     }
 
     logger.info('Remote video %s updated', videoAttributesToUpdate.name)
diff --git a/server/controllers/api/requests.js b/server/controllers/api/requests.ts
index 6fd5753ac..304499a4f 100644
--- a/server/controllers/api/requests.js
+++ b/server/controllers/api/requests.ts
@@ -1,32 +1,34 @@
-'use strict'
+import express = require('express')
+import { parallel } from 'async'
 
-const express = require('express')
-const parallel = require('async/parallel')
+import {
+  getRequestScheduler,
+  getRequestVideoQaduScheduler,
+  getRequestVideoEventScheduler
+} from '../../lib'
+import { authenticate, ensureIsAdmin } from '../../middlewares'
 
-const friends = require('../../lib/friends')
-const middlewares = require('../../middlewares')
-const admin = middlewares.admin
-const oAuth = middlewares.oauth
+const requestsRouter = express.Router()
 
-const router = express.Router()
-
-router.get('/stats',
-  oAuth.authenticate,
-  admin.ensureIsAdmin,
+requestsRouter.get('/stats',
+  authenticate,
+  ensureIsAdmin,
   getStatsRequests
 )
 
 // ---------------------------------------------------------------------------
 
-module.exports = router
+export {
+  requestsRouter
+}
 
 // ---------------------------------------------------------------------------
 
 function getStatsRequests (req, res, next) {
   parallel({
-    requestScheduler: buildRequestSchedulerFunction(friends.getRequestScheduler()),
-    requestVideoQaduScheduler: buildRequestSchedulerFunction(friends.getRequestVideoQaduScheduler()),
-    requestVideoEventScheduler: buildRequestSchedulerFunction(friends.getRequestVideoEventScheduler())
+    requestScheduler: buildRequestSchedulerFunction(getRequestScheduler()),
+    requestVideoQaduScheduler: buildRequestSchedulerFunction(getRequestVideoQaduScheduler()),
+    requestVideoEventScheduler: buildRequestSchedulerFunction(getRequestVideoEventScheduler())
   }, function (err, result) {
     if (err) return next(err)
 
diff --git a/server/controllers/api/users.js b/server/controllers/api/users.ts
index c7fe7bf85..981a4706a 100644
--- a/server/controllers/api/users.js
+++ b/server/controllers/api/users.ts
@@ -1,79 +1,83 @@
-'use strict'
+import express = require('express')
+import { waterfall } from 'async'
 
-const express = require('express')
-const waterfall = require('async/waterfall')
-
-const constants = require('../../initializers/constants')
 const db = require('../../initializers/database')
-const logger = require('../../helpers/logger')
-const utils = require('../../helpers/utils')
-const middlewares = require('../../middlewares')
-const admin = middlewares.admin
-const oAuth = middlewares.oauth
-const pagination = middlewares.pagination
-const sort = middlewares.sort
-const validatorsPagination = middlewares.validators.pagination
-const validatorsSort = middlewares.validators.sort
-const validatorsUsers = middlewares.validators.users
-
-const router = express.Router()
-
-router.get('/me',
-  oAuth.authenticate,
+import { CONFIG, USER_ROLES } from '../../initializers'
+import { logger, getFormatedObjects } from '../../helpers'
+import {
+  authenticate,
+  ensureIsAdmin,
+  usersAddValidator,
+  usersUpdateValidator,
+  usersRemoveValidator,
+  usersVideoRatingValidator,
+  paginationValidator,
+  setPagination,
+  usersSortValidator,
+  setUsersSort,
+  token
+} from '../../middlewares'
+
+const usersRouter = express.Router()
+
+usersRouter.get('/me',
+  authenticate,
   getUserInformation
 )
 
-router.get('/me/videos/:videoId/rating',
-  oAuth.authenticate,
-  validatorsUsers.usersVideoRating,
+usersRouter.get('/me/videos/:videoId/rating',
+  authenticate,
+  usersVideoRatingValidator,
   getUserVideoRating
 )
 
-router.get('/',
-  validatorsPagination.pagination,
-  validatorsSort.usersSort,
-  sort.setUsersSort,
-  pagination.setPagination,
+usersRouter.get('/',
+  paginationValidator,
+  usersSortValidator,
+  setUsersSort,
+  setPagination,
   listUsers
 )
 
-router.post('/',
-  oAuth.authenticate,
-  admin.ensureIsAdmin,
-  validatorsUsers.usersAdd,
+usersRouter.post('/',
+  authenticate,
+  ensureIsAdmin,
+  usersAddValidator,
   createUser
 )
 
-router.post('/register',
+usersRouter.post('/register',
   ensureRegistrationEnabled,
-  validatorsUsers.usersAdd,
+  usersAddValidator,
   createUser
 )
 
-router.put('/:id',
-  oAuth.authenticate,
-  validatorsUsers.usersUpdate,
+usersRouter.put('/:id',
+  authenticate,
+  usersUpdateValidator,
   updateUser
 )
 
-router.delete('/:id',
-  oAuth.authenticate,
-  admin.ensureIsAdmin,
-  validatorsUsers.usersRemove,
+usersRouter.delete('/:id',
+  authenticate,
+  ensureIsAdmin,
+  usersRemoveValidator,
   removeUser
 )
 
-router.post('/token', oAuth.token, success)
+usersRouter.post('/token', token, success)
 // TODO: Once https://github.com/oauthjs/node-oauth2-server/pull/289 is merged, implement revoke token route
 
 // ---------------------------------------------------------------------------
 
-module.exports = router
+export {
+  usersRouter
+}
 
 // ---------------------------------------------------------------------------
 
 function ensureRegistrationEnabled (req, res, next) {
-  const registrationEnabled = constants.CONFIG.SIGNUP.ENABLED
+  const registrationEnabled = CONFIG.SIGNUP.ENABLED
 
   if (registrationEnabled === true) {
     return next()
@@ -88,7 +92,7 @@ function createUser (req, res, next) {
     password: req.body.password,
     email: req.body.email,
     displayNSFW: false,
-    role: constants.USER_ROLES.USER
+    role: USER_ROLES.USER
   })
 
   user.save().asCallback(function (err, createdUser) {
@@ -126,7 +130,7 @@ function listUsers (req, res, next) {
   db.User.listForApi(req.query.start, req.query.count, req.query.sort, function (err, usersList, usersTotal) {
     if (err) return next(err)
 
-    res.json(utils.getFormatedObjects(usersList, usersTotal))
+    res.json(getFormatedObjects(usersList, usersTotal))
   })
 }
 
diff --git a/server/controllers/api/videos/abuse.js b/server/controllers/api/videos/abuse.ts
index 0fb44bb14..88204120f 100644
--- a/server/controllers/api/videos/abuse.js
+++ b/server/controllers/api/videos/abuse.ts
@@ -1,43 +1,48 @@
-'use strict'
-
-const express = require('express')
-const waterfall = require('async/waterfall')
+import express = require('express')
+import { waterfall } from 'async'
 
 const db = require('../../../initializers/database')
-const logger = require('../../../helpers/logger')
-const friends = require('../../../lib/friends')
-const middlewares = require('../../../middlewares')
-const admin = middlewares.admin
-const oAuth = middlewares.oauth
-const pagination = middlewares.pagination
-const validators = middlewares.validators
-const validatorsPagination = validators.pagination
-const validatorsSort = validators.sort
-const validatorsVideos = validators.videos
-const sort = middlewares.sort
-const databaseUtils = require('../../../helpers/database-utils')
-const utils = require('../../../helpers/utils')
-
-const router = express.Router()
-
-router.get('/abuse',
-  oAuth.authenticate,
-  admin.ensureIsAdmin,
-  validatorsPagination.pagination,
-  validatorsSort.videoAbusesSort,
-  sort.setVideoAbusesSort,
-  pagination.setPagination,
+import friends = require('../../../lib/friends')
+import {
+  logger,
+  getFormatedObjects,
+  retryTransactionWrapper,
+  startSerializableTransaction,
+  commitTransaction,
+  rollbackTransaction
+} from '../../../helpers'
+import {
+  authenticate,
+  ensureIsAdmin,
+  paginationValidator,
+  videoAbuseReportValidator,
+  videoAbusesSortValidator,
+  setVideoAbusesSort,
+  setPagination
+} from '../../../middlewares'
+
+const abuseVideoRouter = express.Router()
+
+abuseVideoRouter.get('/abuse',
+  authenticate,
+  ensureIsAdmin,
+  paginationValidator,
+  videoAbusesSortValidator,
+  setVideoAbusesSort,
+  setPagination,
   listVideoAbuses
 )
-router.post('/:id/abuse',
-  oAuth.authenticate,
-  validatorsVideos.videoAbuseReport,
+abuseVideoRouter.post('/:id/abuse',
+  authenticate,
+  videoAbuseReportValidator,
   reportVideoAbuseRetryWrapper
 )
 
 // ---------------------------------------------------------------------------
 
-module.exports = router
+export {
+  abuseVideoRouter
+}
 
 // ---------------------------------------------------------------------------
 
@@ -45,7 +50,7 @@ function listVideoAbuses (req, res, next) {
   db.VideoAbuse.listForApi(req.query.start, req.query.count, req.query.sort, function (err, abusesList, abusesTotal) {
     if (err) return next(err)
 
-    res.json(utils.getFormatedObjects(abusesList, abusesTotal))
+    res.json(getFormatedObjects(abusesList, abusesTotal))
   })
 }
 
@@ -55,7 +60,7 @@ function reportVideoAbuseRetryWrapper (req, res, next) {
     errorMessage: 'Cannot report abuse to the video with many retries.'
   }
 
-  databaseUtils.retryTransactionWrapper(reportVideoAbuse, options, function (err) {
+  retryTransactionWrapper(reportVideoAbuse, options, function (err) {
     if (err) return next(err)
 
     return res.type('json').status(204).end()
@@ -75,7 +80,7 @@ function reportVideoAbuse (req, res, finalCallback) {
 
   waterfall([
 
-    databaseUtils.startSerializableTransaction,
+    startSerializableTransaction,
 
     function createAbuse (t, callback) {
       db.VideoAbuse.create(abuse).asCallback(function (err, abuse) {
@@ -98,12 +103,12 @@ function reportVideoAbuse (req, res, finalCallback) {
       return callback(null, t)
     },
 
-    databaseUtils.commitTransaction
+    commitTransaction
 
   ], function andFinally (err, t) {
     if (err) {
       logger.debug('Cannot update the video.', { error: err })
-      return databaseUtils.rollbackTransaction(err, t, finalCallback)
+      return rollbackTransaction(err, t, finalCallback)
     }
 
     logger.info('Abuse report for video %s created.', videoInstance.name)
diff --git a/server/controllers/api/videos/blacklist.js b/server/controllers/api/videos/blacklist.ts
index 8c3e2a69d..db6d95e73 100644
--- a/server/controllers/api/videos/blacklist.js
+++ b/server/controllers/api/videos/blacklist.ts
@@ -1,27 +1,27 @@
-'use strict'
-
-const express = require('express')
+import express = require('express')
 
 const db = require('../../../initializers/database')
-const logger = require('../../../helpers/logger')
-const middlewares = require('../../../middlewares')
-const admin = middlewares.admin
-const oAuth = middlewares.oauth
-const validators = middlewares.validators
-const validatorsVideos = validators.videos
-
-const router = express.Router()
-
-router.post('/:id/blacklist',
-  oAuth.authenticate,
-  admin.ensureIsAdmin,
-  validatorsVideos.videosBlacklist,
+import { logger } from '../../../helpers'
+import {
+  authenticate,
+  ensureIsAdmin,
+  videosBlacklistValidator
+} from '../../../middlewares'
+
+const blacklistRouter = express.Router()
+
+blacklistRouter.post('/:id/blacklist',
+  authenticate,
+  ensureIsAdmin,
+  videosBlacklistValidator,
   addVideoToBlacklist
 )
 
 // ---------------------------------------------------------------------------
 
-module.exports = router
+export {
+  blacklistRouter
+}
 
 // ---------------------------------------------------------------------------
 
diff --git a/server/controllers/api/videos/index.js b/server/controllers/api/videos/index.ts
index 8de44d5ac..5fbf03676 100644
--- a/server/controllers/api/videos/index.js
+++ b/server/controllers/api/videos/index.ts
@@ -1,37 +1,57 @@
-'use strict'
+import express = require('express')
+import fs = require('fs')
+import multer = require('multer')
+import path = require('path')
+import { waterfall } from 'async'
 
-const express = require('express')
-const fs = require('fs')
-const multer = require('multer')
-const path = require('path')
-const waterfall = require('async/waterfall')
-
-const constants = require('../../../initializers/constants')
 const db = require('../../../initializers/database')
-const logger = require('../../../helpers/logger')
-const friends = require('../../../lib/friends')
-const middlewares = require('../../../middlewares')
-const oAuth = middlewares.oauth
-const pagination = middlewares.pagination
-const validators = middlewares.validators
-const validatorsPagination = validators.pagination
-const validatorsSort = validators.sort
-const validatorsVideos = validators.videos
-const search = middlewares.search
-const sort = middlewares.sort
-const databaseUtils = require('../../../helpers/database-utils')
-const utils = require('../../../helpers/utils')
-
-const abuseController = require('./abuse')
-const blacklistController = require('./blacklist')
-const rateController = require('./rate')
-
-const router = express.Router()
+import {
+  CONFIG,
+  REQUEST_VIDEO_QADU_TYPES,
+  REQUEST_VIDEO_EVENT_TYPES,
+  VIDEO_CATEGORIES,
+  VIDEO_LICENCES,
+  VIDEO_LANGUAGES
+} from '../../../initializers'
+import {
+  addEventToRemoteVideo,
+  quickAndDirtyUpdateVideoToFriends,
+  addVideoToFriends,
+  updateVideoToFriends
+} from '../../../lib'
+import {
+  authenticate,
+  paginationValidator,
+  videosSortValidator,
+  setVideosSort,
+  setPagination,
+  setVideosSearch,
+  videosUpdateValidator,
+  videosSearchValidator,
+  videosAddValidator,
+  videosGetValidator,
+  videosRemoveValidator
+} from '../../../middlewares'
+import {
+  logger,
+  commitTransaction,
+  retryTransactionWrapper,
+  rollbackTransaction,
+  startSerializableTransaction,
+  generateRandomString,
+  getFormatedObjects
+} from '../../../helpers'
+
+import { abuseVideoRouter } from './abuse'
+import { blacklistRouter } from './blacklist'
+import { rateVideoRouter } from './rate'
+
+const videosRouter = express.Router()
 
 // multer configuration
 const storage = multer.diskStorage({
   destination: function (req, file, cb) {
-    cb(null, constants.CONFIG.STORAGE.VIDEOS_DIR)
+    cb(null, CONFIG.STORAGE.VIDEOS_DIR)
   },
 
   filename: function (req, file, cb) {
@@ -39,7 +59,7 @@ const storage = multer.diskStorage({
     if (file.mimetype === 'video/webm') extension = 'webm'
     else if (file.mimetype === 'video/mp4') extension = 'mp4'
     else if (file.mimetype === 'video/ogg') extension = 'ogv'
-    utils.generateRandomString(16, function (err, randomString) {
+    generateRandomString(16, function (err, randomString) {
       const fieldname = err ? undefined : randomString
       cb(null, fieldname + '.' + extension)
     })
@@ -48,70 +68,72 @@ const storage = multer.diskStorage({
 
 const reqFiles = multer({ storage: storage }).fields([{ name: 'videofile', maxCount: 1 }])
 
-router.use('/', abuseController)
-router.use('/', blacklistController)
-router.use('/', rateController)
+videosRouter.use('/', abuseVideoRouter)
+videosRouter.use('/', blacklistRouter)
+videosRouter.use('/', rateVideoRouter)
 
-router.get('/categories', listVideoCategories)
-router.get('/licences', listVideoLicences)
-router.get('/languages', listVideoLanguages)
+videosRouter.get('/categories', listVideoCategories)
+videosRouter.get('/licences', listVideoLicences)
+videosRouter.get('/languages', listVideoLanguages)
 
-router.get('/',
-  validatorsPagination.pagination,
-  validatorsSort.videosSort,
-  sort.setVideosSort,
-  pagination.setPagination,
+videosRouter.get('/',
+  paginationValidator,
+  videosSortValidator,
+  setVideosSort,
+  setPagination,
   listVideos
 )
-router.put('/:id',
-  oAuth.authenticate,
+videosRouter.put('/:id',
+  authenticate,
   reqFiles,
-  validatorsVideos.videosUpdate,
+  videosUpdateValidator,
   updateVideoRetryWrapper
 )
-router.post('/',
-  oAuth.authenticate,
+videosRouter.post('/',
+  authenticate,
   reqFiles,
-  validatorsVideos.videosAdd,
+  videosAddValidator,
   addVideoRetryWrapper
 )
-router.get('/:id',
-  validatorsVideos.videosGet,
+videosRouter.get('/:id',
+  videosGetValidator,
   getVideo
 )
 
-router.delete('/:id',
-  oAuth.authenticate,
-  validatorsVideos.videosRemove,
+videosRouter.delete('/:id',
+  authenticate,
+  videosRemoveValidator,
   removeVideo
 )
 
-router.get('/search/:value',
-  validatorsVideos.videosSearch,
-  validatorsPagination.pagination,
-  validatorsSort.videosSort,
-  sort.setVideosSort,
-  pagination.setPagination,
-  search.setVideosSearch,
+videosRouter.get('/search/:value',
+  videosSearchValidator,
+  paginationValidator,
+  videosSortValidator,
+  setVideosSort,
+  setPagination,
+  setVideosSearch,
   searchVideos
 )
 
 // ---------------------------------------------------------------------------
 
-module.exports = router
+export {
+  videosRouter
+}
 
 // ---------------------------------------------------------------------------
 
 function listVideoCategories (req, res, next) {
-  res.json(constants.VIDEO_CATEGORIES)
+  res.json(VIDEO_CATEGORIES)
 }
 
 function listVideoLicences (req, res, next) {
-  res.json(constants.VIDEO_LICENCES)
+  res.json(VIDEO_LICENCES)
 }
 
 function listVideoLanguages (req, res, next) {
-  res.json(constants.VIDEO_LANGUAGES)
+  res.json(VIDEO_LANGUAGES)
 }
 
 // Wrapper to video add that retry the function if there is a database error
@@ -122,7 +144,7 @@ function addVideoRetryWrapper (req, res, next) {
     errorMessage: 'Cannot insert the video with many retries.'
   }
 
-  databaseUtils.retryTransactionWrapper(addVideo, options, function (err) {
+  retryTransactionWrapper(addVideo, options, function (err) {
     if (err) return next(err)
 
     // TODO : include Location of the new video -> 201
@@ -135,7 +157,7 @@ function addVideo (req, res, videoFile, finalCallback) {
 
   waterfall([
 
-    databaseUtils.startSerializableTransaction,
+    startSerializableTransaction,
 
     function findOrCreateAuthor (t, callback) {
       const user = res.locals.oauth.token.User
@@ -179,7 +201,7 @@ function addVideo (req, res, videoFile, finalCallback) {
 
      // Set the videoname the same as the id
     function renameVideoFile (t, author, tagInstances, video, callback) {
-      const videoDir = constants.CONFIG.STORAGE.VIDEOS_DIR
+      const videoDir = CONFIG.STORAGE.VIDEOS_DIR
       const source = path.join(videoDir, videoFile.filename)
       const destination = path.join(videoDir, video.getVideoFilename())
 
@@ -218,25 +240,25 @@ function addVideo (req, res, videoFile, finalCallback) {
 
     function sendToFriends (t, video, callback) {
       // Let transcoding job send the video to friends because the videofile extension might change
-      if (constants.CONFIG.TRANSCODING.ENABLED === true) return callback(null, t)
+      if (CONFIG.TRANSCODING.ENABLED === true) return callback(null, t)
 
       video.toAddRemoteJSON(function (err, remoteVideo) {
         if (err) return callback(err)
 
         // Now we'll add the video's meta data to our friends
-        friends.addVideoToFriends(remoteVideo, t, function (err) {
+        addVideoToFriends(remoteVideo, t, function (err) {
           return callback(err, t)
         })
       })
     },
 
-    databaseUtils.commitTransaction
+    commitTransaction
 
   ], function andFinally (err, t) {
     if (err) {
       // This is just a debug because we will retry the insert
       logger.debug('Cannot insert the video.', { error: err })
-      return databaseUtils.rollbackTransaction(err, t, finalCallback)
+      return rollbackTransaction(err, t, finalCallback)
     }
 
     logger.info('Video with name %s created.', videoInfos.name)
@@ -250,7 +272,7 @@ function updateVideoRetryWrapper (req, res, next) {
     errorMessage: 'Cannot update the video with many retries.'
   }
 
-  databaseUtils.retryTransactionWrapper(updateVideo, options, function (err) {
+  retryTransactionWrapper(updateVideo, options, function (err) {
     if (err) return next(err)
 
     // TODO : include Location of the new video -> 201
@@ -265,7 +287,7 @@ function updateVideo (req, res, finalCallback) {
 
   waterfall([
 
-    databaseUtils.startSerializableTransaction,
+    startSerializableTransaction,
 
     function findOrCreateTags (t, callback) {
       if (videoInfosToUpdate.tags) {
@@ -312,12 +334,12 @@ function updateVideo (req, res, finalCallback) {
       const json = videoInstance.toUpdateRemoteJSON()
 
       // Now we'll update the video's meta data to our friends
-      friends.updateVideoToFriends(json, t, function (err) {
+      updateVideoToFriends(json, t, function (err) {
         return callback(err, t)
       })
     },
 
-    databaseUtils.commitTransaction
+    commitTransaction
 
   ], function andFinally (err, t) {
     if (err) {
@@ -331,7 +353,7 @@ function updateVideo (req, res, finalCallback) {
         videoInstance.set(key, value)
       })
 
-      return databaseUtils.rollbackTransaction(err, t, finalCallback)
+      return rollbackTransaction(err, t, finalCallback)
     }
 
     logger.info('Video with name %s updated.', videoInfosToUpdate.name)
@@ -354,17 +376,17 @@ function getVideo (req, res, next) {
       // For example, only add a view when a user watch a video during 30s etc
       const qaduParams = {
         videoId: videoInstance.id,
-        type: constants.REQUEST_VIDEO_QADU_TYPES.VIEWS
+        type: REQUEST_VIDEO_QADU_TYPES.VIEWS
       }
-      friends.quickAndDirtyUpdateVideoToFriends(qaduParams)
+      quickAndDirtyUpdateVideoToFriends(qaduParams)
     })
   } else {
     // Just send the event to our friends
     const eventParams = {
       videoId: videoInstance.id,
-      type: constants.REQUEST_VIDEO_EVENT_TYPES.VIEWS
+      type: REQUEST_VIDEO_EVENT_TYPES.VIEWS
     }
-    friends.addEventToRemoteVideo(eventParams)
+    addEventToRemoteVideo(eventParams)
   }
 
   // Do not wait the view system
@@ -375,7 +397,7 @@ function listVideos (req, res, next) {
   db.Video.listForApi(req.query.start, req.query.count, req.query.sort, function (err, videosList, videosTotal) {
     if (err) return next(err)
 
-    res.json(utils.getFormatedObjects(videosList, videosTotal))
+    res.json(getFormatedObjects(videosList, videosTotal))
   })
 }
 
@@ -398,7 +420,7 @@ function searchVideos (req, res, next) {
     function (err, videosList, videosTotal) {
       if (err) return next(err)
 
-      res.json(utils.getFormatedObjects(videosList, videosTotal))
+      res.json(getFormatedObjects(videosList, videosTotal))
     }
   )
 }
diff --git a/server/controllers/api/videos/rate.js b/server/controllers/api/videos/rate.ts
index df8a69a1d..21053792a 100644
--- a/server/controllers/api/videos/rate.js
+++ b/server/controllers/api/videos/rate.ts
@@ -1,29 +1,41 @@
-'use strict'
+import express = require('express')
+import { waterfall } from 'async'
 
-const express = require('express')
-const waterfall = require('async/waterfall')
-
-const constants = require('../../../initializers/constants')
 const db = require('../../../initializers/database')
-const logger = require('../../../helpers/logger')
-const friends = require('../../../lib/friends')
-const middlewares = require('../../../middlewares')
-const oAuth = middlewares.oauth
-const validators = middlewares.validators
-const validatorsVideos = validators.videos
-const databaseUtils = require('../../../helpers/database-utils')
-
-const router = express.Router()
-
-router.put('/:id/rate',
-  oAuth.authenticate,
-  validatorsVideos.videoRate,
+import {
+  logger,
+  retryTransactionWrapper,
+  startSerializableTransaction,
+  commitTransaction,
+  rollbackTransaction
+} from '../../../helpers'
+import {
+  VIDEO_RATE_TYPES,
+  REQUEST_VIDEO_EVENT_TYPES,
+  REQUEST_VIDEO_QADU_TYPES
+} from '../../../initializers'
+import {
+  addEventsToRemoteVideo,
+  quickAndDirtyUpdatesVideoToFriends
+} from '../../../lib'
+import {
+  authenticate,
+  videoRateValidator
+} from '../../../middlewares'
+
+const rateVideoRouter = express.Router()
+
+rateVideoRouter.put('/:id/rate',
+  authenticate,
+  videoRateValidator,
   rateVideoRetryWrapper
 )
 
 // ---------------------------------------------------------------------------
 
-module.exports = router
+export {
+  rateVideoRouter
+}
 
 // ---------------------------------------------------------------------------
 
@@ -33,7 +45,7 @@ function rateVideoRetryWrapper (req, res, next) {
     errorMessage: 'Cannot update the user video rate.'
   }
 
-  databaseUtils.retryTransactionWrapper(rateVideo, options, function (err) {
+  retryTransactionWrapper(rateVideo, options, function (err) {
     if (err) return next(err)
 
     return res.type('json').status(204).end()
@@ -46,7 +58,7 @@ function rateVideo (req, res, finalCallback) {
   const userInstance = res.locals.oauth.token.User
 
   waterfall([
-    databaseUtils.startSerializableTransaction,
+    startSerializableTransaction,
 
     function findPreviousRate (t, callback) {
       db.UserVideoRate.load(userInstance.id, videoInstance.id, t, function (err, previousRate) {
@@ -60,14 +72,14 @@ function rateVideo (req, res, finalCallback) {
       let likesToIncrement = 0
       let dislikesToIncrement = 0
 
-      if (rateType === constants.VIDEO_RATE_TYPES.LIKE) likesToIncrement++
-      else if (rateType === constants.VIDEO_RATE_TYPES.DISLIKE) dislikesToIncrement++
+      if (rateType === VIDEO_RATE_TYPES.LIKE) likesToIncrement++
+      else if (rateType === VIDEO_RATE_TYPES.DISLIKE) dislikesToIncrement++
 
       // There was a previous rate, update it
       if (previousRate) {
         // We will remove the previous rate, so we will need to remove it from the video attribute
-        if (previousRate.type === constants.VIDEO_RATE_TYPES.LIKE) likesToIncrement--
-        else if (previousRate.type === constants.VIDEO_RATE_TYPES.DISLIKE) dislikesToIncrement--
+        if (previousRate.type === VIDEO_RATE_TYPES.LIKE) likesToIncrement--
+        else if (previousRate.type === VIDEO_RATE_TYPES.DISLIKE) dislikesToIncrement--
 
         previousRate.type = rateType
 
@@ -110,7 +122,7 @@ function rateVideo (req, res, finalCallback) {
       if (likesToIncrement !== 0) {
         eventsParams.push({
           videoId: videoInstance.id,
-          type: constants.REQUEST_VIDEO_EVENT_TYPES.LIKES,
+          type: REQUEST_VIDEO_EVENT_TYPES.LIKES,
           count: likesToIncrement
         })
       }
@@ -118,12 +130,12 @@ function rateVideo (req, res, finalCallback) {
       if (dislikesToIncrement !== 0) {
         eventsParams.push({
           videoId: videoInstance.id,
-          type: constants.REQUEST_VIDEO_EVENT_TYPES.DISLIKES,
+          type: REQUEST_VIDEO_EVENT_TYPES.DISLIKES,
           count: dislikesToIncrement
         })
       }
 
-      friends.addEventsToRemoteVideo(eventsParams, t, function (err) {
+      addEventsToRemoteVideo(eventsParams, t, function (err) {
         return callback(err, t, likesToIncrement, dislikesToIncrement)
       })
     },
@@ -138,29 +150,29 @@ function rateVideo (req, res, finalCallback) {
       if (likesToIncrement !== 0) {
         qadusParams.push({
           videoId: videoInstance.id,
-          type: constants.REQUEST_VIDEO_QADU_TYPES.LIKES
+          type: REQUEST_VIDEO_QADU_TYPES.LIKES
         })
       }
 
       if (dislikesToIncrement !== 0) {
         qadusParams.push({
           videoId: videoInstance.id,
-          type: constants.REQUEST_VIDEO_QADU_TYPES.DISLIKES
+          type: REQUEST_VIDEO_QADU_TYPES.DISLIKES
         })
       }
 
-      friends.quickAndDirtyUpdatesVideoToFriends(qadusParams, t, function (err) {
+      quickAndDirtyUpdatesVideoToFriends(qadusParams, t, function (err) {
         return callback(err, t)
       })
     },
 
-    databaseUtils.commitTransaction
+    commitTransaction
 
   ], function (err, t) {
     if (err) {
       // This is just a debug because we will retry the insert
       logger.debug('Cannot add the user video rate.', { error: err })
-      return databaseUtils.rollbackTransaction(err, t, finalCallback)
+      return rollbackTransaction(err, t, finalCallback)
     }
 
     logger.info('User video rate for video %s of user %s updated.', videoInstance.name, userInstance.username)