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