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

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