-import * as Sequelize from 'sequelize'
-import {
- AllowNull,
- BeforeDestroy,
- BelongsTo,
- Column,
- CreatedAt,
- DataType,
- ForeignKey,
- IFindOptions,
- Is,
- Model,
- Scopes,
- Table,
- UpdatedAt
-} from 'sequelize-typescript'
+import { AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, Is, Model, Scopes, Table, UpdatedAt } from 'sequelize-typescript'
import { ActivityTagObject } from '../../../shared/models/activitypub/objects/common-objects'
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 { CONFIG, CONSTRAINTS_FIELDS } from '../../initializers'
-import { sendDeleteVideoComment } from '../../lib/activitypub/send'
+import { CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants'
import { AccountModel } from '../account/account'
import { ActorModel } from '../activitypub/actor'
-import { AvatarModel } from '../avatar/avatar'
-import { ServerModel } from '../server/server'
-import { buildBlockedAccountSQL, getSort, throwIfNotValid } from '../utils'
+import { buildBlockedAccountSQL, buildLocalAccountIdsIn, getSort, throwIfNotValid } from '../utils'
import { VideoModel } from './video'
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'
+import * as Bluebird from 'bluebird'
+import {
+ MComment,
+ MCommentAP,
+ MCommentFormattable,
+ MCommentId,
+ MCommentOwner,
+ MCommentOwnerReplyVideoLight,
+ MCommentOwnerVideo,
+ MCommentOwnerVideoFeed,
+ MCommentOwnerVideoReply
+} from '../../typings/models/video'
+import { MUserAccountId } from '@server/typings/models'
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,
- include: [
- {
- model: () => ActorModel,
- include: [
- {
- model: () => ServerModel,
- required: false
- },
- {
- model: () => AvatarModel,
- required: false
- }
- ]
- }
- ]
+ model: AccountModel
}
]
},
[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,
required: true,
include: [
{
- model: () => AccountModel,
- required: true,
- include: [
- {
- model: () => ActorModel,
- required: true
- }
- ]
+ model: AccountModel,
+ required: true
}
]
}
}
]
}
-})
+}))
@Table({
tableName: 'videoComment',
indexes: [
})
Account: AccountModel
- @BeforeDestroy
- static async sendDeleteIfOwned (instance: VideoCommentModel, options) {
- if (!instance.Account || !instance.Account.Actor) {
- instance.Account = await instance.$get('Account', {
- include: [ ActorModel ],
- transaction: options.transaction
- }) as AccountModel
- }
-
- if (!instance.Video) {
- instance.Video = await instance.$get('Video', {
- include: [
- {
- model: VideoChannelModel,
- include: [
- {
- model: AccountModel,
- include: [
- {
- model: ActorModel
- }
- ]
- }
- ]
- }
- ],
- transaction: options.transaction
- }) as VideoModel
- }
-
- if (instance.isOwned()) {
- await sendDeleteVideoComment(instance, options.transaction)
- }
- }
-
- static loadById (id: number, t?: Sequelize.Transaction) {
- const query: IFindOptions<VideoCommentModel> = {
+ static loadById (id: number, t?: Transaction): Bluebird<MComment> {
+ 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): Bluebird<MCommentOwnerVideoReply> {
+ const query: FindOptions = {
where: {
id
}
.findOne(query)
}
- static loadByUrlAndPopulateAccount (url: string, t?: Sequelize.Transaction) {
- const query: IFindOptions<VideoCommentModel> = {
+ static loadByUrlAndPopulateAccountAndVideo (url: string, t?: Transaction): Bluebird<MCommentOwnerVideo> {
+ const query: FindOptions = {
where: {
url
}
if (t !== undefined) query.transaction = t
- return VideoCommentModel.scope([ ScopeNames.WITH_ACCOUNT ]).findOne(query)
+ return VideoCommentModel.scope([ ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_VIDEO ]).findOne(query)
}
- static loadByUrlAndPopulateReplyAndVideo (url: string, t?: Sequelize.Transaction) {
- const query: IFindOptions<VideoCommentModel> = {
+ static loadByUrlAndPopulateReplyAndVideoUrlAndAccount (url: string, t?: Transaction): Bluebird<MCommentOwnerReplyVideoLight> {
+ const query: FindOptions = {
where: {
url
- }
+ },
+ include: [
+ {
+ attributes: [ 'id', 'url' ],
+ model: VideoModel.unscoped()
+ }
+ ]
}
if (t !== undefined) query.transaction = t
- return VideoCommentModel.scope([ ScopeNames.WITH_IN_REPLY_TO, ScopeNames.WITH_VIDEO ]).findOne(query)
+ return VideoCommentModel.scope([ ScopeNames.WITH_IN_REPLY_TO, ScopeNames.WITH_ACCOUNT ]).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?: MUserAccountId
+ }) {
+ 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?: MUserAccountId
+ }) {
+ 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: MCommentId, t: Transaction, order: 'ASC' | 'DESC' = 'ASC'): Bluebird<MCommentOwner[]> {
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 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: {
transaction: t
}
- return VideoCommentModel.findAndCountAll(query)
+ return VideoCommentModel.findAndCountAll<MComment>(query)
}
- static listForFeed (start: number, count: number, videoId?: number) {
+ static listForFeed (start: number, count: number, videoId?: number): Bluebird<MCommentOwnerVideoFeed[]> {
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,
+ accountId: {
+ [Op.notIn]: buildLocalAccountIdsIn()
+ }
+ }
+ }
+
+ return VideoCommentModel.destroy(query)
+ }
+
getCommentStaticPath () {
return this.Video.getWatchStaticPath() + ';threadId=' + this.getThreadId()
}
let result: string[] = []
const localMention = `@(${actorNameAlphabet}+)`
- const remoteMention = `${localMention}@${CONFIG.WEBSERVER.HOST}`
+ const remoteMention = `${localMention}@${WEBSERVER.HOST}`
const mentionRegex = this.isOwned()
? '(?:(?:' + remoteMention + ')|(?:' + localMention + '))' // Include local mentions?
return uniq(result)
}
- toFormattedJSON () {
+ toFormattedJSON (this: MCommentFormattable) {
return {
id: this.id,
url: this.url,
} as VideoComment
}
- toActivityPubObject (threadParentComments: VideoCommentModel[]): VideoCommentObject {
+ toActivityPubObject (this: MCommentAP, threadParentComments: MCommentOwner[]): VideoCommentObject {
let inReplyTo: string
// New thread, so in AS we reply to the video
if (this.inReplyToCommentId === null) {
projects / github / Chocobozzz / PeerTube.git / blobdiff