X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fmodels%2Fvideo%2Fvideo-channel.ts;h=03a3cdf81da8c7c7f6d84cc89666bbc67936cbbe;hb=4f32032fed8587ea97d45e235b167e8958efd81f;hp=068c8029d033eb0cec79c446495bc42fa63ae7e2;hpb=d48ff09d27d234425c3e9f091ae9072d8e6d8b7a;p=github%2FChocobozzz%2FPeerTube.git diff --git a/server/models/video/video-channel.ts b/server/models/video/video-channel.ts index 068c8029d..03a3cdf81 100644 --- a/server/models/video/video-channel.ts +++ b/server/models/video/video-channel.ts @@ -1,87 +1,241 @@ -import * as Sequelize from 'sequelize' import { - AfterDestroy, AllowNull, + BeforeDestroy, BelongsTo, Column, CreatedAt, DataType, Default, + DefaultScope, ForeignKey, HasMany, Is, - IsUUID, - Model, Scopes, + Model, + Scopes, + Sequelize, Table, UpdatedAt } from 'sequelize-typescript' -import { IFindOptions } from 'sequelize-typescript/lib/interfaces/IFindOptions' -import { activityPubCollection } from '../../helpers' -import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub' -import { isVideoChannelDescriptionValid, isVideoChannelNameValid } from '../../helpers/custom-validators/video-channels' -import { CONSTRAINTS_FIELDS } from '../../initializers' -import { getAnnounceActivityPubUrl } from '../../lib/activitypub' -import { sendDeleteVideoChannel } from '../../lib/activitypub/send' -import { AccountModel } from '../account/account' -import { ServerModel } from '../server/server' -import { getSort, throwIfNotValid } from '../utils' +import { ActivityPubActor } from '../../../shared/models/activitypub' +import { VideoChannel, VideoChannelSummary } from '../../../shared/models/videos' +import { + isVideoChannelDescriptionValid, + isVideoChannelNameValid, + isVideoChannelSupportValid +} from '../../helpers/custom-validators/video-channels' +import { sendDeleteActor } from '../../lib/activitypub/send' +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' -import { VideoChannelShareModel } from './video-channel-share' - -enum ScopeNames { +import { CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants' +import { ServerModel } from '../server/server' +import { FindOptions, Op, literal, ScopeOptions } 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 '../../types/models/video' + +export enum ScopeNames { + FOR_API = 'FOR_API', + SUMMARY = 'SUMMARY', WITH_ACCOUNT = 'WITH_ACCOUNT', - WITH_VIDEOS = 'WITH_VIDEOS' + WITH_ACTOR = 'WITH_ACTOR', + WITH_VIDEOS = 'WITH_VIDEOS', + WITH_STATS = 'WITH_STATS' +} + +type AvailableForListOptions = { + actorId: number +} + +type AvailableWithStatsOptions = { + daysPrior: number +} + +export type SummaryOptions = { + actorRequired?: boolean // Default: true + withAccount?: boolean // Default: false + withAccountBlockerIds?: number[] } -@Scopes({ +@DefaultScope(() => ({ + include: [ + { + model: ActorModel, + required: true + } + ] +})) +@Scopes(() => ({ + [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.SUMMARY]: (options: SummaryOptions = {}) => { + const base: FindOptions = { + attributes: [ 'id', 'name', 'description', 'actorId' ], + include: [ + { + attributes: [ 'id', 'preferredUsername', 'url', 'serverId', 'avatarId' ], + model: ActorModel.unscoped(), + required: options.actorRequired ?? 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.WITH_ACCOUNT]: { include: [ { - model: () => AccountModel, - include: [ { model: () => ServerModel, required: false } ] + model: AccountModel, + required: true } ] }, + [ScopeNames.WITH_ACTOR]: { + include: [ + ActorModel + ] + }, [ScopeNames.WITH_VIDEOS]: { include: [ - () => VideoModel + VideoModel ] + }, + [ScopeNames.WITH_STATS]: (options: AvailableWithStatsOptions = { daysPrior: 30 }) => { + const daysPrior = parseInt(options.daysPrior + '', 10) + + return { + attributes: { + include: [ + [ + literal('(SELECT COUNT(*) FROM "video" WHERE "channelId" = "VideoChannelModel"."id")'), + 'videosCount' + ], + [ + literal( + '(' + + `SELECT string_agg(concat_ws('|', t.day, t.views), ',') ` + + 'FROM ( ' + + 'WITH ' + + 'days AS ( ' + + `SELECT generate_series(date_trunc('day', now()) - '${daysPrior} day'::interval, ` + + `date_trunc('day', now()), '1 day'::interval) AS day ` + + ') ' + + 'SELECT days.day AS day, COALESCE(SUM("videoView".views), 0) AS views ' + + 'FROM days ' + + 'LEFT JOIN (' + + '"videoView" INNER JOIN "video" ON "videoView"."videoId" = "video"."id" ' + + 'AND "video"."channelId" = "VideoChannelModel"."id"' + + `) ON date_trunc('day', "videoView"."startDate") = date_trunc('day', days.day) ` + + 'GROUP BY day ' + + 'ORDER BY day ' + + ') t' + + ')' + ), + 'viewsPerDay' + ] + ] + } + } } -}) +})) @Table({ tableName: 'videoChannel', indexes: [ + buildTrigramSearchIndex('video_channel_name_trigram', 'name'), + { fields: [ 'accountId' ] + }, + { + fields: [ 'actorId' ] } ] }) export class VideoChannelModel extends Model { - @AllowNull(false) - @Default(DataType.UUIDV4) - @IsUUID(4) - @Column(DataType.UUID) - uuid: string - @AllowNull(false) @Is('VideoChannelName', value => throwIfNotValid(value, isVideoChannelNameValid, 'name')) @Column name: string @AllowNull(true) - @Is('VideoChannelDescription', value => throwIfNotValid(value, isVideoChannelDescriptionValid, 'description')) - @Column + @Default(null) + @Is('VideoChannelDescription', value => throwIfNotValid(value, isVideoChannelDescriptionValid, 'description', true)) + @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.DESCRIPTION.max)) description: string - @AllowNull(false) - @Column - remote: boolean - - @AllowNull(false) - @Is('VideoChannelUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url')) - @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.URL.max)) - url: string + @AllowNull(true) + @Default(null) + @Is('VideoChannelSupport', value => throwIfNotValid(value, isVideoChannelSupportValid, 'support', true)) + @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.SUPPORT.max)) + support: string @CreatedAt createdAt: Date @@ -89,6 +243,18 @@ export class VideoChannelModel extends Model { @UpdatedAt updatedAt: Date + @ForeignKey(() => ActorModel) + @Column + actorId: number + + @BelongsTo(() => ActorModel, { + foreignKey: { + allowNull: false + }, + onDelete: 'cascade' + }) + Actor: ActorModel + @ForeignKey(() => AccountModel) @Column accountId: number @@ -97,7 +263,7 @@ export class VideoChannelModel extends Model { foreignKey: { allowNull: false }, - onDelete: 'CASCADE' + hooks: true }) Account: AccountModel @@ -106,23 +272,28 @@ export class VideoChannelModel extends Model { name: 'channelId', allowNull: false }, - onDelete: 'CASCADE' + onDelete: 'CASCADE', + hooks: true }) Videos: VideoModel[] - @HasMany(() => VideoChannelShareModel, { + @HasMany(() => VideoPlaylistModel, { foreignKey: { - name: 'channelId', - allowNull: false + allowNull: true }, - onDelete: 'CASCADE' + onDelete: 'CASCADE', + hooks: true }) - VideoChannelShares: VideoChannelShareModel[] + VideoPlaylists: VideoPlaylistModel[] - @AfterDestroy - static sendDeleteIfOwned (instance: VideoChannelModel) { - if (instance.isOwned()) { - return sendDeleteVideoChannel(instance, undefined) + @BeforeDestroy + static async sendDeleteIfOwned (instance: VideoChannelModel, options) { + if (!instance.Actor) { + instance.Actor = await instance.$get('Actor', { transaction: options.transaction }) + } + + if (instance.Actor.isOwned()) { + return sendDeleteActor(instance.Actor, options.transaction) } return undefined @@ -138,153 +309,302 @@ 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) ] + order: getSort(sort) } - return VideoChannelModel.scope(ScopeNames.WITH_ACCOUNT).findAndCountAll(query) + const scopes = { + method: [ ScopeNames.FOR_API, { actorId } as AvailableForListOptions ] + } + return VideoChannelModel + .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: [ { - model: AccountModel, + attributes: [ 'preferredUsername', 'serverId' ], + model: ActorModel.unscoped(), where: { - id: accountId - }, - required: true, - include: [ { model: ServerModel, required: false } ] + serverId: null + } } ] } - return VideoChannelModel.findAndCountAll(query) - .then(({ rows, count }) => { - return { total: count, data: rows } - }) + return VideoChannelModel + .unscoped() + .findAll(query) } - static loadByUrl (url: string, t?: Sequelize.Transaction) { - const query: IFindOptions = { + 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: { - url + [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 + '))' + ) + ] } } - if (t !== undefined) query.transaction = t - - return VideoChannelModel.scope(ScopeNames.WITH_ACCOUNT).findOne(query) + 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 loadByUUIDOrUrl (uuid: string, url: string, t?: Sequelize.Transaction) { - const query: IFindOptions = { - where: { - [ Sequelize.Op.or ]: [ - { uuid }, - { url } - ] - } + static listByAccount (options: { + accountId: number + start: number + count: number + sort: string + withStats?: boolean + }) { + const query = { + offset: options.start, + limit: options.count, + order: getSort(options.sort), + include: [ + { + model: AccountModel, + where: { + id: options.accountId + }, + required: true + } + ] } - if (t !== undefined) query.transaction = t + const scopes: string | ScopeOptions | (string | ScopeOptions)[] = [ ScopeNames.WITH_ACTOR ] + + if (options.withStats === true) { + scopes.push({ + method: [ ScopeNames.WITH_STATS, { daysPrior: 30 } as AvailableWithStatsOptions ] + }) + } - return VideoChannelModel.findOne(query) + return VideoChannelModel + .scope(scopes) + .findAndCountAll(query) + .then(({ rows, count }) => { + return { total: count, data: rows } + }) } - 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.scope(ScopeNames.WITH_ACCOUNT).findOne(options) + return VideoChannelModel.unscoped() + .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ]) + .findOne(query) } - static loadAndPopulateAccount (id: number) { - return VideoChannelModel.scope(ScopeNames.WITH_ACCOUNT).findById(id) + static loadAndPopulateAccount (id: number): Bluebird { + return VideoChannelModel.unscoped() + .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ]) + .findByPk(id) } - static loadByUUIDAndPopulateAccount (uuid: string) { - const options = { - where: { - uuid - } + static loadByUrlAndPopulateAccount (url: string): Bluebird { + const query = { + include: [ + { + model: ActorModel, + required: true, + where: { + 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.scope(ScopeNames.WITH_ACCOUNT).findOne(options) + return VideoChannelModel.unscoped() + .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ]) + .findOne(query) } - static loadAndPopulateAccountAndVideos (id: number) { + 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(query) + } + + static loadAndPopulateAccountAndVideos (id: number): Bluebird { const options = { include: [ VideoModel ] } - return VideoChannelModel.scope([ ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_VIDEOS ]).findById(id, options) + return VideoChannelModel.unscoped() + .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_VIDEOS ]) + .findByPk(id, options) } - isOwned () { - return this.remote === false - } + toFormattedSummaryJSON (this: MChannelSummaryFormattable): VideoChannelSummary { + const actor = this.Actor.toFormattedSummaryJSON() - toFormattedJSON () { - const json = { + return { id: this.id, - uuid: this.uuid, - name: this.name, - description: this.description, - isLocal: this.isOwned(), - createdAt: this.createdAt, - updatedAt: this.updatedAt + name: actor.name, + displayName: this.getDisplayName(), + url: actor.url, + host: actor.host, + avatar: actor.avatar } + } - if (this.Account !== undefined) { - json[ 'owner' ] = { - name: this.Account.name, - uuid: this.Account.uuid - } + toFormattedJSON (this: MChannelFormattable): VideoChannel { + const viewsPerDayString = this.get('viewsPerDay') as string + const videosCount = this.get('videosCount') as number + + let viewsPerDay: { date: Date, views: number }[] + + if (viewsPerDayString) { + viewsPerDay = viewsPerDayString.split(',') + .map(v => { + const [ dateString, amount ] = v.split('|') + + return { + date: new Date(dateString), + views: +amount + } + }) } - if (Array.isArray(this.Videos)) { - json[ 'videos' ] = this.Videos.map(v => v.toFormattedJSON()) + 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, + videosCount, + viewsPerDay } - return json + if (this.Account) videoChannel.ownerAccount = this.Account.toFormattedJSON() + + return Object.assign(actor, videoChannel) } - toActivityPubObject () { - let sharesObject - if (Array.isArray(this.VideoChannelShares)) { - const shares: string[] = [] + toActivityPubObject (this: MChannelAP): ActivityPubActor { + const obj = this.Actor.toActivityPubObject(this.name) - for (const videoChannelShare of this.VideoChannelShares) { - const shareUrl = getAnnounceActivityPubUrl(this.url, videoChannelShare.Account) - shares.push(shareUrl) - } + return Object.assign(obj, { + summary: this.description, + support: this.support, + attributedTo: [ + { + type: 'Person' as 'Person', + id: this.Account.Actor.url + } + ] + }) + } - sharesObject = activityPubCollection(shares) - } + getDisplayName () { + return this.name + } - return { - type: 'VideoChannel' as 'VideoChannel', - id: this.url, - uuid: this.uuid, - content: this.description, - name: this.name, - published: this.createdAt.toISOString(), - updated: this.updatedAt.toISOString(), - shares: sharesObject - } + isOutdated () { + return this.Actor.isOutdated() } }