X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fcontrollers%2Fapi%2Fvideos%2Findex.ts;h=91ab8c66aead59a9463a9a04136a80a66d229442;hb=fadf619ad61a016c1c7fc53de5a8f398a4f77519;hp=964db151dc262e3b8f0e2f8edabb4916aff52d1d;hpb=0d0e8dd0904b380b70e19ebcb4763d65601c4632;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/controllers/api/videos/index.ts b/server/controllers/api/videos/index.ts
index 964db151d..91ab8c66a 100644
--- a/server/controllers/api/videos/index.ts
+++ b/server/controllers/api/videos/index.ts
@@ -1,57 +1,50 @@
 import * as express from 'express'
 import * as multer from 'multer'
 import { extname, join } from 'path'
-
-import { database as db } from '../../../initializers/database'
+import { VideoCreate, VideoPrivacy, VideoUpdate } from '../../../../shared'
+import {
+  generateRandomString,
+  getFormattedObjects,
+  getVideoFileHeight,
+  logger,
+  renamePromise,
+  resetSequelizeInstance,
+  retryTransactionWrapper
+} from '../../../helpers'
+import { getServerAccount } from '../../../helpers/utils'
 import {
   CONFIG,
-  REQUEST_VIDEO_QADU_TYPES,
-  REQUEST_VIDEO_EVENT_TYPES,
+  sequelizeTypescript,
   VIDEO_CATEGORIES,
-  VIDEO_LICENCES,
   VIDEO_LANGUAGES,
-  VIDEO_PRIVACIES,
-  VIDEO_MIMETYPE_EXT
+  VIDEO_LICENCES,
+  VIDEO_MIMETYPE_EXT,
+  VIDEO_PRIVACIES
 } from '../../../initializers'
+import { fetchRemoteVideoDescription, getVideoActivityPubUrl, shareVideoByServer } from '../../../lib/activitypub'
+import { sendAddVideo, sendCreateViewToOrigin, sendUpdateVideo } from '../../../lib/activitypub/send'
+import { sendCreateViewToVideoFollowers } from '../../../lib/index'
+import { transcodingJobScheduler } from '../../../lib/jobs/transcoding-job-scheduler'
 import {
-  addEventToRemoteVideo,
-  quickAndDirtyUpdateVideoToFriends,
-  addVideoToFriends,
-  updateVideoToFriends,
-  JobScheduler,
-  fetchRemoteDescription
-} from '../../../lib'
-import {
+  asyncMiddleware,
   authenticate,
   paginationValidator,
-  videosSortValidator,
-  setVideosSort,
   setPagination,
-  setVideosSearch,
-  videosUpdateValidator,
-  videosSearchValidator,
+  setVideosSort,
   videosAddValidator,
   videosGetValidator,
   videosRemoveValidator,
-  asyncMiddleware
+  videosSearchValidator,
+  videosSortValidator,
+  videosUpdateValidator
 } from '../../../middlewares'
-import {
-  logger,
-  retryTransactionWrapper,
-  generateRandomString,
-  getFormattedObjects,
-  renamePromise,
-  getVideoFileHeight,
-  resetSequelizeInstance
-} from '../../../helpers'
-import { VideoInstance } from '../../../models'
-import { VideoCreate, VideoUpdate, VideoPrivacy } from '../../../../shared'
-
+import { TagModel } from '../../../models/video/tag'
+import { VideoModel } from '../../../models/video/video'
+import { VideoFileModel } from '../../../models/video/video-file'
 import { abuseVideoRouter } from './abuse'
 import { blacklistRouter } from './blacklist'
-import { rateVideoRouter } from './rate'
 import { videoChannelRouter } from './channel'
-import { getActivityPubUrl } from '../../../helpers/activitypub'
+import { rateVideoRouter } from './rate'
 
 const videosRouter = express.Router()
 
@@ -72,7 +65,7 @@ const storage = multer.diskStorage({
       randomString = 'fake-random-string'
     }
 
-    cb(null, randomString + '.' + extension)
+    cb(null, randomString + extension)
   }
 })
 
@@ -95,43 +88,45 @@ videosRouter.get('/',
   setPagination,
   asyncMiddleware(listVideos)
 )
+videosRouter.get('/search',
+  videosSearchValidator,
+  paginationValidator,
+  videosSortValidator,
+  setVideosSort,
+  setPagination,
+  asyncMiddleware(searchVideos)
+)
 videosRouter.put('/:id',
   authenticate,
-  videosUpdateValidator,
+  asyncMiddleware(videosUpdateValidator),
   asyncMiddleware(updateVideoRetryWrapper)
 )
 videosRouter.post('/upload',
   authenticate,
   reqFiles,
-  videosAddValidator,
+  asyncMiddleware(videosAddValidator),
   asyncMiddleware(addVideoRetryWrapper)
 )
 
 videosRouter.get('/:id/description',
-  videosGetValidator,
+  asyncMiddleware(videosGetValidator),
   asyncMiddleware(getVideoDescription)
 )
 videosRouter.get('/:id',
-  videosGetValidator,
+  asyncMiddleware(videosGetValidator),
   getVideo
 )
