server/controllers/api/videos.js

   1 'use strict'
   2
   3 const express = require('express')
   4 const fs = require('fs')
   5 const multer = require('multer')
   6 const path = require('path')
   7 const waterfall = require('async/waterfall')
   8
   9 const constants = require('../../initializers/constants')
  10 const db = require('../../initializers/database')
  11 const logger = require('../../helpers/logger')
  12 const friends = require('../../lib/friends')
  13 const middlewares = require('../../middlewares')
  14 const admin = middlewares.admin
  15 const oAuth = middlewares.oauth
  16 const pagination = middlewares.pagination
  17 const validators = middlewares.validators
  18 const validatorsPagination = validators.pagination
  19 const validatorsSort = validators.sort
  20 const validatorsVideos = validators.videos
  21 const search = middlewares.search
  22 const sort = middlewares.sort
  23 const utils = require('../../helpers/utils')
  24
  25 const router = express.Router()
  26
  27 // multer configuration
  28 const storage = multer.diskStorage({
  29   destination: function (req, file, cb) {
  30     cb(null, constants.CONFIG.STORAGE.VIDEOS_DIR)
  31   },
  32
  33   filename: function (req, file, cb) {
  34     let extension = ''
  35     if (file.mimetype === 'video/webm') extension = 'webm'
  36     else if (file.mimetype === 'video/mp4') extension = 'mp4'
  37     else if (file.mimetype === 'video/ogg') extension = 'ogv'
  38     utils.generateRandomString(16, function (err, randomString) {
  39       const fieldname = err ? undefined : randomString
  40       cb(null, fieldname + '.' + extension)
  41     })
  42   }
  43 })
  44
  45 const reqFiles = multer({ storage: storage }).fields([{ name: 'videofile', maxCount: 1 }])
  46
  47 router.get('/abuse',
  48   oAuth.authenticate,
  49   admin.ensureIsAdmin,
  50   validatorsPagination.pagination,
  51   validatorsSort.videoAbusesSort,
  52   sort.setVideoAbusesSort,
  53   pagination.setPagination,
  54   listVideoAbuses
  55 )
  56 router.post('/:id/abuse',
  57   oAuth.authenticate,
  58   validatorsVideos.videoAbuseReport,
  59   reportVideoAbuseRetryWrapper
  60 )
  61
  62 router.get('/',
  63   validatorsPagination.pagination,
  64   validatorsSort.videosSort,
  65   sort.setVideosSort,
  66   pagination.setPagination,
  67   listVideos
  68 )
  69 router.put('/:id',
  70   oAuth.authenticate,
  71   reqFiles,
  72   validatorsVideos.videosUpdate,
  73   updateVideoRetryWrapper
  74 )
  75 router.post('/',
  76   oAuth.authenticate,
  77   reqFiles,
  78   validatorsVideos.videosAdd,
  79   addVideoRetryWrapper
  80 )
  81 router.get('/:id',
  82   validatorsVideos.videosGet,
  83   getVideo
  84 )
  85 router.delete('/:id',
  86   oAuth.authenticate,
  87   validatorsVideos.videosRemove,
  88   removeVideo
  89 )
  90 router.get('/search/:value',
  91   validatorsVideos.videosSearch,
  92   validatorsPagination.pagination,
  93   validatorsSort.videosSort,
  94   sort.setVideosSort,
  95   pagination.setPagination,
  96   search.setVideosSearch,
  97   searchVideos
  98 )
  99
 100 // ---------------------------------------------------------------------------
 101
 102 module.exports = router
 103
 104 // ---------------------------------------------------------------------------
 105
 106 // Wrapper to video add that retry the function if there is a database error
 107 // We need this because we run the transaction in SERIALIZABLE isolation that can fail
 108 function addVideoRetryWrapper (req, res, next) {
 109   utils.transactionRetryer(
 110     function (callback) {
 111       return addVideo(req, res, req.files.videofile[0], callback)
 112     },
 113     function (err) {
 114       if (err) {
 115         logger.error('Cannot insert the video with many retries.', { error: err })
 116         return next(err)
 117       }
 118
 119       // TODO : include Location of the new video -> 201
 120       return res.type('json').status(204).end()
 121     }
 122   )
 123 }
 124
 125 function addVideo (req, res, videoFile, callback) {
 126   const videoInfos = req.body
 127
 128   waterfall([
 129
 130     function startTransaction (callbackWaterfall) {
 131       db.sequelize.transaction({ isolationLevel: 'SERIALIZABLE' }).asCallback(function (err, t) {
 132         return callbackWaterfall(err, t)
 133       })
 134     },
 135
 136     function findOrCreateAuthor (t, callbackWaterfall) {
 137       const user = res.locals.oauth.token.User
 138
 139       const name = user.username
 140       // null because it is OUR pod
 141       const podId = null
 142       const userId = user.id
 143
 144       db.Author.findOrCreateAuthor(name, podId, userId, t, function (err, authorInstance) {
 145         return callbackWaterfall(err, t, authorInstance)
 146       })
 147     },
 148
 149     function findOrCreateTags (t, author, callbackWaterfall) {
 150       const tags = videoInfos.tags
 151
 152       db.Tag.findOrCreateTags(tags, t, function (err, tagInstances) {
 153         return callbackWaterfall(err, t, author, tagInstances)
 154       })
 155     },
 156
 157     function createVideoObject (t, author, tagInstances, callbackWaterfall) {
 158       const videoData = {
 159         name: videoInfos.name,
 160         remoteId: null,
 161         extname: path.extname(videoFile.filename),
 162         description: videoInfos.description,
 163         duration: videoFile.duration,
 164         authorId: author.id
 165       }
 166
 167       const video = db.Video.build(videoData)
 168
 169       return callbackWaterfall(null, t, author, tagInstances, video)
 170     },
 171
 172      // Set the videoname the same as the id
 173     function renameVideoFile (t, author, tagInstances, video, callbackWaterfall) {
 174       const videoDir = constants.CONFIG.STORAGE.VIDEOS_DIR
 175       const source = path.join(videoDir, videoFile.filename)
 176       const destination = path.join(videoDir, video.getVideoFilename())
 177
 178       fs.rename(source, destination, function (err) {
 179         if (err) return callbackWaterfall(err)
 180
 181         // This is important in case if there is another attempt
 182         videoFile.filename = video.getVideoFilename()
 183         return callbackWaterfall(null, t, author, tagInstances, video)
 184       })
 185     },
 186
 187     function insertVideoIntoDB (t, author, tagInstances, video, callbackWaterfall) {
 188       const options = { transaction: t }
 189
 190       // Add tags association
 191       video.save(options).asCallback(function (err, videoCreated) {
 192         if (err) return callbackWaterfall(err)
 193
 194         // Do not forget to add Author informations to the created video
 195         videoCreated.Author = author
 196
 197         return callbackWaterfall(err, t, tagInstances, videoCreated)
 198       })
 199     },
 200
 201     function associateTagsToVideo (t, tagInstances, video, callbackWaterfall) {
 202       const options = { transaction: t }
 203
 204       video.setTags(tagInstances, options).asCallback(function (err) {
 205         video.Tags = tagInstances
 206
 207         return callbackWaterfall(err, t, video)
 208       })
 209     },
 210
 211     function sendToFriends (t, video, callbackWaterfall) {
 212       video.toAddRemoteJSON(function (err, remoteVideo) {
 213         if (err) return callbackWaterfall(err)
 214
 215         // Now we'll add the video's meta data to our friends
 216         friends.addVideoToFriends(remoteVideo, t, function (err) {
 217           return callbackWaterfall(err, t)
 218         })
 219       })
 220     }
 221
 222   ], function andFinally (err, t) {
 223     if (err) {
 224       // This is just a debug because we will retry the insert
 225       logger.debug('Cannot insert the video.', { error: err })
 226
 227       // Abort transaction?
 228       if (t) t.rollback()
 229
 230       return callback(err)
 231     }
 232
 233     // Commit transaction
 234     t.commit().asCallback(function (err) {
 235       if (err) return callback(err)
 236
 237       logger.info('Video with name %s created.', videoInfos.name)
 238       return callback(null)
 239     })
 240   })
 241 }
 242
 243 function updateVideoRetryWrapper (req, res, next) {
 244   utils.transactionRetryer(
 245     function (callback) {
 246       return updateVideo(req, res, callback)
 247     },
 248     function (err) {
 249       if (err) {
 250         logger.error('Cannot update the video with many retries.', { error: err })
 251         return next(err)
 252       }
 253
 254       // TODO : include Location of the new video -> 201
 255       return res.type('json').status(204).end()
 256     }
 257   )
 258 }
 259
 260 function updateVideo (req, res, finalCallback) {
 261   const videoInstance = res.locals.video
 262   const videoFieldsSave = videoInstance.toJSON()
 263   const videoInfosToUpdate = req.body
 264
 265   waterfall([
 266
 267     function startTransaction (callback) {
 268       db.sequelize.transaction({ isolationLevel: 'SERIALIZABLE' }).asCallback(function (err, t) {
 269         return callback(err, t)
 270       })
 271     },
 272
 273     function findOrCreateTags (t, callback) {
 274       if (videoInfosToUpdate.tags) {
 275         db.Tag.findOrCreateTags(videoInfosToUpdate.tags, t, function (err, tagInstances) {
 276           return callback(err, t, tagInstances)
 277         })
 278       } else {
 279         return callback(null, t, null)
 280       }
 281     },
 282
 283     function updateVideoIntoDB (t, tagInstances, callback) {
 284       const options = {
 285         transaction: t
 286       }
 287
 288       if (videoInfosToUpdate.name) videoInstance.set('name', videoInfosToUpdate.name)
 289       if (videoInfosToUpdate.description) videoInstance.set('description', videoInfosToUpdate.description)
 290
 291       videoInstance.save(options).asCallback(function (err) {
 292         return callback(err, t, tagInstances)
 293       })
 294     },
 295
 296     function associateTagsToVideo (t, tagInstances, callback) {
 297       if (tagInstances) {
 298         const options = { transaction: t }
 299
 300         videoInstance.setTags(tagInstances, options).asCallback(function (err) {
 301           videoInstance.Tags = tagInstances
 302
 303           return callback(err, t)
 304         })
 305       } else {
 306         return callback(null, t)
 307       }
 308     },
 309
 310     function sendToFriends (t, callback) {
 311       const json = videoInstance.toUpdateRemoteJSON()
 312
 313       // Now we'll update the video's meta data to our friends
 314       friends.updateVideoToFriends(json, t, function (err) {
 315         return callback(err, t)
 316       })
 317     }
 318
 319   ], function andFinally (err, t) {
 320     if (err) {
 321       logger.debug('Cannot update the video.', { error: err })
 322
 323       // Abort transaction?
 324       if (t) t.rollback()
 325
 326       // Force fields we want to update
 327       // If the transaction is retried, sequelize will think the object has not changed
 328       // So it will skip the SQL request, even if the last one was ROLLBACKed!
 329       Object.keys(videoFieldsSave).forEach(function (key) {
 330         const value = videoFieldsSave[key]
 331         videoInstance.set(key, value)
 332       })
 333
 334       return finalCallback(err)
 335     }
 336
 337     // Commit transaction
 338     t.commit().asCallback(function (err) {
 339       if (err) return finalCallback(err)
 340
 341       logger.info('Video with name %s updated.', videoInfosToUpdate.name)
 342       return finalCallback(null)
 343     })
 344   })
 345 }
 346
 347 function getVideo (req, res, next) {
 348   const videoInstance = res.locals.video
 349   res.json(videoInstance.toFormatedJSON())
 350 }
 351
 352 function listVideos (req, res, next) {
 353   db.Video.listForApi(req.query.start, req.query.count, req.query.sort, function (err, videosList, videosTotal) {
 354     if (err) return next(err)
 355
 356     res.json(utils.getFormatedObjects(videosList, videosTotal))
 357   })
 358 }
 359
 360 function removeVideo (req, res, next) {
 361   const videoInstance = res.locals.video
 362
 363   videoInstance.destroy().asCallback(function (err) {
 364     if (err) {
 365       logger.error('Errors when removed the video.', { error: err })
 366       return next(err)
 367     }
 368
 369     return res.type('json').status(204).end()
 370   })
 371 }
 372
 373 function searchVideos (req, res, next) {
 374   db.Video.searchAndPopulateAuthorAndPodAndTags(
 375     req.params.value, req.query.field, req.query.start, req.query.count, req.query.sort,
 376     function (err, videosList, videosTotal) {
 377       if (err) return next(err)
 378
 379       res.json(utils.getFormatedObjects(videosList, videosTotal))
 380     }
 381   )
 382 }
 383
 384 function listVideoAbuses (req, res, next) {
 385   db.VideoAbuse.listForApi(req.query.start, req.query.count, req.query.sort, function (err, abusesList, abusesTotal) {
 386     if (err) return next(err)
 387
 388     res.json(utils.getFormatedObjects(abusesList, abusesTotal))
 389   })
 390 }
 391
 392 function reportVideoAbuseRetryWrapper (req, res, next) {
 393   utils.transactionRetryer(
 394     function (callback) {
 395       return reportVideoAbuse(req, res, callback)
 396     },
 397     function (err) {
 398       if (err) {
 399         logger.error('Cannot report abuse to the video with many retries.', { error: err })
 400         return next(err)
 401       }
 402
 403       return res.type('json').status(204).end()
 404     }
 405   )
 406 }
 407
 408 function reportVideoAbuse (req, res, finalCallback) {
 409   const videoInstance = res.locals.video
 410   const reporterUsername = res.locals.oauth.token.User.username
 411
 412   const abuse = {
 413     reporterUsername,
 414     reason: req.body.reason,
 415     videoId: videoInstance.id,
 416     reporterPodId: null // This is our pod that reported this abuse
 417   }
 418
 419   waterfall([
 420
 421     function startTransaction (callback) {
 422       db.sequelize.transaction().asCallback(function (err, t) {
 423         return callback(err, t)
 424       })
 425     },
 426
 427     function createAbuse (t, callback) {
 428       db.VideoAbuse.create(abuse).asCallback(function (err, abuse) {
 429         return callback(err, t, abuse)
 430       })
 431     },
 432
 433     function sendToFriendsIfNeeded (t, abuse, callback) {
 434       // We send the information to the destination pod
 435       if (videoInstance.isOwned() === false) {
 436         const reportData = {
 437           reporterUsername,
 438           reportReason: abuse.reason,
 439           videoRemoteId: videoInstance.remoteId
 440         }
 441
 442         friends.reportAbuseVideoToFriend(reportData, videoInstance)
 443       }
 444
 445       return callback(null, t)
 446     }
 447
 448   ], function andFinally (err, t) {
 449     if (err) {
 450       logger.debug('Cannot update the video.', { error: err })
 451
 452       // Abort transaction?
 453       if (t) t.rollback()
 454
 455       return finalCallback(err)
 456     }
 457
 458     // Commit transaction
 459     t.commit().asCallback(function (err) {
 460       if (err) return finalCallback(err)
 461
 462       logger.info('Abuse report for video %s created.', videoInstance.name)
 463       return finalCallback(null)
 464     })
 465   })
 466 }
 467