10 files changed, 694 insertions, 261 deletions

diff --git a/server/controllers/api/clients.js b/server/controllers/api/clients.js
index 7755f6c2b..cf83cb835 100644
--- a/server/controllers/api/clients.js
+++ b/server/controllers/api/clients.js
@@ -1,13 +1,11 @@
 'use strict'
 
 const express = require('express')
-const mongoose = require('mongoose')
 
 const constants = require('../../initializers/constants')
+const db = require('../../initializers/database')
 const logger = require('../../helpers/logger')
 
-const Client = mongoose.model('OAuthClient')
-
 const router = express.Router()
 
 router.get('/local', getLocalClient)
@@ -27,12 +25,12 @@ function getLocalClient (req, res, next) {
     return res.type('json').status(403).end()
   }
 
-  Client.loadFirstClient(function (err, client) {
+  db.OAuthClient.loadFirstClient(function (err, client) {
     if (err) return next(err)
     if (!client) return next(new Error('No client available.'))
 
     res.json({
-      client_id: client._id,
+      client_id: client.clientId,
       client_secret: client.clientSecret
     })
   })
diff --git a/server/controllers/api/index.js b/server/controllers/api/index.js
index 4cb65ed55..f13ff922c 100644
--- a/server/controllers/api/index.js
+++ b/server/controllers/api/index.js
@@ -2,6 +2,8 @@
 
 const express = require('express')
 
+const utils = require('../../helpers/utils')
+
 const router = express.Router()
 
 const clientsController = require('./clients')
@@ -18,7 +20,7 @@ router.use('/requests', requestsController)
 router.use('/users', usersController)
 router.use('/videos', videosController)
 router.use('/ping', pong)
-router.use('/*', badRequest)
+router.use('/*', utils.badRequest)
 
 // ---------------------------------------------------------------------------
 
@@ -29,7 +31,3 @@ module.exports = router
 function pong (req, res, next) {
   return res.send('pong').status(200).end()
 }
-
-function badRequest (req, res, next) {
-  res.type('json').status(400).end()
-}
diff --git a/server/controllers/api/pods.js b/server/controllers/api/pods.js
index 7857fcee0..38702face 100644
--- a/server/controllers/api/pods.js
+++ b/server/controllers/api/pods.js
@@ -1,10 +1,11 @@
 'use strict'
 
 const express = require('express')
-const mongoose = require('mongoose')
 const waterfall = require('async/waterfall')
 
+const db = require('../../initializers/database')
 const logger = require('../../helpers/logger')
+const utils = require('../../helpers/utils')
 const friends = require('../../lib/friends')
 const middlewares = require('../../middlewares')
 const admin = middlewares.admin
@@ -15,7 +16,6 @@ const validators = middlewares.validators.pods
 const signatureValidator = middlewares.validators.remote.signature
 
 const router = express.Router()
-const Pod = mongoose.model('Pod')
 
 router.get('/', listPods)
 router.post('/',
@@ -37,7 +37,7 @@ router.get('/quitfriends',
 )
 // Post because this is a secured request
 router.post('/remove',
-  signatureValidator,
+  signatureValidator.signature,
   checkSignature,
   removePods
 )
@@ -53,15 +53,15 @@ function addPods (req, res, next) {
 
   waterfall([
     function addPod (callback) {
-      const pod = new Pod(informations)
-      pod.save(function (err, podCreated) {
+      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)
+      friends.sendOwnedVideosToPod(podCreated.id)
 
       callback(null)
     },
@@ -84,10 +84,10 @@ function addPods (req, res, next) {
 }
 
 function listPods (req, res, next) {
-  Pod.list(function (err, podsList) {
+  db.Pod.list(function (err, podsList) {
     if (err) return next(err)
 
-    res.json(getFormatedPods(podsList))
+    res.json(utils.getFormatedObjects(podsList, podsList.length))
   })
 }
 
@@ -111,11 +111,11 @@ function removePods (req, res, next) {
 
   waterfall([
     function loadPod (callback) {
-      Pod.loadByHost(host, callback)
+      db.Pod.loadByHost(host, callback)
     },
 
-    function removePod (pod, callback) {
-      pod.remove(callback)
+    function deletePod (pod, callback) {
+      pod.destroy().asCallback(callback)
     }
   ], function (err) {
     if (err) return next(err)
@@ -131,15 +131,3 @@ function quitFriends (req, res, next) {
     res.type('json').status(204).end()
   })
 }
-
-// ---------------------------------------------------------------------------
-
-function getFormatedPods (pods) {
-  const formatedPods = []
-
-  pods.forEach(function (pod) {
-    formatedPods.push(pod.toFormatedJSON())
-  })
-
-  return formatedPods
-}
diff --git a/server/controllers/api/remote.js b/server/controllers/api/remote.js
deleted file mode 100644
index f1046c534..000000000
--- a/server/controllers/api/remote.js
+++ /dev/null
@@ -1,86 +0,0 @@
-'use strict'
-
-const each = require('async/each')
-const eachSeries = require('async/eachSeries')
-const express = require('express')
-const mongoose = require('mongoose')
-
-const middlewares = require('../../middlewares')
-const secureMiddleware = middlewares.secure
-const validators = middlewares.validators.remote
-const logger = require('../../helpers/logger')
-
-const router = express.Router()
-const Video = mongoose.model('Video')
-
-router.post('/videos',
-  validators.signature,
-  secureMiddleware.checkSignature,
-  validators.remoteVideos,
-  remoteVideos
-)
-
-// ---------------------------------------------------------------------------
-
-module.exports = router
-
-// ---------------------------------------------------------------------------
-
-function remoteVideos (req, res, next) {
-  const requests = req.body.data
-  const fromHost = req.body.signature.host
-
-  // We need to process in the same order to keep consistency
-  // TODO: optimization
-  eachSeries(requests, function (request, callbackEach) {
-    const videoData = request.data
-
-    if (request.type === 'add') {
-      addRemoteVideo(videoData, fromHost, callbackEach)
-    } else if (request.type === 'remove') {
-      removeRemoteVideo(videoData, fromHost, callbackEach)
-    } else {
-      logger.error('Unkown remote request type %s.', request.type)
-    }
-  }, function (err) {
-    if (err) logger.error('Error managing remote videos.', { error: err })
-  })
-
-  // We don't need to keep the other pod waiting
-  return res.type('json').status(204).end()
-}
-
-function addRemoteVideo (videoToCreateData, fromHost, callback) {
-  logger.debug('Adding remote video "%s".', videoToCreateData.name)
-
-  const video = new Video(videoToCreateData)
-  video.podHost = fromHost
-  Video.generateThumbnailFromBase64(video, videoToCreateData.thumbnailBase64, function (err) {
-    if (err) {
-      logger.error('Cannot generate thumbnail from base 64 data.', { error: err })
-      return callback(err)
-    }
-
-    video.save(callback)
-  })
-}
-
-function removeRemoteVideo (videoToRemoveData, fromHost, callback) {
-  // We need the list because we have to remove some other stuffs (thumbnail etc)
-  Video.listByHostAndRemoteId(fromHost, videoToRemoveData.remoteId, function (err, videosList) {
-    if (err) {
-      logger.error('Cannot list videos from host and magnets.', { error: err })
-      return callback(err)
-    }
-
-    if (videosList.length === 0) {
-      logger.error('No remote video was found for this pod.', { magnetUri: videoToRemoveData.magnetUri, podHost: fromHost })
-    }
-
-    each(videosList, function (video, callbackEach) {
-      logger.debug('Removing remote video %s.', video.magnetUri)
-
-      video.remove(callbackEach)
-    }, callback)
-  })
-}
diff --git a/server/controllers/api/remote/index.js b/server/controllers/api/remote/index.js
new file mode 100644
index 000000000..2947632d5
--- /dev/null
+++ b/server/controllers/api/remote/index.js
@@ -0,0 +1,16 @@
+'use strict'
+
+const express = require('express')
+
+const utils = require('../../../helpers/utils')
+
+const router = express.Router()
+
+const videosRemoteController = require('./videos')
+
+router.use('/videos', videosRemoteController)
+router.use('/*', utils.badRequest)
+
+// ---------------------------------------------------------------------------
+
+module.exports = router
diff --git a/server/controllers/api/remote/videos.js b/server/controllers/api/remote/videos.js
new file mode 100644
index 000000000..c45a86dbb
--- /dev/null
+++ b/server/controllers/api/remote/videos.js
@@ -0,0 +1,328 @@
+'use strict'
+
+const eachSeries = require('async/eachSeries')
+const express = require('express')
+const waterfall = require('async/waterfall')
+
+const db = require('../../../initializers/database')
+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 utils = require('../../../helpers/utils')
+
+const router = express.Router()
+
+router.post('/',
+  signatureValidators.signature,
+  secureMiddleware.checkSignature,
+  videosValidators.remoteVideos,
+  remoteVideos
+)
+
+// ---------------------------------------------------------------------------
+
+module.exports = router
+
+// ---------------------------------------------------------------------------
+
+function remoteVideos (req, res, next) {
+  const requests = req.body.data
+  const fromPod = res.locals.secure.pod
+
+  // We need to process in the same order to keep consistency
+  // TODO: optimization
+  eachSeries(requests, function (request, callbackEach) {
+    const data = request.data
+
+    switch (request.type) {
+      case 'add':
+        addRemoteVideoRetryWrapper(data, fromPod, callbackEach)
+        break
+
+      case 'update':
+        updateRemoteVideoRetryWrapper(data, fromPod, callbackEach)
+        break
+
+      case 'remove':
+        removeRemoteVideo(data, fromPod, callbackEach)
+        break
+
+      case 'report-abuse':
+        reportAbuseRemoteVideo(data, fromPod, callbackEach)
+        break
+
+      default:
+        logger.error('Unkown remote request type %s.', request.type)
+    }
+  }, function (err) {
+    if (err) logger.error('Error managing remote videos.', { error: err })
+  })
+
+  // We don't need to keep the other pod waiting
+  return res.type('json').status(204).end()
+}
+
+// Handle retries on fail
+function addRemoteVideoRetryWrapper (videoToCreateData, fromPod, finalCallback) {
+  utils.transactionRetryer(
+    function (callback) {
+      return addRemoteVideo(videoToCreateData, fromPod, callback)
+    },
+    function (err) {
+      if (err) {
+        logger.error('Cannot insert the remote video with many retries.', { error: err })
+      }
+
+      // Do not return the error, continue the process
+      return finalCallback(null)
+    }
+  )
+}
+
+function addRemoteVideo (videoToCreateData, fromPod, finalCallback) {
+  logger.debug('Adding remote video "%s".', videoToCreateData.remoteId)
+
+  waterfall([
+
+    function startTransaction (callback) {
+      db.sequelize.transaction({ isolationLevel: 'SERIALIZABLE' }).asCallback(function (err, t) {
+        return callback(err, t)
+      })
+    },
+
+    function findOrCreateAuthor (t, callback) {
+      const name = videoToCreateData.author
+      const podId = fromPod.id
+      // This author is from another pod so we do not associate a user
+      const userId = null
+
+      db.Author.findOrCreateAuthor(name, podId, userId, t, function (err, authorInstance) {
+        return callback(err, t, authorInstance)
+      })
+    },
+
+    function findOrCreateTags (t, author, callback) {
+      const tags = videoToCreateData.tags
+
+      db.Tag.findOrCreateTags(tags, t, function (err, tagInstances) {
+        return callback(err, t, author, tagInstances)
+      })
+    },
+
+    function createVideoObject (t, author, tagInstances, callback) {
+      const videoData = {
+        name: videoToCreateData.name,
+        remoteId: videoToCreateData.remoteId,
+        extname: videoToCreateData.extname,
+        infoHash: videoToCreateData.infoHash,
+        description: videoToCreateData.description,
+        authorId: author.id,
+        duration: videoToCreateData.duration,
+        createdAt: videoToCreateData.createdAt,
+        // FIXME: updatedAt does not seems to be considered by Sequelize
+        updatedAt: videoToCreateData.updatedAt
+      }
+
+      const video = db.Video.build(videoData)
+
+      return callback(null, t, tagInstances, video)
+    },
+
+    function generateThumbnail (t, tagInstances, video, callback) {
+      db.Video.generateThumbnailFromData(video, videoToCreateData.thumbnailData, function (err) {
+        if (err) {
+          logger.error('Cannot generate thumbnail from data.', { error: err })
+          return callback(err)
+        }
+
+        return callback(err, t, tagInstances, video)
+      })
+    },
+
+    function insertVideoIntoDB (t, tagInstances, video, callback) {
+      const options = {
+        transaction: t
+      }
+
+      video.save(options).asCallback(function (err, videoCreated) {
+        return callback(err, t, tagInstances, videoCreated)
+      })
+    },
+
+    function associateTagsToVideo (t, tagInstances, video, callback) {
+      const options = { transaction: t }
+
+      video.setTags(tagInstances, options).asCallback(function (err) {
+        return callback(err, t)
+      })
+    }
+
+  ], 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 })
+
+      // Abort transaction?
+      if (t) t.rollback()
+
+      return finalCallback(err)
+    }
+
+    // Commit transaction
+    t.commit().asCallback(function (err) {
+      if (err) return finalCallback(err)
+
+      logger.info('Remote video %s inserted.', videoToCreateData.name)
+      return finalCallback(null)
+    })
+  })
+}
+
+// Handle retries on fail
+function updateRemoteVideoRetryWrapper (videoAttributesToUpdate, fromPod, finalCallback) {
+  utils.transactionRetryer(
+    function (callback) {
+      return updateRemoteVideo(videoAttributesToUpdate, fromPod, callback)
+    },
+    function (err) {
+      if (err) {
+        logger.error('Cannot update the remote video with many retries.', { error: err })
+      }
+
+      // Do not return the error, continue the process
+      return finalCallback(null)
+    }
+  )
+}
+
+function updateRemoteVideo (videoAttributesToUpdate, fromPod, finalCallback) {
+  logger.debug('Updating remote video "%s".', videoAttributesToUpdate.remoteId)
+
+  waterfall([
+
+    function startTransaction (callback) {
+      db.sequelize.transaction({ isolationLevel: 'SERIALIZABLE' }).asCallback(function (err, t) {
+        return callback(err, t)
+      })
+    },
+
+    function findVideo (t, callback) {
+      fetchVideo(fromPod.host, videoAttributesToUpdate.remoteId, function (err, videoInstance) {
+        return callback(err, t, videoInstance)
+      })
+    },
+
+    function findOrCreateTags (t, videoInstance, callback) {
+      const tags = videoAttributesToUpdate.tags
+
+      db.Tag.findOrCreateTags(tags, t, function (err, tagInstances) {
+        return callback(err, t, videoInstance, tagInstances)
+      })
+    },
+
+    function updateVideoIntoDB (t, videoInstance, tagInstances, callback) {
+      const options = { transaction: t }
+
+      videoInstance.set('name', videoAttributesToUpdate.name)
+      videoInstance.set('description', videoAttributesToUpdate.description)
+      videoInstance.set('infoHash', videoAttributesToUpdate.infoHash)
+      videoInstance.set('duration', videoAttributesToUpdate.duration)
+      videoInstance.set('createdAt', videoAttributesToUpdate.createdAt)
+      videoInstance.set('updatedAt', videoAttributesToUpdate.updatedAt)
+      videoInstance.set('extname', videoAttributesToUpdate.extname)
+
+      videoInstance.save(options).asCallback(function (err) {
+        return callback(err, t, videoInstance, tagInstances)
+      })
+    },
+
+    function associateTagsToVideo (t, videoInstance, tagInstances, callback) {
+      const options = { transaction: t }
+
+      videoInstance.setTags(tagInstances, options).asCallback(function (err) {
+        return callback(err, t)
+      })
+    }
+
+  ], 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 })
+
+      // Abort transaction?
+      if (t) t.rollback()
+
+      return finalCallback(err)
+    }
+
+   // Commit transaction
+    t.commit().asCallback(function (err) {
+      if (err) return finalCallback(err)
+
+      logger.info('Remote video %s updated', videoAttributesToUpdate.name)
+      return finalCallback(null)
+    })
+  })
+}
+
+function removeRemoteVideo (videoToRemoveData, fromPod, callback) {
+  // We need the instance because we have to remove some other stuffs (thumbnail etc)
+  fetchVideo(fromPod.host, videoToRemoveData.remoteId, function (err, video) {
+    // Do not return the error, continue the process
+    if (err) return callback(null)
+
+    logger.debug('Removing remote video %s.', video.remoteId)
+    video.destroy().asCallback(function (err) {
+      // Do not return the error, continue the process
+      if (err) {
+        logger.error('Cannot remove remote video with id %s.', videoToRemoveData.remoteId, { error: err })
+      }
+
+      return callback(null)
+    })
+  })
+}
+
+function reportAbuseRemoteVideo (reportData, fromPod, callback) {
+  db.Video.load(reportData.videoRemoteId, function (err, video) {
+    if (err || !video) {
+      if (!err) err = new Error('video not found')
+
+      logger.error('Cannot load video from id.', { error: err, id: reportData.videoRemoteId })
+      // Do not return the error, continue the process
+      return callback(null)
+    }
+
+    logger.debug('Reporting remote abuse for video %s.', video.id)
+
+    const videoAbuseData = {
+      reporterUsername: reportData.reporterUsername,
+      reason: reportData.reportReason,
+      reporterPodId: fromPod.id,
+      videoId: video.id
+    }
+
+    db.VideoAbuse.create(videoAbuseData).asCallback(function (err) {
+      if (err) {
+        logger.error('Cannot create remote abuse video.', { error: err })
+      }
+
+      return callback(null)
+    })
+  })
+}
+
+function fetchVideo (podHost, remoteId, callback) {
+  db.Video.loadByHostAndRemoteId(podHost, remoteId, function (err, video) {
+    if (err || !video) {
+      if (!err) err = new Error('video not found')
+
+      logger.error('Cannot load video from host and remote id.', { error: err, podHost, remoteId })
+      return callback(err)
+    }
+
+    return callback(null, video)
+  })
+}
diff --git a/server/controllers/api/requests.js b/server/controllers/api/requests.js
index 52aad6997..1f9193fc8 100644
--- a/server/controllers/api/requests.js
+++ b/server/controllers/api/requests.js
@@ -1,15 +1,13 @@
 'use strict'
 
 const express = require('express')
-const mongoose = require('mongoose')
 
 const constants = require('../../initializers/constants')
+const db = require('../../initializers/database')
 const middlewares = require('../../middlewares')
 const admin = middlewares.admin
 const oAuth = middlewares.oauth
 
-const Request = mongoose.model('Request')
-
 const router = express.Router()
 
 router.get('/stats',
@@ -25,13 +23,13 @@ module.exports = router
 // ---------------------------------------------------------------------------
 
 function getStatsRequests (req, res, next) {
-  Request.list(function (err, requests) {
+  db.Request.countTotalRequests(function (err, totalRequests) {
     if (err) return next(err)
 
     return res.json({
-      requests: requests,
+      totalRequests: totalRequests,
       maxRequestsInParallel: constants.REQUESTS_IN_PARALLEL,
-      remainingMilliSeconds: Request.remainingMilliSeconds(),
+      remainingMilliSeconds: db.Request.remainingMilliSeconds(),
       milliSecondsInterval: constants.REQUESTS_INTERVAL
     })
   })
diff --git a/server/controllers/api/users.js b/server/controllers/api/users.js
index b4d687312..6cd0e84f7 100644
--- a/server/controllers/api/users.js
+++ b/server/controllers/api/users.js
@@ -1,13 +1,12 @@
 'use strict'
 
-const each = require('async/each')
 const express = require('express')
-const mongoose = require('mongoose')
 const waterfall = require('async/waterfall')
 
 const constants = require('../../initializers/constants')
-const friends = require('../../lib/friends')
+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
@@ -17,9 +16,6 @@ const validatorsPagination = middlewares.validators.pagination
 const validatorsSort = middlewares.validators.sort
 const validatorsUsers = middlewares.validators.users
 
-const User = mongoose.model('User')
-const Video = mongoose.model('Video')
-
 const router = express.Router()
 
 router.get('/me', oAuth.authenticate, getUserInformation)
@@ -62,13 +58,13 @@ module.exports = router
 // ---------------------------------------------------------------------------
 
 function createUser (req, res, next) {
-  const user = new User({
+  const user = db.User.build({
     username: req.body.username,
     password: req.body.password,
     role: constants.USER_ROLES.USER
   })
 
-  user.save(function (err, createdUser) {
+  user.save().asCallback(function (err, createdUser) {
     if (err) return next(err)
 
     return res.type('json').status(204).end()
@@ -76,7 +72,7 @@ function createUser (req, res, next) {
 }
 
 function getUserInformation (req, res, next) {
-  User.loadByUsername(res.locals.oauth.token.user.username, function (err, user) {
+  db.User.loadByUsername(res.locals.oauth.token.user.username, function (err, user) {
     if (err) return next(err)
 
     return res.json(user.toFormatedJSON())
@@ -84,48 +80,21 @@ function getUserInformation (req, res, next) {
 }
 
 function listUsers (req, res, next) {
-  User.listForApi(req.query.start, req.query.count, req.query.sort, function (err, usersList, usersTotal) {
+  db.User.listForApi(req.query.start, req.query.count, req.query.sort, function (err, usersList, usersTotal) {
     if (err) return next(err)
 
-    res.json(getFormatedUsers(usersList, usersTotal))
+    res.json(utils.getFormatedObjects(usersList, usersTotal))
   })
 }
 
 function removeUser (req, res, next) {
   waterfall([
-    function getUser (callback) {
-      User.loadById(req.params.id, callback)
-    },
-
-    function getVideos (user, callback) {
-      Video.listOwnedByAuthor(user.username, function (err, videos) {
-        return callback(err, user, videos)
-      })
-    },
-
-    function removeVideosFromDB (user, videos, callback) {
-      each(videos, function (video, callbackEach) {
-        video.remove(callbackEach)
-      }, function (err) {
-        return callback(err, user, videos)
-      })
-    },
-
-    function sendInformationToFriends (user, videos, callback) {
-      videos.forEach(function (video) {
-        const params = {
-          name: video.name,
-          magnetUri: video.magnetUri
-        }
-
-        friends.removeVideoToFriends(params)
-      })
-
-      return callback(null, user)
+    function loadUser (callback) {
+      db.User.loadById(req.params.id, callback)
     },
 
-    function removeUserFromDB (user, callback) {
-      user.remove(callback)
+    function deleteUser (user, callback) {
+      user.destroy().asCallback(callback)
     }
   ], function andFinally (err) {
     if (err) {
@@ -138,11 +107,11 @@ function removeUser (req, res, next) {
 }
 
 function updateUser (req, res, next) {
-  User.loadByUsername(res.locals.oauth.token.user.username, function (err, user) {
+  db.User.loadByUsername(res.locals.oauth.token.user.username, function (err, user) {
     if (err) return next(err)
 
     user.password = req.body.password
-    user.save(function (err) {
+    user.save().asCallback(function (err) {
       if (err) return next(err)
 
       return res.sendStatus(204)
@@ -153,18 +122,3 @@ function updateUser (req, res, next) {
 function success (req, res, next) {
   res.end()
 }
-
-// ---------------------------------------------------------------------------
-
-function getFormatedUsers (users, usersTotal) {
-  const formatedUsers = []
-
-  users.forEach(function (user) {
-    formatedUsers.push(user.toFormatedJSON())
-  })
-
-  return {
-    total: usersTotal,
-    data: formatedUsers
-  }
-}
diff --git a/server/controllers/api/videos.js b/server/controllers/api/videos.js
index daf452573..2c4af520e 100644
--- a/server/controllers/api/videos.js
+++ b/server/controllers/api/videos.js
@@ -2,15 +2,16 @@
 
 const express = require('express')
 const fs = require('fs')
-const mongoose = require('mongoose')
 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 admin = middlewares.admin
 const oAuth = middlewares.oauth
 const pagination = middlewares.pagination
 const validators = middlewares.validators
@@ -22,7 +23,6 @@ const sort = middlewares.sort
 const utils = require('../../helpers/utils')
 
 const router = express.Router()
-const Video = mongoose.model('Video')
 
 // multer configuration
 const storage = multer.diskStorage({
@@ -44,6 +44,21 @@ const storage = multer.diskStorage({
 
 const reqFiles = multer({ storage: storage }).fields([{ name: 'videofile', maxCount: 1 }])
 
+router.get('/abuse',
+  oAuth.authenticate,
+  admin.ensureIsAdmin,
+  validatorsPagination.pagination,
+  validatorsSort.videoAbusesSort,
+  sort.setVideoAbusesSort,
+  pagination.setPagination,
+  listVideoAbuses
+)
+router.post('/:id/abuse',
+  oAuth.authenticate,
+  validatorsVideos.videoAbuseReport,
+  reportVideoAbuseRetryWrapper
+)
+
 router.get('/',
   validatorsPagination.pagination,
   validatorsSort.videosSort,
@@ -51,11 +66,17 @@ router.get('/',
   pagination.setPagination,
   listVideos
 )
+router.put('/:id',
+  oAuth.authenticate,
+  reqFiles,
+  validatorsVideos.videosUpdate,
+  updateVideoRetryWrapper
+)
 router.post('/',
   oAuth.authenticate,
   reqFiles,
   validatorsVideos.videosAdd,
-  addVideo
+  addVideoRetryWrapper
 )
 router.get('/:id',
   validatorsVideos.videosGet,
@@ -82,117 +103,264 @@ module.exports = router
 
 // ---------------------------------------------------------------------------
 
-function addVideo (req, res, next) {
-  const videoFile = req.files.videofile[0]
+// Wrapper to video add that retry the function if there is a database error
+// We need this because we run the transaction in SERIALIZABLE isolation that can fail
+function addVideoRetryWrapper (req, res, next) {
+  utils.transactionRetryer(
+    function (callback) {
+      return addVideo(req, res, req.files.videofile[0], callback)
+    },
+    function (err) {
+      if (err) {
+        logger.error('Cannot insert the video with many retries.', { error: err })
+        return next(err)
+      }
+
+      // TODO : include Location of the new video -> 201
+      return res.type('json').status(204).end()
+    }
+  )
+}
+
+function addVideo (req, res, videoFile, callback) {
   const videoInfos = req.body
 
   waterfall([
-    function createVideoObject (callback) {
-      const id = mongoose.Types.ObjectId()
 
+    function startTransaction (callbackWaterfall) {
+      db.sequelize.transaction({ isolationLevel: 'SERIALIZABLE' }).asCallback(function (err, t) {
+        return callbackWaterfall(err, t)
+      })
+    },
+
+    function findOrCreateAuthor (t, callbackWaterfall) {
+      const user = res.locals.oauth.token.User
+
+      const name = user.username
+      // null because it is OUR pod
+      const podId = null
+      const userId = user.id
+
+      db.Author.findOrCreateAuthor(name, podId, userId, t, function (err, authorInstance) {
+        return callbackWaterfall(err, t, authorInstance)
+      })
+    },
+
+    function findOrCreateTags (t, author, callbackWaterfall) {
+      const tags = videoInfos.tags
+
+      db.Tag.findOrCreateTags(tags, t, function (err, tagInstances) {
+        return callbackWaterfall(err, t, author, tagInstances)
+      })
+    },
+
+    function createVideoObject (t, author, tagInstances, callbackWaterfall) {
       const videoData = {
-        _id: id,
         name: videoInfos.name,
         remoteId: null,
         extname: path.extname(videoFile.filename),
         description: videoInfos.description,
-        author: res.locals.oauth.token.user.username,
         duration: videoFile.duration,
-        tags: videoInfos.tags
+        authorId: author.id
       }
 
-      const video = new Video(videoData)
+      const video = db.Video.build(videoData)
 
-      return callback(null, video)
+      return callbackWaterfall(null, t, author, tagInstances, video)
     },
 
-     // Set the videoname the same as the MongoDB id
-    function renameVideoFile (video, callback) {
+     // Set the videoname the same as the id
+    function renameVideoFile (t, author, tagInstances, video, callbackWaterfall) {
       const videoDir = constants.CONFIG.STORAGE.VIDEOS_DIR
       const source = path.join(videoDir, videoFile.filename)
       const destination = path.join(videoDir, video.getVideoFilename())
 
       fs.rename(source, destination, function (err) {
-        return callback(err, video)
+        if (err) return callbackWaterfall(err)
+
+        // This is important in case if there is another attempt
+        videoFile.filename = video.getVideoFilename()
+        return callbackWaterfall(null, t, author, tagInstances, video)
+      })
+    },
+
+    function insertVideoIntoDB (t, author, tagInstances, video, callbackWaterfall) {
+      const options = { transaction: t }
+
+      // Add tags association
+      video.save(options).asCallback(function (err, videoCreated) {
+        if (err) return callbackWaterfall(err)
+
+        // Do not forget to add Author informations to the created video
+        videoCreated.Author = author
+
+        return callbackWaterfall(err, t, tagInstances, videoCreated)
       })
     },
 
-    function insertIntoDB (video, callback) {
-      video.save(function (err, video) {
-        // Assert there are only one argument sent to the next function (video)
-        return callback(err, video)
+    function associateTagsToVideo (t, tagInstances, video, callbackWaterfall) {
+      const options = { transaction: t }
+
+      video.setTags(tagInstances, options).asCallback(function (err) {
+        video.Tags = tagInstances
+
+        return callbackWaterfall(err, t, video)
       })
     },
 
-    function sendToFriends (video, callback) {
-      video.toRemoteJSON(function (err, remoteVideo) {
-        if (err) return callback(err)
+    function sendToFriends (t, video, callbackWaterfall) {
+      video.toAddRemoteJSON(function (err, remoteVideo) {
+        if (err) return callbackWaterfall(err)
 
         // Now we'll add the video's meta data to our friends
-        friends.addVideoToFriends(remoteVideo)
-
-        return callback(null)
+        friends.addVideoToFriends(remoteVideo, t, function (err) {
+          return callbackWaterfall(err, t)
+        })
       })
     }
 
-  ], function andFinally (err) {
+  ], function andFinally (err, t) {
     if (err) {
-      logger.error('Cannot insert the video.')
-      return next(err)
+      // This is just a debug because we will retry the insert
+      logger.debug('Cannot insert the video.', { error: err })
+
+      // Abort transaction?
+      if (t) t.rollback()
+
+      return callback(err)
     }
 
-    // TODO : include Location of the new video -> 201
-    return res.type('json').status(204).end()
+    // Commit transaction
+    t.commit().asCallback(function (err) {
+      if (err) return callback(err)
+
+      logger.info('Video with name %s created.', videoInfos.name)
+      return callback(null)
+    })
   })
 }
 
-function getVideo (req, res, next) {
-  Video.load(req.params.id, function (err, video) {
-    if (err) return next(err)
+function updateVideoRetryWrapper (req, res, next) {
+  utils.transactionRetryer(
+    function (callback) {
+      return updateVideo(req, res, callback)
+    },
+    function (err) {
+      if (err) {
+        logger.error('Cannot update the video with many retries.', { error: err })
+        return next(err)
+      }
 
-    if (!video) {
+      // TODO : include Location of the new video -> 201
       return res.type('json').status(204).end()
     }
-
-    res.json(video.toFormatedJSON())
-  })
+  )
 }
 
-function listVideos (req, res, next) {
-  Video.listForApi(req.query.start, req.query.count, req.query.sort, function (err, videosList, videosTotal) {
-    if (err) return next(err)
+function updateVideo (req, res, finalCallback) {
+  const videoInstance = res.locals.video
+  const videoFieldsSave = videoInstance.toJSON()
+  const videoInfosToUpdate = req.body
 
-    res.json(getFormatedVideos(videosList, videosTotal))
-  })
-}
+  waterfall([
 
-function removeVideo (req, res, next) {
-  const videoId = req.params.id
+    function startTransaction (callback) {
+      db.sequelize.transaction({ isolationLevel: 'SERIALIZABLE' }).asCallback(function (err, t) {
+        return callback(err, t)
+      })
+    },
 
-  waterfall([
-    function getVideo (callback) {
-      Video.load(videoId, callback)
+    function findOrCreateTags (t, callback) {
+      if (videoInfosToUpdate.tags) {
+        db.Tag.findOrCreateTags(videoInfosToUpdate.tags, t, function (err, tagInstances) {
+          return callback(err, t, tagInstances)
+        })
+      } else {
+        return callback(null, t, null)
+      }
     },
 
-    function removeFromDB (video, callback) {
-      video.remove(function (err) {
-        if (err) return callback(err)
+    function updateVideoIntoDB (t, tagInstances, callback) {
+      const options = {
+        transaction: t
+      }
+
+      if (videoInfosToUpdate.name) videoInstance.set('name', videoInfosToUpdate.name)
+      if (videoInfosToUpdate.description) videoInstance.set('description', videoInfosToUpdate.description)
 
-        return callback(null, video)
+      videoInstance.save(options).asCallback(function (err) {
+        return callback(err, t, tagInstances)
       })
     },
 
-    function sendInformationToFriends (video, callback) {
-      const params = {
-        name: video.name,
-        remoteId: video._id
+    function associateTagsToVideo (t, tagInstances, callback) {
+      if (tagInstances) {
+        const options = { transaction: t }
+
+        videoInstance.setTags(tagInstances, options).asCallback(function (err) {
+          videoInstance.Tags = tagInstances
+
+          return callback(err, t)
+        })
+      } else {
+        return callback(null, t)
       }
+    },
 
-      friends.removeVideoToFriends(params)
+    function sendToFriends (t, callback) {
+      const json = videoInstance.toUpdateRemoteJSON()
 
-      return callback(null)
+      // Now we'll update the video's meta data to our friends
+      friends.updateVideoToFriends(json, t, function (err) {
+        return callback(err, t)
+      })
+    }
+
+  ], function andFinally (err, t) {
+    if (err) {
+      logger.debug('Cannot update the video.', { error: err })
+
+      // Abort transaction?
+      if (t) t.rollback()
+
+      // Force fields we want to update
+      // If the transaction is retried, sequelize will think the object has not changed
+      // So it will skip the SQL request, even if the last one was ROLLBACKed!
+      Object.keys(videoFieldsSave).forEach(function (key) {
+        const value = videoFieldsSave[key]
+        videoInstance.set(key, value)
+      })
+
+      return finalCallback(err)
     }
-  ], function andFinally (err) {
+
+    // Commit transaction
+    t.commit().asCallback(function (err) {
+      if (err) return finalCallback(err)
+
+      logger.info('Video with name %s updated.', videoInfosToUpdate.name)
+      return finalCallback(null)
+    })
+  })
+}
+
+function getVideo (req, res, next) {
+  const videoInstance = res.locals.video
+  res.json(videoInstance.toFormatedJSON())
+}
+
+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))
+  })
+}
+
+function removeVideo (req, res, next) {
+  const videoInstance = res.locals.video
+
+  videoInstance.destroy().asCallback(function (err) {
     if (err) {
       logger.error('Errors when removed the video.', { error: err })
       return next(err)
@@ -203,25 +371,97 @@ function removeVideo (req, res, next) {
 }
 
 function searchVideos (req, res, next) {
-  Video.search(req.params.value, req.query.field, req.query.start, req.query.count, req.query.sort,
-  function (err, videosList, videosTotal) {
+  db.Video.searchAndPopulateAuthorAndPodAndTags(
+    req.params.value, req.query.field, req.query.start, req.query.count, req.query.sort,
+    function (err, videosList, videosTotal) {
+      if (err) return next(err)
+
+      res.json(utils.getFormatedObjects(videosList, videosTotal))
+    }
+  )
+}
+
+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(getFormatedVideos(videosList, videosTotal))
+    res.json(utils.getFormatedObjects(abusesList, abusesTotal))
   })
 }
 
-// ---------------------------------------------------------------------------
+function reportVideoAbuseRetryWrapper (req, res, next) {
+  utils.transactionRetryer(
+    function (callback) {
+      return reportVideoAbuse(req, res, callback)
+    },
+    function (err) {
+      if (err) {
+        logger.error('Cannot report abuse to the video with many retries.', { error: err })
+        return next(err)
+      }
 
-function getFormatedVideos (videos, videosTotal) {
-  const formatedVideos = []
+      return res.type('json').status(204).end()
+    }
+  )
+}
 
-  videos.forEach(function (video) {
-    formatedVideos.push(video.toFormatedJSON())
-  })
+function reportVideoAbuse (req, res, finalCallback) {
+  const videoInstance = res.locals.video
+  const reporterUsername = res.locals.oauth.token.User.username
 
-  return {
-    total: videosTotal,
-    data: formatedVideos
+  const abuse = {
+    reporterUsername,
+    reason: req.body.reason,
+    videoId: videoInstance.id,
+    reporterPodId: null // This is our pod that reported this abuse
   }
+
+  waterfall([
+
+    function startTransaction (callback) {
+      db.sequelize.transaction().asCallback(function (err, t) {
+        return callback(err, t)
+      })
+    },
+
+    function createAbuse (t, callback) {
+      db.VideoAbuse.create(abuse).asCallback(function (err, abuse) {
+        return callback(err, t, abuse)
+      })
+    },
+
+    function sendToFriendsIfNeeded (t, abuse, callback) {
+      // We send the information to the destination pod
+      if (videoInstance.isOwned() === false) {
+        const reportData = {
+          reporterUsername,
+          reportReason: abuse.reason,
+          videoRemoteId: videoInstance.remoteId
+        }
+
+        friends.reportAbuseVideoToFriend(reportData, videoInstance)
+      }
+
+      return callback(null, t)
+    }
+
+  ], function andFinally (err, t) {
+    if (err) {
+      logger.debug('Cannot update the video.', { error: err })
+
+      // Abort transaction?
+      if (t) t.rollback()
+
+      return finalCallback(err)
+    }
+
+    // Commit transaction
+    t.commit().asCallback(function (err) {
+      if (err) return finalCallback(err)
+
+      logger.info('Abuse report for video %s created.', videoInstance.name)
+      return finalCallback(null)
+    })
+  })
 }
+
diff --git a/server/controllers/client.js b/server/controllers/client.js
index 572db6133..8c242af07 100644
--- a/server/controllers/client.js
+++ b/server/controllers/client.js
@@ -3,13 +3,12 @@
 const parallel = require('async/parallel')
 const express = require('express')
 const fs = require('fs')
-const mongoose = require('mongoose')
 const path = require('path')
 const validator = require('express-validator').validator
 
 const constants = require('../initializers/constants')
+const db = require('../initializers/database')
 
-const Video = mongoose.model('Video')
 const router = express.Router()
 
 const opengraphComment = '<!-- opengraph tags -->'
@@ -45,14 +44,14 @@ function addOpenGraphTags (htmlStringPage, video) {
   if (video.isOwned()) {
     basePreviewUrlHttp = constants.CONFIG.WEBSERVER.URL
   } else {
-    basePreviewUrlHttp = constants.REMOTE_SCHEME.HTTP + '://' + video.podHost
+    basePreviewUrlHttp = constants.REMOTE_SCHEME.HTTP + '://' + video.Author.Pod.host
   }
 
   // We fetch the remote preview (bigger than the thumbnail)
   // This should not overhead the remote server since social websites put in a cache the OpenGraph tags
   // We can't use the thumbnail because these social websites want bigger images (> 200x200 for Facebook for example)
   const previewUrl = basePreviewUrlHttp + constants.STATIC_PATHS.PREVIEWS + video.getPreviewName()
-  const videoUrl = constants.CONFIG.WEBSERVER.URL + '/videos/watch/' + video._id
+  const videoUrl = constants.CONFIG.WEBSERVER.URL + '/videos/watch/' + video.id
 
   const metaTags = {
     'og:type': 'video',
@@ -86,7 +85,7 @@ function generateWatchHtmlPage (req, res, next) {
   const videoId = req.params.id
 
   // Let Angular application handle errors
-  if (!validator.isMongoId(videoId)) return res.sendFile(indexPath)
+  if (!validator.isUUID(videoId, 4)) return res.sendFile(indexPath)
 
   parallel({
     file: function (callback) {
@@ -94,7 +93,7 @@ function generateWatchHtmlPage (req, res, next) {
     },
 
     video: function (callback) {
-      Video.load(videoId, callback)
+      db.Video.loadAndPopulateAuthorAndPodAndTags(videoId, callback)
     }
   }, function (err, results) {
     if (err) return next(err)