server/models/video/video-comment.ts

   1 import { uniq } from 'lodash'
   2 import { FindAndCountOptions, FindOptions, Op, Order, QueryTypes, ScopeOptions, Sequelize, Transaction, WhereOptions } from 'sequelize'
   3 import {
   4   AllowNull,
   5   BelongsTo,
   6   Column,
   7   CreatedAt,
   8   DataType,
   9   ForeignKey,
  10   HasMany,
  11   Is,
  12   Model,
  13   Scopes,
  14   Table,
  15   UpdatedAt
  16 } from 'sequelize-typescript'
  17 import { getServerActor } from '@server/models/application/application'
  18 import { MAccount, MAccountId, MUserAccountId } from '@server/types/models'
  19 import { AttributesOnly } from '@shared/core-utils'
  20 import { VideoPrivacy } from '@shared/models'
  21 import { ActivityTagObject, ActivityTombstoneObject } from '../../../shared/models/activitypub/objects/common-objects'
  22 import { VideoCommentObject } from '../../../shared/models/activitypub/objects/video-comment-object'
  23 import { VideoComment, VideoCommentAdmin } from '../../../shared/models/videos/comment/video-comment.model'
  24 import { actorNameAlphabet } from '../../helpers/custom-validators/activitypub/actor'
  25 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
  26 import { regexpCapture } from '../../helpers/regexp'
  27 import { CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants'
  28 import {
  29   MComment,
  30   MCommentAdminFormattable,
  31   MCommentAP,
  32   MCommentFormattable,
  33   MCommentId,
  34   MCommentOwner,
  35   MCommentOwnerReplyVideoLight,
  36   MCommentOwnerVideo,
  37   MCommentOwnerVideoFeed,
  38   MCommentOwnerVideoReply,
  39   MVideoImmutable
  40 } from '../../types/models/video'
  41 import { VideoCommentAbuseModel } from '../abuse/video-comment-abuse'
  42 import { AccountModel } from '../account/account'
  43 import { ActorModel, unusedActorAttributesForAPI } from '../actor/actor'
  44 import {
  45   buildBlockedAccountSQL,
  46   buildBlockedAccountSQLOptimized,
  47   buildLocalAccountIdsIn,
  48   getCommentSort,
  49   searchAttribute,
  50   throwIfNotValid
  51 } from '../utils'
  52 import { VideoModel } from './video'
  53 import { VideoChannelModel } from './video-channel'
  54
  55 export enum ScopeNames {
  56   WITH_ACCOUNT = 'WITH_ACCOUNT',
  57   WITH_ACCOUNT_FOR_API = 'WITH_ACCOUNT_FOR_API',
  58   WITH_IN_REPLY_TO = 'WITH_IN_REPLY_TO',
  59   WITH_VIDEO = 'WITH_VIDEO',
  60   ATTRIBUTES_FOR_API = 'ATTRIBUTES_FOR_API'
  61 }
  62
  63 @Scopes(() => ({
  64   [ScopeNames.ATTRIBUTES_FOR_API]: (blockerAccountIds: number[]) => {
  65     return {
  66       attributes: {
  67         include: [
  68           [
  69             Sequelize.literal(
  70               '(' +
  71                 'WITH "blocklist" AS (' + buildBlockedAccountSQL(blockerAccountIds) + ')' +
  72                 'SELECT COUNT("replies"."id") - (' +
  73                   'SELECT COUNT("replies"."id") ' +
  74                   'FROM "videoComment" AS "replies" ' +
  75                   'WHERE "replies"."originCommentId" = "VideoCommentModel"."id" ' +
  76                   'AND "accountId" IN (SELECT "id" FROM "blocklist")' +
  77                 ')' +
  78                 'FROM "videoComment" AS "replies" ' +
  79                 'WHERE "replies"."originCommentId" = "VideoCommentModel"."id" ' +
  80                 'AND "accountId" NOT IN (SELECT "id" FROM "blocklist")' +
  81               ')'
  82             ),
  83             'totalReplies'
  84           ],
  85           [
  86             Sequelize.literal(
  87               '(' +
  88                 'SELECT COUNT("replies"."id") ' +
  89                 'FROM "videoComment" AS "replies" ' +
  90                 'INNER JOIN "video" ON "video"."id" = "replies"."videoId" ' +
  91                 'INNER JOIN "videoChannel" ON "videoChannel"."id" = "video"."channelId" ' +
  92                 'WHERE "replies"."originCommentId" = "VideoCommentModel"."id" ' +
  93                 'AND "replies"."accountId" = "videoChannel"."accountId"' +
  94               ')'
  95             ),
  96             'totalRepliesFromVideoAuthor'
  97           ]
  98         ]
  99       }
 100     } as FindOptions
 101   },
 102   [ScopeNames.WITH_ACCOUNT]: {
 103     include: [
 104       {
 105         model: AccountModel
 106       }
 107     ]
 108   },
 109   [ScopeNames.WITH_ACCOUNT_FOR_API]: {
 110     include: [
 111       {
 112         model: AccountModel.unscoped(),
 113         include: [
 114           {
 115             attributes: {
 116               exclude: unusedActorAttributesForAPI
 117             },
 118             model: ActorModel, // Default scope includes avatar and server
 119             required: true
 120           }
 121         ]
 122       }
 123     ]
 124   },
 125   [ScopeNames.WITH_IN_REPLY_TO]: {
 126     include: [
 127       {
 128         model: VideoCommentModel,
 129         as: 'InReplyToVideoComment'
 130       }
 131     ]
 132   },
 133   [ScopeNames.WITH_VIDEO]: {
 134     include: [
 135       {
 136         model: VideoModel,
 137         required: true,
 138         include: [
 139           {
 140             model: VideoChannelModel,
 141             required: true,
 142             include: [
 143               {
 144                 model: AccountModel,
 145                 required: true
 146               }
 147             ]
 148           }
 149         ]
 150       }
 151     ]
 152   }
 153 }))
 154 @Table({
 155   tableName: 'videoComment',
 156   indexes: [
 157     {
 158       fields: [ 'videoId' ]
 159     },
 160     {
 161       fields: [ 'videoId', 'originCommentId' ]
 162     },
 163     {
 164       fields: [ 'url' ],
 165       unique: true
 166     },
 167     {
 168       fields: [ 'accountId' ]
 169     },
 170     {
 171       fields: [
 172         { name: 'createdAt', order: 'DESC' }
 173       ]
 174     }
 175   ]
 176 })
 177 export class VideoCommentModel extends Model<Partial<AttributesOnly<VideoCommentModel>>> {
 178   @CreatedAt
 179   createdAt: Date
 180
 181   @UpdatedAt
 182   updatedAt: Date
 183
 184   @AllowNull(true)
 185   @Column(DataType.DATE)
 186   deletedAt: Date
 187
 188   @AllowNull(false)
 189   @Is('VideoCommentUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
 190   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.URL.max))
 191   url: string
 192
 193   @AllowNull(false)
 194   @Column(DataType.TEXT)
 195   text: string
 196
 197   @ForeignKey(() => VideoCommentModel)
 198   @Column
 199   originCommentId: number
 200
 201   @BelongsTo(() => VideoCommentModel, {
 202     foreignKey: {
 203       name: 'originCommentId',
 204       allowNull: true
 205     },
 206     as: 'OriginVideoComment',
 207     onDelete: 'CASCADE'
 208   })
 209   OriginVideoComment: VideoCommentModel
 210
 211   @ForeignKey(() => VideoCommentModel)
 212   @Column
 213   inReplyToCommentId: number
 214
 215   @BelongsTo(() => VideoCommentModel, {
 216     foreignKey: {
 217       name: 'inReplyToCommentId',
 218       allowNull: true
 219     },
 220     as: 'InReplyToVideoComment',
 221     onDelete: 'CASCADE'
 222   })
 223   InReplyToVideoComment: VideoCommentModel | null
 224
 225   @ForeignKey(() => VideoModel)
 226   @Column
 227   videoId: number
 228
 229   @BelongsTo(() => VideoModel, {
 230     foreignKey: {
 231       allowNull: false
 232     },
 233     onDelete: 'CASCADE'
 234   })
 235   Video: VideoModel
 236
 237   @ForeignKey(() => AccountModel)
 238   @Column
 239   accountId: number
 240
 241   @BelongsTo(() => AccountModel, {
 242     foreignKey: {
 243       allowNull: true
 244     },
 245     onDelete: 'CASCADE'
 246   })
 247   Account: AccountModel
 248
 249   @HasMany(() => VideoCommentAbuseModel, {
 250     foreignKey: {
 251       name: 'videoCommentId',
 252       allowNull: true
 253     },
 254     onDelete: 'set null'
 255   })
 256   CommentAbuses: VideoCommentAbuseModel[]
 257
 258   static loadById (id: number, t?: Transaction): Promise<MComment> {
 259     const query: FindOptions = {
 260       where: {
 261         id
 262       }
 263     }
 264
 265     if (t !== undefined) query.transaction = t
 266
 267     return VideoCommentModel.findOne(query)
 268   }
 269
 270   static loadByIdAndPopulateVideoAndAccountAndReply (id: number, t?: Transaction): Promise<MCommentOwnerVideoReply> {
 271     const query: FindOptions = {
 272       where: {
 273         id
 274       }
 275     }
 276
 277     if (t !== undefined) query.transaction = t
 278
 279     return VideoCommentModel
 280       .scope([ ScopeNames.WITH_VIDEO, ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_IN_REPLY_TO ])
 281       .findOne(query)
 282   }
 283
 284   static loadByUrlAndPopulateAccountAndVideo (url: string, t?: Transaction): Promise<MCommentOwnerVideo> {
 285     const query: FindOptions = {
 286       where: {
 287         url
 288       }
 289     }
 290
 291     if (t !== undefined) query.transaction = t
 292
 293     return VideoCommentModel.scope([ ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_VIDEO ]).findOne(query)
 294   }
 295
 296   static loadByUrlAndPopulateReplyAndVideoUrlAndAccount (url: string, t?: Transaction): Promise<MCommentOwnerReplyVideoLight> {
 297     const query: FindOptions = {
 298       where: {
 299         url
 300       },
 301       include: [
 302         {
 303           attributes: [ 'id', 'url' ],
 304           model: VideoModel.unscoped()
 305         }
 306       ]
 307     }
 308
 309     if (t !== undefined) query.transaction = t
 310
 311     return VideoCommentModel.scope([ ScopeNames.WITH_IN_REPLY_TO, ScopeNames.WITH_ACCOUNT ]).findOne(query)
 312   }
 313
 314   static listCommentsForApi (parameters: {
 315     start: number
 316     count: number
 317     sort: string
 318
 319     isLocal?: boolean
 320     search?: string
 321     searchAccount?: string
 322     searchVideo?: string
 323   }) {
 324     const { start, count, sort, isLocal, search, searchAccount, searchVideo } = parameters
 325
 326     const where: WhereOptions = {
 327       deletedAt: null
 328     }
 329
 330     const whereAccount: WhereOptions = {}
 331     const whereActor: WhereOptions = {}
 332     const whereVideo: WhereOptions = {}
 333
 334     if (isLocal === true) {
 335       Object.assign(whereActor, {
 336         serverId: null
 337       })
 338     } else if (isLocal === false) {
 339       Object.assign(whereActor, {
 340         serverId: {
 341           [Op.ne]: null
 342         }
 343       })
 344     }
 345
 346     if (search) {
 347       Object.assign(where, {
 348         [Op.or]: [
 349           searchAttribute(search, 'text'),
 350           searchAttribute(search, '$Account.Actor.preferredUsername$'),
 351           searchAttribute(search, '$Account.name$'),
 352           searchAttribute(search, '$Video.name$')
 353         ]
 354       })
 355     }
 356
 357     if (searchAccount) {
 358       Object.assign(whereActor, {
 359         [Op.or]: [
 360           searchAttribute(searchAccount, '$Account.Actor.preferredUsername$'),
 361           searchAttribute(searchAccount, '$Account.name$')
 362         ]
 363       })
 364     }
 365
 366     if (searchVideo) {
 367       Object.assign(whereVideo, searchAttribute(searchVideo, 'name'))
 368     }
 369
 370     const query: FindAndCountOptions = {
 371       offset: start,
 372       limit: count,
 373       order: getCommentSort(sort),
 374       where,
 375       include: [
 376         {
 377           model: AccountModel.unscoped(),
 378           required: true,
 379           where: whereAccount,
 380           include: [
 381             {
 382               attributes: {
 383                 exclude: unusedActorAttributesForAPI
 384               },
 385               model: ActorModel, // Default scope includes avatar and server
 386               required: true,
 387               where: whereActor
 388             }
 389           ]
 390         },
 391         {
 392           model: VideoModel.unscoped(),
 393           required: true,
 394           where: whereVideo
 395         }
 396       ]
 397     }
 398
 399     return VideoCommentModel
 400       .findAndCountAll(query)
 401       .then(({ rows, count }) => {
 402         return { total: count, data: rows }
 403       })
 404   }
 405
 406   static async listThreadsForApi (parameters: {
 407     videoId: number
 408     isVideoOwned: boolean
 409     start: number
 410     count: number
 411     sort: string
 412     user?: MUserAccountId
 413   }) {
 414     const { videoId, isVideoOwned, start, count, sort, user } = parameters
 415
 416     const blockerAccountIds = await VideoCommentModel.buildBlockerAccountIds({ videoId, user, isVideoOwned })
 417
 418     const accountBlockedWhere = {
 419       accountId: {
 420         [Op.notIn]: Sequelize.literal(
 421           '(' + buildBlockedAccountSQL(blockerAccountIds) + ')'
 422         )
 423       }
 424     }
 425
 426     const queryList = {
 427       offset: start,
 428       limit: count,
 429       order: getCommentSort(sort),
 430       where: {
 431         [Op.and]: [
 432           {
 433             videoId
 434           },
 435           {
 436             inReplyToCommentId: null
 437           },
 438           {
 439             [Op.or]: [
 440               accountBlockedWhere,
 441               {
 442                 accountId: null
 443               }
 444             ]
 445           }
 446         ]
 447       }
 448     }
 449
 450     const scopesList: (string | ScopeOptions)[] = [
 451       ScopeNames.WITH_ACCOUNT_FOR_API,
 452       {
 453         method: [ ScopeNames.ATTRIBUTES_FOR_API, blockerAccountIds ]
 454       }
 455     ]
 456
 457     const queryCount = {
 458       where: {
 459         videoId,
 460         deletedAt: null,
 461         ...accountBlockedWhere
 462       }
 463     }
 464
 465     return Promise.all([
 466       VideoCommentModel.scope(scopesList).findAndCountAll(queryList),
 467       VideoCommentModel.count(queryCount)
 468     ]).then(([ { rows, count }, totalNotDeletedComments ]) => {
 469       return { total: count, data: rows, totalNotDeletedComments }
 470     })
 471   }
 472
 473   static async listThreadCommentsForApi (parameters: {
 474     videoId: number
 475     isVideoOwned: boolean
 476     threadId: number
 477     user?: MUserAccountId
 478   }) {
 479     const { videoId, threadId, user, isVideoOwned } = parameters
 480
 481     const blockerAccountIds = await VideoCommentModel.buildBlockerAccountIds({ videoId, user, isVideoOwned })
 482
 483     const query = {
 484       order: [ [ 'createdAt', 'ASC' ], [ 'updatedAt', 'ASC' ] ] as Order,
 485       where: {
 486         videoId,
 487         [Op.and]: [
 488           {
 489             [Op.or]: [
 490               { id: threadId },
 491               { originCommentId: threadId }
 492             ]
 493           },
 494           {
 495             [Op.or]: [
 496               {
 497                 accountId: {
 498                   [Op.notIn]: Sequelize.literal(
 499                     '(' + buildBlockedAccountSQL(blockerAccountIds) + ')'
 500                   )
 501                 }
 502               },
 503               {
 504                 accountId: null
 505               }
 506             ]
 507           }
 508         ]
 509       }
 510     }
 511
 512     const scopes: any[] = [
 513       ScopeNames.WITH_ACCOUNT_FOR_API,
 514       {
 515         method: [ ScopeNames.ATTRIBUTES_FOR_API, blockerAccountIds ]
 516       }
 517     ]
 518
 519     return VideoCommentModel.scope(scopes)
 520       .findAndCountAll(query)
 521       .then(({ rows, count }) => {
 522         return { total: count, data: rows }
 523       })
 524   }
 525
 526   static listThreadParentComments (comment: MCommentId, t: Transaction, order: 'ASC' | 'DESC' = 'ASC'): Promise<MCommentOwner[]> {
 527     const query = {
 528       order: [ [ 'createdAt', order ] ] as Order,
 529       where: {
 530         id: {
 531           [Op.in]: Sequelize.literal('(' +
 532             'WITH RECURSIVE children (id, "inReplyToCommentId") AS ( ' +
 533               `SELECT id, "inReplyToCommentId" FROM "videoComment" WHERE id = ${comment.id} ` +
 534               'UNION ' +
 535               'SELECT "parent"."id", "parent"."inReplyToCommentId" FROM "videoComment" "parent" ' +
 536               'INNER JOIN "children" ON "children"."inReplyToCommentId" = "parent"."id"' +
 537             ') ' +
 538             'SELECT id FROM children' +
 539           ')'),
 540           [Op.ne]: comment.id
 541         }
 542       },
 543       transaction: t
 544     }
 545
 546     return VideoCommentModel
 547       .scope([ ScopeNames.WITH_ACCOUNT ])
 548       .findAll(query)
 549   }
 550
 551   static async listAndCountByVideoForAP (video: MVideoImmutable, start: number, count: number, t?: Transaction) {
 552     const blockerAccountIds = await VideoCommentModel.buildBlockerAccountIds({
 553       videoId: video.id,
 554       isVideoOwned: video.isOwned()
 555     })
 556
 557     const query = {
 558       order: [ [ 'createdAt', 'ASC' ] ] as Order,
 559       offset: start,
 560       limit: count,
 561       where: {
 562         videoId: video.id,
 563         accountId: {
 564           [Op.notIn]: Sequelize.literal(
 565             '(' + buildBlockedAccountSQL(blockerAccountIds) + ')'
 566           )
 567         }
 568       },
 569       transaction: t
 570     }
 571
 572     return VideoCommentModel.findAndCountAll<MComment>(query)
 573   }
 574
 575   static async listForFeed (parameters: {
 576     start: number
 577     count: number
 578     videoId?: number
 579     accountId?: number
 580     videoChannelId?: number
 581   }): Promise<MCommentOwnerVideoFeed[]> {
 582     const serverActor = await getServerActor()
 583     const { start, count, videoId, accountId, videoChannelId } = parameters
 584
 585     const whereAnd: WhereOptions[] = buildBlockedAccountSQLOptimized(
 586       '"VideoCommentModel"."accountId"',
 587       [ serverActor.Account.id, '"Video->VideoChannel"."accountId"' ]
 588     )
 589
 590     if (accountId) {
 591       whereAnd.push({
 592         [Op.eq]: accountId
 593       })
 594     }
 595
 596     const accountWhere = {
 597       [Op.and]: whereAnd
 598     }
 599
 600     const videoChannelWhere = videoChannelId ? { id: videoChannelId } : undefined
 601
 602     const query = {
 603       order: [ [ 'createdAt', 'DESC' ] ] as Order,
 604       offset: start,
 605       limit: count,
 606       where: {
 607         deletedAt: null,
 608         accountId: accountWhere
 609       },
 610       include: [
 611         {
 612           attributes: [ 'name', 'uuid' ],
 613           model: VideoModel.unscoped(),
 614           required: true,
 615           where: {
 616             privacy: VideoPrivacy.PUBLIC
 617           },
 618           include: [
 619             {
 620               attributes: [ 'accountId' ],
 621               model: VideoChannelModel.unscoped(),
 622               required: true,
 623               where: videoChannelWhere
 624             }
 625           ]
 626         }
 627       ]
 628     }
 629
 630     if (videoId) query.where['videoId'] = videoId
 631
 632     return VideoCommentModel
 633       .scope([ ScopeNames.WITH_ACCOUNT ])
 634       .findAll(query)
 635   }
 636
 637   static listForBulkDelete (ofAccount: MAccount, filter: { onVideosOfAccount?: MAccountId } = {}) {
 638     const accountWhere = filter.onVideosOfAccount
 639       ? { id: filter.onVideosOfAccount.id }
 640       : {}
 641
 642     const query = {
 643       limit: 1000,
 644       where: {
 645         deletedAt: null,
 646         accountId: ofAccount.id
 647       },
 648       include: [
 649         {
 650           model: VideoModel,
 651           required: true,
 652           include: [
 653             {
 654               model: VideoChannelModel,
 655               required: true,
 656               include: [
 657                 {
 658                   model: AccountModel,
 659                   required: true,
 660                   where: accountWhere
 661                 }
 662               ]
 663             }
 664           ]
 665         }
 666       ]
 667     }
 668
 669     return VideoCommentModel
 670       .scope([ ScopeNames.WITH_ACCOUNT ])
 671       .findAll(query)
 672   }
 673
 674   static async getStats () {
 675     const totalLocalVideoComments = await VideoCommentModel.count({
 676       include: [
 677         {
 678           model: AccountModel,
 679           required: true,
 680           include: [
 681             {
 682               model: ActorModel,
 683               required: true,
 684               where: {
 685                 serverId: null
 686               }
 687             }
 688           ]
 689         }
 690       ]
 691     })
 692     const totalVideoComments = await VideoCommentModel.count()
 693
 694     return {
 695       totalLocalVideoComments,
 696       totalVideoComments
 697     }
 698   }
 699
 700   static listRemoteCommentUrlsOfLocalVideos () {
 701     const query = `SELECT "videoComment".url FROM "videoComment" ` +
 702       `INNER JOIN account ON account.id = "videoComment"."accountId" ` +
 703       `INNER JOIN actor ON actor.id = "account"."actorId" AND actor."serverId" IS NOT NULL ` +
 704       `INNER JOIN video ON video.id = "videoComment"."videoId" AND video.remote IS FALSE`
 705
 706     return VideoCommentModel.sequelize.query<{ url: string }>(query, {
 707       type: QueryTypes.SELECT,
 708       raw: true
 709     }).then(rows => rows.map(r => r.url))
 710   }
 711
 712   static cleanOldCommentsOf (videoId: number, beforeUpdatedAt: Date) {
 713     const query = {
 714       where: {
 715         updatedAt: {
 716           [Op.lt]: beforeUpdatedAt
 717         },
 718         videoId,
 719         accountId: {
 720           [Op.notIn]: buildLocalAccountIdsIn()
 721         },
 722         // Do not delete Tombstones
 723         deletedAt: null
 724       }
 725     }
 726
 727     return VideoCommentModel.destroy(query)
 728   }
 729
 730   getCommentStaticPath () {
 731     return this.Video.getWatchStaticPath() + ';threadId=' + this.getThreadId()
 732   }
 733
 734   getThreadId (): number {
 735     return this.originCommentId || this.id
 736   }
 737
 738   isOwned () {
 739     if (!this.Account) {
 740       return false
 741     }
 742
 743     return this.Account.isOwned()
 744   }
 745
 746   isDeleted () {
 747     return this.deletedAt !== null
 748   }
 749
 750   extractMentions () {
 751     let result: string[] = []
 752
 753     const localMention = `@(${actorNameAlphabet}+)`
 754     const remoteMention = `${localMention}@${WEBSERVER.HOST}`
 755
 756     const mentionRegex = this.isOwned()
 757       ? '(?:(?:' + remoteMention + ')|(?:' + localMention + '))' // Include local mentions?
 758       : '(?:' + remoteMention + ')'
 759
 760     const firstMentionRegex = new RegExp(`^${mentionRegex} `, 'g')
 761     const endMentionRegex = new RegExp(` ${mentionRegex}$`, 'g')
 762     const remoteMentionsRegex = new RegExp(' ' + remoteMention + ' ', 'g')
 763
 764     result = result.concat(
 765       regexpCapture(this.text, firstMentionRegex)
 766         .map(([ , username1, username2 ]) => username1 || username2),
 767
 768       regexpCapture(this.text, endMentionRegex)
 769         .map(([ , username1, username2 ]) => username1 || username2),
 770
 771       regexpCapture(this.text, remoteMentionsRegex)
 772         .map(([ , username ]) => username)
 773     )
 774
 775     // Include local mentions
 776     if (this.isOwned()) {
 777       const localMentionsRegex = new RegExp(' ' + localMention + ' ', 'g')
 778
 779       result = result.concat(
 780         regexpCapture(this.text, localMentionsRegex)
 781           .map(([ , username ]) => username)
 782       )
 783     }
 784
 785     return uniq(result)
 786   }
 787
 788   toFormattedJSON (this: MCommentFormattable) {
 789     return {
 790       id: this.id,
 791       url: this.url,
 792       text: this.text,
 793
 794       threadId: this.getThreadId(),
 795       inReplyToCommentId: this.inReplyToCommentId || null,
 796       videoId: this.videoId,
 797
 798       createdAt: this.createdAt,
 799       updatedAt: this.updatedAt,
 800       deletedAt: this.deletedAt,
 801
 802       isDeleted: this.isDeleted(),
 803
 804       totalRepliesFromVideoAuthor: this.get('totalRepliesFromVideoAuthor') || 0,
 805       totalReplies: this.get('totalReplies') || 0,
 806
 807       account: this.Account
 808         ? this.Account.toFormattedJSON()
 809         : null
 810     } as VideoComment
 811   }
 812
 813   toFormattedAdminJSON (this: MCommentAdminFormattable) {
 814     return {
 815       id: this.id,
 816       url: this.url,
 817       text: this.text,
 818
 819       threadId: this.getThreadId(),
 820       inReplyToCommentId: this.inReplyToCommentId || null,
 821       videoId: this.videoId,
 822
 823       createdAt: this.createdAt,
 824       updatedAt: this.updatedAt,
 825
 826       video: {
 827         id: this.Video.id,
 828         uuid: this.Video.uuid,
 829         name: this.Video.name
 830       },
 831
 832       account: this.Account
 833         ? this.Account.toFormattedJSON()
 834         : null
 835     } as VideoCommentAdmin
 836   }
 837
 838   toActivityPubObject (this: MCommentAP, threadParentComments: MCommentOwner[]): VideoCommentObject | ActivityTombstoneObject {
 839     let inReplyTo: string
 840     // New thread, so in AS we reply to the video
 841     if (this.inReplyToCommentId === null) {
 842       inReplyTo = this.Video.url
 843     } else {
 844       inReplyTo = this.InReplyToVideoComment.url
 845     }
 846
 847     if (this.isDeleted()) {
 848       return {
 849         id: this.url,
 850         type: 'Tombstone',
 851         formerType: 'Note',
 852         inReplyTo,
 853         published: this.createdAt.toISOString(),
 854         updated: this.updatedAt.toISOString(),
 855         deleted: this.deletedAt.toISOString()
 856       }
 857     }
 858
 859     const tag: ActivityTagObject[] = []
 860     for (const parentComment of threadParentComments) {
 861       if (!parentComment.Account) continue
 862
 863       const actor = parentComment.Account.Actor
 864
 865       tag.push({
 866         type: 'Mention',
 867         href: actor.url,
 868         name: `@${actor.preferredUsername}@${actor.getHost()}`
 869       })
 870     }
 871
 872     return {
 873       type: 'Note' as 'Note',
 874       id: this.url,
 875       content: this.text,
 876       inReplyTo,
 877       updated: this.updatedAt.toISOString(),
 878       published: this.createdAt.toISOString(),
 879       url: this.url,
 880       attributedTo: this.Account.Actor.url,
 881       tag
 882     }
 883   }
 884
 885   private static async buildBlockerAccountIds (options: {
 886     videoId: number
 887     isVideoOwned: boolean
 888     user?: MUserAccountId
 889   }) {
 890     const { videoId, user, isVideoOwned } = options
 891
 892     const serverActor = await getServerActor()
 893     const blockerAccountIds = [ serverActor.Account.id ]
 894
 895     if (user) blockerAccountIds.push(user.Account.id)
 896
 897     if (isVideoOwned) {
 898       const videoOwnerAccount = await AccountModel.loadAccountIdFromVideo(videoId)
 899       blockerAccountIds.push(videoOwnerAccount.id)
 900     }
 901
 902     return blockerAccountIds
 903   }
 904 }