import * as express from 'express'
import { extname, join } from 'path'
import { VideoCreate, VideoPrivacy, VideoState, VideoUpdate } from '../../../../shared'
-import { renamePromise } from '../../../helpers/core-utils'
-import { getVideoFileResolution } from '../../../helpers/ffmpeg-utils'
+import { getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffmpeg-utils'
import { processImage } from '../../../helpers/image-utils'
import { logger } from '../../../helpers/logger'
-import { getFormattedObjects, getServerActor, resetSequelizeInstance } from '../../../helpers/utils'
+import { auditLoggerFactory, getAuditIdFromRes, VideoAuditView } from '../../../helpers/audit-logger'
+import { getFormattedObjects, getServerActor } from '../../../helpers/utils'
import {
CONFIG,
- IMAGE_MIMETYPE_EXT,
+ MIMETYPES,
PREVIEWS_SIZE,
sequelizeTypescript,
THUMBNAILS_SIZE,
VIDEO_CATEGORIES,
VIDEO_LANGUAGES,
VIDEO_LICENCES,
- VIDEO_MIMETYPE_EXT,
VIDEO_PRIVACIES
} from '../../../initializers'
import {
asyncMiddleware,
asyncRetryTransactionMiddleware,
authenticate,
+ checkVideoFollowConstraints,
+ commonVideosFiltersValidator,
optionalAuthenticate,
paginationValidator,
setDefaultPagination,
videosAddValidator,
videosGetValidator,
videosRemoveValidator,
- videosSearchValidator,
videosSortValidator,
videosUpdateValidator
} from '../../../middlewares'
import { blacklistRouter } from './blacklist'
import { videoCommentRouter } from './comment'
import { rateVideoRouter } from './rate'
+import { ownershipVideoRouter } from './ownership'
import { VideoFilter } from '../../../../shared/models/videos/video-query.type'
-import { VideoSortField } from '../../../../client/src/app/shared/video/sort-field.type'
-import { createReqFiles, isNSFWHidden } from '../../../helpers/express-utils'
+import { buildNSFWFilter, createReqFiles } from '../../../helpers/express-utils'
import { ScheduleVideoUpdateModel } from '../../../models/video/schedule-video-update'
-
+import { videoCaptionsRouter } from './captions'
+import { videoImportsRouter } from './import'
+import { resetSequelizeInstance } from '../../../helpers/database-utils'
+import { move } from 'fs-extra'
+import { watchingRouter } from './watching'
+import { Notifier } from '../../../lib/notifier'
+
+const auditLogger = auditLoggerFactory('videos')
const videosRouter = express.Router()
const reqVideoFileAdd = createReqFiles(
[ 'videofile', 'thumbnailfile', 'previewfile' ],
- Object.assign({}, VIDEO_MIMETYPE_EXT, IMAGE_MIMETYPE_EXT),
+ Object.assign({}, MIMETYPES.VIDEO.MIMETYPE_EXT, MIMETYPES.IMAGE.MIMETYPE_EXT),
{
- videofile: CONFIG.STORAGE.VIDEOS_DIR,
- thumbnailfile: CONFIG.STORAGE.THUMBNAILS_DIR,
- previewfile: CONFIG.STORAGE.PREVIEWS_DIR
+ videofile: CONFIG.STORAGE.TMP_DIR,
+ thumbnailfile: CONFIG.STORAGE.TMP_DIR,
+ previewfile: CONFIG.STORAGE.TMP_DIR
}
)
const reqVideoFileUpdate = createReqFiles(
[ 'thumbnailfile', 'previewfile' ],
- IMAGE_MIMETYPE_EXT,
+ MIMETYPES.IMAGE.MIMETYPE_EXT,
{
- thumbnailfile: CONFIG.STORAGE.THUMBNAILS_DIR,
- previewfile: CONFIG.STORAGE.PREVIEWS_DIR
+ thumbnailfile: CONFIG.STORAGE.TMP_DIR,
+ previewfile: CONFIG.STORAGE.TMP_DIR
}
)
videosRouter.use('/', blacklistRouter)
videosRouter.use('/', rateVideoRouter)
videosRouter.use('/', videoCommentRouter)
+videosRouter.use('/', videoCaptionsRouter)
+videosRouter.use('/', videoImportsRouter)
+videosRouter.use('/', ownershipVideoRouter)
+videosRouter.use('/', watchingRouter)
videosRouter.get('/categories', listVideoCategories)
videosRouter.get('/licences', listVideoLicences)
setDefaultSort,
setDefaultPagination,
optionalAuthenticate,
+ commonVideosFiltersValidator,
asyncMiddleware(listVideos)
)
-videosRouter.get('/search',
- videosSearchValidator,
- paginationValidator,
- videosSortValidator,
- setDefaultSort,
- setDefaultPagination,
- optionalAuthenticate,
- asyncMiddleware(searchVideos)
-)
videosRouter.put('/:id',
authenticate,
reqVideoFileUpdate,
asyncMiddleware(getVideoDescription)
)
videosRouter.get('/:id',
+ optionalAuthenticate,
asyncMiddleware(videosGetValidator),
+ asyncMiddleware(checkVideoFollowConstraints),
getVideo
)
videosRouter.post('/:id/views',
}
async function addVideo (req: express.Request, res: express.Response) {
+ // Processing the video could be long
+ // Set timeout to 10 minutes
+ req.setTimeout(1000 * 60 * 10, () => {
+ logger.error('Upload video has timed out.')
+ return res.sendStatus(408)
+ })
+
const videoPhysicalFile = req.files['videofile'][0]
const videoInfo: VideoCreate = req.body
const videoData = {
name: videoInfo.name,
remote: false,
- extname: extname(videoPhysicalFile.filename),
category: videoInfo.category,
licence: videoInfo.licence,
language: videoInfo.language,
// Build the file object
const { videoFileResolution } = await getVideoFileResolution(videoPhysicalFile.path)
+ const fps = await getVideoFileFPS(videoPhysicalFile.path)
+
const videoFileData = {
extname: extname(videoPhysicalFile.filename),
resolution: videoFileResolution,
- size: videoPhysicalFile.size
+ size: videoPhysicalFile.size,
+ fps
}
const videoFile = new VideoFileModel(videoFileData)
// Move physical file
const videoDir = CONFIG.STORAGE.VIDEOS_DIR
const destination = join(videoDir, video.getVideoFilename(videoFile))
- await renamePromise(videoPhysicalFile.path, destination)
+ await move(videoPhysicalFile.path, destination)
// This is important in case if there is another attempt in the retry process
videoPhysicalFile.filename = video.getVideoFilename(videoFile)
videoPhysicalFile.path = destination
await federateVideoIfNeeded(video, true, t)
+ auditLogger.create(getAuditIdFromRes(res), new VideoAuditView(videoCreated.toFormattedDetailsJSON()))
logger.info('Video with name %s and uuid %s created.', videoInfo.name, videoCreated.uuid)
return videoCreated
})
+ Notifier.Instance.notifyOnNewVideo(videoCreated)
+
if (video.state === VideoState.TO_TRANSCODE) {
// Put uuid because we don't have id auto incremented for now
const dataInput = {
async function updateVideo (req: express.Request, res: express.Response) {
const videoInstance: VideoModel = res.locals.video
const videoFieldsSave = videoInstance.toJSON()
+ const oldVideoAuditView = new VideoAuditView(videoInstance.toFormattedDetailsJSON())
const videoInfoToUpdate: VideoUpdate = req.body
const wasPrivateVideo = videoInstance.privacy === VideoPrivacy.PRIVATE
+ const wasUnlistedVideo = videoInstance.privacy === VideoPrivacy.UNLISTED
// Process thumbnail or create it from the video
if (req.files && req.files['thumbnailfile']) {
}
try {
- await sequelizeTypescript.transaction(async t => {
- const sequelizeOptions = {
- transaction: t
- }
+ const videoInstanceUpdated = await sequelizeTypescript.transaction(async t => {
+ const sequelizeOptions = { transaction: t }
const oldVideoChannel = videoInstance.VideoChannel
if (videoInfoToUpdate.name !== undefined) videoInstance.set('name', videoInfoToUpdate.name)
}
const isNewVideo = wasPrivateVideo && videoInstanceUpdated.privacy !== VideoPrivacy.PRIVATE
- await federateVideoIfNeeded(videoInstanceUpdated, isNewVideo, t)
+
+ // Don't send update if the video was unfederated
+ if (!videoInstanceUpdated.VideoBlacklist || videoInstanceUpdated.VideoBlacklist.unfederated === false) {
+ await federateVideoIfNeeded(videoInstanceUpdated, isNewVideo, t)
+ }
+
+ auditLogger.update(
+ getAuditIdFromRes(res),
+ new VideoAuditView(videoInstanceUpdated.toFormattedDetailsJSON()),
+ oldVideoAuditView
+ )
+ logger.info('Video with name %s and uuid %s updated.', videoInstance.name, videoInstance.uuid)
+
+ return videoInstanceUpdated
})
- logger.info('Video with name %s and uuid %s updated.', videoInstance.name, videoInstance.uuid)
+ if (wasUnlistedVideo || wasPrivateVideo) {
+ Notifier.Instance.notifyOnNewVideo(videoInstanceUpdated)
+ }
} catch (err) {
// Force fields we want to update
// If the transaction is retried, sequelize will think the object has not changed
function getVideo (req: express.Request, res: express.Response) {
const videoInstance = res.locals.video
+ if (videoInstance.isOutdated()) {
+ JobQueue.Instance.createJob({ type: 'activitypub-refresher', payload: { type: 'video', videoUrl: videoInstance.url } })
+ .catch(err => logger.error('Cannot create AP refresher job for video %s.', videoInstance.url, { err }))
+ }
+
return res.json(videoInstance.toFormattedDetailsJSON())
}
const videoInstance = res.locals.video
const ip = req.ip
- const exists = await Redis.Instance.isViewExists(ip, videoInstance.uuid)
+ const exists = await Redis.Instance.isVideoIPViewExists(ip, videoInstance.uuid)
if (exists) {
logger.debug('View for ip %s and video %s already exists.', ip, videoInstance.uuid)
return res.status(204).end()
}
- await videoInstance.increment('views')
- await Redis.Instance.setView(ip, videoInstance.uuid)
-
- const serverAccount = await getServerActor()
+ await Promise.all([
+ Redis.Instance.addVideoView(videoInstance.id),
+ Redis.Instance.setIPVideoView(ip, videoInstance.uuid)
+ ])
- await sendCreateView(serverAccount, videoInstance, undefined)
+ const serverActor = await getServerActor()
+ await sendCreateView(serverActor, videoInstance, undefined)
return res.status(204).end()
}
return res.json({ description })
}
-async function listVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listVideos (req: express.Request, res: express.Response) {
const resultList = await VideoModel.listForApi({
start: req.query.start,
count: req.query.count,
sort: req.query.sort,
- hideNSFW: isNSFWHidden(res),
+ includeLocalVideos: true,
+ categoryOneOf: req.query.categoryOneOf,
+ licenceOneOf: req.query.licenceOneOf,
+ languageOneOf: req.query.languageOneOf,
+ tagsOneOf: req.query.tagsOneOf,
+ tagsAllOf: req.query.tagsAllOf,
+ nsfw: buildNSFWFilter(res, req.query.nsfw),
filter: req.query.filter as VideoFilter,
- withFiles: false
+ withFiles: false,
+ user: res.locals.oauth ? res.locals.oauth.token.User : undefined
})
return res.json(getFormattedObjects(resultList.data, resultList.total))
await videoInstance.destroy({ transaction: t })
})
+ auditLogger.delete(getAuditIdFromRes(res), new VideoAuditView(videoInstance.toFormattedDetailsJSON()))
logger.info('Video with name %s and uuid %s deleted.', videoInstance.name, videoInstance.uuid)
return res.type('json').status(204).end()
}
-
-async function searchVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
- const resultList = await VideoModel.searchAndPopulateAccountAndServer(
- req.query.search as string,
- req.query.start as number,
- req.query.count as number,
- req.query.sort as VideoSortField,
- isNSFWHidden(res)
- )
-
- return res.json(getFormattedObjects(resultList.data, resultList.total))
-}
projects / github / Chocobozzz / PeerTube.git / blobdiff