client/src/app/shared/shared-moderation/user-moderation-dropdown.component.ts

   1 import { Component, EventEmitter, Input, OnChanges, OnInit, Output, ViewChild } from '@angular/core'
   2 import { AuthService, ConfirmService, Notifier, ServerService, UserService } from '@app/core'
   3 import { Account, DropdownAction } from '@app/shared/shared-main'
   4 import { I18n } from '@ngx-translate/i18n-polyfill'
   5 import { BulkRemoveCommentsOfBody, ServerConfig, User, UserRight } from '@shared/models'
   6 import { BlocklistService } from './blocklist.service'
   7 import { BulkService } from './bulk.service'
   8 import { UserBanModalComponent } from './user-ban-modal.component'
   9
  10 @Component({
  11   selector: 'my-user-moderation-dropdown',
  12   templateUrl: './user-moderation-dropdown.component.html'
  13 })
  14 export class UserModerationDropdownComponent implements OnInit, OnChanges {
  15   @ViewChild('userBanModal') userBanModal: UserBanModalComponent
  16
  17   @Input() user: User
  18   @Input() account: Account
  19
  20   @Input() buttonSize: 'normal' | 'small' = 'normal'
  21   @Input() placement = 'left-top left-bottom auto'
  22   @Input() label: string
  23   @Input() container: 'body' | undefined = undefined
  24
  25   @Output() userChanged = new EventEmitter()
  26   @Output() userDeleted = new EventEmitter()
  27
  28   userActions: DropdownAction<{ user: User, account: Account }>[][] = []
  29
  30   private serverConfig: ServerConfig
  31
  32   constructor (
  33     private authService: AuthService,
  34     private notifier: Notifier,
  35     private confirmService: ConfirmService,
  36     private serverService: ServerService,
  37     private userService: UserService,
  38     private blocklistService: BlocklistService,
  39     private bulkService: BulkService,
  40     private i18n: I18n
  41   ) { }
  42
  43   get requiresEmailVerification () {
  44     return this.serverConfig.signup.requiresEmailVerification
  45   }
  46
  47   ngOnInit (): void {
  48     this.serverConfig = this.serverService.getTmpConfig()
  49     this.serverService.getConfig()
  50       .subscribe(config => this.serverConfig = config)
  51   }
  52
  53   ngOnChanges () {
  54     this.buildActions()
  55   }
  56
  57   openBanUserModal (user: User) {
  58     if (user.username === 'root') {
  59       this.notifier.error(this.i18n('You cannot ban root.'))
  60       return
  61     }
  62
  63     this.userBanModal.openModal(user)
  64   }
  65
  66   onUserBanned () {
  67     this.userChanged.emit()
  68   }
  69
  70   async unbanUser (user: User) {
  71     const message = this.i18n('Do you really want to unban {{username}}?', { username: user.username })
  72     const res = await this.confirmService.confirm(message, this.i18n('Unban'))
  73     if (res === false) return
  74
  75     this.userService.unbanUsers(user)
  76         .subscribe(
  77           () => {
  78             this.notifier.success(this.i18n('User {{username}} unbanned.', { username: user.username }))
  79
  80             this.userChanged.emit()
  81           },
  82
  83           err => this.notifier.error(err.message)
  84         )
  85   }
  86
  87   async removeUser (user: User) {
  88     if (user.username === 'root') {
  89       this.notifier.error(this.i18n('You cannot delete root.'))
  90       return
  91     }
  92
  93     const message = this.i18n('If you remove this user, you will not be able to create another with the same username!')
  94     const res = await this.confirmService.confirm(message, this.i18n('Delete'))
  95     if (res === false) return
  96
  97     this.userService.removeUser(user).subscribe(
  98       () => {
  99         this.notifier.success(this.i18n('User {{username}} deleted.', { username: user.username }))
 100         this.userDeleted.emit()
 101       },
 102
 103       err => this.notifier.error(err.message)
 104     )
 105   }
 106
 107   setEmailAsVerified (user: User) {
 108     this.userService.updateUser(user.id, { emailVerified: true }).subscribe(
 109       () => {
 110         this.notifier.success(this.i18n('User {{username}} email set as verified', { username: user.username }))
 111
 112         this.userChanged.emit()
 113       },
 114
 115       err => this.notifier.error(err.message)
 116     )
 117   }
 118
 119   blockAccountByUser (account: Account) {
 120     this.blocklistService.blockAccountByUser(account)
 121         .subscribe(
 122           () => {
 123             this.notifier.success(this.i18n('Account {{nameWithHost}} muted.', { nameWithHost: account.nameWithHost }))
 124
 125             this.account.mutedByUser = true
 126             this.userChanged.emit()
 127           },
 128
 129           err => this.notifier.error(err.message)
 130         )
 131   }
 132
 133   unblockAccountByUser (account: Account) {
 134     this.blocklistService.unblockAccountByUser(account)
 135         .subscribe(
 136           () => {
 137             this.notifier.success(this.i18n('Account {{nameWithHost}} unmuted.', { nameWithHost: account.nameWithHost }))
 138
 139             this.account.mutedByUser = false
 140             this.userChanged.emit()
 141           },
 142
 143           err => this.notifier.error(err.message)
 144         )
 145   }
 146
 147   blockServerByUser (host: string) {
 148     this.blocklistService.blockServerByUser(host)
 149         .subscribe(
 150           () => {
 151             this.notifier.success(this.i18n('Instance {{host}} muted.', { host }))
 152
 153             this.account.mutedServerByUser = true
 154             this.userChanged.emit()
 155           },
 156
 157           err => this.notifier.error(err.message)
 158         )
 159   }
 160
 161   unblockServerByUser (host: string) {
 162     this.blocklistService.unblockServerByUser(host)
 163         .subscribe(
 164           () => {
 165             this.notifier.success(this.i18n('Instance {{host}} unmuted.', { host }))
 166
 167             this.account.mutedServerByUser = false
 168             this.userChanged.emit()
 169           },
 170
 171           err => this.notifier.error(err.message)
 172         )
 173   }
 174
 175   blockAccountByInstance (account: Account) {
 176     this.blocklistService.blockAccountByInstance(account)
 177         .subscribe(
 178           () => {
 179             this.notifier.success(this.i18n('Account {{nameWithHost}} muted by the instance.', { nameWithHost: account.nameWithHost }))
 180
 181             this.account.mutedByInstance = true
 182             this.userChanged.emit()
 183           },
 184
 185           err => this.notifier.error(err.message)
 186         )
 187   }
 188
 189   unblockAccountByInstance (account: Account) {
 190     this.blocklistService.unblockAccountByInstance(account)
 191         .subscribe(
 192           () => {
 193             this.notifier.success(this.i18n('Account {{nameWithHost}} unmuted by the instance.', { nameWithHost: account.nameWithHost }))
 194
 195             this.account.mutedByInstance = false
 196             this.userChanged.emit()
 197           },
 198
 199           err => this.notifier.error(err.message)
 200         )
 201   }
 202
 203   blockServerByInstance (host: string) {
 204     this.blocklistService.blockServerByInstance(host)
 205         .subscribe(
 206           () => {
 207             this.notifier.success(this.i18n('Instance {{host}} muted by the instance.', { host }))
 208
 209             this.account.mutedServerByInstance = true
 210             this.userChanged.emit()
 211           },
 212
 213           err => this.notifier.error(err.message)
 214         )
 215   }
 216
 217   unblockServerByInstance (host: string) {
 218     this.blocklistService.unblockServerByInstance(host)
 219         .subscribe(
 220           () => {
 221             this.notifier.success(this.i18n('Instance {{host}} unmuted by the instance.', { host }))
 222
 223             this.account.mutedServerByInstance = false
 224             this.userChanged.emit()
 225           },
 226
 227           err => this.notifier.error(err.message)
 228         )
 229   }
 230
 231   async bulkRemoveCommentsOf (body: BulkRemoveCommentsOfBody) {
 232     const message = this.i18n('Are you sure you want to remove all the comments of this account?')
 233     const res = await this.confirmService.confirm(message, this.i18n('Delete account comments'))
 234     if (res === false) return
 235
 236     this.bulkService.removeCommentsOf(body)
 237         .subscribe(
 238           () => {
 239             this.notifier.success(this.i18n('Will remove comments of this account (may take several minutes).'))
 240           },
 241
 242           err => this.notifier.error(err.message)
 243         )
 244   }
 245
 246   getRouterUserEditLink (user: User) {
 247     return [ '/admin', 'users', 'update', user.id ]
 248   }
 249
 250   private buildActions () {
 251     this.userActions = []
 252
 253     if (this.authService.isLoggedIn()) {
 254       const authUser = this.authService.getUser()
 255
 256       if (this.user && authUser.id === this.user.id) return
 257
 258       if (this.user && authUser.hasRight(UserRight.MANAGE_USERS) && authUser.canManage(this.user)) {
 259         this.userActions.push([
 260           {
 261             label: this.i18n('Edit user'),
 262             description: this.i18n('Change quota, role, and more.'),
 263             linkBuilder: ({ user }) => this.getRouterUserEditLink(user)
 264           },
 265           {
 266             label: this.i18n('Delete user'),
 267             description: this.i18n('Videos will be deleted, comments will be tombstoned.'),
 268             handler: ({ user }) => this.removeUser(user)
 269           },
 270           {
 271             label: this.i18n('Ban'),
 272             description: this.i18n('User won\'t be able to login anymore, but videos and comments will be kept as is.'),
 273             handler: ({ user }) => this.openBanUserModal(user),
 274             isDisplayed: ({ user }) => !user.blocked
 275           },
 276           {
 277             label: this.i18n('Unban user'),
 278             description: this.i18n('Allow the user to login and create videos/comments again'),
 279             handler: ({ user }) => this.unbanUser(user),
 280             isDisplayed: ({ user }) => user.blocked
 281           },
 282           {
 283             label: this.i18n('Set Email as Verified'),
 284             handler: ({ user }) => this.setEmailAsVerified(user),
 285             isDisplayed: ({ user }) => this.requiresEmailVerification && !user.blocked && user.emailVerified === false
 286           }
 287         ])
 288       }
 289
 290       // Actions on accounts/servers
 291       if (this.account) {
 292         // User actions
 293         this.userActions.push([
 294           {
 295             label: this.i18n('Mute this account'),
 296             description: this.i18n('Hide any content from that user for you.'),
 297             isDisplayed: ({ account }) => account.mutedByUser === false,
 298             handler: ({ account }) => this.blockAccountByUser(account)
 299           },
 300           {
 301             label: this.i18n('Unmute this account'),
 302             description: this.i18n('Show back content from that user for you.'),
 303             isDisplayed: ({ account }) => account.mutedByUser === true,
 304             handler: ({ account }) => this.unblockAccountByUser(account)
 305           },
 306           {
 307             label: this.i18n('Mute the instance'),
 308             description: this.i18n('Hide any content from that instance for you.'),
 309             isDisplayed: ({ account }) => !account.userId && account.mutedServerByInstance === false,
 310             handler: ({ account }) => this.blockServerByUser(account.host)
 311           },
 312           {
 313             label: this.i18n('Unmute the instance'),
 314             description: this.i18n('Show back content from that instance for you.'),
 315             isDisplayed: ({ account }) => !account.userId && account.mutedServerByInstance === true,
 316             handler: ({ account }) => this.unblockServerByUser(account.host)
 317           },
 318           {
 319             label: this.i18n('Remove comments from your videos'),
 320             description: this.i18n('Remove comments of this account from your videos.'),
 321             handler: ({ account }) => this.bulkRemoveCommentsOf({ accountName: account.nameWithHost, scope: 'my-videos' })
 322           }
 323         ])
 324
 325         let instanceActions: DropdownAction<{ user: User, account: Account }>[] = []
 326
 327         // Instance actions on account blocklists
 328         if (authUser.hasRight(UserRight.MANAGE_ACCOUNTS_BLOCKLIST)) {
 329           instanceActions = instanceActions.concat([
 330             {
 331               label: this.i18n('Mute this account by your instance'),
 332               description: this.i18n('Hide any content from that user for you, your instance and its users.'),
 333               isDisplayed: ({ account }) => account.mutedByInstance === false,
 334               handler: ({ account }) => this.blockAccountByInstance(account)
 335             },
 336             {
 337               label: this.i18n('Unmute this account by your instance'),
 338               description: this.i18n('Show back content from that user for you, your instance and its users.'),
 339               isDisplayed: ({ account }) => account.mutedByInstance === true,
 340               handler: ({ account }) => this.unblockAccountByInstance(account)
 341             }
 342           ])
 343         }
 344
 345         // Instance actions on server blocklists
 346         if (authUser.hasRight(UserRight.MANAGE_SERVERS_BLOCKLIST)) {
 347           instanceActions = instanceActions.concat([
 348             {
 349               label: this.i18n('Mute the instance by your instance'),
 350               description: this.i18n('Hide any content from that instance for you, your instance and its users.'),
 351               isDisplayed: ({ account }) => !account.userId && account.mutedServerByInstance === false,
 352               handler: ({ account }) => this.blockServerByInstance(account.host)
 353             },
 354             {
 355               label: this.i18n('Unmute the instance by your instance'),
 356               description: this.i18n('Show back content from that instance for you, your instance and its users.'),
 357               isDisplayed: ({ account }) => !account.userId && account.mutedServerByInstance === true,
 358               handler: ({ account }) => this.unblockServerByInstance(account.host)
 359             }
 360           ])
 361         }
 362
 363         if (authUser.hasRight(UserRight.REMOVE_ANY_VIDEO_COMMENT)) {
 364           instanceActions = instanceActions.concat([
 365             {
 366               label: this.i18n('Remove comments from your instance'),
 367               description: this.i18n('Remove comments of this account from your instance.'),
 368               handler: ({ account }) => this.bulkRemoveCommentsOf({ accountName: account.nameWithHost, scope: 'instance' })
 369             }
 370           ])
 371         }
 372
 373         if (instanceActions.length !== 0) {
 374           this.userActions.push(instanceActions)
 375         }
 376       }
 377     }
 378   }
 379 }