Moderation tweaks (#2548)

* Only allow admins to see the roles and permissions screen.

* Hide the selection checkbox on Admins when changing roles.

* Show an empty state for banned users.

* Add separate actions for ban and remove.

* Implement reset permissions and demote self alerts.

* Add tests for resetting permissions and demoting self.

* Add a warning when promoting someone to administrator.

ElementX/Sources/Screens/RoomRolesAndPermissionsScreen/RoomRolesAndPermissionsScreenCoordinator.swift

@@ -21,28 +21,31 @@ import SwiftUI
 
 struct RoomRolesAndPermissionsScreenCoordinatorParameters {
     let roomProxy: RoomProxyProtocol
+    let userIndicatorController: UserIndicatorControllerProtocol
 }
 
 enum RoomRolesAndPermissionsScreenCoordinatorAction {
     case editRoles(RoomRolesAndPermissionsScreenRole)
     case editPermissions(RoomRolesAndPermissionsScreenPermissionsGroup)
+    case demotedOwnUser
 }
 
 final class RoomRolesAndPermissionsScreenCoordinator: CoordinatorProtocol {
     private var viewModel: RoomRolesAndPermissionsScreenViewModelProtocol
-    private let actionsSubject: PassthroughSubject<RoomRolesAndPermissionsScreenCoordinatorAction, Never> = .init()
     private var cancellables = Set<AnyCancellable>()
     
-    var actions: AnyPublisher<RoomRolesAndPermissionsScreenCoordinatorAction, Never> {
+    private let actionsSubject: PassthroughSubject<RoomRolesAndPermissionsScreenCoordinatorAction, Never> = .init()
+    var actionsPublisher: AnyPublisher<RoomRolesAndPermissionsScreenCoordinatorAction, Never> {
         actionsSubject.eraseToAnyPublisher()
     }
     
     init(parameters: RoomRolesAndPermissionsScreenCoordinatorParameters) {
-        viewModel = RoomRolesAndPermissionsScreenViewModel(roomProxy: parameters.roomProxy)
+        viewModel = RoomRolesAndPermissionsScreenViewModel(roomProxy: parameters.roomProxy,
+                                                           userIndicatorController: parameters.userIndicatorController)
     }
     
     func start() {
-        viewModel.actions.sink { [weak self] action in
+        viewModel.actionsPublisher.sink { [weak self] action in
             MXLog.info("Coordinator: received view model action: \(action)")
             
             guard let self else { return }
@@ -51,6 +54,8 @@ final class RoomRolesAndPermissionsScreenCoordinator: CoordinatorProtocol {
                 actionsSubject.send(.editRoles(role))
             case .editPermissions(let permissionsGroup):
                 actionsSubject.send(.editPermissions(permissionsGroup))
+            case .demotedOwnUser:
+                actionsSubject.send(.demotedOwnUser)
             }
         }
         .store(in: &cancellables)

ElementX/Sources/Screens/RoomRolesAndPermissionsScreen/RoomRolesAndPermissionsScreenModels.swift

@@ -17,13 +17,33 @@
 import Foundation
 
 enum RoomRolesAndPermissionsScreenViewModelAction {
+    /// The user would like to edit member roles.
     case editRoles(RoomRolesAndPermissionsScreenRole)
+    /// The user would like to edit room permissions.
     case editPermissions(RoomRolesAndPermissionsScreenPermissionsGroup)
+    /// The user has demoted themself.
+    case demotedOwnUser
 }
 
 struct RoomRolesAndPermissionsScreenViewState: BindableState {
+    /// The number of administrators in the room.
     var administratorCount: Int?
+    /// The number of moderators in the room.
     var moderatorCount: Int?
+    var bindings = RoomRolesAndPermissionsScreenViewStateBindings()
+}
+
+struct RoomRolesAndPermissionsScreenViewStateBindings {
+    var alertInfo: AlertInfo<RoomRolesAndPermissionsScreenAlertType>?
+}
+
+enum RoomRolesAndPermissionsScreenAlertType {
+    /// Ask the user which role they would like to demote themself to.
+    case editOwnRole
+    /// Confirm that the user would like to reset the room's permissions.
+    case resetConfirmation
+    /// An error occurred.
+    case error
 }
 
 enum RoomRolesAndPermissionsScreenViewAction {

ElementX/Sources/Screens/RoomRolesAndPermissionsScreen/RoomRolesAndPermissionsScreenViewModel.swift

@@ -21,14 +21,16 @@ typealias RoomRolesAndPermissionsScreenViewModelType = StateStoreViewModel<RoomR
 
 class RoomRolesAndPermissionsScreenViewModel: RoomRolesAndPermissionsScreenViewModelType, RoomRolesAndPermissionsScreenViewModelProtocol {
     private let roomProxy: RoomProxyProtocol
-    private var actionsSubject: PassthroughSubject<RoomRolesAndPermissionsScreenViewModelAction, Never> = .init()
+    private let userIndicatorController: UserIndicatorControllerProtocol
     
-    var actions: AnyPublisher<RoomRolesAndPermissionsScreenViewModelAction, Never> {
+    private var actionsSubject: PassthroughSubject<RoomRolesAndPermissionsScreenViewModelAction, Never> = .init()
+    var actionsPublisher: AnyPublisher<RoomRolesAndPermissionsScreenViewModelAction, Never> {
         actionsSubject.eraseToAnyPublisher()
     }
 
-    init(roomProxy: RoomProxyProtocol) {
+    init(roomProxy: RoomProxyProtocol, userIndicatorController: UserIndicatorControllerProtocol) {
         self.roomProxy = roomProxy
+        self.userIndicatorController = userIndicatorController
         super.init(initialViewState: RoomRolesAndPermissionsScreenViewState())
         
         roomProxy.membersPublisher.sink { [weak self] members in
@@ -48,11 +50,28 @@ class RoomRolesAndPermissionsScreenViewModel: RoomRolesAndPermissionsScreenViewM
         case .editRoles(let role):
             actionsSubject.send(.editRoles(role))
         case .editOwnUserRole:
-            break
+            state.bindings.alertInfo = AlertInfo(id: .resetConfirmation,
+                                                 title: L10n.screenRoomRolesAndPermissionsChangeMyRole,
+                                                 message: L10n.screenRoomChangeRoleConfirmDemoteSelfDescription,
+                                                 verticalButtons: [
+                                                     .init(title: L10n.screenRoomRolesAndPermissionsChangeRoleDemoteToModerator, role: .destructive) {
+                                                         Task { await self.updateOwnRole(.moderator) }
+                                                     },
+                                                     .init(title: L10n.screenRoomRolesAndPermissionsChangeRoleDemoteToMember, role: .destructive) {
+                                                         Task { await self.updateOwnRole(.user) }
+                                                     },
+                                                     .init(title: L10n.actionCancel, role: .cancel) { }
+                                                 ])
         case .editPermissions(let permissionsGroup):
             actionsSubject.send(.editPermissions(permissionsGroup))
         case .reset:
-            break
+            state.bindings.alertInfo = AlertInfo(id: .resetConfirmation,
+                                                 title: L10n.screenRoomRolesAndPermissionsResetConfirmTitle,
+                                                 message: L10n.screenRoomRolesAndPermissionsResetConfirmDescription,
+                                                 primaryButton: .init(title: L10n.actionReset, role: .destructive) {
+                                                     Task { await self.resetPermissions() }
+                                                 },
+                                                 secondaryButton: .init(title: L10n.actionCancel, role: .cancel) { })
         }
     }
     
@@ -62,4 +81,54 @@ class RoomRolesAndPermissionsScreenViewModel: RoomRolesAndPermissionsScreenViewM
         state.administratorCount = members.filter { $0.role == .administrator }.count
         state.moderatorCount = members.filter { $0.role == .moderator }.count
     }
+    
+    private func updateOwnRole(_ role: RoomMemberDetails.Role) async {
+        showSavingIndicator()
+        
+        switch await roomProxy.updatePowerLevelsForUsers([(userID: roomProxy.ownUserID, powerLevel: role.rustPowerLevel)]) {
+        case .success:
+            showSuccessIndicator()
+            actionsSubject.send(.demotedOwnUser)
+        case .failure:
+            state.bindings.alertInfo = AlertInfo(id: .error)
+        }
+        
+        hideSavingIndicator()
+    }
+    
+    private func resetPermissions() async {
+        showSavingIndicator()
+        
+        switch await roomProxy.resetPowerLevels() {
+        case .success(let success):
+            showSuccessIndicator()
+        case .failure(let failure):
+            state.bindings.alertInfo = AlertInfo(id: .error)
+        }
+        
+        hideSavingIndicator()
+    }
+    
+    // MARK: Loading indicator
+    
+    private static let savingIndicatorID = "RolesAndPermissionsSaving"
+    private static let successIndicatorID = "RolesAndPermissionsSuccess"
+    
+    private func showSavingIndicator() {
+        userIndicatorController.submitIndicator(UserIndicator(id: Self.savingIndicatorID,
+                                                              type: .modal(progress: .indeterminate, interactiveDismissDisabled: true, allowsInteraction: false),
+                                                              title: L10n.commonSaving,
+                                                              persistent: true))
+    }
+    
+    private func hideSavingIndicator() {
+        userIndicatorController.retractIndicatorWithId(Self.savingIndicatorID)
+    }
+    
+    private func showSuccessIndicator() {
+        userIndicatorController.submitIndicator(UserIndicator(id: Self.successIndicatorID,
+                                                              type: .toast,
+                                                              title: L10n.commonSuccess,
+                                                              iconName: "checkmark"))
+    }
 }

ElementX/Sources/Screens/RoomRolesAndPermissionsScreen/RoomRolesAndPermissionsScreenViewModelProtocol.swift

@@ -18,6 +18,6 @@ import Combine
 
 @MainActor
 protocol RoomRolesAndPermissionsScreenViewModelProtocol {
-    var actions: AnyPublisher<RoomRolesAndPermissionsScreenViewModelAction, Never> { get }
+    var actionsPublisher: AnyPublisher<RoomRolesAndPermissionsScreenViewModelAction, Never> { get }
     var context: RoomRolesAndPermissionsScreenViewModelType.Context { get }
 }

ElementX/Sources/Screens/RoomRolesAndPermissionsScreen/View/RoomRolesAndPermissionsScreen.swift

@@ -30,6 +30,7 @@ struct RoomRolesAndPermissionsScreen: View {
         .compoundList()
         .navigationTitle(L10n.screenRoomRolesAndPermissionsTitle)
         .navigationBarTitleDisplayMode(.inline)
+        .alert(item: $context.alertInfo)
     }
     
     private var rolesSection: some View {
@@ -119,7 +120,8 @@ struct RoomRolesAndPermissionsScreen: View {
 // MARK: - Previews
 
 struct RoomRolesAndPermissionsScreen_Previews: PreviewProvider, TestablePreview {
-    static let viewModel = RoomRolesAndPermissionsScreenViewModel(roomProxy: RoomProxyMock(with: .init(members: .allMembersAsAdmin)))
+    static let viewModel = RoomRolesAndPermissionsScreenViewModel(roomProxy: RoomProxyMock(with: .init(members: .allMembersAsAdmin)),
+                                                                  userIndicatorController: UserIndicatorControllerMock())
     static var previews: some View {
         NavigationStack {
             RoomRolesAndPermissionsScreen(context: viewModel.context)