Add server localization

[github/Chocobozzz/PeerTube.git] / client / src / app / shared / video / video.service.ts

diff --git a/client/src/app/shared/video/video.service.ts b/client/src/app/shared/video/video.service.ts
index 8870cbee48b50e11606755cb88ada82b8c0ebf6a..c607b7d6a70ae0d69fb0d38a81718a2351da22d8 100644 (file)
--- a/client/src/app/shared/video/video.service.ts
+++ b/client/src/app/shared/video/video.service.ts
@@ -1,8 +1,7 @@
+import { catchError, map, switchMap } from 'rxjs/operators'
 import { HttpClient, HttpParams, HttpRequest } from '@angular/common/http'
 import { Injectable } from '@angular/core'
-import 'rxjs/add/operator/catch'
-import 'rxjs/add/operator/map'
-import { Observable } from 'rxjs/Observable'
+import { Observable } from 'rxjs'
 import { Video as VideoServerModel, VideoDetails as VideoDetailsServerModel } from '../../../../../shared'
 import { ResultList } from '../../../../../shared/models/result-list.model'
 import { UserVideoRateUpdate } from '../../../../../shared/models/videos/user-video-rate-update.model'
@@ -25,6 +24,7 @@ import { Account } from '@app/shared/account/account.model'
 import { AccountService } from '@app/shared/account/account.service'
 import { VideoChannel } from '../../../../../shared/models/videos'
 import { VideoChannelService } from '@app/shared/video-channel/video-channel.service'
