-import * as Bluebird from 'bluebird'
-import { Response } from 'express'
import 'express-validator'
-import { AccountModel } from '../../models/account/account'
import { isUserDescriptionValid, isUserUsernameValid } from './users'
import { exists } from './misc'
return isUserDescriptionValid(value)
}
-function doesAccountIdExist (id: number, res: Response, sendNotFound = true) {
- const promise = AccountModel.load(id)
-
- return doesAccountExist(promise, res, sendNotFound)
-}
-
-function doesLocalAccountNameExist (name: string, res: Response, sendNotFound = true) {
- const promise = AccountModel.loadLocalByName(name)
-
- return doesAccountExist(promise, res, sendNotFound)
-}
-
-function doesAccountNameWithHostExist (nameWithDomain: string, res: Response, sendNotFound = true) {
- return doesAccountExist(AccountModel.loadByNameWithHost(nameWithDomain), res, sendNotFound)
-}
-
-async function doesAccountExist (p: Bluebird<AccountModel>, res: Response, sendNotFound: boolean) {
- const account = await p
-
- if (!account) {
- if (sendNotFound === true) {
- res.status(404)
- .send({ error: 'Account not found' })
- .end()
- }
-
- return false
- }
-
- res.locals.account = account
-
- return true
-}
-
// ---------------------------------------------------------------------------
export {
isAccountIdValid,
- doesAccountIdExist,
- doesLocalAccountNameExist,
isAccountDescriptionValid,
- doesAccountNameWithHostExist,
isAccountNameValid
}
return exists(value) && VIDEO_ABUSE_STATES[ value ] !== undefined
}
-async function doesVideoAbuseExist (abuseId: number, videoId: number, res: Response) {
- const videoAbuse = await VideoAbuseModel.loadByIdAndVideoId(abuseId, videoId)
-
- if (videoAbuse === null) {
- res.status(404)
- .json({ error: 'Video abuse not found' })
- .end()
-
- return false
- }
-
- res.locals.videoAbuse = videoAbuse
- return true
-}
-
// ---------------------------------------------------------------------------
export {
- doesVideoAbuseExist,
isVideoAbuseStateValid,
isVideoAbuseReasonValid,
isVideoAbuseModerationCommentValid
-import { Response } from 'express'
import * as validator from 'validator'
import { exists } from './misc'
import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
-import { VideoBlacklistModel } from '../../models/video/video-blacklist'
import { VideoBlacklistType } from '../../../shared/models/videos'
const VIDEO_BLACKLIST_CONSTRAINTS_FIELDS = CONSTRAINTS_FIELDS.VIDEO_BLACKLIST
return value === null || validator.isLength(value, VIDEO_BLACKLIST_CONSTRAINTS_FIELDS.REASON)
}
-async function doesVideoBlacklistExist (videoId: number, res: Response) {
- const videoBlacklist = await VideoBlacklistModel.loadByVideoId(videoId)
-
- if (videoBlacklist === null) {
- res.status(404)
- .json({ error: 'Blacklisted video not found' })
- .end()
-
- return false
- }
-
- res.locals.videoBlacklist = videoBlacklist
- return true
-}
-
function isVideoBlacklistTypeValid (value: any) {
return exists(value) && validator.isInt('' + value) && VideoBlacklistType[value] !== undefined
}
export {
isVideoBlacklistReasonValid,
- isVideoBlacklistTypeValid,
- doesVideoBlacklistExist
+ isVideoBlacklistTypeValid
}
import { CONSTRAINTS_FIELDS, MIMETYPES, VIDEO_LANGUAGES } from '../../initializers/constants'
import { exists, isFileValid } from './misc'
-import { Response } from 'express'
-import { VideoModel } from '../../models/video/video'
-import { VideoCaptionModel } from '../../models/video/video-caption'
function isVideoCaptionLanguageValid (value: any) {
return exists(value) && VIDEO_LANGUAGES[ value ] !== undefined
return isFileValid(files, videoCaptionTypesRegex, field, CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.FILE_SIZE.max)
}
-async function doesVideoCaptionExist (video: VideoModel, language: string, res: Response) {
- const videoCaption = await VideoCaptionModel.loadByVideoIdAndLanguage(video.id, language)
-
- if (!videoCaption) {
- res.status(404)
- .json({ error: 'Video caption not found' })
- .end()
-
- return false
- }
-
- res.locals.videoCaption = videoCaption
- return true
-}
-
// ---------------------------------------------------------------------------
export {
isVideoCaptionFile,
- isVideoCaptionLanguageValid,
- doesVideoCaptionExist
+ isVideoCaptionLanguageValid
}
return value === null || (exists(value) && validator.isLength(value, VIDEO_CHANNELS_CONSTRAINTS_FIELDS.SUPPORT))
}
-async function doesLocalVideoChannelNameExist (name: string, res: express.Response) {
- const videoChannel = await VideoChannelModel.loadLocalByNameAndPopulateAccount(name)
-
- return processVideoChannelExist(videoChannel, res)
-}
-
-async function doesVideoChannelIdExist (id: number, res: express.Response) {
- const videoChannel = await VideoChannelModel.loadAndPopulateAccount(+id)
-
- return processVideoChannelExist(videoChannel, res)
-}
-
-async function doesVideoChannelNameWithHostExist (nameWithDomain: string, res: express.Response) {
- const videoChannel = await VideoChannelModel.loadByNameWithHostAndPopulateAccount(nameWithDomain)
-
- return processVideoChannelExist(videoChannel, res)
-}
-
// ---------------------------------------------------------------------------
export {
- doesVideoChannelNameWithHostExist,
- doesLocalVideoChannelNameExist,
isVideoChannelDescriptionValid,
isVideoChannelNameValid,
isVideoChannelSupportValid,
- doesVideoChannelIdExist
}
function processVideoChannelExist (videoChannel: VideoChannelModel, res: express.Response) {
return exists(value) && VIDEO_PLAYLIST_TYPES[ value ] !== undefined
}
-async function doesVideoPlaylistExist (id: number | string, res: express.Response, fetchType: 'summary' | 'all' = 'summary') {
- const videoPlaylist = fetchType === 'summary'
- ? await VideoPlaylistModel.loadWithAccountAndChannelSummary(id, undefined)
- : await VideoPlaylistModel.loadWithAccountAndChannel(id, undefined)
-
- if (!videoPlaylist) {
- res.status(404)
- .json({ error: 'Video playlist not found' })
- .end()
-
- return false
- }
-
- res.locals.videoPlaylist = videoPlaylist
- return true
-}
-
// ---------------------------------------------------------------------------
export {
- doesVideoPlaylistExist,
isVideoPlaylistNameValid,
isVideoPlaylistDescriptionValid,
isVideoPlaylistPrivacyValid,
} from '../../initializers/constants'
import { VideoModel } from '../../models/video/video'
import { exists, isArray, isDateValid, isFileValid } from './misc'
-import { VideoChannelModel } from '../../models/video/video-channel'
import { UserModel } from '../../models/account/user'
import * as magnetUtil from 'magnet-uri'
-import { fetchVideo, VideoFetchType } from '../video'
const VIDEOS_CONSTRAINTS_FIELDS = CONSTRAINTS_FIELDS.VIDEOS
return parsed && isVideoFileInfoHashValid(parsed.infoHash)
}
-function checkUserCanManageVideo (user: UserModel, video: VideoModel, right: UserRight, res: Response) {
- // Retrieve the user who did the request
- if (video.isOwned() === false) {
- res.status(403)
- .json({ error: 'Cannot manage a video of another server.' })
- .end()
- return false
- }
-
- // Check if the user can delete the video
- // The user can delete it if he has the right
- // Or if s/he is the video's account
- const account = video.VideoChannel.Account
- if (user.hasRight(right) === false && account.userId !== user.id) {
- res.status(403)
- .json({ error: 'Cannot manage a video of another user.' })
- .end()
- return false
- }
-
- return true
-}
-
-async function doesVideoExist (id: number | string, res: Response, fetchType: VideoFetchType = 'all') {
- 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)
- .json({ error: 'Video not found' })
- .end()
-
- return false
- }
-
- if (fetchType !== 'none') res.locals.video = video
- return true
-}
-
-async function doesVideoChannelOfAccountExist (channelId: number, user: UserModel, res: Response) {
- if (user.hasRight(UserRight.UPDATE_ANY_VIDEO) === true) {
- const videoChannel = await VideoChannelModel.loadAndPopulateAccount(channelId)
- if (videoChannel === null) {
- res.status(400)
- .json({ error: 'Unknown video `video channel` on this instance.' })
- .end()
-
- return false
- }
-
- res.locals.videoChannel = videoChannel
- return true
- }
-
- const videoChannel = await VideoChannelModel.loadByIdAndAccount(channelId, user.Account.id)
- if (videoChannel === null) {
- res.status(400)
- .json({ error: 'Unknown video `video channel` for this account.' })
- .end()
-
- return false
- }
-
- res.locals.videoChannel = videoChannel
- return true
-}
-
// ---------------------------------------------------------------------------
export {
isVideoCategoryValid,
- checkUserCanManageVideo,
isVideoLicenceValid,
isVideoLanguageValid,
isVideoTruncatedDescriptionValid,
isVideoPrivacyValid,
isVideoFileResolutionValid,
isVideoFileSizeValid,
- doesVideoExist,
isVideoImage,
- doesVideoChannelOfAccountExist,
isVideoSupportValid,
isVideoFilterValid
}
--- /dev/null
+import { Response } from 'express'
+import { AccountModel } from '../../models/account/account'
+import * as Bluebird from 'bluebird'
+
+function doesAccountIdExist (id: number, res: Response, sendNotFound = true) {
+ const promise = AccountModel.load(id)
+
+ return doesAccountExist(promise, res, sendNotFound)
+}
+
+function doesLocalAccountNameExist (name: string, res: Response, sendNotFound = true) {
+ const promise = AccountModel.loadLocalByName(name)
+
+ return doesAccountExist(promise, res, sendNotFound)
+}
+
+function doesAccountNameWithHostExist (nameWithDomain: string, res: Response, sendNotFound = true) {
+ return doesAccountExist(AccountModel.loadByNameWithHost(nameWithDomain), res, sendNotFound)
+}
+
+async function doesAccountExist (p: Bluebird<AccountModel>, res: Response, sendNotFound: boolean) {
+ const account = await p
+
+ if (!account) {
+ if (sendNotFound === true) {
+ res.status(404)
+ .send({ error: 'Account not found' })
+ .end()
+ }
+
+ return false
+ }
+
+ res.locals.account = account
+
+ return true
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+ doesAccountIdExist,
+ doesLocalAccountNameExist,
+ doesAccountNameWithHostExist,
+ doesAccountExist
+}
--- /dev/null
+export * from './accounts'
+export * from './video-abuses'
+export * from './video-blacklists'
+export * from './video-captions'
+export * from './video-channels'
+export * from './video-playlists'
+export * from './videos'
--- /dev/null
+import * as express from 'express'
+import { VideoChannelModel } from '../../models/video/video-channel'
+
+async function doesLocalVideoChannelNameExist (name: string, res: express.Response) {
+ const videoChannel = await VideoChannelModel.loadLocalByNameAndPopulateAccount(name)
+
+ return processVideoChannelExist(videoChannel, res)
+}
+
+async function doesVideoChannelIdExist (id: number, res: express.Response) {
+ const videoChannel = await VideoChannelModel.loadAndPopulateAccount(+id)
+
+ return processVideoChannelExist(videoChannel, res)
+}
+
+async function doesVideoChannelNameWithHostExist (nameWithDomain: string, res: express.Response) {
+ const videoChannel = await VideoChannelModel.loadByNameWithHostAndPopulateAccount(nameWithDomain)
+
+ return processVideoChannelExist(videoChannel, res)
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+ doesLocalVideoChannelNameExist,
+ doesVideoChannelIdExist,
+ doesVideoChannelNameWithHostExist
+}
+
+function processVideoChannelExist (videoChannel: VideoChannelModel, res: express.Response) {
+ if (!videoChannel) {
+ res.status(404)
+ .json({ error: 'Video channel not found' })
+ .end()
+
+ return false
+ }
+
+ res.locals.videoChannel = videoChannel
+ return true
+}
--- /dev/null
+import { Response } from 'express'
+import { VideoBlacklistModel } from '../../models/video/video-blacklist'
+
+async function doesVideoBlacklistExist (videoId: number, res: Response) {
+ const videoBlacklist = await VideoBlacklistModel.loadByVideoId(videoId)
+
+ if (videoBlacklist === null) {
+ res.status(404)
+ .json({ error: 'Blacklisted video not found' })
+ .end()
+
+ return false
+ }
+
+ res.locals.videoBlacklist = videoBlacklist
+ return true
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+ doesVideoBlacklistExist
+}
--- /dev/null
+import { VideoModel } from '../../models/video/video'
+import { Response } from 'express'
+import { VideoCaptionModel } from '../../models/video/video-caption'
+
+async function doesVideoCaptionExist (video: VideoModel, language: string, res: Response) {
+ const videoCaption = await VideoCaptionModel.loadByVideoIdAndLanguage(video.id, language)
+
+ if (!videoCaption) {
+ res.status(404)
+ .json({ error: 'Video caption not found' })
+ .end()
+
+ return false
+ }
+
+ res.locals.videoCaption = videoCaption
+ return true
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+ doesVideoCaptionExist
+}
--- /dev/null
+import { Response } from 'express'
+import { VideoAbuseModel } from '../../models/video/video-abuse'
+
+async function doesVideoAbuseExist (abuseId: number, videoId: number, res: Response) {
+ const videoAbuse = await VideoAbuseModel.loadByIdAndVideoId(abuseId, videoId)
+
+ if (videoAbuse === null) {
+ res.status(404)
+ .json({ error: 'Video abuse not found' })
+ .end()
+
+ return false
+ }
+
+ res.locals.videoAbuse = videoAbuse
+ return true
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+ doesVideoAbuseExist
+}
--- /dev/null
+import * as express from 'express'
+import { VideoPlaylistModel } from '../../models/video/video-playlist'
+
+async function doesVideoPlaylistExist (id: number | string, res: express.Response, fetchType: 'summary' | 'all' = 'summary') {
+ const videoPlaylist = fetchType === 'summary'
+ ? await VideoPlaylistModel.loadWithAccountAndChannelSummary(id, undefined)
+ : await VideoPlaylistModel.loadWithAccountAndChannel(id, undefined)
+
+ if (!videoPlaylist) {
+ res.status(404)
+ .json({ error: 'Video playlist not found' })
+ .end()
+
+ return false
+ }
+
+ res.locals.videoPlaylist = videoPlaylist
+ return true
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+ doesVideoPlaylistExist
+}
--- /dev/null
+import { Response } from 'express'
+import { fetchVideo, VideoFetchType } from '../video'
+import { UserModel } from '../../models/account/user'
+import { UserRight } from '../../../shared/models/users'
+import { VideoChannelModel } from '../../models/video/video-channel'
+import { VideoModel } from '../../models/video/video'
+
+async function doesVideoExist (id: number | string, res: Response, fetchType: VideoFetchType = 'all') {
+ 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)
+ .json({ error: 'Video not found' })
+ .end()
+
+ return false
+ }
+
+ if (fetchType !== 'none') res.locals.video = video
+ return true
+}
+
+async function doesVideoChannelOfAccountExist (channelId: number, user: UserModel, res: Response) {
+ if (user.hasRight(UserRight.UPDATE_ANY_VIDEO) === true) {
+ const videoChannel = await VideoChannelModel.loadAndPopulateAccount(channelId)
+ if (videoChannel === null) {
+ res.status(400)
+ .json({ error: 'Unknown video `video channel` on this instance.' })
+ .end()
+
+ return false
+ }
+
+ res.locals.videoChannel = videoChannel
+ return true
+ }
+
+ const videoChannel = await VideoChannelModel.loadByIdAndAccount(channelId, user.Account.id)
+ if (videoChannel === null) {
+ res.status(400)
+ .json({ error: 'Unknown video `video channel` for this account.' })
+ .end()
+
+ return false
+ }
+
+ res.locals.videoChannel = videoChannel
+ return true
+}
+
+function checkUserCanManageVideo (user: UserModel, video: VideoModel, right: UserRight, res: Response) {
+ // Retrieve the user who did the request
+ if (video.isOwned() === false) {
+ res.status(403)
+ .json({ error: 'Cannot manage a video of another server.' })
+ .end()
+ return false
+ }
+
+ // Check if the user can delete the video
+ // The user can delete it if he has the right
+ // Or if s/he is the video's account
+ const account = video.VideoChannel.Account
+ if (user.hasRight(right) === false && account.userId !== user.id) {
+ res.status(403)
+ .json({ error: 'Cannot manage a video of another user.' })
+ .end()
+ return false
+ }
+
+ return true
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+ doesVideoChannelOfAccountExist,
+ doesVideoExist,
+ checkUserCanManageVideo
+}
import { VideoChannelModel } from '../models/video/video-channel'
import * as Bluebird from 'bluebird'
import { CONFIG } from '../initializers/config'
+import { logger } from '../helpers/logger'
export class ClientHtml {
private static htmlCache: { [ path: string ]: string } = {}
static invalidCache () {
+ logger.info('Cleaning HTML cache.')
+
ClientHtml.htmlCache = {}
}
private static async addAsyncPluginCSS (htmlStringPage: string) {
const globalCSSContent = await readFile(PLUGIN_GLOBAL_CSS_PATH)
- if (!globalCSSContent) return htmlStringPage
+ if (globalCSSContent.byteLength === 0) return htmlStringPage
const fileHash = sha256(globalCSSContent)
const linkTag = `<link rel="stylesheet" href="/plugins/global.css?hash=${fileHash}" />`
// ###################### CSS ######################
private resetCSSGlobalFile () {
+ ClientHtml.invalidCache()
+
return outputFile(PLUGIN_GLOBAL_CSS_PATH, '')
}
import * as express from 'express'
import { param } from 'express-validator/check'
-import { isAccountNameValid, doesAccountNameWithHostExist, doesLocalAccountNameExist } from '../../helpers/custom-validators/accounts'
+import { isAccountNameValid } from '../../helpers/custom-validators/accounts'
import { logger } from '../../helpers/logger'
import { areValidationErrors } from './utils'
+import { doesAccountNameWithHostExist, doesLocalAccountNameExist } from '../../helpers/middlewares'
const localAccountValidator = [
param('name').custom(isAccountNameValid).withMessage('Should have a valid account name'),
import * as express from 'express'
import { logger } from '../../helpers/logger'
import { areValidationErrors } from './utils'
-import { doesAccountNameWithHostExist } from '../../helpers/custom-validators/accounts'
import { AccountBlocklistModel } from '../../models/account/account-blocklist'
import { isHostValid } from '../../helpers/custom-validators/servers'
import { ServerBlocklistModel } from '../../models/server/server-blocklist'
import { ServerModel } from '../../models/server/server'
import { getServerActor } from '../../helpers/utils'
import { WEBSERVER } from '../../initializers/constants'
+import { doesAccountNameWithHostExist } from '../../helpers/middlewares'
const blockAccountValidator = [
body('accountName').exists().withMessage('Should have an account name with host'),
import * as express from 'express'
import { param, query } from 'express-validator/check'
-import { doesAccountIdExist, doesAccountNameWithHostExist } from '../../helpers/custom-validators/accounts'
import { isIdOrUUIDValid, isIdValid } from '../../helpers/custom-validators/misc'
import { logger } from '../../helpers/logger'
import { areValidationErrors } from './utils'
import { isValidRSSFeed } from '../../helpers/custom-validators/feeds'
-import { doesVideoChannelIdExist, doesVideoChannelNameWithHostExist } from '../../helpers/custom-validators/video-channels'
-import { doesVideoExist } from '../../helpers/custom-validators/videos'
+import { doesVideoExist } from '../../helpers/middlewares/videos'
+import {
+ doesAccountIdExist,
+ doesAccountNameWithHostExist,
+ doesVideoChannelIdExist,
+ doesVideoChannelNameWithHostExist
+} from '../../helpers/middlewares'
const videoFeedsValidator = [
param('format').optional().custom(isValidRSSFeed).withMessage('Should have a valid format (rss, atom, json)'),
import { join } from 'path'
import { isTestInstance } from '../../helpers/core-utils'
import { isIdOrUUIDValid } from '../../helpers/custom-validators/misc'
-import { doesVideoExist } from '../../helpers/custom-validators/videos'
import { logger } from '../../helpers/logger'
import { areValidationErrors } from './utils'
import { WEBSERVER } from '../../initializers/constants'
+import { doesVideoExist } from '../../helpers/middlewares'
const urlShouldStartWith = WEBSERVER.SCHEME + '://' + join(WEBSERVER.HOST, 'videos', 'watch') + '/'
const videoWatchRegex = new RegExp('([^/]+)$')
import 'express-validator'
import { body, param } from 'express-validator/check'
import { exists, isBooleanValid, isIdOrUUIDValid, toIntOrNull } from '../../helpers/custom-validators/misc'
-import { doesVideoExist } from '../../helpers/custom-validators/videos'
import { logger } from '../../helpers/logger'
import { areValidationErrors } from './utils'
import { VideoRedundancyModel } from '../../models/redundancy/video-redundancy'
import { isHostValid } from '../../helpers/custom-validators/servers'
import { ServerModel } from '../../models/server/server'
+import { doesVideoExist } from '../../helpers/middlewares'
const videoFileRedundancyGetValidator = [
param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
isUserNSFWPolicyValid,
isUserPasswordValid,
isUserRoleValid,
- isUserUsernameValid, isUserVideoLanguages,
+ isUserUsernameValid,
+ isUserVideoLanguages,
isUserVideoQuotaDailyValid,
isUserVideoQuotaValid,
isUserVideosHistoryEnabledValid
} from '../../helpers/custom-validators/users'
-import { doesVideoExist } from '../../helpers/custom-validators/videos'
import { logger } from '../../helpers/logger'
import { isSignupAllowed, isSignupAllowedForCurrentIP } from '../../helpers/signup'
import { Redis } from '../../lib/redis'
import { UserRegister } from '../../../shared/models/users/user-register.model'
import { isThemeNameValid } from '../../helpers/custom-validators/plugins'
import { isThemeRegistered } from '../../lib/plugins/theme-utils'
+import { doesVideoExist } from '../../helpers/middlewares'
const usersAddValidator = [
body('username').custom(isUserUsernameValid).withMessage('Should have a valid username (lowercase alphanumeric characters)'),
import 'express-validator'
import { body, param } from 'express-validator/check'
import { isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
-import { doesVideoExist } from '../../../helpers/custom-validators/videos'
import { logger } from '../../../helpers/logger'
import { areValidationErrors } from '../utils'
import {
- doesVideoAbuseExist,
isVideoAbuseModerationCommentValid,
isVideoAbuseReasonValid,
isVideoAbuseStateValid
} from '../../../helpers/custom-validators/video-abuses'
+import { doesVideoAbuseExist, doesVideoExist } from '../../../helpers/middlewares'
const videoAbuseReportValidator = [
param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
import * as express from 'express'
import { body, param, query } from 'express-validator/check'
import { isBooleanValid, isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
-import { doesVideoExist } from '../../../helpers/custom-validators/videos'
import { logger } from '../../../helpers/logger'
import { areValidationErrors } from '../utils'
-import {
- doesVideoBlacklistExist,
- isVideoBlacklistReasonValid,
- isVideoBlacklistTypeValid
-} from '../../../helpers/custom-validators/video-blacklist'
+import { isVideoBlacklistReasonValid, isVideoBlacklistTypeValid } from '../../../helpers/custom-validators/video-blacklist'
+import { doesVideoBlacklistExist, doesVideoExist } from '../../../helpers/middlewares'
const videosBlacklistRemoveValidator = [
param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
import * as express from 'express'
import { areValidationErrors } from '../utils'
-import { checkUserCanManageVideo, doesVideoExist } from '../../../helpers/custom-validators/videos'
import { isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
import { body, param } from 'express-validator/check'
import { CONSTRAINTS_FIELDS } from '../../../initializers/constants'
import { UserRight } from '../../../../shared'
import { logger } from '../../../helpers/logger'
-import { doesVideoCaptionExist, isVideoCaptionFile, isVideoCaptionLanguageValid } from '../../../helpers/custom-validators/video-captions'
+import { isVideoCaptionFile, isVideoCaptionLanguageValid } from '../../../helpers/custom-validators/video-captions'
import { cleanUpReqFiles } from '../../../helpers/express-utils'
+import { checkUserCanManageVideo, doesVideoCaptionExist, doesVideoExist } from '../../../helpers/middlewares'
const addVideoCaptionValidator = [
param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
import { body, param } from 'express-validator/check'
import { UserRight } from '../../../../shared'
import {
- doesLocalVideoChannelNameExist,
- doesVideoChannelNameWithHostExist,
isVideoChannelDescriptionValid,
isVideoChannelNameValid,
isVideoChannelSupportValid
import { isActorPreferredUsernameValid } from '../../../helpers/custom-validators/activitypub/actor'
import { ActorModel } from '../../../models/activitypub/actor'
import { isBooleanValid } from '../../../helpers/custom-validators/misc'
+import { doesLocalVideoChannelNameExist, doesVideoChannelNameWithHostExist } from '../../../helpers/middlewares'
const videoChannelsAddValidator = [
body('name').custom(isActorPreferredUsernameValid).withMessage('Should have a valid channel name'),
import { UserRight } from '../../../../shared'
import { isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
import { isValidVideoCommentText } from '../../../helpers/custom-validators/video-comments'
-import { doesVideoExist } from '../../../helpers/custom-validators/videos'
import { logger } from '../../../helpers/logger'
import { UserModel } from '../../../models/account/user'
import { VideoModel } from '../../../models/video/video'
import { areValidationErrors } from '../utils'
import { Hooks } from '../../../lib/plugins/hooks'
import { isLocalVideoThreadAccepted, isLocalVideoCommentReplyAccepted, AcceptResult } from '../../../lib/moderation'
+import { doesVideoExist } from '../../../helpers/middlewares'
const listVideoCommentThreadsValidator = [
param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
import { getCommonVideoEditAttributes } from './videos'
import { isVideoImportTargetUrlValid, isVideoImportTorrentFile } from '../../../helpers/custom-validators/video-imports'
import { cleanUpReqFiles } from '../../../helpers/express-utils'
-import { doesVideoChannelOfAccountExist, isVideoMagnetUriValid, isVideoNameValid } from '../../../helpers/custom-validators/videos'
+import { isVideoMagnetUriValid, isVideoNameValid } from '../../../helpers/custom-validators/videos'
import { CONFIG } from '../../../initializers/config'
import { CONSTRAINTS_FIELDS } from '../../../initializers/constants'
+import { doesVideoChannelOfAccountExist } from '../../../helpers/middlewares'
const videoImportAddValidator = getCommonVideoEditAttributes().concat([
body('channelId')
import { logger } from '../../../helpers/logger'
import { UserModel } from '../../../models/account/user'
import { areValidationErrors } from '../utils'
-import { doesVideoExist, isVideoImage } from '../../../helpers/custom-validators/videos'
+import { isVideoImage } from '../../../helpers/custom-validators/videos'
import { CONSTRAINTS_FIELDS } from '../../../initializers/constants'
import { isArrayOf, isIdOrUUIDValid, isIdValid, isUUIDValid, toIntArray, toValueOrNull } from '../../../helpers/custom-validators/misc'
import {
- doesVideoPlaylistExist,
isVideoPlaylistDescriptionValid,
isVideoPlaylistNameValid,
isVideoPlaylistPrivacyValid,
} from '../../../helpers/custom-validators/video-playlists'
import { VideoPlaylistModel } from '../../../models/video/video-playlist'
import { cleanUpReqFiles } from '../../../helpers/express-utils'
-import { doesVideoChannelIdExist } from '../../../helpers/custom-validators/video-channels'
import { VideoPlaylistElementModel } from '../../../models/video/video-playlist-element'
import { authenticatePromiseIfNeeded } from '../../oauth'
import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
import { VideoPlaylistType } from '../../../../shared/models/videos/playlist/video-playlist-type.model'
+import { doesVideoChannelIdExist, doesVideoExist, doesVideoPlaylistExist } from '../../../helpers/middlewares'
const videoPlaylistsAddValidator = getCommonPlaylistEditAttributes().concat([
body('displayName')
import { body, param, query } from 'express-validator/check'
import { isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
import { isRatingValid } from '../../../helpers/custom-validators/video-rates'
-import { doesVideoExist, isVideoRatingTypeValid } from '../../../helpers/custom-validators/videos'
+import { isVideoRatingTypeValid } from '../../../helpers/custom-validators/videos'
import { logger } from '../../../helpers/logger'
import { areValidationErrors } from '../utils'
import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
import { VideoRateType } from '../../../../shared/models/videos'
import { isAccountNameValid } from '../../../helpers/custom-validators/accounts'
+import { doesVideoExist } from '../../../helpers/middlewares'
const videoUpdateRateValidator = [
param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
import 'express-validator'
import { param } from 'express-validator/check'
import { isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
-import { doesVideoExist } from '../../../helpers/custom-validators/videos'
import { logger } from '../../../helpers/logger'
import { VideoShareModel } from '../../../models/video/video-share'
import { areValidationErrors } from '../utils'
+import { doesVideoExist } from '../../../helpers/middlewares'
const videosShareValidator = [
param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
import { body, param } from 'express-validator/check'
import * as express from 'express'
import { isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
-import { doesVideoExist } from '../../../helpers/custom-validators/videos'
import { areValidationErrors } from '../utils'
import { logger } from '../../../helpers/logger'
+import { doesVideoExist } from '../../../helpers/middlewares'
const videoWatchingValidator = [
param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
toValueOrNull
} from '../../../helpers/custom-validators/misc'
import {
- checkUserCanManageVideo,
- doesVideoChannelOfAccountExist,
- doesVideoExist,
isScheduleVideoUpdatePrivacyValid,
isVideoCategoryValid,
isVideoDescriptionValid,
import { getDurationFromVideoFile } from '../../../helpers/ffmpeg-utils'
import { logger } from '../../../helpers/logger'
import { CONSTRAINTS_FIELDS } from '../../../initializers/constants'
-import { authenticate, authenticatePromiseIfNeeded } from '../../oauth'
+import { authenticatePromiseIfNeeded } from '../../oauth'
import { areValidationErrors } from '../utils'
import { cleanUpReqFiles } from '../../../helpers/express-utils'
import { VideoModel } from '../../../models/video/video'
import { CONFIG } from '../../../initializers/config'
import { isLocalVideoAccepted } from '../../../lib/moderation'
import { Hooks } from '../../../lib/plugins/hooks'
+import { checkUserCanManageVideo, doesVideoChannelOfAccountExist, doesVideoExist } from '../../../helpers/middlewares'
const videosAddValidator = getCommonVideoEditAttributes().concat([
body('videofile')
projects / oweals / peertube.git / commitdiff