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

feature/activate/build.gradle.kts

@@ -23,6 +23,7 @@ kotlin {
             implementation(compose.components.resources)
             implementation(compose.ui)
             implementation(projects.core.domain)
+            implementation(projects.coreBase.store)
             implementation(compose.components.uiToolingPreview)
         }
     }

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

@@ -25,9 +25,14 @@ 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
+import template.core.base.store.submit.SubmitState
+import template.core.base.store.submit.submitHandler
 
 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
         }
+    }
 }