+import { ServerService } from '@app/core'
 
 @Injectable()
 export class VideoService {
@@ -34,7 +34,8 @@ export class VideoService {
   constructor (
     private authHttp: HttpClient,
     private restExtractor: RestExtractor,
-    private restService: RestService
+    private restService: RestService,
+    private serverService: ServerService
   ) {}
 
   getVideoViewUrl (uuid: string) {
@@ -42,23 +43,31 @@ export class VideoService {
   }
 
   getVideo (uuid: string): Observable<VideoDetails> {
-    return this.authHttp.get<VideoDetailsServerModel>(VideoService.BASE_VIDEO_URL + uuid)
-                        .map(videoHash => new VideoDetails(videoHash))
-                        .catch((res) => this.restExtractor.handleError(res))
+    return this.serverService.localeObservable
+               .pipe(
+                 switchMap(translations => {
+                  return this.authHttp.get<VideoDetailsServerModel>(VideoService.BASE_VIDEO_URL + uuid)
+                     .pipe(map(videoHash => ({ videoHash, translations })))
+                 }),
+                 map(({ videoHash, translations }) => new VideoDetails(videoHash, translations)),
+                 catchError(res => this.restExtractor.handleError(res))
+               )
   }
 
-  viewVideo (uuid: string): Observable<VideoDetails> {
+  viewVideo (uuid: string): Observable<boolean> {
     return this.authHttp.post(this.getVideoViewUrl(uuid), {})
-      .map(this.restExtractor.extractDataBool)
-      .catch(this.restExtractor.handleError)
+               .pipe(
+                 map(this.restExtractor.extractDataBool),
+                 catchError(this.restExtractor.handleError)
+               )
   }
 
   updateVideo (video: VideoEdit) {
-    const language = video.language || undefined
-    const licence = video.licence || undefined
-    const category = video.category || undefined
-    const description = video.description || undefined
-    const support = video.support || undefined
+    const language = video.language || null
+    const licence = video.licence || null
+    const category = video.category || null
+    const description = video.description || null
+    const support = video.support || null
 
     const body: VideoUpdate = {
       name: video.name,
@@ -67,6 +76,7 @@ export class VideoService {
       language,
       support,
       description,
+      channelId: video.channelId,
       privacy: video.privacy,
       tags: video.tags,
       nsfw: video.nsfw,
@@ -78,16 +88,18 @@ export class VideoService {
     const data = objectToFormData(body)
 
     return this.authHttp.put(VideoService.BASE_VIDEO_URL + video.id, data)
-                        .map(this.restExtractor.extractDataBool)
-                        .catch(this.restExtractor.handleError)
+               .pipe(
+                 map(this.restExtractor.extractDataBool),
+                 catchError(this.restExtractor.handleError)
+               )
   }
 
   uploadVideo (video: FormData) {
     const req = new HttpRequest('POST', VideoService.BASE_VIDEO_URL + 'upload', video, { reportProgress: true })
 
     return this.authHttp
-      .request(req)
-      .catch(this.restExtractor.handleError)
+               .request<{ video: { id: number, uuid: string} }>(req)
+               .pipe(catchError(this.restExtractor.handleError))
   }
 
   getMyVideos (videoPagination: ComponentPagination, sort: VideoSortField): Observable<{ videos: Video[], totalVideos: number}> {
@@ -96,9 +108,12 @@ export class VideoService {
     let params = new HttpParams()
     params = this.restService.addRestGetParams(params, pagination, sort)
 
-    return this.authHttp.get(UserService.BASE_USERS_URL + '/me/videos', { params })
-      .map(this.extractVideos)
-      .catch((res) => this.restExtractor.handleError(res))
+    return this.authHttp
+               .get<ResultList<Video>>(UserService.BASE_USERS_URL + '/me/videos', { params })
+               .pipe(
+                 switchMap(res => this.extractVideos(res)),
+                 catchError(res => this.restExtractor.handleError(res))
+               )
   }
 
   getAccountVideos (
@@ -112,9 +127,11 @@ export class VideoService {
     params = this.restService.addRestGetParams(params, pagination, sort)
 
     return this.authHttp
-               .get(AccountService.BASE_ACCOUNT_URL + account.id + '/videos', { params })
-               .map(this.extractVideos)
-               .catch((res) => this.restExtractor.handleError(res))
+               .get<ResultList<Video>>(AccountService.BASE_ACCOUNT_URL + account.nameWithHost + '/videos', { params })
+               .pipe(
+                 switchMap(res => this.extractVideos(res)),
+                 catchError(res => this.restExtractor.handleError(res))
+               )
   }
 
   getVideoChannelVideos (
@@ -128,9 +145,11 @@ export class VideoService {
     params = this.restService.addRestGetParams(params, pagination, sort)
 
     return this.authHttp
-               .get(VideoChannelService.BASE_VIDEO_CHANNEL_URL + videoChannel.uuid + '/videos', { params })
-               .map(this.extractVideos)
-               .catch((res) => this.restExtractor.handleError(res))
+               .get<ResultList<Video>>(VideoChannelService.BASE_VIDEO_CHANNEL_URL + videoChannel.uuid + '/videos', { params })
+               .pipe(
+                 switchMap(res => this.extractVideos(res)),
+                 catchError(res => this.restExtractor.handleError(res))
+               )
   }
 
   getVideos (
@@ -148,9 +167,11 @@ export class VideoService {
     }
 
     return this.authHttp
-      .get(VideoService.BASE_VIDEO_URL, { params })
-      .map(this.extractVideos)
-      .catch((res) => this.restExtractor.handleError(res))
+               .get<ResultList<Video>>(VideoService.BASE_VIDEO_URL, { params })
+               .pipe(
+                 switchMap(res => this.extractVideos(res)),
+                 catchError(res => this.restExtractor.handleError(res))
+               )
   }
 
   buildBaseFeedUrls (params: HttpParams) {
@@ -214,23 +235,29 @@ export class VideoService {
     params = params.append('search', search)
 
     return this.authHttp
-      .get<ResultList<VideoServerModel>>(url, { params })
-      .map(this.extractVideos)
-      .catch((res) => this.restExtractor.handleError(res))
+               .get<ResultList<VideoServerModel>>(url, { params })
+               .pipe(
+                 switchMap(res => this.extractVideos(res)),
+                 catchError(res => this.restExtractor.handleError(res))
+               )
   }
 
   removeVideo (id: number) {
     return this.authHttp
-      .delete(VideoService.BASE_VIDEO_URL + id)
-      .map(this.restExtractor.extractDataBool)
-      .catch((res) => this.restExtractor.handleError(res))
+               .delete(VideoService.BASE_VIDEO_URL + id)
+               .pipe(
+                 map(this.restExtractor.extractDataBool),
+                 catchError(res => this.restExtractor.handleError(res))
+               )
   }
 
   loadCompleteDescription (descriptionPath: string) {
     return this.authHttp
-      .get(environment.apiUrl + descriptionPath)
-      .map(res => res['description'])
-      .catch((res) => this.restExtractor.handleError(res))
+               .get(environment.apiUrl + descriptionPath)
+               .pipe(
+                 map(res => res[ 'description' ]),
+                 catchError(res => this.restExtractor.handleError(res))
+               )
   }
 
   setVideoLike (id: number) {
@@ -245,12 +272,11 @@ export class VideoService {
     return this.setVideoRate(id, 'none')
   }
 
-  getUserVideoRating (id: number): Observable<UserVideoRate> {
+  getUserVideoRating (id: number) {
     const url = UserService.BASE_USERS_URL + 'me/videos/' + id + '/rating'
 
-    return this.authHttp
-      .get(url)
-      .catch(res => this.restExtractor.handleError(res))
+    return this.authHttp.get<UserVideoRate>(url)
+               .pipe(catchError(res => this.restExtractor.handleError(res)))
   }
 
   private setVideoRate (id: number, rateType: VideoRateType) {
@@ -260,20 +286,27 @@ export class VideoService {
     }
 
     return this.authHttp
-      .put(url, body)
-      .map(this.restExtractor.extractDataBool)
-      .catch(res => this.restExtractor.handleError(res))
+               .put(url, body)
+               .pipe(
+                 map(this.restExtractor.extractDataBool),
+                 catchError(res => this.restExtractor.handleError(res))
+               )
   }
 
   private extractVideos (result: ResultList<VideoServerModel>) {
-    const videosJson = result.data
-    const totalVideos = result.total
-    const videos = []
-
-    for (const videoJson of videosJson) {
-      videos.push(new Video(videoJson))
-    }
-
-    return { videos, totalVideos }
+    return this.serverService.localeObservable
+      .pipe(
+        map(translations => {
+          const videosJson = result.data
+          const totalVideos = result.total
+          const videos: Video[] = []
+
+          for (const videoJson of videosJson) {
+            videos.push(new Video(videoJson, translations))
+          }
+
+          return { videos, totalVideos }
+        })
+      )
   }
 }