PeerTube/server/models/user/user-notification.ts

670 lines
18 KiB
TypeScript
Raw Normal View History

2020-07-01 16:05:30 +02:00
import { FindOptions, ModelIndexesOptions, Op, WhereOptions } from 'sequelize'
2019-04-18 11:28:17 +02:00
import { AllowNull, BelongsTo, Column, CreatedAt, Default, ForeignKey, Is, Model, Scopes, Table, UpdatedAt } from 'sequelize-typescript'
2020-07-01 16:05:30 +02:00
import { UserNotificationIncludes, UserNotificationModelForApi } from '@server/types/models/user'
import { uuidToShort } from '@shared/extra-utils'
2021-12-24 10:14:47 +01:00
import { UserNotification, UserNotificationType } from '@shared/models'
import { AttributesOnly } from '@shared/typescript-utils'
2018-12-26 10:36:24 +01:00
import { isBooleanValid } from '../../helpers/custom-validators/misc'
import { isUserNotificationTypeValid } from '../../helpers/custom-validators/user-notifications'
2020-07-01 16:05:30 +02:00
import { AbuseModel } from '../abuse/abuse'
import { VideoAbuseModel } from '../abuse/video-abuse'
import { VideoCommentAbuseModel } from '../abuse/video-comment-abuse'
2021-05-11 11:15:29 +02:00
import { AccountModel } from '../account/account'
import { ActorModel } from '../actor/actor'
import { ActorFollowModel } from '../actor/actor-follow'
import { ActorImageModel } from '../actor/actor-image'
2021-03-11 16:54:52 +01:00
import { ApplicationModel } from '../application/application'
import { PluginModel } from '../server/plugin'
import { ServerModel } from '../server/server'
2020-07-01 16:05:30 +02:00
import { getSort, throwIfNotValid } from '../utils'
import { VideoModel } from '../video/video'
import { VideoBlacklistModel } from '../video/video-blacklist'
import { VideoChannelModel } from '../video/video-channel'
import { VideoCommentModel } from '../video/video-comment'
import { VideoImportModel } from '../video/video-import'
import { UserModel } from './user'
2018-12-26 10:36:24 +01:00
enum ScopeNames {
WITH_ALL = 'WITH_ALL'
}
function buildActorWithAvatarInclude () {
return {
attributes: [ 'preferredUsername' ],
2019-04-23 09:50:57 +02:00
model: ActorModel.unscoped(),
required: true,
include: [
{
attributes: [ 'filename' ],
2021-04-06 11:35:56 +02:00
as: 'Avatar',
model: ActorImageModel.unscoped(),
required: false
},
{
attributes: [ 'host' ],
2019-04-23 09:50:57 +02:00
model: ServerModel.unscoped(),
required: false
}
]
}
}
function buildVideoInclude (required: boolean) {
return {
attributes: [ 'id', 'uuid', 'name' ],
2019-04-23 09:50:57 +02:00
model: VideoModel.unscoped(),
required
}
}
function buildChannelInclude (required: boolean, withActor = false) {
return {
required,
attributes: [ 'id', 'name' ],
2019-04-23 09:50:57 +02:00
model: VideoChannelModel.unscoped(),
include: withActor === true ? [ buildActorWithAvatarInclude() ] : []
}
}
function buildAccountInclude (required: boolean, withActor = false) {
return {
required,
attributes: [ 'id', 'name' ],
2019-04-23 09:50:57 +02:00
model: AccountModel.unscoped(),
include: withActor === true ? [ buildActorWithAvatarInclude() ] : []
}
}
2019-04-23 09:50:57 +02:00
@Scopes(() => ({
2018-12-26 10:36:24 +01:00
[ScopeNames.WITH_ALL]: {
include: [
Object.assign(buildVideoInclude(false), {
include: [ buildChannelInclude(true, true) ]
}),
2018-12-26 10:36:24 +01:00
{
attributes: [ 'id', 'originCommentId' ],
2019-04-23 09:50:57 +02:00
model: VideoCommentModel.unscoped(),
2018-12-26 10:36:24 +01:00
required: false,
include: [
buildAccountInclude(true, true),
buildVideoInclude(true)
2018-12-26 10:36:24 +01:00
]
},
2018-12-26 10:36:24 +01:00
{
attributes: [ 'id', 'state' ],
2020-07-01 16:05:30 +02:00
model: AbuseModel.unscoped(),
2018-12-26 10:36:24 +01:00
required: false,
2020-07-01 16:05:30 +02:00
include: [
{
attributes: [ 'id' ],
model: VideoAbuseModel.unscoped(),
required: false,
2021-03-11 16:54:52 +01:00
include: [ buildVideoInclude(false) ]
2020-07-01 16:05:30 +02:00
},
{
attributes: [ 'id' ],
model: VideoCommentAbuseModel.unscoped(),
required: false,
include: [
{
attributes: [ 'id', 'originCommentId' ],
model: VideoCommentModel.unscoped(),
2021-03-11 16:54:52 +01:00
required: false,
2020-07-01 16:05:30 +02:00
include: [
{
2020-07-08 15:51:46 +02:00
attributes: [ 'id', 'name', 'uuid' ],
2020-07-01 16:05:30 +02:00
model: VideoModel.unscoped(),
2021-03-11 16:54:52 +01:00
required: false
2020-07-01 16:05:30 +02:00
}
]
}
]
},
{
model: AccountModel,
as: 'FlaggedAccount',
2021-03-11 16:54:52 +01:00
required: false,
2020-07-01 16:05:30 +02:00
include: [ buildActorWithAvatarInclude() ]
}
]
2018-12-26 10:36:24 +01:00
},
2018-12-26 10:36:24 +01:00
{
attributes: [ 'id' ],
2019-04-23 09:50:57 +02:00
model: VideoBlacklistModel.unscoped(),
2018-12-26 10:36:24 +01:00
required: false,
include: [ buildVideoInclude(true) ]
},
{
attributes: [ 'id', 'magnetUri', 'targetUrl', 'torrentName' ],
2019-04-23 09:50:57 +02:00
model: VideoImportModel.unscoped(),
required: false,
include: [ buildVideoInclude(false) ]
},
2021-03-11 16:54:52 +01:00
{
attributes: [ 'id', 'name', 'type', 'latestVersion' ],
model: PluginModel.unscoped(),
required: false
},
{
attributes: [ 'id', 'latestPeerTubeVersion' ],
model: ApplicationModel.unscoped(),
required: false
},
{
attributes: [ 'id', 'state' ],
2019-04-23 09:50:57 +02:00
model: ActorFollowModel.unscoped(),
required: false,
include: [
{
attributes: [ 'preferredUsername' ],
2019-04-23 09:50:57 +02:00
model: ActorModel.unscoped(),
required: true,
as: 'ActorFollower',
include: [
{
attributes: [ 'id', 'name' ],
2019-04-23 09:50:57 +02:00
model: AccountModel.unscoped(),
required: true
},
{
attributes: [ 'filename' ],
2021-04-06 11:35:56 +02:00
as: 'Avatar',
model: ActorImageModel.unscoped(),
required: false
},
{
attributes: [ 'host' ],
2019-04-23 09:50:57 +02:00
model: ServerModel.unscoped(),
required: false
}
]
},
{
attributes: [ 'preferredUsername', 'type' ],
2019-04-23 09:50:57 +02:00
model: ActorModel.unscoped(),
required: true,
as: 'ActorFollowing',
include: [
buildChannelInclude(false),
buildAccountInclude(false),
{
attributes: [ 'host' ],
model: ServerModel.unscoped(),
required: false
}
]
}
]
},
buildAccountInclude(false, true)
2019-04-23 09:50:57 +02:00
]
2018-12-26 10:36:24 +01:00
}
2019-04-23 09:50:57 +02:00
}))
2018-12-26 10:36:24 +01:00
@Table({
tableName: 'userNotification',
indexes: [
{
fields: [ 'userId' ]
2018-12-26 10:36:24 +01:00
},
{
fields: [ 'videoId' ],
where: {
videoId: {
[Op.ne]: null
}
}
},
{
fields: [ 'commentId' ],
where: {
commentId: {
[Op.ne]: null
}
}
},
{
2020-07-01 16:05:30 +02:00
fields: [ 'abuseId' ],
where: {
2020-07-01 16:05:30 +02:00
abuseId: {
[Op.ne]: null
}
}
},
{
fields: [ 'videoBlacklistId' ],
where: {
videoBlacklistId: {
[Op.ne]: null
}
}
},
{
fields: [ 'videoImportId' ],
where: {
videoImportId: {
[Op.ne]: null
}
}
},
{
fields: [ 'accountId' ],
where: {
accountId: {
[Op.ne]: null
}
}
},
{
fields: [ 'actorFollowId' ],
where: {
actorFollowId: {
[Op.ne]: null
}
}
2021-03-11 16:54:52 +01:00
},
{
fields: [ 'pluginId' ],
where: {
pluginId: {
[Op.ne]: null
}
}
},
{
fields: [ 'applicationId' ],
where: {
applicationId: {
[Op.ne]: null
}
}
2018-12-26 10:36:24 +01:00
}
2019-04-23 09:50:57 +02:00
] as (ModelIndexesOptions & { where?: WhereOptions })[]
2018-12-26 10:36:24 +01:00
})
2021-05-12 14:09:04 +02:00
export class UserNotificationModel extends Model<Partial<AttributesOnly<UserNotificationModel>>> {
2018-12-26 10:36:24 +01:00
@AllowNull(false)
@Default(null)
@Is('UserNotificationType', value => throwIfNotValid(value, isUserNotificationTypeValid, 'type'))
@Column
type: UserNotificationType
@AllowNull(false)
@Default(false)
@Is('UserNotificationRead', value => throwIfNotValid(value, isBooleanValid, 'read'))
@Column
read: boolean
@CreatedAt
createdAt: Date
@UpdatedAt
updatedAt: Date
@ForeignKey(() => UserModel)
@Column
userId: number
@BelongsTo(() => UserModel, {
foreignKey: {
allowNull: false
},
onDelete: 'cascade'
})
User: UserModel
@ForeignKey(() => VideoModel)
@Column
videoId: number
@BelongsTo(() => VideoModel, {
foreignKey: {
allowNull: true
},
onDelete: 'cascade'
})
Video: VideoModel
@ForeignKey(() => VideoCommentModel)
@Column
commentId: number
@BelongsTo(() => VideoCommentModel, {
foreignKey: {
allowNull: true
},
onDelete: 'cascade'
})
Comment: VideoCommentModel
2020-07-01 16:05:30 +02:00
@ForeignKey(() => AbuseModel)
2018-12-26 10:36:24 +01:00
@Column
2020-07-01 16:05:30 +02:00
abuseId: number
2018-12-26 10:36:24 +01:00
2020-07-01 16:05:30 +02:00
@BelongsTo(() => AbuseModel, {
2018-12-26 10:36:24 +01:00
foreignKey: {
allowNull: true
},
onDelete: 'cascade'
})
2020-07-01 16:05:30 +02:00
Abuse: AbuseModel
2018-12-26 10:36:24 +01:00
@ForeignKey(() => VideoBlacklistModel)
@Column
videoBlacklistId: number
@BelongsTo(() => VideoBlacklistModel, {
foreignKey: {
allowNull: true
},
onDelete: 'cascade'
})
VideoBlacklist: VideoBlacklistModel
@ForeignKey(() => VideoImportModel)
@Column
videoImportId: number
@BelongsTo(() => VideoImportModel, {
foreignKey: {
allowNull: true
},
onDelete: 'cascade'
})
VideoImport: VideoImportModel
@ForeignKey(() => AccountModel)
@Column
accountId: number
@BelongsTo(() => AccountModel, {
foreignKey: {
allowNull: true
},
onDelete: 'cascade'
})
Account: AccountModel
@ForeignKey(() => ActorFollowModel)
@Column
actorFollowId: number
@BelongsTo(() => ActorFollowModel, {
foreignKey: {
allowNull: true
},
onDelete: 'cascade'
})
ActorFollow: ActorFollowModel
2021-03-11 16:54:52 +01:00
@ForeignKey(() => PluginModel)
@Column
pluginId: number
@BelongsTo(() => PluginModel, {
foreignKey: {
allowNull: true
},
onDelete: 'cascade'
})
Plugin: PluginModel
@ForeignKey(() => ApplicationModel)
@Column
applicationId: number
@BelongsTo(() => ApplicationModel, {
foreignKey: {
allowNull: true
},
onDelete: 'cascade'
})
Application: ApplicationModel
static listForApi (userId: number, start: number, count: number, sort: string, unread?: boolean) {
2020-01-09 09:01:08 +01:00
const where = { userId }
2019-04-18 11:28:17 +02:00
const query: FindOptions = {
2018-12-26 10:36:24 +01:00
offset: start,
limit: count,
order: getSort(sort),
2020-01-09 09:01:08 +01:00
where
2018-12-26 10:36:24 +01:00
}
if (unread !== undefined) query.where['read'] = !unread
2020-01-09 09:01:08 +01:00
return Promise.all([
UserNotificationModel.count({ where })
.then(count => count || 0),
count === 0
? []
: UserNotificationModel.scope(ScopeNames.WITH_ALL).findAll(query)
]).then(([ total, data ]) => ({ total, data }))
2018-12-26 10:36:24 +01:00
}
static markAsRead (userId: number, notificationIds: number[]) {
const query = {
where: {
userId,
id: {
2020-01-28 14:45:17 +01:00
[Op.in]: notificationIds
2018-12-26 10:36:24 +01:00
}
}
}
return UserNotificationModel.update({ read: true }, query)
}
2019-01-08 11:26:41 +01:00
static markAllAsRead (userId: number) {
const query = { where: { userId } }
return UserNotificationModel.update({ read: true }, query)
}
static removeNotificationsOf (options: { id: number, type: 'account' | 'server', forUserId?: number }) {
const id = parseInt(options.id + '', 10)
function buildAccountWhereQuery (base: string) {
const whereSuffix = options.forUserId
? ` AND "userNotification"."userId" = ${options.forUserId}`
: ''
if (options.type === 'account') {
return base +
` WHERE "account"."id" = ${id} ${whereSuffix}`
}
return base +
` WHERE "actor"."serverId" = ${id} ${whereSuffix}`
}
const queries = [
buildAccountWhereQuery(
`SELECT "userNotification"."id" FROM "userNotification" ` +
`INNER JOIN "account" ON "userNotification"."accountId" = "account"."id" ` +
`INNER JOIN actor ON "actor"."id" = "account"."actorId" `
),
// Remove notifications from muted accounts that followed ours
buildAccountWhereQuery(
`SELECT "userNotification"."id" FROM "userNotification" ` +
`INNER JOIN "actorFollow" ON "actorFollow".id = "userNotification"."actorFollowId" ` +
`INNER JOIN actor ON actor.id = "actorFollow"."actorId" ` +
`INNER JOIN account ON account."actorId" = actor.id `
),
// Remove notifications from muted accounts that commented something
buildAccountWhereQuery(
`SELECT "userNotification"."id" FROM "userNotification" ` +
`INNER JOIN "actorFollow" ON "actorFollow".id = "userNotification"."actorFollowId" ` +
`INNER JOIN actor ON actor.id = "actorFollow"."actorId" ` +
`INNER JOIN account ON account."actorId" = actor.id `
),
buildAccountWhereQuery(
`SELECT "userNotification"."id" FROM "userNotification" ` +
`INNER JOIN "videoComment" ON "videoComment".id = "userNotification"."commentId" ` +
`INNER JOIN account ON account.id = "videoComment"."accountId" ` +
`INNER JOIN actor ON "actor"."id" = "account"."actorId" `
)
]
const query = `DELETE FROM "userNotification" WHERE id IN (${queries.join(' UNION ')})`
return UserNotificationModel.sequelize.query(query)
}
2019-08-15 11:53:26 +02:00
toFormattedJSON (this: UserNotificationModelForApi): UserNotification {
const video = this.Video
2020-01-31 16:56:52 +01:00
? Object.assign(this.formatVideo(this.Video), { channel: this.formatActor(this.Video.VideoChannel) })
: undefined
2021-02-03 09:33:05 +01:00
const videoImport = this.VideoImport
? {
id: this.VideoImport.id,
video: this.VideoImport.Video ? this.formatVideo(this.VideoImport.Video) : undefined,
torrentName: this.VideoImport.torrentName,
magnetUri: this.VideoImport.magnetUri,
targetUrl: this.VideoImport.targetUrl
}
: undefined
const comment = this.Comment
? {
id: this.Comment.id,
threadId: this.Comment.getThreadId(),
account: this.formatActor(this.Comment.Account),
video: this.formatVideo(this.Comment.Video)
}
: undefined
2018-12-26 10:36:24 +01:00
2020-07-01 16:05:30 +02:00
const abuse = this.Abuse ? this.formatAbuse(this.Abuse) : undefined
2018-12-26 10:36:24 +01:00
2021-02-03 09:33:05 +01:00
const videoBlacklist = this.VideoBlacklist
? {
id: this.VideoBlacklist.id,
video: this.formatVideo(this.VideoBlacklist.Video)
}
: undefined
2018-12-26 10:36:24 +01:00
const account = this.Account ? this.formatActor(this.Account) : undefined
const actorFollowingType = {
Application: 'instance' as 'instance',
Group: 'channel' as 'channel',
Person: 'account' as 'account'
}
2021-02-03 09:33:05 +01:00
const actorFollow = this.ActorFollow
? {
id: this.ActorFollow.id,
state: this.ActorFollow.state,
follower: {
id: this.ActorFollow.ActorFollower.Account.id,
displayName: this.ActorFollow.ActorFollower.Account.getDisplayName(),
name: this.ActorFollow.ActorFollower.preferredUsername,
avatar: this.ActorFollow.ActorFollower.Avatar ? { path: this.ActorFollow.ActorFollower.Avatar.getStaticPath() } : undefined,
host: this.ActorFollow.ActorFollower.getHost()
},
following: {
type: actorFollowingType[this.ActorFollow.ActorFollowing.type],
displayName: (this.ActorFollow.ActorFollowing.VideoChannel || this.ActorFollow.ActorFollowing.Account).getDisplayName(),
name: this.ActorFollow.ActorFollowing.preferredUsername,
host: this.ActorFollow.ActorFollowing.getHost()
}
}
2021-02-03 09:33:05 +01:00
: undefined
2021-03-11 16:54:52 +01:00
const plugin = this.Plugin
? {
name: this.Plugin.name,
type: this.Plugin.type,
latestVersion: this.Plugin.latestVersion
}
: undefined
const peertube = this.Application
? { latestVersion: this.Application.latestPeerTubeVersion }
: undefined
2018-12-26 10:36:24 +01:00
return {
id: this.id,
type: this.type,
read: this.read,
video,
videoImport,
2018-12-26 10:36:24 +01:00
comment,
2020-07-01 16:05:30 +02:00
abuse,
2018-12-26 10:36:24 +01:00
videoBlacklist,
account,
actorFollow,
2021-03-11 16:54:52 +01:00
plugin,
peertube,
2018-12-26 10:36:24 +01:00
createdAt: this.createdAt.toISOString(),
updatedAt: this.updatedAt.toISOString()
}
}
2019-08-15 11:53:26 +02:00
formatVideo (this: UserNotificationModelForApi, video: UserNotificationIncludes.VideoInclude) {
return {
id: video.id,
uuid: video.uuid,
shortUUID: uuidToShort(video.uuid),
name: video.name
}
}
2020-07-01 16:05:30 +02:00
formatAbuse (this: UserNotificationModelForApi, abuse: UserNotificationIncludes.AbuseInclude) {
2021-02-03 09:33:05 +01:00
const commentAbuse = abuse.VideoCommentAbuse?.VideoComment
? {
threadId: abuse.VideoCommentAbuse.VideoComment.getThreadId(),
2021-03-11 16:54:52 +01:00
video: abuse.VideoCommentAbuse.VideoComment.Video
? {
id: abuse.VideoCommentAbuse.VideoComment.Video.id,
name: abuse.VideoCommentAbuse.VideoComment.Video.name,
shortUUID: uuidToShort(abuse.VideoCommentAbuse.VideoComment.Video.uuid),
2021-03-11 16:54:52 +01:00
uuid: abuse.VideoCommentAbuse.VideoComment.Video.uuid
}
: undefined
2020-07-01 16:05:30 +02:00
}
2021-02-03 09:33:05 +01:00
: undefined
2020-07-01 16:05:30 +02:00
const videoAbuse = abuse.VideoAbuse?.Video ? this.formatVideo(abuse.VideoAbuse.Video) : undefined
2021-03-11 16:54:52 +01:00
const accountAbuse = (!commentAbuse && !videoAbuse && abuse.FlaggedAccount) ? this.formatActor(abuse.FlaggedAccount) : undefined
2020-07-01 16:05:30 +02:00
return {
id: abuse.id,
state: abuse.state,
2020-07-01 16:05:30 +02:00
video: videoAbuse,
comment: commentAbuse,
account: accountAbuse
}
}
2019-08-15 11:53:26 +02:00
formatActor (
this: UserNotificationModelForApi,
accountOrChannel: UserNotificationIncludes.AccountIncludeActor | UserNotificationIncludes.VideoChannelIncludeActor
) {
const avatar = accountOrChannel.Actor.Avatar
2019-08-09 11:32:40 +02:00
? { path: accountOrChannel.Actor.Avatar.getStaticPath() }
: undefined
return {
id: accountOrChannel.id,
displayName: accountOrChannel.getDisplayName(),
name: accountOrChannel.Actor.preferredUsername,
host: accountOrChannel.Actor.getHost(),
avatar
}
}
2018-12-26 10:36:24 +01:00
}