[routerLink]="['/videos/watch', video.uuid]" [attr.title]="video.name"
class="video-thumbnail"
>
-<img alt="" [attr.aria-labelledby]="video.name" [attr.src]="getImageUrl()" [ngClass]="{ 'blur-filter': nsfw }" />
+
<img alt="" [attr.aria-labelledby]="video.name" [attr.src]="getImageUrl()" [ngClass]="{ 'blur-filter': nsfw }" />
-<div class="video-thumbnail-overlay">
- {{ video.durationLabel }}
-</div>
+ <div class="video-thumbnail-overlay">{{ video.durationLabel }}</div>
+
+ <div class="progress-bar" *ngIf="video.userHistory?.currentTime">
+ <div [ngStyle]="{ 'width.%': getProgressPercent() }"></div>
+ </div>
</a>
}
}
+ .progress-bar {
+ height: 3px;
+ width: 100%;
+ position: relative;
+ top: -3px;
+ background-color: rgba(0, 0, 0, 0.20);
+
+ div {
+ height: 100%;
+ background-color: var(--mainColor);
+ }
+ }
+
.video-thumbnail-overlay {
position: absolute;
right: 5px;
return this.video.thumbnailUrl
}
+
+ getProgressPercent () {
+ if (!this.video.userHistory) return 0
+
+ const currentTime = this.video.userHistory.currentTime
+
+ return (currentTime / this.video.duration) * 100
+ }
}
avatar: Avatar
}
+ userHistory?: {
+ currentTime: number
+ }
+
static buildClientUrl (videoUUID: string) {
return '/videos/watch/' + videoUUID
}
this.blacklisted = hash.blacklisted
this.blacklistedReason = hash.blacklistedReason
+
+ this.userHistory = hash.userHistory
}
isVideoNSFWForUser (user: User, serverConfig: ServerConfig) {
return VideoService.BASE_VIDEO_URL + uuid + '/views'
}
+ getUserWatchingVideoUrl (uuid: string) {
+ return VideoService.BASE_VIDEO_URL + uuid + '/watching'
+ }
+
getVideo (uuid: string): Observable<VideoDetails> {
return this.serverService.localeObservable
.pipe(
)
}
- private async onVideoFetched (video: VideoDetails, videoCaptions: VideoCaption[], startTime = 0) {
+ private async onVideoFetched (video: VideoDetails, videoCaptions: VideoCaption[], startTimeFromUrl: number) {
this.video = video
// Re init attributes
this.completeDescriptionShown = false
this.remoteServerDown = false
+ let startTime = startTimeFromUrl || (this.video.userHistory ? this.video.userHistory.currentTime : 0)
+ // Don't start the video if we are at the end
+ if (this.video.duration - startTime <= 1) startTime = 0
+
if (this.video.isVideoNSFWForUser(this.user, this.serverService.getConfig())) {
const res = await this.confirmService.confirm(
this.i18n('This video contains mature or explicit content. Are you sure you want to watch it?'),
poster: this.video.previewUrl,
startTime,
theaterMode: true,
- language: this.localeId
+ language: this.localeId,
+
+ userWatching: this.user ? {
+ url: this.videoService.getUserWatchingVideoUrl(this.video.uuid),
+ authorizationHeader: this.authService.getRequestHeaderValue()
+ } : undefined
})
if (this.videojsLocaleLoaded === false) {
import './peertube-videojs-plugin'
import './peertube-load-progress-bar'
import './theater-button'
-import { VideoJSCaption, videojsUntyped } from './peertube-videojs-typings'
+import { UserWatching, VideoJSCaption, videojsUntyped } from './peertube-videojs-typings'
import { buildVideoEmbed, buildVideoLink, copyToClipboard } from './utils'
import { getCompleteLocale, getShortLocale, is18nLocale, isDefaultLocale } from '../../../../shared/models/i18n/i18n'
startTime: number | string
theaterMode: boolean,
videoCaptions: VideoJSCaption[],
+
language?: string,
controls?: boolean,
muted?: boolean,
loop?: boolean
+
+ userWatching?: UserWatching
}) {
const videojsOptions = {
// We don't use text track settings for now
playerElement: options.playerElement,
videoViewUrl: options.videoViewUrl,
videoDuration: options.videoDuration,
- startTime: options.startTime
+ startTime: options.startTime,
+ userWatching: options.userWatching
}
},
controlBar: {
import { VideoFile } from '../../../../shared/models/videos/video.model'
import { renderVideo } from './video-renderer'
import './settings-menu-button'
-import { PeertubePluginOptions, VideoJSCaption, VideoJSComponentInterface, videojsUntyped } from './peertube-videojs-typings'
+import { PeertubePluginOptions, UserWatching, VideoJSCaption, VideoJSComponentInterface, videojsUntyped } from './peertube-videojs-typings'
import { isMobile, timeToInt, videoFileMaxByResolution, videoFileMinByResolution } from './utils'
import * as CacheChunkStore from 'cache-chunk-store'
import { PeertubeChunkStore } from './peertube-chunk-store'
AUTO_QUALITY_THRESHOLD_PERCENT: 30, // Bandwidth should be 30% more important than a resolution bitrate to change to it
AUTO_QUALITY_OBSERVATION_TIME: 10000, // Wait 10 seconds after having change the resolution before another check
AUTO_QUALITY_HIGHER_RESOLUTION_DELAY: 5000, // Buffering higher resolution during 5 seconds
- BANDWIDTH_AVERAGE_NUMBER_OF_VALUES: 5 // Last 5 seconds to build average bandwidth
+ BANDWIDTH_AVERAGE_NUMBER_OF_VALUES: 5, // Last 5 seconds to build average bandwidth
+ USER_WATCHING_VIDEO_INTERVAL: 5000 // Every 5 seconds, notify the user is watching the video
}
private readonly webtorrent = new WebTorrent({
private videoViewInterval
private torrentInfoInterval
private autoQualityInterval
+ private userWatchingVideoInterval
private addTorrentDelay
private qualityObservationTimer
private runAutoQualitySchedulerTimer
this.runTorrentInfoScheduler()
this.runViewAdd()
+ if (options.userWatching) this.runUserWatchVideo(options.userWatching)
+
this.player.one('play', () => {
// Don't run immediately scheduler, wait some seconds the TCP connections are made
this.runAutoQualitySchedulerTimer = setTimeout(() => this.runAutoQualityScheduler(), this.CONSTANTS.AUTO_QUALITY_SCHEDULER)
clearInterval(this.torrentInfoInterval)
clearInterval(this.autoQualityInterval)
+ if (this.userWatchingVideoInterval) clearInterval(this.userWatchingVideoInterval)
+
// Don't need to destroy renderer, video player will be destroyed
this.flushVideoFile(this.currentVideoFile, false)
}, 1000)
}
+ private runUserWatchVideo (options: UserWatching) {
+ let lastCurrentTime = 0
+
+ this.userWatchingVideoInterval = setInterval(() => {
+ const currentTime = Math.floor(this.player.currentTime())
+
+ if (currentTime - lastCurrentTime >= 1) {
+ lastCurrentTime = currentTime
+
+ this.notifyUserIsWatching(currentTime, options.url, options.authorizationHeader)
+ .catch(err => console.error('Cannot notify user is watching.', err))
+ }
+ }, this.CONSTANTS.USER_WATCHING_VIDEO_INTERVAL)
+ }
+
private clearVideoViewInterval () {
if (this.videoViewInterval !== undefined) {
clearInterval(this.videoViewInterval)
return fetch(this.videoViewUrl, { method: 'POST' })
}
+ private notifyUserIsWatching (currentTime: number, url: string, authorizationHeader: string) {
+ const body = new URLSearchParams()
+ body.append('currentTime', currentTime.toString())
+
+ const headers = new Headers({ 'Authorization': authorizationHeader })
+
+ return fetch(url, { method: 'PUT', body, headers })
+ }
+
private fallbackToHttp (done?: Function, play = true) {
this.disableAutoResolution(true)
src: string
}
+type UserWatching = {
+ url: string,
+ authorizationHeader: string
+}
+
type PeertubePluginOptions = {
videoFiles: VideoFile[]
playerElement: HTMLVideoElement
startTime: number | string
autoplay: boolean,
videoCaptions: VideoJSCaption[]
+
+ userWatching?: UserWatching
}
// videojs typings don't have some method we need
VideoJSComponentInterface,
PeertubePluginOptions,
videojsUntyped,
- VideoJSCaption
+ VideoJSCaption,
+ UserWatching
}
localVideoChannelValidator,
videosCustomGetValidator
} from '../../middlewares'
-import { videosGetValidator, videosShareValidator } from '../../middlewares/validators'
-import { videoCommentGetValidator } from '../../middlewares/validators/video-comments'
+import { videoCommentGetValidator, videosGetValidator, videosShareValidator } from '../../middlewares/validators'
import { AccountModel } from '../../models/account/account'
import { ActorModel } from '../../models/activitypub/actor'
import { ActorFollowModel } from '../../models/activitypub/actor-follow'
async function searchVideosDB (query: VideosSearchQuery, res: express.Response) {
const options = Object.assign(query, {
includeLocalVideos: true,
- nsfw: buildNSFWFilter(res, query.nsfw)
+ nsfw: buildNSFWFilter(res, query.nsfw),
+ userId: res.locals.oauth ? res.locals.oauth.token.User.id : undefined
})
const resultList = await VideoModel.searchAndPopulateAccountAndServer(options)
import * as express from 'express'
import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate } from '../../../middlewares'
-import {
- addVideoCaptionValidator,
- deleteVideoCaptionValidator,
- listVideoCaptionsValidator
-} from '../../../middlewares/validators/video-captions'
+import { addVideoCaptionValidator, deleteVideoCaptionValidator, listVideoCaptionsValidator } from '../../../middlewares/validators'
import { createReqFiles } from '../../../helpers/express-utils'
import { CONFIG, sequelizeTypescript, VIDEO_CAPTIONS_MIMETYPE_EXT } from '../../../initializers'
import { getFormattedObjects } from '../../../helpers/utils'
setDefaultPagination,
setDefaultSort
} from '../../../middlewares'
-import { videoCommentThreadsSortValidator } from '../../../middlewares/validators'
import {
addVideoCommentReplyValidator,
addVideoCommentThreadValidator,
listVideoCommentThreadsValidator,
listVideoThreadCommentsValidator,
- removeVideoCommentValidator
-} from '../../../middlewares/validators/video-comments'
+ removeVideoCommentValidator,
+ videoCommentThreadsSortValidator
+} from '../../../middlewares/validators'
import { VideoModel } from '../../../models/video/video'
import { VideoCommentModel } from '../../../models/video/video-comment'
import { auditLoggerFactory, CommentAuditView, getAuditIdFromRes } from '../../../helpers/audit-logger'
import { videoImportsRouter } from './import'
import { resetSequelizeInstance } from '../../../helpers/database-utils'
import { rename } from 'fs-extra'
+import { watchingRouter } from './watching'
const auditLogger = auditLoggerFactory('videos')
const videosRouter = express.Router()
videosRouter.use('/', videoCaptionsRouter)
videosRouter.use('/', videoImportsRouter)
videosRouter.use('/', ownershipVideoRouter)
+videosRouter.use('/', watchingRouter)
videosRouter.get('/categories', listVideoCategories)
videosRouter.get('/licences', listVideoLicences)
asyncMiddleware(getVideoDescription)
)
videosRouter.get('/:id',
+ optionalAuthenticate,
asyncMiddleware(videosGetValidator),
getVideo
)
tagsAllOf: req.query.tagsAllOf,
nsfw: buildNSFWFilter(res, req.query.nsfw),
filter: req.query.filter as VideoFilter,
- withFiles: false
+ withFiles: false,
+ userId: res.locals.oauth ? res.locals.oauth.token.User.id : undefined
})
return res.json(getFormattedObjects(resultList.data, resultList.total))
--- /dev/null
+import * as express from 'express'
+import { UserWatchingVideo } from '../../../../shared'
+import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate, videoWatchingValidator } from '../../../middlewares'
+import { UserVideoHistoryModel } from '../../../models/account/user-video-history'
+import { UserModel } from '../../../models/account/user'
+
+const watchingRouter = express.Router()
+
+watchingRouter.put('/:videoId/watching',
+ authenticate,
+ asyncMiddleware(videoWatchingValidator),
+ asyncRetryTransactionMiddleware(userWatchVideo)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+ watchingRouter
+}
+
+// ---------------------------------------------------------------------------
+
+async function userWatchVideo (req: express.Request, res: express.Response) {
+ const user = res.locals.oauth.token.User as UserModel
+
+ const body: UserWatchingVideo = req.body
+ const { id: videoId } = res.locals.video as { id: number }
+
+ await UserVideoHistoryModel.upsert({
+ videoId,
+ userId: user.id,
+ currentTime: body.currentTime
+ })
+
+ return res.type('json').status(204).end()
+}
}
async function isVideoExist (id: string, res: Response, fetchType: VideoFetchType = 'all') {
- const video = await fetchVideo(id, fetchType)
+ const userId = res.locals.oauth ? res.locals.oauth.token.User.id : undefined
+
+ const video = await fetchVideo(id, fetchType, userId)
if (video === null) {
res.status(404)
type VideoFetchType = 'all' | 'only-video' | 'id' | 'none'
-function fetchVideo (id: number | string, fetchType: VideoFetchType) {
- if (fetchType === 'all') return VideoModel.loadAndPopulateAccountAndServerAndTags(id)
+function fetchVideo (id: number | string, fetchType: VideoFetchType, userId?: number) {
+ if (fetchType === 'all') return VideoModel.loadAndPopulateAccountAndServerAndTags(id, undefined, userId)
if (fetchType === 'only-video') return VideoModel.load(id)
import { VideoViewModel } from '../models/video/video-views'
import { VideoChangeOwnershipModel } from '../models/video/video-change-ownership'
import { VideoRedundancyModel } from '../models/redundancy/video-redundancy'
+import { UserVideoHistoryModel } from '../models/account/user-video-history'
require('pg').defaults.parseInt8 = true // Avoid BIGINT to be converted to string
ScheduleVideoUpdateModel,
VideoImportModel,
VideoViewModel,
- VideoRedundancyModel
+ VideoRedundancyModel,
+ UserVideoHistoryModel
])
// Check extensions exist in the database
)
}
+ /************* Forgot password *************/
+
async setResetPasswordVerificationString (userId: number) {
const generatedString = await generateRandomString(32)
return this.getValue(this.generateResetPasswordKey(userId))
}
+ /************* Email verification *************/
+
async setVerifyEmailVerificationString (userId: number) {
const generatedString = await generateRandomString(32)
return this.getValue(this.generateVerifyEmailKey(userId))
}
+ /************* Views per IP *************/
+
setIPVideoView (ip: string, videoUUID: string) {
- return this.setValue(this.buildViewKey(ip, videoUUID), '1', VIDEO_VIEW_LIFETIME)
+ return this.setValue(this.generateViewKey(ip, videoUUID), '1', VIDEO_VIEW_LIFETIME)
}
async isVideoIPViewExists (ip: string, videoUUID: string) {
- return this.exists(this.buildViewKey(ip, videoUUID))
+ return this.exists(this.generateViewKey(ip, videoUUID))
}
+ /************* API cache *************/
+
async getCachedRoute (req: express.Request) {
- const cached = await this.getObject(this.buildCachedRouteKey(req))
+ const cached = await this.getObject(this.generateCachedRouteKey(req))
return cached as CachedRoute
}
(statusCode) ? { statusCode: statusCode.toString() } : null
)
- return this.setObject(this.buildCachedRouteKey(req), cached, lifetime)
+ return this.setObject(this.generateCachedRouteKey(req), cached, lifetime)
}
+ /************* Video views *************/
+
addVideoView (videoId: number) {
const keyIncr = this.generateVideoViewKey(videoId)
const keySet = this.generateVideosViewKey()
])
}
- generateVideosViewKey (hour?: number) {
+ /************* Keys generation *************/
+
+ generateCachedRouteKey (req: express.Request) {
+ return req.method + '-' + req.originalUrl
+ }
+
+ private generateVideosViewKey (hour?: number) {
if (!hour) hour = new Date().getHours()
return `videos-view-h${hour}`
}
- generateVideoViewKey (videoId: number, hour?: number) {
+ private generateVideoViewKey (videoId: number, hour?: number) {
if (!hour) hour = new Date().getHours()
return `video-view-${videoId}-h${hour}`
}
- generateResetPasswordKey (userId: number) {
+ private generateResetPasswordKey (userId: number) {
return 'reset-password-' + userId
}
- generateVerifyEmailKey (userId: number) {
+ private generateVerifyEmailKey (userId: number) {
return 'verify-email-' + userId
}
- buildViewKey (ip: string, videoUUID: string) {
+ private generateViewKey (ip: string, videoUUID: string) {
return videoUUID + '-' + ip
}
- buildCachedRouteKey (req: express.Request) {
- return req.method + '-' + req.originalUrl
- }
+ /************* Redis helpers *************/
private getValue (key: string) {
return new Promise<string>((res, rej) => {
})
}
+ private deleteFieldInHash (key: string, field: string) {
+ return new Promise<void>((res, rej) => {
+ this.client.hdel(this.prefix + key, field, err => err ? rej(err) : res())
+ })
+ }
+
private setValue (key: string, value: string, expirationMilliseconds: number) {
return new Promise<void>((res, rej) => {
this.client.set(this.prefix + key, value, 'PX', expirationMilliseconds, (err, ok) => {
})
}
+ private setValueInHash (key: string, field: string, value: string) {
+ return new Promise<void>((res, rej) => {
+ this.client.hset(this.prefix + key, field, value, (err) => {
+ if (err) return rej(err)
+
+ return res()
+ })
+ })
+ }
+
private increment (key: string) {
return new Promise<number>((res, rej) => {
this.client.incr(this.prefix + key, (err, value) => {
function cacheRoute (lifetimeArg: string | number) {
return async function (req: express.Request, res: express.Response, next: express.NextFunction) {
- const redisKey = Redis.Instance.buildCachedRouteKey(req)
+ const redisKey = Redis.Instance.generateCachedRouteKey(req)
try {
await lock.acquire(redisKey, async (done) => {
export * from './users'
export * from './user-subscriptions'
export * from './videos'
-export * from './video-abuses'
-export * from './video-blacklist'
-export * from './video-channels'
export * from './webfinger'
export * from './search'
-export * from './video-imports'
+++ /dev/null
-import * as express from 'express'
-import 'express-validator'
-import { body, param } from 'express-validator/check'
-import { isIdOrUUIDValid, isIdValid } from '../../helpers/custom-validators/misc'
-import { isVideoExist } from '../../helpers/custom-validators/videos'
-import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
-import {
- isVideoAbuseExist,
- isVideoAbuseModerationCommentValid,
- isVideoAbuseReasonValid,
- isVideoAbuseStateValid
-} from '../../helpers/custom-validators/video-abuses'
-
-const videoAbuseReportValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
- body('reason').custom(isVideoAbuseReasonValid).withMessage('Should have a valid reason'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videoAbuseReport parameters', { parameters: req.body })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res)) return
-
- return next()
- }
-]
-
-const videoAbuseGetValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
- param('id').custom(isIdValid).not().isEmpty().withMessage('Should have a valid id'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videoAbuseGetValidator parameters', { parameters: req.body })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res)) return
- if (!await isVideoAbuseExist(req.params.id, res.locals.video.id, res)) return
-
- return next()
- }
-]
-
-const videoAbuseUpdateValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
- param('id').custom(isIdValid).not().isEmpty().withMessage('Should have a valid id'),
- body('state')
- .optional()
- .custom(isVideoAbuseStateValid).withMessage('Should have a valid video abuse state'),
- body('moderationComment')
- .optional()
- .custom(isVideoAbuseModerationCommentValid).withMessage('Should have a valid video moderation comment'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videoAbuseUpdateValidator parameters', { parameters: req.body })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res)) return
- if (!await isVideoAbuseExist(req.params.id, res.locals.video.id, res)) return
-
- return next()
- }
-]
-
-// ---------------------------------------------------------------------------
-
-export {
- videoAbuseReportValidator,
- videoAbuseGetValidator,
- videoAbuseUpdateValidator
-}
+++ /dev/null
-import * as express from 'express'
-import { body, param } from 'express-validator/check'
-import { isIdOrUUIDValid } from '../../helpers/custom-validators/misc'
-import { isVideoExist } from '../../helpers/custom-validators/videos'
-import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
-import { isVideoBlacklistExist, isVideoBlacklistReasonValid } from '../../helpers/custom-validators/video-blacklist'
-
-const videosBlacklistRemoveValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking blacklistRemove parameters.', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res)) return
- if (!await isVideoBlacklistExist(res.locals.video.id, res)) return
-
- return next()
- }
-]
-
-const videosBlacklistAddValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
- body('reason')
- .optional()
- .custom(isVideoBlacklistReasonValid).withMessage('Should have a valid reason'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videosBlacklistAdd parameters', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res)) return
-
- return next()
- }
-]
-
-const videosBlacklistUpdateValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
- body('reason')
- .optional()
- .custom(isVideoBlacklistReasonValid).withMessage('Should have a valid reason'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videosBlacklistUpdate parameters', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res)) return
- if (!await isVideoBlacklistExist(res.locals.video.id, res)) return
-
- return next()
- }
-]
-
-// ---------------------------------------------------------------------------
-
-export {
- videosBlacklistAddValidator,
- videosBlacklistRemoveValidator,
- videosBlacklistUpdateValidator
-}
+++ /dev/null
-import * as express from 'express'
-import { areValidationErrors } from './utils'
-import { checkUserCanManageVideo, isVideoExist } from '../../helpers/custom-validators/videos'
-import { isIdOrUUIDValid } from '../../helpers/custom-validators/misc'
-import { body, param } from 'express-validator/check'
-import { CONSTRAINTS_FIELDS } from '../../initializers'
-import { UserRight } from '../../../shared'
-import { logger } from '../../helpers/logger'
-import { isVideoCaptionExist, isVideoCaptionFile, isVideoCaptionLanguageValid } from '../../helpers/custom-validators/video-captions'
-import { cleanUpReqFiles } from '../../helpers/express-utils'
-
-const addVideoCaptionValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
- param('captionLanguage').custom(isVideoCaptionLanguageValid).not().isEmpty().withMessage('Should have a valid caption language'),
- body('captionfile')
- .custom((value, { req }) => isVideoCaptionFile(req.files, 'captionfile')).withMessage(
- 'This caption file is not supported or too large. Please, make sure it is of the following type : '
- + CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.EXTNAME.join(', ')
- ),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking addVideoCaption parameters', { parameters: req.body })
-
- if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
- if (!await isVideoExist(req.params.videoId, res)) return cleanUpReqFiles(req)
-
- // Check if the user who did the request is able to update the video
- const user = res.locals.oauth.token.User
- if (!checkUserCanManageVideo(user, res.locals.video, UserRight.UPDATE_ANY_VIDEO, res)) return cleanUpReqFiles(req)
-
- return next()
- }
-]
-
-const deleteVideoCaptionValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
- param('captionLanguage').custom(isVideoCaptionLanguageValid).not().isEmpty().withMessage('Should have a valid caption language'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking deleteVideoCaption parameters', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res)) return
- if (!await isVideoCaptionExist(res.locals.video, req.params.captionLanguage, res)) return
-
- // Check if the user who did the request is able to update the video
- const user = res.locals.oauth.token.User
- if (!checkUserCanManageVideo(user, res.locals.video, UserRight.UPDATE_ANY_VIDEO, res)) return
-
- return next()
- }
-]
-
-const listVideoCaptionsValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking listVideoCaptions parameters', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res, 'id')) return
-
- return next()
- }
-]
-
-export {
- addVideoCaptionValidator,
- listVideoCaptionsValidator,
- deleteVideoCaptionValidator
-}
+++ /dev/null
-import * as express from 'express'
-import { body, param } from 'express-validator/check'
-import { UserRight } from '../../../shared'
-import { isAccountNameWithHostExist } from '../../helpers/custom-validators/accounts'
-import {
- isLocalVideoChannelNameExist,
- isVideoChannelDescriptionValid,
- isVideoChannelNameValid,
- isVideoChannelNameWithHostExist,
- isVideoChannelSupportValid
-} from '../../helpers/custom-validators/video-channels'
-import { logger } from '../../helpers/logger'
-import { UserModel } from '../../models/account/user'
-import { VideoChannelModel } from '../../models/video/video-channel'
-import { areValidationErrors } from './utils'
-import { isActorPreferredUsernameValid } from '../../helpers/custom-validators/activitypub/actor'
-import { ActorModel } from '../../models/activitypub/actor'
-
-const listVideoAccountChannelsValidator = [
- param('accountName').exists().withMessage('Should have a valid account name'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking listVideoAccountChannelsValidator parameters', { parameters: req.body })
-
- if (areValidationErrors(req, res)) return
- if (!await isAccountNameWithHostExist(req.params.accountName, res)) return
-
- return next()
- }
-]
-
-const videoChannelsAddValidator = [
- body('name').custom(isActorPreferredUsernameValid).withMessage('Should have a valid channel name'),
- body('displayName').custom(isVideoChannelNameValid).withMessage('Should have a valid display name'),
- body('description').optional().custom(isVideoChannelDescriptionValid).withMessage('Should have a valid description'),
- body('support').optional().custom(isVideoChannelSupportValid).withMessage('Should have a valid support text'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videoChannelsAdd parameters', { parameters: req.body })
-
- if (areValidationErrors(req, res)) return
-
- const actor = await ActorModel.loadLocalByName(req.body.name)
- if (actor) {
- res.status(409)
- .send({ error: 'Another actor (account/channel) with this name on this instance already exists or has already existed.' })
- .end()
- return false
- }
-
- return next()
- }
-]
-
-const videoChannelsUpdateValidator = [
- param('nameWithHost').exists().withMessage('Should have an video channel name with host'),
- body('displayName').optional().custom(isVideoChannelNameValid).withMessage('Should have a valid display name'),
- body('description').optional().custom(isVideoChannelDescriptionValid).withMessage('Should have a valid description'),
- body('support').optional().custom(isVideoChannelSupportValid).withMessage('Should have a valid support text'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videoChannelsUpdate parameters', { parameters: req.body })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoChannelNameWithHostExist(req.params.nameWithHost, res)) return
-
- // We need to make additional checks
- if (res.locals.videoChannel.Actor.isOwned() === false) {
- return res.status(403)
- .json({ error: 'Cannot update video channel of another server' })
- .end()
- }
-
- if (res.locals.videoChannel.Account.userId !== res.locals.oauth.token.User.id) {
- return res.status(403)
- .json({ error: 'Cannot update video channel of another user' })
- .end()
- }
-
- return next()
- }
-]
-
-const videoChannelsRemoveValidator = [
- param('nameWithHost').exists().withMessage('Should have an video channel name with host'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videoChannelsRemove parameters', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoChannelNameWithHostExist(req.params.nameWithHost, res)) return
-
- if (!checkUserCanDeleteVideoChannel(res.locals.oauth.token.User, res.locals.videoChannel, res)) return
- if (!await checkVideoChannelIsNotTheLastOne(res)) return
-
- return next()
- }
-]
-
-const videoChannelsNameWithHostValidator = [
- param('nameWithHost').exists().withMessage('Should have an video channel name with host'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videoChannelsNameWithHostValidator parameters', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
-
- if (!await isVideoChannelNameWithHostExist(req.params.nameWithHost, res)) return
-
- return next()
- }
-]
-
-const localVideoChannelValidator = [
- param('name').custom(isVideoChannelNameValid).withMessage('Should have a valid video channel name'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking localVideoChannelValidator parameters', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isLocalVideoChannelNameExist(req.params.name, res)) return
-
- return next()
- }
-]
-
-// ---------------------------------------------------------------------------
-
-export {
- listVideoAccountChannelsValidator,
- videoChannelsAddValidator,
- videoChannelsUpdateValidator,
- videoChannelsRemoveValidator,
- videoChannelsNameWithHostValidator,
- localVideoChannelValidator
-}
-
-// ---------------------------------------------------------------------------
-
-function checkUserCanDeleteVideoChannel (user: UserModel, videoChannel: VideoChannelModel, res: express.Response) {
- if (videoChannel.Actor.isOwned() === false) {
- res.status(403)
- .json({ error: 'Cannot remove video channel of another server.' })
- .end()
-
- return false
- }
-
- // Check if the user can delete the video channel
- // The user can delete it if s/he is an admin
- // Or if s/he is the video channel's account
- if (user.hasRight(UserRight.REMOVE_ANY_VIDEO_CHANNEL) === false && videoChannel.Account.userId !== user.id) {
- res.status(403)
- .json({ error: 'Cannot remove video channel of another user' })
- .end()
-
- return false
- }
-
- return true
-}
-
-async function checkVideoChannelIsNotTheLastOne (res: express.Response) {
- const count = await VideoChannelModel.countByAccount(res.locals.oauth.token.User.Account.id)
-
- if (count <= 1) {
- res.status(409)
- .json({ error: 'Cannot remove the last channel of this user' })
- .end()
-
- return false
- }
-
- return true
-}
+++ /dev/null
-import * as express from 'express'
-import { body, param } from 'express-validator/check'
-import { UserRight } from '../../../shared'
-import { isIdOrUUIDValid, isIdValid } from '../../helpers/custom-validators/misc'
-import { isValidVideoCommentText } from '../../helpers/custom-validators/video-comments'
-import { isVideoExist } from '../../helpers/custom-validators/videos'
-import { logger } from '../../helpers/logger'
-import { UserModel } from '../../models/account/user'
-import { VideoModel } from '../../models/video/video'
-import { VideoCommentModel } from '../../models/video/video-comment'
-import { areValidationErrors } from './utils'
-
-const listVideoCommentThreadsValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking listVideoCommentThreads parameters.', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res, 'only-video')) return
-
- return next()
- }
-]
-
-const listVideoThreadCommentsValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
- param('threadId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid threadId'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking listVideoThreadComments parameters.', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res, 'only-video')) return
- if (!await isVideoCommentThreadExist(req.params.threadId, res.locals.video, res)) return
-
- return next()
- }
-]
-
-const addVideoCommentThreadValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
- body('text').custom(isValidVideoCommentText).not().isEmpty().withMessage('Should have a valid comment text'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking addVideoCommentThread parameters.', { parameters: req.params, body: req.body })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res)) return
- if (!isVideoCommentsEnabled(res.locals.video, res)) return
-
- return next()
- }
-]
-
-const addVideoCommentReplyValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
- param('commentId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid commentId'),
- body('text').custom(isValidVideoCommentText).not().isEmpty().withMessage('Should have a valid comment text'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking addVideoCommentReply parameters.', { parameters: req.params, body: req.body })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res)) return
- if (!isVideoCommentsEnabled(res.locals.video, res)) return
- if (!await isVideoCommentExist(req.params.commentId, res.locals.video, res)) return
-
- return next()
- }
-]
-
-const videoCommentGetValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
- param('commentId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid commentId'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videoCommentGetValidator parameters.', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res, 'id')) return
- if (!await isVideoCommentExist(req.params.commentId, res.locals.video, res)) return
-
- return next()
- }
-]
-
-const removeVideoCommentValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
- param('commentId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid commentId'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking removeVideoCommentValidator parameters.', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res)) return
- if (!await isVideoCommentExist(req.params.commentId, res.locals.video, res)) return
-
- // Check if the user who did the request is able to delete the video
- if (!checkUserCanDeleteVideoComment(res.locals.oauth.token.User, res.locals.videoComment, res)) return
-
- return next()
- }
-]
-
-// ---------------------------------------------------------------------------
-
-export {
- listVideoCommentThreadsValidator,
- listVideoThreadCommentsValidator,
- addVideoCommentThreadValidator,
- addVideoCommentReplyValidator,
- videoCommentGetValidator,
- removeVideoCommentValidator
-}
-
-// ---------------------------------------------------------------------------
-
-async function isVideoCommentThreadExist (id: number, video: VideoModel, res: express.Response) {
- const videoComment = await VideoCommentModel.loadById(id)
-
- if (!videoComment) {
- res.status(404)
- .json({ error: 'Video comment thread not found' })
- .end()
-
- return false
- }
-
- if (videoComment.videoId !== video.id) {
- res.status(400)
- .json({ error: 'Video comment is associated to this video.' })
- .end()
-
- return false
- }
-
- if (videoComment.inReplyToCommentId !== null) {
- res.status(400)
- .json({ error: 'Video comment is not a thread.' })
- .end()
-
- return false
- }
-
- res.locals.videoCommentThread = videoComment
- return true
-}
-
-async function isVideoCommentExist (id: number, video: VideoModel, res: express.Response) {
- const videoComment = await VideoCommentModel.loadByIdAndPopulateVideoAndAccountAndReply(id)
-
- if (!videoComment) {
- res.status(404)
- .json({ error: 'Video comment thread not found' })
- .end()
-
- return false
- }
-
- if (videoComment.videoId !== video.id) {
- res.status(400)
- .json({ error: 'Video comment is associated to this video.' })
- .end()
-
- return false
- }
-
- res.locals.videoComment = videoComment
- return true
-}
-
-function isVideoCommentsEnabled (video: VideoModel, res: express.Response) {
- if (video.commentsEnabled !== true) {
- res.status(409)
- .json({ error: 'Video comments are disabled for this video.' })
- .end()
-
- return false
- }
-
- return true
-}
-
-function checkUserCanDeleteVideoComment (user: UserModel, videoComment: VideoCommentModel, res: express.Response) {
- const account = videoComment.Account
- if (user.hasRight(UserRight.REMOVE_ANY_VIDEO_COMMENT) === false && account.userId !== user.id) {
- res.status(403)
- .json({ error: 'Cannot remove video comment of another user' })
- .end()
- return false
- }
-
- return true
-}
+++ /dev/null
-import * as express from 'express'
-import { body } from 'express-validator/check'
-import { isIdValid } from '../../helpers/custom-validators/misc'
-import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
-import { getCommonVideoAttributes } from './videos'
-import { isVideoImportTargetUrlValid, isVideoImportTorrentFile } from '../../helpers/custom-validators/video-imports'
-import { cleanUpReqFiles } from '../../helpers/express-utils'
-import { isVideoChannelOfAccountExist, isVideoMagnetUriValid, isVideoNameValid } from '../../helpers/custom-validators/videos'
-import { CONFIG } from '../../initializers/constants'
-import { CONSTRAINTS_FIELDS } from '../../initializers'
-
-const videoImportAddValidator = getCommonVideoAttributes().concat([
- body('channelId')
- .toInt()
- .custom(isIdValid).withMessage('Should have correct video channel id'),
- body('targetUrl')
- .optional()
- .custom(isVideoImportTargetUrlValid).withMessage('Should have a valid video import target URL'),
- body('magnetUri')
- .optional()
- .custom(isVideoMagnetUriValid).withMessage('Should have a valid video magnet URI'),
- body('torrentfile')
- .custom((value, { req }) => isVideoImportTorrentFile(req.files)).withMessage(
- 'This torrent file is not supported or too large. Please, make sure it is of the following type: '
- + CONSTRAINTS_FIELDS.VIDEO_IMPORTS.TORRENT_FILE.EXTNAME.join(', ')
- ),
- body('name')
- .optional()
- .custom(isVideoNameValid).withMessage('Should have a valid name'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videoImportAddValidator parameters', { parameters: req.body })
-
- const user = res.locals.oauth.token.User
- const torrentFile = req.files && req.files['torrentfile'] ? req.files['torrentfile'][0] : undefined
-
- if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
-
- if (req.body.targetUrl && CONFIG.IMPORT.VIDEOS.HTTP.ENABLED !== true) {
- cleanUpReqFiles(req)
- return res.status(409)
- .json({ error: 'HTTP import is not enabled on this instance.' })
- .end()
- }
-
- if (CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED !== true && (req.body.magnetUri || torrentFile)) {
- cleanUpReqFiles(req)
- return res.status(409)
- .json({ error: 'Torrent/magnet URI import is not enabled on this instance.' })
- .end()
- }
-
- if (!await isVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
-
- // Check we have at least 1 required param
- if (!req.body.targetUrl && !req.body.magnetUri && !torrentFile) {
- cleanUpReqFiles(req)
-
- return res.status(400)
- .json({ error: 'Should have a magnetUri or a targetUrl or a torrent file.' })
- .end()
- }
-
- return next()
- }
-])
-
-// ---------------------------------------------------------------------------
-
-export {
- videoImportAddValidator
-}
-
-// ---------------------------------------------------------------------------
+++ /dev/null
-import * as express from 'express'
-import 'express-validator'
-import { body, param, ValidationChain } from 'express-validator/check'
-import { UserRight, VideoChangeOwnershipStatus, VideoPrivacy } from '../../../shared'
-import {
- isBooleanValid,
- isDateValid,
- isIdOrUUIDValid,
- isIdValid,
- isUUIDValid,
- toIntOrNull,
- toValueOrNull
-} from '../../helpers/custom-validators/misc'
-import {
- checkUserCanManageVideo,
- isScheduleVideoUpdatePrivacyValid,
- isVideoCategoryValid,
- isVideoChannelOfAccountExist,
- isVideoDescriptionValid,
- isVideoExist,
- isVideoFile,
- isVideoImage,
- isVideoLanguageValid,
- isVideoLicenceValid,
- isVideoNameValid,
- isVideoPrivacyValid,
- isVideoRatingTypeValid,
- isVideoSupportValid,
- isVideoTagsValid
-} from '../../helpers/custom-validators/videos'
-import { getDurationFromVideoFile } from '../../helpers/ffmpeg-utils'
-import { logger } from '../../helpers/logger'
-import { CONSTRAINTS_FIELDS } from '../../initializers'
-import { VideoShareModel } from '../../models/video/video-share'
-import { authenticate } from '../oauth'
-import { areValidationErrors } from './utils'
-import { cleanUpReqFiles } from '../../helpers/express-utils'
-import { VideoModel } from '../../models/video/video'
-import { UserModel } from '../../models/account/user'
-import { checkUserCanTerminateOwnershipChange, doesChangeVideoOwnershipExist } from '../../helpers/custom-validators/video-ownership'
-import { VideoChangeOwnershipAccept } from '../../../shared/models/videos/video-change-ownership-accept.model'
-import { VideoChangeOwnershipModel } from '../../models/video/video-change-ownership'
-import { AccountModel } from '../../models/account/account'
-import { VideoFetchType } from '../../helpers/video'
-
-const videosAddValidator = getCommonVideoAttributes().concat([
- body('videofile')
- .custom((value, { req }) => isVideoFile(req.files)).withMessage(
- 'This file is not supported or too large. Please, make sure it is of the following type: '
- + CONSTRAINTS_FIELDS.VIDEOS.EXTNAME.join(', ')
- ),
- body('name').custom(isVideoNameValid).withMessage('Should have a valid name'),
- body('channelId')
- .toInt()
- .custom(isIdValid).withMessage('Should have correct video channel id'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videosAdd parameters', { parameters: req.body, files: req.files })
-
- if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
- if (areErrorsInScheduleUpdate(req, res)) return cleanUpReqFiles(req)
-
- const videoFile: Express.Multer.File = req.files['videofile'][0]
- const user = res.locals.oauth.token.User
-
- if (!await isVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
-
- const isAble = await user.isAbleToUploadVideo(videoFile)
- if (isAble === false) {
- res.status(403)
- .json({ error: 'The user video quota is exceeded with this video.' })
- .end()
-
- return cleanUpReqFiles(req)
- }
-
- let duration: number
-
- try {
- duration = await getDurationFromVideoFile(videoFile.path)
- } catch (err) {
- logger.error('Invalid input file in videosAddValidator.', { err })
- res.status(400)
- .json({ error: 'Invalid input file.' })
- .end()
-
- return cleanUpReqFiles(req)
- }
-
- videoFile['duration'] = duration
-
- return next()
- }
-])
-
-const videosUpdateValidator = getCommonVideoAttributes().concat([
- param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
- body('name')
- .optional()
- .custom(isVideoNameValid).withMessage('Should have a valid name'),
- body('channelId')
- .optional()
- .toInt()
- .custom(isIdValid).withMessage('Should have correct video channel id'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videosUpdate parameters', { parameters: req.body })
-
- if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
- if (areErrorsInScheduleUpdate(req, res)) return cleanUpReqFiles(req)
- if (!await isVideoExist(req.params.id, res)) return cleanUpReqFiles(req)
-
- const video = res.locals.video
-
- // Check if the user who did the request is able to update the video
- const user = res.locals.oauth.token.User
- if (!checkUserCanManageVideo(user, res.locals.video, UserRight.UPDATE_ANY_VIDEO, res)) return cleanUpReqFiles(req)
-
- if (video.privacy !== VideoPrivacy.PRIVATE && req.body.privacy === VideoPrivacy.PRIVATE) {
- cleanUpReqFiles(req)
- return res.status(409)
- .json({ error: 'Cannot set "private" a video that was not private.' })
- .end()
- }
-
- if (req.body.channelId && !await isVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
-
- return next()
- }
-])
-
-const videosCustomGetValidator = (fetchType: VideoFetchType) => {
- return [
- param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videosGet parameters', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.id, res, fetchType)) return
-
- const video: VideoModel = res.locals.video
-
- // Video private or blacklisted
- if (video.privacy === VideoPrivacy.PRIVATE || video.VideoBlacklist) {
- return authenticate(req, res, () => {
- const user: UserModel = res.locals.oauth.token.User
-
- // Only the owner or a user that have blacklist rights can see the video
- if (video.VideoChannel.Account.userId !== user.id && !user.hasRight(UserRight.MANAGE_VIDEO_BLACKLIST)) {
- return res.status(403)
- .json({ error: 'Cannot get this private or blacklisted video.' })
- .end()
- }
-
- return next()
- })
- }
-
- // Video is public, anyone can access it
- if (video.privacy === VideoPrivacy.PUBLIC) return next()
-
- // Video is unlisted, check we used the uuid to fetch it
- if (video.privacy === VideoPrivacy.UNLISTED) {
- if (isUUIDValid(req.params.id)) return next()
-
- // Don't leak this unlisted video
- return res.status(404).end()
- }
- }
- ]
-}
-
-const videosGetValidator = videosCustomGetValidator('all')
-
-const videosRemoveValidator = [
- param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videosRemove parameters', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.id, res)) return
-
- // Check if the user who did the request is able to delete the video
- if (!checkUserCanManageVideo(res.locals.oauth.token.User, res.locals.video, UserRight.REMOVE_ANY_VIDEO, res)) return
-
- return next()
- }
-]
-
-const videoRateValidator = [
- param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
- body('rating').custom(isVideoRatingTypeValid).withMessage('Should have a valid rate type'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videoRate parameters', { parameters: req.body })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.id, res)) return
-
- return next()
- }
-]
-
-const videosShareValidator = [
- param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
- param('accountId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid account id'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking videoShare parameters', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.id, res)) return
-
- const share = await VideoShareModel.load(req.params.accountId, res.locals.video.id, undefined)
- if (!share) {
- return res.status(404)
- .end()
- }
-
- res.locals.videoShare = share
- return next()
- }
-]
-
-const videosChangeOwnershipValidator = [
- param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking changeOwnership parameters', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await isVideoExist(req.params.videoId, res)) return
-
- // Check if the user who did the request is able to change the ownership of the video
- if (!checkUserCanManageVideo(res.locals.oauth.token.User, res.locals.video, UserRight.CHANGE_VIDEO_OWNERSHIP, res)) return
-
- const nextOwner = await AccountModel.loadLocalByName(req.body.username)
- if (!nextOwner) {
- res.status(400)
- .type('json')
- .end()
- return
- }
- res.locals.nextOwner = nextOwner
-
- return next()
- }
-]
-
-const videosTerminateChangeOwnershipValidator = [
- param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
-
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- logger.debug('Checking changeOwnership parameters', { parameters: req.params })
-
- if (areValidationErrors(req, res)) return
- if (!await doesChangeVideoOwnershipExist(req.params.id, res)) return
-
- // Check if the user who did the request is able to change the ownership of the video
- if (!checkUserCanTerminateOwnershipChange(res.locals.oauth.token.User, res.locals.videoChangeOwnership, res)) return
-
- return next()
- },
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- const videoChangeOwnership = res.locals.videoChangeOwnership as VideoChangeOwnershipModel
-
- if (videoChangeOwnership.status === VideoChangeOwnershipStatus.WAITING) {
- return next()
- } else {
- res.status(403)
- .json({ error: 'Ownership already accepted or refused' })
- .end()
- return
- }
- }
-]
-
-const videosAcceptChangeOwnershipValidator = [
- async (req: express.Request, res: express.Response, next: express.NextFunction) => {
- const body = req.body as VideoChangeOwnershipAccept
- if (!await isVideoChannelOfAccountExist(body.channelId, res.locals.oauth.token.User, res)) return
-
- const user = res.locals.oauth.token.User
- const videoChangeOwnership = res.locals.videoChangeOwnership as VideoChangeOwnershipModel
- const isAble = await user.isAbleToUploadVideo(videoChangeOwnership.Video.getOriginalFile())
- if (isAble === false) {
- res.status(403)
- .json({ error: 'The user video quota is exceeded with this video.' })
- .end()
- return
- }
-
- return next()
- }
-]
-
-function getCommonVideoAttributes () {
- return [
- body('thumbnailfile')
- .custom((value, { req }) => isVideoImage(req.files, 'thumbnailfile')).withMessage(
- 'This thumbnail file is not supported or too large. Please, make sure it is of the following type: '
- + CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME.join(', ')
- ),
- body('previewfile')
- .custom((value, { req }) => isVideoImage(req.files, 'previewfile')).withMessage(
- 'This preview file is not supported or too large. Please, make sure it is of the following type: '
- + CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME.join(', ')
- ),
-
- body('category')
- .optional()
- .customSanitizer(toIntOrNull)
- .custom(isVideoCategoryValid).withMessage('Should have a valid category'),
- body('licence')
- .optional()
- .customSanitizer(toIntOrNull)
- .custom(isVideoLicenceValid).withMessage('Should have a valid licence'),
- body('language')
- .optional()
- .customSanitizer(toValueOrNull)
- .custom(isVideoLanguageValid).withMessage('Should have a valid language'),
- body('nsfw')
- .optional()
- .toBoolean()
- .custom(isBooleanValid).withMessage('Should have a valid NSFW attribute'),
- body('waitTranscoding')
- .optional()
- .toBoolean()
- .custom(isBooleanValid).withMessage('Should have a valid wait transcoding attribute'),
- body('privacy')
- .optional()
- .toInt()
- .custom(isVideoPrivacyValid).withMessage('Should have correct video privacy'),
- body('description')
- .optional()
- .customSanitizer(toValueOrNull)
- .custom(isVideoDescriptionValid).withMessage('Should have a valid description'),
- body('support')
- .optional()
- .customSanitizer(toValueOrNull)
- .custom(isVideoSupportValid).withMessage('Should have a valid support text'),
- body('tags')
- .optional()
- .customSanitizer(toValueOrNull)
- .custom(isVideoTagsValid).withMessage('Should have correct tags'),
- body('commentsEnabled')
- .optional()
- .toBoolean()
- .custom(isBooleanValid).withMessage('Should have comments enabled boolean'),
-
- body('scheduleUpdate')
- .optional()
- .customSanitizer(toValueOrNull),
- body('scheduleUpdate.updateAt')
- .optional()
- .custom(isDateValid).withMessage('Should have a valid schedule update date'),
- body('scheduleUpdate.privacy')
- .optional()
- .toInt()
- .custom(isScheduleVideoUpdatePrivacyValid).withMessage('Should have correct schedule update privacy')
- ] as (ValidationChain | express.Handler)[]
-}
-
-// ---------------------------------------------------------------------------
-
-export {
- videosAddValidator,
- videosUpdateValidator,
- videosGetValidator,
- videosCustomGetValidator,
- videosRemoveValidator,
- videosShareValidator,
-
- videoRateValidator,
-
- videosChangeOwnershipValidator,
- videosTerminateChangeOwnershipValidator,
- videosAcceptChangeOwnershipValidator,
-
- getCommonVideoAttributes
-}
-
-// ---------------------------------------------------------------------------
-
-function areErrorsInScheduleUpdate (req: express.Request, res: express.Response) {
- if (req.body.scheduleUpdate) {
- if (!req.body.scheduleUpdate.updateAt) {
- res.status(400)
- .json({ error: 'Schedule update at is mandatory.' })
- .end()
-
- return true
- }
- }
-
- return false
-}
--- /dev/null
+export * from './video-abuses'
+export * from './video-blacklist'
+export * from './video-captions'
+export * from './video-channels'
+export * from './video-comments'
+export * from './video-imports'
+export * from './video-watch'
+export * from './videos'
--- /dev/null
+import * as express from 'express'
+import 'express-validator'
+import { body, param } from 'express-validator/check'
+import { isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
+import { isVideoExist } from '../../../helpers/custom-validators/videos'
+import { logger } from '../../../helpers/logger'
+import { areValidationErrors } from '../utils'
+import {
+ isVideoAbuseExist,
+ isVideoAbuseModerationCommentValid,
+ isVideoAbuseReasonValid,
+ isVideoAbuseStateValid
+} from '../../../helpers/custom-validators/video-abuses'
+
+const videoAbuseReportValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+ body('reason').custom(isVideoAbuseReasonValid).withMessage('Should have a valid reason'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videoAbuseReport parameters', { parameters: req.body })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res)) return
+
+ return next()
+ }
+]
+
+const videoAbuseGetValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+ param('id').custom(isIdValid).not().isEmpty().withMessage('Should have a valid id'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videoAbuseGetValidator parameters', { parameters: req.body })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res)) return
+ if (!await isVideoAbuseExist(req.params.id, res.locals.video.id, res)) return
+
+ return next()
+ }
+]
+
+const videoAbuseUpdateValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+ param('id').custom(isIdValid).not().isEmpty().withMessage('Should have a valid id'),
+ body('state')
+ .optional()
+ .custom(isVideoAbuseStateValid).withMessage('Should have a valid video abuse state'),
+ body('moderationComment')
+ .optional()
+ .custom(isVideoAbuseModerationCommentValid).withMessage('Should have a valid video moderation comment'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videoAbuseUpdateValidator parameters', { parameters: req.body })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res)) return
+ if (!await isVideoAbuseExist(req.params.id, res.locals.video.id, res)) return
+
+ return next()
+ }
+]
+
+// ---------------------------------------------------------------------------
+
+export {
+ videoAbuseReportValidator,
+ videoAbuseGetValidator,
+ videoAbuseUpdateValidator
+}
--- /dev/null
+import * as express from 'express'
+import { body, param } from 'express-validator/check'
+import { isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
+import { isVideoExist } from '../../../helpers/custom-validators/videos'
+import { logger } from '../../../helpers/logger'
+import { areValidationErrors } from '../utils'
+import { isVideoBlacklistExist, isVideoBlacklistReasonValid } from '../../../helpers/custom-validators/video-blacklist'
+
+const videosBlacklistRemoveValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking blacklistRemove parameters.', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res)) return
+ if (!await isVideoBlacklistExist(res.locals.video.id, res)) return
+
+ return next()
+ }
+]
+
+const videosBlacklistAddValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+ body('reason')
+ .optional()
+ .custom(isVideoBlacklistReasonValid).withMessage('Should have a valid reason'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videosBlacklistAdd parameters', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res)) return
+
+ return next()
+ }
+]
+
+const videosBlacklistUpdateValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+ body('reason')
+ .optional()
+ .custom(isVideoBlacklistReasonValid).withMessage('Should have a valid reason'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videosBlacklistUpdate parameters', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res)) return
+ if (!await isVideoBlacklistExist(res.locals.video.id, res)) return
+
+ return next()
+ }
+]
+
+// ---------------------------------------------------------------------------
+
+export {
+ videosBlacklistAddValidator,
+ videosBlacklistRemoveValidator,
+ videosBlacklistUpdateValidator
+}
--- /dev/null
+import * as express from 'express'
+import { areValidationErrors } from '../utils'
+import { checkUserCanManageVideo, isVideoExist } from '../../../helpers/custom-validators/videos'
+import { isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
+import { body, param } from 'express-validator/check'
+import { CONSTRAINTS_FIELDS } from '../../../initializers'
+import { UserRight } from '../../../../shared'
+import { logger } from '../../../helpers/logger'
+import { isVideoCaptionExist, isVideoCaptionFile, isVideoCaptionLanguageValid } from '../../../helpers/custom-validators/video-captions'
+import { cleanUpReqFiles } from '../../../helpers/express-utils'
+
+const addVideoCaptionValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
+ param('captionLanguage').custom(isVideoCaptionLanguageValid).not().isEmpty().withMessage('Should have a valid caption language'),
+ body('captionfile')
+ .custom((value, { req }) => isVideoCaptionFile(req.files, 'captionfile')).withMessage(
+ 'This caption file is not supported or too large. Please, make sure it is of the following type : '
+ + CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.EXTNAME.join(', ')
+ ),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking addVideoCaption parameters', { parameters: req.body })
+
+ if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
+ if (!await isVideoExist(req.params.videoId, res)) return cleanUpReqFiles(req)
+
+ // Check if the user who did the request is able to update the video
+ const user = res.locals.oauth.token.User
+ if (!checkUserCanManageVideo(user, res.locals.video, UserRight.UPDATE_ANY_VIDEO, res)) return cleanUpReqFiles(req)
+
+ return next()
+ }
+]
+
+const deleteVideoCaptionValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
+ param('captionLanguage').custom(isVideoCaptionLanguageValid).not().isEmpty().withMessage('Should have a valid caption language'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking deleteVideoCaption parameters', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res)) return
+ if (!await isVideoCaptionExist(res.locals.video, req.params.captionLanguage, res)) return
+
+ // Check if the user who did the request is able to update the video
+ const user = res.locals.oauth.token.User
+ if (!checkUserCanManageVideo(user, res.locals.video, UserRight.UPDATE_ANY_VIDEO, res)) return
+
+ return next()
+ }
+]
+
+const listVideoCaptionsValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking listVideoCaptions parameters', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res, 'id')) return
+
+ return next()
+ }
+]
+
+export {
+ addVideoCaptionValidator,
+ listVideoCaptionsValidator,
+ deleteVideoCaptionValidator
+}
--- /dev/null
+import * as express from 'express'
+import { body, param } from 'express-validator/check'
+import { UserRight } from '../../../../shared'
+import { isAccountNameWithHostExist } from '../../../helpers/custom-validators/accounts'
+import {
+ isLocalVideoChannelNameExist,
+ isVideoChannelDescriptionValid,
+ isVideoChannelNameValid,
+ isVideoChannelNameWithHostExist,
+ isVideoChannelSupportValid
+} from '../../../helpers/custom-validators/video-channels'
+import { logger } from '../../../helpers/logger'
+import { UserModel } from '../../../models/account/user'
+import { VideoChannelModel } from '../../../models/video/video-channel'
+import { areValidationErrors } from '../utils'
+import { isActorPreferredUsernameValid } from '../../../helpers/custom-validators/activitypub/actor'
+import { ActorModel } from '../../../models/activitypub/actor'
+
+const listVideoAccountChannelsValidator = [
+ param('accountName').exists().withMessage('Should have a valid account name'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking listVideoAccountChannelsValidator parameters', { parameters: req.body })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isAccountNameWithHostExist(req.params.accountName, res)) return
+
+ return next()
+ }
+]
+
+const videoChannelsAddValidator = [
+ body('name').custom(isActorPreferredUsernameValid).withMessage('Should have a valid channel name'),
+ body('displayName').custom(isVideoChannelNameValid).withMessage('Should have a valid display name'),
+ body('description').optional().custom(isVideoChannelDescriptionValid).withMessage('Should have a valid description'),
+ body('support').optional().custom(isVideoChannelSupportValid).withMessage('Should have a valid support text'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videoChannelsAdd parameters', { parameters: req.body })
+
+ if (areValidationErrors(req, res)) return
+
+ const actor = await ActorModel.loadLocalByName(req.body.name)
+ if (actor) {
+ res.status(409)
+ .send({ error: 'Another actor (account/channel) with this name on this instance already exists or has already existed.' })
+ .end()
+ return false
+ }
+
+ return next()
+ }
+]
+
+const videoChannelsUpdateValidator = [
+ param('nameWithHost').exists().withMessage('Should have an video channel name with host'),
+ body('displayName').optional().custom(isVideoChannelNameValid).withMessage('Should have a valid display name'),
+ body('description').optional().custom(isVideoChannelDescriptionValid).withMessage('Should have a valid description'),
+ body('support').optional().custom(isVideoChannelSupportValid).withMessage('Should have a valid support text'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videoChannelsUpdate parameters', { parameters: req.body })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoChannelNameWithHostExist(req.params.nameWithHost, res)) return
+
+ // We need to make additional checks
+ if (res.locals.videoChannel.Actor.isOwned() === false) {
+ return res.status(403)
+ .json({ error: 'Cannot update video channel of another server' })
+ .end()
+ }
+
+ if (res.locals.videoChannel.Account.userId !== res.locals.oauth.token.User.id) {
+ return res.status(403)
+ .json({ error: 'Cannot update video channel of another user' })
+ .end()
+ }
+
+ return next()
+ }
+]
+
+const videoChannelsRemoveValidator = [
+ param('nameWithHost').exists().withMessage('Should have an video channel name with host'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videoChannelsRemove parameters', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoChannelNameWithHostExist(req.params.nameWithHost, res)) return
+
+ if (!checkUserCanDeleteVideoChannel(res.locals.oauth.token.User, res.locals.videoChannel, res)) return
+ if (!await checkVideoChannelIsNotTheLastOne(res)) return
+
+ return next()
+ }
+]
+
+const videoChannelsNameWithHostValidator = [
+ param('nameWithHost').exists().withMessage('Should have an video channel name with host'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videoChannelsNameWithHostValidator parameters', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+
+ if (!await isVideoChannelNameWithHostExist(req.params.nameWithHost, res)) return
+
+ return next()
+ }
+]
+
+const localVideoChannelValidator = [
+ param('name').custom(isVideoChannelNameValid).withMessage('Should have a valid video channel name'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking localVideoChannelValidator parameters', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isLocalVideoChannelNameExist(req.params.name, res)) return
+
+ return next()
+ }
+]
+
+// ---------------------------------------------------------------------------
+
+export {
+ listVideoAccountChannelsValidator,
+ videoChannelsAddValidator,
+ videoChannelsUpdateValidator,
+ videoChannelsRemoveValidator,
+ videoChannelsNameWithHostValidator,
+ localVideoChannelValidator
+}
+
+// ---------------------------------------------------------------------------
+
+function checkUserCanDeleteVideoChannel (user: UserModel, videoChannel: VideoChannelModel, res: express.Response) {
+ if (videoChannel.Actor.isOwned() === false) {
+ res.status(403)
+ .json({ error: 'Cannot remove video channel of another server.' })
+ .end()
+
+ return false
+ }
+
+ // Check if the user can delete the video channel
+ // The user can delete it if s/he is an admin
+ // Or if s/he is the video channel's account
+ if (user.hasRight(UserRight.REMOVE_ANY_VIDEO_CHANNEL) === false && videoChannel.Account.userId !== user.id) {
+ res.status(403)
+ .json({ error: 'Cannot remove video channel of another user' })
+ .end()
+
+ return false
+ }
+
+ return true
+}
+
+async function checkVideoChannelIsNotTheLastOne (res: express.Response) {
+ const count = await VideoChannelModel.countByAccount(res.locals.oauth.token.User.Account.id)
+
+ if (count <= 1) {
+ res.status(409)
+ .json({ error: 'Cannot remove the last channel of this user' })
+ .end()
+
+ return false
+ }
+
+ return true
+}
--- /dev/null
+import * as express from 'express'
+import { body, param } from 'express-validator/check'
+import { UserRight } from '../../../../shared'
+import { isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
+import { isValidVideoCommentText } from '../../../helpers/custom-validators/video-comments'
+import { isVideoExist } from '../../../helpers/custom-validators/videos'
+import { logger } from '../../../helpers/logger'
+import { UserModel } from '../../../models/account/user'
+import { VideoModel } from '../../../models/video/video'
+import { VideoCommentModel } from '../../../models/video/video-comment'
+import { areValidationErrors } from '../utils'
+
+const listVideoCommentThreadsValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking listVideoCommentThreads parameters.', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res, 'only-video')) return
+
+ return next()
+ }
+]
+
+const listVideoThreadCommentsValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+ param('threadId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid threadId'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking listVideoThreadComments parameters.', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res, 'only-video')) return
+ if (!await isVideoCommentThreadExist(req.params.threadId, res.locals.video, res)) return
+
+ return next()
+ }
+]
+
+const addVideoCommentThreadValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+ body('text').custom(isValidVideoCommentText).not().isEmpty().withMessage('Should have a valid comment text'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking addVideoCommentThread parameters.', { parameters: req.params, body: req.body })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res)) return
+ if (!isVideoCommentsEnabled(res.locals.video, res)) return
+
+ return next()
+ }
+]
+
+const addVideoCommentReplyValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+ param('commentId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid commentId'),
+ body('text').custom(isValidVideoCommentText).not().isEmpty().withMessage('Should have a valid comment text'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking addVideoCommentReply parameters.', { parameters: req.params, body: req.body })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res)) return
+ if (!isVideoCommentsEnabled(res.locals.video, res)) return
+ if (!await isVideoCommentExist(req.params.commentId, res.locals.video, res)) return
+
+ return next()
+ }
+]
+
+const videoCommentGetValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+ param('commentId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid commentId'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videoCommentGetValidator parameters.', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res, 'id')) return
+ if (!await isVideoCommentExist(req.params.commentId, res.locals.video, res)) return
+
+ return next()
+ }
+]
+
+const removeVideoCommentValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+ param('commentId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid commentId'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking removeVideoCommentValidator parameters.', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res)) return
+ if (!await isVideoCommentExist(req.params.commentId, res.locals.video, res)) return
+
+ // Check if the user who did the request is able to delete the video
+ if (!checkUserCanDeleteVideoComment(res.locals.oauth.token.User, res.locals.videoComment, res)) return
+
+ return next()
+ }
+]
+
+// ---------------------------------------------------------------------------
+
+export {
+ listVideoCommentThreadsValidator,
+ listVideoThreadCommentsValidator,
+ addVideoCommentThreadValidator,
+ addVideoCommentReplyValidator,
+ videoCommentGetValidator,
+ removeVideoCommentValidator
+}
+
+// ---------------------------------------------------------------------------
+
+async function isVideoCommentThreadExist (id: number, video: VideoModel, res: express.Response) {
+ const videoComment = await VideoCommentModel.loadById(id)
+
+ if (!videoComment) {
+ res.status(404)
+ .json({ error: 'Video comment thread not found' })
+ .end()
+
+ return false
+ }
+
+ if (videoComment.videoId !== video.id) {
+ res.status(400)
+ .json({ error: 'Video comment is associated to this video.' })
+ .end()
+
+ return false
+ }
+
+ if (videoComment.inReplyToCommentId !== null) {
+ res.status(400)
+ .json({ error: 'Video comment is not a thread.' })
+ .end()
+
+ return false
+ }
+
+ res.locals.videoCommentThread = videoComment
+ return true
+}
+
+async function isVideoCommentExist (id: number, video: VideoModel, res: express.Response) {
+ const videoComment = await VideoCommentModel.loadByIdAndPopulateVideoAndAccountAndReply(id)
+
+ if (!videoComment) {
+ res.status(404)
+ .json({ error: 'Video comment thread not found' })
+ .end()
+
+ return false
+ }
+
+ if (videoComment.videoId !== video.id) {
+ res.status(400)
+ .json({ error: 'Video comment is associated to this video.' })
+ .end()
+
+ return false
+ }
+
+ res.locals.videoComment = videoComment
+ return true
+}
+
+function isVideoCommentsEnabled (video: VideoModel, res: express.Response) {
+ if (video.commentsEnabled !== true) {
+ res.status(409)
+ .json({ error: 'Video comments are disabled for this video.' })
+ .end()
+
+ return false
+ }
+
+ return true
+}
+
+function checkUserCanDeleteVideoComment (user: UserModel, videoComment: VideoCommentModel, res: express.Response) {
+ const account = videoComment.Account
+ if (user.hasRight(UserRight.REMOVE_ANY_VIDEO_COMMENT) === false && account.userId !== user.id) {
+ res.status(403)
+ .json({ error: 'Cannot remove video comment of another user' })
+ .end()
+ return false
+ }
+
+ return true
+}
--- /dev/null
+import * as express from 'express'
+import { body } from 'express-validator/check'
+import { isIdValid } from '../../../helpers/custom-validators/misc'
+import { logger } from '../../../helpers/logger'
+import { areValidationErrors } from '../utils'
+import { getCommonVideoAttributes } from './videos'
+import { isVideoImportTargetUrlValid, isVideoImportTorrentFile } from '../../../helpers/custom-validators/video-imports'
+import { cleanUpReqFiles } from '../../../helpers/express-utils'
+import { isVideoChannelOfAccountExist, isVideoMagnetUriValid, isVideoNameValid } from '../../../helpers/custom-validators/videos'
+import { CONFIG } from '../../../initializers/constants'
+import { CONSTRAINTS_FIELDS } from '../../../initializers'
+
+const videoImportAddValidator = getCommonVideoAttributes().concat([
+ body('channelId')
+ .toInt()
+ .custom(isIdValid).withMessage('Should have correct video channel id'),
+ body('targetUrl')
+ .optional()
+ .custom(isVideoImportTargetUrlValid).withMessage('Should have a valid video import target URL'),
+ body('magnetUri')
+ .optional()
+ .custom(isVideoMagnetUriValid).withMessage('Should have a valid video magnet URI'),
+ body('torrentfile')
+ .custom((value, { req }) => isVideoImportTorrentFile(req.files)).withMessage(
+ 'This torrent file is not supported or too large. Please, make sure it is of the following type: '
+ + CONSTRAINTS_FIELDS.VIDEO_IMPORTS.TORRENT_FILE.EXTNAME.join(', ')
+ ),
+ body('name')
+ .optional()
+ .custom(isVideoNameValid).withMessage('Should have a valid name'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videoImportAddValidator parameters', { parameters: req.body })
+
+ const user = res.locals.oauth.token.User
+ const torrentFile = req.files && req.files['torrentfile'] ? req.files['torrentfile'][0] : undefined
+
+ if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
+
+ if (req.body.targetUrl && CONFIG.IMPORT.VIDEOS.HTTP.ENABLED !== true) {
+ cleanUpReqFiles(req)
+ return res.status(409)
+ .json({ error: 'HTTP import is not enabled on this instance.' })
+ .end()
+ }
+
+ if (CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED !== true && (req.body.magnetUri || torrentFile)) {
+ cleanUpReqFiles(req)
+ return res.status(409)
+ .json({ error: 'Torrent/magnet URI import is not enabled on this instance.' })
+ .end()
+ }
+
+ if (!await isVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
+
+ // Check we have at least 1 required param
+ if (!req.body.targetUrl && !req.body.magnetUri && !torrentFile) {
+ cleanUpReqFiles(req)
+
+ return res.status(400)
+ .json({ error: 'Should have a magnetUri or a targetUrl or a torrent file.' })
+ .end()
+ }
+
+ return next()
+ }
+])
+
+// ---------------------------------------------------------------------------
+
+export {
+ videoImportAddValidator
+}
+
+// ---------------------------------------------------------------------------
--- /dev/null
+import { body, param } from 'express-validator/check'
+import * as express from 'express'
+import { isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
+import { isVideoExist } from '../../../helpers/custom-validators/videos'
+import { areValidationErrors } from '../utils'
+import { logger } from '../../../helpers/logger'
+
+const videoWatchingValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+ body('currentTime')
+ .toInt()
+ .isInt().withMessage('Should have correct current time'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videoWatching parameters', { parameters: req.body })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res, 'id')) return
+
+ return next()
+ }
+]
+
+// ---------------------------------------------------------------------------
+
+export {
+ videoWatchingValidator
+}
--- /dev/null
+import * as express from 'express'
+import 'express-validator'
+import { body, param, ValidationChain } from 'express-validator/check'
+import { UserRight, VideoChangeOwnershipStatus, VideoPrivacy } from '../../../../shared'
+import {
+ isBooleanValid,
+ isDateValid,
+ isIdOrUUIDValid,
+ isIdValid,
+ isUUIDValid,
+ toIntOrNull,
+ toValueOrNull
+} from '../../../helpers/custom-validators/misc'
+import {
+ checkUserCanManageVideo,
+ isScheduleVideoUpdatePrivacyValid,
+ isVideoCategoryValid,
+ isVideoChannelOfAccountExist,
+ isVideoDescriptionValid,
+ isVideoExist,
+ isVideoFile,
+ isVideoImage,
+ isVideoLanguageValid,
+ isVideoLicenceValid,
+ isVideoNameValid,
+ isVideoPrivacyValid,
+ isVideoRatingTypeValid,
+ isVideoSupportValid,
+ isVideoTagsValid
+} from '../../../helpers/custom-validators/videos'
+import { getDurationFromVideoFile } from '../../../helpers/ffmpeg-utils'
+import { logger } from '../../../helpers/logger'
+import { CONSTRAINTS_FIELDS } from '../../../initializers'
+import { VideoShareModel } from '../../../models/video/video-share'
+import { authenticate } from '../../oauth'
+import { areValidationErrors } from '../utils'
+import { cleanUpReqFiles } from '../../../helpers/express-utils'
+import { VideoModel } from '../../../models/video/video'
+import { UserModel } from '../../../models/account/user'
+import { checkUserCanTerminateOwnershipChange, doesChangeVideoOwnershipExist } from '../../../helpers/custom-validators/video-ownership'
+import { VideoChangeOwnershipAccept } from '../../../../shared/models/videos/video-change-ownership-accept.model'
+import { VideoChangeOwnershipModel } from '../../../models/video/video-change-ownership'
+import { AccountModel } from '../../../models/account/account'
+import { VideoFetchType } from '../../../helpers/video'
+
+const videosAddValidator = getCommonVideoAttributes().concat([
+ body('videofile')
+ .custom((value, { req }) => isVideoFile(req.files)).withMessage(
+ 'This file is not supported or too large. Please, make sure it is of the following type: '
+ + CONSTRAINTS_FIELDS.VIDEOS.EXTNAME.join(', ')
+ ),
+ body('name').custom(isVideoNameValid).withMessage('Should have a valid name'),
+ body('channelId')
+ .toInt()
+ .custom(isIdValid).withMessage('Should have correct video channel id'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videosAdd parameters', { parameters: req.body, files: req.files })
+
+ if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
+ if (areErrorsInScheduleUpdate(req, res)) return cleanUpReqFiles(req)
+
+ const videoFile: Express.Multer.File = req.files['videofile'][0]
+ const user = res.locals.oauth.token.User
+
+ if (!await isVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
+
+ const isAble = await user.isAbleToUploadVideo(videoFile)
+ if (isAble === false) {
+ res.status(403)
+ .json({ error: 'The user video quota is exceeded with this video.' })
+ .end()
+
+ return cleanUpReqFiles(req)
+ }
+
+ let duration: number
+
+ try {
+ duration = await getDurationFromVideoFile(videoFile.path)
+ } catch (err) {
+ logger.error('Invalid input file in videosAddValidator.', { err })
+ res.status(400)
+ .json({ error: 'Invalid input file.' })
+ .end()
+
+ return cleanUpReqFiles(req)
+ }
+
+ videoFile['duration'] = duration
+
+ return next()
+ }
+])
+
+const videosUpdateValidator = getCommonVideoAttributes().concat([
+ param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+ body('name')
+ .optional()
+ .custom(isVideoNameValid).withMessage('Should have a valid name'),
+ body('channelId')
+ .optional()
+ .toInt()
+ .custom(isIdValid).withMessage('Should have correct video channel id'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videosUpdate parameters', { parameters: req.body })
+
+ if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
+ if (areErrorsInScheduleUpdate(req, res)) return cleanUpReqFiles(req)
+ if (!await isVideoExist(req.params.id, res)) return cleanUpReqFiles(req)
+
+ const video = res.locals.video
+
+ // Check if the user who did the request is able to update the video
+ const user = res.locals.oauth.token.User
+ if (!checkUserCanManageVideo(user, res.locals.video, UserRight.UPDATE_ANY_VIDEO, res)) return cleanUpReqFiles(req)
+
+ if (video.privacy !== VideoPrivacy.PRIVATE && req.body.privacy === VideoPrivacy.PRIVATE) {
+ cleanUpReqFiles(req)
+ return res.status(409)
+ .json({ error: 'Cannot set "private" a video that was not private.' })
+ .end()
+ }
+
+ if (req.body.channelId && !await isVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
+
+ return next()
+ }
+])
+
+const videosCustomGetValidator = (fetchType: VideoFetchType) => {
+ return [
+ param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videosGet parameters', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.id, res, fetchType)) return
+
+ const video: VideoModel = res.locals.video
+
+ // Video private or blacklisted
+ if (video.privacy === VideoPrivacy.PRIVATE || video.VideoBlacklist) {
+ return authenticate(req, res, () => {
+ const user: UserModel = res.locals.oauth.token.User
+
+ // Only the owner or a user that have blacklist rights can see the video
+ if (video.VideoChannel.Account.userId !== user.id && !user.hasRight(UserRight.MANAGE_VIDEO_BLACKLIST)) {
+ return res.status(403)
+ .json({ error: 'Cannot get this private or blacklisted video.' })
+ .end()
+ }
+
+ return next()
+ })
+ }
+
+ // Video is public, anyone can access it
+ if (video.privacy === VideoPrivacy.PUBLIC) return next()
+
+ // Video is unlisted, check we used the uuid to fetch it
+ if (video.privacy === VideoPrivacy.UNLISTED) {
+ if (isUUIDValid(req.params.id)) return next()
+
+ // Don't leak this unlisted video
+ return res.status(404).end()
+ }
+ }
+ ]
+}
+
+const videosGetValidator = videosCustomGetValidator('all')
+
+const videosRemoveValidator = [
+ param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videosRemove parameters', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.id, res)) return
+
+ // Check if the user who did the request is able to delete the video
+ if (!checkUserCanManageVideo(res.locals.oauth.token.User, res.locals.video, UserRight.REMOVE_ANY_VIDEO, res)) return
+
+ return next()
+ }
+]
+
+const videoRateValidator = [
+ param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+ body('rating').custom(isVideoRatingTypeValid).withMessage('Should have a valid rate type'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videoRate parameters', { parameters: req.body })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.id, res)) return
+
+ return next()
+ }
+]
+
+const videosShareValidator = [
+ param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+ param('accountId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid account id'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videoShare parameters', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.id, res)) return
+
+ const share = await VideoShareModel.load(req.params.accountId, res.locals.video.id, undefined)
+ if (!share) {
+ return res.status(404)
+ .end()
+ }
+
+ res.locals.videoShare = share
+ return next()
+ }
+]
+
+const videosChangeOwnershipValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking changeOwnership parameters', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res)) return
+
+ // Check if the user who did the request is able to change the ownership of the video
+ if (!checkUserCanManageVideo(res.locals.oauth.token.User, res.locals.video, UserRight.CHANGE_VIDEO_OWNERSHIP, res)) return
+
+ const nextOwner = await AccountModel.loadLocalByName(req.body.username)
+ if (!nextOwner) {
+ res.status(400)
+ .type('json')
+ .end()
+ return
+ }
+ res.locals.nextOwner = nextOwner
+
+ return next()
+ }
+]
+
+const videosTerminateChangeOwnershipValidator = [
+ param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking changeOwnership parameters', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+ if (!await doesChangeVideoOwnershipExist(req.params.id, res)) return
+
+ // Check if the user who did the request is able to change the ownership of the video
+ if (!checkUserCanTerminateOwnershipChange(res.locals.oauth.token.User, res.locals.videoChangeOwnership, res)) return
+
+ return next()
+ },
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ const videoChangeOwnership = res.locals.videoChangeOwnership as VideoChangeOwnershipModel
+
+ if (videoChangeOwnership.status === VideoChangeOwnershipStatus.WAITING) {
+ return next()
+ } else {
+ res.status(403)
+ .json({ error: 'Ownership already accepted or refused' })
+ .end()
+ return
+ }
+ }
+]
+
+const videosAcceptChangeOwnershipValidator = [
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ const body = req.body as VideoChangeOwnershipAccept
+ if (!await isVideoChannelOfAccountExist(body.channelId, res.locals.oauth.token.User, res)) return
+
+ const user = res.locals.oauth.token.User
+ const videoChangeOwnership = res.locals.videoChangeOwnership as VideoChangeOwnershipModel
+ const isAble = await user.isAbleToUploadVideo(videoChangeOwnership.Video.getOriginalFile())
+ if (isAble === false) {
+ res.status(403)
+ .json({ error: 'The user video quota is exceeded with this video.' })
+ .end()
+ return
+ }
+
+ return next()
+ }
+]
+
+function getCommonVideoAttributes () {
+ return [
+ body('thumbnailfile')
+ .custom((value, { req }) => isVideoImage(req.files, 'thumbnailfile')).withMessage(
+ 'This thumbnail file is not supported or too large. Please, make sure it is of the following type: '
+ + CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME.join(', ')
+ ),
+ body('previewfile')
+ .custom((value, { req }) => isVideoImage(req.files, 'previewfile')).withMessage(
+ 'This preview file is not supported or too large. Please, make sure it is of the following type: '
+ + CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME.join(', ')
+ ),
+
+ body('category')
+ .optional()
+ .customSanitizer(toIntOrNull)
+ .custom(isVideoCategoryValid).withMessage('Should have a valid category'),
+ body('licence')
+ .optional()
+ .customSanitizer(toIntOrNull)
+ .custom(isVideoLicenceValid).withMessage('Should have a valid licence'),
+ body('language')
+ .optional()
+ .customSanitizer(toValueOrNull)
+ .custom(isVideoLanguageValid).withMessage('Should have a valid language'),
+ body('nsfw')
+ .optional()
+ .toBoolean()
+ .custom(isBooleanValid).withMessage('Should have a valid NSFW attribute'),
+ body('waitTranscoding')
+ .optional()
+ .toBoolean()
+ .custom(isBooleanValid).withMessage('Should have a valid wait transcoding attribute'),
+ body('privacy')
+ .optional()
+ .toInt()
+ .custom(isVideoPrivacyValid).withMessage('Should have correct video privacy'),
+ body('description')
+ .optional()
+ .customSanitizer(toValueOrNull)
+ .custom(isVideoDescriptionValid).withMessage('Should have a valid description'),
+ body('support')
+ .optional()
+ .customSanitizer(toValueOrNull)
+ .custom(isVideoSupportValid).withMessage('Should have a valid support text'),
+ body('tags')
+ .optional()
+ .customSanitizer(toValueOrNull)
+ .custom(isVideoTagsValid).withMessage('Should have correct tags'),
+ body('commentsEnabled')
+ .optional()
+ .toBoolean()
+ .custom(isBooleanValid).withMessage('Should have comments enabled boolean'),
+
+ body('scheduleUpdate')
+ .optional()
+ .customSanitizer(toValueOrNull),
+ body('scheduleUpdate.updateAt')
+ .optional()
+ .custom(isDateValid).withMessage('Should have a valid schedule update date'),
+ body('scheduleUpdate.privacy')
+ .optional()
+ .toInt()
+ .custom(isScheduleVideoUpdatePrivacyValid).withMessage('Should have correct schedule update privacy')
+ ] as (ValidationChain | express.Handler)[]
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+ videosAddValidator,
+ videosUpdateValidator,
+ videosGetValidator,
+ videosCustomGetValidator,
+ videosRemoveValidator,
+ videosShareValidator,
+
+ videoRateValidator,
+
+ videosChangeOwnershipValidator,
+ videosTerminateChangeOwnershipValidator,
+ videosAcceptChangeOwnershipValidator,
+
+ getCommonVideoAttributes
+}
+
+// ---------------------------------------------------------------------------
+
+function areErrorsInScheduleUpdate (req: express.Request, res: express.Response) {
+ if (req.body.scheduleUpdate) {
+ if (!req.body.scheduleUpdate.updateAt) {
+ res.status(400)
+ .json({ error: 'Schedule update at is mandatory.' })
+ .end()
+
+ return true
+ }
+ }
+
+ return false
+}
--- /dev/null
+import { AllowNull, BelongsTo, Column, CreatedAt, ForeignKey, IsInt, Min, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { VideoModel } from '../video/video'
+import { UserModel } from './user'
+
+@Table({
+ tableName: 'userVideoHistory',
+ indexes: [
+ {
+ fields: [ 'userId', 'videoId' ],
+ unique: true
+ },
+ {
+ fields: [ 'userId' ]
+ },
+ {
+ fields: [ 'videoId' ]
+ }
+ ]
+})
+export class UserVideoHistoryModel extends Model<UserVideoHistoryModel> {
+ @CreatedAt
+ createdAt: Date
+
+ @UpdatedAt
+ updatedAt: Date
+
+ @AllowNull(false)
+ @IsInt
+ @Column
+ currentTime: number
+
+ @ForeignKey(() => VideoModel)
+ @Column
+ videoId: number
+
+ @BelongsTo(() => VideoModel, {
+ foreignKey: {
+ allowNull: false
+ },
+ onDelete: 'CASCADE'
+ })
+ Video: VideoModel
+
+ @ForeignKey(() => UserModel)
+ @Column
+ userId: number
+
+ @BelongsTo(() => UserModel, {
+ foreignKey: {
+ allowNull: false
+ },
+ onDelete: 'CASCADE'
+ })
+ User: UserModel
+}
getVideoLikesActivityPubUrl,
getVideoSharesActivityPubUrl
} from '../../lib/activitypub'
+import { isArray } from 'util'
export type VideoFormattingJSONOptions = {
completeDescription?: boolean
const formattedAccount = video.VideoChannel.Account.toFormattedJSON()
const formattedVideoChannel = video.VideoChannel.toFormattedJSON()
+ const userHistory = isArray(video.UserVideoHistories) ? video.UserVideoHistories[0] : undefined
+
const videoObject: Video = {
id: video.id,
uuid: video.uuid,
url: formattedVideoChannel.url,
host: formattedVideoChannel.host,
avatar: formattedVideoChannel.avatar
- }
+ },
+
+ userHistory: userHistory ? {
+ currentTime: userHistory.currentTime
+ } : undefined
}
if (options) {
videoModelToFormattedJSON
} from './video-format-utils'
import * as validator from 'validator'
+import { UserVideoHistoryModel } from '../account/user-video-history'
+
// FIXME: Define indexes here because there is an issue with TS and Sequelize.literal when called directly in the annotation
const indexes: Sequelize.DefineIndexesOptions[] = [
WITH_TAGS = 'WITH_TAGS',
WITH_FILES = 'WITH_FILES',
WITH_SCHEDULED_UPDATE = 'WITH_SCHEDULED_UPDATE',
- WITH_BLACKLISTED = 'WITH_BLACKLISTED'
+ WITH_BLACKLISTED = 'WITH_BLACKLISTED',
+ WITH_USER_HISTORY = 'WITH_USER_HISTORY'
}
type ForAPIOptions = {
include: [
{
model: () => VideoFileModel.unscoped(),
+ // FIXME: typings
+ [ 'separate' as any ]: true, // We may have multiple files, having multiple redundancies so let's separate this join
required: false,
include: [
{
required: false
}
]
+ },
+ [ ScopeNames.WITH_USER_HISTORY ]: (userId: number) => {
+ return {
+ include: [
+ {
+ attributes: [ 'currentTime' ],
+ model: UserVideoHistoryModel.unscoped(),
+ required: false,
+ where: {
+ userId
+ }
+ }
+ ]
+ }
}
})
@Table({
name: 'videoId',
allowNull: false
},
- onDelete: 'cascade',
- hooks: true
+ onDelete: 'cascade'
})
VideoViews: VideoViewModel[]
+ @HasMany(() => UserVideoHistoryModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: false
+ },
+ onDelete: 'cascade'
+ })
+ UserVideoHistories: UserVideoHistoryModel[]
+
@HasOne(() => ScheduleVideoUpdateModel, {
foreignKey: {
name: 'videoId',
accountId?: number,
videoChannelId?: number,
actorId?: number
- trendingDays?: number
+ trendingDays?: number,
+ userId?: number
}, countVideos = true) {
const query: IFindOptions<VideoModel> = {
offset: options.start,
accountId: options.accountId,
videoChannelId: options.videoChannelId,
includeLocalVideos: options.includeLocalVideos,
+ userId: options.userId,
trendingDays
}
tagsAllOf?: string[]
durationMin?: number // seconds
durationMax?: number // seconds
+ userId?: number
}) {
const whereAnd = []
licenceOneOf: options.licenceOneOf,
languageOneOf: options.languageOneOf,
tagsOneOf: options.tagsOneOf,
- tagsAllOf: options.tagsAllOf
+ tagsAllOf: options.tagsAllOf,
+ userId: options.userId
}
return VideoModel.getAvailableForApi(query, queryOptions)
return VideoModel.scope([ ScopeNames.WITH_ACCOUNT_DETAILS, ScopeNames.WITH_FILES ]).findOne(query)
}
- static loadAndPopulateAccountAndServerAndTags (id: number | string, t?: Sequelize.Transaction) {
+ static loadAndPopulateAccountAndServerAndTags (id: number | string, t?: Sequelize.Transaction, userId?: number) {
const where = VideoModel.buildWhereIdOrUUID(id)
const options = {
transaction: t
}
+ const scopes = [
+ ScopeNames.WITH_TAGS,
+ ScopeNames.WITH_BLACKLISTED,
+ ScopeNames.WITH_FILES,
+ ScopeNames.WITH_ACCOUNT_DETAILS,
+ ScopeNames.WITH_SCHEDULED_UPDATE
+ ]
+
+ if (userId) {
+ scopes.push({ method: [ ScopeNames.WITH_USER_HISTORY, userId ] } as any) // FIXME: typings
+ }
+
return VideoModel
- .scope([
- ScopeNames.WITH_TAGS,
- ScopeNames.WITH_BLACKLISTED,
- ScopeNames.WITH_FILES,
- ScopeNames.WITH_ACCOUNT_DETAILS,
- ScopeNames.WITH_SCHEDULED_UPDATE
- ])
+ .scope(scopes)
.findOne(options)
}
return {}
}
- private static async getAvailableForApi (query: IFindOptions<VideoModel>, options: AvailableForListIDsOptions, countVideos = true) {
+ private static async getAvailableForApi (
+ query: IFindOptions<VideoModel>,
+ options: AvailableForListIDsOptions & { userId?: number},
+ countVideos = true
+ ) {
const idsScope = {
method: [
ScopeNames.AVAILABLE_FOR_LIST_IDS, options
if (ids.length === 0) return { data: [], total: count }
- const apiScope = {
- method: [ ScopeNames.FOR_API, { ids, withFiles: options.withFiles } as ForAPIOptions ]
+ // FIXME: typings
+ const apiScope: any[] = [
+ {
+ method: [ ScopeNames.FOR_API, { ids, withFiles: options.withFiles } as ForAPIOptions ]
+ }
+ ]
+
+ if (options.userId) {
+ apiScope.push({ method: [ ScopeNames.WITH_USER_HISTORY, options.userId ] })
}
const secondQuery = {
import './video-comments'
import './video-imports'
import './videos'
+import './videos-history'
--- /dev/null
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+ flushTests,
+ killallServers,
+ makePostBodyRequest,
+ makePutBodyRequest,
+ runServer,
+ ServerInfo,
+ setAccessTokensToServers,
+ uploadVideo
+} from '../../utils'
+
+const expect = chai.expect
+
+describe('Test videos history API validator', function () {
+ let path: string
+ let server: ServerInfo
+
+ // ---------------------------------------------------------------
+
+ before(async function () {
+ this.timeout(30000)
+
+ await flushTests()
+
+ server = await runServer(1)
+
+ await setAccessTokensToServers([ server ])
+
+ const res = await uploadVideo(server.url, server.accessToken, {})
+ const videoUUID = res.body.video.uuid
+
+ path = '/api/v1/videos/' + videoUUID + '/watching'
+ })
+
+ describe('When notifying a user is watching a video', function () {
+
+ it('Should fail with an unauthenticated user', async function () {
+ const fields = { currentTime: 5 }
+ await makePutBodyRequest({ url: server.url, path, fields, statusCodeExpected: 401 })
+ })
+
+ it('Should fail with an incorrect video id', async function () {
+ const fields = { currentTime: 5 }
+ const path = '/api/v1/videos/blabla/watching'
+ await makePutBodyRequest({ url: server.url, path, fields, token: server.accessToken, statusCodeExpected: 400 })
+ })
+
+ it('Should fail with an unknown video', async function () {
+ const fields = { currentTime: 5 }
+ const path = '/api/v1/videos/d91fff41-c24d-4508-8e13-3bd5902c3b02/watching'
+
+ await makePutBodyRequest({ url: server.url, path, fields, token: server.accessToken, statusCodeExpected: 404 })
+ })
+
+ it('Should fail with a bad current time', async function () {
+ const fields = { currentTime: 'hello' }
+ await makePutBodyRequest({ url: server.url, path, fields, token: server.accessToken, statusCodeExpected: 400 })
+ })
+
+ it('Should succeed with the correct parameters', async function () {
+ const fields = { currentTime: 5 }
+
+ await makePutBodyRequest({ url: server.url, path, fields, token: server.accessToken, statusCodeExpected: 204 })
+ })
+ })
+
+ after(async function () {
+ killallServers([ server ])
+
+ // Keep the logs if the test failed
+ if (this['ok']) {
+ await flushTests()
+ }
+ })
+})
import './video-privacy'
import './video-schedule-update'
import './video-transcoder'
+import './videos-history'
import './videos-overview'
--- /dev/null
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+ flushTests,
+ getVideosListWithToken,
+ getVideoWithToken,
+ killallServers, makePutBodyRequest,
+ runServer, searchVideoWithToken,
+ ServerInfo,
+ setAccessTokensToServers,
+ uploadVideo
+} from '../../utils'
+import { Video, VideoDetails } from '../../../../shared/models/videos'
+import { userWatchVideo } from '../../utils/videos/video-history'
+
+const expect = chai.expect
+
+describe('Test videos history', function () {
+ let server: ServerInfo = null
+ let video1UUID: string
+ let video2UUID: string
+ let video3UUID: string
+
+ before(async function () {
+ this.timeout(30000)
+
+ await flushTests()
+
+ server = await runServer(1)
+
+ await setAccessTokensToServers([ server ])
+
+ {
+ const res = await uploadVideo(server.url, server.accessToken, { name: 'video 1' })
+ video1UUID = res.body.video.uuid
+ }
+
+ {
+ const res = await uploadVideo(server.url, server.accessToken, { name: 'video 2' })
+ video2UUID = res.body.video.uuid
+ }
+
+ {
+ const res = await uploadVideo(server.url, server.accessToken, { name: 'video 3' })
+ video3UUID = res.body.video.uuid
+ }
+ })
+
+ it('Should get videos, without watching history', async function () {
+ const res = await getVideosListWithToken(server.url, server.accessToken)
+ const videos: Video[] = res.body.data
+
+ for (const video of videos) {
+ const resDetail = await getVideoWithToken(server.url, server.accessToken, video.id)
+ const videoDetails: VideoDetails = resDetail.body
+
+ expect(video.userHistory).to.be.undefined
+ expect(videoDetails.userHistory).to.be.undefined
+ }
+ })
+
+ it('Should watch the first and second video', async function () {
+ await userWatchVideo(server.url, server.accessToken, video1UUID, 3)
+ await userWatchVideo(server.url, server.accessToken, video2UUID, 8)
+ })
+
+ it('Should return the correct history when listing, searching and getting videos', async function () {
+ const videosOfVideos: Video[][] = []
+
+ {
+ const res = await getVideosListWithToken(server.url, server.accessToken)
+ videosOfVideos.push(res.body.data)
+ }
+
+ {
+ const res = await searchVideoWithToken(server.url, 'video', server.accessToken)
+ videosOfVideos.push(res.body.data)
+ }
+
+ for (const videos of videosOfVideos) {
+ const video1 = videos.find(v => v.uuid === video1UUID)
+ const video2 = videos.find(v => v.uuid === video2UUID)
+ const video3 = videos.find(v => v.uuid === video3UUID)
+
+ expect(video1.userHistory).to.not.be.undefined
+ expect(video1.userHistory.currentTime).to.equal(3)
+
+ expect(video2.userHistory).to.not.be.undefined
+ expect(video2.userHistory.currentTime).to.equal(8)
+
+ expect(video3.userHistory).to.be.undefined
+ }
+
+ {
+ const resDetail = await getVideoWithToken(server.url, server.accessToken, video1UUID)
+ const videoDetails: VideoDetails = resDetail.body
+
+ expect(videoDetails.userHistory).to.not.be.undefined
+ expect(videoDetails.userHistory.currentTime).to.equal(3)
+ }
+
+ {
+ const resDetail = await getVideoWithToken(server.url, server.accessToken, video2UUID)
+ const videoDetails: VideoDetails = resDetail.body
+
+ expect(videoDetails.userHistory).to.not.be.undefined
+ expect(videoDetails.userHistory.currentTime).to.equal(8)
+ }
+
+ {
+ const resDetail = await getVideoWithToken(server.url, server.accessToken, video3UUID)
+ const videoDetails: VideoDetails = resDetail.body
+
+ expect(videoDetails.userHistory).to.be.undefined
+ }
+ })
+
+ after(async function () {
+ killallServers([ server ])
+
+ // Keep the logs if the test failed
+ if (this['ok']) {
+ await flushTests()
+ }
+ })
+})
--- /dev/null
+import { makePutBodyRequest } from '../requests/requests'
+
+function userWatchVideo (url: string, token: string, videoId: number | string, currentTime: number) {
+ const path = '/api/v1/videos/' + videoId + '/watching'
+ const fields = { currentTime }
+
+ return makePutBodyRequest({ url, path, token, fields, statusCodeExpected: 204 })
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+ userWatchVideo
+}
export * from './user-right.enum'
export * from './user-role'
export * from './user-video-quota.model'
+export * from './user-watching-video.model'
--- /dev/null
+export interface UserWatchingVideo {
+ currentTime: number
+}
account: AccountAttribute
channel: VideoChannelAttribute
+
+ userHistory?: {
+ currentTime: number
+ }
}
export interface VideoDetails extends Video {
projects / oweals / peertube.git / commitdiff