feat(feature/activate): migrate ActivateViewModel to SubmitHandler<Unit>

Replaces manual DataState collection with template.core.base.store's
SubmitHandler — a one-shot, idempotent submission executor with built-in
Submitting / Submitted / Failed lifecycle and automatic cancel-prior-job
semantics for sequential calls.

VM:
  - Single SubmitHandler<Unit> instead of three viewModelScope.launch blocks
  - submit.state mapped to existing ActivateUiState via .map.stateIn so
    Screen-side state shape (Initial / Loading / ActivatedSuccessfully /
    Error) is unchanged — no Screen changes required
  - Per-action success/failure StringResource tracked in two vars set
    before each submit; safe because they're written synchronously with
    submit.submit { ... } and only read when state transitions to a
    terminal value
  - ActivateClientUseCase / ActivateCenterUseCase (Flow<DataState<T>>)
    bridged via .first { it !is DataState.Loading } + throw on Error
  - ActivateGroupUseCase (suspend, returns DataState<Unit> directly) just
    checks for Error and throws

build.gradle.kts:
  + implementation(projects.coreBase.store)

This is the migration template for all subsequent mutation-feature
migrations (auth, savings, recurringDeposit, note, checker-inbox-task,
collectionSheet, report, document, loan, client). Each follows the same
shape: introduce a SubmitHandler<R> in the VM, map its state to the
feature's existing UiState, bridge use-case return shapes through
SubmitHandler.submit { ... }, leave the Screen untouched.

Author: Rajan Maurya

core/data/build.gradle.kts

