Give moderators access to edit channels (#4608)

* give admins access to edit all channels

closes #4598

* test(channels): +admin update another users channel

* Fix tests

* fix(server): delete another users channel

Since the channel owner isn't necessary the auth user we need to check
the right account whether it's the last video or not.

* REMOVE_ANY_VIDEO_CHANNEL > MANAGE_ANY_VIDEO_CHANNEL

Merge REMOVE_ANY_VIDEO_CHANNEL and MANY_VIDEO_CHANNELS to
MANAGE_ANY_VIDEO_CHANNEL.

* user-right: moderator can't manage admins channel

* client: MyVideoChannelCreateComponent > VideoChannelCreateComponent

* client: MyVideoChannelEdit > VideoChannelEdit

* Revert "user-right: moderator can't manage admins channel"

This reverts commit 2c627c154e2bfe6af2e0f45efb27faf4117572f3.

* server: clean dupl validator functionality

* fix ensureUserCanManageChannel usage

It's not async anymore.

* server: merge channel validator middleares

ensureAuthUserOwnsChannelValidator & ensureUserCanManageChannel gets
merged into one middleware.

* client(VideoChannelEdit): redirect to prev route

* fix(VideoChannels): handle anon users

* client: new routes for create/update channel

* Refactor channel validators

Co-authored-by: Chocobozzz <me@florianbigard.com>

1 files changed, 189 insertions, 0 deletions

diff --git a/client/src/app/+manage/video-channel-edit/video-channel-update.component.ts b/client/src/app/+manage/video-channel-edit/video-channel-update.component.ts
new file mode 100644
index 000000000..21b6167b2
--- /dev/null
+++ b/client/src/app/+manage/video-channel-edit/video-channel-update.component.ts
@@ -0,0 +1,189 @@
+import { Subscription } from 'rxjs'
+import { HttpErrorResponse } from '@angular/common/http'
+import { Component, OnDestroy, OnInit } from '@angular/core'
+import { ActivatedRoute, Router } from '@angular/router'
+import { AuthService, Notifier, RedirectService, ServerService } from '@app/core'
+import { genericUploadErrorHandler } from '@app/helpers'
+import {
+  VIDEO_CHANNEL_DESCRIPTION_VALIDATOR,
+  VIDEO_CHANNEL_DISPLAY_NAME_VALIDATOR,
+  VIDEO_CHANNEL_SUPPORT_VALIDATOR
+} from '@app/shared/form-validators/video-channel-validators'
+import { FormValidatorService } from '@app/shared/shared-forms'
+import { VideoChannel, VideoChannelService } from '@app/shared/shared-main'
+import { HTMLServerConfig, VideoChannelUpdate } from '@shared/models'
+import { VideoChannelEdit } from './video-channel-edit'
+
+@Component({
+  selector: 'my-video-channel-update',
+  templateUrl: './video-channel-edit.component.html',
+  styleUrls: [ './video-channel-edit.component.scss' ]
+})
+export class VideoChannelUpdateComponent extends VideoChannelEdit implements OnInit, OnDestroy {
+  error: string
+  videoChannel: VideoChannel
+
+  private paramsSub: Subscription
+  private oldSupportField: string
+  private serverConfig: HTMLServerConfig
+
+  constructor (
+    protected formValidatorService: FormValidatorService,
+    private authService: AuthService,
+    private notifier: Notifier,
+    private router: Router,
+    private route: ActivatedRoute,
+    private videoChannelService: VideoChannelService,
+    private serverService: ServerService,
+    private redirectService: RedirectService
+  ) {
+    super()
+  }
+
+  ngOnInit () {
+    this.serverConfig = this.serverService.getHTMLConfig()
+
+    this.buildForm({
+      'display-name': VIDEO_CHANNEL_DISPLAY_NAME_VALIDATOR,
+      description: VIDEO_CHANNEL_DESCRIPTION_VALIDATOR,
+      support: VIDEO_CHANNEL_SUPPORT_VALIDATOR,
+      bulkVideosSupportUpdate: null
+    })
+
+    this.paramsSub = this.route.params.subscribe(routeParams => {
+      const videoChannelName = routeParams['videoChannelName']
+
+      this.videoChannelService.getVideoChannel(videoChannelName)
+        .subscribe({
+          next: videoChannelToUpdate => {
+            this.videoChannel = videoChannelToUpdate
+
+            this.oldSupportField = videoChannelToUpdate.support
+
+            this.form.patchValue({
+              'display-name': videoChannelToUpdate.displayName,
+              description: videoChannelToUpdate.description,
+              support: videoChannelToUpdate.support
+            })
+          },
+
+          error: err => {
+            this.error = err.message
+          }
+        })
+    })
+  }
+
+  ngOnDestroy () {
+    if (this.paramsSub) this.paramsSub.unsubscribe()
+  }
+
+  formValidated () {
+    this.error = undefined
+
+    const body = this.form.value
+    const videoChannelUpdate: VideoChannelUpdate = {
+      displayName: body['display-name'],
+      description: body.description || null,
+      support: body.support || null,
+      bulkVideosSupportUpdate: body.bulkVideosSupportUpdate || false
+    }
+
+    this.videoChannelService.updateVideoChannel(this.videoChannel.name, videoChannelUpdate)
+      .subscribe({
+        next: () => {
+          this.authService.refreshUserInformation()
+
+          this.notifier.success($localize`Video channel ${videoChannelUpdate.displayName} updated.`)
+
+          this.redirectService.redirectToPreviousRoute([ '/c', this.videoChannel.name ])
+        },
+
+        error: err => {
+          this.error = err.message
+        }
+      })
+  }
+
+  onAvatarChange (formData: FormData) {
+    this.videoChannelService.changeVideoChannelImage(this.videoChannel.name, formData, 'avatar')
+        .subscribe({
+          next: data => {
+            this.notifier.success($localize`Avatar changed.`)
+
+            this.videoChannel.updateAvatar(data.avatar)
+          },
+
+          error: (err: HttpErrorResponse) => genericUploadErrorHandler({
+            err,
+            name: $localize`avatar`,
+            notifier: this.notifier
+          })
+        })
+  }
+
+  onAvatarDelete () {
+    this.videoChannelService.deleteVideoChannelImage(this.videoChannel.name, 'avatar')
+                            .subscribe({
+                              next: () => {
+                                this.notifier.success($localize`Avatar deleted.`)
+
+                                this.videoChannel.resetAvatar()
+                              },
+
+                              error: err => this.notifier.error(err.message)
+                            })
+  }
+
+  onBannerChange (formData: FormData) {
+    this.videoChannelService.changeVideoChannelImage(this.videoChannel.name, formData, 'banner')
+        .subscribe({
+          next: data => {
+            this.notifier.success($localize`Banner changed.`)
+
+            this.videoChannel.updateBanner(data.banner)
+          },
+
+          error: (err: HttpErrorResponse) => genericUploadErrorHandler({
+            err,
+            name: $localize`banner`,
+            notifier: this.notifier
+          })
+        })
+  }
+
+  onBannerDelete () {
+    this.videoChannelService.deleteVideoChannelImage(this.videoChannel.name, 'banner')
+                            .subscribe({
+                              next: () => {
+                                this.notifier.success($localize`Banner deleted.`)
+
+                                this.videoChannel.resetBanner()
+                              },
+
+                              error: err => this.notifier.error(err.message)
+                            })
+  }
+
+  get maxAvatarSize () {
+    return this.serverConfig.avatar.file.size.max
+  }
+
+  get avatarExtensions () {
+    return this.serverConfig.avatar.file.extensions.join(',')
+  }
+
+  isCreation () {
+    return false
+  }
+
+  getFormButtonTitle () {
+    return $localize`Update`
+  }
+
+  isBulkUpdateVideosDisplayed () {
+    if (this.oldSupportField === undefined) return false
+
+    return this.oldSupportField !== this.form.value['support']
+  }
+}