-import { map, maxBy, truncate } from 'lodash'
-import * as magnetUtil from 'magnet-uri'
-import * as parseTorrent from 'parse-torrent'
+import Bluebird from 'bluebird'
+import { remove } from 'fs-extra'
+import { maxBy, minBy } from 'lodash'
import { join } from 'path'
-import * as safeBuffer from 'safe-buffer'
-import * as Sequelize from 'sequelize'
-import { VideoPrivacy, VideoResolution } from '../../../shared'
-import { VideoTorrentObject } from '../../../shared/models/activitypub/objects/video-torrent-object'
+import { FindOptions, Includeable, IncludeOptions, Op, QueryTypes, ScopeOptions, Sequelize, Transaction, WhereOptions } from 'sequelize'
+import {
+ AllowNull,
+ BeforeDestroy,
+ BelongsTo,
+ BelongsToMany,
+ Column,
+ CreatedAt,
+ DataType,
+ Default,
+ ForeignKey,
+ HasMany,
+ HasOne,
+ Is,
+ IsInt,
+ IsUUID,
+ Min,
+ Model,
+ Scopes,
+ Table,
+ UpdatedAt
+} from 'sequelize-typescript'
+import { buildNSFWFilter } from '@server/helpers/express-utils'
+import { getPrivaciesForFederation, isPrivacyForFederation, isStateForFederation } from '@server/helpers/video'
+import { LiveManager } from '@server/lib/live/live-manager'
+import { removeHLSObjectStorage, removeWebTorrentObjectStorage } from '@server/lib/object-storage'
+import { getHLSDirectory, getHLSRedundancyDirectory } from '@server/lib/paths'
+import { VideoPathManager } from '@server/lib/video-path-manager'
+import { getServerActor } from '@server/models/application/application'
+import { ModelCache } from '@server/models/model-cache'
+import { buildVideoEmbedPath, buildVideoWatchPath, pick } from '@shared/core-utils'
+import { uuidToShort } from '@shared/extra-utils'
+import {
+ ResultList,
+ ThumbnailType,
+ UserRight,
+ Video,
+ VideoDetails,
+ VideoFile,
+ VideoInclude,
+ VideoObject,
+ VideoPrivacy,
+ VideoRateType,
+ VideoState,
+ VideoStorage,
+ VideoStreamingPlaylistType
+} from '@shared/models'
+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 {
- createTorrentPromise,
- generateImageFromVideoFile,
- getActivityPubUrl,
- getVideoFileHeight,
- isVideoCategoryValid,
isVideoDescriptionValid,
isVideoDurationValid,
- isVideoLanguageValid,
- isVideoLicenceValid,
isVideoNameValid,
- isVideoNSFWValid,
isVideoPrivacyValid,
- logger,
- renamePromise,
- statPromise,
- transcode,
- unlinkPromise,
- writeFilePromise
-} from '../../helpers'
+ isVideoStateValid,
+ isVideoSupportValid
+} from '../../helpers/custom-validators/videos'
+import { getVideoFileResolution } from '../../helpers/ffprobe-utils'
+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 { sendDeleteVideo } from '../../lib/activitypub/send'
import {
- API_VERSION,
- CONFIG,
- CONSTRAINTS_FIELDS,
- PREVIEWS_SIZE,
- REMOTE_SCHEME,
- STATIC_PATHS,
- THUMBNAILS_SIZE,
- VIDEO_CATEGORIES,
- VIDEO_LANGUAGES,
- VIDEO_LICENCES,
- VIDEO_PRIVACIES
-} from '../../initializers'
-
-import { addMethodsToModel, getSort } from '../utils'
-
-import { TagInstance } from './tag-interface'
-import { VideoFileInstance, VideoFileModel } from './video-file-interface'
-import { VideoAttributes, VideoInstance, VideoMethods } from './video-interface'
-import { sendDeleteVideo } from '../../lib/activitypub/send-request'
-import { isVideoUrlValid } from '../../helpers/custom-validators/videos'
-
-const Buffer = safeBuffer.Buffer
-
-let Video: Sequelize.Model<VideoInstance, VideoAttributes>
-let getOriginalFile: VideoMethods.GetOriginalFile
-let getVideoFilename: VideoMethods.GetVideoFilename
-let getThumbnailName: VideoMethods.GetThumbnailName
-let getThumbnailPath: VideoMethods.GetThumbnailPath
-let getPreviewName: VideoMethods.GetPreviewName
-let getPreviewPath: VideoMethods.GetPreviewPath
-let getTorrentFileName: VideoMethods.GetTorrentFileName
-let isOwned: VideoMethods.IsOwned
-let toFormattedJSON: VideoMethods.ToFormattedJSON
-let toFormattedDetailsJSON: VideoMethods.ToFormattedDetailsJSON
-let toActivityPubObject: VideoMethods.ToActivityPubObject
-let optimizeOriginalVideofile: VideoMethods.OptimizeOriginalVideofile
-let transcodeOriginalVideofile: VideoMethods.TranscodeOriginalVideofile
-let createPreview: VideoMethods.CreatePreview
-let createThumbnail: VideoMethods.CreateThumbnail
-let getVideoFilePath: VideoMethods.GetVideoFilePath
-let createTorrentAndSetInfoHash: VideoMethods.CreateTorrentAndSetInfoHash
-let getOriginalFileHeight: VideoMethods.GetOriginalFileHeight
-let getEmbedPath: VideoMethods.GetEmbedPath
-let getDescriptionPath: VideoMethods.GetDescriptionPath
-let getTruncatedDescription: VideoMethods.GetTruncatedDescription
-let getCategoryLabel: VideoMethods.GetCategoryLabel
-let getLicenceLabel: VideoMethods.GetLicenceLabel
-let getLanguageLabel: VideoMethods.GetLanguageLabel
-
-let generateThumbnailFromData: VideoMethods.GenerateThumbnailFromData
-let list: VideoMethods.List
-let listForApi: VideoMethods.ListForApi
-let listUserVideosForApi: VideoMethods.ListUserVideosForApi
-let loadByHostAndUUID: VideoMethods.LoadByHostAndUUID
-let listOwnedAndPopulateAccountAndTags: VideoMethods.ListOwnedAndPopulateAccountAndTags
-let listOwnedByAccount: VideoMethods.ListOwnedByAccount
-let load: VideoMethods.Load
-let loadByUUID: VideoMethods.LoadByUUID
-let loadByUUIDOrURL: VideoMethods.LoadByUUIDOrURL
-let loadLocalVideoByUUID: VideoMethods.LoadLocalVideoByUUID
-let loadAndPopulateAccount: VideoMethods.LoadAndPopulateAccount
-let loadAndPopulateAccountAndServerAndTags: VideoMethods.LoadAndPopulateAccountAndServerAndTags
-let loadByUUIDAndPopulateAccountAndServerAndTags: VideoMethods.LoadByUUIDAndPopulateAccountAndServerAndTags
-let searchAndPopulateAccountAndServerAndTags: VideoMethods.SearchAndPopulateAccountAndServerAndTags
-let removeThumbnail: VideoMethods.RemoveThumbnail
-let removePreview: VideoMethods.RemovePreview
-let removeFile: VideoMethods.RemoveFile
-let removeTorrent: VideoMethods.RemoveTorrent
-
-export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
- Video = sequelize.define<VideoInstance, VideoAttributes>('Video',
- {
- uuid: {
- type: DataTypes.UUID,
- defaultValue: DataTypes.UUIDV4,
- allowNull: false,
- validate: {
- isUUID: 4
- }
- },
- name: {
- type: DataTypes.STRING,
- allowNull: false,
- validate: {
- nameValid: value => {
- const res = isVideoNameValid(value)
- if (res === false) throw new Error('Video name is not valid.')
- }
- }
- },
- category: {
- type: DataTypes.INTEGER,
- allowNull: false,
- validate: {
- categoryValid: value => {
- const res = isVideoCategoryValid(value)
- if (res === false) throw new Error('Video category is not valid.')
- }
- }
+ MChannel,
+ MChannelAccountDefault,
+ MChannelId,
+ MStreamingPlaylist,
+ MStreamingPlaylistFilesVideo,
+ MUserAccountId,
+ MUserId,
+ MVideo,
+ MVideoAccountLight,
+ MVideoAccountLightBlacklistAllFiles,
+ MVideoAP,
+ MVideoDetails,
+ MVideoFileVideo,
+ MVideoFormattable,
+ MVideoFormattableDetails,
+ MVideoForUser,
+ MVideoFullLight,
+ MVideoId,
+ MVideoImmutable,
+ MVideoThumbnail,
+ MVideoThumbnailBlacklist,
+ MVideoWithAllFiles,
+ MVideoWithFile
+} from '../../types/models'
+import { MThumbnail } from '../../types/models/video/thumbnail'
+import { MVideoFile, MVideoFileStreamingPlaylistVideo } from '../../types/models/video/video-file'
+import { VideoAbuseModel } from '../abuse/video-abuse'
+import { AccountModel } from '../account/account'
+import { AccountVideoRateModel } from '../account/account-video-rate'
+import { ActorModel } from '../actor/actor'
+import { ActorImageModel } from '../actor/actor-image'
+import { VideoRedundancyModel } from '../redundancy/video-redundancy'
+import { ServerModel } from '../server/server'
+import { TrackerModel } from '../server/tracker'
+import { VideoTrackerModel } from '../server/video-tracker'
+import { setAsUpdated } from '../shared'
+import { UserModel } from '../user/user'
+import { UserVideoHistoryModel } from '../user/user-video-history'
+import { buildTrigramSearchIndex, buildWhereIdOrUUID, getVideoSort, isOutdated, throwIfNotValid } from '../utils'
+import {
+ videoFilesModelToFormattedJSON,
+ VideoFormattingJSONOptions,
+ videoModelToActivityPubObject,
+ videoModelToFormattedDetailsJSON,
+ videoModelToFormattedJSON
+} from './formatter/video-format-utils'
+import { ScheduleVideoUpdateModel } from './schedule-video-update'
+import { VideoModelGetQueryBuilder } from './sql/video-model-get-query-builder'
+import { BuildVideosListQueryOptions, DisplayOnlyForFollowerOptions, VideosIdListQueryBuilder } from './sql/videos-id-list-query-builder'
+import { VideosModelListQueryBuilder } from './sql/videos-model-list-query-builder'
+import { TagModel } from './tag'
+import { ThumbnailModel } from './thumbnail'
+import { VideoBlacklistModel } from './video-blacklist'
+import { VideoCaptionModel } from './video-caption'
+import { ScopeNames as VideoChannelScopeNames, SummaryOptions, VideoChannelModel } from './video-channel'
+import { VideoCommentModel } from './video-comment'
+import { VideoFileModel } from './video-file'
+import { VideoImportModel } from './video-import'
+import { VideoJobInfoModel } from './video-job-info'
+import { VideoLiveModel } from './video-live'
+import { VideoPlaylistElementModel } from './video-playlist-element'
+import { VideoShareModel } from './video-share'
+import { VideoStreamingPlaylistModel } from './video-streaming-playlist'
+import { VideoTagModel } from './video-tag'
+import { VideoViewModel } from './video-view'
+
+export enum ScopeNames {
+ FOR_API = 'FOR_API',
+ WITH_ACCOUNT_DETAILS = 'WITH_ACCOUNT_DETAILS',
+ WITH_TAGS = 'WITH_TAGS',
+ WITH_WEBTORRENT_FILES = 'WITH_WEBTORRENT_FILES',
+ WITH_SCHEDULED_UPDATE = 'WITH_SCHEDULED_UPDATE',
+ WITH_BLACKLISTED = 'WITH_BLACKLISTED',
+ WITH_STREAMING_PLAYLISTS = 'WITH_STREAMING_PLAYLISTS',
+ WITH_IMMUTABLE_ATTRIBUTES = 'WITH_IMMUTABLE_ATTRIBUTES',
+ WITH_USER_HISTORY = 'WITH_USER_HISTORY',
+ WITH_THUMBNAILS = 'WITH_THUMBNAILS'
+}
+
+export type ForAPIOptions = {
+ ids?: number[]
+
+ videoPlaylistId?: number
+
+ withAccountBlockerIds?: number[]
+}
+
+@Scopes(() => ({
+ [ScopeNames.WITH_IMMUTABLE_ATTRIBUTES]: {
+ attributes: [ 'id', 'url', 'uuid', 'remote' ]
+ },
+ [ScopeNames.FOR_API]: (options: ForAPIOptions) => {
+ const include: Includeable[] = [
+ {
+ model: VideoChannelModel.scope({
+ method: [
+ VideoChannelScopeNames.SUMMARY, {
+ withAccount: true,
+ withAccountBlockerIds: options.withAccountBlockerIds
+ } as SummaryOptions
+ ]
+ }),
+ required: true
},
- licence: {
- type: DataTypes.INTEGER,
- allowNull: false,
- defaultValue: null,
- validate: {
- licenceValid: value => {
- const res = isVideoLicenceValid(value)
- if (res === false) throw new Error('Video licence is not valid.')
- }
+ {
+ attributes: [ 'type', 'filename' ],
+ model: ThumbnailModel,
+ required: false
+ }
+ ]
+
+ const query: FindOptions = {}
+
+ if (options.ids) {
+ query.where = {
+ id: {
+ [Op.in]: options.ids
}
- },
- language: {
- type: DataTypes.INTEGER,
- allowNull: true,
- validate: {
- languageValid: value => {
- const res = isVideoLanguageValid(value)
- if (res === false) throw new Error('Video language is not valid.')
- }
+ }
+ }
+
+ if (options.videoPlaylistId) {
+ include.push({
+ model: VideoPlaylistElementModel.unscoped(),
+ required: true,
+ where: {
+ videoPlaylistId: options.videoPlaylistId
}
- },
- privacy: {
- type: DataTypes.INTEGER,
- allowNull: false,
- validate: {
- privacyValid: value => {
- const res = isVideoPrivacyValid(value)
- if (res === false) throw new Error('Video privacy is not valid.')
+ })
+ }
+
+ query.include = include
+
+ return query
+ },
+ [ScopeNames.WITH_THUMBNAILS]: {
+ include: [
+ {
+ model: ThumbnailModel,
+ required: false
+ }
+ ]
+ },
+ [ScopeNames.WITH_ACCOUNT_DETAILS]: {
+ include: [
+ {
+ model: VideoChannelModel.unscoped(),
+ required: true,
+ include: [
+ {
+ attributes: {
+ exclude: [ 'privateKey', 'publicKey' ]
+ },
+ model: ActorModel.unscoped(),
+ required: true,
+ include: [
+ {
+ attributes: [ 'host' ],
+ model: ServerModel.unscoped(),
+ required: false
+ },
+ {
+ model: ActorImageModel.unscoped(),
+ as: 'Avatar',
+ required: false
+ }
+ ]
+ },
+ {
+ model: AccountModel.unscoped(),
+ required: true,
+ include: [
+ {
+ model: ActorModel.unscoped(),
+ attributes: {
+ exclude: [ 'privateKey', 'publicKey' ]
+ },
+ required: true,
+ include: [
+ {
+ attributes: [ 'host' ],
+ model: ServerModel.unscoped(),
+ required: false
+ },
+ {
+ model: ActorImageModel.unscoped(),
+ as: 'Avatar',
+ required: false
+ }
+ ]
+ }
+ ]
}
+ ]
+ }
+ ]
+ },
+ [ScopeNames.WITH_TAGS]: {
+ include: [ TagModel ]
+ },
+ [ScopeNames.WITH_BLACKLISTED]: {
+ include: [
+ {
+ attributes: [ 'id', 'reason', 'unfederated' ],
+ model: VideoBlacklistModel,
+ required: false
+ }
+ ]
+ },
+ [ScopeNames.WITH_WEBTORRENT_FILES]: (withRedundancies = false) => {
+ let subInclude: any[] = []
+
+ if (withRedundancies === true) {
+ subInclude = [
+ {
+ attributes: [ 'fileUrl' ],
+ model: VideoRedundancyModel.unscoped(),
+ required: false
}
- },
- nsfw: {
- type: DataTypes.BOOLEAN,
- allowNull: false,
- validate: {
- nsfwValid: value => {
- const res = isVideoNSFWValid(value)
- if (res === false) throw new Error('Video nsfw attribute is not valid.')
- }
+ ]
+ }
+
+ return {
+ include: [
+ {
+ model: VideoFileModel,
+ separate: true,
+ required: false,
+ include: subInclude
}
- },
- description: {
- type: DataTypes.STRING(CONSTRAINTS_FIELDS.VIDEOS.DESCRIPTION.max),
- allowNull: false,
- validate: {
- descriptionValid: value => {
- const res = isVideoDescriptionValid(value)
- if (res === false) throw new Error('Video description is not valid.')
- }
+ ]
+ }
+ },
+ [ScopeNames.WITH_STREAMING_PLAYLISTS]: (withRedundancies = false) => {
+ const subInclude: IncludeOptions[] = [
+ {
+ model: VideoFileModel,
+ required: false
+ }
+ ]
+
+ if (withRedundancies === true) {
+ subInclude.push({
+ attributes: [ 'fileUrl' ],
+ model: VideoRedundancyModel.unscoped(),
+ required: false
+ })
+ }
+
+ return {
+ include: [
+ {
+ model: VideoStreamingPlaylistModel.unscoped(),
+ required: false,
+ separate: true,
+ include: subInclude
}
- },
- duration: {
- type: DataTypes.INTEGER,
- allowNull: false,
- validate: {
- durationValid: value => {
- const res = isVideoDurationValid(value)
- if (res === false) throw new Error('Video duration is not valid.')
+ ]
+ }
+ },
+ [ScopeNames.WITH_SCHEDULED_UPDATE]: {
+ include: [
+ {
+ model: ScheduleVideoUpdateModel.unscoped(),
+ required: false
+ }
+ ]
+ },
+ [ScopeNames.WITH_USER_HISTORY]: (userId: number) => {
+ return {
+ include: [
+ {
+ attributes: [ 'currentTime' ],
+ model: UserVideoHistoryModel.unscoped(),
+ required: false,
+ where: {
+ userId
}
}
- },
- views: {
- type: DataTypes.INTEGER,
- allowNull: false,
- defaultValue: 0,
- validate: {
- min: 0,
- isInt: true
- }
- },
- likes: {
- type: DataTypes.INTEGER,
- allowNull: false,
- defaultValue: 0,
- validate: {
- min: 0,
- isInt: true
+ ]
+ }
+ }
+}))
+@Table({
+ tableName: 'video',
+ indexes: [
+ buildTrigramSearchIndex('video_name_trigram', 'name'),
+
+ { fields: [ 'createdAt' ] },
+ {
+ fields: [
+ { name: 'publishedAt', order: 'DESC' },
+ { name: 'id', order: 'ASC' }
+ ]
+ },
+ { fields: [ 'duration' ] },
+ {
+ fields: [
+ { name: 'views', order: 'DESC' },
+ { name: 'id', order: 'ASC' }
+ ]
+ },
+ { fields: [ 'channelId' ] },
+ {
+ fields: [ 'originallyPublishedAt' ],
+ where: {
+ originallyPublishedAt: {
+ [Op.ne]: null
}
- },
- dislikes: {
- type: DataTypes.INTEGER,
- allowNull: false,
- defaultValue: 0,
- validate: {
- min: 0,
- isInt: true
+ }
+ },
+ {
+ fields: [ 'category' ], // We don't care videos with an unknown category
+ where: {
+ category: {
+ [Op.ne]: null
}
- },
- remote: {
- type: DataTypes.BOOLEAN,
- allowNull: false,
- defaultValue: false
- },
- url: {
- type: DataTypes.STRING(CONSTRAINTS_FIELDS.VIDEOS.URL.max),
- allowNull: false,
- validate: {
- urlValid: value => {
- const res = isVideoUrlValid(value)
- if (res === false) throw new Error('Video URL is not valid.')
- }
+ }
+ },
+ {
+ fields: [ 'licence' ], // We don't care videos with an unknown licence
+ where: {
+ licence: {
+ [Op.ne]: null
}
}
},
{
- indexes: [
- {
- fields: [ 'name' ]
- },
- {
- fields: [ 'createdAt' ]
- },
- {
- fields: [ 'duration' ]
- },
- {
- fields: [ 'views' ]
- },
- {
- fields: [ 'likes' ]
- },
- {
- fields: [ 'uuid' ]
- },
- {
- fields: [ 'channelId' ]
+ fields: [ 'language' ], // We don't care videos with an unknown language
+ where: {
+ language: {
+ [Op.ne]: null
}
- ],
- hooks: {
- afterDestroy
}
+ },
+ {
+ fields: [ 'nsfw' ], // Most of the videos are not NSFW
+ where: {
+ nsfw: true
+ }
+ },
+ {
+ fields: [ 'remote' ], // Only index local videos
+ where: {
+ remote: false
+ }
+ },
+ {
+ fields: [ 'uuid' ],
+ unique: true
+ },
+ {
+ fields: [ 'url' ],
+ unique: true
}
- )
-
- const classMethods = [
- associate,
-
- generateThumbnailFromData,
- list,
- listForApi,
- listUserVideosForApi,
- listOwnedAndPopulateAccountAndTags,
- listOwnedByAccount,
- load,
- loadAndPopulateAccount,
- loadAndPopulateAccountAndServerAndTags,
- loadByHostAndUUID,
- loadByUUIDOrURL,
- loadByUUID,
- loadLocalVideoByUUID,
- loadByUUIDAndPopulateAccountAndServerAndTags,
- searchAndPopulateAccountAndServerAndTags
- ]
- const instanceMethods = [
- createPreview,
- createThumbnail,
- createTorrentAndSetInfoHash,
- getPreviewName,
- getPreviewPath,
- getThumbnailName,
- getThumbnailPath,
- getTorrentFileName,
- getVideoFilename,
- getVideoFilePath,
- getOriginalFile,
- isOwned,
- removeFile,
- removePreview,
- removeThumbnail,
- removeTorrent,
- toActivityPubObject,
- toFormattedJSON,
- toFormattedDetailsJSON,
- optimizeOriginalVideofile,
- transcodeOriginalVideofile,
- getOriginalFileHeight,
- getEmbedPath,
- getTruncatedDescription,
- getDescriptionPath,
- getCategoryLabel,
- getLicenceLabel,
- getLanguageLabel
]
- addMethodsToModel(Video, classMethods, instanceMethods)
+})
+export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
+
+ @AllowNull(false)
+ @Default(DataType.UUIDV4)
+ @IsUUID(4)
+ @Column(DataType.UUID)
+ uuid: string
+
+ @AllowNull(false)
+ @Is('VideoName', value => throwIfNotValid(value, isVideoNameValid, 'name'))
+ @Column
+ name: string
+
+ @AllowNull(true)
+ @Default(null)
+ @Column
+ category: number
+
+ @AllowNull(true)
+ @Default(null)
+ @Column
+ licence: number
+
+ @AllowNull(true)
+ @Default(null)
+ @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.LANGUAGE.max))
+ language: string
+
+ @AllowNull(false)
+ @Is('VideoPrivacy', value => throwIfNotValid(value, isVideoPrivacyValid, 'privacy'))
+ @Column
+ privacy: VideoPrivacy
+
+ @AllowNull(false)
+ @Is('VideoNSFW', value => throwIfNotValid(value, isBooleanValid, 'NSFW boolean'))
+ @Column
+ nsfw: boolean
+
+ @AllowNull(true)
+ @Default(null)
+ @Is('VideoDescription', value => throwIfNotValid(value, isVideoDescriptionValid, 'description', true))
+ @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.DESCRIPTION.max))
+ description: string
+
+ @AllowNull(true)
+ @Default(null)
+ @Is('VideoSupport', value => throwIfNotValid(value, isVideoSupportValid, 'support', true))
+ @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.SUPPORT.max))
+ support: string
+
+ @AllowNull(false)
+ @Is('VideoDuration', value => throwIfNotValid(value, isVideoDurationValid, 'duration'))
+ @Column
+ duration: number
+
+ @AllowNull(false)
+ @Default(0)
+ @IsInt
+ @Min(0)
+ @Column
+ views: number
+
+ @AllowNull(false)
+ @Default(0)
+ @IsInt
+ @Min(0)
+ @Column
+ likes: number
+
+ @AllowNull(false)
+ @Default(0)
+ @IsInt
+ @Min(0)
+ @Column
+ dislikes: number
+
+ @AllowNull(false)
+ @Column
+ remote: boolean
+
+ @AllowNull(false)
+ @Default(false)
+ @Column
+ isLive: boolean
+
+ @AllowNull(false)
+ @Is('VideoUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
+ @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.URL.max))
+ url: string
+
+ @AllowNull(false)
+ @Column
+ commentsEnabled: boolean
+
+ @AllowNull(false)
+ @Column
+ downloadEnabled: boolean
+
+ @AllowNull(false)
+ @Column
+ waitTranscoding: boolean
+
+ @AllowNull(false)
+ @Default(null)
+ @Is('VideoState', value => throwIfNotValid(value, isVideoStateValid, 'state'))
+ @Column
+ state: VideoState
+
+ @CreatedAt
+ createdAt: Date
+
+ @UpdatedAt
+ updatedAt: Date
+
+ @AllowNull(false)
+ @Default(DataType.NOW)
+ @Column
+ publishedAt: Date
+
+ @AllowNull(true)
+ @Default(null)
+ @Column
+ originallyPublishedAt: Date
+
+ @ForeignKey(() => VideoChannelModel)
+ @Column
+ channelId: number
+
+ @BelongsTo(() => VideoChannelModel, {
+ foreignKey: {
+ allowNull: true
+ },
+ onDelete: 'cascade'
+ })
+ VideoChannel: VideoChannelModel
- return Video
-}
+ @BelongsToMany(() => TagModel, {
+ foreignKey: 'videoId',
+ through: () => VideoTagModel,
+ onDelete: 'CASCADE'
+ })
+ Tags: TagModel[]
+
+ @BelongsToMany(() => TrackerModel, {
+ foreignKey: 'videoId',
+ through: () => VideoTrackerModel,
+ onDelete: 'CASCADE'
+ })
+ Trackers: TrackerModel[]
-// ------------------------------ METHODS ------------------------------
+ @HasMany(() => ThumbnailModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: true
+ },
+ hooks: true,
+ onDelete: 'cascade'
+ })
+ Thumbnails: ThumbnailModel[]
+
+ @HasMany(() => VideoPlaylistElementModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: true
+ },
+ onDelete: 'set null'
+ })
+ VideoPlaylistElements: VideoPlaylistElementModel[]
-function associate (models) {
- Video.belongsTo(models.VideoChannel, {
+ @HasMany(() => VideoAbuseModel, {
foreignKey: {
- name: 'channelId',
+ name: 'videoId',
+ allowNull: true
+ },
+ onDelete: 'set null'
+ })
+ VideoAbuses: VideoAbuseModel[]
+
+ @HasMany(() => VideoFileModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: true
+ },
+ hooks: true,
+ onDelete: 'cascade'
+ })
+ VideoFiles: VideoFileModel[]
+
+ @HasMany(() => VideoStreamingPlaylistModel, {
+ foreignKey: {
+ name: 'videoId',
allowNull: false
},
+ hooks: true,
onDelete: 'cascade'
})
+ VideoStreamingPlaylists: VideoStreamingPlaylistModel[]
- Video.belongsToMany(models.Tag, {
- foreignKey: 'videoId',
- through: models.VideoTag,
+ @HasMany(() => VideoShareModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: false
+ },
onDelete: 'cascade'
})
+ VideoShares: VideoShareModel[]
- Video.hasMany(models.VideoAbuse, {
+ @HasMany(() => AccountVideoRateModel, {
foreignKey: {
name: 'videoId',
allowNull: false
},
onDelete: 'cascade'
})
+ AccountVideoRates: AccountVideoRateModel[]
- Video.hasMany(models.VideoFile, {
+ @HasMany(() => VideoCommentModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: false
+ },
+ onDelete: 'cascade',
+ hooks: true
+ })
+ VideoComments: VideoCommentModel[]
+
+ @HasMany(() => VideoViewModel, {
foreignKey: {
name: 'videoId',
allowNull: false
},
onDelete: 'cascade'
})
-}
+ VideoViews: VideoViewModel[]
+
+ @HasMany(() => UserVideoHistoryModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: false
+ },
+ onDelete: 'cascade'
+ })
+ UserVideoHistories: UserVideoHistoryModel[]
+
+ @HasOne(() => ScheduleVideoUpdateModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: false
+ },
+ onDelete: 'cascade'
+ })
+ ScheduleVideoUpdate: ScheduleVideoUpdateModel
+
+ @HasOne(() => VideoBlacklistModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: false
+ },
+ onDelete: 'cascade'
+ })
+ VideoBlacklist: VideoBlacklistModel
+
+ @HasOne(() => VideoLiveModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: false
+ },
+ onDelete: 'cascade'
+ })
+ VideoLive: VideoLiveModel
+
+ @HasOne(() => VideoImportModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: true
+ },
+ onDelete: 'set null'
+ })
+ VideoImport: VideoImportModel
+
+ @HasMany(() => VideoCaptionModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: false
+ },
+ onDelete: 'cascade',
+ hooks: true,
+ ['separate' as any]: true
+ })
+ VideoCaptions: VideoCaptionModel[]
+
+ @HasOne(() => VideoJobInfoModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: false
+ },
+ onDelete: 'cascade'
+ })
+ VideoJobInfo: VideoJobInfoModel
+
+ @BeforeDestroy
+ static async sendDelete (instance: MVideoAccountLight, options) {
+ if (!instance.isOwned()) return undefined
+
+ // Lazy load channels
+ if (!instance.VideoChannel) {
+ instance.VideoChannel = await instance.$get('VideoChannel', {
+ include: [
+ ActorModel,
+ AccountModel
+ ],
+ transaction: options.transaction
+ }) as MChannelAccountDefault
+ }
+
+ return sendDeleteVideo(instance, options.transaction)
+ }
+
+ @BeforeDestroy
+ static async removeFiles (instance: VideoModel, options) {
+ const tasks: Promise<any>[] = []
+
+ logger.info('Removing files of video %s.', instance.url)
+
+ if (instance.isOwned()) {
+ if (!Array.isArray(instance.VideoFiles)) {
+ instance.VideoFiles = await instance.$get('VideoFiles', { transaction: options.transaction })
+ }
+
+ // Remove physical files and torrents
+ instance.VideoFiles.forEach(file => {
+ tasks.push(instance.removeWebTorrentFileAndTorrent(file))
+ })
+
+ // Remove playlists file
+ if (!Array.isArray(instance.VideoStreamingPlaylists)) {
+ instance.VideoStreamingPlaylists = await instance.$get('VideoStreamingPlaylists', { transaction: options.transaction })
+ }
+
+ for (const p of instance.VideoStreamingPlaylists) {
+ tasks.push(instance.removeStreamingPlaylistFiles(p))
+ }
+ }
+
+ // 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 })
+ })
+
+ return undefined
+ }
+
+ @BeforeDestroy
+ static stopLiveIfNeeded (instance: VideoModel) {
+ if (!instance.isLive) return
+
+ logger.info('Stopping live of video %s after video deletion.', instance.uuid)
+
+ LiveManager.Instance.stopSessionOf(instance.id)
+ }
+
+ @BeforeDestroy
+ static invalidateCache (instance: VideoModel) {
+ ModelCache.Instance.invalidateCache('video', instance.id)
+ }
+
+ @BeforeDestroy
+ static async saveEssentialDataToAbuses (instance: VideoModel, options) {
+ const tasks: Promise<any>[] = []
+
+ if (!Array.isArray(instance.VideoAbuses)) {
+ instance.VideoAbuses = await instance.$get('VideoAbuses', { transaction: options.transaction })
+
+ if (instance.VideoAbuses.length === 0) return undefined
+ }
+
+ logger.info('Saving video abuses details of video %s.', instance.url)
+
+ if (!instance.Trackers) instance.Trackers = await instance.$get('Trackers', { transaction: options.transaction })
+ const details = instance.toFormattedDetailsJSON()
+
+ for (const abuse of instance.VideoAbuses) {
+ abuse.deletedVideo = details
+ tasks.push(abuse.save({ transaction: options.transaction }))
+ }
+
+ await Promise.all(tasks)
+ }
+
+ static listLocalIds (): Promise<number[]> {
+ const query = {
+ attributes: [ 'id' ],
+ raw: true,
+ where: {
+ remote: false
+ }
+ }
+
+ return VideoModel.findAll(query)
+ .then(rows => rows.map(r => r.id))
+ }
+
+ static listAllAndSharedByActorForOutbox (actorId: number, start: number, count: number) {
+ function getRawQuery (select: string) {
+ const queryVideo = 'SELECT ' + select + ' FROM "video" AS "Video" ' +
+ 'INNER JOIN "videoChannel" AS "VideoChannel" ON "VideoChannel"."id" = "Video"."channelId" ' +
+ 'INNER JOIN "account" AS "Account" ON "Account"."id" = "VideoChannel"."accountId" ' +
+ 'WHERE "Account"."actorId" = ' + actorId
+ const queryVideoShare = 'SELECT ' + select + ' FROM "videoShare" AS "VideoShare" ' +
+ 'INNER JOIN "video" AS "Video" ON "Video"."id" = "VideoShare"."videoId" ' +
+ 'WHERE "VideoShare"."actorId" = ' + actorId
+
+ return `(${queryVideo}) UNION (${queryVideoShare})`
+ }
+
+ const rawQuery = getRawQuery('"Video"."id"')
+ const rawCountQuery = getRawQuery('COUNT("Video"."id") as "total"')
+
+ const query = {
+ distinct: true,
+ offset: start,
+ limit: count,
+ order: getVideoSort('-createdAt', [ 'Tags', 'name', 'ASC' ]),
+ where: {
+ id: {
+ [Op.in]: Sequelize.literal('(' + rawQuery + ')')
+ },
+ [Op.or]: getPrivaciesForFederation()
+ },
+ include: [
+ {
+ attributes: [ 'filename', 'language', 'fileUrl' ],
+ model: VideoCaptionModel.unscoped(),
+ required: false
+ },
+ {
+ attributes: [ 'id', 'url' ],
+ model: VideoShareModel.unscoped(),
+ required: false,
+ // We only want videos shared by this actor
+ where: {
+ [Op.and]: [
+ {
+ id: {
+ [Op.not]: null
+ }
+ },
+ {
+ actorId
+ }
+ ]
+ },
+ include: [
+ {
+ attributes: [ 'id', 'url' ],
+ model: ActorModel.unscoped()
+ }
+ ]
+ },
+ {
+ model: VideoChannelModel.unscoped(),
+ required: true,
+ include: [
+ {
+ attributes: [ 'name' ],
+ model: AccountModel.unscoped(),
+ required: true,
+ include: [
+ {
+ attributes: [ 'id', 'url', 'followersUrl' ],
+ model: ActorModel.unscoped(),
+ required: true
+ }
+ ]
+ },
+ {
+ attributes: [ 'id', 'url', 'followersUrl' ],
+ model: ActorModel.unscoped(),
+ required: true
+ }
+ ]
+ },
+ {
+ model: VideoStreamingPlaylistModel.unscoped(),
+ required: false,
+ include: [
+ {
+ model: VideoFileModel,
+ required: false
+ }
+ ]
+ },
+ VideoLiveModel.unscoped(),
+ VideoFileModel,
+ TagModel
+ ]
+ }
+
+ return Bluebird.all([
+ VideoModel.scope(ScopeNames.WITH_THUMBNAILS).findAll(query),
+ VideoModel.sequelize.query<{ total: string }>(rawCountQuery, { type: QueryTypes.SELECT })
+ ]).then(([ rows, totals ]) => {
+ // totals: totalVideos + totalVideoShares
+ let totalVideos = 0
+ let totalVideoShares = 0
+ if (totals[0]) totalVideos = parseInt(totals[0].total, 10)
+ if (totals[1]) totalVideoShares = parseInt(totals[1].total, 10)
+
+ const total = totalVideos + totalVideoShares
+ return {
+ data: rows,
+ total: total
+ }
+ })
+ }
+
+ static async listPublishedLiveUUIDs () {
+ const options = {
+ attributes: [ 'uuid' ],
+ where: {
+ isLive: true,
+ remote: false,
+ state: VideoState.PUBLISHED
+ }
+ }
+
+ const result = await VideoModel.findAll(options)
+
+ return result.map(v => v.uuid)
+ }
+
+ static listUserVideosForApi (options: {
+ accountId: number
+ start: number
+ count: number
+ sort: string
+
+ channelId?: number
+ isLive?: boolean
+ search?: string
+ }) {
+ const { accountId, channelId, start, count, sort, search, isLive } = options
+
+ function buildBaseQuery (): FindOptions {
+ const where: WhereOptions = {}
+
+ if (search) {
+ where.name = {
+ [Op.iLike]: '%' + search + '%'
+ }
+ }
+
+ if (exists(isLive)) {
+ where.isLive = isLive
+ }
+
+ const channelWhere = channelId
+ ? { id: channelId }
+ : {}
+
+ const baseQuery = {
+ offset: start,
+ limit: count,
+ where,
+ order: getVideoSort(sort),
+ include: [
+ {
+ model: VideoChannelModel,
+ required: true,
+ where: channelWhere,
+ include: [
+ {
+ model: AccountModel,
+ where: {
+ id: accountId
+ },
+ required: true
+ }
+ ]
+ }
+ ]
+ }
-function afterDestroy (video: VideoInstance) {
- const tasks = []
+ return baseQuery
+ }
- tasks.push(
- video.removeThumbnail()
- )
+ const countQuery = buildBaseQuery()
+ const findQuery = buildBaseQuery()
- if (video.isOwned()) {
- tasks.push(
- video.removePreview(),
- sendDeleteVideo(video, undefined)
- )
+ const findScopes: (string | ScopeOptions)[] = [
+ ScopeNames.WITH_SCHEDULED_UPDATE,
+ ScopeNames.WITH_BLACKLISTED,
+ ScopeNames.WITH_THUMBNAILS
+ ]
- // Remove physical files and torrents
- video.VideoFiles.forEach(file => {
- tasks.push(video.removeFile(file))
- tasks.push(video.removeTorrent(file))
+ return Promise.all([
+ VideoModel.count(countQuery),
+ VideoModel.scope(findScopes).findAll<MVideoForUser>(findQuery)
+ ]).then(([ count, rows ]) => {
+ return {
+ data: rows,
+ total: count
+ }
})
}
- return Promise.all(tasks)
- .catch(err => {
- logger.error('Some errors when removing files of video %s in after destroy hook.', video.uuid, err)
+ static async listForApi (options: {
+ start: number
+ count: number
+ sort: string
+
+ nsfw: boolean
+ isLive?: boolean
+ isLocal?: boolean
+ include?: VideoInclude
+
+ hasFiles?: boolean // default false
+ hasWebtorrentFiles?: boolean
+ hasHLSFiles?: boolean
+
+ categoryOneOf?: number[]
+ licenceOneOf?: number[]
+ languageOneOf?: string[]
+ tagsOneOf?: string[]
+ tagsAllOf?: string[]
+ privacyOneOf?: VideoPrivacy[]
+
+ accountId?: number
+ videoChannelId?: number
+
+ displayOnlyForFollower: DisplayOnlyForFollowerOptions | null
+
+ videoPlaylistId?: number
+
+ trendingDays?: number
+
+ user?: MUserAccountId
+ historyOfUser?: MUserId
+
+ countVideos?: boolean
+
+ search?: string
+ }) {
+ VideoModel.throwIfPrivateIncludeWithoutUser(options.include, options.user)
+ VideoModel.throwIfPrivacyOneOfWithoutUser(options.privacyOneOf, options.user)
+
+ const trendingDays = options.sort.endsWith('trending')
+ ? CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS
+ : undefined
+
+ let trendingAlgorithm: string
+ if (options.sort.endsWith('hot')) trendingAlgorithm = 'hot'
+ if (options.sort.endsWith('best')) trendingAlgorithm = 'best'
+
+ const serverActor = await getServerActor()
+
+ const queryOptions = {
+ ...pick(options, [
+ 'start',
+ 'count',
+ 'sort',
+ 'nsfw',
+ 'isLive',
+ 'categoryOneOf',
+ 'licenceOneOf',
+ 'languageOneOf',
+ 'tagsOneOf',
+ 'tagsAllOf',
+ 'privacyOneOf',
+ 'isLocal',
+ 'include',
+ 'displayOnlyForFollower',
+ 'hasFiles',
+ 'accountId',
+ 'videoChannelId',
+ 'videoPlaylistId',
+ 'user',
+ 'historyOfUser',
+ 'hasHLSFiles',
+ 'hasWebtorrentFiles',
+ 'search'
+ ]),
+
+ serverAccountIdForBlock: serverActor.Account.id,
+ trendingDays,
+ trendingAlgorithm
+ }
+
+ return VideoModel.getAvailableForApi(queryOptions, options.countVideos)
+ }
+
+ static async searchAndPopulateAccountAndServer (options: {
+ start: number
+ count: number
+ sort: string
+
+ nsfw?: boolean
+ isLive?: boolean
+ isLocal?: boolean
+ include?: VideoInclude
+
+ categoryOneOf?: number[]
+ licenceOneOf?: number[]
+ languageOneOf?: string[]
+ tagsOneOf?: string[]
+ tagsAllOf?: string[]
+ privacyOneOf?: VideoPrivacy[]
+
+ displayOnlyForFollower: DisplayOnlyForFollowerOptions | null
+
+ user?: MUserAccountId
+
+ hasWebtorrentFiles?: boolean
+ hasHLSFiles?: boolean
+
+ search?: string
+
+ host?: string
+ startDate?: string // ISO 8601
+ endDate?: string // ISO 8601
+ originallyPublishedStartDate?: string
+ originallyPublishedEndDate?: string
+
+ durationMin?: number // seconds
+ durationMax?: number // seconds
+ uuids?: string[]
+ }) {
+ VideoModel.throwIfPrivateIncludeWithoutUser(options.include, options.user)
+ VideoModel.throwIfPrivacyOneOfWithoutUser(options.privacyOneOf, options.user)
+
+ const serverActor = await getServerActor()
+
+ const queryOptions = {
+ ...pick(options, [
+ 'include',
+ 'nsfw',
+ 'isLive',
+ 'categoryOneOf',
+ 'licenceOneOf',
+ 'languageOneOf',
+ 'tagsOneOf',
+ 'tagsAllOf',
+ 'privacyOneOf',
+ 'user',
+ 'isLocal',
+ 'host',
+ 'start',
+ 'count',
+ 'sort',
+ 'startDate',
+ 'endDate',
+ 'originallyPublishedStartDate',
+ 'originallyPublishedEndDate',
+ 'durationMin',
+ 'durationMax',
+ 'hasHLSFiles',
+ 'hasWebtorrentFiles',
+ 'uuids',
+ 'search',
+ 'displayOnlyForFollower'
+ ]),
+ serverAccountIdForBlock: serverActor.Account.id
+ }
+
+ return VideoModel.getAvailableForApi(queryOptions)
+ }
+
+ static countLocalLives () {
+ const options = {
+ where: {
+ remote: false,
+ isLive: true,
+ state: {
+ [Op.ne]: VideoState.LIVE_ENDED
+ }
+ }
+ }
+
+ return VideoModel.count(options)
+ }
+
+ static countVideosUploadedByUserSince (userId: number, since: Date) {
+ const options = {
+ include: [
+ {
+ model: VideoChannelModel.unscoped(),
+ required: true,
+ include: [
+ {
+ model: AccountModel.unscoped(),
+ required: true,
+ include: [
+ {
+ model: UserModel.unscoped(),
+ required: true,
+ where: {
+ id: userId
+ }
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ where: {
+ createdAt: {
+ [Op.gte]: since
+ }
+ }
+ }
+
+ return VideoModel.unscoped().count(options)
+ }
+
+ static countLivesOfAccount (accountId: number) {
+ const options = {
+ where: {
+ remote: false,
+ isLive: true,
+ state: {
+ [Op.ne]: VideoState.LIVE_ENDED
+ }
+ },
+ include: [
+ {
+ required: true,
+ model: VideoChannelModel.unscoped(),
+ where: {
+ accountId
+ }
+ }
+ ]
+ }
+
+ return VideoModel.count(options)
+ }
+
+ static load (id: number | string, transaction?: Transaction): Promise<MVideoThumbnail> {
+ const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
+
+ return queryBuilder.queryVideo({ id, transaction, type: 'thumbnails' })
+ }
+
+ static loadWithBlacklist (id: number | string, transaction?: Transaction): Promise<MVideoThumbnailBlacklist> {
+ const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
+
+ return queryBuilder.queryVideo({ id, transaction, type: 'thumbnails-blacklist' })
+ }
+
+ static loadImmutableAttributes (id: number | string, t?: Transaction): Promise<MVideoImmutable> {
+ const fun = () => {
+ const query = {
+ where: buildWhereIdOrUUID(id),
+ transaction: t
+ }
+
+ return VideoModel.scope(ScopeNames.WITH_IMMUTABLE_ATTRIBUTES).findOne(query)
+ }
+
+ return ModelCache.Instance.doCache({
+ cacheType: 'load-video-immutable-id',
+ key: '' + id,
+ deleteKey: 'video',
+ fun
})
-}
+ }
-getOriginalFile = function (this: VideoInstance) {
- if (Array.isArray(this.VideoFiles) === false) return undefined
+ static loadByUrlImmutableAttributes (url: string, transaction?: Transaction): Promise<MVideoImmutable> {
+ const fun = () => {
+ const query: FindOptions = {
+ where: {
+ url
+ },
+ transaction
+ }
- // The original file is the file that have the higher resolution
- return maxBy(this.VideoFiles, file => file.resolution)
-}
+ return VideoModel.scope(ScopeNames.WITH_IMMUTABLE_ATTRIBUTES).findOne(query)
+ }
-getVideoFilename = function (this: VideoInstance, videoFile: VideoFileInstance) {
- return this.uuid + '-' + videoFile.resolution + videoFile.extname
-}
+ return ModelCache.Instance.doCache({
+ cacheType: 'load-video-immutable-url',
+ key: url,
+ deleteKey: 'video',
+ fun
+ })
+ }
-getThumbnailName = function (this: VideoInstance) {
- // We always have a copy of the thumbnail
- const extension = '.jpg'
- return this.uuid + extension
-}
+ static loadOnlyId (id: number | string, transaction?: Transaction): Promise<MVideoId> {
+ const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
-getPreviewName = function (this: VideoInstance) {
- const extension = '.jpg'
- return this.uuid + extension
-}
+ return queryBuilder.queryVideo({ id, transaction, type: 'id' })
+ }
-getTorrentFileName = function (this: VideoInstance, videoFile: VideoFileInstance) {
- const extension = '.torrent'
- return this.uuid + '-' + videoFile.resolution + extension
-}
+ static loadWithFiles (id: number | string, transaction?: Transaction, logging?: boolean): Promise<MVideoWithAllFiles> {
+ const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
-isOwned = function (this: VideoInstance) {
- return this.remote === false
-}
+ return queryBuilder.queryVideo({ id, transaction, type: 'all-files', logging })
+ }
-createPreview = function (this: VideoInstance, videoFile: VideoFileInstance) {
- const imageSize = PREVIEWS_SIZE.width + 'x' + PREVIEWS_SIZE.height
+ static loadByUrl (url: string, transaction?: Transaction): Promise<MVideoThumbnail> {
+ const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
- return generateImageFromVideoFile(
- this.getVideoFilePath(videoFile),
- CONFIG.STORAGE.PREVIEWS_DIR,
- this.getPreviewName(),
- imageSize
- )
-}
+ return queryBuilder.queryVideo({ url, transaction, type: 'thumbnails' })
+ }
-createThumbnail = function (this: VideoInstance, videoFile: VideoFileInstance) {
- const imageSize = THUMBNAILS_SIZE.width + 'x' + THUMBNAILS_SIZE.height
+ static loadByUrlAndPopulateAccount (url: string, transaction?: Transaction): Promise<MVideoAccountLightBlacklistAllFiles> {
+ const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
- return generateImageFromVideoFile(
- this.getVideoFilePath(videoFile),
- CONFIG.STORAGE.THUMBNAILS_DIR,
- this.getThumbnailName(),
- imageSize
- )
-}
+ return queryBuilder.queryVideo({ url, transaction, type: 'account-blacklist-files' })
+ }
-getVideoFilePath = function (this: VideoInstance, videoFile: VideoFileInstance) {
- return join(CONFIG.STORAGE.VIDEOS_DIR, this.getVideoFilename(videoFile))
-}
+ static loadAndPopulateAccountAndServerAndTags (id: number | string, t?: Transaction, userId?: number): Promise<MVideoFullLight> {
+ const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
-createTorrentAndSetInfoHash = async function (this: VideoInstance, videoFile: VideoFileInstance) {
- const options = {
- announceList: [
- [ CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT + '/tracker/socket' ]
- ],
- urlList: [
- CONFIG.WEBSERVER.URL + STATIC_PATHS.WEBSEED + this.getVideoFilename(videoFile)
- ]
+ return queryBuilder.queryVideo({ id, transaction: t, type: 'full-light', userId })
}
- const torrent = await createTorrentPromise(this.getVideoFilePath(videoFile), options)
+ static loadForGetAPI (parameters: {
+ id: number | string
+ transaction?: Transaction
+ userId?: number
+ }): Promise<MVideoDetails> {
+ const { id, transaction, userId } = parameters
+ const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
- const filePath = join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
- logger.info('Creating torrent %s.', filePath)
-
- await writeFilePromise(filePath, torrent)
+ return queryBuilder.queryVideo({ id, transaction, type: 'api', userId })
+ }
- const parsedTorrent = parseTorrent(torrent)
- videoFile.infoHash = parsedTorrent.infoHash
-}
+ static async getStats () {
+ const totalLocalVideos = await VideoModel.count({
+ where: {
+ remote: false
+ }
+ })
-getEmbedPath = function (this: VideoInstance) {
- return '/videos/embed/' + this.uuid
-}
+ let totalLocalVideoViews = await VideoModel.sum('views', {
+ where: {
+ remote: false
+ }
+ })
-getThumbnailPath = function (this: VideoInstance) {
- return join(STATIC_PATHS.THUMBNAILS, this.getThumbnailName())
-}
+ // Sequelize could return null...
+ if (!totalLocalVideoViews) totalLocalVideoViews = 0
-getPreviewPath = function (this: VideoInstance) {
- return join(STATIC_PATHS.PREVIEWS, this.getPreviewName())
-}
+ const serverActor = await getServerActor()
-toFormattedJSON = function (this: VideoInstance) {
- let serverHost
-
- if (this.VideoChannel.Account.Server) {
- serverHost = this.VideoChannel.Account.Server.host
- } else {
- // It means it's our video
- serverHost = CONFIG.WEBSERVER.HOST
- }
-
- const json = {
- id: this.id,
- uuid: this.uuid,
- name: this.name,
- category: this.category,
- categoryLabel: this.getCategoryLabel(),
- licence: this.licence,
- licenceLabel: this.getLicenceLabel(),
- language: this.language,
- languageLabel: this.getLanguageLabel(),
- nsfw: this.nsfw,
- description: this.getTruncatedDescription(),
- serverHost,
- isLocal: this.isOwned(),
- account: this.VideoChannel.Account.name,
- duration: this.duration,
- views: this.views,
- likes: this.likes,
- dislikes: this.dislikes,
- tags: map<TagInstance, string>(this.Tags, 'name'),
- thumbnailPath: this.getThumbnailPath(),
- previewPath: this.getPreviewPath(),
- embedPath: this.getEmbedPath(),
- createdAt: this.createdAt,
- updatedAt: this.updatedAt
- }
-
- return json
-}
+ const { total: totalVideos } = await VideoModel.listForApi({
+ start: 0,
+ count: 0,
+ sort: '-publishedAt',
+ nsfw: buildNSFWFilter(),
+ displayOnlyForFollower: {
+ actorId: serverActor.id,
+ orLocalVideos: true
+ }
+ })
-toFormattedDetailsJSON = function (this: VideoInstance) {
- const formattedJson = this.toFormattedJSON()
-
- // Maybe our server is not up to date and there are new privacy settings since our version
- let privacyLabel = VIDEO_PRIVACIES[this.privacy]
- if (!privacyLabel) privacyLabel = 'Unknown'
-
- const detailsJson = {
- privacyLabel,
- privacy: this.privacy,
- descriptionPath: this.getDescriptionPath(),
- channel: this.VideoChannel.toFormattedJSON(),
- files: []
- }
-
- // Format and sort video files
- const { baseUrlHttp, baseUrlWs } = getBaseUrls(this)
- detailsJson.files = this.VideoFiles
- .map(videoFile => {
- let resolutionLabel = videoFile.resolution + 'p'
-
- const videoFileJson = {
- resolution: videoFile.resolution,
- resolutionLabel,
- magnetUri: generateMagnetUri(this, videoFile, baseUrlHttp, baseUrlWs),
- size: videoFile.size,
- torrentUrl: getTorrentUrl(this, videoFile, baseUrlHttp),
- fileUrl: getVideoFileUrl(this, videoFile, baseUrlHttp)
- }
-
- return videoFileJson
- })
- .sort((a, b) => {
- if (a.resolution < b.resolution) return 1
- if (a.resolution === b.resolution) return 0
- return -1
- })
-
- return Object.assign(formattedJson, detailsJson)
-}
+ return {
+ totalLocalVideos,
+ totalLocalVideoViews,
+ totalVideos
+ }
+ }
-toActivityPubObject = function (this: VideoInstance) {
- const { baseUrlHttp, baseUrlWs } = getBaseUrls(this)
-
- const tag = this.Tags.map(t => ({
- type: 'Hashtag' as 'Hashtag',
- name: t.name
- }))
-
- const url = []
- for (const file of this.VideoFiles) {
- url.push({
- type: 'Link',
- mimeType: 'video/' + file.extname.replace('.', ''),
- url: getVideoFileUrl(this, file, baseUrlHttp),
- width: file.resolution,
- size: file.size
+ static incrementViews (id: number, views: number) {
+ return VideoModel.increment('views', {
+ by: views,
+ where: {
+ id
+ }
})
+ }
- url.push({
- type: 'Link',
- mimeType: 'application/x-bittorrent',
- url: getTorrentUrl(this, file, baseUrlHttp),
- width: file.resolution
+ static updateRatesOf (videoId: number, type: VideoRateType, t: Transaction) {
+ const field = type === 'like'
+ ? 'likes'
+ : 'dislikes'
+
+ const rawQuery = `UPDATE "video" SET "${field}" = ` +
+ '(' +
+ 'SELECT COUNT(id) FROM "accountVideoRate" WHERE "accountVideoRate"."videoId" = "video"."id" AND type = :rateType' +
+ ') ' +
+ 'WHERE "video"."id" = :videoId'
+
+ return AccountVideoRateModel.sequelize.query(rawQuery, {
+ transaction: t,
+ replacements: { videoId, rateType: type },
+ type: QueryTypes.UPDATE
})
+ }
- url.push({
- type: 'Link',
- mimeType: 'application/x-bittorrent;x-scheme-handler/magnet',
- url: generateMagnetUri(this, file, baseUrlHttp, baseUrlWs),
- width: file.resolution
- })
+ static checkVideoHasInstanceFollow (videoId: number, followerActorId: number) {
+ // Instances only share videos
+ 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 ' +
+ 'LIMIT 1'
+
+ const options = {
+ type: QueryTypes.SELECT as QueryTypes.SELECT,
+ bind: { followerActorId, videoId },
+ raw: true
+ }
+
+ return VideoModel.sequelize.query(query, options)
+ .then(results => results.length === 1)
}
- const videoObject: VideoTorrentObject = {
- type: 'Video' as 'Video',
- id: getActivityPubUrl('video', this.uuid),
- name: this.name,
- // https://www.w3.org/TR/activitystreams-vocabulary/#dfn-duration
- duration: 'PT' + this.duration + 'S',
- uuid: this.uuid,
- tag,
- category: {
- identifier: this.category + '',
- name: this.getCategoryLabel()
- },
- licence: {
- identifier: this.licence + '',
- name: this.getLicenceLabel()
- },
- language: {
- identifier: this.language + '',
- name: this.getLanguageLabel()
- },
- views: this.views,
- nsfw: this.nsfw,
- published: this.createdAt.toISOString(),
- updated: this.updatedAt.toISOString(),
- mediaType: 'text/markdown',
- content: this.getTruncatedDescription(),
- icon: {
- type: 'Image',
- url: getThumbnailUrl(this, baseUrlHttp),
- mediaType: 'image/jpeg',
- width: THUMBNAILS_SIZE.width,
- height: THUMBNAILS_SIZE.height
- },
- url
+ static bulkUpdateSupportField (ofChannel: MChannel, t: Transaction) {
+ const options = {
+ where: {
+ channelId: ofChannel.id
+ },
+ transaction: t
+ }
+
+ return VideoModel.update({ support: ofChannel.support }, options)
}
- return videoObject
-}
+ static getAllIdsFromChannel (videoChannel: MChannelId): Promise<number[]> {
+ const query = {
+ attributes: [ 'id' ],
+ where: {
+ channelId: videoChannel.id
+ }
+ }
-getTruncatedDescription = function (this: VideoInstance) {
- const options = {
- length: CONSTRAINTS_FIELDS.VIDEOS.TRUNCATED_DESCRIPTION.max
+ return VideoModel.findAll(query)
+ .then(videos => videos.map(v => v.id))
}
- return truncate(this.description, options)
-}
+ // threshold corresponds to how many video the field should have to be returned
+ static async getRandomFieldSamples (field: 'category' | 'channelId', threshold: number, count: number) {
+ const serverActor = await getServerActor()
+
+ const queryOptions: BuildVideosListQueryOptions = {
+ attributes: [ `"${field}"` ],
+ group: `GROUP BY "${field}"`,
+ having: `HAVING COUNT("${field}") >= ${threshold}`,
+ start: 0,
+ sort: 'random',
+ count,
+ serverAccountIdForBlock: serverActor.Account.id,
+ displayOnlyForFollower: {
+ actorId: serverActor.id,
+ orLocalVideos: true
+ }
+ }
-optimizeOriginalVideofile = async function (this: VideoInstance) {
- const videosDirectory = CONFIG.STORAGE.VIDEOS_DIR
- const newExtname = '.mp4'
- const inputVideoFile = this.getOriginalFile()
- const videoInputPath = join(videosDirectory, this.getVideoFilename(inputVideoFile))
- const videoOutputPath = join(videosDirectory, this.id + '-transcoded' + newExtname)
+ const queryBuilder = new VideosIdListQueryBuilder(VideoModel.sequelize)
- const transcodeOptions = {
- inputPath: videoInputPath,
- outputPath: videoOutputPath
+ return queryBuilder.queryVideoIds(queryOptions)
+ .then(rows => rows.map(r => r[field]))
}
- try {
- // Could be very long!
- await transcode(transcodeOptions)
+ static buildTrendingQuery (trendingDays: number) {
+ return {
+ attributes: [],
+ subQuery: false,
+ model: VideoViewModel,
+ required: false,
+ where: {
+ startDate: {
+ [Op.gte]: new Date(new Date().getTime() - (24 * 3600 * 1000) * trendingDays)
+ }
+ }
+ }
+ }
- await unlinkPromise(videoInputPath)
+ private static async getAvailableForApi (
+ options: BuildVideosListQueryOptions,
+ countVideos = true
+ ): Promise<ResultList<VideoModel>> {
+ function getCount () {
+ if (countVideos !== true) return Promise.resolve(undefined)
- // Important to do this before getVideoFilename() to take in account the new file extension
- inputVideoFile.set('extname', newExtname)
+ const countOptions = Object.assign({}, options, { isCount: true })
+ const queryBuilder = new VideosIdListQueryBuilder(VideoModel.sequelize)
- await renamePromise(videoOutputPath, this.getVideoFilePath(inputVideoFile))
- const stats = await statPromise(this.getVideoFilePath(inputVideoFile))
+ return queryBuilder.countVideoIds(countOptions)
+ }
- inputVideoFile.set('size', stats.size)
+ function getModels () {
+ if (options.count === 0) return Promise.resolve([])
- await this.createTorrentAndSetInfoHash(inputVideoFile)
- await inputVideoFile.save()
+ const queryBuilder = new VideosModelListQueryBuilder(VideoModel.sequelize)
- } catch (err) {
- // Auto destruction...
- this.destroy().catch(err => logger.error('Cannot destruct video after transcoding failure.', err))
+ return queryBuilder.queryVideos(options)
+ }
- throw err
- }
-}
+ const [ count, rows ] = await Promise.all([ getCount(), getModels() ])
-transcodeOriginalVideofile = async function (this: VideoInstance, resolution: VideoResolution) {
- const videosDirectory = CONFIG.STORAGE.VIDEOS_DIR
- const extname = '.mp4'
+ return {
+ data: rows,
+ total: count
+ }
+ }
- // We are sure it's x264 in mp4 because optimizeOriginalVideofile was already executed
- const videoInputPath = join(videosDirectory, this.getVideoFilename(this.getOriginalFile()))
+ private static throwIfPrivateIncludeWithoutUser (include: VideoInclude, user: MUserAccountId) {
+ if (VideoModel.isPrivateInclude(include) && !user?.hasRight(UserRight.SEE_ALL_VIDEOS)) {
+ throw new Error('Try to filter all-local but user cannot see all videos')
+ }
+ }
- const newVideoFile = (Video['sequelize'].models.VideoFile as VideoFileModel).build({
- resolution,
- extname,
- size: 0,
- videoId: this.id
- })
- const videoOutputPath = join(videosDirectory, this.getVideoFilename(newVideoFile))
+ private static throwIfPrivacyOneOfWithoutUser (privacyOneOf: VideoPrivacy[], user: MUserAccountId) {
+ if (privacyOneOf && !user?.hasRight(UserRight.SEE_ALL_VIDEOS)) {
+ throw new Error('Try to choose video privacies but user cannot see all videos')
+ }
+ }
- const transcodeOptions = {
- inputPath: videoInputPath,
- outputPath: videoOutputPath,
- resolution
+ private static isPrivateInclude (include: VideoInclude) {
+ return include & VideoInclude.BLACKLISTED ||
+ include & VideoInclude.BLOCKED_OWNER ||
+ include & VideoInclude.NOT_PUBLISHED_STATE
}
- await transcode(transcodeOptions)
+ isBlacklisted () {
+ return !!this.VideoBlacklist
+ }
- const stats = await statPromise(videoOutputPath)
+ isBlocked () {
+ return this.VideoChannel.Account.Actor.Server?.isBlocked() || this.VideoChannel.Account.isBlocked()
+ }
- newVideoFile.set('size', stats.size)
+ getQualityFileBy<T extends MVideoWithFile> (this: T, fun: (files: MVideoFile[], it: (file: MVideoFile) => number) => MVideoFile) {
+ // We first transcode to WebTorrent format, so try this array first
+ if (Array.isArray(this.VideoFiles) && this.VideoFiles.length !== 0) {
+ const file = fun(this.VideoFiles, file => file.resolution)
- await this.createTorrentAndSetInfoHash(newVideoFile)
+ return Object.assign(file, { Video: this })
+ }
- await newVideoFile.save()
+ // No webtorrent files, try with streaming playlist files
+ if (Array.isArray(this.VideoStreamingPlaylists) && this.VideoStreamingPlaylists.length !== 0) {
+ const streamingPlaylistWithVideo = Object.assign(this.VideoStreamingPlaylists[0], { Video: this })
- this.VideoFiles.push(newVideoFile)
-}
+ const file = fun(streamingPlaylistWithVideo.VideoFiles, file => file.resolution)
+ return Object.assign(file, { VideoStreamingPlaylist: streamingPlaylistWithVideo })
+ }
-getOriginalFileHeight = function (this: VideoInstance) {
- const originalFilePath = this.getVideoFilePath(this.getOriginalFile())
+ return undefined
+ }
- return getVideoFileHeight(originalFilePath)
-}
+ getMaxQualityFile<T extends MVideoWithFile> (this: T): MVideoFileVideo | MVideoFileStreamingPlaylistVideo {
+ return this.getQualityFileBy(maxBy)
+ }
-getDescriptionPath = function (this: VideoInstance) {
- return `/api/${API_VERSION}/videos/${this.uuid}/description`
-}
+ getMinQualityFile<T extends MVideoWithFile> (this: T): MVideoFileVideo | MVideoFileStreamingPlaylistVideo {
+ return this.getQualityFileBy(minBy)
+ }
-getCategoryLabel = function (this: VideoInstance) {
- let categoryLabel = VIDEO_CATEGORIES[this.category]
+ getWebTorrentFile<T extends MVideoWithFile> (this: T, resolution: number): MVideoFileVideo {
+ if (Array.isArray(this.VideoFiles) === false) return undefined
- // Maybe our server is not up to date and there are new categories since our version
- if (!categoryLabel) categoryLabel = 'Misc'
+ const file = this.VideoFiles.find(f => f.resolution === resolution)
+ if (!file) return undefined
- return categoryLabel
-}
+ return Object.assign(file, { Video: this })
+ }
-getLicenceLabel = function (this: VideoInstance) {
- let licenceLabel = VIDEO_LICENCES[this.licence]
+ hasWebTorrentFiles () {
+ return Array.isArray(this.VideoFiles) === true && this.VideoFiles.length !== 0
+ }
- // Maybe our server is not up to date and there are new licences since our version
- if (!licenceLabel) licenceLabel = 'Unknown'
+ async addAndSaveThumbnail (thumbnail: MThumbnail, transaction?: Transaction) {
+ thumbnail.videoId = this.id
- return licenceLabel
-}
+ const savedThumbnail = await thumbnail.save({ transaction })
-getLanguageLabel = function (this: VideoInstance) {
- // Language is an optional attribute
- let languageLabel = VIDEO_LANGUAGES[this.language]
- if (!languageLabel) languageLabel = 'Unknown'
+ if (Array.isArray(this.Thumbnails) === false) this.Thumbnails = []
- return languageLabel
-}
+ this.Thumbnails = this.Thumbnails.filter(t => t.id !== savedThumbnail.id)
+ this.Thumbnails.push(savedThumbnail)
+ }
-removeThumbnail = function (this: VideoInstance) {
- const thumbnailPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, this.getThumbnailName())
- return unlinkPromise(thumbnailPath)
-}
+ getMiniature () {
+ if (Array.isArray(this.Thumbnails) === false) return undefined
-removePreview = function (this: VideoInstance) {
- // Same name than video thumbnail
- return unlinkPromise(CONFIG.STORAGE.PREVIEWS_DIR + this.getPreviewName())
-}
+ return this.Thumbnails.find(t => t.type === ThumbnailType.MINIATURE)
+ }
-removeFile = function (this: VideoInstance, videoFile: VideoFileInstance) {
- const filePath = join(CONFIG.STORAGE.VIDEOS_DIR, this.getVideoFilename(videoFile))
- return unlinkPromise(filePath)
-}
+ hasPreview () {
+ return !!this.getPreview()
+ }
-removeTorrent = function (this: VideoInstance, videoFile: VideoFileInstance) {
- const torrentPath = join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
- return unlinkPromise(torrentPath)
-}
+ getPreview () {
+ if (Array.isArray(this.Thumbnails) === false) return undefined
-// ------------------------------ STATICS ------------------------------
+ return this.Thumbnails.find(t => t.type === ThumbnailType.PREVIEW)
+ }
-generateThumbnailFromData = function (video: VideoInstance, thumbnailData: string) {
- // Creating the thumbnail for a remote video
+ isOwned () {
+ return this.remote === false
+ }
- const thumbnailName = video.getThumbnailName()
- const thumbnailPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, thumbnailName)
- return writeFilePromise(thumbnailPath, Buffer.from(thumbnailData, 'binary')).then(() => {
- return thumbnailName
- })
-}
+ getWatchStaticPath () {
+ return buildVideoWatchPath({ shortUUID: uuidToShort(this.uuid) })
+ }
-list = function () {
- const query = {
- include: [ Video['sequelize'].models.VideoFile ]
+ getEmbedStaticPath () {
+ return buildVideoEmbedPath(this)
}
- return Video.findAll(query)
-}
+ getMiniatureStaticPath () {
+ const thumbnail = this.getMiniature()
+ if (!thumbnail) return null
-listUserVideosForApi = function (userId: number, start: number, count: number, sort: string) {
- const query = {
- distinct: true,
- offset: start,
- limit: count,
- order: [ getSort(sort), [ Video['sequelize'].models.Tag, 'name', 'ASC' ] ],
- include: [
- {
- model: Video['sequelize'].models.VideoChannel,
- required: true,
- include: [
- {
- model: Video['sequelize'].models.Account,
- where: {
- userId
- },
- required: true
- }
- ]
- },
- Video['sequelize'].models.Tag
- ]
+ return join(STATIC_PATHS.THUMBNAILS, thumbnail.filename)
}
- return Video.findAndCountAll(query).then(({ rows, count }) => {
- return {
- data: rows,
- total: count
- }
- })
-}
+ getPreviewStaticPath () {
+ const preview = this.getPreview()
+ if (!preview) return null
-listForApi = function (start: number, count: number, sort: string) {
- const query = {
- distinct: true,
- offset: start,
- limit: count,
- order: [ getSort(sort), [ Video['sequelize'].models.Tag, 'name', 'ASC' ] ],
- include: [
- {
- model: Video['sequelize'].models.VideoChannel,
- required: true,
- include: [
- {
- model: Video['sequelize'].models.Account,
- required: true,
- include: [
- {
- model: Video['sequelize'].models.Server,
- required: false
- }
- ]
- }
- ]
- },
- Video['sequelize'].models.Tag
- ],
- where: createBaseVideosWhere()
+ // We use a local cache, so specify our cache endpoint instead of potential remote URL
+ return join(LAZY_STATIC_PATHS.PREVIEWS, preview.filename)
}
- return Video.findAndCountAll(query).then(({ rows, count }) => {
- return {
- data: rows,
- total: count
- }
- })
-}
+ toFormattedJSON (this: MVideoFormattable, options?: VideoFormattingJSONOptions): Video {
+ return videoModelToFormattedJSON(this, options)
+ }
-loadByHostAndUUID = function (fromHost: string, uuid: string, t?: Sequelize.Transaction) {
- const query: Sequelize.FindOptions<VideoAttributes> = {
- where: {
- uuid
- },
- include: [
- {
- model: Video['sequelize'].models.VideoFile
- },
- {
- model: Video['sequelize'].models.VideoChannel,
- include: [
- {
- model: Video['sequelize'].models.Account,
- include: [
- {
- model: Video['sequelize'].models.Server,
- required: true,
- where: {
- host: fromHost
- }
- }
- ]
- }
- ]
- }
- ]
+ toFormattedDetailsJSON (this: MVideoFormattableDetails): VideoDetails {
+ return videoModelToFormattedDetailsJSON(this)
}
- if (t !== undefined) query.transaction = t
+ getFormattedVideoFilesJSON (includeMagnet = true): VideoFile[] {
+ let files: VideoFile[] = []
- return Video.findOne(query)
-}
+ if (Array.isArray(this.VideoFiles)) {
+ const result = videoFilesModelToFormattedJSON(this, this.VideoFiles, includeMagnet)
+ files = files.concat(result)
+ }
-listOwnedAndPopulateAccountAndTags = function () {
- const query = {
- where: {
- remote: false
- },
- include: [
- Video['sequelize'].models.VideoFile,
- {
- model: Video['sequelize'].models.VideoChannel,
- include: [ Video['sequelize'].models.Account ]
- },
- Video['sequelize'].models.Tag
- ]
+ for (const p of (this.VideoStreamingPlaylists || [])) {
+ const result = videoFilesModelToFormattedJSON(this, p.VideoFiles, includeMagnet)
+ files = files.concat(result)
+ }
+
+ return files
}
- return Video.findAll(query)
-}
+ toActivityPubObject (this: MVideoAP): VideoObject {
+ return videoModelToActivityPubObject(this)
+ }
-listOwnedByAccount = function (account: string) {
- const query = {
- where: {
- remote: false
- },
- include: [
- {
- model: Video['sequelize'].models.VideoFile
- },
- {
- model: Video['sequelize'].models.VideoChannel,
- include: [
- {
- model: Video['sequelize'].models.Account,
- where: {
- name: account
- }
- }
- ]
- }
- ]
+ getTruncatedDescription () {
+ if (!this.description) return null
+
+ const maxLength = CONSTRAINTS_FIELDS.VIDEOS.TRUNCATED_DESCRIPTION.max
+ return peertubeTruncate(this.description, { length: maxLength })
}
- return Video.findAll(query)
-}
+ getMaxQualityResolution () {
+ const file = this.getMaxQualityFile()
+ const videoOrPlaylist = file.getVideoOrStreamingPlaylist()
-load = function (id: number) {
- return Video.findById(id)
-}
+ return VideoPathManager.Instance.makeAvailableVideoFile(file.withVideoOrPlaylist(videoOrPlaylist), originalFilePath => {
+ return getVideoFileResolution(originalFilePath)
+ })
+ }
-loadByUUID = function (uuid: string, t?: Sequelize.Transaction) {
- const query: Sequelize.FindOptions<VideoAttributes> = {
- where: {
- uuid
- },
- include: [ Video['sequelize'].models.VideoFile ]
+ getDescriptionAPIPath () {
+ return `/api/${API_VERSION}/videos/${this.uuid}/description`
}
- if (t !== undefined) query.transaction = t
+ getHLSPlaylist (): MStreamingPlaylistFilesVideo {
+ if (!this.VideoStreamingPlaylists) return undefined
- return Video.findOne(query)
-}
+ const playlist = this.VideoStreamingPlaylists.find(p => p.type === VideoStreamingPlaylistType.HLS)
+ if (!playlist) return undefined
-loadByUUIDOrURL = function (uuid: string, url: string, t?: Sequelize.Transaction) {
- const query: Sequelize.FindOptions<VideoAttributes> = {
- where: {
- [Sequelize.Op.or]: [
- { uuid },
- { url }
- ]
- },
- include: [ Video['sequelize'].models.VideoFile ]
+ playlist.Video = this
+
+ return playlist
}
- if (t !== undefined) query.transaction = t
+ setHLSPlaylist (playlist: MStreamingPlaylist) {
+ const toAdd = [ playlist ] as [ VideoStreamingPlaylistModel ]
- return Video.findOne(query)
-}
+ if (Array.isArray(this.VideoStreamingPlaylists) === false || this.VideoStreamingPlaylists.length === 0) {
+ this.VideoStreamingPlaylists = toAdd
+ return
+ }
-loadLocalVideoByUUID = function (uuid: string, t?: Sequelize.Transaction) {
- const query: Sequelize.FindOptions<VideoAttributes> = {
- where: {
- uuid,
- remote: false
- },
- include: [ Video['sequelize'].models.VideoFile ]
+ this.VideoStreamingPlaylists = this.VideoStreamingPlaylists
+ .filter(s => s.type !== VideoStreamingPlaylistType.HLS)
+ .concat(toAdd)
}
- if (t !== undefined) query.transaction = t
+ removeWebTorrentFileAndTorrent (videoFile: MVideoFile, isRedundancy = false) {
+ const filePath = isRedundancy
+ ? VideoPathManager.Instance.getFSRedundancyVideoFilePath(this, videoFile)
+ : VideoPathManager.Instance.getFSVideoFileOutputPath(this, videoFile)
- return Video.findOne(query)
-}
+ const promises: Promise<any>[] = [ remove(filePath) ]
+ if (!isRedundancy) promises.push(videoFile.removeTorrent())
-loadAndPopulateAccount = function (id: number) {
- const options = {
- include: [
- Video['sequelize'].models.VideoFile,
- {
- model: Video['sequelize'].models.VideoChannel,
- include: [ Video['sequelize'].models.Account ]
- }
- ]
+ if (videoFile.storage === VideoStorage.OBJECT_STORAGE) {
+ promises.push(removeWebTorrentObjectStorage(videoFile))
+ }
+
+ return Promise.all(promises)
}
- return Video.findById(id, options)
-}
+ async removeStreamingPlaylistFiles (streamingPlaylist: MStreamingPlaylist, isRedundancy = false) {
+ const directoryPath = isRedundancy
+ ? getHLSRedundancyDirectory(this)
+ : getHLSDirectory(this)
-loadAndPopulateAccountAndServerAndTags = function (id: number) {
- const options = {
- include: [
- {
- model: Video['sequelize'].models.VideoChannel,
- include: [
- {
- model: Video['sequelize'].models.Account,
- include: [ { model: Video['sequelize'].models.Server, required: false } ]
- }
- ]
- },
- Video['sequelize'].models.Tag,
- Video['sequelize'].models.VideoFile
- ]
- }
+ await remove(directoryPath)
- return Video.findById(id, options)
-}
+ if (isRedundancy !== true) {
+ const streamingPlaylistWithFiles = streamingPlaylist as MStreamingPlaylistFilesVideo
+ streamingPlaylistWithFiles.Video = this
-loadByUUIDAndPopulateAccountAndServerAndTags = function (uuid: string) {
- const options = {
- where: {
- uuid
- },
- include: [
- {
- model: Video['sequelize'].models.VideoChannel,
- include: [
- {
- model: Video['sequelize'].models.Account,
- include: [ { model: Video['sequelize'].models.Server, required: false } ]
- }
- ]
- },
- Video['sequelize'].models.Tag,
- Video['sequelize'].models.VideoFile
- ]
- }
+ if (!Array.isArray(streamingPlaylistWithFiles.VideoFiles)) {
+ streamingPlaylistWithFiles.VideoFiles = await streamingPlaylistWithFiles.$get('VideoFiles')
+ }
- return Video.findOne(options)
-}
+ // Remove physical files and torrents
+ await Promise.all(
+ streamingPlaylistWithFiles.VideoFiles.map(file => file.removeTorrent())
+ )
-searchAndPopulateAccountAndServerAndTags = function (value: string, field: string, start: number, count: number, sort: string) {
- const serverInclude: Sequelize.IncludeOptions = {
- model: Video['sequelize'].models.Server,
- required: false
+ if (streamingPlaylist.storage === VideoStorage.OBJECT_STORAGE) {
+ await removeHLSObjectStorage(streamingPlaylist.withVideo(this))
+ }
+ }
}
- const accountInclude: Sequelize.IncludeOptions = {
- model: Video['sequelize'].models.Account,
- include: [ serverInclude ]
+ isOutdated () {
+ if (this.isOwned()) return false
+
+ return isOutdated(this, ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL)
}
- const videoChannelInclude: Sequelize.IncludeOptions = {
- model: Video['sequelize'].models.VideoChannel,
- include: [ accountInclude ],
- required: true
+ hasPrivacyForFederation () {
+ return isPrivacyForFederation(this.privacy)
}
- const tagInclude: Sequelize.IncludeOptions = {
- model: Video['sequelize'].models.Tag
+ hasStateForFederation () {
+ return isStateForFederation(this.state)
}
- const query: Sequelize.FindOptions<VideoAttributes> = {
- distinct: true,
- where: createBaseVideosWhere(),
- offset: start,
- limit: count,
- order: [ getSort(sort), [ Video['sequelize'].models.Tag, 'name', 'ASC' ] ]
+ isNewVideo (newPrivacy: VideoPrivacy) {
+ return this.hasPrivacyForFederation() === false && isPrivacyForFederation(newPrivacy) === true
}
- if (field === 'tags') {
- const escapedValue = Video['sequelize'].escape('%' + value + '%')
- query.where['id'][Sequelize.Op.in] = Video['sequelize'].literal(
- `(SELECT "VideoTags"."videoId"
- FROM "Tags"
- INNER JOIN "VideoTags" ON "Tags"."id" = "VideoTags"."tagId"
- WHERE name ILIKE ${escapedValue}
- )`
- )
- } else if (field === 'host') {
- // FIXME: Include our server? (not stored in the database)
- serverInclude.where = {
- host: {
- [Sequelize.Op.iLike]: '%' + value + '%'
- }
- }
- serverInclude.required = true
- } else if (field === 'account') {
- accountInclude.where = {
- name: {
- [Sequelize.Op.iLike]: '%' + value + '%'
- }
- }
- } else {
- query.where[field] = {
- [Sequelize.Op.iLike]: '%' + value + '%'
- }
+ setAsRefreshed (transaction?: Transaction) {
+ return setAsUpdated('video', this.id, transaction)
}
- query.include = [
- videoChannelInclude, tagInclude
- ]
+ requiresAuth () {
+ return this.privacy === VideoPrivacy.PRIVATE || this.privacy === VideoPrivacy.INTERNAL || !!this.VideoBlacklist
+ }
- return Video.findAndCountAll(query).then(({ rows, count }) => {
- return {
- data: rows,
- total: count
+ setPrivacy (newPrivacy: VideoPrivacy) {
+ if (this.privacy === VideoPrivacy.PRIVATE && newPrivacy !== VideoPrivacy.PRIVATE) {
+ this.publishedAt = new Date()
}
- })
-}
-// ---------------------------------------------------------------------------
-
-function createBaseVideosWhere () {
- return {
- id: {
- [Sequelize.Op.notIn]: Video['sequelize'].literal(
- '(SELECT "BlacklistedVideos"."videoId" FROM "BlacklistedVideos")'
- )
- },
- privacy: VideoPrivacy.PUBLIC
+ this.privacy = newPrivacy
}
-}
-function getBaseUrls (video: VideoInstance) {
- let baseUrlHttp
- let baseUrlWs
-
- if (video.isOwned()) {
- baseUrlHttp = CONFIG.WEBSERVER.URL
- baseUrlWs = CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT
- } else {
- baseUrlHttp = REMOTE_SCHEME.HTTP + '://' + video.VideoChannel.Account.Server.host
- baseUrlWs = REMOTE_SCHEME.WS + '://' + video.VideoChannel.Account.Server.host
+ isConfidential () {
+ return this.privacy === VideoPrivacy.PRIVATE ||
+ this.privacy === VideoPrivacy.UNLISTED ||
+ this.privacy === VideoPrivacy.INTERNAL
}
- return { baseUrlHttp, baseUrlWs }
-}
-
-function getThumbnailUrl (video: VideoInstance, baseUrlHttp: string) {
- return baseUrlHttp + STATIC_PATHS.THUMBNAILS + video.getThumbnailName()
-}
+ async setNewState (newState: VideoState, isNewVideo: boolean, transaction: Transaction) {
+ if (this.state === newState) throw new Error('Cannot use same state ' + newState)
-function getTorrentUrl (video: VideoInstance, videoFile: VideoFileInstance, baseUrlHttp: string) {
- return baseUrlHttp + STATIC_PATHS.TORRENTS + video.getTorrentFileName(videoFile)
-}
+ this.state = newState
-function getVideoFileUrl (video: VideoInstance, videoFile: VideoFileInstance, baseUrlHttp: string) {
- return baseUrlHttp + STATIC_PATHS.WEBSEED + video.getVideoFilename(videoFile)
-}
+ if (this.state === VideoState.PUBLISHED && isNewVideo) {
+ this.publishedAt = new Date()
+ }
-function generateMagnetUri (video: VideoInstance, videoFile: VideoFileInstance, baseUrlHttp: string, baseUrlWs: string) {
- const xs = getTorrentUrl(video, videoFile, baseUrlHttp)
- const announce = [ baseUrlWs + '/tracker/socket', baseUrlHttp + '/tracker/announce' ]
- const urlList = [ getVideoFileUrl(video, videoFile, baseUrlHttp) ]
+ await this.save({ transaction })
+ }
- const magnetHash = {
- xs,
- announce,
- urlList,
- infoHash: videoFile.infoHash,
- name: video.name
+ getBandwidthBits (this: MVideo, videoFile: MVideoFile) {
+ return Math.ceil((videoFile.size * 8) / this.duration)
}
- return magnetUtil.encode(magnetHash)
+ getTrackerUrls () {
+ if (this.isOwned()) {
+ return [
+ WEBSERVER.URL + '/tracker/announce',
+ WEBSERVER.WS + '://' + WEBSERVER.HOSTNAME + ':' + WEBSERVER.PORT + '/tracker/socket'
+ ]
+ }
+
+ return this.Trackers.map(t => t.url)
+ }
}
projects / github / Chocobozzz / PeerTube.git / blobdiff