Writeopia · leandroBorgesFerreira · Jan 31, 2026 · Jan 31, 2026 · Jan 31, 2026
diff --git a/application/composeApp/build.gradle.kts b/application/composeApp/build.gradle.kts
@@ -176,8 +176,8 @@ android {
         applicationId = "io.writeopia"
         minSdk = libs.versions.minSdk.get().toInt()
         targetSdk = libs.versions.targetSdk.get().toInt()
-        versionCode = 57
-        versionName = "0.44.0"
+        versionCode = 60
+        versionName = "0.47.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

diff --git a/...n/core/auth_core/src/commonMain/kotlin/io/writeopia/auth/core/manager/WorkspaceHandler.kt b/...n/core/auth_core/src/commonMain/kotlin/io/writeopia/auth/core/manager/WorkspaceHandler.kt
@@ -0,0 +1,33 @@
+package io.writeopia.auth.core.manager
+
+import io.writeopia.sdk.models.utils.ResultData
+import io.writeopia.sdk.models.workspace.Workspace
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
+
+interface WorkspaceHandler {
+    val availableWorkspaces: StateFlow<ResultData<List<Workspace>>>
+
+    val selectedWorkspace: Flow<Workspace?>
+
+    val usersOfSelectedWorkspace: Flow<ResultData<List<String>>>
+
+    val lastWorkspaceSync: StateFlow<ResultData<String>>
+
+    val workspaceLocalPath: StateFlow<String>
+
+    fun initScope(coroutineScope: CoroutineScope)
+
+    fun loadAvailableWorkspaces()
+
+    fun selectWorkspaceToManage(workspaceId: String)
+
+    fun syncWorkspace()
+
+    fun addUserToWorkspace(userEmail: String)
+
+    fun changeWorkspaceLocalPath(path: String)
+
+    fun initWorkspacePath()
+}
diff --git a/application/core/documents/config/ktlint/baseline.xml b/application/core/documents/config/ktlint/baseline.xml
@@ -3,6 +3,9 @@
     <file name="src/androidMain/kotlin/io/writeopia/core/folders/di/InDocumentSearchInjection.android.kt">
         <error line="7" column="74" source="standard:function-expression-body" />
     </file>
+    <file name="src/commonMain/kotlin/io/writeopia/core/folders/di/WorkspaceHandlerImpl.kt">
+        <error line="43" column="17" source="standard:backing-property-naming" />
+    </file>
     <file name="src/commonMain/kotlin/io/writeopia/core/folders/repository/InDocumentSearchSqlRepository.kt">
         <error line="10" column="80" source="standard:function-expression-body" />
     </file>

diff --git a/...core/documents/src/commonMain/kotlin/io/writeopia/core/folders/di/WorkspaceHandlerImpl.kt b/...core/documents/src/commonMain/kotlin/io/writeopia/core/folders/di/WorkspaceHandlerImpl.kt
@@ -0,0 +1,145 @@
+@file:OptIn(ExperimentalTime::class)
+
+package io.writeopia.core.folders.di
+
+import io.writeopia.auth.core.data.WorkspaceApi
+import io.writeopia.auth.core.manager.AuthRepository
+import io.writeopia.auth.core.manager.WorkspaceHandler
+import io.writeopia.core.folders.sync.WorkspaceSync
+import io.writeopia.models.interfaces.configuration.WorkspaceConfigRepository
+import io.writeopia.sdk.models.utils.ResultData
+import io.writeopia.sdk.models.workspace.Workspace
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.launch
+import kotlin.time.Clock
+import kotlin.time.ExperimentalTime
+
+class WorkspaceHandlerImpl(
+    private val authRepository: AuthRepository,
+    private val workspaceApi: WorkspaceApi,
+    private val workspaceSync: WorkspaceSync,
+    private val workspaceConfigRepository: WorkspaceConfigRepository
+) : WorkspaceHandler {
+
+    private val _availableWorkspaces: MutableStateFlow<ResultData<List<Workspace>>> =
+        MutableStateFlow(ResultData.Idle())
+    override val availableWorkspaces: StateFlow<ResultData<List<Workspace>>> = _availableWorkspaces
+
+    private lateinit var coroutineScope: CoroutineScope
+
+    override fun initScope(coroutineScope: CoroutineScope) {
+        this.coroutineScope = coroutineScope
+    }
+
+    private val _selectedWorkspaceId = MutableStateFlow<String?>(null)
+    override val selectedWorkspace: Flow<Workspace?> by lazy {
+        combine(_availableWorkspaces, _selectedWorkspaceId) { workspacesResult, selectedId ->
+            if (workspacesResult is ResultData.Complete) {
+                workspacesResult.data.firstOrNull { it.id == selectedId }
+            } else {
+                null
+            }
+        }
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    override val usersOfSelectedWorkspace: Flow<ResultData<List<String>>> =
+        selectedWorkspace.flatMapLatest { workspace ->
+            val workspaceId = workspace?.id
+
+            flow {
+                val token = authRepository.getAuthToken()
+
+                if (token != null && workspaceId != null) {
+                    workspaceApi.getUsersOfWorkspace(workspaceId, token, forceRefresh = false)
+                        .collect { emit(it) }
+                } else {
+                    emit(ResultData.Error())
+                }
+            }
+        }
+
+    private val _lastWorkspaceSync = MutableStateFlow<ResultData<String>>(ResultData.Idle())
+    override val lastWorkspaceSync: StateFlow<ResultData<String>> = _lastWorkspaceSync.asStateFlow()
+
+    private val _workspaceLocalPath = MutableStateFlow("")
+    override val workspaceLocalPath: StateFlow<String> = _workspaceLocalPath.asStateFlow()
+
+    override fun loadAvailableWorkspaces() {
+        coroutineScope.launch {
+            val result = authRepository.getAuthToken()?.let { token ->
+                workspaceApi.getAvailableWorkspaces(token)
+            }
+
+            if (result != null) {
+                _availableWorkspaces.value = result
+            }
+        }
+    }
+
+    override fun selectWorkspaceToManage(workspaceId: String) {
+        _selectedWorkspaceId.value = workspaceId
+    }
+
+    override fun syncWorkspace() {
+        coroutineScope.launch {
+            _lastWorkspaceSync.value = ResultData.Loading()
+
+            val workspace = authRepository.getWorkspace() ?: Workspace.disconnectedWorkspace()
+            val workspaceId = workspace.id
+            val result = workspaceSync.syncWorkspace(workspaceId, force = true)
+
+            _lastWorkspaceSync.value = if (result is ResultData.Complete) {
+                val lastSync = Clock.System
+                    .now()
+                    .toString()
+
+                ResultData.Complete("Last sync: $lastSync")
+            } else {
+                println("result error: $result")
+                ResultData.Error(RuntimeException("Error in sync"))
+            }
+        }
+    }
+
+    override fun addUserToWorkspace(userEmail: String) {
+        coroutineScope.launch {
+            val workspaceId = _selectedWorkspaceId.value
+
+            if (workspaceId != null) {
+                authRepository.getAuthToken()?.let { token ->
+                    val result = workspaceApi.addUserToWorkspace(workspaceId, userEmail, token)
+
+                    if (result is ResultData.Complete) {
+                        workspaceApi.refreshUsersInWorkspace(workspaceId, token)
+                    }
+                }
+            }
+        }
+    }
+
+    override fun changeWorkspaceLocalPath(path: String) {
+        coroutineScope.launch(Dispatchers.Default) {
+            val userId = authRepository.getUser().id
+
+            workspaceConfigRepository.saveWorkspacePath(path, userId)
+            _workspaceLocalPath.value = workspaceConfigRepository.loadWorkspacePath(userId) ?: ""
+        }
+    }
+
+    override fun initWorkspacePath() {
+        coroutineScope.launch {
+            _workspaceLocalPath.value =
+                workspaceConfigRepository.loadWorkspacePath(authRepository.getUser().id) ?: ""
+        }
+    }
+}
diff --git a/...n/core/documents/src/commonMain/kotlin/io/writeopia/core/folders/di/WorkspaceInjection.kt b/...n/core/documents/src/commonMain/kotlin/io/writeopia/core/folders/di/WorkspaceInjection.kt
@@ -1,6 +1,9 @@
 package io.writeopia.core.folders.di
 
+import io.writeopia.auth.core.data.WorkspaceApi
 import io.writeopia.auth.core.di.AuthCoreInjectionNeo
+import io.writeopia.auth.core.manager.WorkspaceHandler
+import io.writeopia.core.configuration.di.AppConfigurationInjector
 import io.writeopia.core.folders.api.DocumentsApi
 import io.writeopia.core.folders.sync.DocumentConflictHandler
 import io.writeopia.core.folders.sync.ImageSync
@@ -15,8 +18,21 @@ class WorkspaceInjection private constructor(
     private val connectionInjector: WriteopiaConnectionInjector =
         WriteopiaConnectionInjector.singleton(),
     private val repositoryInjection: RepositoryInjector = RepositoryInjector.singleton(),
+    private val appConfigurationInjector: AppConfigurationInjector =
+        AppConfigurationInjector.singleton(),
 ) {
 
+    private fun provideWorkspaceApi() =
+        WorkspaceApi(appConnectionInjection.provideHttpClient(), connectionInjector.baseUrl())
+
+    fun provideWorkspaceHandler(): WorkspaceHandler =
+        WorkspaceHandlerImpl(
+            authRepository = authCoreInjection.provideAuthRepository(),
+            workspaceApi = provideWorkspaceApi(),
+            workspaceSync = provideWorkspaceSync(),
+            workspaceConfigRepository = appConfigurationInjector.provideNotesConfigurationRepository()
+        )
+
     fun provideWorkspaceSync(): WorkspaceSync {
         val documentRepo = repositoryInjection.provideDocumentRepository()
         return WorkspaceSync(

diff --git a/.../features/account/src/commonMain/kotlin/io/writeopia/account/di/AccountMenuKmpInjector.kt b/.../features/account/src/commonMain/kotlin/io/writeopia/account/di/AccountMenuKmpInjector.kt
@@ -9,17 +9,17 @@ import io.writeopia.core.folders.di.WorkspaceInjection
 
 class AccountMenuKmpInjector private constructor(
     private val workspaceInjection: WorkspaceInjection = WorkspaceInjection.singleton(),
+    private val authCoreInjection: AuthCoreInjectionNeo = AuthCoreInjectionNeo.singleton(),
 ) {
 
-    private fun provideAccountMenuKmpViewModel(): AccountMenuKmpViewModel =
-        AccountMenuKmpViewModel(
-            authRepository = AuthCoreInjectionNeo.singleton().provideAuthRepository(),
-            workspaceSync = workspaceInjection.provideWorkspaceSync()
-        )
-
     @Composable
     fun provideAccountMenuViewModel(): AccountMenuViewModel =
-        viewModel { provideAccountMenuKmpViewModel() }
+        viewModel {
+            AccountMenuKmpViewModel(
+                authRepository = authCoreInjection.provideAuthRepository(),
+                workspaceHandler = workspaceInjection.provideWorkspaceHandler()
+            )
+        }
 
     companion object {
         private var instance: AccountMenuKmpInjector? = null

diff --git a/...ation/features/account/src/commonMain/kotlin/io/writeopia/account/ui/AccountMenuScreen.kt b/...ation/features/account/src/commonMain/kotlin/io/writeopia/account/ui/AccountMenuScreen.kt
@@ -1,22 +1,15 @@
 package io.writeopia.account.ui
 
 import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import io.writeopia.account.viewmodel.AccountMenuViewModel
-import io.writeopia.sdk.models.utils.toBoolean
-import io.writeopia.commonui.buttons.AccentButton
 import io.writeopia.model.ColorThemeOption
-import io.writeopia.resources.WrStrings
 import io.writeopia.sdk.models.utils.ResultData
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -30,11 +23,11 @@ fun AccountMenuScreen(
     selectColorTheme: (ColorThemeOption) -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    Column(modifier = modifier.fillMaxSize().padding(16.dp)) {
-        Connect(accountMenuViewModel, isLoggedInState, onLogout, goToRegister)
-
-        Spacer(modifier = Modifier.height(16.dp))
-
+    Column(
+        modifier = modifier.fillMaxSize()
+            .padding(16.dp)
+            .verticalScroll(state = rememberScrollState())
+    ) {
         SettingsScreen(
             showPath = false,
             showOllamaConfig = false,
@@ -53,43 +46,18 @@ fun AccountMenuScreen(
             downloadModel = {},
             deleteModel = {},
             syncWorkspace = accountMenuViewModel::syncWorkspace,
+            workspacesState = accountMenuViewModel.availableWorkspaces,
+            selectedWorkspaceState = accountMenuViewModel.selectedWorkspace,
+            selectWorkspace = accountMenuViewModel::selectWorkspace,
+            addUserToTeam = accountMenuViewModel::addUserToWorkspace,
+            usersInSelectedWorkspace = accountMenuViewModel.usersOfSelectedWorkspace,
+            isLoggedInState = isLoggedInState,
+            goToRegister = goToRegister,
+            logout = {
+                accountMenuViewModel.logout {
+                    onLogout()
+                }
+            },
         )
     }
 }
-
-@Composable
-private fun Connect(
-    accountMenuViewModel: AccountMenuViewModel,
-    isLoggedInState: StateFlow<ResultData<Boolean>>,
-    onLogout: () -> Unit,
-    goToRegister: () -> Unit
-) {
-    val isLoggedIn = isLoggedInState.collectAsState().value.toBoolean()
-
-    val titleStyle = MaterialTheme.typography.titleLarge
-    val titleColor = MaterialTheme.colorScheme.onBackground
-
-    Text(WrStrings.account(), style = titleStyle, color = titleColor)
-
-    if (!isLoggedIn) {
-        Spacer(modifier = Modifier.height(8.dp))
-
-        Text(
-            modifier = Modifier,
-            text = WrStrings.youAreOffline(),
-            style = MaterialTheme.typography.bodySmall,
-            color = MaterialTheme.colorScheme.onBackground,
-            fontWeight = FontWeight.Bold,
-        )
-    }
-
-    Spacer(modifier = Modifier.height(4.dp))
-
-    AccentButton(text = if (isLoggedIn) WrStrings.logout() else WrStrings.singIn()) {
-        if (isLoggedIn) {
-            accountMenuViewModel.logout(onLogout)
-        } else {
-            goToRegister()
-        }
-    }
-}