430 lines
13 KiB
TypeScript
430 lines
13 KiB
TypeScript
import * as express from 'express'
|
|
import * as Promise from 'bluebird'
|
|
import * as multer from 'multer'
|
|
import { extname, join } from 'path'
|
|
|
|
import { database as db } from '../../../initializers/database'
|
|
import {
|
|
CONFIG,
|
|
REQUEST_VIDEO_QADU_TYPES,
|
|
REQUEST_VIDEO_EVENT_TYPES,
|
|
VIDEO_CATEGORIES,
|
|
VIDEO_LICENCES,
|
|
VIDEO_LANGUAGES
|
|
} from '../../../initializers'
|
|
import {
|
|
addEventToRemoteVideo,
|
|
quickAndDirtyUpdateVideoToFriends,
|
|
addVideoToFriends,
|
|
updateVideoToFriends,
|
|
JobScheduler
|
|
} from '../../../lib'
|
|
import {
|
|
authenticate,
|
|
paginationValidator,
|
|
videosSortValidator,
|
|
setVideosSort,
|
|
setPagination,
|
|
setVideosSearch,
|
|
videosUpdateValidator,
|
|
videosSearchValidator,
|
|
videosAddValidator,
|
|
videosGetValidator,
|
|
videosRemoveValidator
|
|
} from '../../../middlewares'
|
|
import {
|
|
logger,
|
|
retryTransactionWrapper,
|
|
generateRandomString,
|
|
getFormattedObjects,
|
|
renamePromise,
|
|
getVideoFileHeight
|
|
} from '../../../helpers'
|
|
import { TagInstance, VideoInstance } from '../../../models'
|
|
import { VideoCreate, VideoUpdate } from '../../../../shared'
|
|
|
|
import { abuseVideoRouter } from './abuse'
|
|
import { blacklistRouter } from './blacklist'
|
|
import { rateVideoRouter } from './rate'
|
|
import { videoChannelRouter } from './channel'
|
|
|
|
const videosRouter = express.Router()
|
|
|
|
// multer configuration
|
|
const storage = multer.diskStorage({
|
|
destination: (req, file, cb) => {
|
|
cb(null, CONFIG.STORAGE.VIDEOS_DIR)
|
|
},
|
|
|
|
filename: (req, file, cb) => {
|
|
let extension = ''
|
|
if (file.mimetype === 'video/webm') extension = 'webm'
|
|
else if (file.mimetype === 'video/mp4') extension = 'mp4'
|
|
else if (file.mimetype === 'video/ogg') extension = 'ogv'
|
|
generateRandomString(16)
|
|
.then(randomString => {
|
|
cb(null, randomString + '.' + extension)
|
|
})
|
|
.catch(err => {
|
|
logger.error('Cannot generate random string for file name.', err)
|
|
throw err
|
|
})
|
|
}
|
|
})
|
|
|
|
const reqFiles = multer({ storage: storage }).fields([{ name: 'videofile', maxCount: 1 }])
|
|
|
|
videosRouter.use('/', abuseVideoRouter)
|
|
videosRouter.use('/', blacklistRouter)
|
|
videosRouter.use('/', rateVideoRouter)
|
|
videosRouter.use('/', videoChannelRouter)
|
|
|
|
videosRouter.get('/categories', listVideoCategories)
|
|
videosRouter.get('/licences', listVideoLicences)
|
|
videosRouter.get('/languages', listVideoLanguages)
|
|
|
|
videosRouter.get('/',
|
|
paginationValidator,
|
|
videosSortValidator,
|
|
setVideosSort,
|
|
setPagination,
|
|
listVideos
|
|
)
|
|
videosRouter.put('/:id',
|
|
authenticate,
|
|
videosUpdateValidator,
|
|
updateVideoRetryWrapper
|
|
)
|
|
videosRouter.post('/upload',
|
|
authenticate,
|
|
reqFiles,
|
|
videosAddValidator,
|
|
addVideoRetryWrapper
|
|
)
|
|
videosRouter.get('/:id',
|
|
videosGetValidator,
|
|
getVideo
|
|
)
|
|
|
|
videosRouter.delete('/:id',
|
|
authenticate,
|
|
videosRemoveValidator,
|
|
removeVideoRetryWrapper
|
|
)
|
|
|
|
videosRouter.get('/search/:value',
|
|
videosSearchValidator,
|
|
paginationValidator,
|
|
videosSortValidator,
|
|
setVideosSort,
|
|
setPagination,
|
|
setVideosSearch,
|
|
searchVideos
|
|
)
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export {
|
|
videosRouter
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function listVideoCategories (req: express.Request, res: express.Response) {
|
|
res.json(VIDEO_CATEGORIES)
|
|
}
|
|
|
|
function listVideoLicences (req: express.Request, res: express.Response) {
|
|
res.json(VIDEO_LICENCES)
|
|
}
|
|
|
|
function listVideoLanguages (req: express.Request, res: express.Response) {
|
|
res.json(VIDEO_LANGUAGES)
|
|
}
|
|
|
|
// Wrapper to video add that retry the function if there is a database error
|
|
// We need this because we run the transaction in SERIALIZABLE isolation that can fail
|
|
function addVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
|
|
const options = {
|
|
arguments: [ req, res, req.files['videofile'][0] ],
|
|
errorMessage: 'Cannot insert the video with many retries.'
|
|
}
|
|
|
|
retryTransactionWrapper(addVideo, options)
|
|
.then(() => {
|
|
// TODO : include Location of the new video -> 201
|
|
res.type('json').status(204).end()
|
|
})
|
|
.catch(err => next(err))
|
|
}
|
|
|
|
function addVideo (req: express.Request, res: express.Response, videoPhysicalFile: Express.Multer.File) {
|
|
const videoInfo: VideoCreate = req.body
|
|
let videoUUID = ''
|
|
|
|
return db.sequelize.transaction(t => {
|
|
let p: Promise<TagInstance[]>
|
|
|
|
if (!videoInfo.tags) p = Promise.resolve(undefined)
|
|
else p = db.Tag.findOrCreateTags(videoInfo.tags, t)
|
|
|
|
return p
|
|
.then(tagInstances => {
|
|
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,
|
|
duration: videoPhysicalFile['duration'], // duration was added by a previous middleware
|
|
channelId: res.locals.videoChannel.id
|
|
}
|
|
|
|
const video = db.Video.build(videoData)
|
|
return { tagInstances, video }
|
|
})
|
|
.then(({ tagInstances, video }) => {
|
|
const videoFilePath = join(CONFIG.STORAGE.VIDEOS_DIR, videoPhysicalFile.filename)
|
|
return getVideoFileHeight(videoFilePath)
|
|
.then(height => ({ tagInstances, video, videoFileHeight: height }))
|
|
})
|
|
.then(({ tagInstances, video, videoFileHeight }) => {
|
|
const videoFileData = {
|
|
extname: extname(videoPhysicalFile.filename),
|
|
resolution: videoFileHeight,
|
|
size: videoPhysicalFile.size
|
|
}
|
|
|
|
const videoFile = db.VideoFile.build(videoFileData)
|
|
return { tagInstances, video, videoFile }
|
|
})
|
|
.then(({ tagInstances, video, videoFile }) => {
|
|
const videoDir = CONFIG.STORAGE.VIDEOS_DIR
|
|
const source = join(videoDir, videoPhysicalFile.filename)
|
|
const destination = join(videoDir, video.getVideoFilename(videoFile))
|
|
|
|
return renamePromise(source, destination)
|
|
.then(() => {
|
|
// This is important in case if there is another attempt in the retry process
|
|
videoPhysicalFile.filename = video.getVideoFilename(videoFile)
|
|
return { tagInstances, video, videoFile }
|
|
})
|
|
})
|
|
.then(({ tagInstances, video, videoFile }) => {
|
|
const tasks = []
|
|
|
|
tasks.push(
|
|
video.createTorrentAndSetInfoHash(videoFile),
|
|
video.createThumbnail(videoFile),
|
|
video.createPreview(videoFile)
|
|
)
|
|
|
|
if (CONFIG.TRANSCODING.ENABLED === true) {
|
|
// Put uuid because we don't have id auto incremented for now
|
|
const dataInput = {
|
|
videoUUID: video.uuid
|
|
}
|
|
|
|
tasks.push(
|
|
JobScheduler.Instance.createJob(t, 'videoFileOptimizer', dataInput)
|
|
)
|
|
}
|
|
|
|
return Promise.all(tasks).then(() => ({ tagInstances, video, videoFile }))
|
|
})
|
|
.then(({ tagInstances, video, videoFile }) => {
|
|
const options = { transaction: t }
|
|
|
|
return video.save(options)
|
|
.then(videoCreated => {
|
|
// Do not forget to add video channel information to the created video
|
|
videoCreated.VideoChannel = res.locals.videoChannel
|
|
videoUUID = videoCreated.uuid
|
|
|
|
return { tagInstances, video: videoCreated, videoFile }
|
|
})
|
|
})
|
|
.then(({ tagInstances, video, videoFile }) => {
|
|
const options = { transaction: t }
|
|
videoFile.videoId = video.id
|
|
|
|
return videoFile.save(options)
|
|
.then(() => video.VideoFiles = [ videoFile ])
|
|
.then(() => ({ tagInstances, video }))
|
|
})
|
|
.then(({ tagInstances, video }) => {
|
|
if (!tagInstances) return video
|
|
|
|
const options = { transaction: t }
|
|
return video.setTags(tagInstances, options)
|
|
.then(() => {
|
|
video.Tags = tagInstances
|
|
return video
|
|
})
|
|
})
|
|
.then(video => {
|
|
// Let transcoding job send the video to friends because the video file extension might change
|
|
if (CONFIG.TRANSCODING.ENABLED === true) return undefined
|
|
|
|
return video.toAddRemoteJSON()
|
|
.then(remoteVideo => {
|
|
// Now we'll add the video's meta data to our friends
|
|
return addVideoToFriends(remoteVideo, t)
|
|
})
|
|
})
|
|
})
|
|
.then(() => logger.info('Video with name %s and uuid %s created.', videoInfo.name, videoUUID))
|
|
.catch((err: Error) => {
|
|
logger.debug('Cannot insert the video.', err)
|
|
throw err
|
|
})
|
|
}
|
|
|
|
function updateVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
|
|
const options = {
|
|
arguments: [ req, res ],
|
|
errorMessage: 'Cannot update the video with many retries.'
|
|
}
|
|
|
|
retryTransactionWrapper(updateVideo, options)
|
|
.then(() => {
|
|
return res.type('json').status(204).end()
|
|
})
|
|
.catch(err => next(err))
|
|
}
|
|
|
|
function updateVideo (req: express.Request, res: express.Response) {
|
|
const videoInstance = res.locals.video
|
|
const videoFieldsSave = videoInstance.toJSON()
|
|
const videoInfoToUpdate: VideoUpdate = req.body
|
|
|
|
return db.sequelize.transaction(t => {
|
|
let tagsPromise: Promise<TagInstance[]>
|
|
if (!videoInfoToUpdate.tags) {
|
|
tagsPromise = Promise.resolve(null)
|
|
} else {
|
|
tagsPromise = db.Tag.findOrCreateTags(videoInfoToUpdate.tags, t)
|
|
}
|
|
|
|
return tagsPromise
|
|
.then(tagInstances => {
|
|
const options = {
|
|
transaction: t
|
|
}
|
|
|
|
if (videoInfoToUpdate.name !== undefined) videoInstance.set('name', videoInfoToUpdate.name)
|
|
if (videoInfoToUpdate.category !== undefined) videoInstance.set('category', videoInfoToUpdate.category)
|
|
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.description !== undefined) videoInstance.set('description', videoInfoToUpdate.description)
|
|
|
|
return videoInstance.save(options).then(() => tagInstances)
|
|
})
|
|
.then(tagInstances => {
|
|
if (!tagInstances) return
|
|
|
|
const options = { transaction: t }
|
|
return videoInstance.setTags(tagInstances, options)
|
|
.then(() => {
|
|
videoInstance.Tags = tagInstances
|
|
|
|
return
|
|
})
|
|
})
|
|
.then(() => {
|
|
const json = videoInstance.toUpdateRemoteJSON()
|
|
|
|
// Now we'll update the video's meta data to our friends
|
|
return updateVideoToFriends(json, t)
|
|
})
|
|
})
|
|
.then(() => {
|
|
logger.info('Video with name %s and uuid %s updated.', videoInstance.name, videoInstance.uuid)
|
|
})
|
|
.catch(err => {
|
|
logger.debug('Cannot update the video.', err)
|
|
|
|
// Force fields we want to update
|
|
// If the transaction is retried, sequelize will think the object has not changed
|
|
// So it will skip the SQL request, even if the last one was ROLLBACKed!
|
|
Object.keys(videoFieldsSave).forEach(key => {
|
|
const value = videoFieldsSave[key]
|
|
videoInstance.set(key, value)
|
|
})
|
|
|
|
throw err
|
|
})
|
|
}
|
|
|
|
function getVideo (req: express.Request, res: express.Response) {
|
|
const videoInstance = res.locals.video
|
|
|
|
if (videoInstance.isOwned()) {
|
|
// The increment is done directly in the database, not using the instance value
|
|
videoInstance.increment('views')
|
|
.then(() => {
|
|
// FIXME: make a real view system
|
|
// For example, only add a view when a user watch a video during 30s etc
|
|
const qaduParams = {
|
|
videoId: videoInstance.id,
|
|
type: REQUEST_VIDEO_QADU_TYPES.VIEWS
|
|
}
|
|
return quickAndDirtyUpdateVideoToFriends(qaduParams)
|
|
})
|
|
.catch(err => logger.error('Cannot add view to video %d.', videoInstance.id, err))
|
|
} else {
|
|
// Just send the event to our friends
|
|
const eventParams = {
|
|
videoId: videoInstance.id,
|
|
type: REQUEST_VIDEO_EVENT_TYPES.VIEWS
|
|
}
|
|
addEventToRemoteVideo(eventParams)
|
|
}
|
|
|
|
// Do not wait the view system
|
|
res.json(videoInstance.toFormattedDetailsJSON())
|
|
}
|
|
|
|
function listVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
|
|
db.Video.listForApi(req.query.start, req.query.count, req.query.sort)
|
|
.then(result => res.json(getFormattedObjects(result.data, result.total)))
|
|
.catch(err => next(err))
|
|
}
|
|
|
|
function removeVideoRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
|
|
const options = {
|
|
arguments: [ req, res ],
|
|
errorMessage: 'Cannot remove the video with many retries.'
|
|
}
|
|
|
|
retryTransactionWrapper(removeVideo, options)
|
|
.then(() => {
|
|
return res.type('json').status(204).end()
|
|
})
|
|
.catch(err => next(err))
|
|
}
|
|
|
|
function removeVideo (req: express.Request, res: express.Response) {
|
|
const videoInstance: VideoInstance = res.locals.video
|
|
|
|
return db.sequelize.transaction(t => {
|
|
return videoInstance.destroy({ transaction: t })
|
|
})
|
|
.then(() => {
|
|
logger.info('Video with name %s and uuid %s deleted.', videoInstance.name, videoInstance.uuid)
|
|
})
|
|
.catch(err => {
|
|
logger.error('Errors when removed the video.', err)
|
|
throw err
|
|
})
|
|
}
|
|
|
|
function searchVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
|
|
db.Video.searchAndPopulateAuthorAndPodAndTags(req.params.value, req.query.field, req.query.start, req.query.count, req.query.sort)
|
|
.then(result => res.json(getFormattedObjects(result.data, result.total)))
|
|
.catch(err => next(err))
|
|
}
|