<div class="form-group">
<textarea placeholder="Add comment..." formControlName="text" [ngClass]="{ 'input-error': formErrors['text'] }" #textarea>
+
</textarea>
<div *ngIf="formErrors.text" class="form-error">
{{ formErrors.text }}
import { FormBuilder, FormGroup } from '@angular/forms'
import { NotificationsService } from 'angular2-notifications'
import { Observable } from 'rxjs/Observable'
-import { VideoCommentCreate } from '../../../../../../shared/models/videos/video-comment.model'
+import { VideoCommentCreate, VideoCommentThreadTree } from '../../../../../../shared/models/videos/video-comment.model'
import { FormReactive } from '../../../shared'
import { VIDEO_COMMENT_TEXT } from '../../../shared/forms/form-validators/video-comment'
import { User } from '../../../shared/users'
@Input() user: User
@Input() video: Video
@Input() parentComment: VideoComment
+ @Input() parentComments: VideoComment[]
@Input() focusOnInit = false
@Output() commentCreated = new EventEmitter<VideoCommentCreate>()
if (this.focusOnInit === true) {
this.textareaElement.nativeElement.focus()
}
+
+ if (this.parentComment) {
+ const mentions = this.parentComments
+ .filter(c => c.account.id !== this.user.account.id)
+ .map(c => '@' + c.account.name)
+
+ const mentionsSet = new Set(mentions)
+ const mentionsText = Array.from(mentionsSet).join(' ') + ' '
+
+ this.form.patchValue({ text: mentionsText })
+ }
}
formValidated () {
[user]="user"
[video]="video"
[parentComment]="comment"
+ [parentComments]="newParentComments"
[focusOnInit]="true"
(commentCreated)="onCommentReplyCreated($event)"
></my-video-comment-add>
[video]="video"
[inReplyToCommentId]="inReplyToCommentId"
[commentTree]="commentChild"
+ [parentComments]="newParentComments"
(wantedToReply)="onWantToReply($event)"
(wantedToDelete)="onWantToDelete($event)"
(resetReply)="onResetReply()"
export class VideoCommentComponent implements OnInit {
@Input() video: Video
@Input() comment: VideoComment
+ @Input() parentComments: VideoComment[] = []
@Input() commentTree: VideoCommentThreadTree
@Input() inReplyToCommentId: number
@Output() resetReply = new EventEmitter()
sanitizedCommentHTML = ''
+ newParentComments = []
constructor (private authService: AuthService) {}
this.sanitizedCommentHTML = sanitizeHtml(this.comment.text, {
allowedTags: [ 'p', 'span' ]
})
+
+ this.newParentComments = this.parentComments.concat([ this.comment ])
}
onCommentReplyCreated (createdComment: VideoComment) {
font-size: 15px;
cursor: pointer;
margin-left: 56px;
+ margin-bottom: 10px;
}
.glyphicon, .comment-thread-loading {
async function videoCommentController (req: express.Request, res: express.Response, next: express.NextFunction) {
const videoComment: VideoCommentModel = res.locals.videoComment
- return res.json(videoComment.toActivityPubObject())
+ const threadParentComments = await VideoCommentModel.listThreadParentComments(videoComment, undefined)
+ return res.json(videoComment.toActivityPubObject(threadParentComments))
}
import { ActorModel } from '../../../models/activitypub/actor'
import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
import { VideoModel } from '../../../models/video/video'
+import { VideoCommentModel } from '../../../models/video/video-comment'
import { VideoShareModel } from '../../../models/video/video-share'
import { activitypubHttpJobScheduler, ActivityPubHttpPayload } from '../../jobs/activitypub-http-job-scheduler'
}
}
+function getOriginVideoCommentAudience (
+ videoComment: VideoCommentModel,
+ threadParentComments: VideoCommentModel[],
+ actorsInvolvedInVideo: ActorModel[],
+ isOrigin = false
+) {
+ const to = [ ACTIVITY_PUB.PUBLIC ]
+ const cc = [ ]
+
+ // Owner of the video we comment
+ if (isOrigin === false) {
+ cc.push(videoComment.Video.VideoChannel.Account.Actor.url)
+ }
+
+ // Followers of the poster
+ cc.push(videoComment.Account.Actor.followersUrl)
+
+ // Send to actors we reply to
+ for (const parentComment of threadParentComments) {
+ cc.push(parentComment.Account.Actor.url)
+ }
+
+ return {
+ to,
+ cc: cc.concat(actorsInvolvedInVideo.map(a => a.followersUrl))
+ }
+}
+
function getObjectFollowersAudience (actorsInvolvedInObject: ActorModel[]) {
return {
to: actorsInvolvedInObject.map(a => a.followersUrl),
}
async function getActorsInvolvedInVideo (video: VideoModel, t: Transaction) {
- const actorsToForwardView = await VideoShareModel.loadActorsByShare(video.id, t)
- actorsToForwardView.push(video.VideoChannel.Account.Actor)
+ const actors = await VideoShareModel.loadActorsByShare(video.id, t)
+ actors.push(video.VideoChannel.Account.Actor)
- return actorsToForwardView
+ return actors
}
async function getAudience (actorSender: ActorModel, t: Transaction, isPublic = true) {
getActorsInvolvedInVideo,
getObjectFollowersAudience,
forwardActivity,
- audiencify
+ audiencify,
+ getOriginVideoCommentAudience
}
import { VideoCommentModel } from '../../../models/video/video-comment'
import { getVideoAbuseActivityPubUrl, getVideoDislikeActivityPubUrl, getVideoViewActivityPubUrl } from '../url'
import {
- audiencify, broadcastToFollowers, getActorsInvolvedInVideo, getAudience, getObjectFollowersAudience, getOriginVideoAudience,
+ audiencify, broadcastToFollowers, getActorsInvolvedInVideo, getAudience, getObjectFollowersAudience,
+ getOriginVideoAudience, getOriginVideoCommentAudience,
unicastTo
} from './misc'
async function sendCreateVideoCommentToOrigin (comment: VideoCommentModel, t: Transaction) {
const byActor = comment.Account.Actor
+ const threadParentComments = await VideoCommentModel.listThreadParentComments(comment, t)
+ const commentObject = comment.toActivityPubObject(threadParentComments)
const actorsInvolvedInVideo = await getActorsInvolvedInVideo(comment.Video, t)
- const audience = getOriginVideoAudience(comment.Video, actorsInvolvedInVideo)
+ const audience = getOriginVideoCommentAudience(comment, threadParentComments, actorsInvolvedInVideo)
- const commentObject = comment.toActivityPubObject()
const data = await createActivityData(comment.url, byActor, commentObject, t, audience)
return unicastTo(data, byActor, comment.Video.VideoChannel.Account.Actor.sharedInboxUrl, t)
async function sendCreateVideoCommentToVideoFollowers (comment: VideoCommentModel, t: Transaction) {
const byActor = comment.Account.Actor
+ const threadParentComments = await VideoCommentModel.listThreadParentComments(comment, t)
+ const commentObject = comment.toActivityPubObject(threadParentComments)
- const actorsToForwardView = await getActorsInvolvedInVideo(comment.Video, t)
- const audience = getObjectFollowersAudience(actorsToForwardView)
-
- const commentObject = comment.toActivityPubObject()
+ const actorsInvolvedInVideo = await getActorsInvolvedInVideo(comment.Video, t)
+ const audience = getOriginVideoCommentAudience(comment, threadParentComments, actorsInvolvedInVideo)
const data = await createActivityData(comment.url, byActor, commentObject, t, audience)
const followersException = [ byActor ]
- return broadcastToFollowers(data, byActor, actorsToForwardView, t, followersException)
+ return broadcastToFollowers(data, byActor, actorsInvolvedInVideo, t, followersException)
}
async function sendCreateViewToOrigin (byActor: ActorModel, video: VideoModel, t: Transaction) {
AfterDestroy, AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, IFindOptions, 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'
})
}
+ static listThreadParentComments (comment: VideoCommentModel, t: Sequelize.Transaction) {
+ const query = {
+ order: [ [ 'createdAt', 'ASC' ] ],
+ where: {
+ [ Sequelize.Op.or ]: [
+ { id: comment.getThreadId() },
+ { originCommentId: comment.getThreadId() }
+ ],
+ id: {
+ [ Sequelize.Op.ne ]: comment.id
+ }
+ },
+ transaction: t
+ }
+
+ return VideoCommentModel
+ .scope([ ScopeNames.WITH_ACCOUNT ])
+ .findAll(query)
+ }
+
+ getThreadId (): number {
+ return this.originCommentId || this.id
+ }
+
isOwned () {
return this.Account.isOwned()
}
} as VideoComment
}
- toActivityPubObject (): VideoCommentObject {
+ toActivityPubObject (threadParentComments: VideoCommentModel[]): VideoCommentObject {
let inReplyTo: string
// New thread, so in AS we reply to the video
if (this.inReplyToCommentId === null) {
inReplyTo = this.InReplyToVideoComment.url
}
+ const tag: ActivityTagObject[] = []
+ for (const parentComment of threadParentComments) {
+ const actor = parentComment.Account.Actor
+
+ tag.push({
+ type: 'Mention',
+ href: actor.url,
+ name: `@${actor.preferredUsername}@${actor.getHost()}`
+ })
+ }
+
return {
type: 'Note' as 'Note',
id: this.url,
updated: this.updatedAt.toISOString(),
published: this.createdAt.toISOString(),
url: this.url,
- attributedTo: this.Account.Actor.url
+ attributedTo: this.Account.Actor.url,
+ tag
}
}
}
}
export interface ActivityTagObject {
- type: 'Hashtag'
+ type: 'Hashtag' | 'Mention'
+ href?: string
name: string
}
+import { ActivityTagObject } from './common-objects'
+
export interface VideoCommentObject {
type: 'Note'
id: string
updated: string
url: string
attributedTo: string
+ tag: ActivityTagObject[]
}