X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fmodels%2Fvideo%2Fvideo-channel.ts;h=5598d80f615fe53f4ede030caf28b251ab55c42c;hb=88108880bbdba473cfe36ecbebc1c3c4f972e102;hp=46c2db63fa56399e0f7ed7c3992f0876253d8fdc;hpb=911238e343e1cccae349ff9c44bcffadb96fa393;p=github%2FChocobozzz%2FPeerTube.git diff --git a/server/models/video/video-channel.ts b/server/models/video/video-channel.ts index 46c2db63f..5598d80f6 100644 --- a/server/models/video/video-channel.ts +++ b/server/models/video/video-channel.ts @@ -1,349 +1,477 @@ -import * as Sequelize from 'sequelize' - -import { isVideoChannelNameValid, isVideoChannelDescriptionValid } from '../../helpers' -import { removeVideoChannelToFriends } from '../../lib' - -import { addMethodsToModel, getSort } from '../utils' import { - VideoChannelInstance, - VideoChannelAttributes, - - VideoChannelMethods -} from './video-channel-interface' - -let VideoChannel: Sequelize.Model -let toFormattedJSON: VideoChannelMethods.ToFormattedJSON -let toAddRemoteJSON: VideoChannelMethods.ToAddRemoteJSON -let toUpdateRemoteJSON: VideoChannelMethods.ToUpdateRemoteJSON -let isOwned: VideoChannelMethods.IsOwned -let countByAuthor: VideoChannelMethods.CountByAuthor -let listOwned: VideoChannelMethods.ListOwned -let listForApi: VideoChannelMethods.ListForApi -let listByAuthor: VideoChannelMethods.ListByAuthor -let loadByIdAndAuthor: VideoChannelMethods.LoadByIdAndAuthor -let loadByUUID: VideoChannelMethods.LoadByUUID -let loadAndPopulateAuthor: VideoChannelMethods.LoadAndPopulateAuthor -let loadByUUIDAndPopulateAuthor: VideoChannelMethods.LoadByUUIDAndPopulateAuthor -let loadByHostAndUUID: VideoChannelMethods.LoadByHostAndUUID -let loadAndPopulateAuthorAndVideos: VideoChannelMethods.LoadAndPopulateAuthorAndVideos - -export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) { - VideoChannel = sequelize.define('VideoChannel', - { - uuid: { - type: DataTypes.UUID, - defaultValue: DataTypes.UUIDV4, - allowNull: false, - validate: { - isUUID: 4 - } - }, - name: { - type: DataTypes.STRING, - allowNull: false, - validate: { - nameValid: value => { - const res = isVideoChannelNameValid(value) - if (res === false) throw new Error('Video channel name is not valid.') - } - } - }, - description: { - type: DataTypes.STRING, - allowNull: true, - validate: { - descriptionValid: value => { - const res = isVideoChannelDescriptionValid(value) - if (res === false) throw new Error('Video channel description is not valid.') - } - } - }, - remote: { - type: DataTypes.BOOLEAN, - allowNull: false, - defaultValue: false - } - }, - { - indexes: [ - { - fields: [ 'authorId' ] - } - ], - hooks: { - afterDestroy - } - } - ) - - const classMethods = [ - associate, - - listForApi, - listByAuthor, - listOwned, - loadByIdAndAuthor, - loadAndPopulateAuthor, - loadByUUIDAndPopulateAuthor, - loadByUUID, - loadByHostAndUUID, - loadAndPopulateAuthorAndVideos, - countByAuthor - ] - const instanceMethods = [ - isOwned, - toFormattedJSON, - toAddRemoteJSON, - toUpdateRemoteJSON - ] - addMethodsToModel(VideoChannel, classMethods, instanceMethods) - - return VideoChannel -} - -// ------------------------------ METHODS ------------------------------ - -isOwned = function (this: VideoChannelInstance) { - return this.remote === false -} - -toFormattedJSON = function (this: VideoChannelInstance) { - const json = { - id: this.id, - uuid: this.uuid, - name: this.name, - description: this.description, - isLocal: this.isOwned(), - createdAt: this.createdAt, - updatedAt: this.updatedAt - } - - if (this.Author !== undefined) { - json['owner'] = { - name: this.Author.name, - uuid: this.Author.uuid - } - } - - if (Array.isArray(this.Videos)) { - json['videos'] = this.Videos.map(v => v.toFormattedJSON()) + AllowNull, + BeforeDestroy, + BelongsTo, + Column, + CreatedAt, + DataType, + Default, + DefaultScope, + ForeignKey, + HasMany, + Is, + Model, + Scopes, + Sequelize, + Table, + UpdatedAt +} from 'sequelize-typescript' +import { ActivityPubActor } from '../../../shared/models/activitypub' +import { VideoChannel } from '../../../shared/models/videos' +import { + isVideoChannelDescriptionValid, + isVideoChannelNameValid, + isVideoChannelSupportValid +} from '../../helpers/custom-validators/video-channels' +import { sendDeleteActor } from '../../lib/activitypub/send' +import { AccountModel } from '../account/account' +import { ActorModel, unusedActorAttributesForAPI } from '../activitypub/actor' +import { buildTrigramSearchIndex, createSimilarityAttribute, getSort, throwIfNotValid } from '../utils' +import { VideoModel } from './video' +import { CONSTRAINTS_FIELDS } from '../../initializers' +import { ServerModel } from '../server/server' +import { DefineIndexesOptions } from 'sequelize' + +// FIXME: Define indexes here because there is an issue with TS and Sequelize.literal when called directly in the annotation +const indexes: DefineIndexesOptions[] = [ + buildTrigramSearchIndex('video_channel_name_trigram', 'name'), + + { + fields: [ 'accountId' ] + }, + { + fields: [ 'actorId' ] } +] - return json +enum ScopeNames { + AVAILABLE_FOR_LIST = 'AVAILABLE_FOR_LIST', + WITH_ACCOUNT = 'WITH_ACCOUNT', + WITH_ACTOR = 'WITH_ACTOR', + WITH_VIDEOS = 'WITH_VIDEOS' } -toAddRemoteJSON = function (this: VideoChannelInstance) { - const json = { - uuid: this.uuid, - name: this.name, - description: this.description, - createdAt: this.createdAt, - updatedAt: this.updatedAt, - ownerUUID: this.Author.uuid - } - - return json +type AvailableForListOptions = { + actorId: number } -toUpdateRemoteJSON = function (this: VideoChannelInstance) { - const json = { - uuid: this.uuid, - name: this.name, - description: this.description, - createdAt: this.createdAt, - updatedAt: this.updatedAt, - ownerUUID: this.Author.uuid +@DefaultScope({ + include: [ + { + model: () => ActorModel, + required: true + } + ] +}) +@Scopes({ + [ScopeNames.AVAILABLE_FOR_LIST]: (options: AvailableForListOptions) => { + const actorIdNumber = parseInt(options.actorId + '', 10) + + // Only list local channels OR channels that are on an instance followed by actorId + const inQueryInstanceFollow = '(' + + 'SELECT "actor"."serverId" FROM "actorFollow" ' + + 'INNER JOIN "actor" ON actor.id= "actorFollow"."targetActorId" ' + + 'WHERE "actorFollow"."actorId" = ' + actorIdNumber + + ')' + + return { + include: [ + { + attributes: { + exclude: unusedActorAttributesForAPI + }, + model: ActorModel, + where: { + [Sequelize.Op.or]: [ + { + serverId: null + }, + { + serverId: { + [ Sequelize.Op.in ]: Sequelize.literal(inQueryInstanceFollow) + } + } + ] + } + }, + { + model: AccountModel, + required: true, + include: [ + { + attributes: { + exclude: unusedActorAttributesForAPI + }, + model: ActorModel, // Default scope includes avatar and server + required: true + } + ] + } + ] + } + }, + [ScopeNames.WITH_ACCOUNT]: { + include: [ + { + model: () => AccountModel, + required: true + } + ] + }, + [ScopeNames.WITH_VIDEOS]: { + include: [ + () => VideoModel + ] + }, + [ScopeNames.WITH_ACTOR]: { + include: [ + () => ActorModel + ] } +}) +@Table({ + tableName: 'videoChannel', + indexes +}) +export class VideoChannelModel extends Model { + + @AllowNull(false) + @Is('VideoChannelName', value => throwIfNotValid(value, isVideoChannelNameValid, 'name')) + @Column + name: string + + @AllowNull(true) + @Default(null) + @Is('VideoChannelDescription', value => throwIfNotValid(value, isVideoChannelDescriptionValid, 'description')) + @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.DESCRIPTION.max)) + description: string + + @AllowNull(true) + @Default(null) + @Is('VideoChannelSupport', value => throwIfNotValid(value, isVideoChannelSupportValid, 'support')) + @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.SUPPORT.max)) + support: string + + @CreatedAt + createdAt: Date + + @UpdatedAt + updatedAt: Date + + @ForeignKey(() => ActorModel) + @Column + actorId: number + + @BelongsTo(() => ActorModel, { + foreignKey: { + allowNull: false + }, + onDelete: 'cascade' + }) + Actor: ActorModel - return json -} - -// ------------------------------ STATICS ------------------------------ + @ForeignKey(() => AccountModel) + @Column + accountId: number -function associate (models) { - VideoChannel.belongsTo(models.Author, { + @BelongsTo(() => AccountModel, { foreignKey: { - name: 'authorId', allowNull: false }, - onDelete: 'CASCADE' + hooks: true }) + Account: AccountModel - VideoChannel.hasMany(models.Video, { + @HasMany(() => VideoModel, { foreignKey: { name: 'channelId', allowNull: false }, - onDelete: 'CASCADE' + onDelete: 'CASCADE', + hooks: true }) -} + Videos: VideoModel[] -function afterDestroy (videoChannel: VideoChannelInstance) { - if (videoChannel.isOwned()) { - const removeVideoChannelToFriendsParams = { - uuid: videoChannel.uuid + @BeforeDestroy + static async sendDeleteIfOwned (instance: VideoChannelModel, options) { + if (!instance.Actor) { + instance.Actor = await instance.$get('Actor', { transaction: options.transaction }) as ActorModel } - return removeVideoChannelToFriends(removeVideoChannelToFriendsParams) - } + if (instance.Actor.isOwned()) { + return sendDeleteActor(instance.Actor, options.transaction) + } - return undefined -} + return undefined + } -countByAuthor = function (authorId: number) { - const query = { - where: { - authorId + static countByAccount (accountId: number) { + const query = { + where: { + accountId + } } + + return VideoChannelModel.count(query) } - return VideoChannel.count(query) -} + static listForApi (actorId: number, start: number, count: number, sort: string) { + const query = { + offset: start, + limit: count, + order: getSort(sort) + } -listOwned = function () { - const query = { - where: { - remote: false - }, - include: [ VideoChannel['sequelize'].models.Author ] + const scopes = { + method: [ ScopeNames.AVAILABLE_FOR_LIST, { actorId } as AvailableForListOptions ] + } + return VideoChannelModel + .scope(scopes) + .findAndCountAll(query) + .then(({ rows, count }) => { + return { total: count, data: rows } + }) } - return VideoChannel.findAll(query) -} + static listLocalsForSitemap (sort: string) { + const query = { + attributes: [ ], + offset: 0, + order: getSort(sort), + include: [ + { + attributes: [ 'preferredUsername', 'serverId' ], + model: ActorModel.unscoped(), + where: { + serverId: null + } + } + ] + } -listForApi = function (start: number, count: number, sort: string) { - const query = { - offset: start, - limit: count, - order: [ getSort(sort) ], - include: [ - { - model: VideoChannel['sequelize'].models.Author, - required: true, - include: [ { model: VideoChannel['sequelize'].models.Pod, required: false } ] + return VideoChannelModel + .unscoped() + .findAll(query) + } + + static searchForApi (options: { + actorId: number + search: string + start: number + count: number + sort: string + }) { + const attributesInclude = [] + const escapedSearch = VideoModel.sequelize.escape(options.search) + const escapedLikeSearch = VideoModel.sequelize.escape('%' + options.search + '%') + attributesInclude.push(createSimilarityAttribute('VideoChannelModel.name', options.search)) + + const query = { + attributes: { + include: attributesInclude + }, + offset: options.start, + limit: options.count, + order: getSort(options.sort), + where: { + [Sequelize.Op.or]: [ + Sequelize.literal( + 'lower(immutable_unaccent("VideoChannelModel"."name")) % lower(immutable_unaccent(' + escapedSearch + '))' + ), + Sequelize.literal( + 'lower(immutable_unaccent("VideoChannelModel"."name")) LIKE lower(immutable_unaccent(' + escapedLikeSearch + '))' + ) + ] } - ] + } + + const scopes = { + method: [ ScopeNames.AVAILABLE_FOR_LIST, { actorId: options.actorId } as AvailableForListOptions ] + } + return VideoChannelModel + .scope(scopes) + .findAndCountAll(query) + .then(({ rows, count }) => { + return { total: count, data: rows } + }) } - return VideoChannel.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 + } + ] + } -listByAuthor = function (authorId: number) { - const query = { - order: [ getSort('createdAt') ], - include: [ - { - model: VideoChannel['sequelize'].models.Author, - where: { - id: authorId - }, - required: true, - include: [ { model: VideoChannel['sequelize'].models.Pod, required: false } ] - } - ] + return VideoChannelModel + .findAndCountAll(query) + .then(({ rows, count }) => { + return { total: count, data: rows } + }) } - return VideoChannel.findAndCountAll(query).then(({ rows, count }) => { - return { total: count, data: rows } - }) -} + static loadByIdAndPopulateAccount (id: number) { + return VideoChannelModel.unscoped() + .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ]) + .findById(id) + } -loadByUUID = function (uuid: string, t?: Sequelize.Transaction) { - const query: Sequelize.FindOptions = { - where: { - uuid + static loadByIdAndAccount (id: number, accountId: number) { + const query = { + where: { + id, + accountId + } } + + return VideoChannelModel.unscoped() + .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ]) + .findOne(query) } - if (t !== undefined) query.transaction = t + static loadAndPopulateAccount (id: number) { + return VideoChannelModel.unscoped() + .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ]) + .findById(id) + } - return VideoChannel.findOne(query) -} + static loadByUUIDAndPopulateAccount (uuid: string) { + const query = { + include: [ + { + model: ActorModel, + required: true, + where: { + uuid + } + } + ] + } -loadByHostAndUUID = function (fromHost: string, uuid: string, t?: Sequelize.Transaction) { - const query: Sequelize.FindOptions = { - where: { - uuid - }, - include: [ - { - model: VideoChannel['sequelize'].models.Author, - include: [ - { - model: VideoChannel['sequelize'].models.Pod, - required: true, - where: { - host: fromHost - } + return VideoChannelModel + .scope([ ScopeNames.WITH_ACCOUNT ]) + .findOne(query) + } + + static loadByUrlAndPopulateAccount (url: string) { + const query = { + include: [ + { + model: ActorModel, + required: true, + where: { + url } - ] - } - ] + } + ] + } + + return VideoChannelModel + .scope([ ScopeNames.WITH_ACCOUNT ]) + .findOne(query) } - if (t !== undefined) query.transaction = t + static loadLocalByNameAndPopulateAccount (name: string) { + const query = { + include: [ + { + model: ActorModel, + required: true, + where: { + preferredUsername: name, + serverId: null + } + } + ] + } - return VideoChannel.findOne(query) -} + return VideoChannelModel.unscoped() + .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ]) + .findOne(query) + } -loadByIdAndAuthor = function (id: number, authorId: number) { - const options = { - where: { - id, - authorId - }, - include: [ - { - model: VideoChannel['sequelize'].models.Author, - include: [ { model: VideoChannel['sequelize'].models.Pod, required: false } ] - } - ] + static loadByNameAndHostAndPopulateAccount (name: string, host: string) { + const query = { + include: [ + { + model: ActorModel, + required: true, + where: { + preferredUsername: name + }, + include: [ + { + model: ServerModel, + required: true, + where: { host } + } + ] + } + ] + } + + return VideoChannelModel.unscoped() + .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ]) + .findOne(query) } - return VideoChannel.findOne(options) -} + static loadAndPopulateAccountAndVideos (id: number) { + const options = { + include: [ + VideoModel + ] + } -loadAndPopulateAuthor = function (id: number) { - const options = { - include: [ - { - model: VideoChannel['sequelize'].models.Author, - include: [ { model: VideoChannel['sequelize'].models.Pod, required: false } ] - } - ] + return VideoChannelModel.unscoped() + .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_VIDEOS ]) + .findById(id, options) } - return VideoChannel.findById(id, options) -} + toFormattedJSON (): VideoChannel { + const actor = this.Actor.toFormattedJSON() + const videoChannel = { + id: this.id, + displayName: this.getDisplayName(), + description: this.description, + support: this.support, + isLocal: this.Actor.isOwned(), + createdAt: this.createdAt, + updatedAt: this.updatedAt, + ownerAccount: undefined + } -loadByUUIDAndPopulateAuthor = function (uuid: string) { - const options = { - where: { - uuid - }, - include: [ - { - model: VideoChannel['sequelize'].models.Author, - include: [ { model: VideoChannel['sequelize'].models.Pod, required: false } ] - } - ] + if (this.Account) videoChannel.ownerAccount = this.Account.toFormattedJSON() + + return Object.assign(actor, videoChannel) } - return VideoChannel.findOne(options) -} + toActivityPubObject (): ActivityPubActor { + const obj = this.Actor.toActivityPubObject(this.name, 'VideoChannel') -loadAndPopulateAuthorAndVideos = function (id: number) { - const options = { - include: [ - { - model: VideoChannel['sequelize'].models.Author, - include: [ { model: VideoChannel['sequelize'].models.Pod, required: false } ] - }, - VideoChannel['sequelize'].models.Video - ] + return Object.assign(obj, { + summary: this.description, + support: this.support, + attributedTo: [ + { + type: 'Person' as 'Person', + id: this.Account.Actor.url + } + ] + }) + } + + getDisplayName () { + return this.name } - return VideoChannel.findById(id, options) + isOutdated () { + return this.Actor.isOutdated() + } }