client/src/app/shared/shared-video-comment/video-comment.service.ts

   1 import { SortMeta } from 'primeng/api'
   2 import { from, Observable } from 'rxjs'
   3 import { catchError, concatMap, map, toArray } from 'rxjs/operators'
   4 import { HttpClient, HttpParams } from '@angular/common/http'
   5 import { Injectable } from '@angular/core'
   6 import { ComponentPaginationLight, RestExtractor, RestPagination, RestService } from '@app/core'
   7 import { objectLineFeedToHtml } from '@app/helpers'
   8 import {
   9   FeedFormat,
  10   ResultList,
  11   VideoComment as VideoCommentServerModel,
  12   VideoCommentAdmin,
  13   VideoCommentCreate,
  14   VideoCommentThreadTree as VideoCommentThreadTreeServerModel
  15 } from '@shared/models'
  16 import { environment } from '../../../environments/environment'
  17 import { VideoCommentThreadTree } from './video-comment-thread-tree.model'
  18 import { VideoComment } from './video-comment.model'
  19
  20 @Injectable()
  21 export class VideoCommentService {
  22   static BASE_FEEDS_URL = environment.apiUrl + '/feeds/video-comments.'
  23
  24   private static BASE_VIDEO_URL = environment.apiUrl + '/api/v1/videos/'
  25
  26   constructor (
  27     private authHttp: HttpClient,
  28     private restExtractor: RestExtractor,
  29     private restService: RestService
  30   ) {}
  31
  32   addCommentThread (videoId: number | string, comment: VideoCommentCreate) {
  33     const url = VideoCommentService.BASE_VIDEO_URL + videoId + '/comment-threads'
  34     const normalizedComment = objectLineFeedToHtml(comment, 'text')
  35
  36     return this.authHttp.post<{ comment: VideoCommentServerModel }>(url, normalizedComment)
  37                .pipe(
  38                   map(data => this.extractVideoComment(data.comment)),
  39                   catchError(err => this.restExtractor.handleError(err))
  40                )
  41   }
  42
  43   addCommentReply (videoId: number | string, inReplyToCommentId: number, comment: VideoCommentCreate) {
  44     const url = VideoCommentService.BASE_VIDEO_URL + videoId + '/comments/' + inReplyToCommentId
  45     const normalizedComment = objectLineFeedToHtml(comment, 'text')
  46
  47     return this.authHttp.post<{ comment: VideoCommentServerModel }>(url, normalizedComment)
  48                .pipe(
  49                  map(data => this.extractVideoComment(data.comment)),
  50                  catchError(err => this.restExtractor.handleError(err))
  51                )
  52   }
  53
  54   getAdminVideoComments (options: {
  55     pagination: RestPagination,
  56     sort: SortMeta,
  57     search?: string
  58   }): Observable<ResultList<VideoCommentAdmin>> {
  59     const { pagination, sort, search } = options
  60     const url = VideoCommentService.BASE_VIDEO_URL + 'comments'
  61
  62     let params = new HttpParams()
  63     params = this.restService.addRestGetParams(params, pagination, sort)
  64
  65     if (search) {
  66       params = this.buildParamsFromSearch(search, params)
  67     }
  68
  69     return this.authHttp.get<ResultList<VideoCommentAdmin>>(url, { params })
  70       .pipe(
  71         catchError(res => this.restExtractor.handleError(res))
  72       )
  73   }
  74
  75   getVideoCommentThreads (parameters: {
  76     videoId: number | string,
  77     componentPagination: ComponentPaginationLight,
  78     sort: string
  79   }): Observable<ResultList<VideoComment>> {
  80     const { videoId, componentPagination, sort } = parameters
  81
  82     const pagination = this.restService.componentPaginationToRestPagination(componentPagination)
  83
  84     let params = new HttpParams()
  85     params = this.restService.addRestGetParams(params, pagination, sort)
  86
  87     const url = VideoCommentService.BASE_VIDEO_URL + videoId + '/comment-threads'
  88     return this.authHttp.get<ResultList<VideoComment>>(url, { params })
  89                .pipe(
  90                  map(result => this.extractVideoComments(result)),
  91                  catchError(err => this.restExtractor.handleError(err))
  92                )
  93   }
  94
  95   getVideoThreadComments (parameters: {
  96     videoId: number | string,
  97     threadId: number
  98   }): Observable<VideoCommentThreadTree> {
  99     const { videoId, threadId } = parameters
 100     const url = `${VideoCommentService.BASE_VIDEO_URL + videoId}/comment-threads/${threadId}`
 101
 102     return this.authHttp
 103                .get<VideoCommentThreadTreeServerModel>(url)
 104                .pipe(
 105                  map(tree => this.extractVideoCommentTree(tree)),
 106                  catchError(err => this.restExtractor.handleError(err))
 107                )
 108   }
 109
 110   deleteVideoComment (videoId: number | string, commentId: number) {
 111     const url = `${VideoCommentService.BASE_VIDEO_URL + videoId}/comments/${commentId}`
 112
 113     return this.authHttp
 114                .delete(url)
 115                .pipe(
 116                  map(this.restExtractor.extractDataBool),
 117                  catchError(err => this.restExtractor.handleError(err))
 118                )
 119   }
 120
 121   deleteVideoComments (comments: { videoId: number | string, commentId: number }[]) {
 122     return from(comments)
 123       .pipe(
 124         concatMap(c => this.deleteVideoComment(c.videoId, c.commentId)),
 125         toArray()
 126       )
 127   }
 128
 129   getVideoCommentsFeeds (videoUUID?: string) {
 130     const feeds = [
 131       {
 132         format: FeedFormat.RSS,
 133         label: 'rss 2.0',
 134         url: VideoCommentService.BASE_FEEDS_URL + FeedFormat.RSS.toLowerCase()
 135       },
 136       {
 137         format: FeedFormat.ATOM,
 138         label: 'atom 1.0',
 139         url: VideoCommentService.BASE_FEEDS_URL + FeedFormat.ATOM.toLowerCase()
 140       },
 141       {
 142         format: FeedFormat.JSON,
 143         label: 'json 1.0',
 144         url: VideoCommentService.BASE_FEEDS_URL + FeedFormat.JSON.toLowerCase()
 145       }
 146     ]
 147
 148     if (videoUUID !== undefined) {
 149       for (const feed of feeds) {
 150         feed.url += '?videoId=' + videoUUID
 151       }
 152     }
 153
 154     return feeds
 155   }
 156
 157   private extractVideoComment (videoComment: VideoCommentServerModel) {
 158     return new VideoComment(videoComment)
 159   }
 160
 161   private extractVideoComments (result: ResultList<VideoCommentServerModel>) {
 162     const videoCommentsJson = result.data
 163     const totalComments = result.total
 164     const comments: VideoComment[] = []
 165
 166     for (const videoCommentJson of videoCommentsJson) {
 167       comments.push(new VideoComment(videoCommentJson))
 168     }
 169
 170     return { data: comments, total: totalComments }
 171   }
 172
 173   private extractVideoCommentTree (tree: VideoCommentThreadTreeServerModel) {
 174     if (!tree) return tree as VideoCommentThreadTree
 175
 176     tree.comment = new VideoComment(tree.comment)
 177     tree.children.forEach(c => this.extractVideoCommentTree(c))
 178
 179     return tree as VideoCommentThreadTree
 180   }
 181
 182   private buildParamsFromSearch (search: string, params: HttpParams) {
 183     const filters = this.restService.parseQueryStringFilter(search, {
 184       isLocal: {
 185         prefix: 'local:',
 186         isBoolean: true,
 187         handler: v => {
 188           if (v === 'true') return v
 189           if (v === 'false') return v
 190
 191           return undefined
 192         }
 193       },
 194
 195       searchAccount: { prefix: 'account:' },
 196       searchVideo: { prefix: 'video:' }
 197     })
 198
 199     return this.restService.addObjectParams(params, filters)
 200   }
 201 }