Try to improve permanent live label

[github/Chocobozzz/PeerTube.git] / client / src / app / +videos / +video-edit / video-add-components / video-go-live.component.ts

diff --git a/client/src/app/+videos/+video-edit/video-add-components/video-go-live.component.ts b/client/src/app/+videos/+video-edit/video-add-components/video-go-live.component.ts
index 64fd4c4d4e145184c6e1317731ea045c04132dbc..ee7011b4c1a5d5bb3bb7f24692de41ba746424a3 100644 (file)
--- a/client/src/app/+videos/+video-edit/video-add-components/video-go-live.component.ts
+++ b/client/src/app/+videos/+video-edit/video-add-components/video-go-live.component.ts
@@ -1,12 +1,14 @@
 
-import { Component, EventEmitter, OnInit, Output } from '@angular/core'
+import { forkJoin } from 'rxjs'
+import { AfterViewInit, Component, EventEmitter, OnInit, Output } from '@angular/core'
 import { Router } from '@angular/router'
-import { AuthService, CanComponentDeactivate, Notifier, ServerService } from '@app/core'
+import { AuthService, CanComponentDeactivate, HooksService, Notifier, ServerService } from '@app/core'
 import { scrollToTop } from '@app/helpers'
 import { FormValidatorService } from '@app/shared/shared-forms'
-import { VideoCaptionService, VideoEdit, VideoService, VideoLiveService } from '@app/shared/shared-main'
+import { Video, VideoCaptionService, VideoEdit, VideoService } from '@app/shared/shared-main'
+import { LiveVideoService } from '@app/shared/shared-video-live'
 import { LoadingBarService } from '@ngx-loading-bar/core'
-import { VideoCreate, VideoLive, VideoPrivacy } from '@shared/models'
+import { LiveVideo, LiveVideoCreate, LiveVideoUpdate, PeerTubeProblemDocument, ServerErrorCode } from '@shared/models'
 import { VideoSend } from './video-send'
 
 @Component({
@@ -17,18 +19,19 @@ import { VideoSend } from './video-send'
     './video-send.scss'
   ]
 })
