2069 lines
55 KiB
TypeScript
2069 lines
55 KiB
TypeScript
import { buildVideoEmbedPath, buildVideoWatchPath, pick, wait } from '@peertube/peertube-core-utils'
|
|
import { ffprobePromise, getAudioStream, getVideoStreamDimensionsInfo, getVideoStreamFPS, hasAudioStream } from '@peertube/peertube-ffmpeg'
|
|
import {
|
|
ResultList,
|
|
ThumbnailType,
|
|
UserRight,
|
|
Video,
|
|
VideoDetails,
|
|
VideoFile,
|
|
VideoInclude,
|
|
VideoIncludeType,
|
|
VideoObject,
|
|
VideoPrivacy,
|
|
VideoRateType,
|
|
VideoState,
|
|
VideoStorage,
|
|
VideoStreamingPlaylistType,
|
|
type VideoPrivacyType,
|
|
type VideoStateType
|
|
} from '@peertube/peertube-models'
|
|
import { uuidToShort } from '@peertube/peertube-node-utils'
|
|
import { AttributesOnly } from '@peertube/peertube-typescript-utils'
|
|
import { getPrivaciesForFederation, isPrivacyForFederation, isStateForFederation } from '@server/helpers/video.js'
|
|
import { InternalEventEmitter } from '@server/lib/internal-event-emitter.js'
|
|
import { LiveManager } from '@server/lib/live/live-manager.js'
|
|
import {
|
|
removeHLSFileObjectStorageByFilename,
|
|
removeHLSObjectStorage,
|
|
removeWebVideoObjectStorage
|
|
} from '@server/lib/object-storage/index.js'
|
|
import { tracer } from '@server/lib/opentelemetry/tracing.js'
|
|
import { getHLSDirectory, getHLSRedundancyDirectory, getHlsResolutionPlaylistFilename } from '@server/lib/paths.js'
|
|
import { Hooks } from '@server/lib/plugins/hooks.js'
|
|
import { VideoPathManager } from '@server/lib/video-path-manager.js'
|
|
import { isVideoInPrivateDirectory } from '@server/lib/video-privacy.js'
|
|
import { getServerActor } from '@server/models/application/application.js'
|
|
import { ModelCache } from '@server/models/shared/model-cache.js'
|
|
import Bluebird from 'bluebird'
|
|
import { remove } from 'fs-extra/esm'
|
|
import maxBy from 'lodash-es/maxBy.js'
|
|
import minBy from 'lodash-es/minBy.js'
|
|
import { FindOptions, IncludeOptions, Includeable, Op, QueryTypes, ScopeOptions, Sequelize, Transaction, WhereOptions } from 'sequelize'
|
|
import {
|
|
AfterCreate,
|
|
AfterDestroy,
|
|
AfterUpdate,
|
|
AllowNull,
|
|
BeforeDestroy,
|
|
BelongsTo,
|
|
BelongsToMany,
|
|
Column,
|
|
CreatedAt,
|
|
DataType,
|
|
Default,
|
|
ForeignKey,
|
|
HasMany,
|
|
HasOne,
|
|
Is,
|
|
IsInt,
|
|
IsUUID,
|
|
Min,
|
|
Model,
|
|
Scopes,
|
|
Table,
|
|
UpdatedAt
|
|
} from 'sequelize-typescript'
|
|
import { peertubeTruncate } from '../../helpers/core-utils.js'
|
|
import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc.js'
|
|
import { exists, isArray, isBooleanValid, isUUIDValid } from '../../helpers/custom-validators/misc.js'
|
|
import {
|
|
isVideoDescriptionValid,
|
|
isVideoDurationValid,
|
|
isVideoNameValid,
|
|
isVideoPrivacyValid,
|
|
isVideoStateValid,
|
|
isVideoSupportValid
|
|
} from '../../helpers/custom-validators/videos.js'
|
|
import { logger } from '../../helpers/logger.js'
|
|
import { CONFIG } from '../../initializers/config.js'
|
|
import { ACTIVITY_PUB, API_VERSION, CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants.js'
|
|
import { sendDeleteVideo } from '../../lib/activitypub/send/index.js'
|
|
import {
|
|
MChannel,
|
|
MChannelAccountDefault,
|
|
MChannelId,
|
|
MStoryboard,
|
|
MStreamingPlaylist,
|
|
MStreamingPlaylistFilesVideo,
|
|
MUserAccountId,
|
|
MUserId,
|
|
MVideoAP,
|
|
MVideoAPLight,
|
|
MVideoAccountLightBlacklistAllFiles,
|
|
MVideoCaptionLanguageUrl,
|
|
MVideoDetails,
|
|
MVideoFileVideo,
|
|
MVideoForUser,
|
|
MVideoFormattable,
|
|
MVideoFormattableDetails,
|
|
MVideoFullLight,
|
|
MVideoId,
|
|
MVideoImmutable,
|
|
MVideoThumbnail,
|
|
MVideoThumbnailBlacklist,
|
|
MVideoWithAllFiles,
|
|
MVideoWithFile,
|
|
type MVideo,
|
|
type MVideoAccountLight
|
|
} from '../../types/models/index.js'
|
|
import { MThumbnail } from '../../types/models/video/thumbnail.js'
|
|
import { MVideoFile, MVideoFileStreamingPlaylistVideo } from '../../types/models/video/video-file.js'
|
|
import { VideoAbuseModel } from '../abuse/video-abuse.js'
|
|
import { AccountVideoRateModel } from '../account/account-video-rate.js'
|
|
import { AccountModel } from '../account/account.js'
|
|
import { ActorImageModel } from '../actor/actor-image.js'
|
|
import { ActorModel } from '../actor/actor.js'
|
|
import { VideoRedundancyModel } from '../redundancy/video-redundancy.js'
|
|
import { ServerModel } from '../server/server.js'
|
|
import { TrackerModel } from '../server/tracker.js'
|
|
import { VideoTrackerModel } from '../server/video-tracker.js'
|
|
import { buildTrigramSearchIndex, buildWhereIdOrUUID, getVideoSort, isOutdated, setAsUpdated, throwIfNotValid } from '../shared/index.js'
|
|
import { UserVideoHistoryModel } from '../user/user-video-history.js'
|
|
import { UserModel } from '../user/user.js'
|
|
import { VideoViewModel } from '../view/video-view.js'
|
|
import { videoModelToActivityPubObject } from './formatter/video-activity-pub-format.js'
|
|
import {
|
|
VideoFormattingJSONOptions,
|
|
videoFilesModelToFormattedJSON,
|
|
videoModelToFormattedDetailsJSON,
|
|
videoModelToFormattedJSON
|
|
} from './formatter/video-api-format.js'
|
|
import { ScheduleVideoUpdateModel } from './schedule-video-update.js'
|
|
import {
|
|
BuildVideosListQueryOptions,
|
|
DisplayOnlyForFollowerOptions,
|
|
VideoModelGetQueryBuilder,
|
|
VideosIdListQueryBuilder,
|
|
VideosModelListQueryBuilder
|
|
} from './sql/video/index.js'
|
|
import { StoryboardModel } from './storyboard.js'
|
|
import { TagModel } from './tag.js'
|
|
import { ThumbnailModel } from './thumbnail.js'
|
|
import { VideoBlacklistModel } from './video-blacklist.js'
|
|
import { VideoCaptionModel } from './video-caption.js'
|
|
import { SummaryOptions, VideoChannelModel, ScopeNames as VideoChannelScopeNames } from './video-channel.js'
|
|
import { VideoCommentModel } from './video-comment.js'
|
|
import { VideoFileModel } from './video-file.js'
|
|
import { VideoImportModel } from './video-import.js'
|
|
import { VideoJobInfoModel } from './video-job-info.js'
|
|
import { VideoLiveModel } from './video-live.js'
|
|
import { VideoPasswordModel } from './video-password.js'
|
|
import { VideoPlaylistElementModel } from './video-playlist-element.js'
|
|
import { VideoShareModel } from './video-share.js'
|
|
import { VideoSourceModel } from './video-source.js'
|
|
import { VideoStreamingPlaylistModel } from './video-streaming-playlist.js'
|
|
import { VideoTagModel } from './video-tag.js'
|
|
|
|
export enum ScopeNames {
|
|
FOR_API = 'FOR_API',
|
|
WITH_ACCOUNT_DETAILS = 'WITH_ACCOUNT_DETAILS',
|
|
WITH_TAGS = 'WITH_TAGS',
|
|
WITH_WEB_VIDEO_FILES = 'WITH_WEB_VIDEO_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
|
|
},
|
|
{
|
|
attributes: [ 'type', 'filename' ],
|
|
model: ThumbnailModel,
|
|
required: false
|
|
}
|
|
]
|
|
|
|
const query: FindOptions = {}
|
|
|
|
if (options.ids) {
|
|
query.where = {
|
|
id: {
|
|
[Op.in]: options.ids
|
|
}
|
|
}
|
|
}
|
|
|
|
if (options.videoPlaylistId) {
|
|
include.push({
|
|
model: VideoPlaylistElementModel.unscoped(),
|
|
required: true,
|
|
where: {
|
|
videoPlaylistId: options.videoPlaylistId
|
|
}
|
|
})
|
|
}
|
|
|
|
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,
|
|
as: 'Avatars',
|
|
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,
|
|
as: 'Avatars',
|
|
required: false
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
]
|
|
},
|
|
[ScopeNames.WITH_TAGS]: {
|
|
include: [ TagModel ]
|
|
},
|
|
[ScopeNames.WITH_BLACKLISTED]: {
|
|
include: [
|
|
{
|
|
attributes: [ 'id', 'reason', 'unfederated' ],
|
|
model: VideoBlacklistModel,
|
|
required: false
|
|
}
|
|
]
|
|
},
|
|
[ScopeNames.WITH_WEB_VIDEO_FILES]: (withRedundancies = false) => {
|
|
let subInclude: any[] = []
|
|
|
|
if (withRedundancies === true) {
|
|
subInclude = [
|
|
{
|
|
attributes: [ 'fileUrl' ],
|
|
model: VideoRedundancyModel.unscoped(),
|
|
required: false
|
|
}
|
|
]
|
|
}
|
|
|
|
return {
|
|
include: [
|
|
{
|
|
model: VideoFileModel,
|
|
separate: true,
|
|
required: false,
|
|
include: subInclude
|
|
}
|
|
]
|
|
}
|
|
},
|
|
[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
|
|
}
|
|
]
|
|
}
|
|
},
|
|
[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
|
|
}
|
|
}
|
|
]
|
|
}
|
|
}
|
|
}))
|
|
@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
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fields: [ 'category' ], // We don't care videos with an unknown category
|
|
where: {
|
|
category: {
|
|
[Op.ne]: null
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fields: [ 'licence' ], // We don't care videos with an unknown licence
|
|
where: {
|
|
licence: {
|
|
[Op.ne]: null
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fields: [ 'language' ], // We don't care videos with an unknown language
|
|
where: {
|
|
language: {
|
|
[Op.ne]: null
|
|
}
|
|
}
|
|
},
|
|
{
|
|
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
|
|
}
|
|
]
|
|
})
|
|
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(DataType.INTEGER)
|
|
privacy: VideoPrivacyType
|
|
|
|
@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: VideoStateType
|
|
|
|
// We already have the information in videoSource table for local videos, but we prefer to normalize it for performance
|
|
// And also to store the info from remote instances
|
|
@AllowNull(true)
|
|
@Column
|
|
inputFileUpdatedAt: Date
|
|
|
|
@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: Awaited<VideoChannelModel>
|
|
|
|
@BelongsToMany(() => TagModel, {
|
|
foreignKey: 'videoId',
|
|
through: () => VideoTagModel,
|
|
onDelete: 'CASCADE'
|
|
})
|
|
Tags: Awaited<TagModel>[]
|
|
|
|
@BelongsToMany(() => TrackerModel, {
|
|
foreignKey: 'videoId',
|
|
through: () => VideoTrackerModel,
|
|
onDelete: 'CASCADE'
|
|
})
|
|
Trackers: Awaited<TrackerModel>[]
|
|
|
|
@HasMany(() => ThumbnailModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: true
|
|
},
|
|
hooks: true,
|
|
onDelete: 'cascade'
|
|
})
|
|
Thumbnails: Awaited<ThumbnailModel>[]
|
|
|
|
@HasMany(() => VideoPlaylistElementModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: true
|
|
},
|
|
onDelete: 'set null'
|
|
})
|
|
VideoPlaylistElements: Awaited<VideoPlaylistElementModel>[]
|
|
|
|
@HasOne(() => VideoSourceModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
onDelete: 'CASCADE'
|
|
})
|
|
VideoSource: Awaited<VideoSourceModel>
|
|
|
|
@HasMany(() => VideoAbuseModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: true
|
|
},
|
|
onDelete: 'set null'
|
|
})
|
|
VideoAbuses: Awaited<VideoAbuseModel>[]
|
|
|
|
@HasMany(() => VideoFileModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: true
|
|
},
|
|
hooks: true,
|
|
onDelete: 'cascade'
|
|
})
|
|
VideoFiles: Awaited<VideoFileModel>[]
|
|
|
|
@HasMany(() => VideoStreamingPlaylistModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
hooks: true,
|
|
onDelete: 'cascade'
|
|
})
|
|
VideoStreamingPlaylists: Awaited<VideoStreamingPlaylistModel>[]
|
|
|
|
@HasMany(() => VideoShareModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
onDelete: 'cascade'
|
|
})
|
|
VideoShares: Awaited<VideoShareModel>[]
|
|
|
|
@HasMany(() => AccountVideoRateModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
onDelete: 'cascade'
|
|
})
|
|
AccountVideoRates: Awaited<AccountVideoRateModel>[]
|
|
|
|
@HasMany(() => VideoCommentModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
onDelete: 'cascade',
|
|
hooks: true
|
|
})
|
|
VideoComments: Awaited<VideoCommentModel>[]
|
|
|
|
@HasMany(() => VideoViewModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
onDelete: 'cascade'
|
|
})
|
|
VideoViews: Awaited<VideoViewModel>[]
|
|
|
|
@HasMany(() => UserVideoHistoryModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
onDelete: 'cascade'
|
|
})
|
|
UserVideoHistories: Awaited<UserVideoHistoryModel>[]
|
|
|
|
@HasOne(() => ScheduleVideoUpdateModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
onDelete: 'cascade'
|
|
})
|
|
ScheduleVideoUpdate: Awaited<ScheduleVideoUpdateModel>
|
|
|
|
@HasOne(() => VideoBlacklistModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
onDelete: 'cascade'
|
|
})
|
|
VideoBlacklist: Awaited<VideoBlacklistModel>
|
|
|
|
@HasOne(() => VideoLiveModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
hooks: true,
|
|
onDelete: 'cascade'
|
|
})
|
|
VideoLive: Awaited<VideoLiveModel>
|
|
|
|
@HasOne(() => VideoImportModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: true
|
|
},
|
|
onDelete: 'set null'
|
|
})
|
|
VideoImport: Awaited<VideoImportModel>
|
|
|
|
@HasMany(() => VideoCaptionModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
onDelete: 'cascade',
|
|
hooks: true,
|
|
['separate' as any]: true
|
|
})
|
|
VideoCaptions: Awaited<VideoCaptionModel>[]
|
|
|
|
@HasMany(() => VideoPasswordModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
onDelete: 'cascade'
|
|
})
|
|
VideoPasswords: Awaited<VideoPasswordModel>[]
|
|
|
|
@HasOne(() => VideoJobInfoModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
onDelete: 'cascade'
|
|
})
|
|
VideoJobInfo: Awaited<VideoJobInfoModel>
|
|
|
|
@HasOne(() => StoryboardModel, {
|
|
foreignKey: {
|
|
name: 'videoId',
|
|
allowNull: false
|
|
},
|
|
onDelete: 'cascade',
|
|
hooks: true
|
|
})
|
|
Storyboard: Awaited<StoryboardModel>
|
|
|
|
@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 stopLiveIfNeeded (instance: VideoModel) {
|
|
if (!instance.isLive) return
|
|
|
|
logger.info('Stopping live of video %s after video deletion.', instance.uuid)
|
|
|
|
LiveManager.Instance.stopSessionOf(instance.uuid, null)
|
|
}
|
|
|
|
@BeforeDestroy
|
|
static invalidateCache (instance: VideoModel) {
|
|
ModelCache.Instance.invalidateCache('video', instance.id)
|
|
}
|
|
|
|
@BeforeDestroy
|
|
static async sendDelete (instance: MVideoAccountLight, options: { transaction: Transaction }) {
|
|
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.removeWebVideoFile(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)
|
|
.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
|
|
}
|
|
|
|
@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
|
|
},
|
|
{
|
|
model: StoryboardModel.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
|
|
}
|
|
})
|
|
}
|
|
|
|
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 (forCount: boolean): 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: forCount
|
|
? VideoChannelModel.unscoped()
|
|
: VideoChannelModel,
|
|
required: true,
|
|
where: channelWhere,
|
|
include: [
|
|
{
|
|
model: forCount
|
|
? AccountModel.unscoped()
|
|
: AccountModel,
|
|
where: {
|
|
id: accountId
|
|
},
|
|
required: true
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
|
|
return baseQuery
|
|
}
|
|
|
|
const countQuery = buildBaseQuery(true)
|
|
const findQuery = buildBaseQuery(false)
|
|
|
|
const findScopes: (string | ScopeOptions)[] = [
|
|
ScopeNames.WITH_SCHEDULED_UPDATE,
|
|
ScopeNames.WITH_BLACKLISTED,
|
|
ScopeNames.WITH_THUMBNAILS
|
|
]
|
|
|
|
return Promise.all([
|
|
VideoModel.count(countQuery),
|
|
VideoModel.scope(findScopes).findAll<MVideoForUser>(findQuery)
|
|
]).then(([ count, rows ]) => {
|
|
return {
|
|
data: rows,
|
|
total: count
|
|
}
|
|
})
|
|
}
|
|
|
|
static async listForApi (options: {
|
|
start: number
|
|
count: number
|
|
sort: string
|
|
|
|
nsfw: boolean
|
|
isLive?: boolean
|
|
isLocal?: boolean
|
|
include?: VideoIncludeType
|
|
|
|
hasFiles?: boolean // default false
|
|
|
|
hasWebtorrentFiles?: boolean // TODO: remove in v7
|
|
hasWebVideoFiles?: boolean
|
|
|
|
hasHLSFiles?: boolean
|
|
|
|
categoryOneOf?: number[]
|
|
licenceOneOf?: number[]
|
|
languageOneOf?: string[]
|
|
tagsOneOf?: string[]
|
|
tagsAllOf?: string[]
|
|
privacyOneOf?: VideoPrivacyType[]
|
|
|
|
accountId?: number
|
|
videoChannelId?: number
|
|
|
|
displayOnlyForFollower: DisplayOnlyForFollowerOptions | null
|
|
|
|
videoPlaylistId?: number
|
|
|
|
trendingDays?: number
|
|
|
|
user?: MUserAccountId
|
|
historyOfUser?: MUserId
|
|
|
|
countVideos?: boolean
|
|
|
|
search?: string
|
|
|
|
excludeAlreadyWatched?: boolean
|
|
}) {
|
|
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',
|
|
'hasWebVideoFiles',
|
|
'search',
|
|
'excludeAlreadyWatched'
|
|
]),
|
|
|
|
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?: VideoIncludeType
|
|
|
|
categoryOneOf?: number[]
|
|
licenceOneOf?: number[]
|
|
languageOneOf?: string[]
|
|
tagsOneOf?: string[]
|
|
tagsAllOf?: string[]
|
|
privacyOneOf?: VideoPrivacyType[]
|
|
|
|
displayOnlyForFollower: DisplayOnlyForFollowerOptions | null
|
|
|
|
user?: MUserAccountId
|
|
|
|
hasWebtorrentFiles?: boolean // TODO: remove in v7
|
|
hasWebVideoFiles?: 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[]
|
|
|
|
excludeAlreadyWatched?: boolean
|
|
}) {
|
|
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',
|
|
'hasWebVideoFiles',
|
|
'uuids',
|
|
'search',
|
|
'displayOnlyForFollower',
|
|
'excludeAlreadyWatched'
|
|
]),
|
|
serverAccountIdForBlock: serverActor.Account.id
|
|
}
|
|
|
|
return VideoModel.getAvailableForApi(queryOptions)
|
|
}
|
|
|
|
static countLives (options: {
|
|
remote: boolean
|
|
mode: 'published' | 'not-ended'
|
|
}) {
|
|
const query = {
|
|
where: {
|
|
remote: options.remote,
|
|
isLive: true,
|
|
state: options.mode === 'not-ended'
|
|
? { [Op.ne]: VideoState.LIVE_ENDED }
|
|
: { [Op.eq]: VideoState.PUBLISHED }
|
|
}
|
|
}
|
|
|
|
return VideoModel.count(query)
|
|
}
|
|
|
|
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
|
|
})
|
|
}
|
|
|
|
static loadByUrlImmutableAttributes (url: string, transaction?: Transaction): Promise<MVideoImmutable> {
|
|
const fun = () => {
|
|
const query: FindOptions = {
|
|
where: {
|
|
url
|
|
},
|
|
transaction
|
|
}
|
|
|
|
return VideoModel.scope(ScopeNames.WITH_IMMUTABLE_ATTRIBUTES).findOne(query)
|
|
}
|
|
|
|
return ModelCache.Instance.doCache({
|
|
cacheType: 'load-video-immutable-url',
|
|
key: url,
|
|
deleteKey: 'video',
|
|
fun
|
|
})
|
|
}
|
|
|
|
static loadOnlyId (id: number | string, transaction?: Transaction): Promise<MVideoId> {
|
|
const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
|
|
|
|
return queryBuilder.queryVideo({ id, transaction, type: 'id' })
|
|
}
|
|
|
|
static loadWithFiles (id: number | string, transaction?: Transaction, logging?: boolean): Promise<MVideoWithAllFiles> {
|
|
const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
|
|
|
|
return queryBuilder.queryVideo({ id, transaction, type: 'all-files', logging })
|
|
}
|
|
|
|
static loadByUrl (url: string, transaction?: Transaction): Promise<MVideoThumbnail> {
|
|
const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
|
|
|
|
return queryBuilder.queryVideo({ url, transaction, type: 'thumbnails' })
|
|
}
|
|
|
|
static loadByUrlAndPopulateAccount (url: string, transaction?: Transaction): Promise<MVideoAccountLightBlacklistAllFiles> {
|
|
const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
|
|
|
|
return queryBuilder.queryVideo({ url, transaction, type: 'account-blacklist-files' })
|
|
}
|
|
|
|
static loadFull (id: number | string, t?: Transaction, userId?: number): Promise<MVideoFullLight> {
|
|
const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
|
|
|
|
return queryBuilder.queryVideo({ id, transaction: t, type: 'full', userId })
|
|
}
|
|
|
|
static loadForGetAPI (parameters: {
|
|
id: number | string
|
|
transaction?: Transaction
|
|
userId?: number
|
|
}): Promise<MVideoDetails> {
|
|
const { id, transaction, userId } = parameters
|
|
const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
|
|
|
|
return queryBuilder.queryVideo({ id, transaction, type: 'api', userId })
|
|
}
|
|
|
|
static async getStats () {
|
|
const serverActor = await getServerActor()
|
|
|
|
let totalLocalVideoViews = await VideoModel.sum('views', {
|
|
where: {
|
|
remote: false
|
|
}
|
|
})
|
|
|
|
// Sequelize could return null...
|
|
if (!totalLocalVideoViews) totalLocalVideoViews = 0
|
|
|
|
const baseOptions = {
|
|
start: 0,
|
|
count: 0,
|
|
sort: '-publishedAt',
|
|
nsfw: null,
|
|
displayOnlyForFollower: {
|
|
actorId: serverActor.id,
|
|
orLocalVideos: true
|
|
}
|
|
}
|
|
|
|
const { total: totalLocalVideos } = await VideoModel.listForApi({
|
|
...baseOptions,
|
|
|
|
isLocal: true
|
|
})
|
|
|
|
const { total: totalVideos } = await VideoModel.listForApi(baseOptions)
|
|
|
|
return {
|
|
totalLocalVideos,
|
|
totalLocalVideoViews,
|
|
totalVideos
|
|
}
|
|
}
|
|
|
|
static incrementViews (id: number, views: number) {
|
|
return VideoModel.increment('views', {
|
|
by: views,
|
|
where: {
|
|
id
|
|
}
|
|
})
|
|
}
|
|
|
|
static updateRatesOf (videoId: number, type: VideoRateType, count: number, t: Transaction) {
|
|
const field = type === 'like'
|
|
? 'likes'
|
|
: 'dislikes'
|
|
|
|
const rawQuery = `UPDATE "video" SET "${field}" = :count WHERE "video"."id" = :videoId`
|
|
|
|
return AccountVideoRateModel.sequelize.query(rawQuery, {
|
|
transaction: t,
|
|
replacements: { videoId, rateType: type, count },
|
|
type: QueryTypes.UPDATE
|
|
})
|
|
}
|
|
|
|
static syncLocalRates (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
|
|
})
|
|
}
|
|
|
|
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 ' +
|
|
'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 = {
|
|
type: QueryTypes.SELECT as QueryTypes.SELECT,
|
|
bind: { followerActorId, videoId },
|
|
raw: true
|
|
}
|
|
|
|
return VideoModel.sequelize.query(query, options)
|
|
.then(results => results.length === 1)
|
|
}
|
|
|
|
static bulkUpdateSupportField (ofChannel: MChannel, t: Transaction) {
|
|
const options = {
|
|
where: {
|
|
channelId: ofChannel.id
|
|
},
|
|
transaction: t
|
|
}
|
|
|
|
return VideoModel.update({ support: ofChannel.support }, options)
|
|
}
|
|
|
|
static getAllIdsFromChannel (videoChannel: MChannelId): Promise<number[]> {
|
|
const query = {
|
|
attributes: [ 'id' ],
|
|
where: {
|
|
channelId: videoChannel.id
|
|
}
|
|
}
|
|
|
|
return VideoModel.findAll(query)
|
|
.then(videos => videos.map(v => v.id))
|
|
}
|
|
|
|
// 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
|
|
}
|
|
}
|
|
|
|
const queryBuilder = new VideosIdListQueryBuilder(VideoModel.sequelize)
|
|
|
|
return queryBuilder.queryVideoIds(queryOptions)
|
|
.then(rows => rows.map(r => r[field]))
|
|
}
|
|
|
|
static buildTrendingQuery (trendingDays: number) {
|
|
return {
|
|
attributes: [],
|
|
subQuery: false,
|
|
model: VideoViewModel,
|
|
required: false,
|
|
where: {
|
|
startDate: {
|
|
// FIXME: ts error
|
|
[Op.gte as any]: new Date(new Date().getTime() - (24 * 3600 * 1000) * trendingDays)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static async getAvailableForApi (
|
|
options: BuildVideosListQueryOptions,
|
|
countVideos = true
|
|
): Promise<ResultList<VideoModel>> {
|
|
const span = tracer.startSpan('peertube.VideoModel.getAvailableForApi')
|
|
|
|
function getCount () {
|
|
if (countVideos !== true) return Promise.resolve(undefined)
|
|
|
|
const countOptions = Object.assign({}, options, { isCount: true })
|
|
const queryBuilder = new VideosIdListQueryBuilder(VideoModel.sequelize)
|
|
|
|
return queryBuilder.countVideoIds(countOptions)
|
|
}
|
|
|
|
function getModels () {
|
|
if (options.count === 0) return Promise.resolve([])
|
|
|
|
const queryBuilder = new VideosModelListQueryBuilder(VideoModel.sequelize)
|
|
|
|
return queryBuilder.queryVideos(options)
|
|
}
|
|
|
|
const [ count, rows ] = await Promise.all([ getCount(), getModels() ])
|
|
|
|
span.end()
|
|
|
|
return {
|
|
data: rows,
|
|
total: count
|
|
}
|
|
}
|
|
|
|
private static throwIfPrivateIncludeWithoutUser (include: VideoIncludeType, user: MUserAccountId) {
|
|
if (VideoModel.isPrivateInclude(include) && !user?.hasRight(UserRight.SEE_ALL_VIDEOS)) {
|
|
throw new Error('Try to include protected videos but user cannot see all videos')
|
|
}
|
|
}
|
|
|
|
private static throwIfPrivacyOneOfWithoutUser (privacyOneOf: VideoPrivacyType[], user: MUserAccountId) {
|
|
if (privacyOneOf && !user?.hasRight(UserRight.SEE_ALL_VIDEOS)) {
|
|
throw new Error('Try to choose video privacies but user cannot see all videos')
|
|
}
|
|
}
|
|
|
|
private static isPrivateInclude (include: VideoIncludeType) {
|
|
return include & VideoInclude.BLACKLISTED ||
|
|
include & VideoInclude.BLOCKED_OWNER ||
|
|
include & VideoInclude.NOT_PUBLISHED_STATE
|
|
}
|
|
|
|
isBlacklisted () {
|
|
return !!this.VideoBlacklist
|
|
}
|
|
|
|
isBlocked () {
|
|
return this.VideoChannel.Account.Actor.Server?.isBlocked() || this.VideoChannel.Account.isBlocked()
|
|
}
|
|
|
|
getQualityFileBy<T extends MVideoWithFile> (this: T, fun: (files: MVideoFile[], it: (file: MVideoFile) => number) => MVideoFile) {
|
|
const files = this.getAllFiles()
|
|
const file = fun(files, file => file.resolution)
|
|
if (!file) return undefined
|
|
|
|
if (file.videoId) {
|
|
return Object.assign(file, { Video: this })
|
|
}
|
|
|
|
if (file.videoStreamingPlaylistId) {
|
|
const streamingPlaylistWithVideo = Object.assign(this.VideoStreamingPlaylists[0], { Video: this })
|
|
|
|
return Object.assign(file, { VideoStreamingPlaylist: streamingPlaylistWithVideo })
|
|
}
|
|
|
|
throw new Error('File is not associated to a video of a playlist')
|
|
}
|
|
|
|
getMaxQualityFile<T extends MVideoWithFile> (this: T): MVideoFileVideo | MVideoFileStreamingPlaylistVideo {
|
|
return this.getQualityFileBy(maxBy)
|
|
}
|
|
|
|
getMinQualityFile<T extends MVideoWithFile> (this: T): MVideoFileVideo | MVideoFileStreamingPlaylistVideo {
|
|
return this.getQualityFileBy(minBy)
|
|
}
|
|
|
|
getWebVideoFile<T extends MVideoWithFile> (this: T, resolution: number): MVideoFileVideo {
|
|
if (Array.isArray(this.VideoFiles) === false) return undefined
|
|
|
|
const file = this.VideoFiles.find(f => f.resolution === resolution)
|
|
if (!file) return undefined
|
|
|
|
return Object.assign(file, { Video: this })
|
|
}
|
|
|
|
hasWebVideoFiles () {
|
|
return Array.isArray(this.VideoFiles) === true && this.VideoFiles.length !== 0
|
|
}
|
|
|
|
async addAndSaveThumbnail (thumbnail: MThumbnail, transaction?: Transaction) {
|
|
thumbnail.videoId = this.id
|
|
|
|
const savedThumbnail = await thumbnail.save({ transaction })
|
|
|
|
if (Array.isArray(this.Thumbnails) === false) this.Thumbnails = []
|
|
|
|
this.Thumbnails = this.Thumbnails.filter(t => t.id !== savedThumbnail.id)
|
|
this.Thumbnails.push(savedThumbnail)
|
|
}
|
|
|
|
getMiniature () {
|
|
if (Array.isArray(this.Thumbnails) === false) return undefined
|
|
|
|
return this.Thumbnails.find(t => t.type === ThumbnailType.MINIATURE)
|
|
}
|
|
|
|
hasPreview () {
|
|
return !!this.getPreview()
|
|
}
|
|
|
|
getPreview () {
|
|
if (Array.isArray(this.Thumbnails) === false) return undefined
|
|
|
|
return this.Thumbnails.find(t => t.type === ThumbnailType.PREVIEW)
|
|
}
|
|
|
|
isOwned () {
|
|
return this.remote === false
|
|
}
|
|
|
|
getWatchStaticPath () {
|
|
return buildVideoWatchPath({ shortUUID: uuidToShort(this.uuid) })
|
|
}
|
|
|
|
getEmbedStaticPath () {
|
|
return buildVideoEmbedPath(this)
|
|
}
|
|
|
|
getMiniatureStaticPath () {
|
|
const thumbnail = this.getMiniature()
|
|
if (!thumbnail) return null
|
|
|
|
return thumbnail.getLocalStaticPath()
|
|
}
|
|
|
|
getPreviewStaticPath () {
|
|
const preview = this.getPreview()
|
|
if (!preview) return null
|
|
|
|
return preview.getLocalStaticPath()
|
|
}
|
|
|
|
toFormattedJSON (this: MVideoFormattable, options?: VideoFormattingJSONOptions): Video {
|
|
return videoModelToFormattedJSON(this, options)
|
|
}
|
|
|
|
toFormattedDetailsJSON (this: MVideoFormattableDetails): VideoDetails {
|
|
return videoModelToFormattedDetailsJSON(this)
|
|
}
|
|
|
|
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)) {
|
|
files = files.concat(this.getFormattedWebVideoFilesJSON(includeMagnet))
|
|
}
|
|
|
|
if (Array.isArray(this.VideoStreamingPlaylists)) {
|
|
files = files.concat(this.getFormattedHLSVideoFilesJSON(includeMagnet))
|
|
}
|
|
|
|
return files
|
|
}
|
|
|
|
toActivityPubObject (this: MVideoAP): Promise<VideoObject> {
|
|
return Hooks.wrapObject(
|
|
videoModelToActivityPubObject(this),
|
|
'filter:activity-pub.video.json-ld.build.result',
|
|
{ video: this }
|
|
)
|
|
}
|
|
|
|
async lightAPToFullAP (this: MVideoAPLight, transaction: Transaction): Promise<MVideoAP> {
|
|
const videoAP = this as MVideoAP
|
|
|
|
const getCaptions = () => {
|
|
if (isArray(videoAP.VideoCaptions)) return videoAP.VideoCaptions
|
|
|
|
return this.$get('VideoCaptions', {
|
|
attributes: [ 'filename', 'language', 'fileUrl' ],
|
|
transaction
|
|
}) as Promise<MVideoCaptionLanguageUrl[]>
|
|
}
|
|
|
|
const getStoryboard = () => {
|
|
if (videoAP.Storyboard) return videoAP.Storyboard
|
|
|
|
return this.$get('Storyboard', { transaction }) as Promise<MStoryboard>
|
|
}
|
|
|
|
const [ captions, storyboard ] = await Promise.all([ getCaptions(), getStoryboard() ])
|
|
|
|
return Object.assign(this, {
|
|
VideoCaptions: captions,
|
|
Storyboard: storyboard
|
|
})
|
|
}
|
|
|
|
getTruncatedDescription () {
|
|
if (!this.description) return null
|
|
|
|
const maxLength = CONSTRAINTS_FIELDS.VIDEOS.TRUNCATED_DESCRIPTION.max
|
|
return peertubeTruncate(this.description, { length: maxLength })
|
|
}
|
|
|
|
getAllFiles () {
|
|
let files: MVideoFile[] = []
|
|
|
|
if (Array.isArray(this.VideoFiles)) {
|
|
files = files.concat(this.VideoFiles)
|
|
}
|
|
|
|
if (Array.isArray(this.VideoStreamingPlaylists)) {
|
|
for (const p of this.VideoStreamingPlaylists) {
|
|
if (Array.isArray(p.VideoFiles)) {
|
|
files = files.concat(p.VideoFiles)
|
|
}
|
|
}
|
|
}
|
|
|
|
return files
|
|
}
|
|
|
|
probeMaxQualityFile () {
|
|
const file = this.getMaxQualityFile()
|
|
const videoOrPlaylist = file.getVideoOrStreamingPlaylist()
|
|
|
|
return VideoPathManager.Instance.makeAvailableVideoFile(file.withVideoOrPlaylist(videoOrPlaylist), async originalFilePath => {
|
|
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)
|
|
}
|
|
})
|
|
}
|
|
|
|
getDescriptionAPIPath () {
|
|
return `/api/${API_VERSION}/videos/${this.uuid}/description`
|
|
}
|
|
|
|
getHLSPlaylist (): MStreamingPlaylistFilesVideo {
|
|
if (!this.VideoStreamingPlaylists) return undefined
|
|
|
|
const playlist = this.VideoStreamingPlaylists.find(p => p.type === VideoStreamingPlaylistType.HLS)
|
|
if (!playlist) return undefined
|
|
|
|
return playlist.withVideo(this)
|
|
}
|
|
|
|
setHLSPlaylist (playlist: MStreamingPlaylist) {
|
|
const toAdd = [ playlist ] as [ VideoStreamingPlaylistModel ]
|
|
|
|
if (Array.isArray(this.VideoStreamingPlaylists) === false || this.VideoStreamingPlaylists.length === 0) {
|
|
this.VideoStreamingPlaylists = toAdd
|
|
return
|
|
}
|
|
|
|
this.VideoStreamingPlaylists = this.VideoStreamingPlaylists
|
|
.filter(s => s.type !== VideoStreamingPlaylistType.HLS)
|
|
.concat(toAdd)
|
|
}
|
|
|
|
removeWebVideoFile (videoFile: MVideoFile, isRedundancy = false) {
|
|
const filePath = isRedundancy
|
|
? VideoPathManager.Instance.getFSRedundancyVideoFilePath(this, videoFile)
|
|
: VideoPathManager.Instance.getFSVideoFileOutputPath(this, videoFile)
|
|
|
|
const promises: Promise<any>[] = [ remove(filePath) ]
|
|
if (!isRedundancy) promises.push(videoFile.removeTorrent())
|
|
|
|
if (videoFile.storage === VideoStorage.OBJECT_STORAGE) {
|
|
promises.push(removeWebVideoObjectStorage(videoFile))
|
|
}
|
|
|
|
return Promise.all(promises)
|
|
}
|
|
|
|
async removeStreamingPlaylistFiles (streamingPlaylist: MStreamingPlaylist, isRedundancy = false) {
|
|
const directoryPath = isRedundancy
|
|
? getHLSRedundancyDirectory(this)
|
|
: getHLSDirectory(this)
|
|
|
|
try {
|
|
await remove(directoryPath)
|
|
} catch (err) {
|
|
// If it's a live, ffmpeg may have added another file while fs-extra is removing the directory
|
|
// So wait a little bit and retry
|
|
if (err.code === 'ENOTEMPTY') {
|
|
await wait(1000)
|
|
await remove(directoryPath)
|
|
|
|
return
|
|
}
|
|
|
|
throw err
|
|
}
|
|
|
|
if (isRedundancy !== true) {
|
|
const streamingPlaylistWithFiles = streamingPlaylist as MStreamingPlaylistFilesVideo
|
|
streamingPlaylistWithFiles.Video = this
|
|
|
|
if (!Array.isArray(streamingPlaylistWithFiles.VideoFiles)) {
|
|
streamingPlaylistWithFiles.VideoFiles = await streamingPlaylistWithFiles.$get('VideoFiles')
|
|
}
|
|
|
|
// Remove physical files and torrents
|
|
await Promise.all(
|
|
streamingPlaylistWithFiles.VideoFiles.map(file => file.removeTorrent())
|
|
)
|
|
|
|
if (streamingPlaylist.storage === VideoStorage.OBJECT_STORAGE) {
|
|
await removeHLSObjectStorage(streamingPlaylist.withVideo(this))
|
|
}
|
|
}
|
|
}
|
|
|
|
async removeStreamingPlaylistVideoFile (streamingPlaylist: MStreamingPlaylist, videoFile: MVideoFile) {
|
|
const filePath = VideoPathManager.Instance.getFSHLSOutputPath(this, videoFile.filename)
|
|
await videoFile.removeTorrent()
|
|
await remove(filePath)
|
|
|
|
const resolutionFilename = getHlsResolutionPlaylistFilename(videoFile.filename)
|
|
await remove(VideoPathManager.Instance.getFSHLSOutputPath(this, resolutionFilename))
|
|
|
|
if (videoFile.storage === VideoStorage.OBJECT_STORAGE) {
|
|
await removeHLSFileObjectStorageByFilename(streamingPlaylist.withVideo(this), videoFile.filename)
|
|
await removeHLSFileObjectStorageByFilename(streamingPlaylist.withVideo(this), resolutionFilename)
|
|
}
|
|
}
|
|
|
|
async removeStreamingPlaylistFile (streamingPlaylist: MStreamingPlaylist, filename: string) {
|
|
const filePath = VideoPathManager.Instance.getFSHLSOutputPath(this, filename)
|
|
await remove(filePath)
|
|
|
|
if (streamingPlaylist.storage === VideoStorage.OBJECT_STORAGE) {
|
|
await removeHLSFileObjectStorageByFilename(streamingPlaylist.withVideo(this), filename)
|
|
}
|
|
}
|
|
|
|
isOutdated () {
|
|
if (this.isOwned()) return false
|
|
|
|
return isOutdated(this, ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL)
|
|
}
|
|
|
|
hasPrivacyForFederation () {
|
|
return isPrivacyForFederation(this.privacy)
|
|
}
|
|
|
|
hasStateForFederation () {
|
|
return isStateForFederation(this.state)
|
|
}
|
|
|
|
isNewVideo (newPrivacy: VideoPrivacyType) {
|
|
return this.hasPrivacyForFederation() === false && isPrivacyForFederation(newPrivacy) === true
|
|
}
|
|
|
|
setAsRefreshed (transaction?: Transaction) {
|
|
return setAsUpdated({ sequelize: this.sequelize, table: 'video', id: this.id, transaction })
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
requiresUserAuth (options: {
|
|
urlParamId: string
|
|
checkBlacklist: boolean
|
|
}) {
|
|
const { urlParamId, checkBlacklist } = options
|
|
|
|
if (this.privacy === VideoPrivacy.PRIVATE || this.privacy === VideoPrivacy.INTERNAL) {
|
|
return true
|
|
}
|
|
|
|
if (this.privacy === VideoPrivacy.UNLISTED) {
|
|
if (urlParamId && !isUUIDValid(urlParamId)) return true
|
|
|
|
return false
|
|
}
|
|
|
|
if (checkBlacklist && this.VideoBlacklist) return true
|
|
|
|
if (this.privacy === VideoPrivacy.PUBLIC || this.privacy === VideoPrivacy.PASSWORD_PROTECTED) {
|
|
return false
|
|
}
|
|
|
|
throw new Error(`Unknown video privacy ${this.privacy} to know if the video requires auth`)
|
|
}
|
|
|
|
hasPrivateStaticPath () {
|
|
return isVideoInPrivateDirectory(this.privacy)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
async setNewState (newState: VideoStateType, isNewVideo: boolean, transaction: Transaction) {
|
|
if (this.state === newState) throw new Error('Cannot use same state ' + newState)
|
|
|
|
this.state = newState
|
|
|
|
if (this.state === VideoState.PUBLISHED && isNewVideo) {
|
|
this.publishedAt = new Date()
|
|
}
|
|
|
|
await this.save({ transaction })
|
|
}
|
|
|
|
getBandwidthBits (this: MVideo, videoFile: MVideoFile) {
|
|
if (!this.duration) return videoFile.size
|
|
|
|
return Math.ceil((videoFile.size * 8) / this.duration)
|
|
}
|
|
|
|
getTrackerUrls () {
|
|
if (this.isOwned()) {
|
|
return [
|
|
WEBSERVER.URL + '/tracker/announce',
|
|
WEBSERVER.WS + '://' + WEBSERVER.HOSTNAME + ':' + WEBSERVER.PORT + '/tracker/socket'
|
|
]
|
|
}
|
|
|
|
return this.Trackers.map(t => t.url)
|
|
}
|
|
}
|