PeerTube/server/models/video/video-playlist.ts

726 lines
18 KiB
TypeScript
Raw Normal View History

2020-12-02 10:07:26 +01:00
import { join } from 'path'
import { FindOptions, Includeable, literal, Op, ScopeOptions, Sequelize, Transaction, WhereOptions } from 'sequelize'
2019-02-26 10:55:40 +01:00
import {
AllowNull,
BelongsTo,
Column,
CreatedAt,
DataType,
Default,
ForeignKey,
HasMany,
HasOne,
2019-02-26 10:55:40 +01:00
Is,
IsUUID,
Model,
Scopes,
Table,
2019-12-27 09:04:04 +01:00
UpdatedAt
2019-02-26 10:55:40 +01:00
} from 'sequelize-typescript'
import { activityPubCollectionPagination } from '@server/lib/activitypub/collection'
2020-12-02 10:07:26 +01:00
import { MAccountId, MChannelId } from '@server/types/models'
import { buildPlaylistEmbedPath, buildPlaylistWatchPath, pick } from '@shared/core-utils'
import { buildUUID, uuidToShort } from '@shared/extra-utils'
2023-01-10 11:09:30 +01:00
import { ActivityIconObject, PlaylistObject, VideoPlaylist, VideoPlaylistPrivacy, VideoPlaylistType } from '@shared/models'
import { AttributesOnly } from '@shared/typescript-utils'
2020-12-02 10:07:26 +01:00
import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
2019-02-26 10:55:40 +01:00
import {
isVideoPlaylistDescriptionValid,
isVideoPlaylistNameValid,
isVideoPlaylistPrivacyValid
} from '../../helpers/custom-validators/video-playlists'
2019-03-05 10:58:44 +01:00
import {
2019-03-19 14:13:53 +01:00
ACTIVITY_PUB,
2019-03-05 10:58:44 +01:00
CONSTRAINTS_FIELDS,
STATIC_PATHS,
THUMBNAILS_SIZE,
VIDEO_PLAYLIST_PRIVACIES,
2019-04-11 11:33:44 +02:00
VIDEO_PLAYLIST_TYPES,
WEBSERVER
} from '../../initializers/constants'
2020-12-02 10:07:26 +01:00
import { MThumbnail } from '../../types/models/video/thumbnail'
2019-08-15 11:53:26 +02:00
import {
2019-12-27 09:04:04 +01:00
MVideoPlaylistAccountThumbnail,
MVideoPlaylistAP,
2019-08-20 19:05:31 +02:00
MVideoPlaylistFormattable,
2019-08-15 11:53:26 +02:00
MVideoPlaylistFull,
MVideoPlaylistFullSummary,
MVideoPlaylistSummaryWithElements
2020-06-18 10:45:25 +02:00
} from '../../types/models/video/video-playlist'
2020-12-02 10:07:26 +01:00
import { AccountModel, ScopeNames as AccountScopeNames, SummaryOptions } from '../account/account'
2021-05-11 11:15:29 +02:00
import { ActorModel } from '../actor/actor'
2021-06-17 16:02:38 +02:00
import {
buildServerIdsFollowedBy,
buildTrigramSearchIndex,
buildWhereIdOrUUID,
createSimilarityAttribute,
getPlaylistSort,
isOutdated,
2023-01-10 11:09:30 +01:00
setAsUpdated,
2021-06-17 16:02:38 +02:00
throwIfNotValid
2023-01-10 11:09:30 +01:00
} from '../shared'
2020-12-02 10:07:26 +01:00
import { ThumbnailModel } from './thumbnail'
import { ScopeNames as VideoChannelScopeNames, VideoChannelModel } from './video-channel'
import { VideoPlaylistElementModel } from './video-playlist-element'
2019-02-26 10:55:40 +01:00
enum ScopeNames {
AVAILABLE_FOR_LIST = 'AVAILABLE_FOR_LIST',
WITH_VIDEOS_LENGTH = 'WITH_VIDEOS_LENGTH',
2019-03-05 10:58:44 +01:00
WITH_ACCOUNT_AND_CHANNEL_SUMMARY = 'WITH_ACCOUNT_AND_CHANNEL_SUMMARY',
2019-03-05 11:30:43 +01:00
WITH_ACCOUNT = 'WITH_ACCOUNT',
WITH_THUMBNAIL = 'WITH_THUMBNAIL',
2019-03-05 11:30:43 +01:00
WITH_ACCOUNT_AND_CHANNEL = 'WITH_ACCOUNT_AND_CHANNEL'
2019-02-26 10:55:40 +01:00
}
type AvailableForListOptions = {
followerActorId?: number
2019-03-05 10:58:44 +01:00
type?: VideoPlaylistType
accountId?: number
2019-02-26 10:55:40 +01:00
videoChannelId?: number
2020-01-31 16:56:52 +01:00
listMyPlaylists?: boolean
search?: string
host?: string
uuids?: string[]
2021-06-17 16:02:38 +02:00
withVideos?: boolean
forCount?: boolean
2021-06-17 16:02:38 +02:00
}
function getVideoLengthSelect () {
return 'SELECT COUNT("id") FROM "videoPlaylistElement" WHERE "videoPlaylistId" = "VideoPlaylistModel"."id"'
2019-02-26 10:55:40 +01:00
}
2019-04-23 09:50:57 +02:00
@Scopes(() => ({
2020-01-31 16:56:52 +01:00
[ScopeNames.WITH_THUMBNAIL]: {
include: [
{
2019-04-23 09:50:57 +02:00
model: ThumbnailModel,
required: false
}
]
},
2020-01-31 16:56:52 +01:00
[ScopeNames.WITH_VIDEOS_LENGTH]: {
2019-02-26 10:55:40 +01:00
attributes: {
include: [
2019-04-18 11:28:17 +02:00
[
2021-06-17 16:02:38 +02:00
literal(`(${getVideoLengthSelect()})`),
2019-02-26 10:55:40 +01:00
'videosLength'
]
]
}
2019-04-23 09:50:57 +02:00
} as FindOptions,
2020-01-31 16:56:52 +01:00
[ScopeNames.WITH_ACCOUNT]: {
2019-03-05 10:58:44 +01:00
include: [
{
2019-04-23 09:50:57 +02:00
model: AccountModel,
2019-03-05 10:58:44 +01:00
required: true
}
]
},
2020-01-31 16:56:52 +01:00
[ScopeNames.WITH_ACCOUNT_AND_CHANNEL_SUMMARY]: {
2019-02-26 10:55:40 +01:00
include: [
{
2019-04-23 09:50:57 +02:00
model: AccountModel.scope(AccountScopeNames.SUMMARY),
2019-02-26 10:55:40 +01:00
required: true
},
{
2019-04-23 09:50:57 +02:00
model: VideoChannelModel.scope(VideoChannelScopeNames.SUMMARY),
2019-02-26 10:55:40 +01:00
required: false
}
]
},
2020-01-31 16:56:52 +01:00
[ScopeNames.WITH_ACCOUNT_AND_CHANNEL]: {
2019-03-05 11:30:43 +01:00
include: [
{
2019-04-23 09:50:57 +02:00
model: AccountModel,
2019-03-05 11:30:43 +01:00
required: true
},
{
2019-04-23 09:50:57 +02:00
model: VideoChannelModel,
2019-03-05 11:30:43 +01:00
required: false
}
]
},
2020-01-31 16:56:52 +01:00
[ScopeNames.AVAILABLE_FOR_LIST]: (options: AvailableForListOptions) => {
const whereAnd: WhereOptions[] = []
const whereServer = options.host && options.host !== WEBSERVER.HOST
? { host: options.host }
: undefined
2020-01-09 09:26:59 +01:00
let whereActor: WhereOptions = {}
2019-02-26 10:55:40 +01:00
if (options.host === WEBSERVER.HOST) {
whereActor = {
[Op.and]: [ { serverId: null } ]
}
}
2019-02-26 10:55:40 +01:00
2020-01-09 09:26:59 +01:00
if (options.listMyPlaylists !== true) {
2019-02-26 10:55:40 +01:00
whereAnd.push({
privacy: VideoPlaylistPrivacy.PUBLIC
})
2020-01-09 09:26:59 +01:00
// Only list local playlists
const whereActorOr: WhereOptions[] = [
{
serverId: null
}
]
2020-01-09 09:26:59 +01:00
// … OR playlists that are on an instance followed by actorId
if (options.followerActorId) {
const inQueryInstanceFollow = buildServerIdsFollowedBy(options.followerActorId)
whereActorOr.push({
serverId: {
[Op.in]: literal(inQueryInstanceFollow)
2020-01-09 09:26:59 +01:00
}
})
}
Object.assign(whereActor, { [Op.or]: whereActorOr })
2019-02-26 10:55:40 +01:00
}
if (options.accountId) {
whereAnd.push({
ownerAccountId: options.accountId
})
}
if (options.videoChannelId) {
whereAnd.push({
videoChannelId: options.videoChannelId
})
}
2019-03-05 10:58:44 +01:00
if (options.type) {
whereAnd.push({
type: options.type
})
}
if (options.uuids) {
whereAnd.push({
uuid: {
[Op.in]: options.uuids
}
})
}
2021-06-17 16:02:38 +02:00
if (options.withVideos === true) {
whereAnd.push(
literal(`(${getVideoLengthSelect()}) != 0`)
)
}
let attributesInclude: any[] = [ literal('0 as similarity') ]
2021-06-17 16:02:38 +02:00
if (options.search) {
2021-06-17 16:02:38 +02:00
const escapedSearch = VideoPlaylistModel.sequelize.escape(options.search)
const escapedLikeSearch = VideoPlaylistModel.sequelize.escape('%' + options.search + '%')
attributesInclude = [ createSimilarityAttribute('VideoPlaylistModel.name', options.search) ]
2021-06-17 16:02:38 +02:00
whereAnd.push({
2021-06-17 16:02:38 +02:00
[Op.or]: [
Sequelize.literal(
'lower(immutable_unaccent("VideoPlaylistModel"."name")) % lower(immutable_unaccent(' + escapedSearch + '))'
),
Sequelize.literal(
'lower(immutable_unaccent("VideoPlaylistModel"."name")) LIKE lower(immutable_unaccent(' + escapedLikeSearch + '))'
)
]
})
}
2019-02-26 10:55:40 +01:00
const where = {
2019-04-18 11:28:17 +02:00
[Op.and]: whereAnd
2019-02-26 10:55:40 +01:00
}
const include: Includeable[] = [
{
model: AccountModel.scope({
method: [ AccountScopeNames.SUMMARY, { whereActor, whereServer, forCount: options.forCount } as SummaryOptions ]
}),
required: true
}
]
if (options.forCount !== true) {
include.push({
model: VideoChannelModel.scope(VideoChannelScopeNames.SUMMARY),
required: false
})
}
2019-02-26 10:55:40 +01:00
return {
2021-06-17 16:02:38 +02:00
attributes: {
include: attributesInclude
},
2019-02-26 10:55:40 +01:00
where,
include
2019-04-23 09:50:57 +02:00
} as FindOptions
2019-02-26 10:55:40 +01:00
}
2019-04-23 09:50:57 +02:00
}))
2019-02-26 10:55:40 +01:00
@Table({
tableName: 'videoPlaylist',
indexes: [
2021-06-17 16:02:38 +02:00
buildTrigramSearchIndex('video_playlist_name_trigram', 'name'),
2019-02-26 10:55:40 +01:00
{
fields: [ 'ownerAccountId' ]
},
{
fields: [ 'videoChannelId' ]
},
{
fields: [ 'url' ],
unique: true
}
]
})
2021-05-12 14:09:04 +02:00
export class VideoPlaylistModel extends Model<Partial<AttributesOnly<VideoPlaylistModel>>> {
2019-02-26 10:55:40 +01:00
@CreatedAt
createdAt: Date
@UpdatedAt
updatedAt: Date
@AllowNull(false)
@Is('VideoPlaylistName', value => throwIfNotValid(value, isVideoPlaylistNameValid, 'name'))
@Column
name: string
@AllowNull(true)
2019-04-18 11:28:17 +02:00
@Is('VideoPlaylistDescription', value => throwIfNotValid(value, isVideoPlaylistDescriptionValid, 'description', true))
2020-05-05 16:27:46 +02:00
@Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_PLAYLISTS.DESCRIPTION.max))
2019-02-26 10:55:40 +01:00
description: string
@AllowNull(false)
@Is('VideoPlaylistPrivacy', value => throwIfNotValid(value, isVideoPlaylistPrivacyValid, 'privacy'))
@Column
privacy: VideoPlaylistPrivacy
@AllowNull(false)
@Is('VideoPlaylistUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
@Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_PLAYLISTS.URL.max))
url: string
@AllowNull(false)
@Default(DataType.UUIDV4)
@IsUUID(4)
@Column(DataType.UUID)
uuid: string
2019-03-05 10:58:44 +01:00
@AllowNull(false)
@Default(VideoPlaylistType.REGULAR)
@Column
type: VideoPlaylistType
2019-02-26 10:55:40 +01:00
@ForeignKey(() => AccountModel)
@Column
ownerAccountId: number
@BelongsTo(() => AccountModel, {
foreignKey: {
allowNull: false
},
onDelete: 'CASCADE'
})
OwnerAccount: AccountModel
@ForeignKey(() => VideoChannelModel)
@Column
videoChannelId: number
@BelongsTo(() => VideoChannelModel, {
foreignKey: {
2019-02-28 11:14:26 +01:00
allowNull: true
2019-02-26 10:55:40 +01:00
},
onDelete: 'CASCADE'
})
VideoChannel: VideoChannelModel
@HasMany(() => VideoPlaylistElementModel, {
foreignKey: {
name: 'videoPlaylistId',
allowNull: false
},
2019-03-05 10:58:44 +01:00
onDelete: 'CASCADE'
2019-02-26 10:55:40 +01:00
})
VideoPlaylistElements: VideoPlaylistElementModel[]
@HasOne(() => ThumbnailModel, {
foreignKey: {
name: 'videoPlaylistId',
allowNull: true
},
onDelete: 'CASCADE',
hooks: true
})
Thumbnail: ThumbnailModel
2019-02-26 10:55:40 +01:00
2021-07-29 14:17:03 +02:00
static listForApi (options: AvailableForListOptions & {
2020-01-31 16:56:52 +01:00
start: number
count: number
sort: string
2019-02-26 10:55:40 +01:00
}) {
const query = {
offset: options.start,
limit: options.count,
order: getPlaylistSort(options.sort)
2019-02-26 10:55:40 +01:00
}
const commonAvailableForListOptions = pick(options, [
'type',
'followerActorId',
'accountId',
'videoChannelId',
'listMyPlaylists',
'search',
'host',
'uuids'
])
const scopesFind: (string | ScopeOptions)[] = [
2019-02-26 10:55:40 +01:00
{
method: [
ScopeNames.AVAILABLE_FOR_LIST,
{
...commonAvailableForListOptions,
2021-07-29 14:17:03 +02:00
2021-06-17 16:02:38 +02:00
withVideos: options.withVideos || false
2019-02-26 10:55:40 +01:00
} as AvailableForListOptions
]
2019-04-23 09:50:57 +02:00
},
ScopeNames.WITH_VIDEOS_LENGTH,
ScopeNames.WITH_THUMBNAIL
2019-02-26 10:55:40 +01:00
]
const scopesCount: (string | ScopeOptions)[] = [
{
method: [
ScopeNames.AVAILABLE_FOR_LIST,
{
...commonAvailableForListOptions,
withVideos: options.withVideos || false,
forCount: true
} as AvailableForListOptions
]
},
ScopeNames.WITH_VIDEOS_LENGTH
]
return Promise.all([
VideoPlaylistModel.scope(scopesCount).count(),
VideoPlaylistModel.scope(scopesFind).findAll(query)
]).then(([ count, rows ]) => ({ total: count, data: rows }))
2019-02-26 10:55:40 +01:00
}
2022-07-13 11:58:01 +02:00
static searchForApi (options: Pick<AvailableForListOptions, 'followerActorId' | 'search' | 'host' | 'uuids'> & {
2021-06-17 16:02:38 +02:00
start: number
count: number
sort: string
}) {
return VideoPlaylistModel.listForApi({
...options,
2021-07-29 14:17:03 +02:00
2021-06-17 16:02:38 +02:00
type: VideoPlaylistType.REGULAR,
listMyPlaylists: false,
withVideos: true
})
}
static listPublicUrlsOfForAP (options: { account?: MAccountId, channel?: MChannelId }, start: number, count: number) {
const where = {
privacy: VideoPlaylistPrivacy.PUBLIC
}
if (options.account) {
Object.assign(where, { ownerAccountId: options.account.id })
}
if (options.channel) {
Object.assign(where, { videoChannelId: options.channel.id })
}
const getQuery = (forCount: boolean) => {
return {
attributes: forCount === true
? []
: [ 'url' ],
offset: start,
limit: count,
where
}
2019-02-26 10:55:40 +01:00
}
return Promise.all([
VideoPlaylistModel.count(getQuery(true)),
VideoPlaylistModel.findAll(getQuery(false))
]).then(([ total, rows ]) => ({
total,
data: rows.map(p => p.url)
}))
2019-02-26 10:55:40 +01:00
}
static listPlaylistSummariesOf (accountId: number, videoIds: number[]): Promise<MVideoPlaylistSummaryWithElements[]> {
2019-03-07 17:06:00 +01:00
const query = {
attributes: [ 'id', 'name', 'uuid' ],
2019-03-07 17:06:00 +01:00
where: {
ownerAccountId: accountId
},
include: [
{
2019-07-31 15:57:32 +02:00
attributes: [ 'id', 'videoId', 'startTimestamp', 'stopTimestamp' ],
2019-03-07 17:06:00 +01:00
model: VideoPlaylistElementModel.unscoped(),
where: {
videoId: {
2020-01-28 14:45:17 +01:00
[Op.in]: videoIds
2019-03-07 17:06:00 +01:00
}
},
required: true
}
]
}
return VideoPlaylistModel.findAll(query)
}
2019-02-26 10:55:40 +01:00
static doesPlaylistExist (url: string) {
const query = {
2020-12-08 14:30:29 +01:00
attributes: [ 'id' ],
2019-02-26 10:55:40 +01:00
where: {
url
}
}
return VideoPlaylistModel
.findOne(query)
.then(e => !!e)
}
2020-12-08 14:30:29 +01:00
static loadWithAccountAndChannelSummary (id: number | string, transaction: Transaction): Promise<MVideoPlaylistFullSummary> {
2019-02-26 10:55:40 +01:00
const where = buildWhereIdOrUUID(id)
const query = {
where,
transaction
}
return VideoPlaylistModel
.scope([ ScopeNames.WITH_ACCOUNT_AND_CHANNEL_SUMMARY, ScopeNames.WITH_VIDEOS_LENGTH, ScopeNames.WITH_THUMBNAIL ])
2019-03-05 11:30:43 +01:00
.findOne(query)
}
2020-12-08 14:30:29 +01:00
static loadWithAccountAndChannel (id: number | string, transaction: Transaction): Promise<MVideoPlaylistFull> {
2019-03-05 11:30:43 +01:00
const where = buildWhereIdOrUUID(id)
const query = {
where,
transaction
}
return VideoPlaylistModel
.scope([ ScopeNames.WITH_ACCOUNT_AND_CHANNEL, ScopeNames.WITH_VIDEOS_LENGTH, ScopeNames.WITH_THUMBNAIL ])
2019-02-26 10:55:40 +01:00
.findOne(query)
}
2020-12-08 14:30:29 +01:00
static loadByUrlAndPopulateAccount (url: string): Promise<MVideoPlaylistAccountThumbnail> {
2019-03-05 10:58:44 +01:00
const query = {
where: {
url
}
}
return VideoPlaylistModel.scope([ ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_THUMBNAIL ]).findOne(query)
2019-03-05 10:58:44 +01:00
}
2021-06-17 16:02:38 +02:00
static loadByUrlWithAccountAndChannelSummary (url: string): Promise<MVideoPlaylistFullSummary> {
const query = {
where: {
url
}
}
return VideoPlaylistModel
.scope([ ScopeNames.WITH_ACCOUNT_AND_CHANNEL_SUMMARY, ScopeNames.WITH_VIDEOS_LENGTH, ScopeNames.WITH_THUMBNAIL ])
.findOne(query)
}
2019-02-26 10:55:40 +01:00
static getPrivacyLabel (privacy: VideoPlaylistPrivacy) {
return VIDEO_PLAYLIST_PRIVACIES[privacy] || 'Unknown'
}
2019-03-05 10:58:44 +01:00
static getTypeLabel (type: VideoPlaylistType) {
return VIDEO_PLAYLIST_TYPES[type] || 'Unknown'
}
2019-04-18 11:28:17 +02:00
static resetPlaylistsOfChannel (videoChannelId: number, transaction: Transaction) {
2019-03-05 10:58:44 +01:00
const query = {
where: {
videoChannelId
},
transaction
}
return VideoPlaylistModel.update({ privacy: VideoPlaylistPrivacy.PRIVATE, videoChannelId: null }, query)
}
2019-08-15 11:53:26 +02:00
async setAndSaveThumbnail (thumbnail: MThumbnail, t: Transaction) {
2019-04-23 09:50:57 +02:00
thumbnail.videoPlaylistId = this.id
2019-04-23 09:50:57 +02:00
this.Thumbnail = await thumbnail.save({ transaction: t })
}
hasThumbnail () {
return !!this.Thumbnail
}
hasGeneratedThumbnail () {
return this.hasThumbnail() && this.Thumbnail.automaticallyGenerated === true
}
generateThumbnailName () {
2019-02-26 10:55:40 +01:00
const extension = '.jpg'
return 'playlist-' + buildUUID() + extension
2019-02-26 10:55:40 +01:00
}
getThumbnailUrl () {
if (!this.hasThumbnail()) return null
2019-04-23 09:50:57 +02:00
return WEBSERVER.URL + STATIC_PATHS.THUMBNAILS + this.Thumbnail.filename
2019-02-26 10:55:40 +01:00
}
getThumbnailStaticPath () {
if (!this.hasThumbnail()) return null
2019-02-26 10:55:40 +01:00
2019-04-23 09:50:57 +02:00
return join(STATIC_PATHS.THUMBNAILS, this.Thumbnail.filename)
2019-02-26 10:55:40 +01:00
}
2021-07-26 15:04:37 +02:00
getWatchStaticPath () {
return buildPlaylistWatchPath({ shortUUID: uuidToShort(this.uuid) })
}
2020-08-05 15:35:58 +02:00
getEmbedStaticPath () {
2021-07-26 15:04:37 +02:00
return buildPlaylistEmbedPath(this)
2020-08-05 15:35:58 +02:00
}
static async getStats () {
const totalLocalPlaylists = await VideoPlaylistModel.count({
include: [
{
2022-06-17 16:16:28 +02:00
model: AccountModel.unscoped(),
required: true,
include: [
{
2022-06-17 16:16:28 +02:00
model: ActorModel.unscoped(),
required: true,
where: {
serverId: null
}
}
]
}
],
where: {
privacy: VideoPlaylistPrivacy.PUBLIC
}
})
return {
totalLocalPlaylists
}
}
2019-03-19 14:13:53 +01:00
setAsRefreshed () {
2023-01-10 11:09:30 +01:00
return setAsUpdated({ sequelize: this.sequelize, table: 'videoPlaylist', id: this.id })
2019-03-19 14:13:53 +01:00
}
2021-06-17 16:02:38 +02:00
setVideosLength (videosLength: number) {
this.set('videosLength' as any, videosLength, { raw: true })
}
2019-02-26 10:55:40 +01:00
isOwned () {
return this.OwnerAccount.isOwned()
}
2019-03-19 14:13:53 +01:00
isOutdated () {
if (this.isOwned()) return false
return isOutdated(this, ACTIVITY_PUB.VIDEO_PLAYLIST_REFRESH_INTERVAL)
}
2019-08-20 19:05:31 +02:00
toFormattedJSON (this: MVideoPlaylistFormattable): VideoPlaylist {
2019-02-26 10:55:40 +01:00
return {
id: this.id,
uuid: this.uuid,
shortUUID: uuidToShort(this.uuid),
2019-02-26 10:55:40 +01:00
isLocal: this.isOwned(),
2021-06-17 16:02:38 +02:00
url: this.url,
2019-02-26 10:55:40 +01:00
displayName: this.name,
description: this.description,
privacy: {
id: this.privacy,
label: VideoPlaylistModel.getPrivacyLabel(this.privacy)
},
thumbnailPath: this.getThumbnailStaticPath(),
embedPath: this.getEmbedStaticPath(),
2019-02-26 10:55:40 +01:00
2019-03-05 10:58:44 +01:00
type: {
id: this.type,
label: VideoPlaylistModel.getTypeLabel(this.type)
},
2019-04-18 11:28:17 +02:00
videosLength: this.get('videosLength') as number,
2019-02-26 10:55:40 +01:00
createdAt: this.createdAt,
updatedAt: this.updatedAt,
ownerAccount: this.OwnerAccount.toFormattedSummaryJSON(),
2020-04-21 15:04:39 +02:00
videoChannel: this.VideoChannel
? this.VideoChannel.toFormattedSummaryJSON()
: null
2019-02-26 10:55:40 +01:00
}
}
2019-08-21 14:31:57 +02:00
toActivityPubObject (this: MVideoPlaylistAP, page: number, t: Transaction): Promise<PlaylistObject> {
2019-02-26 10:55:40 +01:00
const handler = (start: number, count: number) => {
2019-03-05 10:58:44 +01:00
return VideoPlaylistElementModel.listUrlsOfForAP(this.id, start, count, t)
2019-02-26 10:55:40 +01:00
}
let icon: ActivityIconObject
if (this.hasThumbnail()) {
icon = {
type: 'Image' as 'Image',
url: this.getThumbnailUrl(),
mediaType: 'image/jpeg' as 'image/jpeg',
width: THUMBNAILS_SIZE.width,
height: THUMBNAILS_SIZE.height
}
}
2019-03-05 10:58:44 +01:00
return activityPubCollectionPagination(this.url, handler, page)
2019-02-26 10:55:40 +01:00
.then(o => {
return Object.assign(o, {
type: 'Playlist' as 'Playlist',
name: this.name,
content: this.description,
mediaType: 'text/markdown' as 'text/markdown',
2019-02-26 10:55:40 +01:00
uuid: this.uuid,
2019-03-05 10:58:44 +01:00
published: this.createdAt.toISOString(),
updated: this.updatedAt.toISOString(),
2019-02-26 10:55:40 +01:00
attributedTo: this.VideoChannel ? [ this.VideoChannel.Actor.url ] : [],
icon
2019-02-26 10:55:40 +01:00
})
})
}
}