single space access implementation

also added the copies for the single and multiple spaces selection

ElementX/Sources/Screens/SecurityAndPrivacyScreen/SecurityAndPrivacyScreenViewModel.swift

@@ -37,7 +37,8 @@ class SecurityAndPrivacyScreenViewModel: SecurityAndPrivacyScreenViewModelType,
                                                                        isEncryptionEnabled: roomProxy.infoPublisher.value.isEncrypted,
                                                                        historyVisibility: roomProxy.infoPublisher.value.historyVisibility.toSecurityAndPrivacyHistoryVisibility,
                                                                        isSpace: roomProxy.infoPublisher.value.isSpace,
-                                                                       isKnockingEnabled: appSettings.knockingEnabled))
+                                                                       isKnockingEnabled: appSettings.knockingEnabled,
+                                                                       isSpaceSettingsEnabled: appSettings.spaceSettingsEnabled))
         
         if let powerLevels = roomProxy.infoPublisher.value.powerLevels {
             setupPermissions(powerLevels: powerLevels)
@@ -45,6 +46,14 @@ class SecurityAndPrivacyScreenViewModel: SecurityAndPrivacyScreenViewModelType,
         
         setupRoomDirectoryVisibility()
         setupSubscriptions()
+        Task {
+            switch await clientProxy.spaceService.joinedParents(roomID: roomProxy.id) {
+            case .success(let joinedParentSpaces):
+                state.joinedParentSpaces = joinedParentSpaces
+            case .failure:
+                break
+            }
+        }
     }
     
     // MARK: - Public
@@ -69,6 +78,11 @@ class SecurityAndPrivacyScreenViewModel: SecurityAndPrivacyScreenViewModelType,
             }
         case .editAddress:
             actionsSubject.send(.displayEditAddressScreen)
+        case .selectedSpaceMembersAccess:
+            handleSelectedSpaceMembersAccess()
+        case .manageSpaces:
+            // TODO: Implement multiple space selection
+            break
         }
     }
     
@@ -127,6 +141,10 @@ class SecurityAndPrivacyScreenViewModel: SecurityAndPrivacyScreenViewModelType,
         appSettings.$knockingEnabled
             .weakAssign(to: \.state.isKnockingEnabled, on: self)
             .store(in: &cancellables)
+        
+        appSettings.$spaceSettingsEnabled
+            .weakAssign(to: \.state.isSpaceSettingsEnabled, on: self)
+            .store(in: &cancellables)
     }
     
     private func setupPermissions(powerLevels: RoomPowerLevelsProxyProtocol) {
@@ -202,6 +220,18 @@ class SecurityAndPrivacyScreenViewModel: SecurityAndPrivacyScreenViewModelType,
         }
     }
     
+    private func handleSelectedSpaceMembersAccess() {
+        switch context.viewState.spaceSelection {
+        case .singleJoined(let joinedParent):
+            context.desiredSettings.accessType = .spaceUsers(spaceIDs: [joinedParent.id])
+        case .singleUnknown(let id):
+            context.desiredSettings.accessType = .spaceUsers(spaceIDs: [id])
+        case .multiple:
+            // TODO: Implement multiple space selection
+            break
+        }
+    }
+    
     private static let loadingIndicatorIdentifier = "\(EditRoomAddressScreenViewModel.self)-Loading"
     
     private func showLoadingIndicator() {
@@ -225,25 +255,10 @@ private extension SecurityAndPrivacyRoomAccessType {
             .knock
         case .anyone:
             .public
-        case .spaceUsers:
-            fatalError("The user shouldn't be able to select this rule")
-        }
-    }
-}
-
-private extension Optional where Wrapped == JoinRule {
-    var toSecurityAndPrivacyRoomAccessType: SecurityAndPrivacyRoomAccessType {
-        switch self {
-        case .none, .public:
-            return .anyone
-        case .invite:
-            return .inviteOnly
-        case .knock, .knockRestricted:
-            return .askToJoin
-        case .restricted:
-            return .spaceUsers
-        default:
-            return .inviteOnly
+        case .spaceUsers(let spaceIDs):
+            .restricted(rules: spaceIDs.map { .roomMembership(roomId: $0) })
+        case .askToJoinWithSpaceUsers(let spaceIDs):
+            .knockRestricted(rules: spaceIDs.map { .roomMembership(roomId: $0) })
         }
     }
 }
@@ -273,3 +288,28 @@ private extension SecurityAndPrivacyHistoryVisibility {
         }
     }
 }
+
+private extension Optional where Wrapped == JoinRule {
+    var toSecurityAndPrivacyRoomAccessType: SecurityAndPrivacyRoomAccessType {
+        switch self {
+        case .none, .public:
+            return .anyone
+        case .invite:
+            return .inviteOnly
+        case .knock, .knockRestricted:
+            // TODO: Handle knock restricted with rules
+            return .askToJoin
+        case .restricted(let rules):
+            let spaceIDs = rules.compactMap { rule in
+                if case let .roomMembership(id) = rule {
+                    id
+                } else {
+                    nil
+                }
+            }
+            return .spaceUsers(spaceIDs: spaceIDs)
+        default:
+            return .inviteOnly
+        }
+    }
+}