-export class VideoGoLiveComponent extends VideoSend implements OnInit, CanComponentDeactivate {
+export class VideoGoLiveComponent extends VideoSend implements OnInit, AfterViewInit, CanComponentDeactivate {
   @Output() firstStepDone = new EventEmitter<string>()
   @Output() firstStepError = new EventEmitter<void>()
 
   isInUpdateForm = false
 
-  videoLive: VideoLive
+  liveVideo: LiveVideo
+
   videoId: number
   videoUUID: string
-  error: string
+  videoShortUUID: string
 
-  protected readonly DEFAULT_VIDEO_PRIVACY = VideoPrivacy.PUBLIC
+  error: string
 
   constructor (
     protected formValidatorService: FormValidatorService,
@@ -38,9 +41,10 @@ export class VideoGoLiveComponent extends VideoSend implements OnInit, CanCompon
     protected serverService: ServerService,
     protected videoService: VideoService,
     protected videoCaptionService: VideoCaptionService,
-    private videoLiveService: VideoLiveService,
-    private router: Router
-    ) {
+    private liveVideoService: LiveVideoService,
+    private router: Router,
+    private hooks: HooksService
+  ) {
     super()
   }
 
@@ -48,41 +52,62 @@ export class VideoGoLiveComponent extends VideoSend implements OnInit, CanCompon
     super.ngOnInit()
   }
 
+  ngAfterViewInit () {
+    this.hooks.runAction('action:go-live.init', 'video-edit')
+  }
+
   canDeactivate () {
     return { canDeactivate: true }
   }
 
   goLive () {
-    const video: VideoCreate = {
-      name: 'Live',
-      privacy: VideoPrivacy.PRIVATE,
+    const name = 'Live'
+
+    const video: LiveVideoCreate = {
+      name,
+      privacy: this.highestPrivacy,
       nsfw: this.serverConfig.instance.isNSFW,
       waitTranscoding: true,
       commentsEnabled: true,
       downloadEnabled: true,
+      permanentLive: false,
+      saveReplay: false,
       channelId: this.firstStepChannelId
     }
 
-    this.firstStepDone.emit(name)
-
     // Go live in private mode, but correctly fill the update form with the first user choice
     const toPatch = Object.assign({}, video, { privacy: this.firstStepPrivacyId })
     this.form.patchValue(toPatch)
 
-    this.videoLiveService.goLive(video).subscribe(
-      res => {
-        this.videoId = res.video.id
-        this.videoUUID = res.video.uuid
-        this.isInUpdateForm = true
+    this.liveVideoService.goLive(video)
+      .subscribe({
+        next: res => {
+          this.videoId = res.video.id
+          this.videoUUID = res.video.uuid
+          this.videoShortUUID = res.video.shortUUID
+          this.isInUpdateForm = true
 
-        this.fetchVideoLive()
-      },
+          this.firstStepDone.emit(name)
 
-      err => {
-        this.firstStepError.emit()
-        this.notifier.error(err.message)
-      }
-    )
+          this.fetchVideoLive()
+        },
+
+        error: err => {
+          this.firstStepError.emit()
+
+          let message = err.message
+
+          const error = err.body as PeerTubeProblemDocument
+
+          if (error?.code === ServerErrorCode.MAX_INSTANCE_LIVES_LIMIT_REACHED) {
+            message = $localize`Cannot create live because this instance have too many created lives`
+          } else if (error?.code === ServerErrorCode.MAX_USER_LIVES_LIMIT_REACHED) {
+            message = $localize`Cannot create live because you created too many lives`
+          }
+
+          this.notifier.error(message)
+        }
+      })
   }
 
   updateSecondStep () {
@@ -94,36 +119,52 @@ export class VideoGoLiveComponent extends VideoSend implements OnInit, CanCompon
     video.patch(this.form.value)
     video.id = this.videoId
     video.uuid = this.videoUUID
+    video.shortUUID = this.videoShortUUID
+
+    const liveVideoUpdate: LiveVideoUpdate = {
+      saveReplay: this.form.value.saveReplay,
+      permanentLive: this.form.value.permanentLive
+    }
 
     // Update the video
-    this.updateVideoAndCaptions(video)
-        .subscribe(
-          () => {
-            this.notifier.success($localize`Live published.`)
-
-            this.router.navigate([ '/videos/watch', video.uuid ])
-          },
-
-          err => {
-            this.error = err.message
-            scrollToTop()
-            console.error(err)
-          }
-        )
+    forkJoin([
+      this.updateVideoAndCaptions(video),
+
+      this.liveVideoService.updateLive(this.videoId, liveVideoUpdate)
+    ]).subscribe({
+      next: () => {
+        this.notifier.success($localize`Live published.`)
+
+        this.router.navigateByUrl(Video.buildWatchUrl(video))
+      },
+
+      error: err => {
+        this.error = err.message
+        scrollToTop()
+        console.error(err)
+      }
+    })
+  }
+
+  getMaxLiveDuration () {
+    return this.serverConfig.live.maxDuration / 1000
+  }
 
+  isWaitTranscodingEnabled () {
+    return this.form.value['saveReplay'] === true
   }
 
   private fetchVideoLive () {
-    this.videoLiveService.getVideoLive(this.videoId)
-      .subscribe(
-        videoLive => {
-          this.videoLive = videoLive
+    this.liveVideoService.getVideoLive(this.videoId)
+      .subscribe({
+        next: liveVideo => {
+          this.liveVideo = liveVideo
         },
 
-        err => {
+        error: err => {
           this.firstStepError.emit()
           this.notifier.error(err.message)
         }
-      )
+      })
   }
 }