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