import Bluebird from 'bluebird'
import { remove } from 'fs-extra'
import { maxBy, minBy } from 'lodash'
-import { join } from 'path'
import { FindOptions, Includeable, IncludeOptions, Op, QueryTypes, ScopeOptions, Sequelize, Transaction, WhereOptions } from 'sequelize'
import {
+ AfterCreate,
+ AfterDestroy,
+ AfterUpdate,
AllowNull,
BeforeDestroy,
BelongsTo,
UpdatedAt
} from 'sequelize-typescript'
import { getPrivaciesForFederation, isPrivacyForFederation, isStateForFederation } from '@server/helpers/video'
+import { InternalEventEmitter } from '@server/lib/internal-event-emitter'
import { LiveManager } from '@server/lib/live/live-manager'
-import { removeHLSFileObjectStorage, removeHLSObjectStorage, removeWebTorrentObjectStorage } from '@server/lib/object-storage'
+import { removeHLSFileObjectStorageByFilename, removeHLSObjectStorage, removeWebTorrentObjectStorage } from '@server/lib/object-storage'
import { tracer } from '@server/lib/opentelemetry/tracing'
import { getHLSDirectory, getHLSRedundancyDirectory, getHlsResolutionPlaylistFilename } from '@server/lib/paths'
+import { Hooks } from '@server/lib/plugins/hooks'
import { VideoPathManager } from '@server/lib/video-path-manager'
+import { isVideoInPrivateDirectory } from '@server/lib/video-privacy'
import { getServerActor } from '@server/models/application/application'
-import { ModelCache } from '@server/models/model-cache'
+import { ModelCache } from '@server/models/shared/model-cache'
import { buildVideoEmbedPath, buildVideoWatchPath, pick } from '@shared/core-utils'
-import { ffprobePromise, getAudioStream, uuidToShort } from '@shared/extra-utils'
+import { uuidToShort } from '@shared/extra-utils'
+import { ffprobePromise, getAudioStream, getVideoStreamDimensionsInfo, getVideoStreamFPS, hasAudioStream } from '@shared/ffmpeg'
import {
ResultList,
ThumbnailType,
import { AttributesOnly } from '@shared/typescript-utils'
import { peertubeTruncate } from '../../helpers/core-utils'
import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
-import { exists, isBooleanValid } from '../../helpers/custom-validators/misc'
+import { exists, isBooleanValid, isUUIDValid } from '../../helpers/custom-validators/misc'
import {
isVideoDescriptionValid,
isVideoDurationValid,
isVideoStateValid,
isVideoSupportValid
} from '../../helpers/custom-validators/videos'
-import { getVideoStreamDimensionsInfo } from '../../helpers/ffmpeg'
import { logger } from '../../helpers/logger'
import { CONFIG } from '../../initializers/config'
-import { ACTIVITY_PUB, API_VERSION, CONSTRAINTS_FIELDS, LAZY_STATIC_PATHS, STATIC_PATHS, WEBSERVER } from '../../initializers/constants'
+import { ACTIVITY_PUB, API_VERSION, CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants'
import { sendDeleteVideo } from '../../lib/activitypub/send'
import {
MChannel,
import { ServerModel } from '../server/server'
import { TrackerModel } from '../server/tracker'
import { VideoTrackerModel } from '../server/video-tracker'
-import { setAsUpdated } from '../shared'
+import { buildTrigramSearchIndex, buildWhereIdOrUUID, getVideoSort, isOutdated, setAsUpdated, throwIfNotValid } from '../shared'
import { UserModel } from '../user/user'
import { UserVideoHistoryModel } from '../user/user-video-history'
-import { buildTrigramSearchIndex, buildWhereIdOrUUID, getVideoSort, isOutdated, throwIfNotValid } from '../utils'
import { VideoViewModel } from '../view/video-view'
import {
videoFilesModelToFormattedJSON,
name: 'videoId',
allowNull: false
},
+ hooks: true,
onDelete: 'cascade'
})
VideoLive: VideoLiveModel
})
VideoJobInfo: VideoJobInfoModel
+ @AfterCreate
+ static notifyCreate (video: MVideo) {
+ InternalEventEmitter.Instance.emit('video-created', { video })
+ }
+
+ @AfterUpdate
+ static notifyUpdate (video: MVideo) {
+ InternalEventEmitter.Instance.emit('video-updated', { video })
+ }
+
+ @AfterDestroy
+ static notifyDestroy (video: MVideo) {
+ InternalEventEmitter.Instance.emit('video-deleted', { video })
+ }
+
@BeforeDestroy
- static async sendDelete (instance: MVideoAccountLight, options) {
+ static async sendDelete (instance: MVideoAccountLight, options: { transaction: Transaction }) {
if (!instance.isOwned()) return undefined
// Lazy load channels
// Do not wait video deletion because we could be in a transaction
Promise.all(tasks)
- .catch(err => {
- logger.error('Some errors when removing files of video %s in before destroy hook.', instance.uuid, { err })
- })
+ .then(() => logger.info('Removed files of video %s.', instance.url))
+ .catch(err => logger.error('Some errors when removing files of video %s in before destroy hook.', instance.uuid, { err }))
return undefined
}
logger.info('Stopping live of video %s after video deletion.', instance.uuid)
- LiveManager.Instance.stopSessionOf(instance.id, null)
+ LiveManager.Instance.stopSessionOf(instance.uuid, null)
}
@BeforeDestroy
countVideos?: boolean
search?: string
+
+ excludeAlreadyWatched?: boolean
}) {
VideoModel.throwIfPrivateIncludeWithoutUser(options.include, options.user)
VideoModel.throwIfPrivacyOneOfWithoutUser(options.privacyOneOf, options.user)
'historyOfUser',
'hasHLSFiles',
'hasWebtorrentFiles',
- 'search'
+ 'search',
+ 'excludeAlreadyWatched'
]),
serverAccountIdForBlock: serverActor.Account.id,
durationMin?: number // seconds
durationMax?: number // seconds
uuids?: string[]
+
+ excludeAlreadyWatched?: boolean
}) {
VideoModel.throwIfPrivateIncludeWithoutUser(options.include, options.user)
VideoModel.throwIfPrivacyOneOfWithoutUser(options.privacyOneOf, options.user)
'hasWebtorrentFiles',
'uuids',
'search',
- 'displayOnlyForFollower'
+ 'displayOnlyForFollower',
+ 'excludeAlreadyWatched'
]),
serverAccountIdForBlock: serverActor.Account.id
}
const query = 'SELECT 1 FROM "videoShare" ' +
'INNER JOIN "actorFollow" ON "actorFollow"."targetActorId" = "videoShare"."actorId" ' +
'WHERE "actorFollow"."actorId" = $followerActorId AND "actorFollow"."state" = \'accepted\' AND "videoShare"."videoId" = $videoId ' +
+ 'UNION ' +
+ 'SELECT 1 FROM "video" ' +
+ 'INNER JOIN "videoChannel" ON "videoChannel"."id" = "video"."channelId" ' +
+ 'INNER JOIN "account" ON "account"."id" = "videoChannel"."accountId" ' +
+ 'INNER JOIN "actorFollow" ON "actorFollow"."targetActorId" = "account"."actorId" ' +
+ 'WHERE "actorFollow"."actorId" = $followerActorId AND "actorFollow"."state" = \'accepted\' AND "video"."id" = $videoId ' +
'LIMIT 1'
const options = {
const thumbnail = this.getMiniature()
if (!thumbnail) return null
- return join(STATIC_PATHS.THUMBNAILS, thumbnail.filename)
+ return thumbnail.getLocalStaticPath()
}
getPreviewStaticPath () {
const preview = this.getPreview()
if (!preview) return null
- // We use a local cache, so specify our cache endpoint instead of potential remote URL
- return join(LAZY_STATIC_PATHS.PREVIEWS, preview.filename)
+ return preview.getLocalStaticPath()
}
toFormattedJSON (this: MVideoFormattable, options?: VideoFormattingJSONOptions): Video {
return videoModelToFormattedDetailsJSON(this)
}
- getFormattedVideoFilesJSON (includeMagnet = true): VideoFile[] {
+ getFormattedWebVideoFilesJSON (includeMagnet = true): VideoFile[] {
+ return videoFilesModelToFormattedJSON(this, this.VideoFiles, { includeMagnet })
+ }
+
+ getFormattedHLSVideoFilesJSON (includeMagnet = true): VideoFile[] {
+ let acc: VideoFile[] = []
+
+ for (const p of this.VideoStreamingPlaylists) {
+ acc = acc.concat(videoFilesModelToFormattedJSON(this, p.VideoFiles, { includeMagnet }))
+ }
+
+ return acc
+ }
+
+ getFormattedAllVideoFilesJSON (includeMagnet = true): VideoFile[] {
let files: VideoFile[] = []
if (Array.isArray(this.VideoFiles)) {
- const result = videoFilesModelToFormattedJSON(this, this.VideoFiles, includeMagnet)
- files = files.concat(result)
+ files = files.concat(this.getFormattedWebVideoFilesJSON(includeMagnet))
}
- for (const p of (this.VideoStreamingPlaylists || [])) {
- const result = videoFilesModelToFormattedJSON(this, p.VideoFiles, includeMagnet)
- files = files.concat(result)
+ if (Array.isArray(this.VideoStreamingPlaylists)) {
+ files = files.concat(this.getFormattedHLSVideoFilesJSON(includeMagnet))
}
return files
}
- toActivityPubObject (this: MVideoAP): VideoObject {
- return videoModelToActivityPubObject(this)
+ toActivityPubObject (this: MVideoAP): Promise<VideoObject> {
+ return Hooks.wrapObject(
+ videoModelToActivityPubObject(this),
+ 'filter:activity-pub.video.json-ld.build.result',
+ { video: this }
+ )
}
getTruncatedDescription () {
const probe = await ffprobePromise(originalFilePath)
const { audioStream } = await getAudioStream(originalFilePath, probe)
+ const hasAudio = await hasAudioStream(originalFilePath, probe)
+ const fps = await getVideoStreamFPS(originalFilePath, probe)
return {
audioStream,
+ hasAudio,
+ fps,
...await getVideoStreamDimensionsInfo(originalFilePath, probe)
}
const playlist = this.VideoStreamingPlaylists.find(p => p.type === VideoStreamingPlaylistType.HLS)
if (!playlist) return undefined
- playlist.Video = this
-
- return playlist
+ return playlist.withVideo(this)
}
setHLSPlaylist (playlist: MStreamingPlaylist) {
await remove(VideoPathManager.Instance.getFSHLSOutputPath(this, resolutionFilename))
if (videoFile.storage === VideoStorage.OBJECT_STORAGE) {
- await removeHLSFileObjectStorage(streamingPlaylist.withVideo(this), videoFile.filename)
- await removeHLSFileObjectStorage(streamingPlaylist.withVideo(this), resolutionFilename)
+ await removeHLSFileObjectStorageByFilename(streamingPlaylist.withVideo(this), videoFile.filename)
+ await removeHLSFileObjectStorageByFilename(streamingPlaylist.withVideo(this), resolutionFilename)
}
}
await remove(filePath)
if (streamingPlaylist.storage === VideoStorage.OBJECT_STORAGE) {
- await removeHLSFileObjectStorage(streamingPlaylist.withVideo(this), filename)
+ await removeHLSFileObjectStorageByFilename(streamingPlaylist.withVideo(this), filename)
}
}
}
setAsRefreshed (transaction?: Transaction) {
- return setAsUpdated('video', this.id, transaction)
+ return setAsUpdated({ sequelize: this.sequelize, table: 'video', id: this.id, transaction })
}
- requiresAuth () {
- return this.privacy === VideoPrivacy.PRIVATE || this.privacy === VideoPrivacy.INTERNAL || !!this.VideoBlacklist
- }
+ // ---------------------------------------------------------------------------
- setPrivacy (newPrivacy: VideoPrivacy) {
- if (this.privacy === VideoPrivacy.PRIVATE && newPrivacy !== VideoPrivacy.PRIVATE) {
- this.publishedAt = new Date()
+ requiresAuth (options: {
+ urlParamId: string
+ checkBlacklist: boolean
+ }) {
+ const { urlParamId, checkBlacklist } = options
+
+ if (this.privacy === VideoPrivacy.PRIVATE || this.privacy === VideoPrivacy.INTERNAL) {
+ return true
}
- this.privacy = newPrivacy
+ if (this.privacy === VideoPrivacy.UNLISTED) {
+ if (urlParamId && !isUUIDValid(urlParamId)) return true
+
+ return false
+ }
+
+ if (checkBlacklist && this.VideoBlacklist) return true
+
+ if (this.privacy !== VideoPrivacy.PUBLIC) {
+ throw new Error(`Unknown video privacy ${this.privacy} to know if the video requires auth`)
+ }
+
+ return false
}
- isConfidential () {
- return this.privacy === VideoPrivacy.PRIVATE ||
- this.privacy === VideoPrivacy.UNLISTED ||
- this.privacy === VideoPrivacy.INTERNAL
+ hasPrivateStaticPath () {
+ return isVideoInPrivateDirectory(this.privacy)
}
+ // ---------------------------------------------------------------------------
+
async setNewState (newState: VideoState, isNewVideo: boolean, transaction: Transaction) {
if (this.state === newState) throw new Error('Cannot use same state ' + newState)