+videosRouter.post('/:id/views',
+  asyncMiddleware(videosGetValidator),
+  asyncMiddleware(viewVideo)
+)
 
 videosRouter.delete('/:id',
   authenticate,
-  videosRemoveValidator,
+  asyncMiddleware(videosRemoveValidator),
   asyncMiddleware(removeVideoRetryWrapper)
 )
 
-videosRouter.get('/search/:value',
-  videosSearchValidator,
-  paginationValidator,
-  videosSortValidator,
-  setVideosSort,
-  setPagination,
-  setVideosSearch,
-  asyncMiddleware(searchVideos)
-)
-
 // ---------------------------------------------------------------------------
 
 export {
@@ -164,59 +159,64 @@ async function addVideoRetryWrapper (req: express.Request, res: express.Response
     errorMessage: 'Cannot insert the video with many retries.'
   }
 
-  await retryTransactionWrapper(addVideo, options)
+  const video = await retryTransactionWrapper(addVideo, options)
 
-  // TODO : include Location of the new video -> 201
-  res.type('json').status(204).end()
+  res.json({
+    video: {
+      id: video.id,
+      uuid: video.uuid
+    }
+  }).end()
 }
 
 async function addVideo (req: express.Request, res: express.Response, videoPhysicalFile: Express.Multer.File) {
   const videoInfo: VideoCreate = req.body
-  let videoUUID = ''
 
-  await db.sequelize.transaction(async t => {
-    const sequelizeOptions = { transaction: t }
+  // Prepare data so we don't block the transaction
+  const videoData = {
+    name: videoInfo.name,
+    remote: false,
+    extname: extname(videoPhysicalFile.filename),
+    category: videoInfo.category,
+    licence: videoInfo.licence,
+    language: videoInfo.language,
+    nsfw: videoInfo.nsfw,
+    description: videoInfo.description,
+    privacy: videoInfo.privacy,
+    duration: videoPhysicalFile['duration'], // duration was added by a previous middleware
+    channelId: res.locals.videoChannel.id
+  }
+  const video = new VideoModel(videoData)
+  video.url = getVideoActivityPubUrl(video)
 
-    const videoData = {
-      name: videoInfo.name,
-      remote: false,
-      extname: extname(videoPhysicalFile.filename),
-      category: videoInfo.category,
-      licence: videoInfo.licence,
-      language: videoInfo.language,
-      nsfw: videoInfo.nsfw,
-      description: videoInfo.description,
-      privacy: videoInfo.privacy,
-      duration: videoPhysicalFile['duration'], // duration was added by a previous middleware
-      channelId: res.locals.videoChannel.id
-    }
-    const video = db.Video.build(videoData)
-    video.url = getActivityPubUrl('video', video.uuid)
+  const videoFilePath = join(CONFIG.STORAGE.VIDEOS_DIR, videoPhysicalFile.filename)
+  const videoFileHeight = await getVideoFileHeight(videoFilePath)
 
-    const videoFilePath = join(CONFIG.STORAGE.VIDEOS_DIR, videoPhysicalFile.filename)
-    const videoFileHeight = await getVideoFileHeight(videoFilePath)
+  const videoFileData = {
+    extname: extname(videoPhysicalFile.filename),
+    resolution: videoFileHeight,
+    size: videoPhysicalFile.size
+  }
+  const videoFile = new VideoFileModel(videoFileData)
+  const videoDir = CONFIG.STORAGE.VIDEOS_DIR
+  const source = join(videoDir, videoPhysicalFile.filename)
+  const destination = join(videoDir, video.getVideoFilename(videoFile))
 
-    const videoFileData = {
-      extname: extname(videoPhysicalFile.filename),
-      resolution: videoFileHeight,
-      size: videoPhysicalFile.size
-    }
-    const videoFile = db.VideoFile.build(videoFileData)
-    const videoDir = CONFIG.STORAGE.VIDEOS_DIR
-    const source = join(videoDir, videoPhysicalFile.filename)
-    const destination = join(videoDir, video.getVideoFilename(videoFile))
+  await renamePromise(source, destination)
+  // This is important in case if there is another attempt in the retry process
+  videoPhysicalFile.filename = video.getVideoFilename(videoFile)
 
-    await renamePromise(source, destination)
-    // This is important in case if there is another attempt in the retry process
-    videoPhysicalFile.filename = video.getVideoFilename(videoFile)
+  const tasks = []
 
-    const tasks = []
+  tasks.push(
+    video.createTorrentAndSetInfoHash(videoFile),
+    video.createThumbnail(videoFile),
+    video.createPreview(videoFile)
+  )
+  await Promise.all(tasks)
 
-    tasks.push(
-      video.createTorrentAndSetInfoHash(videoFile),
-      video.createThumbnail(videoFile),
-      video.createPreview(videoFile)
-    )
+  return sequelizeTypescript.transaction(async t => {
+    const sequelizeOptions = { transaction: t }
 
     if (CONFIG.TRANSCODING.ENABLED === true) {
       // Put uuid because we don't have id auto incremented for now
@@ -224,40 +224,37 @@ async function addVideo (req: express.Request, res: express.Response, videoPhysi
         videoUUID: video.uuid
       }
 
-      tasks.push(
-        JobScheduler.Instance.createJob(t, 'videoFileOptimizer', dataInput)
-      )
+      await transcodingJobScheduler.createJob(t, 'videoFileOptimizer', dataInput)
     }
-    await Promise.all(tasks)
 
     const videoCreated = await video.save(sequelizeOptions)
     // Do not forget to add video channel information to the created video
     videoCreated.VideoChannel = res.locals.videoChannel
-    videoUUID = videoCreated.uuid
 
     videoFile.videoId = video.id
-
     await videoFile.save(sequelizeOptions)
-    video.VideoFiles = [videoFile]
+
+    video.VideoFiles = [ videoFile ]
 
     if (videoInfo.tags) {
-      const tagInstances = await db.Tag.findOrCreateTags(videoInfo.tags, t)
+      const tagInstances = await TagModel.findOrCreateTags(videoInfo.tags, t)
 
-      await video.setTags(tagInstances, sequelizeOptions)
+      await video.$set('Tags', tagInstances, sequelizeOptions)
       video.Tags = tagInstances
     }
 
     // Let transcoding job send the video to friends because the video file extension might change
-    if (CONFIG.TRANSCODING.ENABLED === true) return undefined
-    // Don't send video to remote pods, it is private
-    if (video.privacy === VideoPrivacy.PRIVATE) return undefined
+    if (CONFIG.TRANSCODING.ENABLED === true) return videoCreated
+    // Don't send video to remote servers, it is private
+    if (video.privacy === VideoPrivacy.PRIVATE) return videoCreated
 
-    const remoteVideo = await video.toAddRemoteJSON()
-    // Now we'll add the video's meta data to our friends
-    return addVideoToFriends(remoteVideo, t)
-  })
+    await sendAddVideo(video, t)
+    await shareVideoByServer(video, t)
+
+    logger.info('Video with name %s and uuid %s created.', videoInfo.name, videoCreated.uuid)
 
-  logger.info('Video with name %s and uuid %s created.', videoInfo.name, videoUUID)
+    return videoCreated
+  })
 }
 
 async function updateVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
