server/models/video/video-comment.ts

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