Jetpack REST connection: connect site and user

WordPress/src/main/java/org/wordpress/android/ui/jetpackrestconnection/JetpackConnectionHelper.kt

@@ -0,0 +1,72 @@
+package org.wordpress.android.ui.jetpackrestconnection
+
+import org.wordpress.android.fluxc.model.SiteModel
+import org.wordpress.android.fluxc.utils.AppLogWrapper
+import org.wordpress.android.util.AppLog
+import rs.wordpress.api.kotlin.WpApiClient
+import rs.wordpress.api.kotlin.WpRequestExecutor
+import uniffi.wp_api.JetpackConnectionClient
+import uniffi.wp_api.ParsedUrl
+import uniffi.wp_api.WpApiClientDelegate
+import uniffi.wp_api.WpApiMiddlewarePipeline
+import uniffi.wp_api.WpAppNotifier
+import uniffi.wp_api.WpAuthenticationProvider
+import java.net.URL
+import javax.inject.Inject
+
+class JetpackConnectionHelper @Inject constructor(
+    private val appLogWrapper: AppLogWrapper
+) {
+    fun initWpApiClient(site: SiteModel): WpApiClient {
+        requireRestCredentials(site)
+        return WpApiClient(
+            wpOrgSiteApiRootUrl = URL(resolveRestApiUrl(site)),
+            authProvider = createRestAuthProvider(site)
+        )
+    }
+
+    fun initJetpackConnectionClient(site: SiteModel): JetpackConnectionClient {
+        requireRestCredentials(site)
+
+        val delegate = WpApiClientDelegate(
+            authProvider = createRestAuthProvider(site),
+            requestExecutor = WpRequestExecutor(),
+            middlewarePipeline = WpApiMiddlewarePipeline(emptyList()),
+            appNotifier = InvalidAuthNotifier()
+        )
+
+        return JetpackConnectionClient(
+            apiRootUrl = ParsedUrl.parse(resolveRestApiUrl(site)),
+            delegate = delegate
+        )
+    }
+
+    private fun createRestAuthProvider(site: SiteModel) =
+        WpAuthenticationProvider.staticWithUsernameAndPassword(
+            site.apiRestUsernamePlain!!,
+            site.apiRestPasswordPlain!!
+        )
+
+    private fun requireRestCredentials(site: SiteModel) {
+        require(!site.apiRestUsernamePlain.isNullOrBlank()) {
+            "API username is required"
+        }
+        require(!site.apiRestPasswordPlain.isNullOrBlank()) {
+            "API password is required"
+        }
+    }
+
+    private fun resolveRestApiUrl(site: SiteModel) =
+        site.wpApiRestUrl ?: "${site.url}/wp-json"
+
+    private inner class InvalidAuthNotifier : WpAppNotifier {
+        override suspend fun requestedWithInvalidAuthentication() {
+            appLogWrapper.d(AppLog.T.API, "$TAG: requestedWithInvalidAuthentication")
+            throw IllegalArgumentException("Invalid credentials")
+        }
+    }
+
+    companion object {
+        private const val TAG = "JetpackConnectionHelper"
+    }
+}

WordPress/src/main/java/org/wordpress/android/ui/jetpackrestconnection/JetpackConnector.kt

@@ -0,0 +1,41 @@
+package org.wordpress.android.ui.jetpackrestconnection
+
+import org.wordpress.android.fluxc.model.SiteModel
+import uniffi.wp_api.WpAuthentication
+import uniffi.wp_api.WpComSiteId
+import javax.inject.Inject
+
+class JetpackConnector @Inject constructor(
+    private val jetpackConnectionHelper: JetpackConnectionHelper
+) {
+    /**
+     * Connects the Jetpack site to WordPress.com and returns the site ID
+     */
+    suspend fun connectSite(site: SiteModel): Result<WpComSiteId> = runCatching {
+        val client = jetpackConnectionHelper.initJetpackConnectionClient(site)
+        val wpComSiteId = client.connectSite(CONNECT_FROM)
+        requireValidSiteId(wpComSiteId)
+    }
+
+    /**
+     * Connects the Jetpack user to WordPress.com and returns the site ID
+     */
+    suspend fun connectUser(site: SiteModel, accessToken: String): Result<WpComSiteId> = runCatching {
+        val client = jetpackConnectionHelper.initJetpackConnectionClient(site)
+        val wpComAuthentication = WpAuthentication.Bearer(token = accessToken)
+        val wpComSiteId = client.connectUser(
+            wpComAuthentication = wpComAuthentication,
+            from = CONNECT_FROM
+        )
+        requireValidSiteId(wpComSiteId)
+    }
+
+    private fun requireValidSiteId(wpComSiteId: WpComSiteId): WpComSiteId {
+        require(wpComSiteId > 0UL) { "Jetpack connection failed, no site ID returned" }
+        return wpComSiteId
+    }
+
+    companion object {
+        const val CONNECT_FROM = "jetpack-android-app"
+    }
+}