@@ -272,13 +269,13 @@ async function updateVideoRetryWrapper (req: express.Request, res: express.Respo
 }
 
 async function updateVideo (req: express.Request, res: express.Response) {
-  const videoInstance = res.locals.video
+  const videoInstance: VideoModel = res.locals.video
   const videoFieldsSave = videoInstance.toJSON()
   const videoInfoToUpdate: VideoUpdate = req.body
   const wasPrivateVideo = videoInstance.privacy === VideoPrivacy.PRIVATE
 
   try {
-    await db.sequelize.transaction(async t => {
+    await sequelizeTypescript.transaction(async t => {
       const sequelizeOptions = {
         transaction: t
       }
@@ -288,28 +285,27 @@ async function updateVideo (req: express.Request, res: express.Response) {
       if (videoInfoToUpdate.licence !== undefined) videoInstance.set('licence', videoInfoToUpdate.licence)
       if (videoInfoToUpdate.language !== undefined) videoInstance.set('language', videoInfoToUpdate.language)
       if (videoInfoToUpdate.nsfw !== undefined) videoInstance.set('nsfw', videoInfoToUpdate.nsfw)
-      if (videoInfoToUpdate.privacy !== undefined) videoInstance.set('privacy', videoInfoToUpdate.privacy)
+      if (videoInfoToUpdate.privacy !== undefined) videoInstance.set('privacy', parseInt(videoInfoToUpdate.privacy.toString(), 10))
       if (videoInfoToUpdate.description !== undefined) videoInstance.set('description', videoInfoToUpdate.description)
 
-      await videoInstance.save(sequelizeOptions)
+      const videoInstanceUpdated = await videoInstance.save(sequelizeOptions)
 
       if (videoInfoToUpdate.tags) {
-        const tagInstances = await db.Tag.findOrCreateTags(videoInfoToUpdate.tags, t)
+        const tagInstances = await TagModel.findOrCreateTags(videoInfoToUpdate.tags, t)
 
-        await videoInstance.setTags(tagInstances, sequelizeOptions)
+        await videoInstance.$set('Tags', tagInstances, sequelizeOptions)
         videoInstance.Tags = tagInstances
       }
 
       // Now we'll update the video's meta data to our friends
       if (wasPrivateVideo === false) {
-        const json = videoInstance.toUpdateRemoteJSON()
-        return updateVideoToFriends(json, t)
+        await sendUpdateVideo(videoInstanceUpdated, t)
       }
 
-      // Video is not private anymore, send a create action to remote pods
-      if (wasPrivateVideo === true && videoInstance.privacy !== VideoPrivacy.PRIVATE) {
-        const remoteVideo = await videoInstance.toAddRemoteJSON()
-        return addVideoToFriends(remoteVideo, t)
+      // Video is not private anymore, send a create action to remote servers
+      if (wasPrivateVideo === true && videoInstanceUpdated.privacy !== VideoPrivacy.PRIVATE) {
+        await sendAddVideo(videoInstanceUpdated, t)
+        await shareVideoByServer(videoInstanceUpdated, t)
       }
     })
 
@@ -327,31 +323,22 @@ async function updateVideo (req: express.Request, res: express.Response) {
 function getVideo (req: express.Request, res: express.Response) {
   const videoInstance = res.locals.video
 
+  return res.json(videoInstance.toFormattedDetailsJSON())
+}
+
+async function viewVideo (req: express.Request, res: express.Response) {
+  const videoInstance = res.locals.video
+
+  await videoInstance.increment('views')
+  const serverAccount = await getServerAccount()
+
   if (videoInstance.isOwned()) {
-    // The increment is done directly in the database, not using the instance value
-    // FIXME: make a real view system
-    // For example, only add a view when a user watch a video during 30s etc
-    videoInstance.increment('views')
-      .then(() => {
-        const qaduParams = {
-          videoId: videoInstance.id,
-          type: REQUEST_VIDEO_QADU_TYPES.VIEWS
-        }
-        return quickAndDirtyUpdateVideoToFriends(qaduParams)
-      })
-      .catch(err => logger.error('Cannot add view to video %s.', videoInstance.uuid, err))
+    await sendCreateViewToVideoFollowers(serverAccount, videoInstance, undefined)
   } else {
-    // Just send the event to our friends
-    const eventParams = {
-      videoId: videoInstance.id,
-      type: REQUEST_VIDEO_EVENT_TYPES.VIEWS
-    }
-    addEventToRemoteVideo(eventParams)
-      .catch(err => logger.error('Cannot add event to remote video %s.', videoInstance.uuid, err))
+    await sendCreateViewToOrigin(serverAccount, videoInstance, undefined)
   }
 
-  // Do not wait the view system
-  return res.json(videoInstance.toFormattedDetailsJSON())
+  return res.status(204).end()
 }
 
 async function getVideoDescription (req: express.Request, res: express.Response) {
@@ -361,14 +348,14 @@ async function getVideoDescription (req: express.Request, res: express.Response)
   if (videoInstance.isOwned()) {
     description = videoInstance.description
   } else {
-    description = await fetchRemoteDescription(videoInstance)
+    description = await fetchRemoteVideoDescription(videoInstance)
   }
 
   return res.json({ description })
 }
 
 async function listVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const resultList = await db.Video.listForApi(req.query.start, req.query.count, req.query.sort)
+  const resultList = await VideoModel.listForApi(req.query.start, req.query.count, req.query.sort)
 
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
@@ -385,9 +372,9 @@ async function removeVideoRetryWrapper (req: express.Request, res: express.Respo
 }
 
 async function removeVideo (req: express.Request, res: express.Response) {
-  const videoInstance: VideoInstance = res.locals.video
+  const videoInstance: VideoModel = res.locals.video
 
-  await db.sequelize.transaction(async t => {
+  await sequelizeTypescript.transaction(async t => {
     await videoInstance.destroy({ transaction: t })
   })
 
@@ -395,9 +382,8 @@ async function removeVideo (req: express.Request, res: express.Response) {
 }
 
 async function searchVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const resultList = await db.Video.searchAndPopulateAuthorAndPodAndTags(
-    req.params.value,
-    req.query.field,
+  const resultList = await VideoModel.searchAndPopulateAccountAndServerAndTags(
+    req.query.search,
     req.query.start,
     req.query.count,
     req.query.sort