Last Owner should edit admins, and not leave when is last (#4372)

ElementX/Sources/Screens/RoomChangeRolesScreen/RoomChangeRolesScreenCoordinator.swift

@@ -9,7 +9,7 @@ import Combine
 import SwiftUI
 
 struct RoomChangeRolesScreenCoordinatorParameters {
-    let mode: RoomMemberDetails.Role
+    let mode: RoomRole
     let roomProxy: JoinedRoomProxyProtocol
     let mediaProvider: MediaProviderProtocol
     let userIndicatorController: UserIndicatorControllerProtocol

ElementX/Sources/Screens/RoomChangeRolesScreen/RoomChangeRolesScreenModels.swift

@@ -14,15 +14,19 @@ enum RoomChangeRolesScreenViewModelAction {
 
 struct RoomChangeRolesScreenViewState: BindableState {
     /// The screen's current mode (which role we are promoting/demoting users to/from.
-    let mode: RoomMemberDetails.Role
+    let mode: RoomRole
+    /// The current user's role.
+    var ownRole: RoomRole
+    /// All of the room's members who are currently owners or creators.
+    var owners: [RoomMemberDetails] = []
     /// All of the room's members who are currently admins.
-    var administrators: [RoomMemberDetails]
+    var administrators: [RoomMemberDetails] = []
     /// All of the room's members who are currently moderators.
-    var moderators: [RoomMemberDetails]
+    var moderators: [RoomMemberDetails] = []
     /// All of the room's members who are currently neither an admin or moderator.
-    var users: [RoomMemberDetails]
+    var users: [RoomMemberDetails] = []
     
-    var bindings: RoomChangeRolesScreenViewStateBindings
+    var bindings = RoomChangeRolesScreenViewStateBindings()
     
     /// The members selected for promotion to the current role.
     var membersToPromote: Set<RoomMemberDetails> = []
@@ -35,9 +39,17 @@ struct RoomChangeRolesScreenViewState: BindableState {
     /// The screen's title.
     var title: String {
         switch mode {
-        case .creator, .owner, .administrator:
-            // TODO: Handle the creator permissions change
-            L10n.screenRoomChangeRoleAdministratorsTitle
+        case .creator:
+            "" // The screen can't be configured with this role.
+        case .owner:
+            L10n.screenRoomChangeRoleOwnersTitle
+        case .administrator:
+            switch ownRole {
+            case .creator:
+                L10n.screenRoomChangeRoleAdministratorsOrOwnersTitle
+            default:
+                L10n.screenRoomChangeRoleAdministratorsTitle
+            }
         case .moderator:
             L10n.screenRoomChangeRoleModeratorsTitle
         case .user:
@@ -45,6 +57,10 @@ struct RoomChangeRolesScreenViewState: BindableState {
         }
     }
     
+    var visibleOwners: [RoomMemberDetails] {
+        owners.filter { $0.matches(searchQuery: bindings.searchQuery) }
+    }
+    
     /// The visible admins in the screen (after searching).
     var visibleAdministrators: [RoomMemberDetails] {
         administrators.filter { $0.matches(searchQuery: bindings.searchQuery) }
@@ -62,7 +78,8 @@ struct RoomChangeRolesScreenViewState: BindableState {
     
     /// All of the members who will gain/keep this screen's role after saving any changes.
     var membersWithRole: [RoomMemberDetails] {
-        administrators.filter(isMemberSelected) + moderators.filter(isMemberSelected) + users.filter(isMemberSelected)
+        let members = owners + administrators + moderators + users
+        return members.filter(isMemberSelected)
     }
     
     /// Whether or not any changes have been made to the members.
@@ -78,7 +95,31 @@ struct RoomChangeRolesScreenViewState: BindableState {
     /// Whether or not a specific member has this screen's role.
     func isMemberSelected(_ member: RoomMemberDetails) -> Bool {
         guard !membersToDemote.contains(member) else { return false }
-        return member.role == mode || membersToPromote.contains(member)
+        return member.role >= mode || membersToPromote.contains(member)
+    }
+    
+    func isMemberDisabled(_ member: RoomMemberDetails) -> Bool {
+        member.role > maxDemotableRole
+    }
+    
+    var maxDemotableRole: RoomRole {
+        switch mode {
+        case .owner:
+            return .owner
+        case .administrator:
+            switch ownRole {
+            case .owner:
+                return .administrator
+            case .creator:
+                return .owner
+            default:
+                return .moderator
+            }
+        case .moderator:
+            return .moderator
+        default:
+            return .user
+        }
     }
 }
 
@@ -91,6 +132,8 @@ struct RoomChangeRolesScreenViewStateBindings {
 enum RoomChangeRolesScreenAlertType {
     /// A warning that a particular promotion can't be undone.
     case promotionWarning
+    /// A warning that ownership transfer is final when the room is left.
+    case transferOwnershipWarning
     /// A confirmation that the user would like to discard any unsaved changes.
     case discardChanges
     /// The generic error message.

ElementX/Sources/Screens/RoomChangeRolesScreen/RoomChangeRolesScreenViewModel.swift

@@ -20,22 +20,19 @@ class RoomChangeRolesScreenViewModel: RoomChangeRolesScreenViewModelType, RoomCh
         actionsSubject.eraseToAnyPublisher()
     }
 
-    init(mode: RoomMemberDetails.Role,
+    init(mode: RoomRole,
          roomProxy: JoinedRoomProxyProtocol,
          mediaProvider: MediaProviderProtocol,
          userIndicatorController: UserIndicatorControllerProtocol,
          analytics: AnalyticsService) {
-        guard mode != .user else { fatalError("Invalid screen configuration: \(mode)") }
-        
+        guard mode != .user || mode != .creator else { fatalError("Invalid screen configuration: \(mode)") }
+
         self.roomProxy = roomProxy
         self.userIndicatorController = userIndicatorController
         self.analytics = analytics
         
         super.init(initialViewState: RoomChangeRolesScreenViewState(mode: mode,
-                                                                    administrators: [],
-                                                                    moderators: [],
-                                                                    users: [],
-                                                                    bindings: .init()),
+                                                                    ownRole: roomProxy.membersPublisher.value.first { $0.userID == roomProxy.id }?.role ?? .administrator),
                    mediaProvider: mediaProvider)
         
         roomProxy.membersPublisher
@@ -64,11 +61,16 @@ class RoomChangeRolesScreenViewModel: RoomChangeRolesScreenViewModelType, RoomCh
         case .demoteMember(let member):
             demoteMember(member)
         case .save:
-            if state.mode.isAdminOrHigher, !state.membersToPromote.isEmpty {
-                showPromotionWarning()
-            } else {
-                Task { await save() }
+            if !state.membersToPromote.isEmpty {
+                if state.mode == .administrator, state.ownRole == .administrator {
+                    showPromotionWarning()
+                    return
+                } else if state.mode == .owner {
+                    showTransferOwnershipWarning()
+                    return
+                }
             }
+            Task { await save() }
         case .cancel:
             confirmDiscardChanges()
         }
@@ -77,17 +79,23 @@ class RoomChangeRolesScreenViewModel: RoomChangeRolesScreenViewModelType, RoomCh
     // MARK: - Private
     
     private func updateMembers(_ members: [RoomMemberProxyProtocol]) {
+        var owners = [RoomMemberDetails]()
         var administrators = [RoomMemberDetails]()
         var moderators = [RoomMemberDetails]()
         var users = [RoomMemberDetails]()
         
         for member in members.sorted() {
+            if member.userID == roomProxy.ownUserID {
+                state.ownRole = member.role
+            }
+            
             guard member.isActive else { continue }
             let memberDetails = RoomMemberDetails(withProxy: member)
             
-            switch member.role {
-            // TODO: Create a owner list
-            case .administrator, .creator:
+            switch memberDetails.role {
+            case .creator, .owner:
+                owners.append(memberDetails)
+            case .administrator:
                 administrators.append(memberDetails)
             case .moderator:
                 moderators.append(memberDetails)
@@ -96,6 +104,7 @@ class RoomChangeRolesScreenViewModel: RoomChangeRolesScreenViewModelType, RoomCh
             }
         }
         
+        state.owners = owners
         state.administrators = administrators
         state.moderators = moderators
         state.users = users
@@ -107,9 +116,9 @@ class RoomChangeRolesScreenViewModel: RoomChangeRolesScreenViewModelType, RoomCh
         } else if state.membersToDemote.contains(member) {
             state.membersToDemote.remove(member)
             state.lastPromotedMember = member
-        } else if member.role == state.mode {
+        } else if member.role >= state.mode, member.role <= state.maxDemotableRole {
             state.membersToDemote.insert(member)
-        } else {
+        } else if member.role < state.mode {
             state.membersToPromote.insert(member)
             state.lastPromotedMember = member
         }
@@ -133,6 +142,16 @@ class RoomChangeRolesScreenViewModel: RoomChangeRolesScreenViewModelType, RoomCh
                                       secondaryButton: .init(title: L10n.actionCancel, role: .cancel, action: nil))
     }
     
+    private func showTransferOwnershipWarning() {
+        context.alertInfo = AlertInfo(id: .transferOwnershipWarning,
+                                      title: L10n.screenRoomChangeRoleConfirmChangeOwnersTitle,
+                                      message: L10n.screenRoomChangeRoleConfirmChangeOwnersDescription,
+                                      primaryButton: .init(title: L10n.actionContinue, role: .destructive) {
+                                          Task { await self.save() }
+                                      },
+                                      secondaryButton: .init(title: L10n.actionCancel, role: .cancel, action: nil))
+    }
+    
     private func save() async {
         showSavingIndicator()
         

ElementX/Sources/Screens/RoomChangeRolesScreen/View/RoomChangeRolesScreen.swift

@@ -45,15 +45,18 @@ struct RoomChangeRolesScreen: View {
                     }
                 }
                 
+                RoomChangeRolesScreenSection(members: context.viewState.visibleOwners,
+                                             role: .owner,
+                                             context: context)
+                
                 RoomChangeRolesScreenSection(members: context.viewState.visibleAdministrators,
-                                             title: L10n.screenRoomChangeRoleSectionAdministrators,
-                                             isAdministratorsSection: true,
+                                             role: .administrator,
                                              context: context)
                 RoomChangeRolesScreenSection(members: context.viewState.visibleModerators,
-                                             title: L10n.screenRoomChangeRoleSectionModerators,
+                                             role: .moderator,
                                              context: context)
                 RoomChangeRolesScreenSection(members: context.viewState.visibleUsers,
-                                             title: L10n.screenRoomChangeRoleSectionUsers,
+                                             role: .user,
                                              context: context)
             }
         }
@@ -65,10 +68,12 @@ struct RoomChangeRolesScreen: View {
             ScrollViewReader { scrollView in
                 HStack(spacing: 16) {
                     ForEach(context.viewState.membersWithRole, id: \.id) { member in
-                        RoomChangeRolesScreenSelectedItem(member: member, mediaProvider: context.mediaProvider) {
+                        let dismissAction = context.viewState.isMemberDisabled(member) ? nil : {
                             context.send(viewAction: .demoteMember(member))
                         }
-                        .frame(width: cellWidth)
+                        RoomChangeRolesScreenSelectedItem(member: member, mediaProvider: context.mediaProvider,
+                                                          dismissAction: dismissAction)
+                            .frame(width: cellWidth)
                     }
                 }
                 .onChange(of: context.viewState.lastPromotedMember) { _, newValue in
@@ -104,10 +109,22 @@ struct RoomChangeRolesScreen: View {
 // MARK: - Previews
 
 struct RoomChangeRolesScreen_Previews: PreviewProvider, TestablePreview {
-    static let administratorViewModel = makeViewModel(mode: .administrator)
-    static let moderatorViewModel = makeViewModel(mode: .moderator)
+    static let ownerViewModel = makeViewModel(mode: .owner, ownRole: .creator)
+    static let administratorOrOwnerViewModel = makeViewModel(mode: .administrator, ownRole: .creator)
+    static let administratorViewModel = makeViewModel(mode: .administrator, ownRole: .administrator)
+    static let moderatorViewModel = makeViewModel(mode: .moderator, ownRole: .administrator)
     
     static var previews: some View {
+        NavigationStack {
+            RoomChangeRolesScreen(context: ownerViewModel.context)
+        }
+        .previewDisplayName("Owners")
+        
+        NavigationStack {
+            RoomChangeRolesScreen(context: administratorOrOwnerViewModel.context)
+        }
+        .previewDisplayName("Administrator or Owners")
+        
         NavigationStack {
             RoomChangeRolesScreen(context: administratorViewModel.context)
         }
@@ -119,11 +136,18 @@ struct RoomChangeRolesScreen_Previews: PreviewProvider, TestablePreview {
         .previewDisplayName("Moderators")
     }
     
-    static func makeViewModel(mode: RoomMemberDetails.Role) -> RoomChangeRolesScreenViewModel {
-        RoomChangeRolesScreenViewModel(mode: mode,
-                                       roomProxy: JoinedRoomProxyMock(.init(members: .allMembersAsAdmin)),
-                                       mediaProvider: MediaProviderMock(configuration: .init()),
-                                       userIndicatorController: UserIndicatorControllerMock(),
-                                       analytics: ServiceLocator.shared.analytics)
+    static func makeViewModel(mode: RoomRole, ownRole: RoomRole) -> RoomChangeRolesScreenViewModel {
+        let members: [RoomMemberProxyMock] = switch ownRole {
+        case .creator:
+            .allMembersAsCreator
+        default:
+            .allMembersAsAdminV2
+        }
+        
+        return RoomChangeRolesScreenViewModel(mode: mode,
+                                              roomProxy: JoinedRoomProxyMock(.init(members: members)),
+                                              mediaProvider: MediaProviderMock(configuration: .init()),
+                                              userIndicatorController: UserIndicatorControllerMock(),
+                                              analytics: ServiceLocator.shared.analytics)
     }
 }

ElementX/Sources/Screens/RoomChangeRolesScreen/View/RoomChangeRolesScreenSection.swift

@@ -10,36 +10,46 @@ import SwiftUI
 
 struct RoomChangeRolesScreenSection: View {
     let members: [RoomMemberDetails]
-    let title: String
-    var isAdministratorsSection = false
+    let role: RoomRole
     
     let context: RoomChangeRolesScreenViewModel.Context
     
+    var title: String {
+        switch role {
+        case .creator, .owner:
+            L10n.screenRoomRolesAndPermissionsOwners
+        case .administrator:
+            L10n.screenRoomChangeRoleSectionAdministrators
+        case .moderator:
+            L10n.screenRoomChangeRoleSectionModerators
+        case .user:
+            L10n.screenRoomChangeRoleSectionUsers
+        }
+    }
+    
     var body: some View {
         if !members.isEmpty {
             Section {
                 ForEach(members, id: \.id) { member in
                     RoomChangeRolesScreenRow(member: member,
                                              mediaProvider: context.mediaProvider,
-                                             isSelected: isMemberSelected(member)) {
+                                             isSelected: context.viewState.isMemberSelected(member)) {
                         context.send(viewAction: .toggleMember(member))
                     }
-                    .disabled(member.role.isAdminOrHigher)
+                    .disabled(context.viewState.isMemberDisabled(member))
                 }
             } header: {
                 Text(title)
                     .compoundListSectionHeader()
             } footer: {
-                if isAdministratorsSection, context.viewState.mode == .moderator {
+                if role == .administrator, context.viewState.mode == .moderator {
                     Text(L10n.screenRoomChangeRoleModeratorsAdminSectionFooter)
                         .compoundListSectionFooter()
+                } else if role.isOwner, context.viewState.mode != .owner {
+                    Text(L10n.screenRoomChangeRoleModeratorsOwnerSectionFooter)
+                        .compoundListSectionFooter()
                 }
             }
         }
     }
-    
-    private func isMemberSelected(_ member: RoomMemberDetails) -> Bool {
-        // We always show administrators as selected, even on the moderators screen.
-        member.role.isAdminOrHigher || context.viewState.isMemberSelected(member)
-    }
 }

ElementX/Sources/Screens/RoomChangeRolesScreen/View/RoomChangeRolesScreenSelectedItem.swift

@@ -10,9 +10,22 @@ import SwiftUI
 struct RoomChangeRolesScreenSelectedItem: View {
     let member: RoomMemberDetails
     let mediaProvider: MediaProviderProtocol?
-    let dismissAction: () -> Void
+    let dismissAction: (() -> Void)?
     
     var body: some View {
+        mainContent
+            .accessibilityActions {
+                if let dismissAction {
+                    Button(L10n.actionDismiss) {
+                        dismissAction()
+                    }
+                }
+            }
+    }
+    
+    // MARK: - Private
+    
+    private var mainContent: some View {
         VStack(spacing: 4) {
             avatar
             
@@ -22,13 +35,8 @@ struct RoomChangeRolesScreenSelectedItem: View {
                 .lineLimit(1)
         }
         .accessibilityElement(children: .combine)
-        .accessibilityAction(named: L10n.actionDismiss) {
-            dismissAction()
-        }
     }
     
-    // MARK: - Private
-    
     var avatar: some View {
         LoadableAvatarImage(url: member.avatarURL,
                             name: member.name,
@@ -37,7 +45,7 @@ struct RoomChangeRolesScreenSelectedItem: View {
                             mediaProvider: mediaProvider)
             .accessibilityHidden(true)
             .overlay(alignment: .topTrailing) {
-                if member.role != .administrator {
+                if let dismissAction {
                     Button(action: dismissAction) {
                         Image(systemName: "xmark.circle.fill")
                             .resizable()