client/src/app/shared/shared-main/video/video-import.service.ts

   1 import { SortMeta } from 'primeng/api'
   2 import { Observable } from 'rxjs'
   3 import { catchError, map, switchMap } from 'rxjs/operators'
   4 import { HttpClient, HttpParams } from '@angular/common/http'
   5 import { Injectable } from '@angular/core'
   6 import { RestExtractor, RestPagination, RestService, ServerService, UserService } from '@app/core'
   7 import { objectToFormData } from '@app/helpers'
   8 import { peertubeTranslate } from '@shared/core-utils/i18n'
   9 import { ResultList, VideoImport, VideoImportCreate, VideoUpdate } from '@shared/models'
  10 import { environment } from '../../../../environments/environment'
  11
  12 @Injectable()
  13 export class VideoImportService {
  14   private static BASE_VIDEO_IMPORT_URL = environment.apiUrl + '/api/v1/videos/imports/'
  15
  16   constructor (
  17     private authHttp: HttpClient,
  18     private restService: RestService,
  19     private restExtractor: RestExtractor,
  20     private serverService: ServerService
  21   ) {}
  22
  23   importVideoUrl (targetUrl: string, video: VideoUpdate): Observable<VideoImport> {
  24     const url = VideoImportService.BASE_VIDEO_IMPORT_URL
  25
  26     const body = this.buildImportVideoObject(video)
  27     body.targetUrl = targetUrl
  28
  29     const data = objectToFormData(body)
  30     return this.authHttp.post<VideoImport>(url, data)
  31                .pipe(catchError(res => this.restExtractor.handleError(res)))
  32   }
  33
  34   importVideoTorrent (target: string | Blob, video: VideoUpdate): Observable<VideoImport> {
  35     const url = VideoImportService.BASE_VIDEO_IMPORT_URL
  36     const body: VideoImportCreate = this.buildImportVideoObject(video)
  37
  38     if (typeof target === 'string') body.magnetUri = target
  39     else body.torrentfile = target
  40
  41     const data = objectToFormData(body)
  42     return this.authHttp.post<VideoImport>(url, data)
  43                .pipe(catchError(res => this.restExtractor.handleError(res)))
  44   }
  45
  46   getMyVideoImports (pagination: RestPagination, sort: SortMeta, search?: string): Observable<ResultList<VideoImport>> {
  47     let params = new HttpParams()
  48     params = this.restService.addRestGetParams(params, pagination, sort)
  49
  50     if (search) {
  51       const filters = this.restService.parseQueryStringFilter(search, {
  52         videoChannelSyncId: {
  53           prefix: 'videoChannelSyncId:'
  54         },
  55         targetUrl: {
  56           prefix: 'targetUrl:'
  57         }
  58       })
  59
  60       params = this.restService.addObjectParams(params, filters)
  61     }
  62
  63     return this.authHttp
  64                .get<ResultList<VideoImport>>(UserService.BASE_USERS_URL + '/me/videos/imports', { params })
  65                .pipe(
  66                  switchMap(res => this.extractVideoImports(res)),
  67                  map(res => this.restExtractor.convertResultListDateToHuman(res)),
  68                  catchError(err => this.restExtractor.handleError(err))
  69                )
  70   }
  71
  72   deleteVideoImport (videoImport: VideoImport) {
  73     return this.authHttp.delete(VideoImportService.BASE_VIDEO_IMPORT_URL + videoImport.id)
  74                         .pipe(catchError(err => this.restExtractor.handleError(err)))
  75   }
  76
  77   cancelVideoImport (videoImport: VideoImport) {
  78     return this.authHttp.post(VideoImportService.BASE_VIDEO_IMPORT_URL + videoImport.id + '/cancel', {})
  79                         .pipe(catchError(err => this.restExtractor.handleError(err)))
  80   }
  81
  82   private buildImportVideoObject (video: VideoUpdate): VideoImportCreate {
  83     const language = video.language || null
  84     const licence = video.licence || null
  85     const category = video.category || null
  86     const description = video.description || null
  87     const support = video.support || null
  88     const scheduleUpdate = video.scheduleUpdate || null
  89     const originallyPublishedAt = video.originallyPublishedAt || null
  90
  91     return {
  92       name: video.name,
  93       category,
  94       licence,
  95       language,
  96       support,
  97       description,
  98       channelId: video.channelId,
  99       privacy: video.privacy,
 100       tags: video.tags,
 101       nsfw: video.nsfw,
 102       waitTranscoding: video.waitTranscoding,
 103       commentsEnabled: video.commentsEnabled,
 104       downloadEnabled: video.downloadEnabled,
 105       thumbnailfile: video.thumbnailfile,
 106       previewfile: video.previewfile,
 107       scheduleUpdate,
 108       originallyPublishedAt
 109     }
 110   }
 111
 112   private extractVideoImports (result: ResultList<VideoImport>): Observable<ResultList<VideoImport>> {
 113     return this.serverService.getServerLocale()
 114                .pipe(
 115                  map(translations => {
 116                    result.data.forEach(d =>
 117                      d.state.label = peertubeTranslate(d.state.label, translations)
 118                    )
 119
 120                    return result
 121                  })
 122                )
 123   }
 124 }