server/controllers/api/video-playlist.ts

   1 import * as express from 'express'
   2 import { join } from 'path'
   3 import { scheduleRefreshIfNeeded } from '@server/lib/activitypub/playlists'
   4 import { getServerActor } from '@server/models/application/application'
   5 import { MVideoPlaylistFull, MVideoPlaylistThumbnail, MVideoThumbnail } from '@server/types/models'
   6 import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
   7 import { VideoPlaylistCreate } from '../../../shared/models/videos/playlist/video-playlist-create.model'
   8 import { VideoPlaylistElementCreate } from '../../../shared/models/videos/playlist/video-playlist-element-create.model'
   9 import { VideoPlaylistElementUpdate } from '../../../shared/models/videos/playlist/video-playlist-element-update.model'
  10 import { VideoPlaylistPrivacy } from '../../../shared/models/videos/playlist/video-playlist-privacy.model'
  11 import { VideoPlaylistReorder } from '../../../shared/models/videos/playlist/video-playlist-reorder.model'
  12 import { VideoPlaylistUpdate } from '../../../shared/models/videos/playlist/video-playlist-update.model'
  13 import { resetSequelizeInstance } from '../../helpers/database-utils'
  14 import { buildNSFWFilter, createReqFiles } from '../../helpers/express-utils'
  15 import { logger } from '../../helpers/logger'
  16 import { getFormattedObjects } from '../../helpers/utils'
  17 import { CONFIG } from '../../initializers/config'
  18 import { MIMETYPES, VIDEO_PLAYLIST_PRIVACIES } from '../../initializers/constants'
  19 import { sequelizeTypescript } from '../../initializers/database'
  20 import { sendCreateVideoPlaylist, sendDeleteVideoPlaylist, sendUpdateVideoPlaylist } from '../../lib/activitypub/send'
  21 import { getLocalVideoPlaylistActivityPubUrl, getLocalVideoPlaylistElementActivityPubUrl } from '../../lib/activitypub/url'
  22 import { updatePlaylistMiniatureFromExisting } from '../../lib/thumbnail'
  23 import {
  24   asyncMiddleware,
  25   asyncRetryTransactionMiddleware,
  26   authenticate,
  27   optionalAuthenticate,
  28   paginationValidator,
  29   setDefaultPagination,
  30   setDefaultSort
  31 } from '../../middlewares'
  32 import { videoPlaylistsSortValidator } from '../../middlewares/validators'
  33 import {
  34   commonVideoPlaylistFiltersValidator,
  35   videoPlaylistsAddValidator,
  36   videoPlaylistsAddVideoValidator,
  37   videoPlaylistsDeleteValidator,
  38   videoPlaylistsGetValidator,
  39   videoPlaylistsReorderVideosValidator,
  40   videoPlaylistsUpdateOrRemoveVideoValidator,
  41   videoPlaylistsUpdateValidator
  42 } from '../../middlewares/validators/videos/video-playlists'
  43 import { AccountModel } from '../../models/account/account'
  44 import { VideoPlaylistModel } from '../../models/video/video-playlist'
  45 import { VideoPlaylistElementModel } from '../../models/video/video-playlist-element'
  46
  47 const reqThumbnailFile = createReqFiles([ 'thumbnailfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT, { thumbnailfile: CONFIG.STORAGE.TMP_DIR })
  48
  49 const videoPlaylistRouter = express.Router()
  50
  51 videoPlaylistRouter.get('/privacies', listVideoPlaylistPrivacies)
  52
  53 videoPlaylistRouter.get('/',
  54   paginationValidator,
  55   videoPlaylistsSortValidator,
  56   setDefaultSort,
  57   setDefaultPagination,
  58   commonVideoPlaylistFiltersValidator,
  59   asyncMiddleware(listVideoPlaylists)
  60 )
  61
  62 videoPlaylistRouter.get('/:playlistId',
  63   asyncMiddleware(videoPlaylistsGetValidator('summary')),
  64   getVideoPlaylist
  65 )
  66
  67 videoPlaylistRouter.post('/',
  68   authenticate,
  69   reqThumbnailFile,
  70   asyncMiddleware(videoPlaylistsAddValidator),
  71   asyncRetryTransactionMiddleware(addVideoPlaylist)
  72 )
  73
  74 videoPlaylistRouter.put('/:playlistId',
  75   authenticate,
  76   reqThumbnailFile,
  77   asyncMiddleware(videoPlaylistsUpdateValidator),
  78   asyncRetryTransactionMiddleware(updateVideoPlaylist)
  79 )
  80
  81 videoPlaylistRouter.delete('/:playlistId',
  82   authenticate,
  83   asyncMiddleware(videoPlaylistsDeleteValidator),
  84   asyncRetryTransactionMiddleware(removeVideoPlaylist)
  85 )
  86
  87 videoPlaylistRouter.get('/:playlistId/videos',
  88   asyncMiddleware(videoPlaylistsGetValidator('summary')),
  89   paginationValidator,
  90   setDefaultPagination,
  91   optionalAuthenticate,
  92   asyncMiddleware(getVideoPlaylistVideos)
  93 )
  94
  95 videoPlaylistRouter.post('/:playlistId/videos',
  96   authenticate,
  97   asyncMiddleware(videoPlaylistsAddVideoValidator),
  98   asyncRetryTransactionMiddleware(addVideoInPlaylist)
  99 )
 100
 101 videoPlaylistRouter.post('/:playlistId/videos/reorder',
 102   authenticate,
 103   asyncMiddleware(videoPlaylistsReorderVideosValidator),
 104   asyncRetryTransactionMiddleware(reorderVideosPlaylist)
 105 )
 106
 107 videoPlaylistRouter.put('/:playlistId/videos/:playlistElementId',
 108   authenticate,
 109   asyncMiddleware(videoPlaylistsUpdateOrRemoveVideoValidator),
 110   asyncRetryTransactionMiddleware(updateVideoPlaylistElement)
 111 )
 112
 113 videoPlaylistRouter.delete('/:playlistId/videos/:playlistElementId',
 114   authenticate,
 115   asyncMiddleware(videoPlaylistsUpdateOrRemoveVideoValidator),
 116   asyncRetryTransactionMiddleware(removeVideoFromPlaylist)
 117 )
 118
 119 // ---------------------------------------------------------------------------
 120
 121 export {
 122   videoPlaylistRouter
 123 }
 124
 125 // ---------------------------------------------------------------------------
 126
 127 function listVideoPlaylistPrivacies (req: express.Request, res: express.Response) {
 128   res.json(VIDEO_PLAYLIST_PRIVACIES)
 129 }
 130
 131 async function listVideoPlaylists (req: express.Request, res: express.Response) {
 132   const serverActor = await getServerActor()
 133   const resultList = await VideoPlaylistModel.listForApi({
 134     followerActorId: serverActor.id,
 135     start: req.query.start,
 136     count: req.query.count,
 137     sort: req.query.sort,
 138     type: req.query.type
 139   })
 140
 141   return res.json(getFormattedObjects(resultList.data, resultList.total))
 142 }
 143
 144 function getVideoPlaylist (req: express.Request, res: express.Response) {
 145   const videoPlaylist = res.locals.videoPlaylistSummary
 146
 147   scheduleRefreshIfNeeded(videoPlaylist)
 148
 149   return res.json(videoPlaylist.toFormattedJSON())
 150 }
 151
 152 async function addVideoPlaylist (req: express.Request, res: express.Response) {
 153   const videoPlaylistInfo: VideoPlaylistCreate = req.body
 154   const user = res.locals.oauth.token.User
 155
 156   const videoPlaylist = new VideoPlaylistModel({
 157     name: videoPlaylistInfo.displayName,
 158     description: videoPlaylistInfo.description,
 159     privacy: videoPlaylistInfo.privacy || VideoPlaylistPrivacy.PRIVATE,
 160     ownerAccountId: user.Account.id
 161   }) as MVideoPlaylistFull
 162
 163   videoPlaylist.url = getLocalVideoPlaylistActivityPubUrl(videoPlaylist) // We use the UUID, so set the URL after building the object
 164
 165   if (videoPlaylistInfo.videoChannelId) {
 166     const videoChannel = res.locals.videoChannel
 167
 168     videoPlaylist.videoChannelId = videoChannel.id
 169     videoPlaylist.VideoChannel = videoChannel
 170   }
 171
 172   const thumbnailField = req.files['thumbnailfile']
 173   const thumbnailModel = thumbnailField
 174     ? await updatePlaylistMiniatureFromExisting({
 175       inputPath: thumbnailField[0].path,
 176       playlist: videoPlaylist,
 177       automaticallyGenerated: false
 178     })
 179     : undefined
 180
 181   const videoPlaylistCreated = await sequelizeTypescript.transaction(async t => {
 182     const videoPlaylistCreated = await videoPlaylist.save({ transaction: t }) as MVideoPlaylistFull
 183
 184     if (thumbnailModel) {
 185       thumbnailModel.automaticallyGenerated = false
 186       await videoPlaylistCreated.setAndSaveThumbnail(thumbnailModel, t)
 187     }
 188
 189     // We need more attributes for the federation
 190     videoPlaylistCreated.OwnerAccount = await AccountModel.load(user.Account.id, t)
 191     await sendCreateVideoPlaylist(videoPlaylistCreated, t)
 192
 193     return videoPlaylistCreated
 194   })
 195
 196   logger.info('Video playlist with uuid %s created.', videoPlaylist.uuid)
 197
 198   return res.json({
 199     videoPlaylist: {
 200       id: videoPlaylistCreated.id,
 201       uuid: videoPlaylistCreated.uuid
 202     }
 203   })
 204 }
 205
 206 async function updateVideoPlaylist (req: express.Request, res: express.Response) {
 207   const videoPlaylistInstance = res.locals.videoPlaylistFull
 208   const videoPlaylistFieldsSave = videoPlaylistInstance.toJSON()
 209   const videoPlaylistInfoToUpdate = req.body as VideoPlaylistUpdate
 210
 211   const wasPrivatePlaylist = videoPlaylistInstance.privacy === VideoPlaylistPrivacy.PRIVATE
 212   const wasNotPrivatePlaylist = videoPlaylistInstance.privacy !== VideoPlaylistPrivacy.PRIVATE
 213
 214   const thumbnailField = req.files['thumbnailfile']
 215   const thumbnailModel = thumbnailField
 216     ? await updatePlaylistMiniatureFromExisting({
 217       inputPath: thumbnailField[0].path,
 218       playlist: videoPlaylistInstance,
 219       automaticallyGenerated: false
 220     })
 221     : undefined
 222
 223   try {
 224     await sequelizeTypescript.transaction(async t => {
 225       const sequelizeOptions = {
 226         transaction: t
 227       }
 228
 229       if (videoPlaylistInfoToUpdate.videoChannelId !== undefined) {
 230         if (videoPlaylistInfoToUpdate.videoChannelId === null) {
 231           videoPlaylistInstance.videoChannelId = null
 232         } else {
 233           const videoChannel = res.locals.videoChannel
 234
 235           videoPlaylistInstance.videoChannelId = videoChannel.id
 236           videoPlaylistInstance.VideoChannel = videoChannel
 237         }
 238       }
 239
 240       if (videoPlaylistInfoToUpdate.displayName !== undefined) videoPlaylistInstance.name = videoPlaylistInfoToUpdate.displayName
 241       if (videoPlaylistInfoToUpdate.description !== undefined) videoPlaylistInstance.description = videoPlaylistInfoToUpdate.description
 242
 243       if (videoPlaylistInfoToUpdate.privacy !== undefined) {
 244         videoPlaylistInstance.privacy = parseInt(videoPlaylistInfoToUpdate.privacy.toString(), 10)
 245
 246         if (wasNotPrivatePlaylist === true && videoPlaylistInstance.privacy === VideoPlaylistPrivacy.PRIVATE) {
 247           await sendDeleteVideoPlaylist(videoPlaylistInstance, t)
 248         }
 249       }
 250
 251       const playlistUpdated = await videoPlaylistInstance.save(sequelizeOptions)
 252
 253       if (thumbnailModel) {
 254         thumbnailModel.automaticallyGenerated = false
 255         await playlistUpdated.setAndSaveThumbnail(thumbnailModel, t)
 256       }
 257
 258       const isNewPlaylist = wasPrivatePlaylist && playlistUpdated.privacy !== VideoPlaylistPrivacy.PRIVATE
 259
 260       if (isNewPlaylist) {
 261         await sendCreateVideoPlaylist(playlistUpdated, t)
 262       } else {
 263         await sendUpdateVideoPlaylist(playlistUpdated, t)
 264       }
 265
 266       logger.info('Video playlist %s updated.', videoPlaylistInstance.uuid)
 267
 268       return playlistUpdated
 269     })
 270   } catch (err) {
 271     logger.debug('Cannot update the video playlist.', { err })
 272
 273     // Force fields we want to update
 274     // If the transaction is retried, sequelize will think the object has not changed
 275     // So it will skip the SQL request, even if the last one was ROLLBACKed!
 276     resetSequelizeInstance(videoPlaylistInstance, videoPlaylistFieldsSave)
 277
 278     throw err
 279   }
 280
 281   return res.type('json').status(HttpStatusCode.NO_CONTENT_204).end()
 282 }
 283
 284 async function removeVideoPlaylist (req: express.Request, res: express.Response) {
 285   const videoPlaylistInstance = res.locals.videoPlaylistSummary
 286
 287   await sequelizeTypescript.transaction(async t => {
 288     await videoPlaylistInstance.destroy({ transaction: t })
 289
 290     await sendDeleteVideoPlaylist(videoPlaylistInstance, t)
 291
 292     logger.info('Video playlist %s deleted.', videoPlaylistInstance.uuid)
 293   })
 294
 295   return res.type('json').status(HttpStatusCode.NO_CONTENT_204).end()
 296 }
 297
 298 async function addVideoInPlaylist (req: express.Request, res: express.Response) {
 299   const body: VideoPlaylistElementCreate = req.body
 300   const videoPlaylist = res.locals.videoPlaylistFull
 301   const video = res.locals.onlyVideo
 302
 303   const playlistElement = await sequelizeTypescript.transaction(async t => {
 304     const position = await VideoPlaylistElementModel.getNextPositionOf(videoPlaylist.id, t)
 305
 306     const playlistElement = await VideoPlaylistElementModel.create({
 307       position,
 308       startTimestamp: body.startTimestamp || null,
 309       stopTimestamp: body.stopTimestamp || null,
 310       videoPlaylistId: videoPlaylist.id,
 311       videoId: video.id
 312     }, { transaction: t })
 313
 314     playlistElement.url = getLocalVideoPlaylistElementActivityPubUrl(videoPlaylist, playlistElement)
 315     await playlistElement.save({ transaction: t })
 316
 317     videoPlaylist.changed('updatedAt', true)
 318     await videoPlaylist.save({ transaction: t })
 319
 320     return playlistElement
 321   })
 322
 323   // If the user did not set a thumbnail, automatically take the video thumbnail
 324   if (videoPlaylist.hasThumbnail() === false || (videoPlaylist.hasGeneratedThumbnail() && playlistElement.position === 1)) {
 325     await generateThumbnailForPlaylist(videoPlaylist, video)
 326   }
 327
 328   sendUpdateVideoPlaylist(videoPlaylist, undefined)
 329     .catch(err => logger.error('Cannot send video playlist update.', { err }))
 330
 331   logger.info('Video added in playlist %s at position %d.', videoPlaylist.uuid, playlistElement.position)
 332
 333   return res.json({
 334     videoPlaylistElement: {
 335       id: playlistElement.id
 336     }
 337   }).end()
 338 }
 339
 340 async function updateVideoPlaylistElement (req: express.Request, res: express.Response) {
 341   const body: VideoPlaylistElementUpdate = req.body
 342   const videoPlaylist = res.locals.videoPlaylistFull
 343   const videoPlaylistElement = res.locals.videoPlaylistElement
 344
 345   const playlistElement: VideoPlaylistElementModel = await sequelizeTypescript.transaction(async t => {
 346     if (body.startTimestamp !== undefined) videoPlaylistElement.startTimestamp = body.startTimestamp
 347     if (body.stopTimestamp !== undefined) videoPlaylistElement.stopTimestamp = body.stopTimestamp
 348
 349     const element = await videoPlaylistElement.save({ transaction: t })
 350
 351     videoPlaylist.changed('updatedAt', true)
 352     await videoPlaylist.save({ transaction: t })
 353
 354     await sendUpdateVideoPlaylist(videoPlaylist, t)
 355
 356     return element
 357   })
 358
 359   logger.info('Element of position %d of playlist %s updated.', playlistElement.position, videoPlaylist.uuid)
 360
 361   return res.type('json').status(HttpStatusCode.NO_CONTENT_204).end()
 362 }
 363
 364 async function removeVideoFromPlaylist (req: express.Request, res: express.Response) {
 365   const videoPlaylistElement = res.locals.videoPlaylistElement
 366   const videoPlaylist = res.locals.videoPlaylistFull
 367   const positionToDelete = videoPlaylistElement.position
 368
 369   await sequelizeTypescript.transaction(async t => {
 370     await videoPlaylistElement.destroy({ transaction: t })
 371
 372     // Decrease position of the next elements
 373     await VideoPlaylistElementModel.increasePositionOf(videoPlaylist.id, positionToDelete, null, -1, t)
 374
 375     videoPlaylist.changed('updatedAt', true)
 376     await videoPlaylist.save({ transaction: t })
 377
 378     logger.info('Video playlist element %d of playlist %s deleted.', videoPlaylistElement.position, videoPlaylist.uuid)
 379   })
 380
 381   // Do we need to regenerate the default thumbnail?
 382   if (positionToDelete === 1 && videoPlaylist.hasGeneratedThumbnail()) {
 383     await regeneratePlaylistThumbnail(videoPlaylist)
 384   }
 385
 386   sendUpdateVideoPlaylist(videoPlaylist, undefined)
 387     .catch(err => logger.error('Cannot send video playlist update.', { err }))
 388
 389   return res.type('json').status(HttpStatusCode.NO_CONTENT_204).end()
 390 }
 391
 392 async function reorderVideosPlaylist (req: express.Request, res: express.Response) {
 393   const videoPlaylist = res.locals.videoPlaylistFull
 394   const body: VideoPlaylistReorder = req.body
 395
 396   const start: number = body.startPosition
 397   const insertAfter: number = body.insertAfterPosition
 398   const reorderLength: number = body.reorderLength || 1
 399
 400   if (start === insertAfter) {
 401     return res.status(HttpStatusCode.NO_CONTENT_204).end()
 402   }
 403
 404   // Example: if we reorder position 2 and insert after position 5 (so at position 6): # 1 2 3 4 5 6 7 8 9
 405   //  * increase position when position > 5 # 1 2 3 4 5 7 8 9 10
 406   //  * update position 2 -> position 6 # 1 3 4 5 6 7 8 9 10
 407   //  * decrease position when position position > 2 # 1 2 3 4 5 6 7 8 9
 408   await sequelizeTypescript.transaction(async t => {
 409     const newPosition = insertAfter + 1
 410
 411     // Add space after the position when we want to insert our reordered elements (increase)
 412     await VideoPlaylistElementModel.increasePositionOf(videoPlaylist.id, newPosition, null, reorderLength, t)
 413
 414     let oldPosition = start
 415
 416     // We incremented the position of the elements we want to reorder
 417     if (start >= newPosition) oldPosition += reorderLength
 418
 419     const endOldPosition = oldPosition + reorderLength - 1
 420     // Insert our reordered elements in their place (update)
 421     await VideoPlaylistElementModel.reassignPositionOf(videoPlaylist.id, oldPosition, endOldPosition, newPosition, t)
 422
 423     // Decrease positions of elements after the old position of our ordered elements (decrease)
 424     await VideoPlaylistElementModel.increasePositionOf(videoPlaylist.id, oldPosition, null, -reorderLength, t)
 425
 426     videoPlaylist.changed('updatedAt', true)
 427     await videoPlaylist.save({ transaction: t })
 428
 429     await sendUpdateVideoPlaylist(videoPlaylist, t)
 430   })
 431
 432   // The first element changed
 433   if ((start === 1 || insertAfter === 0) && videoPlaylist.hasGeneratedThumbnail()) {
 434     await regeneratePlaylistThumbnail(videoPlaylist)
 435   }
 436
 437   logger.info(
 438     'Reordered playlist %s (inserted after position %d elements %d - %d).',
 439     videoPlaylist.uuid, insertAfter, start, start + reorderLength - 1
 440   )
 441
 442   return res.type('json').status(HttpStatusCode.NO_CONTENT_204).end()
 443 }
 444
 445 async function getVideoPlaylistVideos (req: express.Request, res: express.Response) {
 446   const videoPlaylistInstance = res.locals.videoPlaylistSummary
 447   const user = res.locals.oauth ? res.locals.oauth.token.User : undefined
 448   const server = await getServerActor()
 449
 450   const resultList = await VideoPlaylistElementModel.listForApi({
 451     start: req.query.start,
 452     count: req.query.count,
 453     videoPlaylistId: videoPlaylistInstance.id,
 454     serverAccount: server.Account,
 455     user
 456   })
 457
 458   const options = {
 459     displayNSFW: buildNSFWFilter(res, req.query.nsfw),
 460     accountId: user ? user.Account.id : undefined
 461   }
 462   return res.json(getFormattedObjects(resultList.data, resultList.total, options))
 463 }
 464
 465 async function regeneratePlaylistThumbnail (videoPlaylist: MVideoPlaylistThumbnail) {
 466   await videoPlaylist.Thumbnail.destroy()
 467   videoPlaylist.Thumbnail = null
 468
 469   const firstElement = await VideoPlaylistElementModel.loadFirstElementWithVideoThumbnail(videoPlaylist.id)
 470   if (firstElement) await generateThumbnailForPlaylist(videoPlaylist, firstElement.Video)
 471 }
 472
 473 async function generateThumbnailForPlaylist (videoPlaylist: MVideoPlaylistThumbnail, video: MVideoThumbnail) {
 474   logger.info('Generating default thumbnail to playlist %s.', videoPlaylist.url)
 475
 476   const videoMiniature = video.getMiniature()
 477   if (!videoMiniature) {
 478     logger.info('Cannot generate thumbnail for playlist %s because video %s does not have any.', videoPlaylist.url, video.url)
 479     return
 480   }
 481
 482   const inputPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, videoMiniature.filename)
 483   const thumbnailModel = await updatePlaylistMiniatureFromExisting({
 484     inputPath,
 485     playlist: videoPlaylist,
 486     automaticallyGenerated: true,
 487     keepOriginal: true
 488   })
 489
 490   thumbnailModel.videoPlaylistId = videoPlaylist.id
 491
 492   videoPlaylist.Thumbnail = await thumbnailModel.save()
 493 }