@@ -40,7 +40,7 @@ kotlin {
             api(projects.core.network)
             api(projects.core.database)
             api(projects.coreBase.common)
-            api(projects.coreBase.store)
+            api(projects.core.store)
 
 
             implementation(libs.mifos.authenticator.passcode)

core/data/src/commonMain/kotlin/com/mifos/core/data/store/SubmitTypes.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2025 Mifos Initiative
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * See https://github.com/openMF/mifos-x-field-officer-app/blob/master/LICENSE.md
+ */
+package com.mifos.core.data.store
+
+import kotlinx.coroutines.CoroutineScope
+
+/**
+ * App-facing re-exports of the offline-first submission primitives.
+ *
+ * Feature modules import these from `com.mifos.core.data.store` and never reach into
+ * `template.core.base.store.*` directly. The dependency direction is enforced:
+ *   core-base/store → core/store → core/data → feature/*
+ */
+
+typealias SubmitHandler<R> = template.core.base.store.submit.SubmitHandler<R>
+typealias SubmitState<R> = template.core.base.store.submit.SubmitState<R>
+
+/** Creates a [SubmitHandler] bound to this [CoroutineScope] (typically `viewModelScope`). */
+fun <R> CoroutineScope.submitHandler(): SubmitHandler<R> =
+    template.core.base.store.submit.submitHandler()

feature/activate/build.gradle.kts

@@ -22,6 +22,7 @@ kotlin {
             implementation(compose.material3)
             implementation(compose.components.resources)
             implementation(compose.ui)
+            implementation(projects.core.data)
             implementation(projects.core.domain)
             implementation(compose.components.uiToolingPreview)
         }

feature/activate/src/commonMain/kotlin/com/mifos/feature/activate/ActivateViewModel.kt

@@ -21,13 +21,18 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import androidx.navigation.toRoute
 import com.mifos.core.common.utils.DataState
+import com.mifos.core.data.store.SubmitState
+import com.mifos.core.data.store.submitHandler
 import com.mifos.core.domain.useCases.ActivateCenterUseCase
 import com.mifos.core.domain.useCases.ActivateClientUseCase
 import com.mifos.core.domain.useCases.ActivateGroupUseCase
 import com.mifos.core.model.objects.clients.ActivatePayload
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import org.jetbrains.compose.resources.StringResource
 
 class ActivateViewModel(
     private val activateClientUseCase: ActivateClientUseCase,
@@ -39,56 +44,51 @@ class ActivateViewModel(
     val id = savedStateHandle.toRoute<ActivateRoute>().id
     val activateType = savedStateHandle.toRoute<ActivateRoute>().type
 
-    private val _activateUiState = MutableStateFlow<ActivateUiState>(ActivateUiState.Initial)
-    val activateUiState = _activateUiState.asStateFlow()
+    private val submit = viewModelScope.submitHandler<Unit>()
+    private var successMessage: StringResource = Res.string.feature_activate_client
+    private var failureMessage: StringResource = Res.string.feature_activate_failed_to_activate_client
 
-    fun activateClient(clientId: Int, clientPayload: ActivatePayload) =
-        viewModelScope.launch {
-            activateClientUseCase(clientId, clientPayload).collect { result ->
-                when (result) {
-                    is DataState.Error ->
-                        _activateUiState.value =
-                            ActivateUiState.Error(Res.string.feature_activate_failed_to_activate_client)
-
-                    is DataState.Loading -> _activateUiState.value = ActivateUiState.Loading
-
-                    is DataState.Success ->
-                        _activateUiState.value =
-                            ActivateUiState.ActivatedSuccessfully(Res.string.feature_activate_client)
-                }
+    val activateUiState: StateFlow<ActivateUiState> = submit.state
+        .map { state ->
+            when (state) {
+                is SubmitState.Idle -> ActivateUiState.Initial
+                is SubmitState.Submitting -> ActivateUiState.Loading
+                is SubmitState.Submitted<*> -> ActivateUiState.ActivatedSuccessfully(successMessage)
+                is SubmitState.Failed -> ActivateUiState.Error(failureMessage)
             }
         }
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.Eagerly,
+            initialValue = ActivateUiState.Initial,
+        )
 
-    fun activateCenter(centerId: Int, centerPayload: ActivatePayload) =
-        viewModelScope.launch {
-            activateCenterUseCase(centerId, centerPayload).collect { result ->
-                when (result) {
-                    is DataState.Error ->
-                        _activateUiState.value =
-                            ActivateUiState.Error(Res.string.feature_activate_failed_to_activate_center)
-
-                    is DataState.Loading -> _activateUiState.value = ActivateUiState.Loading
-
-                    is DataState.Success ->
-                        _activateUiState.value =
-                            ActivateUiState.ActivatedSuccessfully(Res.string.feature_activate_center)
-                }
-            }
+    fun activateClient(clientId: Int, clientPayload: ActivatePayload) {
+        successMessage = Res.string.feature_activate_client
+        failureMessage = Res.string.feature_activate_failed_to_activate_client
+        submit.submit {
+            val terminal = activateClientUseCase(clientId, clientPayload)
+                .first { it !is DataState.Loading }
+            if (terminal is DataState.Error) throw terminal.exception
         }
+    }
 
-    fun activateGroup(groupId: Int, groupPayload: ActivatePayload) =
-        viewModelScope.launch {
-            val result = activateGroupUseCase(groupId, groupPayload)
-            when (result) {
-                is DataState.Error ->
-                    _activateUiState.value =
-                        ActivateUiState.Error(Res.string.feature_activate_failed_to_activate_group)
-
-                DataState.Loading -> Unit // unreachable
+    fun activateCenter(centerId: Int, centerPayload: ActivatePayload) {
+        successMessage = Res.string.feature_activate_center
+        failureMessage = Res.string.feature_activate_failed_to_activate_center
+        submit.submit {
+            val terminal = activateCenterUseCase(centerId, centerPayload)
+                .first { it !is DataState.Loading }
+            if (terminal is DataState.Error) throw terminal.exception
+        }
+    }
 
-                is DataState.Success ->
-                    _activateUiState.value =
-                        ActivateUiState.ActivatedSuccessfully(Res.string.feature_activate_group)
-            }
+    fun activateGroup(groupId: Int, groupPayload: ActivatePayload) {
+        successMessage = Res.string.feature_activate_group
+        failureMessage = Res.string.feature_activate_failed_to_activate_group
+        submit.submit {
+            val terminal = activateGroupUseCase(groupId, groupPayload)
+            if (terminal is DataState.Error) throw terminal.exception
         }
+    }
 }