feat: connect to upgrade-personal-to-team API #WPB-11992

logic/src/commonMain/kotlin/com/wire/kalium/logic/data/event/Event.kt

@@ -390,14 +390,16 @@ sealed class Event(open val id: String) {
             val uri: String?,
             val isPasswordProtected: Boolean,
         ) : Conversation(id, conversationId) {
-            override fun toLogMap(): Map<String, Any?> = mapOf(typeKey to "Conversation.CodeUpdated")
+            override fun toLogMap(): Map<String, Any?> =
+                mapOf(typeKey to "Conversation.CodeUpdated")
         }
 
         data class CodeDeleted(
             override val id: String,
             override val conversationId: ConversationId,
         ) : Conversation(id, conversationId) {
-            override fun toLogMap(): Map<String, Any?> = mapOf(typeKey to "Conversation.CodeDeleted")
+            override fun toLogMap(): Map<String, Any?> =
+                mapOf(typeKey to "Conversation.CodeDeleted")
         }
 
         data class TypingIndicator(

logic/src/commonMain/kotlin/com/wire/kalium/logic/data/user/UserRepository.kt

@@ -58,12 +58,14 @@ import com.wire.kalium.logic.kaliumLogger
 import com.wire.kalium.logic.sync.receiver.handler.legalhold.LegalHoldHandler
 import com.wire.kalium.logic.wrapApiRequest
 import com.wire.kalium.logic.wrapStorageRequest
+import com.wire.kalium.network.api.authenticated.CreateUserTeamDTO
 import com.wire.kalium.network.api.authenticated.teams.TeamMemberDTO
 import com.wire.kalium.network.api.authenticated.teams.TeamMemberIdList
 import com.wire.kalium.network.api.authenticated.userDetails.ListUserRequest
 import com.wire.kalium.network.api.authenticated.userDetails.ListUsersDTO
 import com.wire.kalium.network.api.authenticated.userDetails.qualifiedIds
 import com.wire.kalium.network.api.base.authenticated.TeamsApi
+import com.wire.kalium.network.api.base.authenticated.UpgradePersonalToTeamApi
 import com.wire.kalium.network.api.base.authenticated.self.SelfApi
 import com.wire.kalium.network.api.base.authenticated.userDetails.UserDetailsApi
 import com.wire.kalium.network.api.model.LegalHoldStatusDTO
@@ -164,6 +166,7 @@ interface UserRepository {
     suspend fun getOneOnOnConversationId(userId: QualifiedID): Either<StorageFailure, ConversationId>
     suspend fun getUsersMinimizedByQualifiedIDs(userIds: List<UserId>): Either<StorageFailure, List<OtherUserMinimized>>
     suspend fun getNameAndHandle(userId: UserId): Either<StorageFailure, NameAndHandle>
+    suspend fun migrateUserToTeam(teamName: String): Either<CoreFailure, CreateUserTeamDTO>
 }
 
 @Suppress("LongParameterList", "TooManyFunctions")
@@ -173,6 +176,7 @@ internal class UserDataSource internal constructor(
     private val clientDAO: ClientDAO,
     private val selfApi: SelfApi,
     private val userDetailsApi: UserDetailsApi,
+    private val upgradePersonalToTeamApi: UpgradePersonalToTeamApi,
     private val teamsApi: TeamsApi,
     private val sessionRepository: SessionRepository,
     private val selfUserId: UserId,
@@ -647,6 +651,18 @@ internal class UserDataSource internal constructor(
         userDAO.getNameAndHandle(userId.toDao())
     }.map { NameAndHandle.fromEntity(it) }
 
+    override suspend fun migrateUserToTeam(teamName: String): Either<CoreFailure, CreateUserTeamDTO> {
+        return wrapApiRequest { upgradePersonalToTeamApi.migrateToTeam(teamName) }
+            .onSuccess {
+                kaliumLogger.d("Migrated user to team")
+                fetchSelfUser()
+                // TODO Invalidate team id in memory so UserSessionScope.selfTeamId got updated data WPB-12187
+            }
+            .onFailure { failure ->
+                kaliumLogger.e("Failed to migrate user to team: $failure")
+            }
+    }
+
     companion object {
         internal const val SELF_USER_ID_KEY = "selfUserID"
 

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/UserSessionScope.kt

@@ -332,6 +332,8 @@ import com.wire.kalium.logic.feature.user.guestroomlink.MarkGuestLinkFeatureFlag
 import com.wire.kalium.logic.feature.user.guestroomlink.MarkGuestLinkFeatureFlagAsNotChangedUseCaseImpl
 import com.wire.kalium.logic.feature.user.guestroomlink.ObserveGuestRoomLinkFeatureFlagUseCase
 import com.wire.kalium.logic.feature.user.guestroomlink.ObserveGuestRoomLinkFeatureFlagUseCaseImpl
+import com.wire.kalium.logic.feature.user.migration.MigrateFromPersonalToTeamUseCase
+import com.wire.kalium.logic.feature.user.migration.MigrateFromPersonalToTeamUseCaseImpl
 import com.wire.kalium.logic.feature.user.screenshotCensoring.ObserveScreenshotCensoringConfigUseCase
 import com.wire.kalium.logic.feature.user.screenshotCensoring.ObserveScreenshotCensoringConfigUseCaseImpl
 import com.wire.kalium.logic.feature.user.screenshotCensoring.PersistScreenshotCensoringConfigUseCase
@@ -782,16 +784,17 @@ class UserSessionScope internal constructor(
     )
 
     private val userRepository: UserRepository = UserDataSource(
-        userStorage.database.userDAO,
-        userStorage.database.metadataDAO,
-        userStorage.database.clientDAO,
-        authenticatedNetworkContainer.selfApi,
-        authenticatedNetworkContainer.userDetailsApi,
-        authenticatedNetworkContainer.teamsApi,
-        globalScope.sessionRepository,
-        userId,
-        selfTeamId,
-        legalHoldHandler
+        userDAO = userStorage.database.userDAO,
+        metadataDAO = userStorage.database.metadataDAO,
+        clientDAO = userStorage.database.clientDAO,
+        selfApi = authenticatedNetworkContainer.selfApi,
+        userDetailsApi = authenticatedNetworkContainer.userDetailsApi,
+        upgradePersonalToTeamApi = authenticatedNetworkContainer.upgradePersonalToTeamApi,
+        teamsApi = authenticatedNetworkContainer.teamsApi,
+        sessionRepository = globalScope.sessionRepository,
+        selfUserId = userId,
+        selfTeamIdProvider = selfTeamId,
+        legalHoldHandler = legalHoldHandler,
     )
 
     private val accountRepository: AccountRepository
@@ -2074,6 +2077,9 @@ class UserSessionScope internal constructor(
             userScopedLogger
         )
 
+    val migrateFromPersonalToTeam: MigrateFromPersonalToTeamUseCase
+        get() = MigrateFromPersonalToTeamUseCaseImpl(userRepository)
+
     internal val getProxyCredentials: GetProxyCredentialsUseCase
         get() = GetProxyCredentialsUseCaseImpl(sessionManager)
 

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/user/migration/MigrateFromPersonalToTeamUseCase.kt

@@ -0,0 +1,54 @@
+/*
+ * Wire
+ * Copyright (C) 2024 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+package com.wire.kalium.logic.feature.user.migration
+
+import com.wire.kalium.logic.CoreFailure
+import com.wire.kalium.logic.data.user.UserRepository
+import com.wire.kalium.logic.functional.fold
+
+/**
+ * Use case to migrate user personal account to team account.
+ * This needs at least API V7 to work.
+ */
+interface MigrateFromPersonalToTeamUseCase {
+    suspend operator fun invoke(teamName: String): MigrateFromPersonalToTeamResult
+}
+
+sealed class MigrateFromPersonalToTeamResult {
+    data class Success(val teamId: String, val teamName: String) : MigrateFromPersonalToTeamResult()
+    data class Error(val failure: CoreFailure) : MigrateFromPersonalToTeamResult()
+}
+
+internal class MigrateFromPersonalToTeamUseCaseImpl internal constructor(
+    private val userRepository: UserRepository,
+) : MigrateFromPersonalToTeamUseCase {
+    override suspend operator fun invoke(
+        teamName: String,
+    ): MigrateFromPersonalToTeamResult {
+        return userRepository.migrateUserToTeam(teamName)
+            .fold(
+                { error -> return MigrateFromPersonalToTeamResult.Error(error) },
+                { success ->
+                    MigrateFromPersonalToTeamResult.Success(
+                        teamId = success.teamId,
+                        teamName = success.teamName,
+                    )
+                }
+            )
+    }
+}

logic/src/commonMain/kotlin/com/wire/kalium/logic/sync/receiver/conversation/NewConversationEventHandler.kt

@@ -59,10 +59,17 @@ internal class NewConversationEventHandlerImpl(
             .flatMap { isNewUnhandledConversation ->
                 resolveConversationIfOneOnOne(selfUserTeamId, event)
                     .flatMap {
-                        conversationRepository.updateConversationModifiedDate(event.conversationId, DateTimeUtil.currentInstant())
+                        conversationRepository.updateConversationModifiedDate(
+                            event.conversationId,
+                            DateTimeUtil.currentInstant()
+                        )
                     }
                     .flatMap {
-                        userRepository.fetchUsersIfUnknownByIds(event.conversation.members.otherMembers.map { it.id.toModel() }.toSet())
+                        userRepository.fetchUsersIfUnknownByIds(
+                            event.conversation.members.otherMembers.map {
+                                it.id.toModel()
+                            }.toSet()
+                        )
                     }
                     .map { isNewUnhandledConversation }
             }.onSuccess { isNewUnhandledConversation ->
@@ -73,9 +80,13 @@ internal class NewConversationEventHandlerImpl(
             }
     }
 
-    private suspend fun resolveConversationIfOneOnOne(selfUserTeamId: TeamId?, event: Event.Conversation.NewConversation) =
+    private suspend fun resolveConversationIfOneOnOne(
+        selfUserTeamId: TeamId?,
+        event: Event.Conversation.NewConversation
+    ) =
         if (event.conversation.toConversationType(selfUserTeamId) == ConversationEntity.Type.ONE_ON_ONE) {
-            val otherUserId = event.conversation.members.otherMembers.first().id.toModel()
+            val otherUserId =
+                event.conversation.members.otherMembers.first().id.toModel()
             oneOnOneResolver.resolveOneOnOneConversationWithUserId(
                 userId = otherUserId,
                 invalidateCurrentKnownProtocols = true
@@ -94,13 +105,20 @@ internal class NewConversationEventHandlerImpl(
         event: Event.Conversation.NewConversation
     ) {
         if (isNewUnhandledConversation) {
-            newGroupConversationSystemMessagesCreator.conversationStarted(event.senderUserId, event.conversation, event.dateTime)
+            newGroupConversationSystemMessagesCreator.conversationStarted(
+                event.senderUserId,
+                event.conversation,
+                event.dateTime
+            )
             newGroupConversationSystemMessagesCreator.conversationResolvedMembersAdded(
                 event.conversationId.toDao(),
                 event.conversation.members.otherMembers.map { it.id.toModel() },
                 event.dateTime
             )
-            newGroupConversationSystemMessagesCreator.conversationReadReceiptStatus(event.conversation, event.dateTime)
+            newGroupConversationSystemMessagesCreator.conversationReadReceiptStatus(
+                event.conversation,
+                event.dateTime
+            )
             newGroupConversationSystemMessagesCreator.conversationStartedUnverifiedWarning(
                 event.conversation.id.toModel(),
                 event.dateTime

logic/src/commonTest/kotlin/com/wire/kalium/logic/data/client/ClientRepositoryTest.kt

@@ -36,11 +36,11 @@ import com.wire.kalium.logic.framework.TestEvent
 import com.wire.kalium.logic.functional.Either
 import com.wire.kalium.logic.util.shouldFail
 import com.wire.kalium.logic.util.shouldSucceed
-import com.wire.kalium.network.api.base.authenticated.client.ClientApi
 import com.wire.kalium.network.api.authenticated.client.ClientDTO
 import com.wire.kalium.network.api.authenticated.client.ClientTypeDTO
 import com.wire.kalium.network.api.authenticated.client.DeviceTypeDTO
 import com.wire.kalium.network.api.authenticated.client.SimpleClientResponse
+import com.wire.kalium.network.api.base.authenticated.client.ClientApi
 import com.wire.kalium.network.api.model.ErrorResponse
 import com.wire.kalium.network.exceptions.KaliumException
 import com.wire.kalium.network.utils.NetworkResponse
@@ -257,7 +257,7 @@ class ClientRepositoryTest {
                     deviceType = DeviceTypeDTO.Desktop,
                     label = null,
                     model = "Mac ox",
-                    capabilities = null,
+                    capabilities = listOf(),
                     mlsPublicKeys = null,
                     cookie = null
                 ),
@@ -269,7 +269,7 @@ class ClientRepositoryTest {
                     deviceType = DeviceTypeDTO.Phone,
                     label = null,
                     model = "iphone 15",
-                    capabilities = null,
+                    capabilities = listOf(),
                     mlsPublicKeys = null,
                     cookie = null
                 )

logic/src/commonTest/kotlin/com/wire/kalium/logic/data/user/UserRepositoryTest.kt

@@ -44,15 +44,17 @@ import com.wire.kalium.logic.test_util.TestNetworkException.generic
 import com.wire.kalium.logic.test_util.TestNetworkResponseError
 import com.wire.kalium.logic.util.shouldFail
 import com.wire.kalium.logic.util.shouldSucceed
-import com.wire.kalium.network.api.base.authenticated.TeamsApi
-import com.wire.kalium.network.api.base.authenticated.self.SelfApi
+import com.wire.kalium.network.api.authenticated.CreateUserTeamDTO
 import com.wire.kalium.network.api.authenticated.teams.TeamMemberDTO
 import com.wire.kalium.network.api.authenticated.teams.TeamMemberListNonPaginated
 import com.wire.kalium.network.api.authenticated.userDetails.ListUserRequest
 import com.wire.kalium.network.api.authenticated.userDetails.ListUsersDTO
 import com.wire.kalium.network.api.authenticated.userDetails.QualifiedUserIdListRequest
-import com.wire.kalium.network.api.base.authenticated.userDetails.UserDetailsApi
 import com.wire.kalium.network.api.authenticated.userDetails.qualifiedIds
+import com.wire.kalium.network.api.base.authenticated.TeamsApi
+import com.wire.kalium.network.api.base.authenticated.UpgradePersonalToTeamApi
+import com.wire.kalium.network.api.base.authenticated.self.SelfApi
+import com.wire.kalium.network.api.base.authenticated.userDetails.UserDetailsApi
 import com.wire.kalium.network.api.model.LegalHoldStatusDTO
 import com.wire.kalium.network.api.model.UserProfileDTO
 import com.wire.kalium.network.utils.NetworkResponse
@@ -801,6 +803,37 @@ class UserRepositoryTest {
         }.wasInvoked(exactly = once)
     }
 
+    @Test
+    fun givenApiRequestSucceeds_whenPersonalUserUpgradesToTeam_thenShouldSucceed() = runTest {
+        // given
+        val (arrangement, userRepository) = Arrangement()
+            .withRemoteGetSelfReturningDeletedUser()
+            .withMigrateUserToTeamSuccess()
+            .arrange()
+        // when
+        val result = userRepository.migrateUserToTeam("teamName")
+        // then
+        result.shouldSucceed()
+        coVerify {
+            arrangement.upgradePersonalToTeamApi.migrateToTeam(any())
+        }.wasInvoked(exactly = once)
+    }
+
+    @Test
+    fun givenApiRequestFails_whenPersonalUserUpgradesToTeam_thenShouldPropagateError() = runTest {
+        // given
+        val (arrangement, userRepository) = Arrangement()
+            .withMigrateUserToTeamFailure()
+            .arrange()
+        // when
+        val result = userRepository.migrateUserToTeam("teamName")
+        // then
+        result.shouldFail()
+        coVerify {
+            arrangement.upgradePersonalToTeamApi.migrateToTeam(any())
+        }.wasInvoked(exactly = once)
+    }
+
     private class Arrangement {
         @Mock
         val userDAO = mock(UserDAO::class)
@@ -829,20 +862,25 @@ class UserRepositoryTest {
         @Mock
         val legalHoldHandler: LegalHoldHandler = mock(LegalHoldHandler::class)
 
+        @Mock
+        val upgradePersonalToTeamApi: UpgradePersonalToTeamApi =
+            mock(UpgradePersonalToTeamApi::class)
+
         val selfUserId = TestUser.SELF.id
 
         val userRepository: UserRepository by lazy {
             UserDataSource(
-                userDAO,
-                metadataDAO,
-                clientDAO,
-                selfApi,
-                userDetailsApi,
-                teamsApi,
-                sessionRepository,
-                selfUserId,
-                selfTeamIdProvider,
-                legalHoldHandler
+                userDAO = userDAO,
+                metadataDAO = metadataDAO,
+                clientDAO = clientDAO,
+                selfApi = selfApi,
+                userDetailsApi = userDetailsApi,
+                teamsApi = teamsApi,
+                sessionRepository = sessionRepository,
+                selfUserId = selfUserId,
+                selfTeamIdProvider = selfTeamIdProvider,
+                legalHoldHandler = legalHoldHandler,
+                upgradePersonalToTeamApi = upgradePersonalToTeamApi,
             )
         }
 
@@ -1029,6 +1067,24 @@ class UserRepositoryTest {
             }.returns(NetworkResponse.Success(result, mapOf(), 200))
         }
 
+        suspend fun withMigrateUserToTeamSuccess() = apply {
+            coEvery {
+                upgradePersonalToTeamApi.migrateToTeam(any())
+            }.returns(
+                NetworkResponse.Success(
+                    CreateUserTeamDTO("teamId", "teamName"),
+                    mapOf(),
+                    200
+                )
+            )
+        }
+
+        suspend fun withMigrateUserToTeamFailure() = apply {
+            coEvery {
+                upgradePersonalToTeamApi.migrateToTeam(any())
+            }.returns(NetworkResponse.Error(generic))
+        }
+
         suspend inline fun arrange(block: (Arrangement.() -> Unit) = { }): Pair<Arrangement, UserRepository> {
             withSelfUserIdFlowMetadataReturning(flowOf(TestUser.JSON_QUALIFIED_ID))
             coEvery {