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

   1 import { bufferTime, catchError, filter, map, observeOn, share, switchMap, tap } from 'rxjs/operators'
   2 import { Injectable, NgZone } from '@angular/core'
   3 import { asyncScheduler, merge, Observable, of, ReplaySubject, Subject } from 'rxjs'
   4 import { RestExtractor } from '../rest/rest-extractor.service'
   5 import { HttpClient, HttpParams } from '@angular/common/http'
   6 import { ResultList, VideoPlaylistElementCreate, VideoPlaylistElementUpdate } from '../../../../../shared'
   7 import { environment } from '../../../environments/environment'
   8 import { VideoPlaylist as VideoPlaylistServerModel } from '@shared/models/videos/playlist/video-playlist.model'
   9 import { VideoChannelService } from '@app/shared/video-channel/video-channel.service'
  10 import { VideoChannel } from '@app/shared/video-channel/video-channel.model'
  11 import { VideoPlaylistCreate } from '@shared/models/videos/playlist/video-playlist-create.model'
  12 import { VideoPlaylistUpdate } from '@shared/models/videos/playlist/video-playlist-update.model'
  13 import { objectToFormData } from '@app/shared/misc/utils'
  14 import { AuthUser, ServerService } from '@app/core'
  15 import { VideoPlaylist } from '@app/shared/video-playlist/video-playlist.model'
  16 import { AccountService } from '@app/shared/account/account.service'
  17 import { Account } from '@app/shared/account/account.model'
  18 import { RestService } from '@app/shared/rest'
  19 import { VideoExistInPlaylist, VideosExistInPlaylists } from '@shared/models/videos/playlist/video-exist-in-playlist.model'
  20 import { VideoPlaylistReorder } from '@shared/models/videos/playlist/video-playlist-reorder.model'
  21 import { ComponentPaginationLight } from '@app/shared/rest/component-pagination.model'
  22 import { VideoPlaylistElement as ServerVideoPlaylistElement } from '@shared/models/videos/playlist/video-playlist-element.model'
  23 import { VideoPlaylistElement } from '@app/shared/video-playlist/video-playlist-element.model'
  24 import { uniq } from 'lodash-es'
  25 import * as debug from 'debug'
  26 import { enterZone, leaveZone } from '@app/shared/rxjs/zone'
  27
  28 const logger = debug('peertube:playlists:VideoPlaylistService')
  29
  30 export type CachedPlaylist = VideoPlaylist | { id: number, displayName: string }
  31
  32 @Injectable()
  33 export class VideoPlaylistService {
  34   static BASE_VIDEO_PLAYLIST_URL = environment.apiUrl + '/api/v1/video-playlists/'
  35   static MY_VIDEO_PLAYLIST_URL = environment.apiUrl + '/api/v1/users/me/video-playlists/'
  36
  37   // Use a replay subject because we "next" a value before subscribing
  38   private videoExistsInPlaylistNotifier = new ReplaySubject<number>(1)
  39   private videoExistsInPlaylistCacheSubject = new Subject<VideosExistInPlaylists>()
  40   private readonly videoExistsInPlaylistObservable: Observable<VideosExistInPlaylists>
  41
  42   private videoExistsObservableCache: { [ id: number ]: Observable<VideoExistInPlaylist[]> } = {}
  43   private videoExistsCache: { [ id: number ]: VideoExistInPlaylist[] } = {}
  44
  45   private myAccountPlaylistCache: ResultList<CachedPlaylist> = undefined
  46   private myAccountPlaylistCacheRunning: Observable<ResultList<CachedPlaylist>>
  47   private myAccountPlaylistCacheSubject = new Subject<ResultList<CachedPlaylist>>()
  48
  49   constructor (
  50     private authHttp: HttpClient,
  51     private serverService: ServerService,
  52     private restExtractor: RestExtractor,
  53     private restService: RestService,
  54     private ngZone: NgZone
  55   ) {
  56     this.videoExistsInPlaylistObservable = merge(
  57       this.videoExistsInPlaylistNotifier.pipe(
  58         // We leave Angular zone so Protractor does not get stuck
  59         bufferTime(500, leaveZone(this.ngZone, asyncScheduler)),
  60         filter(videoIds => videoIds.length !== 0),
  61         map(videoIds => uniq(videoIds)),
  62         observeOn(enterZone(this.ngZone, asyncScheduler)),
  63         switchMap(videoIds => this.doVideosExistInPlaylist(videoIds)),
  64         share()
  65       ),
  66
  67       this.videoExistsInPlaylistCacheSubject
  68     )
  69   }
  70
  71   listChannelPlaylists (videoChannel: VideoChannel, componentPagination: ComponentPaginationLight): Observable<ResultList<VideoPlaylist>> {
  72     const url = VideoChannelService.BASE_VIDEO_CHANNEL_URL + videoChannel.nameWithHost + '/video-playlists'
  73     const pagination = this.restService.componentPaginationToRestPagination(componentPagination)
  74
  75     let params = new HttpParams()
  76     params = this.restService.addRestGetParams(params, pagination)
  77
  78     return this.authHttp.get<ResultList<VideoPlaylist>>(url, { params })
  79                .pipe(
  80                  switchMap(res => this.extractPlaylists(res)),
  81                  catchError(err => this.restExtractor.handleError(err))
  82                )
  83   }
  84
  85   listMyPlaylistWithCache (user: AuthUser, search?: string) {
  86     if (!search) {
  87       if (this.myAccountPlaylistCacheRunning) return this.myAccountPlaylistCacheRunning
  88       if (this.myAccountPlaylistCache) return of(this.myAccountPlaylistCache)
  89     }
  90
  91     const obs = this.listAccountPlaylists(user.account, undefined, '-updatedAt', search)
  92                .pipe(
  93                  tap(result => {
  94                    if (!search) {
  95                      this.myAccountPlaylistCacheRunning = undefined
  96                      this.myAccountPlaylistCache = result
  97                    }
  98                  }),
  99                  share()
 100                )
 101
 102     if (!search) this.myAccountPlaylistCacheRunning = obs
 103     return obs
 104   }
 105
 106   listAccountPlaylists (
 107     account: Account,
 108     componentPagination: ComponentPaginationLight,
 109     sort: string,
 110     search?: string
 111   ): Observable<ResultList<VideoPlaylist>> {
 112     const url = AccountService.BASE_ACCOUNT_URL + account.nameWithHost + '/video-playlists'
 113     const pagination = componentPagination
 114       ? this.restService.componentPaginationToRestPagination(componentPagination)
 115       : undefined
 116
 117     let params = new HttpParams()
 118     params = this.restService.addRestGetParams(params, pagination, sort)
 119     if (search) params = this.restService.addObjectParams(params, { search })
 120
 121     return this.authHttp.get<ResultList<VideoPlaylist>>(url, { params })
 122                .pipe(
 123                  switchMap(res => this.extractPlaylists(res)),
 124                  catchError(err => this.restExtractor.handleError(err))
 125                )
 126   }
 127
 128   getVideoPlaylist (id: string | number) {
 129     const url = VideoPlaylistService.BASE_VIDEO_PLAYLIST_URL + id
 130
 131     return this.authHttp.get<VideoPlaylist>(url)
 132                .pipe(
 133                  switchMap(res => this.extractPlaylist(res)),
 134                  catchError(err => this.restExtractor.handleError(err))
 135                )
 136   }
 137
 138   createVideoPlaylist (body: VideoPlaylistCreate) {
 139     const data = objectToFormData(body)
 140
 141     return this.authHttp.post<{ videoPlaylist: { id: number } }>(VideoPlaylistService.BASE_VIDEO_PLAYLIST_URL, data)
 142                .pipe(
 143                  tap(res => {
 144                    if (!this.myAccountPlaylistCache) return
 145
 146                    this.myAccountPlaylistCache.total++
 147
 148                    this.myAccountPlaylistCache.data.push({
 149                      id: res.videoPlaylist.id,
 150                      displayName: body.displayName
 151                    })
 152
 153                    this.myAccountPlaylistCacheSubject.next(this.myAccountPlaylistCache)
 154                  }),
 155                  catchError(err => this.restExtractor.handleError(err))
 156                )
 157   }
 158
 159   updateVideoPlaylist (videoPlaylist: VideoPlaylist, body: VideoPlaylistUpdate) {
 160     const data = objectToFormData(body)
 161
 162     return this.authHttp.put(VideoPlaylistService.BASE_VIDEO_PLAYLIST_URL + videoPlaylist.id, data)
 163                .pipe(
 164                  map(this.restExtractor.extractDataBool),
 165                  tap(() => {
 166                    if (!this.myAccountPlaylistCache) return
 167
 168                    const playlist = this.myAccountPlaylistCache.data.find(p => p.id === videoPlaylist.id)
 169                    playlist.displayName = body.displayName
 170
 171                    this.myAccountPlaylistCacheSubject.next(this.myAccountPlaylistCache)
 172                  }),
 173                  catchError(err => this.restExtractor.handleError(err))
 174                )
 175   }
 176
 177   removeVideoPlaylist (videoPlaylist: VideoPlaylist) {
 178     return this.authHttp.delete(VideoPlaylistService.BASE_VIDEO_PLAYLIST_URL + videoPlaylist.id)
 179                .pipe(
 180                  map(this.restExtractor.extractDataBool),
 181                  tap(() => {
 182                    if (!this.myAccountPlaylistCache) return
 183
 184                    this.myAccountPlaylistCache.total--
 185                    this.myAccountPlaylistCache.data = this.myAccountPlaylistCache.data
 186                                                           .filter(p => p.id !== videoPlaylist.id)
 187
 188                    this.myAccountPlaylistCacheSubject.next(this.myAccountPlaylistCache)
 189                  }),
 190                  catchError(err => this.restExtractor.handleError(err))
 191                )
 192   }
 193
 194   addVideoInPlaylist (playlistId: number, body: VideoPlaylistElementCreate) {
 195     const url = VideoPlaylistService.BASE_VIDEO_PLAYLIST_URL + playlistId + '/videos'
 196
 197     return this.authHttp.post<{ videoPlaylistElement: { id: number } }>(url, body)
 198                .pipe(
 199                  tap(res => {
 200                    const existsResult = this.videoExistsCache[body.videoId]
 201                    existsResult.push({
 202                      playlistId,
 203                      playlistElementId: res.videoPlaylistElement.id,
 204                      startTimestamp: body.startTimestamp,
 205                      stopTimestamp: body.stopTimestamp
 206                    })
 207
 208                    this.runPlaylistCheck(body.videoId)
 209                  }),
 210                  catchError(err => this.restExtractor.handleError(err))
 211                )
 212   }
 213
 214   updateVideoOfPlaylist (playlistId: number, playlistElementId: number, body: VideoPlaylistElementUpdate, videoId: number) {
 215     return this.authHttp.put(VideoPlaylistService.BASE_VIDEO_PLAYLIST_URL + playlistId + '/videos/' + playlistElementId, body)
 216                .pipe(
 217                  map(this.restExtractor.extractDataBool),
 218                  tap(() => {
 219                    const existsResult = this.videoExistsCache[videoId]
 220                    const elem = existsResult.find(e => e.playlistElementId === playlistElementId)
 221
 222                    elem.startTimestamp = body.startTimestamp
 223                    elem.stopTimestamp = body.stopTimestamp
 224
 225                    this.runPlaylistCheck(videoId)
 226                  }),
 227                  catchError(err => this.restExtractor.handleError(err))
 228                )
 229   }
 230
 231   removeVideoFromPlaylist (playlistId: number, playlistElementId: number, videoId?: number) {
 232     return this.authHttp.delete(VideoPlaylistService.BASE_VIDEO_PLAYLIST_URL + playlistId + '/videos/' + playlistElementId)
 233                .pipe(
 234                  map(this.restExtractor.extractDataBool),
 235                  tap(() => {
 236                    if (!videoId) return
 237
 238                    this.videoExistsCache[videoId] = this.videoExistsCache[videoId].filter(e => e.playlistElementId !== playlistElementId)
 239                    this.runPlaylistCheck(videoId)
 240                  }),
 241                  catchError(err => this.restExtractor.handleError(err))
 242                )
 243   }
 244
 245   reorderPlaylist (playlistId: number, oldPosition: number, newPosition: number) {
 246     const body: VideoPlaylistReorder = {
 247       startPosition: oldPosition,
 248       insertAfterPosition: newPosition
 249     }
 250
 251     return this.authHttp.post(VideoPlaylistService.BASE_VIDEO_PLAYLIST_URL + playlistId + '/videos/reorder', body)
 252                .pipe(
 253                  map(this.restExtractor.extractDataBool),
 254                  catchError(err => this.restExtractor.handleError(err))
 255                )
 256   }
 257
 258   getPlaylistVideos (
 259     videoPlaylistId: number | string,
 260     componentPagination: ComponentPaginationLight
 261   ): Observable<ResultList<VideoPlaylistElement>> {
 262     const path = VideoPlaylistService.BASE_VIDEO_PLAYLIST_URL + videoPlaylistId + '/videos'
 263     const pagination = this.restService.componentPaginationToRestPagination(componentPagination)
 264
 265     let params = new HttpParams()
 266     params = this.restService.addRestGetParams(params, pagination)
 267
 268     return this.authHttp
 269                .get<ResultList<ServerVideoPlaylistElement>>(path, { params })
 270                .pipe(
 271                  switchMap(res => this.extractVideoPlaylistElements(res)),
 272                  catchError(err => this.restExtractor.handleError(err))
 273                )
 274   }
 275
 276   listenToMyAccountPlaylistsChange () {
 277     return this.myAccountPlaylistCacheSubject.asObservable()
 278   }
 279
 280   listenToVideoPlaylistChange (videoId: number) {
 281     if (this.videoExistsObservableCache[ videoId ]) {
 282       return this.videoExistsObservableCache[ videoId ]
 283     }
 284
 285     const obs = this.videoExistsInPlaylistObservable
 286                     .pipe(
 287                       map(existsResult => existsResult[ videoId ]),
 288                       filter(r => !!r),
 289                       tap(result => this.videoExistsCache[ videoId ] = result)
 290                     )
 291
 292     this.videoExistsObservableCache[ videoId ] = obs
 293     return obs
 294   }
 295
 296   runPlaylistCheck (videoId: number) {
 297     logger('Running playlist check.')
 298
 299     if (this.videoExistsCache[videoId]) {
 300       logger('Found cache for %d.', videoId)
 301
 302       return this.videoExistsInPlaylistCacheSubject.next({ [videoId]: this.videoExistsCache[videoId] })
 303     }
 304
 305     logger('Fetching from network for %d.', videoId)
 306     return this.videoExistsInPlaylistNotifier.next(videoId)
 307   }
 308
 309   extractPlaylists (result: ResultList<VideoPlaylistServerModel>) {
 310     return this.serverService.getServerLocale()
 311                .pipe(
 312                  map(translations => {
 313                    const playlistsJSON = result.data
 314                    const total = result.total
 315                    const playlists: VideoPlaylist[] = []
 316
 317                    for (const playlistJSON of playlistsJSON) {
 318                      playlists.push(new VideoPlaylist(playlistJSON, translations))
 319                    }
 320
 321                    return { data: playlists, total }
 322                  })
 323                )
 324   }
 325
 326   extractPlaylist (playlist: VideoPlaylistServerModel) {
 327     return this.serverService.getServerLocale()
 328                .pipe(map(translations => new VideoPlaylist(playlist, translations)))
 329   }
 330
 331   extractVideoPlaylistElements (result: ResultList<ServerVideoPlaylistElement>) {
 332     return this.serverService.getServerLocale()
 333                .pipe(
 334                  map(translations => {
 335                    const elementsJson = result.data
 336                    const total = result.total
 337                    const elements: VideoPlaylistElement[] = []
 338
 339                    for (const elementJson of elementsJson) {
 340                      elements.push(new VideoPlaylistElement(elementJson, translations))
 341                    }
 342
 343                    return { total, data: elements }
 344                  })
 345                )
 346   }
 347
 348   private doVideosExistInPlaylist (videoIds: number[]): Observable<VideosExistInPlaylists> {
 349     const url = VideoPlaylistService.MY_VIDEO_PLAYLIST_URL + 'videos-exist'
 350
 351     let params = new HttpParams()
 352     params = this.restService.addObjectParams(params, { videoIds })
 353
 354     return this.authHttp.get<VideoExistInPlaylist>(url, { params, headers: { ignoreLoadingBar: '' } })
 355                .pipe(catchError(err => this.restExtractor.handleError(err)))
 356   }
 357 }