WordPress/src/main/java/org/wordpress/android/ui/jetpackrestconnection/JetpackInstaller.kt

@@ -11,25 +11,19 @@ import uniffi.wp_api.PluginSlug
 import uniffi.wp_api.PluginStatus
 import uniffi.wp_api.PluginUpdateParams
 import uniffi.wp_api.PluginWpOrgDirectorySlug
-import uniffi.wp_api.WpAuthenticationProvider
-import java.net.URL
 import javax.inject.Inject
 
 /**
  * Installs the Jetpack plugin on the given site using wordpress-rs
  */
 class JetpackInstaller @Inject constructor(
+    private val jetpackConnectionHelper: JetpackConnectionHelper,
     private val appLogWrapper: AppLogWrapper,
 ) {
     @Suppress("TooGenericExceptionCaught")
     suspend fun installJetpack(site: SiteModel): Result<PluginStatus> {
-        if (!validateCredentials(site)) {
-            return Result.failure(IllegalArgumentException("Missing credentials for Jetpack installation"))
-        }
-
-        val apiClient = initApiClient(site)
-
         return try {
+            val apiClient = jetpackConnectionHelper.initWpApiClient(site)
             val info = getPluginInfo(apiClient)
             when (info?.status) {
                 PluginStatus.ACTIVE, PluginStatus.NETWORK_ACTIVE -> {
@@ -56,20 +50,6 @@ class JetpackInstaller @Inject constructor(
         }
     }
 
-    private fun validateCredentials(site: SiteModel): Boolean {
-        return !site.apiRestUsernamePlain.isNullOrBlank() && !site.apiRestPasswordPlain.isNullOrBlank()
-    }
-
-    private fun initApiClient(site: SiteModel): WpApiClient {
-        return WpApiClient(
-            wpOrgSiteApiRootUrl = URL(site.wpApiRestUrl),
-            authProvider = WpAuthenticationProvider.staticWithUsernameAndPassword(
-                site.apiRestUsernamePlain!!,
-                site.apiRestPasswordPlain!!
-            )
-        )
-    }
-
     private suspend fun getPluginInfo(apiClient: WpApiClient): PluginInfo? {
         val response = apiClient.request { requestBuilder ->
             requestBuilder.plugins().listWithEditContext(

WordPress/src/main/java/org/wordpress/android/ui/jetpackrestconnection/JetpackRestConnectionScreen.kt

@@ -26,7 +26,7 @@ import androidx.compose.material.icons.filled.Build
 import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.filled.CheckCircle
 import androidx.compose.material.icons.filled.Home
-import androidx.compose.material.icons.filled.Settings
+import androidx.compose.material.icons.filled.Person
 import androidx.compose.material.icons.filled.Warning
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.Icon
@@ -148,9 +148,9 @@ private val stepConfigs = listOf(
         icon = Icons.Default.Home
     ),
     StepConfig(
-        step = ConnectionStep.ConnectWpCom,
-        titleRes = R.string.jetpack_rest_connection_step_connect_wpcom,
-        icon = Icons.Default.Settings
+        step = ConnectionStep.ConnectUser,
+        titleRes = R.string.jetpack_rest_connection_step_connect_user,
+        icon = Icons.Default.Person
     ),
     StepConfig(
         step = ConnectionStep.Finalize,
@@ -270,9 +270,12 @@ private fun getErrorText(context: Context, errorType: ErrorType): String {
         ErrorType.LoginWpComFailed -> R.string.jetpack_rest_connection_error_login_wpcom
         ErrorType.ConnectWpComFailed -> R.string.jetpack_rest_connection_error_connect_wpcom
         ErrorType.InstallJetpackInactive -> R.string.jetpack_rest_connection_error_install_jetpack_inactive
-        is ErrorType.InstallJetpackFailed -> R.string.jetpack_rest_connection_error_install_jetpack
-        is ErrorType.Timeout -> R.string.jetpack_rest_connection_error_timeout
-        is ErrorType.Offline -> R.string.jetpack_rest_connection_error_offline
+        ErrorType.ConnectUserFailed -> R.string.jetpack_rest_connection_error_connect_user
+        ErrorType.MissingAccessToken -> R.string.jetpack_rest_connection_error_access_token
+        ErrorType.ConnectSiteFailed -> R.string.jetpack_rest_connection_error_connect_site
+        ErrorType.InstallJetpackFailed -> R.string.jetpack_rest_connection_error_install_jetpack
+        ErrorType.Timeout -> R.string.jetpack_rest_connection_error_timeout
+        ErrorType.Offline -> R.string.jetpack_rest_connection_error_offline
         is ErrorType.Unknown -> R.string.jetpack_rest_connection_error_unknown
     }
     val baseMessage = context.getString(messageRes)
@@ -421,7 +424,7 @@ private fun JetpackRestConnectionScreenPreview() {
                 ConnectionStep.LoginWpCom to StepState(ConnectionStatus.Completed),
                 ConnectionStep.InstallJetpack to StepState(ConnectionStatus.Completed),
                 ConnectionStep.ConnectSite to StepState(ConnectionStatus.InProgress),
-                ConnectionStep.ConnectWpCom to StepState(
+                ConnectionStep.ConnectUser to StepState(
                     ConnectionStatus.Failed,
                     ErrorType.ConnectWpComFailed
                 ),

WordPress/src/main/java/org/wordpress/android/ui/jetpackrestconnection/JetpackRestConnectionViewModel.kt

@@ -28,6 +28,7 @@ class JetpackRestConnectionViewModel @Inject constructor(
     private val selectedSiteRepository: SelectedSiteRepository,
     private val accountStore: AccountStore,
     private val jetpackInstaller: JetpackInstaller,
+    private val jetpackConnector: JetpackConnector,
     private val appLogWrapper: AppLogWrapper,
 ) : ScopedViewModel(mainDispatcher) {
     private val _currentStep = MutableStateFlow<ConnectionStep?>(null)
@@ -39,11 +40,6 @@ class JetpackRestConnectionViewModel @Inject constructor(
     private val _buttonType = MutableStateFlow<ButtonType?>(ButtonType.Start)
     val buttonType = _buttonType
 
-    data class StepState(
-        val status: ConnectionStatus = ConnectionStatus.NotStarted,
-        val errorType: ErrorType? = null,
-    )
-
     private val _stepStates = MutableStateFlow(initialStepStates)
     val stepStates = _stepStates
 
@@ -68,7 +64,6 @@ class JetpackRestConnectionViewModel @Inject constructor(
      */
     private fun onJobCompleted() {
         appLogWrapper.d(AppLog.T.API, "$TAG: Jetpack connection job completed")
-        job?.cancel()
         _buttonType.value = ButtonType.Done
         _currentStep.value = null
     }
@@ -77,8 +72,8 @@ class JetpackRestConnectionViewModel @Inject constructor(
         null -> ConnectionStep.LoginWpCom
         ConnectionStep.LoginWpCom -> ConnectionStep.InstallJetpack
         ConnectionStep.InstallJetpack -> ConnectionStep.ConnectSite
-        ConnectionStep.ConnectSite -> ConnectionStep.ConnectWpCom
-        ConnectionStep.ConnectWpCom -> ConnectionStep.Finalize
+        ConnectionStep.ConnectSite -> ConnectionStep.ConnectUser
+        ConnectionStep.ConnectUser -> ConnectionStep.Finalize
         ConnectionStep.Finalize -> null
     }
 
@@ -238,7 +233,7 @@ class JetpackRestConnectionViewModel @Inject constructor(
         } catch (e: Exception) {
             appLogWrapper.e(AppLog.T.API, "$TAG: Error in step $step: ${e.message}")
             val errorType = when (e) {
-                is TimeoutCancellationException -> ErrorType.Timeout(e.message)
+                is TimeoutCancellationException -> ErrorType.Timeout
                 else -> ErrorType.Unknown(e.message)
             }
             updateStepStatus(
@@ -262,12 +257,12 @@ class JetpackRestConnectionViewModel @Inject constructor(
 
             ConnectionStep.ConnectSite -> {
                 appLogWrapper.d(AppLog.T.API, "$TAG: Connecting site")
-                // TODO
+                connectSite()
             }
 
-            ConnectionStep.ConnectWpCom -> {
+            ConnectionStep.ConnectUser -> {
                 appLogWrapper.d(AppLog.T.API, "$TAG: Connecting WordPress.com user")
-                // TODO
+                connectUser()
             }
 
             ConnectionStep.Finalize -> {
@@ -334,6 +329,7 @@ class JetpackRestConnectionViewModel @Inject constructor(
                             status = ConnectionStatus.Completed
                         )
                     }
+
                     PluginStatus.INACTIVE -> {
                         updateStepStatus(
                             step = ConnectionStep.InstallJetpack,
@@ -353,6 +349,61 @@ class JetpackRestConnectionViewModel @Inject constructor(
         )
     }
 
+    /**
+     * Connects the current site to Jetpack
+     */
+    private suspend fun connectSite() {
+        val result = jetpackConnector.connectSite(getSite())
+        result.fold(
+            onSuccess = {
+                updateStepStatus(
+                    step = ConnectionStep.ConnectSite,
+                    status = ConnectionStatus.Completed
+                )
+            },
+            onFailure = {
+                updateStepStatus(
+                    step = ConnectionStep.ConnectSite,
+                    status = ConnectionStatus.Failed,
+                    error = ErrorType.ConnectSiteFailed
+                )
+            }
+        )
+    }
+
+    /**
+     * Connects the user to the current site to Jetpack
+     */
+    private suspend fun connectUser() {
+        if (!accountStore.hasAccessToken()) {
+            updateStepStatus(
+                step = ConnectionStep.ConnectUser,
+                status = ConnectionStatus.Failed,
+                error = ErrorType.MissingAccessToken
+            )
+            return
+        }
+        val result = jetpackConnector.connectUser(
+            site = getSite(),
+            accessToken = accountStore.accessToken!!
+        )
+        result.fold(
+            onSuccess = {
+                updateStepStatus(
+                    step = ConnectionStep.ConnectUser,
+                    status = ConnectionStatus.Completed
+                )
+            },
+            onFailure = {
+                updateStepStatus(
+                    step = ConnectionStep.ConnectUser,
+                    status = ConnectionStatus.Failed,
+                    error = ErrorType.ConnectUserFailed
+                )
+            }
+        )
+    }
+
     /**
      * Gets the current site from the store
      */
@@ -363,7 +414,7 @@ class JetpackRestConnectionViewModel @Inject constructor(
         data object LoginWpCom : ConnectionStep()
         data object InstallJetpack : ConnectionStep()
         data object ConnectSite : ConnectionStep()
-        data object ConnectWpCom : ConnectionStep()
+        data object ConnectUser : ConnectionStep()
         data object Finalize : ConnectionStep()
     }
 
@@ -385,8 +436,11 @@ class JetpackRestConnectionViewModel @Inject constructor(
         data object InstallJetpackFailed : ErrorType()
         data object InstallJetpackInactive : ErrorType()
         data object ConnectWpComFailed : ErrorType()
-        data class Timeout(override val message: String? = null) : ErrorType(message)
-        data class Offline(override val message: String? = null) : ErrorType(message)
+        data object ConnectSiteFailed : ErrorType()
+        data object ConnectUserFailed : ErrorType()
+        data object MissingAccessToken : ErrorType()
+        data object Timeout : ErrorType()
+        data object Offline : ErrorType()
         data class Unknown(override val message: String? = null) : ErrorType(message)
     }
 
@@ -396,6 +450,11 @@ class JetpackRestConnectionViewModel @Inject constructor(
         data object Retry : ButtonType()
     }
 
+    data class StepState(
+        val status: ConnectionStatus = ConnectionStatus.NotStarted,
+        val errorType: ErrorType? = null,
+    )
+
     companion object {
         private const val TAG = "JetpackRestConnectionViewModel"
         private const val LIMIT_VERSION = "14.2"
@@ -419,7 +478,7 @@ class JetpackRestConnectionViewModel @Inject constructor(
             ConnectionStep.LoginWpCom to StepState(),
             ConnectionStep.InstallJetpack to StepState(),
             ConnectionStep.ConnectSite to StepState(),
-            ConnectionStep.ConnectWpCom to StepState(),
+            ConnectionStep.ConnectUser to StepState(),
             ConnectionStep.Finalize to StepState()
         )
     }