Send account activitypub update events

[github/Chocobozzz/PeerTube.git] / server / models / video / video-comment.ts

diff --git a/server/models/video/video-comment.ts b/server/models/video/video-comment.ts
index 92c0c6112fe08f37eb252ac600481261062370e2..63675c20bf688abde380b46fc6820a30c6c782c2 100644 (file)
--- a/server/models/video/video-comment.ts
+++ b/server/models/video/video-comment.ts
@@ -1,19 +1,83 @@
 import * as Sequelize from 'sequelize'
 import {
-  AllowNull, BelongsTo, Column, CreatedAt, DataType, Default, ForeignKey, IFindOptions, Is, IsUUID, Model, Table,
+  AfterDestroy, AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, IFindOptions, Is, Model, Scopes, Table,
   UpdatedAt
 } from 'sequelize-typescript'
-import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub'
+import { VideoCommentObject } from '../../../shared/models/activitypub/objects/video-comment-object'
+import { VideoComment } from '../../../shared/models/videos/video-comment.model'
+import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
 import { CONSTRAINTS_FIELDS } from '../../initializers'
+import { AccountModel } from '../account/account'
 import { ActorModel } from '../activitypub/actor'
-import { throwIfNotValid } from '../utils'
+import { ServerModel } from '../server/server'
+import { getSort, throwIfNotValid } from '../utils'
 import { VideoModel } from './video'
 
+enum ScopeNames {
+  WITH_ACCOUNT = 'WITH_ACCOUNT',
+  WITH_IN_REPLY_TO = 'WITH_IN_REPLY_TO',
+  WITH_VIDEO = 'WITH_VIDEO',
+  ATTRIBUTES_FOR_API = 'ATTRIBUTES_FOR_API'
+}
+
+@Scopes({
+  [ScopeNames.ATTRIBUTES_FOR_API]: {
+    attributes: {
+      include: [
+        [
+          Sequelize.literal(
+            '(SELECT COUNT("replies"."id") ' +
+            'FROM "videoComment" AS "replies" ' +
+            'WHERE "replies"."originCommentId" = "VideoCommentModel"."id")'
+          ),
+          'totalReplies'
+        ]
+      ]
+    }
+  },
+  [ScopeNames.WITH_ACCOUNT]: {
+    include: [
+      {
+        model: () => AccountModel,
+        include: [
+          {
+            model: () => ActorModel,
+            include: [
+              {
+                model: () => ServerModel,
+                required: false
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  [ScopeNames.WITH_IN_REPLY_TO]: {
+    include: [
+      {
+        model: () => VideoCommentModel,
+        as: 'InReplyToVideoComment'
+      }
+    ]
+  },
+  [ScopeNames.WITH_VIDEO]: {
+    include: [
+      {
+        model: () => VideoModel,
+        required: false
+      }
+    ]
+  }
+})
 @Table({
   tableName: 'videoComment',
   indexes: [
     {
       fields: [ 'videoId' ]
+    },
+    {
+      fields: [ 'videoId', 'originCommentId' ]
     }
   ]
 })
@@ -39,8 +103,10 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
 
   @BelongsTo(() => VideoCommentModel, {
     foreignKey: {
+      name: 'originCommentId',
       allowNull: true
     },
+    as: 'OriginVideoComment',
     onDelete: 'CASCADE'
   })
   OriginVideoComment: VideoCommentModel
@@ -51,8 +117,10 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
 
   @BelongsTo(() => VideoCommentModel, {
     foreignKey: {
+      name: 'inReplyToCommentId',
       allowNull: true
     },
+    as: 'InReplyToVideoComment',
     onDelete: 'CASCADE'
   })
   InReplyToVideoComment: VideoCommentModel
@@ -69,17 +137,49 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
   })
   Video: VideoModel
 
-  @ForeignKey(() => ActorModel)
+  @ForeignKey(() => AccountModel)
   @Column
-  actorId: number
+  accountId: number
 
-  @BelongsTo(() => ActorModel, {
+  @BelongsTo(() => AccountModel, {
     foreignKey: {
       allowNull: false
     },
     onDelete: 'CASCADE'
   })
-  Actor: ActorModel
+  Account: AccountModel
+
+  @AfterDestroy
+  static sendDeleteIfOwned (instance: VideoCommentModel) {
+    // TODO
+    return undefined
+  }
+
+  static loadById (id: number, t?: Sequelize.Transaction) {
+    const query: IFindOptions<VideoCommentModel> = {
+      where: {
+        id
+      }
+    }
+
+    if (t !== undefined) query.transaction = t
+
+    return VideoCommentModel.findOne(query)
+  }
+
+  static loadByIdAndPopulateVideoAndAccountAndReply (id: number, t?: Sequelize.Transaction) {
+    const query: IFindOptions<VideoCommentModel> = {
+      where: {
+        id
+      }
+    }
+
+    if (t !== undefined) query.transaction = t
+
+    return VideoCommentModel
+      .scope([ ScopeNames.WITH_VIDEO, ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_IN_REPLY_TO ])
+      .findOne(query)
+  }
 
   static loadByUrl (url: string, t?: Sequelize.Transaction) {
     const query: IFindOptions<VideoCommentModel> = {
@@ -92,4 +192,82 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
 
     return VideoCommentModel.findOne(query)
   }
+
+  static listThreadsForApi (videoId: number, start: number, count: number, sort: string) {
+    const query = {
+      offset: start,
+      limit: count,
+      order: [ getSort(sort) ],
+      where: {
+        videoId,
+        inReplyToCommentId: null
+      }
+    }
+
+    return VideoCommentModel
+      .scope([ ScopeNames.WITH_ACCOUNT, ScopeNames.ATTRIBUTES_FOR_API ])
+      .findAndCountAll(query)
+      .then(({ rows, count }) => {
+        return { total: count, data: rows }
+      })
+  }
+
+  static listThreadCommentsForApi (videoId: number, threadId: number) {
+    const query = {
+      order: [ [ 'createdAt', 'ASC' ] ],
+      where: {
+        videoId,
+        [ Sequelize.Op.or ]: [
+          { id: threadId },
+          { originCommentId: threadId }
+        ]
+      }
+    }
+
+    return VideoCommentModel
+      .scope([ ScopeNames.WITH_ACCOUNT, ScopeNames.ATTRIBUTES_FOR_API ])
+      .findAndCountAll(query)
+      .then(({ rows, count }) => {
+        return { total: count, data: rows }
+      })
+  }
+
+  toFormattedJSON () {
+    return {
+      id: this.id,
+      url: this.url,
+      text: this.text,
+      threadId: this.originCommentId || this.id,
+      inReplyToCommentId: this.inReplyToCommentId || null,
+      videoId: this.videoId,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      totalReplies: this.get('totalReplies') || 0,
+      account: {
+        name: this.Account.name,
+        host: this.Account.Actor.getHost()
+      }
+    } as VideoComment
+  }
+
+  toActivityPubObject (): VideoCommentObject {
+    let inReplyTo: string
+    // New thread, so in AS we reply to the video
+    if (this.inReplyToCommentId === null) {
+      inReplyTo = this.Video.url
+    } else {
+      inReplyTo = this.InReplyToVideoComment.url
+    }
+
+    return {
+      type: 'Note' as 'Note',
+      id: this.url,
+      content: this.text,
+      inReplyTo,
+      updated: this.updatedAt.toISOString(),
+      published: this.createdAt.toISOString(),
+      url: this.url,
+      attributedTo: this.Account.Actor.url
+    }
+  }
 }