PeerTube/server/models/video/video-channel.ts
2018-01-11 09:35:50 +01:00

255 lines
5.1 KiB
TypeScript

import {
AfterDestroy,
AllowNull,
BelongsTo,
Column,
CreatedAt,
DefaultScope,
ForeignKey,
HasMany,
Is,
Model,
Scopes,
Table,
UpdatedAt
} from 'sequelize-typescript'
import { ActivityPubActor } from '../../../shared/models/activitypub'
import { isVideoChannelDescriptionValid, isVideoChannelNameValid } from '../../helpers/custom-validators/video-channels'
import { sendDeleteActor } from '../../lib/activitypub/send'
import { AccountModel } from '../account/account'
import { ActorModel } from '../activitypub/actor'
import { getSort, throwIfNotValid } from '../utils'
import { VideoModel } from './video'
enum ScopeNames {
WITH_ACCOUNT = 'WITH_ACCOUNT',
WITH_ACTOR = 'WITH_ACTOR',
WITH_VIDEOS = 'WITH_VIDEOS'
}
@DefaultScope({
include: [
{
model: () => ActorModel,
required: true
}
]
})
@Scopes({
[ScopeNames.WITH_ACCOUNT]: {
include: [
{
model: () => AccountModel,
required: true,
include: [
{
model: () => ActorModel,
required: true
}
]
}
]
},
[ScopeNames.WITH_VIDEOS]: {
include: [
() => VideoModel
]
},
[ScopeNames.WITH_ACTOR]: {
include: [
() => ActorModel
]
}
})
@Table({
tableName: 'videoChannel',
indexes: [
{
fields: [ 'accountId' ]
}
]
})
export class VideoChannelModel extends Model<VideoChannelModel> {
@AllowNull(false)
@Is('VideoChannelName', value => throwIfNotValid(value, isVideoChannelNameValid, 'name'))
@Column
name: string
@AllowNull(true)
@Is('VideoChannelDescription', value => throwIfNotValid(value, isVideoChannelDescriptionValid, 'description'))
@Column
description: string
@CreatedAt
createdAt: Date
@UpdatedAt
updatedAt: Date
@ForeignKey(() => ActorModel)
@Column
actorId: number
@BelongsTo(() => ActorModel, {
foreignKey: {
allowNull: false
},
onDelete: 'cascade'
})
Actor: ActorModel
@ForeignKey(() => AccountModel)
@Column
accountId: number
@BelongsTo(() => AccountModel, {
foreignKey: {
allowNull: false
},
onDelete: 'CASCADE'
})
Account: AccountModel
@HasMany(() => VideoModel, {
foreignKey: {
name: 'channelId',
allowNull: false
},
onDelete: 'CASCADE'
})
Videos: VideoModel[]
@AfterDestroy
static sendDeleteIfOwned (instance: VideoChannelModel) {
if (instance.Actor.isOwned()) {
return sendDeleteActor(instance.Actor, undefined)
}
return undefined
}
static countByAccount (accountId: number) {
const query = {
where: {
accountId
}
}
return VideoChannelModel.count(query)
}
static listForApi (start: number, count: number, sort: string) {
const query = {
offset: start,
limit: count,
order: [ getSort(sort) ]
}
return VideoChannelModel
.scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
.findAndCountAll(query)
.then(({ rows, count }) => {
return { total: count, data: rows }
})
}
static listByAccount (accountId: number) {
const query = {
order: [ getSort('createdAt') ],
include: [
{
model: AccountModel,
where: {
id: accountId
},
required: true
}
]
}
return VideoChannelModel
.findAndCountAll(query)
.then(({ rows, count }) => {
return { total: count, data: rows }
})
}
static loadByIdAndAccount (id: number, accountId: number) {
const options = {
where: {
id,
accountId
}
}
return VideoChannelModel
.scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
.findOne(options)
}
static loadAndPopulateAccount (id: number) {
return VideoChannelModel
.scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
.findById(id)
}
static loadByUUIDAndPopulateAccount (uuid: string) {
const options = {
include: [
{
model: ActorModel,
required: true,
where: {
uuid
}
}
]
}
return VideoChannelModel
.scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
.findOne(options)
}
static loadAndPopulateAccountAndVideos (id: number) {
const options = {
include: [
VideoModel
]
}
return VideoChannelModel
.scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_VIDEOS ])
.findById(id, options)
}
toFormattedJSON () {
const actor = this.Actor.toFormattedJSON()
const account = {
id: this.id,
displayName: this.name,
description: this.description,
isLocal: this.Actor.isOwned(),
createdAt: this.createdAt,
updatedAt: this.updatedAt
}
return Object.assign(actor, account)
}
toActivityPubObject (): ActivityPubActor {
const obj = this.Actor.toActivityPubObject(this.name, 'VideoChannel')
return Object.assign(obj, {
summary: this.description,
attributedTo: [
{
type: 'Person' as 'Person',
id: this.Account.Actor.url
}
]
})
}
}