X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fmodels%2Fvideo%2Fvideo-channel.ts;h=4e98e7ba3f064333176f8a30c2e87c98365c7518;hb=0374b6b5cd685316f924874b2a3068bb345eb0dd;hp=4a50af265fae906a65f0e060688ef7f1b70ffb7c;hpb=6b738c7a31591a83fdcd9c78b6b1f98e543c378b;p=github%2FChocobozzz%2FPeerTube.git diff --git a/server/models/video/video-channel.ts b/server/models/video/video-channel.ts index 4a50af265..4e98e7ba3 100644 --- a/server/models/video/video-channel.ts +++ b/server/models/video/video-channel.ts @@ -1,65 +1,177 @@ import { - AllowNull, BeforeDestroy, BelongsTo, Column, CreatedAt, DefaultScope, ForeignKey, HasMany, Is, Model, Scopes, Table, - UpdatedAt, Default + 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 { VideoChannel, VideoChannelSummary } from '../../../shared/models/videos' import { - isVideoChannelDescriptionValid, isVideoChannelNameValid, + isVideoChannelDescriptionValid, + isVideoChannelNameValid, isVideoChannelSupportValid } from '../../helpers/custom-validators/video-channels' -import { logger } from '../../helpers/logger' import { sendDeleteActor } from '../../lib/activitypub/send' -import { AccountModel } from '../account/account' -import { ActorModel } from '../activitypub/actor' -import { getSort, throwIfNotValid } from '../utils' +import { AccountModel, ScopeNames as AccountModelScopeNames, SummaryOptions as AccountSummaryOptions } from '../account/account' +import { ActorModel, unusedActorAttributesForAPI } from '../activitypub/actor' +import { buildServerIdsFollowedBy, buildTrigramSearchIndex, createSimilarityAttribute, getSort, throwIfNotValid } from '../utils' import { VideoModel } from './video' - -enum ScopeNames { +import { CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants' +import { ServerModel } from '../server/server' +import { FindOptions, ModelIndexesOptions, Op } from 'sequelize' +import { AvatarModel } from '../avatar/avatar' +import { VideoPlaylistModel } from './video-playlist' +import * as Bluebird from 'bluebird' +import { + MChannelAccountDefault, + MChannelActor, + MChannelActorAccountDefaultVideos, + MChannelAP, + MChannelFormattable, + MChannelSummaryFormattable +} from '../../typings/models/video' + +export enum ScopeNames { + FOR_API = 'FOR_API', WITH_ACCOUNT = 'WITH_ACCOUNT', WITH_ACTOR = 'WITH_ACTOR', - WITH_VIDEOS = 'WITH_VIDEOS' + WITH_VIDEOS = 'WITH_VIDEOS', + SUMMARY = 'SUMMARY' +} + +type AvailableForListOptions = { + actorId: number } -@DefaultScope({ +export type SummaryOptions = { + withAccount?: boolean // Default: false + withAccountBlockerIds?: number[] +} + +@DefaultScope(() => ({ include: [ { - model: () => ActorModel, + model: ActorModel, required: true } ] -}) -@Scopes({ +})) +@Scopes(() => ({ + [ScopeNames.SUMMARY]: (options: SummaryOptions = {}) => { + const base: FindOptions = { + attributes: [ 'id', 'name', 'description', 'actorId' ], + include: [ + { + attributes: [ 'id', 'preferredUsername', 'url', 'serverId', 'avatarId' ], + model: ActorModel.unscoped(), + required: true, + include: [ + { + attributes: [ 'host' ], + model: ServerModel.unscoped(), + required: false + }, + { + model: AvatarModel.unscoped(), + required: false + } + ] + } + ] + } + + if (options.withAccount === true) { + base.include.push({ + model: AccountModel.scope({ + method: [ AccountModelScopeNames.SUMMARY, { withAccountBlockerIds: options.withAccountBlockerIds } as AccountSummaryOptions ] + }), + required: true + }) + } + + return base + }, + [ScopeNames.FOR_API]: (options: AvailableForListOptions) => { + // Only list local channels OR channels that are on an instance followed by actorId + const inQueryInstanceFollow = buildServerIdsFollowedBy(options.actorId) + + return { + include: [ + { + attributes: { + exclude: unusedActorAttributesForAPI + }, + model: ActorModel, + where: { + [Op.or]: [ + { + serverId: null + }, + { + serverId: { + [ 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, - include: [ - { - model: () => ActorModel, - required: true - } - ] + model: AccountModel, + required: true } ] }, [ScopeNames.WITH_VIDEOS]: { include: [ - () => VideoModel + VideoModel ] }, [ScopeNames.WITH_ACTOR]: { include: [ - () => ActorModel + ActorModel ] } -}) +})) @Table({ tableName: 'videoChannel', indexes: [ + buildTrigramSearchIndex('video_channel_name_trigram', 'name'), + { fields: [ 'accountId' ] + }, + { + fields: [ 'actorId' ] } ] }) @@ -72,14 +184,14 @@ export class VideoChannelModel extends Model { @AllowNull(true) @Default(null) - @Is('VideoChannelDescription', value => throwIfNotValid(value, isVideoChannelDescriptionValid, 'description')) - @Column + @Is('VideoChannelDescription', value => throwIfNotValid(value, isVideoChannelDescriptionValid, 'description', true)) + @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.DESCRIPTION.max)) description: string @AllowNull(true) @Default(null) - @Is('VideoChannelSupport', value => throwIfNotValid(value, isVideoChannelSupportValid, 'support')) - @Column + @Is('VideoChannelSupport', value => throwIfNotValid(value, isVideoChannelSupportValid, 'support', true)) + @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.SUPPORT.max)) support: string @CreatedAt @@ -122,15 +234,22 @@ export class VideoChannelModel extends Model { }) Videos: VideoModel[] + @HasMany(() => VideoPlaylistModel, { + foreignKey: { + allowNull: true + }, + onDelete: 'CASCADE', + hooks: true + }) + VideoPlaylists: VideoPlaylistModel[] + @BeforeDestroy static async sendDeleteIfOwned (instance: VideoChannelModel, options) { if (!instance.Actor) { - instance.Actor = await instance.$get('Actor', { transaction: options.transaction }) as ActorModel + instance.Actor = await instance.$get('Actor', { transaction: options.transaction }) } if (instance.Actor.isOwned()) { - logger.debug('Sending delete of actor of video channel %s.', instance.Actor.url) - return sendDeleteActor(instance.Actor, options.transaction) } @@ -147,29 +266,102 @@ export class VideoChannelModel extends Model { return VideoChannelModel.count(query) } - static listForApi (start: number, count: number, sort: string) { + static listForApi (actorId: number, start: number, count: number, sort: string) { const query = { offset: start, limit: count, order: getSort(sort) } + const scopes = { + method: [ ScopeNames.FOR_API, { actorId } as AvailableForListOptions ] + } return VideoChannelModel - .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ]) + .scope(scopes) .findAndCountAll(query) .then(({ rows, count }) => { return { total: count, data: rows } }) } - static listByAccount (accountId: number) { + static listLocalsForSitemap (sort: string): Bluebird { const query = { - order: getSort('createdAt'), + attributes: [ ], + offset: 0, + order: getSort(sort), + include: [ + { + attributes: [ 'preferredUsername', 'serverId' ], + model: ActorModel.unscoped(), + where: { + serverId: null + } + } + ] + } + + 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: { + [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.FOR_API, { actorId: options.actorId } as AvailableForListOptions ] + } + return VideoChannelModel + .scope(scopes) + .findAndCountAll(query) + .then(({ rows, count }) => { + return { total: count, data: rows } + }) + } + + static listByAccount (options: { + accountId: number, + start: number, + count: number, + sort: string + }) { + const query = { + offset: options.start, + limit: options.count, + order: getSort(options.sort), include: [ { model: AccountModel, where: { - id: accountId + id: options.accountId }, required: true } @@ -183,81 +375,146 @@ export class VideoChannelModel extends Model { }) } - static loadByIdAndAccount (id: number, accountId: number) { - const options = { + static loadByIdAndPopulateAccount (id: number): Bluebird { + return VideoChannelModel.unscoped() + .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ]) + .findByPk(id) + } + + static loadByIdAndAccount (id: number, accountId: number): Bluebird { + const query = { where: { id, accountId } } - return VideoChannelModel + return VideoChannelModel.unscoped() .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ]) - .findOne(options) + .findOne(query) } - static loadAndPopulateAccount (id: number) { - return VideoChannelModel + static loadAndPopulateAccount (id: number): Bluebird { + return VideoChannelModel.unscoped() .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ]) - .findById(id) + .findByPk(id) } - static loadByUUIDAndPopulateAccount (uuid: string) { - const options = { + static loadByUrlAndPopulateAccount (url: string): Bluebird { + const query = { include: [ { model: ActorModel, required: true, where: { - uuid + url } } ] } return VideoChannelModel + .scope([ ScopeNames.WITH_ACCOUNT ]) + .findOne(query) + } + + static loadByNameWithHostAndPopulateAccount (nameWithHost: string) { + const [ name, host ] = nameWithHost.split('@') + + if (!host || host === WEBSERVER.HOST) return VideoChannelModel.loadLocalByNameAndPopulateAccount(name) + + return VideoChannelModel.loadByNameAndHostAndPopulateAccount(name, host) + } + + static loadLocalByNameAndPopulateAccount (name: string): Bluebird { + const query = { + include: [ + { + model: ActorModel, + required: true, + where: { + preferredUsername: name, + serverId: null + } + } + ] + } + + return VideoChannelModel.unscoped() + .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ]) + .findOne(query) + } + + static loadByNameAndHostAndPopulateAccount (name: string, host: string): Bluebird { + 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(options) + .findOne(query) } - static loadAndPopulateAccountAndVideos (id: number) { + static loadAndPopulateAccountAndVideos (id: number): Bluebird { const options = { include: [ VideoModel ] } - return VideoChannelModel + return VideoChannelModel.unscoped() .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_VIDEOS ]) - .findById(id, options) + .findByPk(id, options) + } + + toFormattedSummaryJSON (this: MChannelSummaryFormattable): VideoChannelSummary { + const actor = this.Actor.toFormattedSummaryJSON() + + return { + id: this.id, + name: actor.name, + displayName: this.getDisplayName(), + url: actor.url, + host: actor.host, + avatar: actor.avatar + } } - toFormattedJSON (): VideoChannel { + toFormattedJSON (this: MChannelFormattable): VideoChannel { const actor = this.Actor.toFormattedJSON() const videoChannel = { id: this.id, - displayName: this.name, + displayName: this.getDisplayName(), description: this.description, support: this.support, isLocal: this.Actor.isOwned(), createdAt: this.createdAt, updatedAt: this.updatedAt, - ownerAccount: undefined, - videos: undefined + ownerAccount: undefined } - if (this.Account) { - videoChannel.ownerAccount = { - id: this.Account.id, - uuid: this.Account.Actor.uuid - } - } + if (this.Account) videoChannel.ownerAccount = this.Account.toFormattedJSON() return Object.assign(actor, videoChannel) } - toActivityPubObject (): ActivityPubActor { - const obj = this.Actor.toActivityPubObject(this.name, 'VideoChannel') + toActivityPubObject (this: MChannelAP): ActivityPubActor { + const obj = this.Actor.toActivityPubObject(this.name) return Object.assign(obj, { summary: this.description, @@ -270,4 +527,12 @@ export class VideoChannelModel extends Model { ] }) } + + getDisplayName () { + return this.name + } + + isOutdated () { + return this.Actor.isOutdated() + } }