Privacy: IS Settings: Add an IS

2026-04-21 17:12:45 +02:00 · 2019-09-25 14:32:55 +02:00
parent 74f111b34e
commit 9ed6f05fd1
6 changed files with 108 additions and 26 deletions
@@ -50,6 +50,8 @@ final class SettingsIdentityServerViewController: UIViewController {
    
    private var displayMode: SettingsIdentityServerDisplayMode?

+    private weak var alertController: UIAlertController?
+
    // MARK: - Setup
    
    class func instantiate(with viewModel: SettingsIdentityServerViewModelType) -> SettingsIdentityServerViewController {
@@ -149,6 +151,8 @@ final class SettingsIdentityServerViewController: UIViewController {
            self.renderLoading()
        case .loaded(let displayMode):
            self.renderLoaded(displayMode: displayMode)
+        case .alert(let alert, let onContinue):
+            self.renderAlert(alert: alert, onContinue: onContinue)
        case .error(let error):
            self.render(error: error)
        }
@@ -195,16 +199,54 @@ final class SettingsIdentityServerViewController: UIViewController {
        self.disconnectMessageLabel.isHidden = false
        self.disconnectButtonContainer.isHidden = false
    }
-    
+
+    private func renderAlert(alert: SettingsIdentityServerAlert, onContinue: @escaping () -> Void) {
+        self.activityPresenter.removeCurrentActivityIndicator(animated: true)
+        
+        switch alert {
+        case .addActionAlert(.noTerms):
+            self.showAlert(title: VectorL10n.identityServerSettingsAlertNoTermsTitle,
+                           message: VectorL10n.identityServerSettingsAlertNoTerms,
+                           continueButtonTitle: VectorL10n.continue,
+                           cancelButtonTitle: VectorL10n.cancel,
+                           onContinue: onContinue)
+        }
+
+    }
+
    private func render(error: Error) {
        self.activityPresenter.removeCurrentActivityIndicator(animated: true)
        self.errorPresenter.presentError(from: self, forError: error, animated: true, handler: nil)
    }

-    func presentExistingIdentityServerDataAlert(with title: String) {
-        
+
+    // MARK: - Alert
+
+    private func showAlert(title: String, message: String, continueButtonTitle: String, cancelButtonTitle: String, onContinue: @escaping () -> Void) {
+        guard self.alertController == nil else {
+            return
+        }
+
+        let alertController = UIAlertController(title: title,
+                                                message: message,
+                                                preferredStyle: .alert)
+
+        alertController.addAction(UIAlertAction(title: cancelButtonTitle, style: .cancel, handler: { action in
+        }))
+
+        alertController.addAction(UIAlertAction(title: continueButtonTitle, style: .default, handler: { action in
+            onContinue()
+        }))
+
+        self.present(alertController, animated: true, completion: nil)
+        self.alertController = alertController
    }
-    
+
+    private func hideAlert(animated: Bool) {
+        self.alertController?.dismiss(animated: true, completion: nil)
+    }
+
+
    // MARK: - Actions

    @objc private func identityServerTextFieldDidChange(_ textField: UITextField) {
@@ -86,12 +86,15 @@ final class SettingsIdentityServerViewModel: SettingsIdentityServerViewModelType
                switch identityServerValidity {
                case .invalid:
                    // Present invalid IS alert
+                    // TODO but how to detect it?
                    break
                case .valid(status: let termsStatus):
                    switch termsStatus {
                    case .noTerms:
-                        // Present no terms alert
-                        break
+                        self.update(viewState: .alert(alert: SettingsIdentityServerAlert.addActionAlert(.noTerms(newHost: newIdentityServer)), onContinue: {
+                            self.update(viewState: .loading)
+                            self.updateAccountDataAndRefreshViewState(with: newIdentityServer)
+                        }))
                    case .terms(agreed: let termsAgreed):
                        if termsAgreed {
                            self.updateAccountDataAndRefreshViewState(with: newIdentityServer)
@@ -116,6 +119,9 @@ final class SettingsIdentityServerViewModel: SettingsIdentityServerViewModelType
    }
    
    private func updateAccountDataAndRefreshViewState(with identityServer: String) {
+        // TODO: We should get a token in intermediate step
+        self.session.setIdentityServer(identityServer, andAccessToken: nil)
+
        self.session.setAccountDataIdentityServer(identityServer, success: {
            self.refreshIdentityServerViewState()
        }, failure: { error in
@@ -182,31 +188,37 @@ final class SettingsIdentityServerViewModel: SettingsIdentityServerViewModelType
        let restClient: MXRestClient = self.session.matrixRestClient
        
        let identityService = MXIdentityService(identityServer: identityServerURL, accessToken: nil, homeserverRestClient: restClient)
-        
-        identityService.accessToken { response in
+
+        // First, check the server
+        identityService.pingIdentityServer { response in
+            self.validationIdentityService = nil
+
            switch response {
-            case .success(let accessToken):
-                let serviceTerms = MXServiceTerms(baseUrl: identityService.identityServer, serviceType: MXServiceTypeIdentityService, matrixSession: self.session, accessToken: accessToken)
-                
-                serviceTerms.areAllTermsAgreed({ (areAllTermsAgreed) in
-                    
-                    completion(.success(IdentityServerValidity.valid(status: .terms(agreed: areAllTermsAgreed))))
-                    
+            case .success:
+                // Them, check if there are terms to accept
+                let serviceTerms = MXServiceTerms(baseUrl: identityService.identityServer, serviceType: MXServiceTypeIdentityService, matrixSession: self.session, accessToken: nil)
+
+                serviceTerms.areAllTermsAgreed({ (agreedTermsProgress) in
+                    self.validationServiceTerms = nil
+
+                    if agreedTermsProgress.totalUnitCount == 0 {
+                        completion(.success(IdentityServerValidity.valid(status: .noTerms)))
+                    } else {
+                        completion(.success(IdentityServerValidity.valid(status: .terms(agreed: agreedTermsProgress.isFinished))))
+                    }
+
+                }, failure: { (error) in
                    self.validationServiceTerms = nil
-                }, failure: { error in
                    completion(.failure(error))
-                    self.validationServiceTerms = nil
                })
-                
+
                self.validationServiceTerms = serviceTerms
-                
+
            case .failure(let error):
                completion(.failure(error))
            }
-            
-            self.validationIdentityService = nil
        }
-        
+
        self.validationIdentityService = identityService
    }
    
@@ -22,6 +22,7 @@ import Foundation
 enum SettingsIdentityServerViewState {
    case loading
    case loaded(displayMode: SettingsIdentityServerDisplayMode)
+    case alert(alert: SettingsIdentityServerAlert, onContinue: () -> Void)
    case error(Error)
 }

@@ -29,3 +30,20 @@ enum SettingsIdentityServerDisplayMode {
    case noIdentityServer
    case identityServer(host: String)
 }
+
+enum SettingsIdentityServerAlert {
+    case addActionAlert(AddActionAlert)
+    enum AddActionAlert {
+        case noTerms(newHost: String)
+    }
+
+//    enum ChangeActionAlert {
+//        case stillSharing3Pids(oldHost: String, newHost: String)
+//        case doubleConfirmation(oldHost: String, newHost: String)
+//        case noTerms(newHost: String)
+//    }
+//    enum DisconnectActionAlert {
+//        case stillSharing3Pids(oldHost: String)
+//        case doubleConfirmation(oldHost: String)
+//    }
+}