1
0
Fork 0
peertube/server/models/user/user-notification.ts

509 lines
13 KiB
TypeScript
Raw Normal View History

import { ModelIndexesOptions, Op, WhereOptions } from 'sequelize'
import { AllowNull, BelongsTo, Column, CreatedAt, Default, ForeignKey, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
import { getBiggestActorImage } from '@server/lib/actor-image'
2020-07-01 10:05:30 -04:00
import { UserNotificationIncludes, UserNotificationModelForApi } from '@server/types/models/user'
import { forceNumber } from '@shared/core-utils'
import { uuidToShort } from '@shared/extra-utils'
2021-12-24 04:14:47 -05:00
import { UserNotification, UserNotificationType } from '@shared/models'
import { AttributesOnly } from '@shared/typescript-utils'
2018-12-26 04:36:24 -05:00
import { isBooleanValid } from '../../helpers/custom-validators/misc'
import { isUserNotificationTypeValid } from '../../helpers/custom-validators/user-notifications'
2020-07-01 10:05:30 -04:00
import { AbuseModel } from '../abuse/abuse'
2021-05-11 05:15:29 -04:00
import { AccountModel } from '../account/account'
import { ActorFollowModel } from '../actor/actor-follow'
2021-03-11 10:54:52 -05:00
import { ApplicationModel } from '../application/application'
import { PluginModel } from '../server/plugin'
import { throwIfNotValid } from '../utils'
2020-07-01 10:05:30 -04:00
import { VideoModel } from '../video/video'
import { VideoBlacklistModel } from '../video/video-blacklist'
import { VideoCommentModel } from '../video/video-comment'
import { VideoImportModel } from '../video/video-import'
import { UserNotificationListQueryBuilder } from './sql/user-notitication-list-query-builder'
2020-07-01 10:05:30 -04:00
import { UserModel } from './user'
2018-12-26 04:36:24 -05:00
@Table({
tableName: 'userNotification',
indexes: [
{
fields: [ 'userId' ]
2018-12-26 04:36:24 -05:00
},
{
fields: [ 'videoId' ],
where: {
videoId: {
[Op.ne]: null
}
}
},
{
fields: [ 'commentId' ],
where: {
commentId: {
[Op.ne]: null
}
}
},
{
2020-07-01 10:05:30 -04:00
fields: [ 'abuseId' ],
where: {
2020-07-01 10:05:30 -04: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 10:54:52 -05:00
},
{
fields: [ 'pluginId' ],
where: {
pluginId: {
[Op.ne]: null
}
}
},
{
fields: [ 'applicationId' ],
where: {
applicationId: {
[Op.ne]: null
}
}
2018-12-26 04:36:24 -05:00
}
2019-04-23 03:50:57 -04:00
] as (ModelIndexesOptions & { where?: WhereOptions })[]
2018-12-26 04:36:24 -05:00
})
2021-05-12 08:09:04 -04:00
export class UserNotificationModel extends Model<Partial<AttributesOnly<UserNotificationModel>>> {
2018-12-26 04:36:24 -05: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'
})
VideoComment: VideoCommentModel
2018-12-26 04:36:24 -05:00
2020-07-01 10:05:30 -04:00
@ForeignKey(() => AbuseModel)
2018-12-26 04:36:24 -05:00
@Column
2020-07-01 10:05:30 -04:00
abuseId: number
2018-12-26 04:36:24 -05:00
2020-07-01 10:05:30 -04:00
@BelongsTo(() => AbuseModel, {
2018-12-26 04:36:24 -05:00
foreignKey: {
allowNull: true
},
onDelete: 'cascade'
})
2020-07-01 10:05:30 -04:00
Abuse: AbuseModel
2018-12-26 04:36:24 -05: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 10:54:52 -05: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 03:01:08 -05:00
const where = { userId }
const query = {
userId,
unread,
2018-12-26 04:36:24 -05:00
offset: start,
limit: count,
sort,
2022-03-03 04:23:44 -05:00
where
2018-12-26 04:36:24 -05:00
}
if (unread !== undefined) query.where['read'] = !unread
2020-01-09 03:01:08 -05:00
return Promise.all([
UserNotificationModel.count({ where })
.then(count => count || 0),
count === 0
? [] as UserNotificationModelForApi[]
2022-03-03 04:23:44 -05:00
: new UserNotificationListQueryBuilder(this.sequelize, query).listNotifications()
2020-01-09 03:01:08 -05:00
]).then(([ total, data ]) => ({ total, data }))
2018-12-26 04:36:24 -05:00
}
static markAsRead (userId: number, notificationIds: number[]) {
const query = {
where: {
userId,
id: {
2020-01-28 08:45:17 -05:00
[Op.in]: notificationIds
2018-12-26 04:36:24 -05:00
}
}
}
return UserNotificationModel.update({ read: true }, query)
}
2019-01-08 05:26:41 -05: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 = forceNumber(options.id)
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 05:53:26 -04:00
toFormattedJSON (this: UserNotificationModelForApi): UserNotification {
const video = this.Video
? {
...this.formatVideo(this.Video),
channel: this.formatActor(this.Video.VideoChannel)
}
: undefined
2021-02-03 03:33:05 -05:00
const videoImport = this.VideoImport
? {
id: this.VideoImport.id,
video: this.VideoImport.Video
? this.formatVideo(this.VideoImport.Video)
: undefined,
2021-02-03 03:33:05 -05:00
torrentName: this.VideoImport.torrentName,
magnetUri: this.VideoImport.magnetUri,
targetUrl: this.VideoImport.targetUrl
}
: undefined
const comment = this.VideoComment
2021-02-03 03:33:05 -05:00
? {
id: this.VideoComment.id,
threadId: this.VideoComment.getThreadId(),
account: this.formatActor(this.VideoComment.Account),
video: this.formatVideo(this.VideoComment.Video)
2021-02-03 03:33:05 -05:00
}
: undefined
2018-12-26 04:36:24 -05:00
2020-07-01 10:05:30 -04:00
const abuse = this.Abuse ? this.formatAbuse(this.Abuse) : undefined
2018-12-26 04:36:24 -05:00
2021-02-03 03:33:05 -05:00
const videoBlacklist = this.VideoBlacklist
? {
id: this.VideoBlacklist.id,
video: this.formatVideo(this.VideoBlacklist.Video)
}
: undefined
2018-12-26 04:36:24 -05: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 03:33:05 -05: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,
host: this.ActorFollow.ActorFollower.getHost(),
...this.formatAvatars(this.ActorFollow.ActorFollower.Avatars)
2021-02-03 03:33:05 -05:00
},
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 03:33:05 -05:00
: undefined
2021-03-11 10:54:52 -05: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 04:36:24 -05:00
return {
id: this.id,
type: this.type,
read: this.read,
video,
videoImport,
2018-12-26 04:36:24 -05:00
comment,
2020-07-01 10:05:30 -04:00
abuse,
2018-12-26 04:36:24 -05:00
videoBlacklist,
account,
actorFollow,
2021-03-11 10:54:52 -05:00
plugin,
peertube,
2018-12-26 04:36:24 -05:00
createdAt: this.createdAt.toISOString(),
updatedAt: this.updatedAt.toISOString()
}
}
formatVideo (video: UserNotificationIncludes.VideoInclude) {
return {
id: video.id,
uuid: video.uuid,
shortUUID: uuidToShort(video.uuid),
name: video.name
}
}
formatAbuse (abuse: UserNotificationIncludes.AbuseInclude) {
2021-02-03 03:33:05 -05:00
const commentAbuse = abuse.VideoCommentAbuse?.VideoComment
? {
threadId: abuse.VideoCommentAbuse.VideoComment.getThreadId(),
2021-03-11 10:54:52 -05: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 10:54:52 -05:00
uuid: abuse.VideoCommentAbuse.VideoComment.Video.uuid
}
: undefined
2020-07-01 10:05:30 -04:00
}
2021-02-03 03:33:05 -05:00
: undefined
2020-07-01 10:05:30 -04:00
const videoAbuse = abuse.VideoAbuse?.Video
? this.formatVideo(abuse.VideoAbuse.Video)
: undefined
2020-07-01 10:05:30 -04:00
const accountAbuse = (!commentAbuse && !videoAbuse && abuse.FlaggedAccount)
? this.formatActor(abuse.FlaggedAccount)
: undefined
2020-07-01 10:05:30 -04:00
return {
id: abuse.id,
state: abuse.state,
2020-07-01 10:05:30 -04:00
video: videoAbuse,
comment: commentAbuse,
account: accountAbuse
}
}
2019-08-15 05:53:26 -04:00
formatActor (
accountOrChannel: UserNotificationIncludes.AccountIncludeActor | UserNotificationIncludes.VideoChannelIncludeActor
) {
return {
id: accountOrChannel.id,
displayName: accountOrChannel.getDisplayName(),
name: accountOrChannel.Actor.preferredUsername,
host: accountOrChannel.Actor.getHost(),
...this.formatAvatars(accountOrChannel.Actor.Avatars)
}
}
formatAvatars (avatars: UserNotificationIncludes.ActorImageInclude[]) {
if (!avatars || avatars.length === 0) return { avatar: undefined, avatars: [] }
return {
avatar: this.formatAvatar(getBiggestActorImage(avatars)),
avatars: avatars.map(a => this.formatAvatar(a))
}
}
formatAvatar (a: UserNotificationIncludes.ActorImageInclude) {
return {
path: a.getStaticPath(),
width: a.width
}
}
2018-12-26 04:36:24 -05:00
}