server/controllers/api/videos/index.ts

   1 import * as express from 'express'
   2 import { move } from 'fs-extra'
   3 import { extname } from 'path'
   4 import toInt from 'validator/lib/toInt'
   5 import { deleteResumableUploadMetaFile, getResumableUploadPath } from '@server/helpers/upload'
   6 import { createTorrentAndSetInfoHash } from '@server/helpers/webtorrent'
   7 import { changeVideoChannelShare } from '@server/lib/activitypub/share'
   8 import { getLocalVideoActivityPubUrl } from '@server/lib/activitypub/url'
   9 import { LiveManager } from '@server/lib/live-manager'
  10 import { addOptimizeOrMergeAudioJob, buildLocalVideoFromReq, buildVideoThumbnailsFromReq, setVideoTags } from '@server/lib/video'
  11 import { generateVideoFilename, getVideoFilePath } from '@server/lib/video-paths'
  12 import { getServerActor } from '@server/models/application/application'
  13 import { MVideo, MVideoFile, MVideoFullLight } from '@server/types/models'
  14 import { uploadx } from '@uploadx/core'
  15 import { VideoCreate, VideosCommonQuery, VideoState, VideoUpdate } from '../../../../shared'
  16 import { HttpStatusCode } from '../../../../shared/core-utils/miscs'
  17 import { auditLoggerFactory, getAuditIdFromRes, VideoAuditView } from '../../../helpers/audit-logger'
  18 import { resetSequelizeInstance, retryTransactionWrapper } from '../../../helpers/database-utils'
  19 import { buildNSFWFilter, createReqFiles, getCountVideos } from '../../../helpers/express-utils'
  20 import { getMetadataFromFile, getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffprobe-utils'
  21 import { logger, loggerTagsFactory } from '../../../helpers/logger'
  22 import { getFormattedObjects } from '../../../helpers/utils'
  23 import { CONFIG } from '../../../initializers/config'
  24 import {
  25   DEFAULT_AUDIO_RESOLUTION,
  26   MIMETYPES,
  27   VIDEO_CATEGORIES,
  28   VIDEO_LANGUAGES,
  29   VIDEO_LICENCES,
  30   VIDEO_PRIVACIES
  31 } from '../../../initializers/constants'
  32 import { sequelizeTypescript } from '../../../initializers/database'
  33 import { sendView } from '../../../lib/activitypub/send/send-view'
  34 import { federateVideoIfNeeded, fetchRemoteVideoDescription } from '../../../lib/activitypub/videos'
  35 import { JobQueue } from '../../../lib/job-queue'
  36 import { Notifier } from '../../../lib/notifier'
  37 import { Hooks } from '../../../lib/plugins/hooks'
  38 import { Redis } from '../../../lib/redis'
  39 import { generateVideoMiniature } from '../../../lib/thumbnail'
  40 import { autoBlacklistVideoIfNeeded } from '../../../lib/video-blacklist'
  41 import {
  42   asyncMiddleware,
  43   asyncRetryTransactionMiddleware,
  44   authenticate,
  45   checkVideoFollowConstraints,
  46   commonVideosFiltersValidator,
  47   optionalAuthenticate,
  48   paginationValidator,
  49   setDefaultPagination,
  50   setDefaultVideosSort,
  51   videoFileMetadataGetValidator,
  52   videosAddLegacyValidator,
  53   videosAddResumableInitValidator,
  54   videosAddResumableValidator,
  55   videosCustomGetValidator,
  56   videosGetValidator,
  57   videosRemoveValidator,
  58   videosSortValidator,
  59   videosUpdateValidator
  60 } from '../../../middlewares'
  61 import { ScheduleVideoUpdateModel } from '../../../models/video/schedule-video-update'
  62 import { VideoModel } from '../../../models/video/video'
  63 import { VideoFileModel } from '../../../models/video/video-file'
  64 import { blacklistRouter } from './blacklist'
  65 import { videoCaptionsRouter } from './captions'
  66 import { videoCommentRouter } from './comment'
  67 import { videoImportsRouter } from './import'
  68 import { liveRouter } from './live'
  69 import { ownershipVideoRouter } from './ownership'
  70 import { rateVideoRouter } from './rate'
  71 import { watchingRouter } from './watching'
  72
  73 const lTags = loggerTagsFactory('api', 'video')
  74 const auditLogger = auditLoggerFactory('videos')
  75 const videosRouter = express.Router()
  76 const uploadxMiddleware = uploadx.upload({ directory: getResumableUploadPath() })
  77
  78 const reqVideoFileAdd = createReqFiles(
  79   [ 'videofile', 'thumbnailfile', 'previewfile' ],
  80   Object.assign({}, MIMETYPES.VIDEO.MIMETYPE_EXT, MIMETYPES.IMAGE.MIMETYPE_EXT),
  81   {
  82     videofile: CONFIG.STORAGE.TMP_DIR,
  83     thumbnailfile: CONFIG.STORAGE.TMP_DIR,
  84     previewfile: CONFIG.STORAGE.TMP_DIR
  85   }
  86 )
  87
  88 const reqVideoFileAddResumable = createReqFiles(
  89   [ 'thumbnailfile', 'previewfile' ],
  90   MIMETYPES.IMAGE.MIMETYPE_EXT,
  91   {
  92     thumbnailfile: getResumableUploadPath(),
  93     previewfile: getResumableUploadPath()
  94   }
  95 )
  96
  97 const reqVideoFileUpdate = createReqFiles(
  98   [ 'thumbnailfile', 'previewfile' ],
  99   MIMETYPES.IMAGE.MIMETYPE_EXT,
 100   {
 101     thumbnailfile: CONFIG.STORAGE.TMP_DIR,
 102     previewfile: CONFIG.STORAGE.TMP_DIR
 103   }
 104 )
 105
 106 videosRouter.use('/', blacklistRouter)
 107 videosRouter.use('/', rateVideoRouter)
 108 videosRouter.use('/', videoCommentRouter)
 109 videosRouter.use('/', videoCaptionsRouter)
 110 videosRouter.use('/', videoImportsRouter)
 111 videosRouter.use('/', ownershipVideoRouter)
 112 videosRouter.use('/', watchingRouter)
 113 videosRouter.use('/', liveRouter)
 114
 115 videosRouter.get('/categories', listVideoCategories)
 116 videosRouter.get('/licences', listVideoLicences)
 117 videosRouter.get('/languages', listVideoLanguages)
 118 videosRouter.get('/privacies', listVideoPrivacies)
 119
 120 videosRouter.get('/',
 121   paginationValidator,
 122   videosSortValidator,
 123   setDefaultVideosSort,
 124   setDefaultPagination,
 125   optionalAuthenticate,
 126   commonVideosFiltersValidator,
 127   asyncMiddleware(listVideos)
 128 )
 129
 130 videosRouter.post('/upload',
 131   authenticate,
 132   reqVideoFileAdd,
 133   asyncMiddleware(videosAddLegacyValidator),
 134   asyncRetryTransactionMiddleware(addVideoLegacy)
 135 )
 136
 137 videosRouter.post('/upload-resumable',
 138   authenticate,
 139   reqVideoFileAddResumable,
 140   asyncMiddleware(videosAddResumableInitValidator),
 141   uploadxMiddleware
 142 )
 143
 144 videosRouter.delete('/upload-resumable',
 145   authenticate,
 146   uploadxMiddleware
 147 )
 148
 149 videosRouter.put('/upload-resumable',
 150   authenticate,
 151   uploadxMiddleware, // uploadx doesn't use call next() before the file upload completes
 152   asyncMiddleware(videosAddResumableValidator),
 153   asyncMiddleware(addVideoResumable)
 154 )
 155
 156 videosRouter.put('/:id',
 157   authenticate,
 158   reqVideoFileUpdate,
 159   asyncMiddleware(videosUpdateValidator),
 160   asyncRetryTransactionMiddleware(updateVideo)
 161 )
 162
 163 videosRouter.get('/:id/description',
 164   asyncMiddleware(videosGetValidator),
 165   asyncMiddleware(getVideoDescription)
 166 )
 167 videosRouter.get('/:id/metadata/:videoFileId',
 168   asyncMiddleware(videoFileMetadataGetValidator),
 169   asyncMiddleware(getVideoFileMetadata)
 170 )
 171 videosRouter.get('/:id',
 172   optionalAuthenticate,
 173   asyncMiddleware(videosCustomGetValidator('only-video-with-rights')),
 174   asyncMiddleware(checkVideoFollowConstraints),
 175   asyncMiddleware(getVideo)
 176 )
 177 videosRouter.post('/:id/views',
 178   asyncMiddleware(videosCustomGetValidator('only-immutable-attributes')),
 179   asyncMiddleware(viewVideo)
 180 )
 181
 182 videosRouter.delete('/:id',
 183   authenticate,
 184   asyncMiddleware(videosRemoveValidator),
 185   asyncRetryTransactionMiddleware(removeVideo)
 186 )
 187
 188 // ---------------------------------------------------------------------------
 189
 190 export {
 191   videosRouter
 192 }
 193
 194 // ---------------------------------------------------------------------------
 195
 196 function listVideoCategories (_req: express.Request, res: express.Response) {
 197   res.json(VIDEO_CATEGORIES)
 198 }
 199
 200 function listVideoLicences (_req: express.Request, res: express.Response) {
 201   res.json(VIDEO_LICENCES)
 202 }
 203
 204 function listVideoLanguages (_req: express.Request, res: express.Response) {
 205   res.json(VIDEO_LANGUAGES)
 206 }
 207
 208 function listVideoPrivacies (_req: express.Request, res: express.Response) {
 209   res.json(VIDEO_PRIVACIES)
 210 }
 211
 212 async function addVideoLegacy (req: express.Request, res: express.Response) {
 213   // Uploading the video could be long
 214   // Set timeout to 10 minutes, as Express's default is 2 minutes
 215   req.setTimeout(1000 * 60 * 10, () => {
 216     logger.error('Upload video has timed out.')
 217     return res.sendStatus(HttpStatusCode.REQUEST_TIMEOUT_408)
 218   })
 219
 220   const videoPhysicalFile = req.files['videofile'][0]
 221   const videoInfo: VideoCreate = req.body
 222   const files = req.files
 223
 224   return addVideo({ res, videoPhysicalFile, videoInfo, files })
 225 }
 226
 227 async function addVideoResumable (_req: express.Request, res: express.Response) {
 228   const videoPhysicalFile = res.locals.videoFileResumable
 229   const videoInfo = videoPhysicalFile.metadata
 230   const files = { previewfile: videoInfo.previewfile }
 231
 232   // Don't need the meta file anymore
 233   await deleteResumableUploadMetaFile(videoPhysicalFile.path)
 234
 235   return addVideo({ res, videoPhysicalFile, videoInfo, files })
 236 }
 237
 238 async function addVideo (options: {
 239   res: express.Response
 240   videoPhysicalFile: express.VideoUploadFile
 241   videoInfo: VideoCreate
 242   files: express.UploadFiles
 243 }) {
 244   const { res, videoPhysicalFile, videoInfo, files } = options
 245   const videoChannel = res.locals.videoChannel
 246   const user = res.locals.oauth.token.User
 247
 248   const videoData = buildLocalVideoFromReq(videoInfo, videoChannel.id)
 249
 250   videoData.state = CONFIG.TRANSCODING.ENABLED
 251     ? VideoState.TO_TRANSCODE
 252     : VideoState.PUBLISHED
 253
 254   videoData.duration = videoPhysicalFile.duration // duration was added by a previous middleware
 255
 256   const video = new VideoModel(videoData) as MVideoFullLight
 257   video.VideoChannel = videoChannel
 258   video.url = getLocalVideoActivityPubUrl(video) // We use the UUID, so set the URL after building the object
 259
 260   const videoFile = new VideoFileModel({
 261     extname: extname(videoPhysicalFile.filename),
 262     size: videoPhysicalFile.size,
 263     videoStreamingPlaylistId: null,
 264     metadata: await getMetadataFromFile(videoPhysicalFile.path)
 265   })
 266
 267   if (videoFile.isAudio()) {
 268     videoFile.resolution = DEFAULT_AUDIO_RESOLUTION
 269   } else {
 270     videoFile.fps = await getVideoFileFPS(videoPhysicalFile.path)
 271     videoFile.resolution = (await getVideoFileResolution(videoPhysicalFile.path)).videoFileResolution
 272   }
 273
 274   videoFile.filename = generateVideoFilename(video, false, videoFile.resolution, videoFile.extname)
 275
 276   // Move physical file
 277   const destination = getVideoFilePath(video, videoFile)
 278   await move(videoPhysicalFile.path, destination)
 279   // This is important in case if there is another attempt in the retry process
 280   videoPhysicalFile.filename = getVideoFilePath(video, videoFile)
 281   videoPhysicalFile.path = destination
 282
 283   const [ thumbnailModel, previewModel ] = await buildVideoThumbnailsFromReq({
 284     video,
 285     files,
 286     fallback: type => generateVideoMiniature({ video, videoFile, type })
 287   })
 288
 289   const { videoCreated } = await sequelizeTypescript.transaction(async t => {
 290     const sequelizeOptions = { transaction: t }
 291
 292     const videoCreated = await video.save(sequelizeOptions) as MVideoFullLight
 293
 294     await videoCreated.addAndSaveThumbnail(thumbnailModel, t)
 295     await videoCreated.addAndSaveThumbnail(previewModel, t)
 296
 297     // Do not forget to add video channel information to the created video
 298     videoCreated.VideoChannel = res.locals.videoChannel
 299
 300     videoFile.videoId = video.id
 301     await videoFile.save(sequelizeOptions)
 302
 303     video.VideoFiles = [ videoFile ]
 304
 305     await setVideoTags({ video, tags: videoInfo.tags, transaction: t })
 306
 307     // Schedule an update in the future?
 308     if (videoInfo.scheduleUpdate) {
 309       await ScheduleVideoUpdateModel.create({
 310         videoId: video.id,
 311         updateAt: new Date(videoInfo.scheduleUpdate.updateAt),
 312         privacy: videoInfo.scheduleUpdate.privacy || null
 313       }, { transaction: t })
 314     }
 315
 316     // Channel has a new content, set as updated
 317     await videoCreated.VideoChannel.setAsUpdated(t)
 318
 319     await autoBlacklistVideoIfNeeded({
 320       video,
 321       user,
 322       isRemote: false,
 323       isNew: true,
 324       transaction: t
 325     })
 326
 327     auditLogger.create(getAuditIdFromRes(res), new VideoAuditView(videoCreated.toFormattedDetailsJSON()))
 328     logger.info('Video with name %s and uuid %s created.', videoInfo.name, videoCreated.uuid, lTags(videoCreated.uuid))
 329
 330     return { videoCreated }
 331   })
 332
 333   // Create the torrent file in async way because it could be long
 334   createTorrentAndSetInfoHashAsync(video, videoFile)
 335     .catch(err => logger.error('Cannot create torrent file for video %s', video.url, { err, ...lTags(video.uuid) }))
 336     .then(() => VideoModel.loadAndPopulateAccountAndServerAndTags(video.id))
 337     .then(refreshedVideo => {
 338       if (!refreshedVideo) return
 339
 340       // Only federate and notify after the torrent creation
 341       Notifier.Instance.notifyOnNewVideoIfNeeded(refreshedVideo)
 342
 343       return retryTransactionWrapper(() => {
 344         return sequelizeTypescript.transaction(t => federateVideoIfNeeded(refreshedVideo, true, t))
 345       })
 346     })
 347     .catch(err => logger.error('Cannot federate or notify video creation %s', video.url, { err, ...lTags(video.uuid) }))
 348
 349   if (video.state === VideoState.TO_TRANSCODE) {
 350     await addOptimizeOrMergeAudioJob(videoCreated, videoFile, user)
 351   }
 352
 353   Hooks.runAction('action:api.video.uploaded', { video: videoCreated })
 354
 355   return res.json({
 356     video: {
 357       id: videoCreated.id,
 358       uuid: videoCreated.uuid
 359     }
 360   })
 361 }
 362
 363 async function updateVideo (req: express.Request, res: express.Response) {
 364   const videoInstance = res.locals.videoAll
 365   const videoFieldsSave = videoInstance.toJSON()
 366   const oldVideoAuditView = new VideoAuditView(videoInstance.toFormattedDetailsJSON())
 367   const videoInfoToUpdate: VideoUpdate = req.body
 368
 369   const wasConfidentialVideo = videoInstance.isConfidential()
 370   const hadPrivacyForFederation = videoInstance.hasPrivacyForFederation()
 371
 372   const [ thumbnailModel, previewModel ] = await buildVideoThumbnailsFromReq({
 373     video: videoInstance,
 374     files: req.files,
 375     fallback: () => Promise.resolve(undefined),
 376     automaticallyGenerated: false
 377   })
 378
 379   try {
 380     const videoInstanceUpdated = await sequelizeTypescript.transaction(async t => {
 381       const sequelizeOptions = { transaction: t }
 382       const oldVideoChannel = videoInstance.VideoChannel
 383
 384       if (videoInfoToUpdate.name !== undefined) videoInstance.name = videoInfoToUpdate.name
 385       if (videoInfoToUpdate.category !== undefined) videoInstance.category = videoInfoToUpdate.category
 386       if (videoInfoToUpdate.licence !== undefined) videoInstance.licence = videoInfoToUpdate.licence
 387       if (videoInfoToUpdate.language !== undefined) videoInstance.language = videoInfoToUpdate.language
 388       if (videoInfoToUpdate.nsfw !== undefined) videoInstance.nsfw = videoInfoToUpdate.nsfw
 389       if (videoInfoToUpdate.waitTranscoding !== undefined) videoInstance.waitTranscoding = videoInfoToUpdate.waitTranscoding
 390       if (videoInfoToUpdate.support !== undefined) videoInstance.support = videoInfoToUpdate.support
 391       if (videoInfoToUpdate.description !== undefined) videoInstance.description = videoInfoToUpdate.description
 392       if (videoInfoToUpdate.commentsEnabled !== undefined) videoInstance.commentsEnabled = videoInfoToUpdate.commentsEnabled
 393       if (videoInfoToUpdate.downloadEnabled !== undefined) videoInstance.downloadEnabled = videoInfoToUpdate.downloadEnabled
 394
 395       if (videoInfoToUpdate.originallyPublishedAt !== undefined && videoInfoToUpdate.originallyPublishedAt !== null) {
 396         videoInstance.originallyPublishedAt = new Date(videoInfoToUpdate.originallyPublishedAt)
 397       }
 398
 399       let isNewVideo = false
 400       if (videoInfoToUpdate.privacy !== undefined) {
 401         isNewVideo = videoInstance.isNewVideo(videoInfoToUpdate.privacy)
 402
 403         const newPrivacy = parseInt(videoInfoToUpdate.privacy.toString(), 10)
 404         videoInstance.setPrivacy(newPrivacy)
 405
 406         // Unfederate the video if the new privacy is not compatible with federation
 407         if (hadPrivacyForFederation && !videoInstance.hasPrivacyForFederation()) {
 408           await VideoModel.sendDelete(videoInstance, { transaction: t })
 409         }
 410       }
 411
 412       const videoInstanceUpdated = await videoInstance.save(sequelizeOptions) as MVideoFullLight
 413
 414       if (thumbnailModel) await videoInstanceUpdated.addAndSaveThumbnail(thumbnailModel, t)
 415       if (previewModel) await videoInstanceUpdated.addAndSaveThumbnail(previewModel, t)
 416
 417       // Video tags update?
 418       if (videoInfoToUpdate.tags !== undefined) {
 419         await setVideoTags({
 420           video: videoInstanceUpdated,
 421           tags: videoInfoToUpdate.tags,
 422           transaction: t
 423         })
 424       }
 425
 426       // Video channel update?
 427       if (res.locals.videoChannel && videoInstanceUpdated.channelId !== res.locals.videoChannel.id) {
 428         await videoInstanceUpdated.$set('VideoChannel', res.locals.videoChannel, { transaction: t })
 429         videoInstanceUpdated.VideoChannel = res.locals.videoChannel
 430
 431         if (hadPrivacyForFederation === true) await changeVideoChannelShare(videoInstanceUpdated, oldVideoChannel, t)
 432       }
 433
 434       // Schedule an update in the future?
 435       if (videoInfoToUpdate.scheduleUpdate) {
 436         await ScheduleVideoUpdateModel.upsert({
 437           videoId: videoInstanceUpdated.id,
 438           updateAt: new Date(videoInfoToUpdate.scheduleUpdate.updateAt),
 439           privacy: videoInfoToUpdate.scheduleUpdate.privacy || null
 440         }, { transaction: t })
 441       } else if (videoInfoToUpdate.scheduleUpdate === null) {
 442         await ScheduleVideoUpdateModel.deleteByVideoId(videoInstanceUpdated.id, t)
 443       }
 444
 445       await autoBlacklistVideoIfNeeded({
 446         video: videoInstanceUpdated,
 447         user: res.locals.oauth.token.User,
 448         isRemote: false,
 449         isNew: false,
 450         transaction: t
 451       })
 452
 453       await federateVideoIfNeeded(videoInstanceUpdated, isNewVideo, t)
 454
 455       auditLogger.update(
 456         getAuditIdFromRes(res),
 457         new VideoAuditView(videoInstanceUpdated.toFormattedDetailsJSON()),
 458         oldVideoAuditView
 459       )
 460       logger.info('Video with name %s and uuid %s updated.', videoInstance.name, videoInstance.uuid, lTags(videoInstance.uuid))
 461
 462       return videoInstanceUpdated
 463     })
 464
 465     if (wasConfidentialVideo) {
 466       Notifier.Instance.notifyOnNewVideoIfNeeded(videoInstanceUpdated)
 467     }
 468
 469     Hooks.runAction('action:api.video.updated', { video: videoInstanceUpdated, body: req.body })
 470   } catch (err) {
 471     // Force fields we want to update
 472     // If the transaction is retried, sequelize will think the object has not changed
 473     // So it will skip the SQL request, even if the last one was ROLLBACKed!
 474     resetSequelizeInstance(videoInstance, videoFieldsSave)
 475
 476     throw err
 477   }
 478
 479   return res.type('json')
 480             .status(HttpStatusCode.NO_CONTENT_204)
 481             .end()
 482 }
 483
 484 async function getVideo (req: express.Request, res: express.Response) {
 485   // We need more attributes
 486   const userId: number = res.locals.oauth ? res.locals.oauth.token.User.id : null
 487
 488   const video = await Hooks.wrapPromiseFun(
 489     VideoModel.loadForGetAPI,
 490     { id: res.locals.onlyVideoWithRights.id, userId },
 491     'filter:api.video.get.result'
 492   )
 493
 494   if (video.isOutdated()) {
 495     JobQueue.Instance.createJob({ type: 'activitypub-refresher', payload: { type: 'video', url: video.url } })
 496   }
 497
 498   return res.json(video.toFormattedDetailsJSON())
 499 }
 500
 501 async function viewVideo (req: express.Request, res: express.Response) {
 502   const immutableVideoAttrs = res.locals.onlyImmutableVideo
 503
 504   const ip = req.ip
 505   const exists = await Redis.Instance.doesVideoIPViewExist(ip, immutableVideoAttrs.uuid)
 506   if (exists) {
 507     logger.debug('View for ip %s and video %s already exists.', ip, immutableVideoAttrs.uuid)
 508     return res.sendStatus(HttpStatusCode.NO_CONTENT_204)
 509   }
 510
 511   const video = await VideoModel.load(immutableVideoAttrs.id)
 512
 513   const promises: Promise<any>[] = [
 514     Redis.Instance.setIPVideoView(ip, video.uuid, video.isLive)
 515   ]
 516
 517   let federateView = true
 518
 519   // Increment our live manager
 520   if (video.isLive && video.isOwned()) {
 521     LiveManager.Instance.addViewTo(video.id)
 522
 523     // Views of our local live will be sent by our live manager
 524     federateView = false
 525   }
 526
 527   // Increment our video views cache counter
 528   if (!video.isLive) {
 529     promises.push(Redis.Instance.addVideoView(video.id))
 530   }
 531
 532   if (federateView) {
 533     const serverActor = await getServerActor()
 534     promises.push(sendView(serverActor, video, undefined))
 535   }
 536
 537   await Promise.all(promises)
 538
 539   Hooks.runAction('action:api.video.viewed', { video, ip })
 540
 541   return res.sendStatus(HttpStatusCode.NO_CONTENT_204)
 542 }
 543
 544 async function getVideoDescription (req: express.Request, res: express.Response) {
 545   const videoInstance = res.locals.videoAll
 546   let description = ''
 547
 548   if (videoInstance.isOwned()) {
 549     description = videoInstance.description
 550   } else {
 551     description = await fetchRemoteVideoDescription(videoInstance)
 552   }
 553
 554   return res.json({ description })
 555 }
 556
 557 async function getVideoFileMetadata (req: express.Request, res: express.Response) {
 558   const videoFile = await VideoFileModel.loadWithMetadata(toInt(req.params.videoFileId))
 559
 560   return res.json(videoFile.metadata)
 561 }
 562
 563 async function listVideos (req: express.Request, res: express.Response) {
 564   const query = req.query as VideosCommonQuery
 565   const countVideos = getCountVideos(req)
 566
 567   const apiOptions = await Hooks.wrapObject({
 568     start: query.start,
 569     count: query.count,
 570     sort: query.sort,
 571     includeLocalVideos: true,
 572     categoryOneOf: query.categoryOneOf,
 573     licenceOneOf: query.licenceOneOf,
 574     languageOneOf: query.languageOneOf,
 575     tagsOneOf: query.tagsOneOf,
 576     tagsAllOf: query.tagsAllOf,
 577     nsfw: buildNSFWFilter(res, query.nsfw),
 578     isLive: query.isLive,
 579     filter: query.filter,
 580     withFiles: false,
 581     user: res.locals.oauth ? res.locals.oauth.token.User : undefined,
 582     countVideos
 583   }, 'filter:api.videos.list.params')
 584
 585   const resultList = await Hooks.wrapPromiseFun(
 586     VideoModel.listForApi,
 587     apiOptions,
 588     'filter:api.videos.list.result'
 589   )
 590
 591   return res.json(getFormattedObjects(resultList.data, resultList.total))
 592 }
 593
 594 async function removeVideo (req: express.Request, res: express.Response) {
 595   const videoInstance = res.locals.videoAll
 596
 597   await sequelizeTypescript.transaction(async t => {
 598     await videoInstance.destroy({ transaction: t })
 599   })
 600
 601   auditLogger.delete(getAuditIdFromRes(res), new VideoAuditView(videoInstance.toFormattedDetailsJSON()))
 602   logger.info('Video with name %s and uuid %s deleted.', videoInstance.name, videoInstance.uuid)
 603
 604   Hooks.runAction('action:api.video.deleted', { video: videoInstance })
 605
 606   return res.type('json')
 607             .status(HttpStatusCode.NO_CONTENT_204)
 608             .end()
 609 }
 610
 611 async function createTorrentAndSetInfoHashAsync (video: MVideo, fileArg: MVideoFile) {
 612   await createTorrentAndSetInfoHash(video, fileArg)
 613
 614   // Refresh videoFile because the createTorrentAndSetInfoHash could be long
 615   const refreshedFile = await VideoFileModel.loadWithVideo(fileArg.id)
 616   // File does not exist anymore, remove the generated torrent
 617   if (!refreshedFile) return fileArg.removeTorrent()
 618
 619   refreshedFile.infoHash = fileArg.infoHash
 620   refreshedFile.torrentFilename = fileArg.torrentFilename
 621
 622   return refreshedFile.save()
 623 }