-import * as Sequelize from 'sequelize'
import {
AllowNull,
BeforeDestroy,
CreatedAt,
DataType,
ForeignKey,
- IFindOptions,
Is,
Model,
Scopes,
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 { CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants'
import { sendDeleteVideoComment } from '../../lib/activitypub/send'
import { AccountModel } from '../account/account'
import { ActorModel } from '../activitypub/actor'
import { VideoChannelModel } from './video-channel'
import { getServerActor } from '../../helpers/utils'
import { UserModel } from '../account/user'
+import { actorNameAlphabet } from '../../helpers/custom-validators/activitypub/actor'
+import { regexpCapture } from '../../helpers/regexp'
+import { uniq } from 'lodash'
+import { FindOptions, Op, Order, ScopeOptions, Sequelize, Transaction } from 'sequelize'
enum ScopeNames {
WITH_ACCOUNT = 'WITH_ACCOUNT',
ATTRIBUTES_FOR_API = 'ATTRIBUTES_FOR_API'
}
-@Scopes({
+@Scopes(() => ({
[ScopeNames.ATTRIBUTES_FOR_API]: (serverAccountId: number, userAccountId?: number) => {
return {
attributes: {
]
]
}
- }
+ } as FindOptions
},
[ScopeNames.WITH_ACCOUNT]: {
include: [
{
- model: () => AccountModel,
+ model: AccountModel,
include: [
{
- model: () => ActorModel,
+ model: ActorModel,
include: [
{
- model: () => ServerModel,
+ model: ServerModel,
required: false
},
{
- model: () => AvatarModel,
+ model: AvatarModel,
required: false
}
]
[ScopeNames.WITH_IN_REPLY_TO]: {
include: [
{
- model: () => VideoCommentModel,
+ model: VideoCommentModel,
as: 'InReplyToVideoComment'
}
]
[ScopeNames.WITH_VIDEO]: {
include: [
{
- model: () => VideoModel,
+ model: VideoModel,
required: true,
include: [
{
- model: () => VideoChannelModel.unscoped(),
+ model: VideoChannelModel.unscoped(),
required: true,
include: [
{
- model: () => AccountModel,
+ model: AccountModel,
required: true,
include: [
{
- model: () => ActorModel,
+ model: ActorModel,
required: true
}
]
}
]
}
-})
+}))
@Table({
tableName: 'videoComment',
indexes: [
}
}
- static loadById (id: number, t?: Sequelize.Transaction) {
- const query: IFindOptions<VideoCommentModel> = {
+ static loadById (id: number, t?: Transaction) {
+ const query: FindOptions = {
where: {
id
}
return VideoCommentModel.findOne(query)
}
- static loadByIdAndPopulateVideoAndAccountAndReply (id: number, t?: Sequelize.Transaction) {
- const query: IFindOptions<VideoCommentModel> = {
+ static loadByIdAndPopulateVideoAndAccountAndReply (id: number, t?: Transaction) {
+ const query: FindOptions = {
where: {
id
}
.findOne(query)
}
- static loadByUrlAndPopulateAccount (url: string, t?: Sequelize.Transaction) {
- const query: IFindOptions<VideoCommentModel> = {
+ static loadByUrlAndPopulateAccount (url: string, t?: Transaction) {
+ const query: FindOptions = {
where: {
url
}
return VideoCommentModel.scope([ ScopeNames.WITH_ACCOUNT ]).findOne(query)
}
- static loadByUrlAndPopulateReplyAndVideo (url: string, t?: Sequelize.Transaction) {
- const query: IFindOptions<VideoCommentModel> = {
+ static loadByUrlAndPopulateReplyAndVideo (url: string, t?: Transaction) {
+ const query: FindOptions = {
where: {
url
}
return VideoCommentModel.scope([ ScopeNames.WITH_IN_REPLY_TO, ScopeNames.WITH_VIDEO ]).findOne(query)
}
- static async listThreadsForApi (videoId: number, start: number, count: number, sort: string, user?: UserModel) {
+ static async listThreadsForApi (parameters: {
+ videoId: number,
+ start: number,
+ count: number,
+ sort: string,
+ user?: UserModel
+ }) {
+ const { videoId, start, count, sort, user } = parameters
+
const serverActor = await getServerActor()
const serverAccountId = serverActor.Account.id
const userAccountId = user ? user.Account.id : undefined
videoId,
inReplyToCommentId: null,
accountId: {
- [Sequelize.Op.notIn]: Sequelize.literal(
+ [Op.notIn]: Sequelize.literal(
'(' + buildBlockedAccountSQL(serverAccountId, userAccountId) + ')'
)
}
}
}
- // FIXME: typings
- const scopes: any[] = [
+ const scopes: (string | ScopeOptions)[] = [
ScopeNames.WITH_ACCOUNT,
{
method: [ ScopeNames.ATTRIBUTES_FOR_API, serverAccountId, userAccountId ]
})
}
- static async listThreadCommentsForApi (videoId: number, threadId: number, user?: UserModel) {
+ static async listThreadCommentsForApi (parameters: {
+ videoId: number,
+ threadId: number,
+ user?: UserModel
+ }) {
+ const { videoId, threadId, user } = parameters
+
const serverActor = await getServerActor()
const serverAccountId = serverActor.Account.id
const userAccountId = user ? user.Account.id : undefined
const query = {
- order: [ [ 'createdAt', 'ASC' ], [ 'updatedAt', 'ASC' ] ],
+ order: [ [ 'createdAt', 'ASC' ], [ 'updatedAt', 'ASC' ] ] as Order,
where: {
videoId,
- [ Sequelize.Op.or ]: [
+ [ Op.or ]: [
{ id: threadId },
{ originCommentId: threadId }
],
accountId: {
- [Sequelize.Op.notIn]: Sequelize.literal(
+ [Op.notIn]: Sequelize.literal(
'(' + buildBlockedAccountSQL(serverAccountId, userAccountId) + ')'
)
}
})
}
- static listThreadParentComments (comment: VideoCommentModel, t: Sequelize.Transaction, order: 'ASC' | 'DESC' = 'ASC') {
+ static listThreadParentComments (comment: VideoCommentModel, t: Transaction, order: 'ASC' | 'DESC' = 'ASC') {
const query = {
- order: [ [ 'createdAt', order ] ],
+ order: [ [ 'createdAt', order ] ] as Order,
where: {
id: {
- [ Sequelize.Op.in ]: Sequelize.literal('(' +
+ [ Op.in ]: Sequelize.literal('(' +
'WITH RECURSIVE children (id, "inReplyToCommentId") AS ( ' +
- 'SELECT id, "inReplyToCommentId" FROM "videoComment" WHERE id = ' + comment.id + ' UNION ' +
- 'SELECT p.id, p."inReplyToCommentId" from "videoComment" p ' +
- 'INNER JOIN children c ON c."inReplyToCommentId" = p.id) ' +
+ `SELECT id, "inReplyToCommentId" FROM "videoComment" WHERE id = ${comment.id} ` +
+ 'UNION ' +
+ 'SELECT "parent"."id", "parent"."inReplyToCommentId" FROM "videoComment" "parent" ' +
+ 'INNER JOIN "children" ON "children"."inReplyToCommentId" = "parent"."id"' +
+ ') ' +
'SELECT id FROM children' +
')'),
- [ Sequelize.Op.ne ]: comment.id
+ [ Op.ne ]: comment.id
}
},
transaction: t
.findAll(query)
}
- static listAndCountByVideoId (videoId: number, start: number, count: number, t?: Sequelize.Transaction, order: 'ASC' | 'DESC' = 'ASC') {
+ static listAndCountByVideoId (videoId: number, start: number, count: number, t?: Transaction, order: 'ASC' | 'DESC' = 'ASC') {
const query = {
- order: [ [ 'createdAt', order ] ],
+ order: [ [ 'createdAt', order ] ] as Order,
offset: start,
limit: count,
where: {
static listForFeed (start: number, count: number, videoId?: number) {
const query = {
- order: [ [ 'createdAt', 'DESC' ] ],
+ order: [ [ 'createdAt', 'DESC' ] ] as Order,
offset: start,
limit: count,
where: {},
}
}
+ static cleanOldCommentsOf (videoId: number, beforeUpdatedAt: Date) {
+ const query = {
+ where: {
+ updatedAt: {
+ [Op.lt]: beforeUpdatedAt
+ },
+ videoId
+ }
+ }
+
+ return VideoCommentModel.destroy(query)
+ }
+
+ getCommentStaticPath () {
+ return this.Video.getWatchStaticPath() + ';threadId=' + this.getThreadId()
+ }
+
getThreadId (): number {
return this.originCommentId || this.id
}
return this.Account.isOwned()
}
+ extractMentions () {
+ let result: string[] = []
+
+ const localMention = `@(${actorNameAlphabet}+)`
+ const remoteMention = `${localMention}@${WEBSERVER.HOST}`
+
+ const mentionRegex = this.isOwned()
+ ? '(?:(?:' + remoteMention + ')|(?:' + localMention + '))' // Include local mentions?
+ : '(?:' + remoteMention + ')'
+
+ const firstMentionRegex = new RegExp(`^${mentionRegex} `, 'g')
+ const endMentionRegex = new RegExp(` ${mentionRegex}$`, 'g')
+ const remoteMentionsRegex = new RegExp(' ' + remoteMention + ' ', 'g')
+
+ result = result.concat(
+ regexpCapture(this.text, firstMentionRegex)
+ .map(([ , username1, username2 ]) => username1 || username2),
+
+ regexpCapture(this.text, endMentionRegex)
+ .map(([ , username1, username2 ]) => username1 || username2),
+
+ regexpCapture(this.text, remoteMentionsRegex)
+ .map(([ , username ]) => username)
+ )
+
+ // Include local mentions
+ if (this.isOwned()) {
+ const localMentionsRegex = new RegExp(' ' + localMention + ' ', 'g')
+
+ result = result.concat(
+ regexpCapture(this.text, localMentionsRegex)
+ .map(([ , username ]) => username)
+ )
+ }
+
+ return uniq(result)
+ }
+
toFormattedJSON () {
return {
id: this.id,
projects / github / Chocobozzz / PeerTube.git / blobdiff