1
0
Fork 0

Add admin view to manage comments

This commit is contained in:
Chocobozzz 2020-11-16 11:55:17 +01:00
parent 0f8d00e314
commit f127331459
No known key found for this signature in database
GPG key ID: 583A612D890159BE
16 changed files with 522 additions and 260 deletions

View file

@ -1,12 +1,8 @@
@import 'mixins';
my-global-icon {
@include apply-svg-color(#7d7d7d);
width: 12px;
height: 12px;
position: relative;
top: -1px;
width: 24px;
height: 24px;
}
.input-group {

View file

@ -1,9 +1,11 @@
<h1>
<my-global-icon iconName="cross" aria-hidden="true"></my-global-icon>
<my-global-icon iconName="message-circle" aria-hidden="true"></my-global-icon>
<ng-container i18n>Video comments</ng-container>
<my-feed [syndicationItems]="syndicationItems"></my-feed>
</h1>
this view does show comments from muted accounts so you can delete them
<em>This view also shows comments from muted accounts.</em>
<p-table
[value]="comments" [lazy]="true" [paginator]="totalRecords > 0" [totalRecords]="totalRecords" [rows]="rowsPerPage" [rowsPerPageOptions]="rowsPerPageOptions"
@ -29,7 +31,7 @@ this view does show comments from muted accounts so you can delete them
</div>
<input
type="text" name="table-filter" id="table-filter" i18n-placeholder placeholder="Filter..."
(keyup)="onSearch($event)"
(keyup)="onInputSearch($event)"
>
<a class="glyphicon glyphicon-remove-sign form-control-feedback form-control-clear" (click)="resetTableFilter()"></a>
<span class="sr-only" i18n>Clear filters</span>
@ -41,9 +43,9 @@ this view does show comments from muted accounts so you can delete them
<ng-template pTemplate="header">
<tr>
<th style="width: 40px"></th>
<th style="width: 100px;" i18n>Account</th>
<th style="width: 100px;" i18n>Video</th>
<th style="width: 100px;" i18n>Comment</th>
<th style="width: 300px" i18n>Account</th>
<th style="width: 300px" i18n>Video</th>
<th i18n>Comment</th>
<th style="width: 150px;" i18n pSortableColumn="createdAt">Date <p-sortIcon field="createdAt"></p-sortIcon></th>
<th style="width: 150px;"></th>
</tr>
@ -58,14 +60,28 @@ this view does show comments from muted accounts so you can delete them
</td>
<td>
{{ videoComment.by }}
<a [href]="videoComment.account.localUrl" i18n-title title="Open account in a new tab" target="_blank" rel="noopener noreferrer">
<div class="chip two-lines">
<img
class="avatar"
[src]="videoComment.accountAvatarUrl"
alt=""
>
<div>
{{ videoComment.account.displayName }}
<span>{{ videoComment.by }}</span>
</div>
</div>
</a>
</td>
<td>
{{ videoComment.video.name }}
<td class="video">
<em i18n>Commented video</em>
<a [href]="videoComment.localUrl" target="_blank" rel="noopener noreferrer">{{ videoComment.video.name }}</a>
</td>
<td>
<td class="comment-html">
<div [innerHTML]="videoComment.textHtml"></div>
</td>

View file

@ -1,12 +1,22 @@
@import 'mixins';
my-global-icon {
@include apply-svg-color(#7d7d7d);
h1 {
my-feed {
margin-left: 5px;
display: inline-block;
width: 12px;
height: 12px;
position: relative;
top: -1px;
::ng-deep {
my-global-icon {
width: 15px !important;
top: 0 !important;
}
}
}
}
my-global-icon {
width: 24px;
height: 24px;
}
.input-group {
@ -25,3 +35,32 @@ my-global-icon {
flex-grow: 1;
}
}
.video {
display: flex;
flex-direction: column;
em {
font-size: 11px;
}
a {
@include ellipsis
}
}
.comment-html {
::ng-deep {
> div {
max-height: 22px;
}
div, p {
@include ellipsis;
}
p {
margin: 0;
}
}
}

View file

@ -1,16 +1,17 @@
import { SortMeta } from 'primeng/api'
import { filter } from 'rxjs/operators'
import { AfterViewInit, Component, OnInit } from '@angular/core'
import { DomSanitizer } from '@angular/platform-browser'
import { ActivatedRoute, Params, Router } from '@angular/router'
import { ConfirmService, MarkdownService, Notifier, RestPagination, RestTable, ServerService } from '@app/core'
import { DropdownAction, VideoService } from '@app/shared/shared-main'
import { AuthService, ConfirmService, MarkdownService, Notifier, RestPagination, RestTable } from '@app/core'
import { DropdownAction } from '@app/shared/shared-main'
import { BulkService } from '@app/shared/shared-moderation'
import { VideoCommentAdmin, VideoCommentService } from '@app/shared/shared-video-comment'
import { FeedFormat, UserRight } from '@shared/models'
@Component({
selector: 'my-video-comment-list',
templateUrl: './video-comment-list.component.html',
styleUrls: [ './video-comment-list.component.scss' ]
styleUrls: [ '../../../shared/shared-moderation/moderation.scss', './video-comment-list.component.scss' ]
})
export class VideoCommentListComponent extends RestTable implements OnInit, AfterViewInit {
comments: VideoCommentAdmin[]
@ -20,26 +21,54 @@ export class VideoCommentListComponent extends RestTable implements OnInit, Afte
videoCommentActions: DropdownAction<VideoCommentAdmin>[][] = []
syndicationItems = [
{
format: FeedFormat.RSS,
label: 'media rss 2.0',
url: VideoCommentService.BASE_FEEDS_URL + FeedFormat.RSS.toLowerCase()
},
{
format: FeedFormat.ATOM,
label: 'atom 1.0',
url: VideoCommentService.BASE_FEEDS_URL + FeedFormat.ATOM.toLowerCase()
},
{
format: FeedFormat.JSON,
label: 'json 1.0',
url: VideoCommentService.BASE_FEEDS_URL + FeedFormat.JSON.toLowerCase()
}
]
get authUser () {
return this.auth.getUser()
}
constructor (
private auth: AuthService,
private notifier: Notifier,
private serverService: ServerService,
private confirmService: ConfirmService,
private videoCommentService: VideoCommentService,
private markdownRenderer: MarkdownService,
private sanitizer: DomSanitizer,
private videoService: VideoService,
private route: ActivatedRoute,
private router: Router
private router: Router,
private bulkService: BulkService
) {
super()
this.videoCommentActions = [
[
{
label: $localize`Delete this comment`,
handler: comment => this.deleteComment(comment),
isDisplayed: () => this.authUser.hasRight(UserRight.REMOVE_ANY_VIDEO_COMMENT)
},
// remove this comment,
// remove all comments of this account
{
label: $localize`Delete all comments of this account`,
description: $localize`Comments are deleted after a few minutes`,
handler: comment => this.deleteUserComments(comment),
isDisplayed: () => this.authUser.hasRight(UserRight.REMOVE_ANY_VIDEO_COMMENT)
}
]
]
}
@ -60,7 +89,7 @@ export class VideoCommentListComponent extends RestTable implements OnInit, Afte
if (this.search) this.setTableFilter(this.search)
}
onSearch (event: Event) {
onInputSearch (event: Event) {
this.onSearch(event)
this.setQueryParams((event.target as HTMLInputElement).value)
}
@ -84,7 +113,7 @@ export class VideoCommentListComponent extends RestTable implements OnInit, Afte
}
toHtml (text: string) {
return this.markdownRenderer.textMarkdownToHTML(text)
return this.markdownRenderer.textMarkdownToHTML(text, true, true)
}
protected loadData () {
@ -108,4 +137,33 @@ export class VideoCommentListComponent extends RestTable implements OnInit, Afte
err => this.notifier.error(err.message)
)
}
private deleteComment (comment: VideoCommentAdmin) {
this.videoCommentService.deleteVideoComment(comment.video.id, comment.id)
.subscribe(
() => this.loadData(),
err => this.notifier.error(err.message)
)
}
private async deleteUserComments (comment: VideoCommentAdmin) {
const message = $localize`Do you really want to delete all comments of ${comment.by}?`
const res = await this.confirmService.confirm(message, $localize`Delete`)
if (res === false) return
const options = {
accountName: comment.by,
scope: 'instance' as 'instance'
}
this.bulkService.removeCommentsOf(options)
.subscribe(
() => {
this.notifier.success($localize`Comments of ${options.accountName} will be deleted in a few minutes`)
},
err => this.notifier.error(err.message)
)
}
}

View file

@ -1,4 +1,4 @@
<div class="video-feed">
<div class="feed">
<my-global-icon
*ngIf="syndicationItems.length !== 0" [ngbPopover]="feedsList" [autoClose]="true" placement="bottom left auto"
class="icon-syndication" role="button" iconName="syndication"

View file

@ -1,7 +1,7 @@
@import '_variables';
@import '_mixins';
.video-feed {
.feed {
width: min-content;
a {

View file

@ -59,12 +59,14 @@ export class VideoCommentAdmin implements VideoCommentAdminServerModel {
createdAt: Date | string
updatedAt: Date | string
account: AccountInterface
account: AccountInterface & { localUrl?: string }
localUrl: string
video: {
id: number
uuid: string
name: string
localUrl: string
}
by: string
@ -85,14 +87,19 @@ export class VideoCommentAdmin implements VideoCommentAdminServerModel {
this.video = {
id: hash.video.id,
uuid: hash.video.uuid,
name: hash.video.name
name: hash.video.name,
localUrl: '/videos/watch/' + hash.video.uuid
}
this.localUrl = this.video.localUrl + ';threadId=' + this.threadId
this.account = hash.account
if (this.account) {
this.by = Actor.CREATE_BY_STRING(this.account.name, this.account.host)
this.accountAvatarUrl = Actor.GET_ACTOR_AVATAR_URL(this.account)
this.account.localUrl = '/accounts/' + this.by
}
}
}

View file

@ -19,8 +19,9 @@ import { SortMeta } from 'primeng/api'
@Injectable()
export class VideoCommentService {
static BASE_FEEDS_URL = environment.apiUrl + '/feeds/video-comments.'
private static BASE_VIDEO_URL = environment.apiUrl + '/api/v1/videos/'
private static BASE_FEEDS_URL = environment.apiUrl + '/feeds/video-comments.'
constructor (
private authHttp: HttpClient,
@ -56,7 +57,7 @@ export class VideoCommentService {
search?: string
}): Observable<ResultList<VideoCommentAdmin>> {
const { pagination, sort, search } = options
const url = VideoCommentService.BASE_VIDEO_URL + '/comments'
const url = VideoCommentService.BASE_VIDEO_URL + 'comments'
let params = new HttpParams()
params = this.restService.addRestGetParams(params, pagination, sort)
@ -172,7 +173,7 @@ export class VideoCommentService {
private buildParamsFromSearch (search: string, params: HttpParams) {
const filters = this.restService.parseQueryStringFilter(search, {
state: {
isLocal: {
prefix: 'local:',
isBoolean: true,
handler: v => {

View file

@ -41,6 +41,7 @@ import { Hooks } from '@server/lib/plugins/hooks'
const usersListValidator = [
query('blocked')
.optional()
.customSanitizer(toBooleanOrNull)
.isBoolean().withMessage('Should be a valid boolean banned state'),
(req: express.Request, res: express.Response, next: express.NextFunction) => {

View file

@ -2,7 +2,7 @@ import * as express from 'express'
import { body, param, query } from 'express-validator'
import { MUserAccountUrl } from '@server/types/models'
import { UserRight } from '../../../../shared'
import { exists, isBooleanValid, isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
import { exists, isBooleanValid, isIdOrUUIDValid, isIdValid, toBooleanOrNull } from '../../../helpers/custom-validators/misc'
import {
doesVideoCommentExist,
doesVideoCommentThreadExist,
@ -18,6 +18,7 @@ import { areValidationErrors } from '../utils'
const listVideoCommentsValidator = [
query('isLocal')
.optional()
.customSanitizer(toBooleanOrNull)
.custom(isBooleanValid)
.withMessage('Should have a valid is local boolean'),

View file

@ -323,14 +323,8 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
}) {
const { start, count, sort, isLocal, search, searchAccount, searchVideo } = parameters
const query: FindAndCountOptions = {
offset: start,
limit: count,
order: getCommentSort(sort)
}
const where: WhereOptions = {
isDeleted: false
deletedAt: null
}
const whereAccount: WhereOptions = {}
@ -338,11 +332,11 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
const whereVideo: WhereOptions = {}
if (isLocal === true) {
Object.assign(where, {
Object.assign(whereActor, {
serverId: null
})
} else if (isLocal === false) {
Object.assign(where, {
Object.assign(whereActor, {
serverId: {
[Op.ne]: null
}
@ -350,43 +344,57 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
}
if (search) {
Object.assign(where, searchAttribute(search, 'text'))
Object.assign(whereActor, searchAttribute(search, 'preferredUsername'))
Object.assign(whereAccount, searchAttribute(search, 'name'))
Object.assign(whereVideo, searchAttribute(search, 'name'))
Object.assign(where, {
[Op.or]: [
searchAttribute(search, 'text'),
searchAttribute(search, '$Account.Actor.preferredUsername$'),
searchAttribute(search, '$Account.name$'),
searchAttribute(search, '$Video.name$')
]
})
}
if (searchAccount) {
Object.assign(whereActor, searchAttribute(search, 'preferredUsername'))
Object.assign(whereAccount, searchAttribute(search, 'name'))
Object.assign(whereActor, {
[Op.or]: [
searchAttribute(searchAccount, '$Account.Actor.preferredUsername$'),
searchAttribute(searchAccount, '$Account.name$')
]
})
}
if (searchVideo) {
Object.assign(whereVideo, searchAttribute(search, 'name'))
Object.assign(whereVideo, searchAttribute(searchVideo, 'name'))
}
query.include = [
{
model: AccountModel.unscoped(),
required: !!searchAccount,
where: whereAccount,
include: [
{
attributes: {
exclude: unusedActorAttributesForAPI
},
model: ActorModel, // Default scope includes avatar and server
required: true,
where: whereActor
}
]
},
{
model: VideoModel.unscoped(),
required: true,
where: whereVideo
}
]
const query: FindAndCountOptions = {
offset: start,
limit: count,
order: getCommentSort(sort),
where,
include: [
{
model: AccountModel.unscoped(),
required: true,
where: whereAccount,
include: [
{
attributes: {
exclude: unusedActorAttributesForAPI
},
model: ActorModel, // Default scope includes avatar and server
required: true,
where: whereActor
}
]
},
{
model: VideoModel.unscoped(),
required: true,
where: whereVideo
}
]
}
return VideoCommentModel
.findAndCountAll(query)

View file

@ -154,18 +154,6 @@ describe('Test users API validators', function () {
await checkBadSortPagination(server.url, path, server.accessToken)
})
it('Should fail with a bad blocked/banned user filter', async function () {
await makeGetRequest({
url: server.url,
path,
query: {
blocked: 42
},
token: server.accessToken,
statusCodeExpected: 400
})
})
it('Should fail with a non authenticated user', async function () {
await makeGetRequest({
url: server.url,

View file

@ -296,6 +296,54 @@ describe('Test video comments API validator', function () {
it('Should return conflict on comment thread add')
})
describe('When listing admin comments threads', function () {
const path = '/api/v1/videos/comments'
it('Should fail with a bad start pagination', async function () {
await checkBadStartPagination(server.url, path, server.accessToken)
})
it('Should fail with a bad count pagination', async function () {
await checkBadCountPagination(server.url, path, server.accessToken)
})
it('Should fail with an incorrect sort', async function () {
await checkBadSortPagination(server.url, path, server.accessToken)
})
it('Should fail with a non authenticated user', async function () {
await makeGetRequest({
url: server.url,
path,
statusCodeExpected: 401
})
})
it('Should fail with a non admin user', async function () {
await makeGetRequest({
url: server.url,
path,
token: userAccessToken,
statusCodeExpected: 403
})
})
it('Should succeed with the correct params', async function () {
await makeGetRequest({
url: server.url,
path,
token: server.accessToken,
query: {
isLocal: false,
search: 'toto',
searchAccount: 'toto',
searchVideo: 'toto'
},
statusCodeExpected: 200
})
})
})
after(async function () {
await cleanupTests([ server ])
})

View file

@ -158,7 +158,7 @@ describe('Test multiple servers', function () {
})
it('Should upload the video on server 2 and propagate on each server', async function () {
this.timeout(50000)
this.timeout(100000)
const user = {
username: 'user1',

View file

@ -2,7 +2,7 @@
import * as chai from 'chai'
import 'mocha'
import { VideoComment, VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
import { VideoComment, VideoCommentAdmin, VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
import { cleanupTests, testImage } from '../../../../shared/extra-utils'
import {
createUser,
@ -18,9 +18,11 @@ import {
addVideoCommentReply,
addVideoCommentThread,
deleteVideoComment,
getAdminVideoComments,
getVideoCommentThreads,
getVideoThreadComments
} from '../../../../shared/extra-utils/videos/video-comments'
import { isLocalLiveVideoAccepted } from '@server/lib/moderation'
const expect = chai.expect
@ -59,186 +61,248 @@ describe('Test video comments', function () {
userAccessTokenServer1 = await getAccessToken(server.url, 'user1', 'password')
})
it('Should not have threads on this video', async function () {
const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
describe('User comments', function () {
expect(res.body.total).to.equal(0)
expect(res.body.data).to.be.an('array')
expect(res.body.data).to.have.lengthOf(0)
it('Should not have threads on this video', async function () {
const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
expect(res.body.total).to.equal(0)
expect(res.body.data).to.be.an('array')
expect(res.body.data).to.have.lengthOf(0)
})
it('Should create a thread in this video', async function () {
const text = 'my super first comment'
const res = await addVideoCommentThread(server.url, server.accessToken, videoUUID, text)
const comment = res.body.comment
expect(comment.inReplyToCommentId).to.be.null
expect(comment.text).equal('my super first comment')
expect(comment.videoId).to.equal(videoId)
expect(comment.id).to.equal(comment.threadId)
expect(comment.account.name).to.equal('root')
expect(comment.account.host).to.equal('localhost:' + server.port)
expect(comment.account.url).to.equal('http://localhost:' + server.port + '/accounts/root')
expect(comment.totalReplies).to.equal(0)
expect(comment.totalRepliesFromVideoAuthor).to.equal(0)
expect(dateIsValid(comment.createdAt as string)).to.be.true
expect(dateIsValid(comment.updatedAt as string)).to.be.true
})
it('Should list threads of this video', async function () {
const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
expect(res.body.total).to.equal(1)
expect(res.body.data).to.be.an('array')
expect(res.body.data).to.have.lengthOf(1)
const comment: VideoComment = res.body.data[0]
expect(comment.inReplyToCommentId).to.be.null
expect(comment.text).equal('my super first comment')
expect(comment.videoId).to.equal(videoId)
expect(comment.id).to.equal(comment.threadId)
expect(comment.account.name).to.equal('root')
expect(comment.account.host).to.equal('localhost:' + server.port)
await testImage(server.url, 'avatar-resized', comment.account.avatar.path, '.png')
expect(comment.totalReplies).to.equal(0)
expect(comment.totalRepliesFromVideoAuthor).to.equal(0)
expect(dateIsValid(comment.createdAt as string)).to.be.true
expect(dateIsValid(comment.updatedAt as string)).to.be.true
threadId = comment.threadId
})
it('Should get all the thread created', async function () {
const res = await getVideoThreadComments(server.url, videoUUID, threadId)
const rootComment = res.body.comment
expect(rootComment.inReplyToCommentId).to.be.null
expect(rootComment.text).equal('my super first comment')
expect(rootComment.videoId).to.equal(videoId)
expect(dateIsValid(rootComment.createdAt as string)).to.be.true
expect(dateIsValid(rootComment.updatedAt as string)).to.be.true
})
it('Should create multiple replies in this thread', async function () {
const text1 = 'my super answer to thread 1'
const childCommentRes = await addVideoCommentReply(server.url, server.accessToken, videoId, threadId, text1)
const childCommentId = childCommentRes.body.comment.id
const text2 = 'my super answer to answer of thread 1'
await addVideoCommentReply(server.url, server.accessToken, videoId, childCommentId, text2)
const text3 = 'my second answer to thread 1'
await addVideoCommentReply(server.url, server.accessToken, videoId, threadId, text3)
})
it('Should get correctly the replies', async function () {
const res = await getVideoThreadComments(server.url, videoUUID, threadId)
const tree: VideoCommentThreadTree = res.body
expect(tree.comment.text).equal('my super first comment')
expect(tree.children).to.have.lengthOf(2)
const firstChild = tree.children[0]
expect(firstChild.comment.text).to.equal('my super answer to thread 1')
expect(firstChild.children).to.have.lengthOf(1)
const childOfFirstChild = firstChild.children[0]
expect(childOfFirstChild.comment.text).to.equal('my super answer to answer of thread 1')
expect(childOfFirstChild.children).to.have.lengthOf(0)
const secondChild = tree.children[1]
expect(secondChild.comment.text).to.equal('my second answer to thread 1')
expect(secondChild.children).to.have.lengthOf(0)
replyToDeleteId = secondChild.comment.id
})
it('Should create other threads', async function () {
const text1 = 'super thread 2'
await addVideoCommentThread(server.url, server.accessToken, videoUUID, text1)
const text2 = 'super thread 3'
await addVideoCommentThread(server.url, server.accessToken, videoUUID, text2)
})
it('Should list the threads', async function () {
const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5, 'createdAt')
expect(res.body.total).to.equal(3)
expect(res.body.data).to.be.an('array')
expect(res.body.data).to.have.lengthOf(3)
expect(res.body.data[0].text).to.equal('my super first comment')
expect(res.body.data[0].totalReplies).to.equal(3)
expect(res.body.data[1].text).to.equal('super thread 2')
expect(res.body.data[1].totalReplies).to.equal(0)
expect(res.body.data[2].text).to.equal('super thread 3')
expect(res.body.data[2].totalReplies).to.equal(0)
})
it('Should delete a reply', async function () {
await deleteVideoComment(server.url, server.accessToken, videoId, replyToDeleteId)
const res = await getVideoThreadComments(server.url, videoUUID, threadId)
const tree: VideoCommentThreadTree = res.body
expect(tree.comment.text).equal('my super first comment')
expect(tree.children).to.have.lengthOf(2)
const firstChild = tree.children[0]
expect(firstChild.comment.text).to.equal('my super answer to thread 1')
expect(firstChild.children).to.have.lengthOf(1)
const childOfFirstChild = firstChild.children[0]
expect(childOfFirstChild.comment.text).to.equal('my super answer to answer of thread 1')
expect(childOfFirstChild.children).to.have.lengthOf(0)
const deletedChildOfFirstChild = tree.children[1]
expect(deletedChildOfFirstChild.comment.text).to.equal('')
expect(deletedChildOfFirstChild.comment.isDeleted).to.be.true
expect(deletedChildOfFirstChild.comment.deletedAt).to.not.be.null
expect(deletedChildOfFirstChild.comment.account).to.be.null
expect(deletedChildOfFirstChild.children).to.have.lengthOf(0)
})
it('Should delete a complete thread', async function () {
await deleteVideoComment(server.url, server.accessToken, videoId, threadId)
const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5, 'createdAt')
expect(res.body.total).to.equal(3)
expect(res.body.data).to.be.an('array')
expect(res.body.data).to.have.lengthOf(3)
expect(res.body.data[0].text).to.equal('')
expect(res.body.data[0].isDeleted).to.be.true
expect(res.body.data[0].deletedAt).to.not.be.null
expect(res.body.data[0].account).to.be.null
expect(res.body.data[0].totalReplies).to.equal(3)
expect(res.body.data[1].text).to.equal('super thread 2')
expect(res.body.data[1].totalReplies).to.equal(0)
expect(res.body.data[2].text).to.equal('super thread 3')
expect(res.body.data[2].totalReplies).to.equal(0)
})
it('Should count replies from the video author correctly', async function () {
const text = 'my super first comment'
await addVideoCommentThread(server.url, server.accessToken, videoUUID, text)
let res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
const comment: VideoComment = res.body.data[0]
const threadId2 = comment.threadId
const text2 = 'a first answer to thread 4 by a third party'
await addVideoCommentReply(server.url, userAccessTokenServer1, videoId, threadId2, text2)
const text3 = 'my second answer to thread 4'
await addVideoCommentReply(server.url, server.accessToken, videoId, threadId2, text3)
res = await getVideoThreadComments(server.url, videoUUID, threadId2)
const tree: VideoCommentThreadTree = res.body
expect(tree.comment.totalReplies).to.equal(tree.comment.totalRepliesFromVideoAuthor + 1)
})
})
it('Should create a thread in this video', async function () {
const text = 'my super first comment'
describe('All instance comments', function () {
async function getComments (options: any = {}) {
const res = await getAdminVideoComments(Object.assign({
url: server.url,
token: server.accessToken,
start: 0,
count: 10
}, options))
const res = await addVideoCommentThread(server.url, server.accessToken, videoUUID, text)
const comment = res.body.comment
return { comments: res.body.data as VideoCommentAdmin[], total: res.body.total as number }
}
expect(comment.inReplyToCommentId).to.be.null
expect(comment.text).equal('my super first comment')
expect(comment.videoId).to.equal(videoId)
expect(comment.id).to.equal(comment.threadId)
expect(comment.account.name).to.equal('root')
expect(comment.account.host).to.equal('localhost:' + server.port)
expect(comment.account.url).to.equal('http://localhost:' + server.port + '/accounts/root')
expect(comment.totalReplies).to.equal(0)
expect(comment.totalRepliesFromVideoAuthor).to.equal(0)
expect(dateIsValid(comment.createdAt as string)).to.be.true
expect(dateIsValid(comment.updatedAt as string)).to.be.true
})
it('Should list instance comments as admin', async function () {
const { comments } = await getComments({ start: 0, count: 1 })
it('Should list threads of this video', async function () {
const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
expect(comments[0].text).to.equal('my second answer to thread 4')
})
expect(res.body.total).to.equal(1)
expect(res.body.data).to.be.an('array')
expect(res.body.data).to.have.lengthOf(1)
it('Should filter instance comments by isLocal', async function () {
const { total, comments } = await getComments({ isLocal: false })
const comment: VideoComment = res.body.data[0]
expect(comment.inReplyToCommentId).to.be.null
expect(comment.text).equal('my super first comment')
expect(comment.videoId).to.equal(videoId)
expect(comment.id).to.equal(comment.threadId)
expect(comment.account.name).to.equal('root')
expect(comment.account.host).to.equal('localhost:' + server.port)
expect(comments).to.have.lengthOf(0)
expect(total).to.equal(0)
})
await testImage(server.url, 'avatar-resized', comment.account.avatar.path, '.png')
it('Should search instance comments by account', async function () {
const { total, comments } = await getComments({ searchAccount: 'user' })
expect(comment.totalReplies).to.equal(0)
expect(comment.totalRepliesFromVideoAuthor).to.equal(0)
expect(dateIsValid(comment.createdAt as string)).to.be.true
expect(dateIsValid(comment.updatedAt as string)).to.be.true
expect(comments).to.have.lengthOf(1)
expect(total).to.equal(1)
threadId = comment.threadId
})
expect(comments[0].text).to.equal('a first answer to thread 4 by a third party')
})
it('Should get all the thread created', async function () {
const res = await getVideoThreadComments(server.url, videoUUID, threadId)
it('Should search instance comments by video', async function () {
{
const { total, comments } = await getComments({ searchVideo: 'video' })
const rootComment = res.body.comment
expect(rootComment.inReplyToCommentId).to.be.null
expect(rootComment.text).equal('my super first comment')
expect(rootComment.videoId).to.equal(videoId)
expect(dateIsValid(rootComment.createdAt as string)).to.be.true
expect(dateIsValid(rootComment.updatedAt as string)).to.be.true
})
expect(comments).to.have.lengthOf(7)
expect(total).to.equal(7)
}
it('Should create multiple replies in this thread', async function () {
const text1 = 'my super answer to thread 1'
const childCommentRes = await addVideoCommentReply(server.url, server.accessToken, videoId, threadId, text1)
const childCommentId = childCommentRes.body.comment.id
{
const { total, comments } = await getComments({ searchVideo: 'hello' })
const text2 = 'my super answer to answer of thread 1'
await addVideoCommentReply(server.url, server.accessToken, videoId, childCommentId, text2)
expect(comments).to.have.lengthOf(0)
expect(total).to.equal(0)
}
})
const text3 = 'my second answer to thread 1'
await addVideoCommentReply(server.url, server.accessToken, videoId, threadId, text3)
})
it('Should search instance comments', async function () {
const { total, comments } = await getComments({ search: 'super thread 3' })
it('Should get correctly the replies', async function () {
const res = await getVideoThreadComments(server.url, videoUUID, threadId)
const tree: VideoCommentThreadTree = res.body
expect(tree.comment.text).equal('my super first comment')
expect(tree.children).to.have.lengthOf(2)
const firstChild = tree.children[0]
expect(firstChild.comment.text).to.equal('my super answer to thread 1')
expect(firstChild.children).to.have.lengthOf(1)
const childOfFirstChild = firstChild.children[0]
expect(childOfFirstChild.comment.text).to.equal('my super answer to answer of thread 1')
expect(childOfFirstChild.children).to.have.lengthOf(0)
const secondChild = tree.children[1]
expect(secondChild.comment.text).to.equal('my second answer to thread 1')
expect(secondChild.children).to.have.lengthOf(0)
replyToDeleteId = secondChild.comment.id
})
it('Should create other threads', async function () {
const text1 = 'super thread 2'
await addVideoCommentThread(server.url, server.accessToken, videoUUID, text1)
const text2 = 'super thread 3'
await addVideoCommentThread(server.url, server.accessToken, videoUUID, text2)
})
it('Should list the threads', async function () {
const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5, 'createdAt')
expect(res.body.total).to.equal(3)
expect(res.body.data).to.be.an('array')
expect(res.body.data).to.have.lengthOf(3)
expect(res.body.data[0].text).to.equal('my super first comment')
expect(res.body.data[0].totalReplies).to.equal(3)
expect(res.body.data[1].text).to.equal('super thread 2')
expect(res.body.data[1].totalReplies).to.equal(0)
expect(res.body.data[2].text).to.equal('super thread 3')
expect(res.body.data[2].totalReplies).to.equal(0)
})
it('Should delete a reply', async function () {
await deleteVideoComment(server.url, server.accessToken, videoId, replyToDeleteId)
const res = await getVideoThreadComments(server.url, videoUUID, threadId)
const tree: VideoCommentThreadTree = res.body
expect(tree.comment.text).equal('my super first comment')
expect(tree.children).to.have.lengthOf(2)
const firstChild = tree.children[0]
expect(firstChild.comment.text).to.equal('my super answer to thread 1')
expect(firstChild.children).to.have.lengthOf(1)
const childOfFirstChild = firstChild.children[0]
expect(childOfFirstChild.comment.text).to.equal('my super answer to answer of thread 1')
expect(childOfFirstChild.children).to.have.lengthOf(0)
const deletedChildOfFirstChild = tree.children[1]
expect(deletedChildOfFirstChild.comment.text).to.equal('')
expect(deletedChildOfFirstChild.comment.isDeleted).to.be.true
expect(deletedChildOfFirstChild.comment.deletedAt).to.not.be.null
expect(deletedChildOfFirstChild.comment.account).to.be.null
expect(deletedChildOfFirstChild.children).to.have.lengthOf(0)
})
it('Should delete a complete thread', async function () {
await deleteVideoComment(server.url, server.accessToken, videoId, threadId)
const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5, 'createdAt')
expect(res.body.total).to.equal(3)
expect(res.body.data).to.be.an('array')
expect(res.body.data).to.have.lengthOf(3)
expect(res.body.data[0].text).to.equal('')
expect(res.body.data[0].isDeleted).to.be.true
expect(res.body.data[0].deletedAt).to.not.be.null
expect(res.body.data[0].account).to.be.null
expect(res.body.data[0].totalReplies).to.equal(3)
expect(res.body.data[1].text).to.equal('super thread 2')
expect(res.body.data[1].totalReplies).to.equal(0)
expect(res.body.data[2].text).to.equal('super thread 3')
expect(res.body.data[2].totalReplies).to.equal(0)
})
it('Should count replies from the video author correctly', async function () {
const text = 'my super first comment'
await addVideoCommentThread(server.url, server.accessToken, videoUUID, text)
let res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
const comment: VideoComment = res.body.data[0]
const threadId2 = comment.threadId
const text2 = 'a first answer to thread 4 by a third party'
await addVideoCommentReply(server.url, userAccessTokenServer1, videoId, threadId2, text2)
const text3 = 'my second answer to thread 4'
await addVideoCommentReply(server.url, server.accessToken, videoId, threadId2, text3)
res = await getVideoThreadComments(server.url, videoUUID, threadId2)
const tree: VideoCommentThreadTree = res.body
expect(tree.comment.totalReplies).to.equal(tree.comment.totalRepliesFromVideoAuthor + 1)
expect(comments).to.have.lengthOf(1)
expect(total).to.equal(1)
expect(comments[0].text).to.equal('super thread 3')
})
})
after(async function () {

View file

@ -1,7 +1,41 @@
/* eslint-disable @typescript-eslint/no-floating-promises */
import * as request from 'supertest'
import { makeDeleteRequest } from '../requests/requests'
import { makeDeleteRequest, makeGetRequest } from '../requests/requests'
function getAdminVideoComments (options: {
url: string
token: string
start: number
count: number
sort?: string
isLocal?: boolean
search?: string
searchAccount?: string
searchVideo?: string
}) {
const { url, token, start, count, sort, isLocal, search, searchAccount, searchVideo } = options
const path = '/api/v1/videos/comments'
const query = {
start,
count,
sort: sort || '-createdAt'
}
if (isLocal !== undefined) Object.assign(query, { isLocal })
if (search !== undefined) Object.assign(query, { search })
if (searchAccount !== undefined) Object.assign(query, { searchAccount })
if (searchVideo !== undefined) Object.assign(query, { searchVideo })
return makeGetRequest({
url,
path,
token,
query,
statusCodeExpected: 200
})
}
function getVideoCommentThreads (url: string, videoId: number | string, start: number, count: number, sort?: string, token?: string) {
const path = '/api/v1/videos/' + videoId + '/comment-threads'
@ -88,6 +122,7 @@ function deleteVideoComment (
export {
getVideoCommentThreads,
getAdminVideoComments,
getVideoThreadComments,
addVideoCommentThread,
addVideoCommentReply,