server/controllers/api/videos/index.ts

   1 import * as express from 'express'
   2 import * as Promise from 'bluebird'
   3 import * as multer from 'multer'
   4 import { extname, join } from 'path'
   5
   6 import { database as db } from '../../../initializers/database'
   7 import {
   8   CONFIG,
   9   REQUEST_VIDEO_QADU_TYPES,
  10   REQUEST_VIDEO_EVENT_TYPES,
  11   VIDEO_CATEGORIES,
  12   VIDEO_LICENCES,
  13   VIDEO_LANGUAGES
  14 } from '../../../initializers'
  15 import {
  16   addEventToRemoteVideo,
  17   quickAndDirtyUpdateVideoToFriends,
  18   addVideoToFriends,
  19   updateVideoToFriends,
  20   JobScheduler
  21 } from '../../../lib'
  22 import {
  23   authenticate,
  24   paginationValidator,
  25   videosSortValidator,
  26   setVideosSort,
  27   setPagination,
  28   setVideosSearch,
  29   videosUpdateValidator,
  30   videosSearchValidator,
  31   videosAddValidator,
  32   videosGetValidator,
  33   videosRemoveValidator
  34 } from '../../../middlewares'
  35 import {
  36   logger,
  37   retryTransactionWrapper,
  38   generateRandomString,
  39   getFormattedObjects,
  40   renamePromise
  41 } from '../../../helpers'
  42 import { TagInstance } from '../../../models'
  43 import { VideoCreate, VideoUpdate } from '../../../../shared'
  44
  45 import { abuseVideoRouter } from './abuse'
  46 import { blacklistRouter } from './blacklist'
  47 import { rateVideoRouter } from './rate'
  48
  49 const videosRouter = express.Router()
  50
  51 // multer configuration
  52 const storage = multer.diskStorage({
  53   destination: (req, file, cb) => {
  54     cb(null, CONFIG.STORAGE.VIDEOS_DIR)
  55   },
  56
  57   filename: (req, file, cb) => {
  58     let extension = ''
  59     if (file.mimetype === 'video/webm') extension = 'webm'
  60     else if (file.mimetype === 'video/mp4') extension = 'mp4'
  61     else if (file.mimetype === 'video/ogg') extension = 'ogv'
  62     generateRandomString(16)
  63       .then(randomString => {
  64         cb(null, randomString + '.' + extension)
  65       })
  66       .catch(err => {
  67         logger.error('Cannot generate random string for file name.', err)
  68         throw err
  69       })
  70   }
  71 })
  72
  73 const reqFiles = multer({ storage: storage }).fields([{ name: 'videofile', maxCount: 1 }])
  74
  75 videosRouter.use('/', abuseVideoRouter)
  76 videosRouter.use('/', blacklistRouter)
  77 videosRouter.use('/', rateVideoRouter)
  78
  79 videosRouter.get('/categories', listVideoCategories)
  80 videosRouter.get('/licences', listVideoLicences)
  81 videosRouter.get('/languages', listVideoLanguages)
  82
  83 videosRouter.get('/',
  84   paginationValidator,
  85   videosSortValidator,
  86   setVideosSort,
  87   setPagination,
  88   listVideos
  89 )
  90 videosRouter.put('/:id',
  91   authenticate,
  92   videosUpdateValidator,
  93   updateVideoRetryWrapper
  94 )
  95 videosRouter.post('/',
  96   authenticate,
  97   reqFiles,
  98   videosAddValidator,
  99   addVideoRetryWrapper
 100 )
 101 videosRouter.get('/:id',
 102   videosGetValidator,
 103   getVideo
 104 )
 105
 106 videosRouter.delete('/:id',
 107   authenticate,
 108   videosRemoveValidator,
 109   removeVideo
 110 )
 111
 112 videosRouter.get('/search/:value',
 113   videosSearchValidator,
 114   paginationValidator,
 115   videosSortValidator,
 116   setVideosSort,
 117   setPagination,
 118   setVideosSearch,
 119   searchVideos
 120 )
 121
 122 // ---------------------------------------------------------------------------
 123
 124 export {
 125   videosRouter
 126 }
 127
 128 // ---------------------------------------------------------------------------
 129
 130 function listVideoCategories (req: express.Request, res: express.Response) {
 131   res.json(VIDEO_CATEGORIES)
 132 }
 133
 134 function listVideoLicences (req: express.Request, res: express.Response) {
 135   res.json(VIDEO_LICENCES)
 136 }
 137
 138 function listVideoLanguages (req: express.Request, res: express.Response) {
 139   res.json(VIDEO_LANGUAGES)
 140 }
 141
 142 // Wrapper to video add that retry the function if there is a database error
 143 // We need this because we run the transaction in SERIALIZABLE isolation that can fail
 144 function addVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
 145   const options = {
 146     arguments: [ req, res, req.files['videofile'][0] ],
 147     errorMessage: 'Cannot insert the video with many retries.'
 148   }
 149
 150   retryTransactionWrapper(addVideo, options)
 151     .then(() => {
 152       // TODO : include Location of the new video -> 201
 153       res.type('json').status(204).end()
 154     })
 155     .catch(err => next(err))
 156 }
 157
 158 function addVideo (req: express.Request, res: express.Response, videoPhysicalFile: Express.Multer.File) {
 159   const videoInfo: VideoCreate = req.body
 160
 161   return db.sequelize.transaction(t => {
 162     const user = res.locals.oauth.token.User
 163
 164     const name = user.username
 165     // null because it is OUR pod
 166     const podId = null
 167     const userId = user.id
 168
 169     return db.Author.findOrCreateAuthor(name, podId, userId, t)
 170       .then(author => {
 171         const tags = videoInfo.tags
 172         if (!tags) return { author, tagInstances: undefined }
 173
 174         return db.Tag.findOrCreateTags(tags, t).then(tagInstances => ({ author, tagInstances }))
 175       })
 176       .then(({ author, tagInstances }) => {
 177         const videoData = {
 178           name: videoInfo.name,
 179           remote: false,
 180           extname: extname(videoPhysicalFile.filename),
 181           category: videoInfo.category,
 182           licence: videoInfo.licence,
 183           language: videoInfo.language,
 184           nsfw: videoInfo.nsfw,
 185           description: videoInfo.description,
 186           duration: videoPhysicalFile['duration'], // duration was added by a previous middleware
 187           authorId: author.id
 188         }
 189
 190         const video = db.Video.build(videoData)
 191         return { author, tagInstances, video }
 192       })
 193       .then(({ author, tagInstances, video }) => {
 194         const videoFileData = {
 195           extname: extname(videoPhysicalFile.filename),
 196           resolution: 0, // TODO: improve readability,
 197           size: videoPhysicalFile.size
 198         }
 199
 200         const videoFile = db.VideoFile.build(videoFileData)
 201         return { author, tagInstances, video, videoFile }
 202       })
 203       .then(({ author, tagInstances, video, videoFile }) => {
 204         const videoDir = CONFIG.STORAGE.VIDEOS_DIR
 205         const source = join(videoDir, videoPhysicalFile.filename)
 206         const destination = join(videoDir, video.getVideoFilename(videoFile))
 207
 208         return renamePromise(source, destination)
 209           .then(() => {
 210             // This is important in case if there is another attempt in the retry process
 211             videoPhysicalFile.filename = video.getVideoFilename(videoFile)
 212             return { author, tagInstances, video, videoFile }
 213           })
 214       })
 215       .then(({ author, tagInstances, video, videoFile }) => {
 216         const tasks = []
 217
 218         tasks.push(
 219           video.createTorrentAndSetInfoHash(videoFile),
 220           video.createThumbnail(videoFile),
 221           video.createPreview(videoFile)
 222         )
 223
 224         if (CONFIG.TRANSCODING.ENABLED === true) {
 225           // Put uuid because we don't have id auto incremented for now
 226           const dataInput = {
 227             videoUUID: video.uuid
 228           }
 229
 230           tasks.push(
 231             JobScheduler.Instance.createJob(t, 'videoTranscoder', dataInput)
 232           )
 233         }
 234
 235         return Promise.all(tasks).then(() => ({ author, tagInstances, video, videoFile }))
 236       })
 237       .then(({ author, tagInstances, video, videoFile }) => {
 238         const options = { transaction: t }
 239
 240         return video.save(options)
 241           .then(videoCreated => {
 242             // Do not forget to add Author information to the created video
 243             videoCreated.Author = author
 244
 245             return { tagInstances, video: videoCreated, videoFile }
 246           })
 247       })
 248       .then(({ tagInstances, video, videoFile }) => {
 249         const options = { transaction: t }
 250         videoFile.videoId = video.id
 251
 252         return videoFile.save(options)
 253           .then(() => video.VideoFiles = [ videoFile ])
 254           .then(() => ({ tagInstances, video }))
 255       })
 256       .then(({ tagInstances, video }) => {
 257         if (!tagInstances) return video
 258
 259         const options = { transaction: t }
 260         return video.setTags(tagInstances, options)
 261           .then(() => {
 262             video.Tags = tagInstances
 263             return video
 264           })
 265       })
 266       .then(video => {
 267         // Let transcoding job send the video to friends because the video file extension might change
 268         if (CONFIG.TRANSCODING.ENABLED === true) return undefined
 269
 270         return video.toAddRemoteJSON()
 271           .then(remoteVideo => {
 272             // Now we'll add the video's meta data to our friends
 273             return addVideoToFriends(remoteVideo, t)
 274           })
 275       })
 276   })
 277   .then(() => logger.info('Video with name %s created.', videoInfo.name))
 278   .catch((err: Error) => {
 279     logger.debug('Cannot insert the video.', err)
 280     throw err
 281   })
 282 }
 283
 284 function updateVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
 285   const options = {
 286     arguments: [ req, res ],
 287     errorMessage: 'Cannot update the video with many retries.'
 288   }
 289
 290   retryTransactionWrapper(updateVideo, options)
 291     .then(() => {
 292       // TODO : include Location of the new video -> 201
 293       return res.type('json').status(204).end()
 294     })
 295     .catch(err => next(err))
 296 }
 297
 298 function updateVideo (req: express.Request, res: express.Response) {
 299   const videoInstance = res.locals.video
 300   const videoFieldsSave = videoInstance.toJSON()
 301   const videoInfoToUpdate: VideoUpdate = req.body
 302
 303   return db.sequelize.transaction(t => {
 304     let tagsPromise: Promise<TagInstance[]>
 305     if (!videoInfoToUpdate.tags) {
 306       tagsPromise = Promise.resolve(null)
 307     } else {
 308       tagsPromise = db.Tag.findOrCreateTags(videoInfoToUpdate.tags, t)
 309     }
 310
 311     return tagsPromise
 312       .then(tagInstances => {
 313         const options = {
 314           transaction: t
 315         }
 316
 317         if (videoInfoToUpdate.name !== undefined) videoInstance.set('name', videoInfoToUpdate.name)
 318         if (videoInfoToUpdate.category !== undefined) videoInstance.set('category', videoInfoToUpdate.category)
 319         if (videoInfoToUpdate.licence !== undefined) videoInstance.set('licence', videoInfoToUpdate.licence)
 320         if (videoInfoToUpdate.language !== undefined) videoInstance.set('language', videoInfoToUpdate.language)
 321         if (videoInfoToUpdate.nsfw !== undefined) videoInstance.set('nsfw', videoInfoToUpdate.nsfw)
 322         if (videoInfoToUpdate.description !== undefined) videoInstance.set('description', videoInfoToUpdate.description)
 323
 324         return videoInstance.save(options).then(() => tagInstances)
 325       })
 326       .then(tagInstances => {
 327         if (!tagInstances) return
 328
 329         const options = { transaction: t }
 330         return videoInstance.setTags(tagInstances, options)
 331           .then(() => {
 332             videoInstance.Tags = tagInstances
 333
 334             return
 335           })
 336       })
 337       .then(() => {
 338         const json = videoInstance.toUpdateRemoteJSON()
 339
 340         // Now we'll update the video's meta data to our friends
 341         return updateVideoToFriends(json, t)
 342       })
 343   })
 344   .then(() => {
 345     logger.info('Video with name %s updated.', videoInstance.name)
 346   })
 347   .catch(err => {
 348     logger.debug('Cannot update the video.', err)
 349
 350     // Force fields we want to update
 351     // If the transaction is retried, sequelize will think the object has not changed
 352     // So it will skip the SQL request, even if the last one was ROLLBACKed!
 353     Object.keys(videoFieldsSave).forEach(key => {
 354       const value = videoFieldsSave[key]
 355       videoInstance.set(key, value)
 356     })
 357
 358     throw err
 359   })
 360 }
 361
 362 function getVideo (req: express.Request, res: express.Response) {
 363   const videoInstance = res.locals.video
 364
 365   if (videoInstance.isOwned()) {
 366     // The increment is done directly in the database, not using the instance value
 367     videoInstance.increment('views')
 368       .then(() => {
 369         // FIXME: make a real view system
 370         // For example, only add a view when a user watch a video during 30s etc
 371         const qaduParams = {
 372           videoId: videoInstance.id,
 373           type: REQUEST_VIDEO_QADU_TYPES.VIEWS
 374         }
 375         return quickAndDirtyUpdateVideoToFriends(qaduParams)
 376       })
 377       .catch(err => logger.error('Cannot add view to video %d.', videoInstance.id, err))
 378   } else {
 379     // Just send the event to our friends
 380     const eventParams = {
 381       videoId: videoInstance.id,
 382       type: REQUEST_VIDEO_EVENT_TYPES.VIEWS
 383     }
 384     addEventToRemoteVideo(eventParams)
 385   }
 386
 387   // Do not wait the view system
 388   res.json(videoInstance.toFormattedJSON())
 389 }
 390
 391 function listVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
 392   db.Video.listForApi(req.query.start, req.query.count, req.query.sort)
 393     .then(result => res.json(getFormattedObjects(result.data, result.total)))
 394     .catch(err => next(err))
 395 }
 396
 397 function removeVideo (req: express.Request, res: express.Response, next: express.NextFunction) {
 398   const videoInstance = res.locals.video
 399
 400   videoInstance.destroy()
 401     .then(() => res.type('json').status(204).end())
 402     .catch(err => {
 403       logger.error('Errors when removed the video.', err)
 404       return next(err)
 405     })
 406 }
 407
 408 function searchVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
 409   db.Video.searchAndPopulateAuthorAndPodAndTags(req.params.value, req.query.field, req.query.start, req.query.count, req.query.sort)
 410     .then(result => res.json(getFormattedObjects(result.data, result.total)))
 411     .catch(err => next(err))
 412 }