server/models/video/video-comment.ts

   1 import {
   2   AllowNull,
   3   BeforeDestroy,
   4   BelongsTo,
   5   Column,
   6   CreatedAt,
   7   DataType,
   8   ForeignKey,
   9   Is,
  10   Model,
  11   Scopes,
  12   Table,
  13   UpdatedAt
  14 } from 'sequelize-typescript'
  15 import { ActivityTagObject } from '../../../shared/models/activitypub/objects/common-objects'
  16 import { VideoCommentObject } from '../../../shared/models/activitypub/objects/video-comment-object'
  17 import { VideoComment } from '../../../shared/models/videos/video-comment.model'
  18 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
  19 import { CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants'
  20 import { sendDeleteVideoComment } from '../../lib/activitypub/send'
  21 import { AccountModel } from '../account/account'
  22 import { ActorModel } from '../activitypub/actor'
  23 import { AvatarModel } from '../avatar/avatar'
  24 import { ServerModel } from '../server/server'
  25 import { buildBlockedAccountSQL, buildLocalAccountIdsIn, getSort, throwIfNotValid } from '../utils'
  26 import { VideoModel } from './video'
  27 import { VideoChannelModel } from './video-channel'
  28 import { getServerActor } from '../../helpers/utils'
  29 import { UserModel } from '../account/user'
  30 import { actorNameAlphabet } from '../../helpers/custom-validators/activitypub/actor'
  31 import { regexpCapture } from '../../helpers/regexp'
  32 import { uniq } from 'lodash'
  33 import { FindOptions, literal, Op, Order, ScopeOptions, Sequelize, Transaction } from 'sequelize'
  34
  35 enum ScopeNames {
  36   WITH_ACCOUNT = 'WITH_ACCOUNT',
  37   WITH_IN_REPLY_TO = 'WITH_IN_REPLY_TO',
  38   WITH_VIDEO = 'WITH_VIDEO',
  39   ATTRIBUTES_FOR_API = 'ATTRIBUTES_FOR_API'
  40 }
  41
  42 @Scopes(() => ({
  43   [ScopeNames.ATTRIBUTES_FOR_API]: (serverAccountId: number, userAccountId?: number) => {
  44     return {
  45       attributes: {
  46         include: [
  47           [
  48             Sequelize.literal(
  49               '(' +
  50                 'WITH "blocklist" AS (' + buildBlockedAccountSQL(serverAccountId, userAccountId) + ')' +
  51                 'SELECT COUNT("replies"."id") - (' +
  52                   'SELECT COUNT("replies"."id") ' +
  53                   'FROM "videoComment" AS "replies" ' +
  54                   'WHERE "replies"."originCommentId" = "VideoCommentModel"."id" ' +
  55                   'AND "accountId" IN (SELECT "id" FROM "blocklist")' +
  56                 ')' +
  57                 'FROM "videoComment" AS "replies" ' +
  58                 'WHERE "replies"."originCommentId" = "VideoCommentModel"."id" ' +
  59                 'AND "accountId" NOT IN (SELECT "id" FROM "blocklist")' +
  60               ')'
  61             ),
  62             'totalReplies'
  63           ]
  64         ]
  65       }
  66     } as FindOptions
  67   },
  68   [ScopeNames.WITH_ACCOUNT]: {
  69     include: [
  70       {
  71         model: AccountModel,
  72         include: [
  73           {
  74             model: ActorModel,
  75             include: [
  76               {
  77                 model: ServerModel,
  78                 required: false
  79               },
  80               {
  81                 model: AvatarModel,
  82                 required: false
  83               }
  84             ]
  85           }
  86         ]
  87       }
  88     ]
  89   },
  90   [ScopeNames.WITH_IN_REPLY_TO]: {
  91     include: [
  92       {
  93         model: VideoCommentModel,
  94         as: 'InReplyToVideoComment'
  95       }
  96     ]
  97   },
  98   [ScopeNames.WITH_VIDEO]: {
  99     include: [
 100       {
 101         model: VideoModel,
 102         required: true,
 103         include: [
 104           {
 105             model: VideoChannelModel.unscoped(),
 106             required: true,
 107             include: [
 108               {
 109                 model: AccountModel,
 110                 required: true,
 111                 include: [
 112                   {
 113                     model: ActorModel,
 114                     required: true
 115                   }
 116                 ]
 117               }
 118             ]
 119           }
 120         ]
 121       }
 122     ]
 123   }
 124 }))
 125 @Table({
 126   tableName: 'videoComment',
 127   indexes: [
 128     {
 129       fields: [ 'videoId' ]
 130     },
 131     {
 132       fields: [ 'videoId', 'originCommentId' ]
 133     },
 134     {
 135       fields: [ 'url' ],
 136       unique: true
 137     },
 138     {
 139       fields: [ 'accountId' ]
 140     }
 141   ]
 142 })
 143 export class VideoCommentModel extends Model<VideoCommentModel> {
 144   @CreatedAt
 145   createdAt: Date
 146
 147   @UpdatedAt
 148   updatedAt: Date
 149
 150   @AllowNull(false)
 151   @Is('VideoCommentUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
 152   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.URL.max))
 153   url: string
 154
 155   @AllowNull(false)
 156   @Column(DataType.TEXT)
 157   text: string
 158
 159   @ForeignKey(() => VideoCommentModel)
 160   @Column
 161   originCommentId: number
 162
 163   @BelongsTo(() => VideoCommentModel, {
 164     foreignKey: {
 165       name: 'originCommentId',
 166       allowNull: true
 167     },
 168     as: 'OriginVideoComment',
 169     onDelete: 'CASCADE'
 170   })
 171   OriginVideoComment: VideoCommentModel
 172
 173   @ForeignKey(() => VideoCommentModel)
 174   @Column
 175   inReplyToCommentId: number
 176
 177   @BelongsTo(() => VideoCommentModel, {
 178     foreignKey: {
 179       name: 'inReplyToCommentId',
 180       allowNull: true
 181     },
 182     as: 'InReplyToVideoComment',
 183     onDelete: 'CASCADE'
 184   })
 185   InReplyToVideoComment: VideoCommentModel | null
 186
 187   @ForeignKey(() => VideoModel)
 188   @Column
 189   videoId: number
 190
 191   @BelongsTo(() => VideoModel, {
 192     foreignKey: {
 193       allowNull: false
 194     },
 195     onDelete: 'CASCADE'
 196   })
 197   Video: VideoModel
 198
 199   @ForeignKey(() => AccountModel)
 200   @Column
 201   accountId: number
 202
 203   @BelongsTo(() => AccountModel, {
 204     foreignKey: {
 205       allowNull: false
 206     },
 207     onDelete: 'CASCADE'
 208   })
 209   Account: AccountModel
 210
 211   @BeforeDestroy
 212   static async sendDeleteIfOwned (instance: VideoCommentModel, options) {
 213     if (!instance.Account || !instance.Account.Actor) {
 214       instance.Account = await instance.$get('Account', {
 215         include: [ ActorModel ],
 216         transaction: options.transaction
 217       }) as AccountModel
 218     }
 219
 220     if (!instance.Video) {
 221       instance.Video = await instance.$get('Video', {
 222         include: [
 223           {
 224             model: VideoChannelModel,
 225             include: [
 226               {
 227                 model: AccountModel,
 228                 include: [
 229                   {
 230                     model: ActorModel
 231                   }
 232                 ]
 233               }
 234             ]
 235           }
 236         ],
 237         transaction: options.transaction
 238       }) as VideoModel
 239     }
 240
 241     if (instance.isOwned()) {
 242       await sendDeleteVideoComment(instance, options.transaction)
 243     }
 244   }
 245
 246   static loadById (id: number, t?: Transaction) {
 247     const query: FindOptions = {
 248       where: {
 249         id
 250       }
 251     }
 252
 253     if (t !== undefined) query.transaction = t
 254
 255     return VideoCommentModel.findOne(query)
 256   }
 257
 258   static loadByIdAndPopulateVideoAndAccountAndReply (id: number, t?: Transaction) {
 259     const query: FindOptions = {
 260       where: {
 261         id
 262       }
 263     }
 264
 265     if (t !== undefined) query.transaction = t
 266
 267     return VideoCommentModel
 268       .scope([ ScopeNames.WITH_VIDEO, ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_IN_REPLY_TO ])
 269       .findOne(query)
 270   }
 271
 272   static loadByUrlAndPopulateAccount (url: string, t?: Transaction) {
 273     const query: FindOptions = {
 274       where: {
 275         url
 276       }
 277     }
 278
 279     if (t !== undefined) query.transaction = t
 280
 281     return VideoCommentModel.scope([ ScopeNames.WITH_ACCOUNT ]).findOne(query)
 282   }
 283
 284   static loadByUrlAndPopulateReplyAndVideoUrlAndAccount (url: string, t?: Transaction) {
 285     const query: FindOptions = {
 286       where: {
 287         url
 288       },
 289       include: [
 290         {
 291           attributes: [ 'id', 'url' ],
 292           model: VideoModel.unscoped()
 293         }
 294       ]
 295     }
 296
 297     if (t !== undefined) query.transaction = t
 298
 299     return VideoCommentModel.scope([ ScopeNames.WITH_IN_REPLY_TO, ScopeNames.WITH_ACCOUNT ]).findOne(query)
 300   }
 301
 302   static async listThreadsForApi (parameters: {
 303     videoId: number,
 304     start: number,
 305     count: number,
 306     sort: string,
 307     user?: UserModel
 308   }) {
 309     const { videoId, start, count, sort, user } = parameters
 310
 311     const serverActor = await getServerActor()
 312     const serverAccountId = serverActor.Account.id
 313     const userAccountId = user ? user.Account.id : undefined
 314
 315     const query = {
 316       offset: start,
 317       limit: count,
 318       order: getSort(sort),
 319       where: {
 320         videoId,
 321         inReplyToCommentId: null,
 322         accountId: {
 323           [Op.notIn]: Sequelize.literal(
 324             '(' + buildBlockedAccountSQL(serverAccountId, userAccountId) + ')'
 325           )
 326         }
 327       }
 328     }
 329
 330     const scopes: (string | ScopeOptions)[] = [
 331       ScopeNames.WITH_ACCOUNT,
 332       {
 333         method: [ ScopeNames.ATTRIBUTES_FOR_API, serverAccountId, userAccountId ]
 334       }
 335     ]
 336
 337     return VideoCommentModel
 338       .scope(scopes)
 339       .findAndCountAll(query)
 340       .then(({ rows, count }) => {
 341         return { total: count, data: rows }
 342       })
 343   }
 344
 345   static async listThreadCommentsForApi (parameters: {
 346     videoId: number,
 347     threadId: number,
 348     user?: UserModel
 349   }) {
 350     const { videoId, threadId, user } = parameters
 351
 352     const serverActor = await getServerActor()
 353     const serverAccountId = serverActor.Account.id
 354     const userAccountId = user ? user.Account.id : undefined
 355
 356     const query = {
 357       order: [ [ 'createdAt', 'ASC' ], [ 'updatedAt', 'ASC' ] ] as Order,
 358       where: {
 359         videoId,
 360         [ Op.or ]: [
 361           { id: threadId },
 362           { originCommentId: threadId }
 363         ],
 364         accountId: {
 365           [Op.notIn]: Sequelize.literal(
 366             '(' + buildBlockedAccountSQL(serverAccountId, userAccountId) + ')'
 367           )
 368         }
 369       }
 370     }
 371
 372     const scopes: any[] = [
 373       ScopeNames.WITH_ACCOUNT,
 374       {
 375         method: [ ScopeNames.ATTRIBUTES_FOR_API, serverAccountId, userAccountId ]
 376       }
 377     ]
 378
 379     return VideoCommentModel
 380       .scope(scopes)
 381       .findAndCountAll(query)
 382       .then(({ rows, count }) => {
 383         return { total: count, data: rows }
 384       })
 385   }
 386
 387   static listThreadParentComments (comment: VideoCommentModel, t: Transaction, order: 'ASC' | 'DESC' = 'ASC') {
 388     const query = {
 389       order: [ [ 'createdAt', order ] ] as Order,
 390       where: {
 391         id: {
 392           [ Op.in ]: Sequelize.literal('(' +
 393             'WITH RECURSIVE children (id, "inReplyToCommentId") AS ( ' +
 394               `SELECT id, "inReplyToCommentId" FROM "videoComment" WHERE id = ${comment.id} ` +
 395               'UNION ' +
 396               'SELECT "parent"."id", "parent"."inReplyToCommentId" FROM "videoComment" "parent" ' +
 397               'INNER JOIN "children" ON "children"."inReplyToCommentId" = "parent"."id"' +
 398             ') ' +
 399             'SELECT id FROM children' +
 400           ')'),
 401           [ Op.ne ]: comment.id
 402         }
 403       },
 404       transaction: t
 405     }
 406
 407     return VideoCommentModel
 408       .scope([ ScopeNames.WITH_ACCOUNT ])
 409       .findAll(query)
 410   }
 411
 412   static listAndCountByVideoId (videoId: number, start: number, count: number, t?: Transaction, order: 'ASC' | 'DESC' = 'ASC') {
 413     const query = {
 414       order: [ [ 'createdAt', order ] ] as Order,
 415       offset: start,
 416       limit: count,
 417       where: {
 418         videoId
 419       },
 420       transaction: t
 421     }
 422
 423     return VideoCommentModel.findAndCountAll(query)
 424   }
 425
 426   static listForFeed (start: number, count: number, videoId?: number) {
 427     const query = {
 428       order: [ [ 'createdAt', 'DESC' ] ] as Order,
 429       offset: start,
 430       limit: count,
 431       where: {},
 432       include: [
 433         {
 434           attributes: [ 'name', 'uuid' ],
 435           model: VideoModel.unscoped(),
 436           required: true
 437         }
 438       ]
 439     }
 440
 441     if (videoId) query.where['videoId'] = videoId
 442
 443     return VideoCommentModel
 444       .scope([ ScopeNames.WITH_ACCOUNT ])
 445       .findAll(query)
 446   }
 447
 448   static async getStats () {
 449     const totalLocalVideoComments = await VideoCommentModel.count({
 450       include: [
 451         {
 452           model: AccountModel,
 453           required: true,
 454           include: [
 455             {
 456               model: ActorModel,
 457               required: true,
 458               where: {
 459                 serverId: null
 460               }
 461             }
 462           ]
 463         }
 464       ]
 465     })
 466     const totalVideoComments = await VideoCommentModel.count()
 467
 468     return {
 469       totalLocalVideoComments,
 470       totalVideoComments
 471     }
 472   }
 473
 474   static cleanOldCommentsOf (videoId: number, beforeUpdatedAt: Date) {
 475     const query = {
 476       where: {
 477         updatedAt: {
 478           [Op.lt]: beforeUpdatedAt
 479         },
 480         videoId,
 481         accountId: {
 482           [Op.notIn]: buildLocalAccountIdsIn()
 483         }
 484       }
 485     }
 486
 487     return VideoCommentModel.destroy(query)
 488   }
 489
 490   getCommentStaticPath () {
 491     return this.Video.getWatchStaticPath() + ';threadId=' + this.getThreadId()
 492   }
 493
 494   getThreadId (): number {
 495     return this.originCommentId || this.id
 496   }
 497
 498   isOwned () {
 499     return this.Account.isOwned()
 500   }
 501
 502   extractMentions () {
 503     let result: string[] = []
 504
 505     const localMention = `@(${actorNameAlphabet}+)`
 506     const remoteMention = `${localMention}@${WEBSERVER.HOST}`
 507
 508     const mentionRegex = this.isOwned()
 509       ? '(?:(?:' + remoteMention + ')|(?:' + localMention + '))' // Include local mentions?
 510       : '(?:' + remoteMention + ')'
 511
 512     const firstMentionRegex = new RegExp(`^${mentionRegex} `, 'g')
 513     const endMentionRegex = new RegExp(` ${mentionRegex}$`, 'g')
 514     const remoteMentionsRegex = new RegExp(' ' + remoteMention + ' ', 'g')
 515
 516     result = result.concat(
 517       regexpCapture(this.text, firstMentionRegex)
 518         .map(([ , username1, username2 ]) => username1 || username2),
 519
 520       regexpCapture(this.text, endMentionRegex)
 521         .map(([ , username1, username2 ]) => username1 || username2),
 522
 523       regexpCapture(this.text, remoteMentionsRegex)
 524         .map(([ , username ]) => username)
 525     )
 526
 527     // Include local mentions
 528     if (this.isOwned()) {
 529       const localMentionsRegex = new RegExp(' ' + localMention + ' ', 'g')
 530
 531       result = result.concat(
 532         regexpCapture(this.text, localMentionsRegex)
 533           .map(([ , username ]) => username)
 534       )
 535     }
 536
 537     return uniq(result)
 538   }
 539
 540   toFormattedJSON () {
 541     return {
 542       id: this.id,
 543       url: this.url,
 544       text: this.text,
 545       threadId: this.originCommentId || this.id,
 546       inReplyToCommentId: this.inReplyToCommentId || null,
 547       videoId: this.videoId,
 548       createdAt: this.createdAt,
 549       updatedAt: this.updatedAt,
 550       totalReplies: this.get('totalReplies') || 0,
 551       account: this.Account.toFormattedJSON()
 552     } as VideoComment
 553   }
 554
 555   toActivityPubObject (threadParentComments: VideoCommentModel[]): VideoCommentObject {
 556     let inReplyTo: string
 557     // New thread, so in AS we reply to the video
 558     if (this.inReplyToCommentId === null) {
 559       inReplyTo = this.Video.url
 560     } else {
 561       inReplyTo = this.InReplyToVideoComment.url
 562     }
 563
 564     const tag: ActivityTagObject[] = []
 565     for (const parentComment of threadParentComments) {
 566       const actor = parentComment.Account.Actor
 567
 568       tag.push({
 569         type: 'Mention',
 570         href: actor.url,
 571         name: `@${actor.preferredUsername}@${actor.getHost()}`
 572       })
 573     }
 574
 575     return {
 576       type: 'Note' as 'Note',
 577       id: this.url,
 578       content: this.text,
 579       inReplyTo,
 580       updated: this.updatedAt.toISOString(),
 581       published: this.createdAt.toISOString(),
 582       url: this.url,
 583       attributedTo: this.Account.Actor.url,
 584       tag
 585     }
 586   }
 587 }