PeerTube/server/models/video/video.ts

1440 lines
38 KiB
TypeScript
Raw Normal View History

2017-11-23 19:36:15 +03:00
import * as Bluebird from 'bluebird'
2018-03-28 12:00:02 +03:00
import { map, maxBy } from 'lodash'
2017-11-10 19:27:49 +03:00
import * as magnetUtil from 'magnet-uri'
2017-06-05 22:53:49 +03:00
import * as parseTorrent from 'parse-torrent'
import { extname, join } from 'path'
2017-05-22 21:58:25 +03:00
import * as Sequelize from 'sequelize'
2017-12-12 19:53:50 +03:00
import {
AllowNull,
BeforeDestroy,
BelongsTo,
BelongsToMany,
Column,
CreatedAt,
DataType,
Default,
ForeignKey,
HasMany,
IFindOptions,
Is,
IsInt,
IsUUID,
Min,
Model,
Scopes,
Table,
UpdatedAt
2017-12-12 19:53:50 +03:00
} from 'sequelize-typescript'
2017-11-10 19:27:49 +03:00
import { VideoPrivacy, VideoResolution } from '../../../shared'
2017-12-12 19:53:50 +03:00
import { VideoTorrentObject } from '../../../shared/models/activitypub/objects'
import { Video, VideoDetails, VideoFile } from '../../../shared/models/videos'
2018-03-13 12:24:28 +03:00
import { VideoFilter } from '../../../shared/models/videos/video-query.type'
2018-03-28 12:00:02 +03:00
import {
copyFilePromise,
2018-05-25 09:38:59 +03:00
createTorrentPromise,
peertubeTruncate,
renamePromise,
statPromise,
unlinkPromise,
2018-03-28 12:00:02 +03:00
writeFilePromise
} from '../../helpers/core-utils'
2017-12-28 13:16:08 +03:00
import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
2018-01-03 12:12:36 +03:00
import { isBooleanValid } from '../../helpers/custom-validators/misc'
2017-12-12 19:53:50 +03:00
import {
isVideoCategoryValid,
isVideoDescriptionValid,
isVideoDurationValid,
isVideoLanguageValid,
isVideoLicenceValid,
isVideoNameValid,
2018-03-12 13:06:15 +03:00
isVideoPrivacyValid,
isVideoSupportValid
2017-12-12 19:53:50 +03:00
} from '../../helpers/custom-validators/videos'
2018-02-27 17:57:28 +03:00
import { generateImageFromVideoFile, getVideoFileResolution, transcode } from '../../helpers/ffmpeg-utils'
2017-12-28 13:16:08 +03:00
import { logger } from '../../helpers/logger'
import { getServerActor } from '../../helpers/utils'
2017-05-15 23:22:03 +03:00
import {
API_VERSION,
CONFIG,
CONSTRAINTS_FIELDS,
PREVIEWS_SIZE,
REMOTE_SCHEME,
2018-05-29 19:30:11 +03:00
STATIC_DOWNLOAD_PATHS,
STATIC_PATHS,
THUMBNAILS_SIZE,
VIDEO_CATEGORIES,
VIDEO_EXT_MIMETYPE,
VIDEO_LANGUAGES,
VIDEO_LICENCES,
VIDEO_PRIVACIES
2017-12-12 19:53:50 +03:00
} from '../../initializers'
import {
getVideoCommentsActivityPubUrl,
getVideoDislikesActivityPubUrl,
getVideoLikesActivityPubUrl,
getVideoSharesActivityPubUrl
} from '../../lib/activitypub'
2017-12-14 19:38:41 +03:00
import { sendDeleteVideo } from '../../lib/activitypub/send'
2017-12-12 19:53:50 +03:00
import { AccountModel } from '../account/account'
import { AccountVideoRateModel } from '../account/account-video-rate'
2017-12-14 19:38:41 +03:00
import { ActorModel } from '../activitypub/actor'
2018-02-16 13:19:54 +03:00
import { AvatarModel } from '../avatar/avatar'
2017-12-12 19:53:50 +03:00
import { ServerModel } from '../server/server'
import { getSort, throwIfNotValid } from '../utils'
import { TagModel } from './tag'
import { VideoAbuseModel } from './video-abuse'
import { VideoChannelModel } from './video-channel'
2017-12-28 13:16:08 +03:00
import { VideoCommentModel } from './video-comment'
2017-12-12 19:53:50 +03:00
import { VideoFileModel } from './video-file'
import { VideoShareModel } from './video-share'
import { VideoTagModel } from './video-tag'
2017-12-14 12:07:57 +03:00
enum ScopeNames {
2017-12-14 19:38:41 +03:00
AVAILABLE_FOR_LIST = 'AVAILABLE_FOR_LIST',
2018-01-04 13:19:16 +03:00
WITH_ACCOUNT_DETAILS = 'WITH_ACCOUNT_DETAILS',
2017-12-14 12:07:57 +03:00
WITH_TAGS = 'WITH_TAGS',
WITH_FILES = 'WITH_FILES',
WITH_SHARES = 'WITH_SHARES',
2017-12-28 13:16:08 +03:00
WITH_RATES = 'WITH_RATES',
WITH_COMMENTS = 'WITH_COMMENTS'
2017-12-14 12:07:57 +03:00
}
@Scopes({
2018-04-24 18:05:32 +03:00
[ScopeNames.AVAILABLE_FOR_LIST]: (options: {
actorId: number,
hideNSFW: boolean,
filter?: VideoFilter,
withFiles?: boolean,
accountId?: number,
videoChannelId?: number
}) => {
2018-04-24 16:10:54 +03:00
const accountInclude = {
2018-04-25 15:32:19 +03:00
attributes: [ 'id', 'name' ],
2018-04-24 16:10:54 +03:00
model: AccountModel.unscoped(),
required: true,
where: {},
include: [
{
2018-04-25 15:32:19 +03:00
attributes: [ 'id', 'uuid', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
2018-04-24 16:10:54 +03:00
model: ActorModel.unscoped(),
required: true,
2018-04-24 18:05:32 +03:00
where: VideoModel.buildActorWhereWithFilter(options.filter),
2018-04-24 16:10:54 +03:00
include: [
{
attributes: [ 'host' ],
model: ServerModel.unscoped(),
required: false
},
{
model: AvatarModel.unscoped(),
required: false
}
]
}
]
}
2018-04-24 18:05:32 +03:00
const videoChannelInclude = {
2018-05-11 16:10:13 +03:00
attributes: [ 'name', 'description', 'id' ],
2018-04-24 18:05:32 +03:00
model: VideoChannelModel.unscoped(),
required: true,
where: {},
include: [
2018-05-11 16:10:13 +03:00
{
attributes: [ 'uuid', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
model: ActorModel.unscoped(),
required: true,
include: [
{
attributes: [ 'host' ],
model: ServerModel.unscoped(),
required: false
},
{
model: AvatarModel.unscoped(),
required: false
}
]
},
2018-04-24 18:05:32 +03:00
accountInclude
]
}
// Force actorId to be a number to avoid SQL injections
const actorIdNumber = parseInt(options.actorId.toString(), 10)
const query: IFindOptions<VideoModel> = {
where: {
id: {
[Sequelize.Op.notIn]: Sequelize.literal(
'(SELECT "videoBlacklist"."videoId" FROM "videoBlacklist")'
),
[ Sequelize.Op.in ]: Sequelize.literal(
'(' +
'SELECT "videoShare"."videoId" AS "id" FROM "videoShare" ' +
'INNER JOIN "actorFollow" ON "actorFollow"."targetActorId" = "videoShare"."actorId" ' +
2018-04-24 18:05:32 +03:00
'WHERE "actorFollow"."actorId" = ' + actorIdNumber +
' UNION ' +
'SELECT "video"."id" AS "id" FROM "video" ' +
'INNER JOIN "videoChannel" ON "videoChannel"."id" = "video"."channelId" ' +
'INNER JOIN "account" ON "account"."id" = "videoChannel"."accountId" ' +
'INNER JOIN "actor" ON "account"."actorId" = "actor"."id" ' +
'LEFT JOIN "actorFollow" ON "actorFollow"."targetActorId" = "actor"."id" ' +
2018-04-24 18:05:32 +03:00
'WHERE "actor"."serverId" IS NULL OR "actorFollow"."actorId" = ' + actorIdNumber +
')'
)
},
privacy: VideoPrivacy.PUBLIC
2017-12-14 19:38:41 +03:00
},
2018-04-24 18:05:32 +03:00
include: [ videoChannelInclude ]
}
2018-04-24 18:05:32 +03:00
if (options.withFiles === true) {
query.include.push({
model: VideoFileModel.unscoped(),
required: true
})
}
// Hide nsfw videos?
2018-04-24 18:05:32 +03:00
if (options.hideNSFW === true) {
query.where['nsfw'] = false
}
2018-04-24 18:05:32 +03:00
if (options.accountId) {
2018-04-24 16:10:54 +03:00
accountInclude.where = {
2018-04-24 18:05:32 +03:00
id: options.accountId
}
}
if (options.videoChannelId) {
videoChannelInclude.where = {
id: options.videoChannelId
2018-04-24 16:10:54 +03:00
}
}
return query
},
2018-01-04 13:19:16 +03:00
[ScopeNames.WITH_ACCOUNT_DETAILS]: {
2017-12-14 12:07:57 +03:00
include: [
{
2018-01-11 16:30:27 +03:00
model: () => VideoChannelModel.unscoped(),
2017-12-14 12:07:57 +03:00
required: true,
include: [
2018-01-11 16:30:27 +03:00
{
attributes: {
exclude: [ 'privateKey', 'publicKey' ]
},
2018-01-18 19:44:04 +03:00
model: () => ActorModel.unscoped(),
required: true,
include: [
{
attributes: [ 'host' ],
model: () => ServerModel.unscoped(),
required: false
}
]
2018-01-11 16:30:27 +03:00
},
2017-12-14 12:07:57 +03:00
{
2018-01-18 19:44:04 +03:00
model: () => AccountModel.unscoped(),
2017-12-14 12:07:57 +03:00
required: true,
include: [
{
2018-01-18 19:44:04 +03:00
model: () => ActorModel.unscoped(),
2018-01-11 16:30:27 +03:00
attributes: {
exclude: [ 'privateKey', 'publicKey' ]
},
2017-12-14 19:38:41 +03:00
required: true,
include: [
{
2018-01-18 19:44:04 +03:00
attributes: [ 'host' ],
model: () => ServerModel.unscoped(),
2017-12-14 19:38:41 +03:00
required: false
2018-02-16 13:19:54 +03:00
},
{
model: () => AvatarModel.unscoped(),
required: false
2017-12-14 19:38:41 +03:00
}
]
2017-12-14 12:07:57 +03:00
}
]
}
]
}
]
},
[ScopeNames.WITH_TAGS]: {
include: [ () => TagModel ]
},
[ScopeNames.WITH_FILES]: {
include: [
{
model: () => VideoFileModel.unscoped(),
2017-12-14 12:07:57 +03:00
required: true
}
]
},
[ScopeNames.WITH_SHARES]: {
include: [
{
['separate' as any]: true,
model: () => VideoShareModel.unscoped()
2017-12-14 12:07:57 +03:00
}
]
},
[ScopeNames.WITH_RATES]: {
include: [
{
['separate' as any]: true,
2017-12-14 12:07:57 +03:00
model: () => AccountVideoRateModel,
include: [
{
model: () => AccountModel.unscoped(),
required: true,
include: [
{
attributes: [ 'url' ],
model: () => ActorModel.unscoped()
}
]
}
]
2017-12-14 12:07:57 +03:00
}
]
2017-12-28 13:16:08 +03:00
},
[ScopeNames.WITH_COMMENTS]: {
include: [
{
['separate' as any]: true,
model: () => VideoCommentModel.unscoped()
2017-12-28 13:16:08 +03:00
}
]
2017-12-14 12:07:57 +03:00
}
})
2017-12-12 19:53:50 +03:00
@Table({
tableName: 'video',
indexes: [
2016-12-11 23:50:51 +03:00
{
2017-12-12 19:53:50 +03:00
fields: [ 'name' ]
2016-12-11 23:50:51 +03:00
},
{
2017-12-12 19:53:50 +03:00
fields: [ 'createdAt' ]
},
{
fields: [ 'duration' ]
},
{
fields: [ 'views' ]
},
{
fields: [ 'likes' ]
},
{
fields: [ 'uuid' ]
},
{
fields: [ 'channelId' ]
2018-01-04 13:19:16 +03:00
},
{
fields: [ 'id', 'privacy' ]
2018-01-10 19:18:12 +03:00
},
{
fields: [ 'url'],
unique: true
2016-12-11 23:50:51 +03:00
}
2017-05-22 21:58:25 +03:00
]
2017-12-12 19:53:50 +03:00
})
export class VideoModel extends Model<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)
@Is('VideoCategory', value => throwIfNotValid(value, isVideoCategoryValid, 'category'))
@Column
category: number
@AllowNull(true)
@Default(null)
@Is('VideoLicence', value => throwIfNotValid(value, isVideoLicenceValid, 'licence'))
@Column
licence: number
@AllowNull(true)
@Default(null)
@Is('VideoLanguage', value => throwIfNotValid(value, isVideoLanguageValid, 'language'))
2018-04-23 15:39:52 +03:00
@Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.LANGUAGE.max))
language: string
2017-12-12 19:53:50 +03:00
@AllowNull(false)
@Is('VideoPrivacy', value => throwIfNotValid(value, isVideoPrivacyValid, 'privacy'))
@Column
privacy: number
@AllowNull(false)
2018-01-03 12:12:36 +03:00
@Is('VideoNSFW', value => throwIfNotValid(value, isBooleanValid, 'NSFW boolean'))
2017-12-12 19:53:50 +03:00
@Column
nsfw: boolean
@AllowNull(true)
@Default(null)
@Is('VideoDescription', value => throwIfNotValid(value, isVideoDescriptionValid, 'description'))
@Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.DESCRIPTION.max))
description: string
@AllowNull(true)
@Default(null)
@Is('VideoSupport', value => throwIfNotValid(value, isVideoSupportValid, 'support'))
@Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.SUPPORT.max))
support: string
2017-12-12 19:53:50 +03:00
@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)
@Is('VideoUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
@Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.URL.max))
url: string
2018-01-03 12:12:36 +03:00
@AllowNull(false)
@Column
commentsEnabled: boolean
2017-12-12 19:53:50 +03:00
@CreatedAt
createdAt: Date
@UpdatedAt
updatedAt: Date
@AllowNull(false)
@Default(Sequelize.NOW)
@Column
publishedAt: Date
2017-12-12 19:53:50 +03:00
@ForeignKey(() => VideoChannelModel)
@Column
channelId: number
@BelongsTo(() => VideoChannelModel, {
2016-12-11 23:50:51 +03:00
foreignKey: {
2017-12-14 19:38:41 +03:00
allowNull: true
2016-12-11 23:50:51 +03:00
},
2018-04-25 11:21:38 +03:00
hooks: true
2016-12-11 23:50:51 +03:00
})
2017-12-12 19:53:50 +03:00
VideoChannel: VideoChannelModel
2016-12-24 18:59:17 +03:00
2017-12-12 19:53:50 +03:00
@BelongsToMany(() => TagModel, {
2016-12-24 18:59:17 +03:00
foreignKey: 'videoId',
2017-12-12 19:53:50 +03:00
through: () => VideoTagModel,
onDelete: 'CASCADE'
2016-12-24 18:59:17 +03:00
})
2017-12-12 19:53:50 +03:00
Tags: TagModel[]
2017-01-04 22:59:23 +03:00
2017-12-12 19:53:50 +03:00
@HasMany(() => VideoAbuseModel, {
2017-01-04 22:59:23 +03:00
foreignKey: {
name: 'videoId',
allowNull: false
},
onDelete: 'cascade'
})
2017-12-12 19:53:50 +03:00
VideoAbuses: VideoAbuseModel[]
2017-12-12 19:53:50 +03:00
@HasMany(() => VideoFileModel, {
foreignKey: {
name: 'videoId',
allowNull: false
},
onDelete: 'cascade'
})
2017-12-12 19:53:50 +03:00
VideoFiles: VideoFileModel[]
2017-11-21 20:23:10 +03:00
2017-12-12 19:53:50 +03:00
@HasMany(() => VideoShareModel, {
2017-11-21 20:23:10 +03:00
foreignKey: {
name: 'videoId',
allowNull: false
},
onDelete: 'cascade'
})
2017-12-12 19:53:50 +03:00
VideoShares: VideoShareModel[]
2017-11-23 18:55:13 +03:00
2017-12-12 19:53:50 +03:00
@HasMany(() => AccountVideoRateModel, {
2017-11-23 18:55:13 +03:00
foreignKey: {
name: 'videoId',
allowNull: false
},
onDelete: 'cascade'
})
2017-12-12 19:53:50 +03:00
AccountVideoRates: AccountVideoRateModel[]
2016-11-11 17:20:03 +03:00
2017-12-28 13:16:08 +03:00
@HasMany(() => VideoCommentModel, {
foreignKey: {
name: 'videoId',
allowNull: false
},
onDelete: 'cascade',
hooks: true
2017-12-28 13:16:08 +03:00
})
VideoComments: VideoCommentModel[]
@BeforeDestroy
static async sendDelete (instance: VideoModel, options) {
if (instance.isOwned()) {
if (!instance.VideoChannel) {
instance.VideoChannel = await instance.$get('VideoChannel', {
include: [
{
model: AccountModel,
include: [ ActorModel ]
}
],
transaction: options.transaction
}) as VideoChannelModel
}
logger.debug('Sending delete of video %s.', instance.url)
return sendDeleteVideo(instance, options.transaction)
}
return undefined
}
2018-04-25 11:21:38 +03:00
@BeforeDestroy
static async removeFilesAndSendDelete (instance: VideoModel) {
const tasks: Promise<any>[] = []
2016-11-11 17:20:03 +03:00
2018-04-25 11:21:38 +03:00
logger.debug('Removing files of video %s.', instance.url)
tasks.push(instance.removeThumbnail())
2017-12-12 19:53:50 +03:00
if (instance.isOwned()) {
if (!Array.isArray(instance.VideoFiles)) {
instance.VideoFiles = await instance.$get('VideoFiles') as VideoFileModel[]
}
tasks.push(instance.removePreview())
2017-12-12 19:53:50 +03:00
// Remove physical files and torrents
instance.VideoFiles.forEach(file => {
tasks.push(instance.removeFile(file))
tasks.push(instance.removeTorrent(file))
})
}
2018-04-25 11:21:38 +03:00
// Do not wait video deletion because we could be in a transaction
Promise.all(tasks)
2017-12-12 19:53:50 +03:00
.catch(err => {
2018-03-26 16:54:13 +03:00
logger.error('Some errors when removing files of video %s in after destroy hook.', instance.uuid, { err })
2017-12-12 19:53:50 +03:00
})
2018-04-25 11:21:38 +03:00
return undefined
2017-12-12 19:53:50 +03:00
}
2016-11-11 17:20:03 +03:00
2017-12-12 19:53:50 +03:00
static list () {
2017-12-14 12:07:57 +03:00
return VideoModel.scope(ScopeNames.WITH_FILES).findAll()
2017-12-12 19:53:50 +03:00
}
2016-11-11 17:20:03 +03:00
2017-12-14 19:38:41 +03:00
static listAllAndSharedByActorForOutbox (actorId: number, start: number, count: number) {
2017-12-12 19:53:50 +03:00
function getRawQuery (select: string) {
const queryVideo = 'SELECT ' + select + ' FROM "video" AS "Video" ' +
'INNER JOIN "videoChannel" AS "VideoChannel" ON "VideoChannel"."id" = "Video"."channelId" ' +
2017-12-14 19:38:41 +03:00
'INNER JOIN "account" AS "Account" ON "Account"."id" = "VideoChannel"."accountId" ' +
'WHERE "Account"."actorId" = ' + actorId
2017-12-12 19:53:50 +03:00
const queryVideoShare = 'SELECT ' + select + ' FROM "videoShare" AS "VideoShare" ' +
'INNER JOIN "video" AS "Video" ON "Video"."id" = "VideoShare"."videoId" ' +
2017-12-14 19:38:41 +03:00
'WHERE "VideoShare"."actorId" = ' + actorId
2017-12-12 19:53:50 +03:00
return `(${queryVideo}) UNION (${queryVideoShare})`
}
2017-12-12 19:53:50 +03:00
const rawQuery = getRawQuery('"Video"."id"')
const rawCountQuery = getRawQuery('COUNT("Video"."id") as "total"')
const query = {
distinct: true,
offset: start,
limit: count,
2018-02-19 11:41:03 +03:00
order: getSort('createdAt', [ 'Tags', 'name', 'ASC' ]),
2017-12-12 19:53:50 +03:00
where: {
id: {
[Sequelize.Op.in]: Sequelize.literal('(' + rawQuery + ')')
},
[Sequelize.Op.or]: [
{ privacy: VideoPrivacy.PUBLIC },
{ privacy: VideoPrivacy.UNLISTED }
]
2017-12-12 19:53:50 +03:00
},
include: [
{
attributes: [ 'id', 'url' ],
model: VideoShareModel.unscoped(),
2017-12-12 19:53:50 +03:00
required: false,
2018-05-28 13:13:00 +03:00
// We only want videos shared by this actor
where: {
[Sequelize.Op.and]: [
{
id: {
[Sequelize.Op.not]: null
}
},
{
actorId
}
]
},
2017-12-14 19:38:41 +03:00
include: [
{
attributes: [ 'id', 'url' ],
model: ActorModel.unscoped()
2017-12-14 19:38:41 +03:00
}
]
2017-12-12 19:53:50 +03:00
},
{
model: VideoChannelModel.unscoped(),
2017-12-12 19:53:50 +03:00
required: true,
include: [
{
attributes: [ 'name' ],
model: AccountModel.unscoped(),
required: true,
include: [
{
2018-05-28 13:13:00 +03:00
attributes: [ 'id', 'url', 'followersUrl' ],
model: ActorModel.unscoped(),
required: true
}
]
},
{
2018-05-28 13:13:00 +03:00
attributes: [ 'id', 'url', 'followersUrl' ],
model: ActorModel.unscoped(),
2017-12-12 19:53:50 +03:00
required: true
}
]
},
VideoFileModel,
TagModel
2017-12-12 19:53:50 +03:00
]
}
2017-12-12 19:53:50 +03:00
return Bluebird.all([
// FIXME: typing issue
VideoModel.findAll(query as any),
VideoModel.sequelize.query(rawCountQuery, { type: Sequelize.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 listAccountVideosForApi (accountId: number, start: number, count: number, sort: string, hideNSFW: boolean, withFiles = false) {
const query: IFindOptions<VideoModel> = {
2017-12-12 19:53:50 +03:00
offset: start,
limit: count,
2018-02-19 11:41:03 +03:00
order: getSort(sort),
2017-12-12 19:53:50 +03:00
include: [
{
model: VideoChannelModel,
required: true,
include: [
{
model: AccountModel,
where: {
2018-04-17 11:56:27 +03:00
id: accountId
2017-12-12 19:53:50 +03:00
},
required: true
}
]
2017-12-14 12:07:57 +03:00
}
2017-12-12 19:53:50 +03:00
]
}
2017-10-16 11:05:49 +03:00
if (withFiles === true) {
query.include.push({
model: VideoFileModel.unscoped(),
required: true
})
}
if (hideNSFW === true) {
query.where = {
nsfw: false
}
}
2017-12-12 19:53:50 +03:00
return VideoModel.findAndCountAll(query).then(({ rows, count }) => {
return {
data: rows,
total: count
}
})
}
2018-04-24 18:05:32 +03:00
static async listForApi (options: {
2018-04-24 16:10:54 +03:00
start: number,
count: number,
sort: string,
hideNSFW: boolean,
2018-04-24 18:05:32 +03:00
withFiles: boolean,
2018-04-24 16:10:54 +03:00
filter?: VideoFilter,
2018-04-24 18:05:32 +03:00
accountId?: number,
videoChannelId?: number
}) {
2017-12-12 19:53:50 +03:00
const query = {
2018-04-24 18:05:32 +03:00
offset: options.start,
limit: options.count,
order: getSort(options.sort)
2017-12-12 19:53:50 +03:00
}
const serverActor = await getServerActor()
2018-04-24 18:05:32 +03:00
const scopes = {
method: [
ScopeNames.AVAILABLE_FOR_LIST, {
actorId: serverActor.id,
hideNSFW: options.hideNSFW,
filter: options.filter,
withFiles: options.withFiles,
accountId: options.accountId,
videoChannelId: options.videoChannelId
}
]
}
return VideoModel.scope(scopes)
2017-12-14 12:07:57 +03:00
.findAndCountAll(query)
.then(({ rows, count }) => {
return {
data: rows,
total: count
}
})
}
static async searchAndPopulateAccountAndServer (value: string, start: number, count: number, sort: string, hideNSFW: boolean) {
const query: IFindOptions<VideoModel> = {
offset: start,
limit: count,
2018-02-19 11:41:03 +03:00
order: getSort(sort),
where: {
[Sequelize.Op.or]: [
{
name: {
[ Sequelize.Op.iLike ]: '%' + value + '%'
}
},
{
2018-05-11 16:10:13 +03:00
preferredUsernameChannel: Sequelize.where(Sequelize.col('VideoChannel->Actor.preferredUsername'), {
[ Sequelize.Op.iLike ]: '%' + value + '%'
})
},
{
2018-05-11 16:10:13 +03:00
preferredUsernameAccount: Sequelize.where(Sequelize.col('VideoChannel->Account->Actor.preferredUsername'), {
[ Sequelize.Op.iLike ]: '%' + value + '%'
})
},
{
host: Sequelize.where(Sequelize.col('VideoChannel->Account->Actor->Server.host'), {
[ Sequelize.Op.iLike ]: '%' + value + '%'
})
}
]
}
}
const serverActor = await getServerActor()
2018-04-24 18:05:32 +03:00
const scopes = {
method: [
ScopeNames.AVAILABLE_FOR_LIST, {
actorId: serverActor.id,
hideNSFW
}
]
}
2018-04-24 18:05:32 +03:00
return VideoModel.scope(scopes)
.findAndCountAll(query)
.then(({ rows, count }) => {
return {
data: rows,
total: count
}
})
}
2017-12-12 19:53:50 +03:00
static load (id: number) {
return VideoModel.findById(id)
}
2017-09-07 16:27:35 +03:00
2017-12-12 19:53:50 +03:00
static loadByUrlAndPopulateAccount (url: string, t?: Sequelize.Transaction) {
const query: IFindOptions<VideoModel> = {
where: {
url
2017-12-14 12:07:57 +03:00
}
2017-12-12 19:53:50 +03:00
}
2017-10-16 11:05:49 +03:00
2017-12-12 19:53:50 +03:00
if (t !== undefined) query.transaction = t
2017-10-16 11:05:49 +03:00
2018-01-04 13:19:16 +03:00
return VideoModel.scope([ ScopeNames.WITH_ACCOUNT_DETAILS, ScopeNames.WITH_FILES ]).findOne(query)
2017-12-12 19:53:50 +03:00
}
2017-10-16 11:05:49 +03:00
2018-01-10 19:18:12 +03:00
static loadByUUIDOrURLAndPopulateAccount (uuid: string, url: string, t?: Sequelize.Transaction) {
2017-12-12 19:53:50 +03:00
const query: IFindOptions<VideoModel> = {
where: {
[Sequelize.Op.or]: [
{ uuid },
{ url }
]
2017-12-14 12:07:57 +03:00
}
2017-12-12 19:53:50 +03:00
}
2016-12-11 23:50:51 +03:00
2017-12-12 19:53:50 +03:00
if (t !== undefined) query.transaction = t
2016-12-11 23:50:51 +03:00
2018-01-10 19:18:12 +03:00
return VideoModel.scope([ ScopeNames.WITH_ACCOUNT_DETAILS, ScopeNames.WITH_FILES ]).findOne(query)
2017-10-24 20:41:09 +03:00
}
2017-12-12 19:53:50 +03:00
static loadAndPopulateAccountAndServerAndTags (id: number) {
const options = {
2017-12-14 12:07:57 +03:00
order: [ [ 'Tags', 'name', 'ASC' ] ]
2017-12-12 19:53:50 +03:00
}
2017-10-24 20:41:09 +03:00
2017-12-14 12:07:57 +03:00
return VideoModel
2018-01-04 13:19:16 +03:00
.scope([ ScopeNames.WITH_TAGS, ScopeNames.WITH_FILES, ScopeNames.WITH_ACCOUNT_DETAILS ])
2017-12-14 12:07:57 +03:00
.findById(id, options)
2017-12-12 19:53:50 +03:00
}
2017-10-24 20:41:09 +03:00
2017-12-20 13:05:10 +03:00
static loadByUUID (uuid: string) {
const options = {
where: {
uuid
}
}
return VideoModel
.scope([ ScopeNames.WITH_FILES ])
.findOne(options)
}
2017-12-12 19:53:50 +03:00
static loadByUUIDAndPopulateAccountAndServerAndTags (uuid: string) {
const options = {
order: [ [ 'Tags', 'name', 'ASC' ] ],
where: {
uuid
2017-12-14 12:07:57 +03:00
}
2017-12-12 19:53:50 +03:00
}
2017-10-31 13:52:52 +03:00
2017-12-14 12:07:57 +03:00
return VideoModel
2018-01-04 13:19:16 +03:00
.scope([ ScopeNames.WITH_TAGS, ScopeNames.WITH_FILES, ScopeNames.WITH_ACCOUNT_DETAILS ])
2017-12-28 13:16:08 +03:00
.findOne(options)
}
2018-02-28 20:04:46 +03:00
static async getStats () {
const totalLocalVideos = await VideoModel.count({
where: {
remote: false
}
})
const totalVideos = await VideoModel.count()
let totalLocalVideoViews = await VideoModel.sum('views', {
where: {
remote: false
}
})
// Sequelize could return null...
if (!totalLocalVideoViews) totalLocalVideoViews = 0
return {
totalLocalVideos,
totalLocalVideoViews,
totalVideos
}
}
2018-03-13 12:24:28 +03:00
private static buildActorWhereWithFilter (filter?: VideoFilter) {
if (filter && filter === 'local') {
return {
serverId: null
}
}
return {}
}
2018-03-19 12:24:12 +03:00
private static getCategoryLabel (id: number) {
let categoryLabel = VIDEO_CATEGORIES[id]
if (!categoryLabel) categoryLabel = 'Misc'
return categoryLabel
}
private static getLicenceLabel (id: number) {
let licenceLabel = VIDEO_LICENCES[id]
if (!licenceLabel) licenceLabel = 'Unknown'
return licenceLabel
}
2018-04-23 15:39:52 +03:00
private static getLanguageLabel (id: string) {
2018-03-19 12:24:12 +03:00
let languageLabel = VIDEO_LANGUAGES[id]
if (!languageLabel) languageLabel = 'Unknown'
return languageLabel
}
private static getPrivacyLabel (id: number) {
let privacyLabel = VIDEO_PRIVACIES[id]
if (!privacyLabel) privacyLabel = 'Unknown'
return privacyLabel
}
2017-12-12 19:53:50 +03:00
getOriginalFile () {
if (Array.isArray(this.VideoFiles) === false) return undefined
2017-12-12 19:53:50 +03:00
// The original file is the file that have the higher resolution
return maxBy(this.VideoFiles, file => file.resolution)
2017-11-09 19:51:58 +03:00
}
2017-12-12 19:53:50 +03:00
getVideoFilename (videoFile: VideoFileModel) {
return this.uuid + '-' + videoFile.resolution + videoFile.extname
}
2017-12-12 19:53:50 +03:00
getThumbnailName () {
// We always have a copy of the thumbnail
const extension = '.jpg'
return this.uuid + extension
2016-12-29 21:07:05 +03:00
}
2017-12-12 19:53:50 +03:00
getPreviewName () {
const extension = '.jpg'
return this.uuid + extension
}
2016-12-29 21:07:05 +03:00
2017-12-12 19:53:50 +03:00
getTorrentFileName (videoFile: VideoFileModel) {
const extension = '.torrent'
return this.uuid + '-' + videoFile.resolution + extension
}
2017-12-12 19:53:50 +03:00
isOwned () {
return this.remote === false
2017-10-30 12:16:27 +03:00
}
2017-12-12 19:53:50 +03:00
createPreview (videoFile: VideoFileModel) {
return generateImageFromVideoFile(
this.getVideoFilePath(videoFile),
CONFIG.STORAGE.PREVIEWS_DIR,
this.getPreviewName(),
2018-02-27 13:29:24 +03:00
PREVIEWS_SIZE
2017-12-12 19:53:50 +03:00
)
}
2017-10-30 12:16:27 +03:00
2017-12-12 19:53:50 +03:00
createThumbnail (videoFile: VideoFileModel) {
return generateImageFromVideoFile(
this.getVideoFilePath(videoFile),
CONFIG.STORAGE.THUMBNAILS_DIR,
this.getThumbnailName(),
2018-02-27 13:29:24 +03:00
THUMBNAILS_SIZE
2017-12-12 19:53:50 +03:00
)
}
2018-05-29 19:30:11 +03:00
getTorrentFilePath (videoFile: VideoFileModel) {
return join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
}
2017-12-12 19:53:50 +03:00
getVideoFilePath (videoFile: VideoFileModel) {
return join(CONFIG.STORAGE.VIDEOS_DIR, this.getVideoFilename(videoFile))
}
2018-04-19 16:13:41 +03:00
async createTorrentAndSetInfoHash (videoFile: VideoFileModel) {
2017-12-12 19:53:50 +03:00
const options = {
2018-04-19 16:37:44 +03:00
// Keep the extname, it's used by the client to stream the file inside a web browser
name: `${this.name} ${videoFile.resolution}p${videoFile.extname}`,
2018-04-19 16:13:41 +03:00
createdBy: 'PeerTube',
2017-12-12 19:53:50 +03:00
announceList: [
2018-01-19 10:44:30 +03:00
[ CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT + '/tracker/socket' ],
[ CONFIG.WEBSERVER.URL + '/tracker/announce' ]
2017-12-12 19:53:50 +03:00
],
urlList: [
CONFIG.WEBSERVER.URL + STATIC_PATHS.WEBSEED + this.getVideoFilename(videoFile)
]
}
2017-12-12 19:53:50 +03:00
const torrent = await createTorrentPromise(this.getVideoFilePath(videoFile), options)
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
const filePath = join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
logger.info('Creating torrent %s.', filePath)
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
await writeFilePromise(filePath, torrent)
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
const parsedTorrent = parseTorrent(torrent)
videoFile.infoHash = parsedTorrent.infoHash
}
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
getEmbedPath () {
return '/videos/embed/' + this.uuid
}
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
getThumbnailPath () {
return join(STATIC_PATHS.THUMBNAILS, this.getThumbnailName())
2017-11-09 19:51:58 +03:00
}
2017-12-12 19:53:50 +03:00
getPreviewPath () {
return join(STATIC_PATHS.PREVIEWS, this.getPreviewName())
}
toFormattedJSON (): Video {
2018-03-12 13:06:15 +03:00
const formattedAccount = this.VideoChannel.Account.toFormattedJSON()
2018-05-11 16:10:13 +03:00
const formattedVideoChannel = this.VideoChannel.toFormattedJSON()
2017-12-12 19:53:50 +03:00
return {
id: this.id,
uuid: this.uuid,
name: this.name,
2018-03-19 12:24:12 +03:00
category: {
id: this.category,
label: VideoModel.getCategoryLabel(this.category)
},
licence: {
id: this.licence,
label: VideoModel.getLicenceLabel(this.licence)
},
language: {
id: this.language,
label: VideoModel.getLanguageLabel(this.language)
},
privacy: {
id: this.privacy,
label: VideoModel.getPrivacyLabel(this.privacy)
},
2017-12-12 19:53:50 +03:00
nsfw: this.nsfw,
description: this.getTruncatedDescription(),
isLocal: this.isOwned(),
duration: this.duration,
views: this.views,
likes: this.likes,
dislikes: this.dislikes,
thumbnailPath: this.getThumbnailPath(),
previewPath: this.getPreviewPath(),
embedPath: this.getEmbedPath(),
createdAt: this.createdAt,
2018-03-12 13:06:15 +03:00
updatedAt: this.updatedAt,
publishedAt: this.publishedAt,
2018-03-12 13:06:15 +03:00
account: {
2018-04-25 15:32:19 +03:00
id: formattedAccount.id,
uuid: formattedAccount.uuid,
2018-03-12 13:06:15 +03:00
name: formattedAccount.name,
displayName: formattedAccount.displayName,
url: formattedAccount.url,
host: formattedAccount.host,
avatar: formattedAccount.avatar
2018-05-11 16:10:13 +03:00
},
channel: {
id: formattedVideoChannel.id,
uuid: formattedVideoChannel.uuid,
name: formattedVideoChannel.name,
displayName: formattedVideoChannel.displayName,
url: formattedVideoChannel.url,
host: formattedVideoChannel.host,
avatar: formattedVideoChannel.avatar
2018-03-12 13:06:15 +03:00
}
}
}
toFormattedDetailsJSON (): VideoDetails {
2017-12-12 19:53:50 +03:00
const formattedJson = this.toFormattedJSON()
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
const detailsJson = {
support: this.support,
2017-12-12 19:53:50 +03:00
descriptionPath: this.getDescriptionPath(),
channel: this.VideoChannel.toFormattedJSON(),
account: this.VideoChannel.Account.toFormattedJSON(),
2018-04-06 12:54:24 +03:00
tags: map(this.Tags, 'name'),
2018-01-03 12:12:36 +03:00
commentsEnabled: this.commentsEnabled,
2017-12-12 19:53:50 +03:00
files: []
}
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
// Format and sort video files
detailsJson.files = this.getFormattedVideoFilesJSON()
return Object.assign(formattedJson, detailsJson)
}
getFormattedVideoFilesJSON (): VideoFile[] {
2017-12-12 19:53:50 +03:00
const { baseUrlHttp, baseUrlWs } = this.getBaseUrls()
return this.VideoFiles
.map(videoFile => {
let resolutionLabel = videoFile.resolution + 'p'
2017-12-12 19:53:50 +03:00
return {
resolution: {
id: videoFile.resolution,
label: resolutionLabel
},
magnetUri: this.generateMagnetUri(videoFile, baseUrlHttp, baseUrlWs),
size: videoFile.size,
torrentUrl: this.getTorrentUrl(videoFile, baseUrlHttp),
2018-05-29 19:30:11 +03:00
torrentDownloadUrl: this.getTorrentDownloadUrl(videoFile, baseUrlHttp),
fileUrl: this.getVideoFileUrl(videoFile, baseUrlHttp),
fileDownloadUrl: this.getVideoFileDownloadUrl(videoFile, baseUrlHttp)
} as VideoFile
})
.sort((a, b) => {
if (a.resolution.id < b.resolution.id) return 1
if (a.resolution.id === b.resolution.id) return 0
return -1
})
2017-12-12 19:53:50 +03:00
}
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
toActivityPubObject (): VideoTorrentObject {
const { baseUrlHttp, baseUrlWs } = this.getBaseUrls()
if (!this.Tags) this.Tags = []
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
const tag = this.Tags.map(t => ({
type: 'Hashtag' as 'Hashtag',
name: t.name
}))
2017-12-12 19:53:50 +03:00
let language
if (this.language) {
language = {
2018-04-23 15:39:52 +03:00
identifier: this.language,
2018-03-19 12:24:12 +03:00
name: VideoModel.getLanguageLabel(this.language)
2017-12-12 19:53:50 +03:00
}
}
2017-12-12 19:53:50 +03:00
let category
if (this.category) {
category = {
identifier: this.category + '',
2018-03-19 12:24:12 +03:00
name: VideoModel.getCategoryLabel(this.category)
2017-12-12 19:53:50 +03:00
}
}
2017-12-12 19:53:50 +03:00
let licence
if (this.licence) {
licence = {
identifier: this.licence + '',
2018-03-19 12:24:12 +03:00
name: VideoModel.getLicenceLabel(this.licence)
2017-12-12 19:53:50 +03:00
}
}
2017-10-30 12:16:27 +03:00
2017-12-12 19:53:50 +03:00
const url = []
for (const file of this.VideoFiles) {
url.push({
type: 'Link',
mimeType: VIDEO_EXT_MIMETYPE[file.extname],
2018-01-12 17:35:30 +03:00
href: this.getVideoFileUrl(file, baseUrlHttp),
2017-12-12 19:53:50 +03:00
width: file.resolution,
size: file.size
})
url.push({
type: 'Link',
mimeType: 'application/x-bittorrent',
2018-01-12 17:35:30 +03:00
href: this.getTorrentUrl(file, baseUrlHttp),
2017-12-12 19:53:50 +03:00
width: file.resolution
})
url.push({
type: 'Link',
mimeType: 'application/x-bittorrent;x-scheme-handler/magnet',
2018-01-12 17:35:30 +03:00
href: this.generateMagnetUri(file, baseUrlHttp, baseUrlWs),
2017-12-12 19:53:50 +03:00
width: file.resolution
})
}
2017-12-12 19:53:50 +03:00
// Add video url too
url.push({
type: 'Link',
mimeType: 'text/html',
2018-01-12 17:35:30 +03:00
href: CONFIG.WEBSERVER.URL + '/videos/watch/' + this.uuid
2017-12-12 19:53:50 +03:00
})
2017-12-12 19:53:50 +03:00
return {
type: 'Video' as 'Video',
id: this.url,
name: this.name,
2018-01-23 19:09:06 +03:00
duration: this.getActivityStreamDuration(),
2017-12-12 19:53:50 +03:00
uuid: this.uuid,
tag,
category,
licence,
language,
views: this.views,
sensitive: this.nsfw,
2018-01-03 12:12:36 +03:00
commentsEnabled: this.commentsEnabled,
published: this.publishedAt.toISOString(),
2017-12-12 19:53:50 +03:00
updated: this.updatedAt.toISOString(),
mediaType: 'text/markdown',
content: this.getTruncatedDescription(),
support: this.support,
2017-12-12 19:53:50 +03:00
icon: {
type: 'Image',
url: this.getThumbnailUrl(baseUrlHttp),
mediaType: 'image/jpeg',
width: THUMBNAILS_SIZE.width,
height: THUMBNAILS_SIZE.height
},
url,
likes: getVideoLikesActivityPubUrl(this),
dislikes: getVideoDislikesActivityPubUrl(this),
shares: getVideoSharesActivityPubUrl(this),
comments: getVideoCommentsActivityPubUrl(this),
2017-12-14 19:38:41 +03:00
attributedTo: [
2018-01-10 19:18:12 +03:00
{
type: 'Person',
id: this.VideoChannel.Account.Actor.url
2018-03-27 14:40:30 +03:00
},
{
type: 'Group',
id: this.VideoChannel.Actor.url
2017-12-14 19:38:41 +03:00
}
]
2017-12-12 19:53:50 +03:00
}
}
getTruncatedDescription () {
if (!this.description) return null
const maxLength = CONSTRAINTS_FIELDS.VIDEOS.TRUNCATED_DESCRIPTION.max
2018-03-28 12:00:02 +03:00
return peertubeTruncate(this.description, maxLength)
}
2018-04-19 16:13:41 +03:00
async optimizeOriginalVideofile () {
2017-12-12 19:53:50 +03:00
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)
2016-12-25 11:44:57 +03:00
2017-12-12 19:53:50 +03:00
const transcodeOptions = {
inputPath: videoInputPath,
outputPath: videoOutputPath
}
// Could be very long!
await transcode(transcodeOptions)
try {
2017-12-12 19:53:50 +03:00
await unlinkPromise(videoInputPath)
2017-12-12 19:53:50 +03:00
// Important to do this before getVideoFilename() to take in account the new file extension
inputVideoFile.set('extname', newExtname)
2017-11-21 20:23:10 +03:00
2017-12-12 19:53:50 +03:00
await renamePromise(videoOutputPath, this.getVideoFilePath(inputVideoFile))
const stats = await statPromise(this.getVideoFilePath(inputVideoFile))
2017-11-21 20:23:10 +03:00
2017-12-12 19:53:50 +03:00
inputVideoFile.set('size', stats.size)
2017-11-21 20:23:10 +03:00
2017-12-12 19:53:50 +03:00
await this.createTorrentAndSetInfoHash(inputVideoFile)
await inputVideoFile.save()
2017-10-31 13:52:52 +03:00
2017-12-12 19:53:50 +03:00
} catch (err) {
// Auto destruction...
2018-03-26 16:54:13 +03:00
this.destroy().catch(err => logger.error('Cannot destruct video after transcoding failure.', { err }))
2017-10-31 13:52:52 +03:00
2017-12-12 19:53:50 +03:00
throw err
}
2016-12-11 23:50:51 +03:00
}
2018-04-19 16:13:41 +03:00
async transcodeOriginalVideofile (resolution: VideoResolution, isPortraitMode: boolean) {
2017-12-12 19:53:50 +03:00
const videosDirectory = CONFIG.STORAGE.VIDEOS_DIR
const extname = '.mp4'
2017-12-12 19:53:50 +03:00
// We are sure it's x264 in mp4 because optimizeOriginalVideofile was already executed
const videoInputPath = join(videosDirectory, this.getVideoFilename(this.getOriginalFile()))
2016-12-11 23:50:51 +03:00
2017-12-12 19:53:50 +03:00
const newVideoFile = new VideoFileModel({
resolution,
extname,
size: 0,
videoId: this.id
})
const videoOutputPath = join(videosDirectory, this.getVideoFilename(newVideoFile))
2017-12-12 19:53:50 +03:00
const transcodeOptions = {
inputPath: videoInputPath,
outputPath: videoOutputPath,
2018-02-27 17:57:28 +03:00
resolution,
isPortraitMode
2017-12-12 19:53:50 +03:00
}
2017-12-12 19:53:50 +03:00
await transcode(transcodeOptions)
2017-12-12 19:53:50 +03:00
const stats = await statPromise(videoOutputPath)
2017-11-16 17:55:01 +03:00
2017-12-12 19:53:50 +03:00
newVideoFile.set('size', stats.size)
2017-11-16 17:55:01 +03:00
2017-12-12 19:53:50 +03:00
await this.createTorrentAndSetInfoHash(newVideoFile)
2017-11-16 17:55:01 +03:00
2017-12-12 19:53:50 +03:00
await newVideoFile.save()
this.VideoFiles.push(newVideoFile)
2017-11-10 16:34:45 +03:00
}
async importVideoFile (inputFilePath: string) {
let updatedVideoFile = new VideoFileModel({
resolution: (await getVideoFileResolution(inputFilePath)).videoFileResolution,
extname: extname(inputFilePath),
size: (await statPromise(inputFilePath)).size,
videoId: this.id
})
const outputPath = this.getVideoFilePath(updatedVideoFile)
await copyFilePromise(inputFilePath, outputPath)
const currentVideoFile = this.VideoFiles.find(videoFile => videoFile.resolution === updatedVideoFile.resolution)
if (currentVideoFile) {
// Remove old file and old torrent
await this.removeFile(currentVideoFile)
await this.removeTorrent(currentVideoFile)
// Remove the old video file from the array
this.VideoFiles = this.VideoFiles.filter(f => f !== currentVideoFile)
// Update the database
currentVideoFile.set('extname', updatedVideoFile.extname)
currentVideoFile.set('size', updatedVideoFile.size)
updatedVideoFile = currentVideoFile
}
await this.createTorrentAndSetInfoHash(updatedVideoFile)
await updatedVideoFile.save()
this.VideoFiles.push(updatedVideoFile)
}
2018-02-27 17:57:28 +03:00
getOriginalFileResolution () {
2017-12-12 19:53:50 +03:00
const originalFilePath = this.getVideoFilePath(this.getOriginalFile())
2017-11-10 16:34:45 +03:00
2018-02-27 17:57:28 +03:00
return getVideoFileResolution(originalFilePath)
2017-12-12 19:53:50 +03:00
}
2017-11-10 16:34:45 +03:00
2017-12-12 19:53:50 +03:00
getDescriptionPath () {
return `/api/${API_VERSION}/videos/${this.uuid}/description`
2016-12-11 23:50:51 +03:00
}
2017-12-12 19:53:50 +03:00
removeThumbnail () {
const thumbnailPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, this.getThumbnailName())
return unlinkPromise(thumbnailPath)
2016-12-11 23:50:51 +03:00
}
2017-12-12 19:53:50 +03:00
removePreview () {
// Same name than video thumbnail
return unlinkPromise(CONFIG.STORAGE.PREVIEWS_DIR + this.getPreviewName())
2016-12-24 18:59:17 +03:00
}
2017-12-12 19:53:50 +03:00
removeFile (videoFile: VideoFileModel) {
const filePath = join(CONFIG.STORAGE.VIDEOS_DIR, this.getVideoFilename(videoFile))
return unlinkPromise(filePath)
2016-12-11 23:50:51 +03:00
}
2017-12-12 19:53:50 +03:00
removeTorrent (videoFile: VideoFileModel) {
const torrentPath = join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
return unlinkPromise(torrentPath)
}
2018-01-23 19:09:06 +03:00
getActivityStreamDuration () {
// https://www.w3.org/TR/activitystreams-vocabulary/#dfn-duration
return 'PT' + this.duration + 'S'
}
2017-12-12 19:53:50 +03:00
private getBaseUrls () {
let baseUrlHttp
let baseUrlWs
2016-12-24 18:59:17 +03:00
2017-12-12 19:53:50 +03:00
if (this.isOwned()) {
baseUrlHttp = CONFIG.WEBSERVER.URL
baseUrlWs = CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT
} else {
2017-12-14 19:38:41 +03:00
baseUrlHttp = REMOTE_SCHEME.HTTP + '://' + this.VideoChannel.Account.Actor.Server.host
baseUrlWs = REMOTE_SCHEME.WS + '://' + this.VideoChannel.Account.Actor.Server.host
}
2017-12-12 19:53:50 +03:00
return { baseUrlHttp, baseUrlWs }
}
2017-12-12 19:53:50 +03:00
private getThumbnailUrl (baseUrlHttp: string) {
return baseUrlHttp + STATIC_PATHS.THUMBNAILS + this.getThumbnailName()
}
2017-12-12 19:53:50 +03:00
private getTorrentUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
return baseUrlHttp + STATIC_PATHS.TORRENTS + this.getTorrentFileName(videoFile)
}
2017-11-09 19:51:58 +03:00
2018-05-29 19:30:11 +03:00
private getTorrentDownloadUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
return baseUrlHttp + STATIC_DOWNLOAD_PATHS.TORRENTS + this.getTorrentFileName(videoFile)
}
2017-12-12 19:53:50 +03:00
private getVideoFileUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
return baseUrlHttp + STATIC_PATHS.WEBSEED + this.getVideoFilename(videoFile)
}
2018-05-29 19:30:11 +03:00
private getVideoFileDownloadUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
return baseUrlHttp + STATIC_DOWNLOAD_PATHS.VIDEOS + this.getVideoFilename(videoFile)
}
2017-12-12 19:53:50 +03:00
private generateMagnetUri (videoFile: VideoFileModel, baseUrlHttp: string, baseUrlWs: string) {
const xs = this.getTorrentUrl(videoFile, baseUrlHttp)
const announce = [ baseUrlWs + '/tracker/socket', baseUrlHttp + '/tracker/announce' ]
const urlList = [ this.getVideoFileUrl(videoFile, baseUrlHttp) ]
const magnetHash = {
xs,
announce,
urlList,
infoHash: videoFile.infoHash,
name: this.name
}
2017-12-12 19:53:50 +03:00
return magnetUtil.encode(magnetHash)
}
}