PeerTube/server/models/video/video.ts

1206 lines
32 KiB
TypeScript
Raw Normal View History

2017-11-23 19:36:15 +03:00
import * as Bluebird from 'bluebird'
2017-10-31 18:31:24 +03:00
import { map, maxBy, truncate } 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'
2017-05-15 23:22:03 +03:00
import { 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 {
AfterDestroy, 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'
2017-12-14 12:07:57 +03:00
import { Video, VideoDetails } from '../../../shared/models/videos'
2017-12-28 13:16:08 +03:00
import { activityPubCollection } from '../../helpers/activitypub'
import { createTorrentPromise, renamePromise, statPromise, unlinkPromise, writeFilePromise } from '../../helpers/core-utils'
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 {
2017-12-28 13:16:08 +03:00
isVideoCategoryValid, isVideoDescriptionValid, isVideoDurationValid, isVideoLanguageValid, isVideoLicenceValid, isVideoNameValid,
2018-01-03 12:12:36 +03:00
isVideoPrivacyValid
2017-12-12 19:53:50 +03:00
} from '../../helpers/custom-validators/videos'
2017-12-28 13:16:08 +03:00
import { generateImageFromVideoFile, getVideoFileHeight, transcode } from '../../helpers/ffmpeg-utils'
import { logger } from '../../helpers/logger'
import { getServerActor } from '../../helpers/utils'
2017-05-15 23:22:03 +03:00
import {
2017-12-28 13:16:08 +03:00
API_VERSION, CONFIG, CONSTRAINTS_FIELDS, PREVIEWS_SIZE, REMOTE_SCHEME, STATIC_PATHS, THUMBNAILS_SIZE, VIDEO_CATEGORIES,
VIDEO_LANGUAGES, VIDEO_LICENCES, VIDEO_PRIVACIES
2017-12-12 19:53:50 +03:00
} from '../../initializers'
import { getAnnounceActivityPubUrl } 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'
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({
[ScopeNames.AVAILABLE_FOR_LIST]: (actorId: number) => ({
2017-12-14 12:07:57 +03:00
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" ' +
'WHERE "actorFollow"."actorId" = ' + parseInt(actorId.toString(), 10) +
' 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" ' +
'WHERE "actor"."serverId" IS NULL OR "actorFollow"."actorId" = ' + parseInt(actorId.toString(), 10) +
')'
2017-12-14 12:07:57 +03:00
)
2017-12-14 19:38:41 +03:00
},
privacy: VideoPrivacy.PUBLIC
},
2018-01-04 13:19:16 +03:00
include: [
{
attributes: [ 'name', 'description' ],
model: VideoChannelModel.unscoped(),
2018-01-04 13:19:16 +03:00
required: true,
include: [
{
attributes: [ 'name' ],
model: AccountModel.unscoped(),
2018-01-04 13:19:16 +03:00
required: true,
include: [
{
attributes: [ 'serverId' ],
model: ActorModel.unscoped(),
2018-01-04 13:19:16 +03:00
required: true,
include: [
{
attributes: [ 'host' ],
model: ServerModel.unscoped()
2018-01-04 13:19:16 +03:00
}
]
}
]
}
]
}
]
}),
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
}
]
2017-12-14 12:07:57 +03:00
}
]
}
]
}
]
},
[ScopeNames.WITH_TAGS]: {
include: [ () => TagModel ]
},
[ScopeNames.WITH_FILES]: {
include: [
{
model: () => VideoFileModel,
required: true
}
]
},
[ScopeNames.WITH_SHARES]: {
include: [
{
model: () => VideoShareModel,
2017-12-14 19:38:41 +03:00
include: [ () => ActorModel ]
2017-12-14 12:07:57 +03:00
}
]
},
[ScopeNames.WITH_RATES]: {
include: [
{
model: () => AccountVideoRateModel,
include: [ () => AccountModel ]
}
]
2017-12-28 13:16:08 +03:00
},
[ScopeNames.WITH_COMMENTS]: {
include: [
{
model: () => VideoCommentModel
}
]
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'))
@Column
language: number
@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(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
@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
},
onDelete: 'cascade'
})
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
}
2017-12-12 19:53:50 +03:00
@AfterDestroy
static async removeFilesAndSendDelete (instance: VideoModel) {
const tasks: Promise<any>[] = []
2016-11-11 17:20:03 +03:00
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))
})
}
2017-12-12 19:53:50 +03:00
return Promise.all(tasks)
.catch(err => {
logger.error('Some errors when removing files of video %s in after destroy hook.', instance.uuid, err)
})
}
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,
order: [ getSort('createdAt'), [ 'Tags', 'name', 'ASC' ] ],
where: {
id: {
[Sequelize.Op.in]: Sequelize.literal('(' + rawQuery + ')')
}
},
include: [
{
attributes: [ 'id' ],
model: VideoShareModel.unscoped(),
2017-12-12 19:53:50 +03:00
required: false,
where: {
[Sequelize.Op.and]: [
{
id: {
[Sequelize.Op.not]: null
}
},
{
2017-12-14 19:38:41 +03:00
actorId
2017-12-12 19:53:50 +03:00
}
]
},
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: [
{
attributes: [ 'id', 'url' ],
model: ActorModel.unscoped(),
required: true
}
]
},
{
attributes: [ 'id', 'url' ],
model: ActorModel.unscoped(),
2017-12-12 19:53:50 +03:00
required: true
}
]
},
{
attributes: [ 'type' ],
2017-12-12 19:53:50 +03:00
model: AccountVideoRateModel,
required: false,
include: [
{
attributes: [ 'id' ],
model: AccountModel.unscoped(),
include: [
{
attributes: [ 'url' ],
model: ActorModel.unscoped(),
include: [
{
attributes: [ 'host' ],
model: ServerModel,
required: false
}
]
}
]
}
]
},
{
attributes: [ 'url' ],
model: VideoCommentModel,
required: false
2017-12-12 19:53:50 +03:00
},
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
}
})
}
2017-12-12 19:53:50 +03:00
static listUserVideosForApi (userId: number, start: number, count: number, sort: string) {
const query = {
offset: start,
limit: count,
2017-12-14 12:07:57 +03:00
order: [ getSort(sort) ],
2017-12-12 19:53:50 +03:00
include: [
{
model: VideoChannelModel,
required: true,
include: [
{
model: AccountModel,
where: {
userId
},
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
2017-12-12 19:53:50 +03:00
return VideoModel.findAndCountAll(query).then(({ rows, count }) => {
return {
data: rows,
total: count
}
})
}
static async listForApi (start: number, count: number, sort: string) {
2017-12-12 19:53:50 +03:00
const query = {
offset: start,
limit: count,
2017-12-14 12:07:57 +03:00
order: [ getSort(sort) ]
2017-12-12 19:53:50 +03:00
}
const serverActor = await getServerActor()
return VideoModel.scope({ method: [ ScopeNames.AVAILABLE_FOR_LIST, serverActor.id ] })
2017-12-14 12:07:57 +03:00
.findAndCountAll(query)
.then(({ rows, count }) => {
return {
data: rows,
total: count
}
})
}
static async searchAndPopulateAccountAndServerAndTags (value: string, start: number, count: number, sort: string) {
const query: IFindOptions<VideoModel> = {
offset: start,
limit: count,
order: [ getSort(sort) ],
where: {
name: {
[Sequelize.Op.iLike]: '%' + value + '%'
}
}
}
const serverActor = await getServerActor()
return VideoModel.scope({ method: [ ScopeNames.AVAILABLE_FOR_LIST, serverActor.id ] })
.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)
}
static loadAndPopulateAll (id: number) {
const options = {
order: [ [ 'Tags', 'name', 'ASC' ] ],
where: {
id
}
}
return VideoModel
.scope([
ScopeNames.WITH_RATES,
ScopeNames.WITH_SHARES,
ScopeNames.WITH_TAGS,
ScopeNames.WITH_FILES,
2018-01-04 13:19:16 +03:00
ScopeNames.WITH_ACCOUNT_DETAILS,
2017-12-28 13:16:08 +03:00
ScopeNames.WITH_COMMENTS
])
2017-12-14 12:07:57 +03:00
.findOne(options)
}
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) {
const imageSize = PREVIEWS_SIZE.width + 'x' + PREVIEWS_SIZE.height
return generateImageFromVideoFile(
this.getVideoFilePath(videoFile),
CONFIG.STORAGE.PREVIEWS_DIR,
this.getPreviewName(),
imageSize
)
}
2017-10-30 12:16:27 +03:00
2017-12-12 19:53:50 +03:00
createThumbnail (videoFile: VideoFileModel) {
const imageSize = THUMBNAILS_SIZE.width + 'x' + THUMBNAILS_SIZE.height
2017-12-12 19:53:50 +03:00
return generateImageFromVideoFile(
this.getVideoFilePath(videoFile),
CONFIG.STORAGE.THUMBNAILS_DIR,
this.getThumbnailName(),
imageSize
)
}
2017-12-12 19:53:50 +03:00
getVideoFilePath (videoFile: VideoFileModel) {
return join(CONFIG.STORAGE.VIDEOS_DIR, this.getVideoFilename(videoFile))
}
2017-12-12 19:53:50 +03:00
createTorrentAndSetInfoHash = async function (videoFile: VideoFileModel) {
const options = {
announceList: [
[ CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT + '/tracker/socket' ]
],
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())
}
2017-12-12 19:53:50 +03:00
toFormattedJSON () {
let serverHost
2017-12-14 19:38:41 +03:00
if (this.VideoChannel.Account.Actor.Server) {
serverHost = this.VideoChannel.Account.Actor.Server.host
2017-12-12 19:53:50 +03:00
} else {
// It means it's our video
serverHost = CONFIG.WEBSERVER.HOST
}
2017-12-12 19:53:50 +03:00
return {
id: this.id,
uuid: this.uuid,
name: this.name,
category: this.category,
categoryLabel: this.getCategoryLabel(),
licence: this.licence,
licenceLabel: this.getLicenceLabel(),
language: this.language,
languageLabel: this.getLanguageLabel(),
nsfw: this.nsfw,
description: this.getTruncatedDescription(),
serverHost,
isLocal: this.isOwned(),
accountName: this.VideoChannel.Account.name,
duration: this.duration,
views: this.views,
likes: this.likes,
dislikes: this.dislikes,
thumbnailPath: this.getThumbnailPath(),
previewPath: this.getPreviewPath(),
embedPath: this.getEmbedPath(),
createdAt: this.createdAt,
updatedAt: this.updatedAt
2017-12-14 12:07:57 +03:00
} as Video
}
2017-12-12 19:53:50 +03:00
toFormattedDetailsJSON () {
const formattedJson = this.toFormattedJSON()
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
// Maybe our server is not up to date and there are new privacy settings since our version
let privacyLabel = VIDEO_PRIVACIES[this.privacy]
if (!privacyLabel) privacyLabel = 'Unknown'
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
const detailsJson = {
privacyLabel,
privacy: this.privacy,
descriptionPath: this.getDescriptionPath(),
channel: this.VideoChannel.toFormattedJSON(),
account: this.VideoChannel.Account.toFormattedJSON(),
2017-12-14 12:07:57 +03:00
tags: map<TagModel, string>(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
const { baseUrlHttp, baseUrlWs } = this.getBaseUrls()
detailsJson.files = this.VideoFiles
.map(videoFile => {
let resolutionLabel = videoFile.resolution + 'p'
return {
resolution: videoFile.resolution,
resolutionLabel,
magnetUri: this.generateMagnetUri(videoFile, baseUrlHttp, baseUrlWs),
size: videoFile.size,
torrentUrl: this.getTorrentUrl(videoFile, baseUrlHttp),
fileUrl: this.getVideoFileUrl(videoFile, baseUrlHttp)
}
})
.sort((a, b) => {
if (a.resolution < b.resolution) return 1
if (a.resolution === b.resolution) return 0
return -1
})
2017-12-14 12:07:57 +03:00
return Object.assign(formattedJson, detailsJson) as VideoDetails
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 = {
identifier: this.language + '',
name: this.getLanguageLabel()
}
}
2017-12-12 19:53:50 +03:00
let category
if (this.category) {
category = {
identifier: this.category + '',
name: this.getCategoryLabel()
}
}
2017-12-12 19:53:50 +03:00
let licence
if (this.licence) {
licence = {
identifier: this.licence + '',
name: this.getLicenceLabel()
}
}
2017-10-30 12:16:27 +03:00
2017-12-12 19:53:50 +03:00
let likesObject
let dislikesObject
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
if (Array.isArray(this.AccountVideoRates)) {
const likes: string[] = []
const dislikes: string[] = []
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
for (const rate of this.AccountVideoRates) {
if (rate.type === 'like') {
2017-12-14 19:38:41 +03:00
likes.push(rate.Account.Actor.url)
2017-12-12 19:53:50 +03:00
} else if (rate.type === 'dislike') {
2017-12-14 19:38:41 +03:00
dislikes.push(rate.Account.Actor.url)
2017-12-12 19:53:50 +03:00
}
}
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
likesObject = activityPubCollection(likes)
dislikesObject = activityPubCollection(dislikes)
}
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
let sharesObject
if (Array.isArray(this.VideoShares)) {
const shares: string[] = []
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
for (const videoShare of this.VideoShares) {
2017-12-14 19:38:41 +03:00
const shareUrl = getAnnounceActivityPubUrl(this.url, videoShare.Actor)
2017-12-12 19:53:50 +03:00
shares.push(shareUrl)
}
2017-11-09 19:51:58 +03:00
2017-12-12 19:53:50 +03:00
sharesObject = activityPubCollection(shares)
}
2017-12-28 13:16:08 +03:00
let commentsObject
if (Array.isArray(this.VideoComments)) {
const comments: string[] = []
for (const videoComment of this.VideoComments) {
comments.push(videoComment.url)
}
commentsObject = activityPubCollection(comments)
}
2017-12-12 19:53:50 +03:00
const url = []
for (const file of this.VideoFiles) {
url.push({
type: 'Link',
mimeType: 'video/' + file.extname.replace('.', ''),
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,
// https://www.w3.org/TR/activitystreams-vocabulary/#dfn-duration
duration: 'PT' + this.duration + 'S',
uuid: this.uuid,
tag,
category,
licence,
language,
views: this.views,
nsfw: this.nsfw,
2018-01-03 12:12:36 +03:00
commentsEnabled: this.commentsEnabled,
2017-12-12 19:53:50 +03:00
published: this.createdAt.toISOString(),
updated: this.updatedAt.toISOString(),
mediaType: 'text/markdown',
content: this.getTruncatedDescription(),
icon: {
type: 'Image',
url: this.getThumbnailUrl(baseUrlHttp),
mediaType: 'image/jpeg',
width: THUMBNAILS_SIZE.width,
height: THUMBNAILS_SIZE.height
},
url,
likes: likesObject,
dislikes: dislikesObject,
2017-12-14 19:38:41 +03:00
shares: sharesObject,
2017-12-28 13:16:08 +03:00
comments: commentsObject,
2017-12-14 19:38:41 +03:00
attributedTo: [
{
type: 'Group',
id: this.VideoChannel.Actor.url
2018-01-10 19:18:12 +03:00
},
{
type: 'Person',
id: this.VideoChannel.Account.Actor.url
2017-12-14 19:38:41 +03:00
}
]
2017-12-12 19:53:50 +03:00
}
}
getTruncatedDescription () {
if (!this.description) return null
2017-12-12 19:53:50 +03:00
const options = {
length: CONSTRAINTS_FIELDS.VIDEOS.TRUNCATED_DESCRIPTION.max
}
2017-12-12 19:53:50 +03:00
return truncate(this.description, options)
}
2017-12-12 19:53:50 +03:00
optimizeOriginalVideofile = async function () {
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
}
2017-12-12 19:53:50 +03:00
try {
// Could be very long!
await transcode(transcodeOptions)
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...
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
}
2017-12-12 19:53:50 +03:00
transcodeOriginalVideofile = async function (resolution: VideoResolution) {
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,
resolution
}
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
}
2017-12-12 19:53:50 +03:00
getOriginalFileHeight () {
const originalFilePath = this.getVideoFilePath(this.getOriginalFile())
2017-11-10 16:34:45 +03:00
2017-12-12 19:53:50 +03:00
return getVideoFileHeight(originalFilePath)
}
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
getCategoryLabel () {
let categoryLabel = VIDEO_CATEGORIES[this.category]
if (!categoryLabel) categoryLabel = 'Misc'
2017-12-12 19:53:50 +03:00
return categoryLabel
}
2017-12-12 19:53:50 +03:00
getLicenceLabel () {
let licenceLabel = VIDEO_LICENCES[this.licence]
if (!licenceLabel) licenceLabel = 'Unknown'
2017-12-12 19:53:50 +03:00
return licenceLabel
2016-12-11 23:50:51 +03:00
}
2016-12-24 18:59:17 +03:00
2017-12-12 19:53:50 +03:00
getLanguageLabel () {
let languageLabel = VIDEO_LANGUAGES[this.language]
if (!languageLabel) languageLabel = 'Unknown'
return languageLabel
2017-10-24 20:41:09 +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)
}
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
2017-12-12 19:53:50 +03:00
private getVideoFileUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
return baseUrlHttp + STATIC_PATHS.WEBSEED + 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)
}
}