fix(mls-migration): set correct CS when Kalium start migration (WPB-9638)

logic/src/commonMain/kotlin/com/wire/kalium/logic/data/conversation/MLSConversationRepository.kt

@@ -493,6 +493,7 @@ internal class MLSConversationDataSource(
         allowPartialMemberList: Boolean = false,
     ): Either<CoreFailure, MLSAdditionResult> = withContext(serialDispatcher) {
         commitPendingProposals(groupID).flatMap {
+            kaliumLogger.d("adding $userIdList to MLS group: $groupID")
             produceAndSendCommitWithRetryAndResult(groupID, retryOnStaleMessage = retryOnStaleMessage) {
                 keyPackageRepository.claimKeyPackages(userIdList, cipherSuite).flatMap { result ->
                     if (result.usersWithoutKeyPackagesAvailable.isNotEmpty() && !allowPartialMemberList) {
@@ -619,6 +620,7 @@ internal class MLSConversationDataSource(
         externalSenders: ByteArray,
         allowPartialMemberList: Boolean = false,
     ): Either<CoreFailure, MLSAdditionResult> = withContext(serialDispatcher) {
+        kaliumLogger.d("establish MLS group: $groupID")
         mlsClientProvider.getMLSClient().flatMap { mlsClient ->
             wrapMLSRequest {
                 mlsClient.createConversation(

logic/src/commonMain/kotlin/com/wire/kalium/logic/data/message/ProtoContentMapper.kt

@@ -34,6 +34,7 @@ import com.wire.kalium.protobuf.encodeToByteArray
 import com.wire.kalium.protobuf.messages.Asset
 import com.wire.kalium.protobuf.messages.Button
 import com.wire.kalium.protobuf.messages.ButtonAction
+import com.wire.kalium.protobuf.messages.ButtonActionConfirmation
 import com.wire.kalium.protobuf.messages.Calling
 import com.wire.kalium.protobuf.messages.Cleared
 import com.wire.kalium.protobuf.messages.ClientAction
@@ -132,7 +133,7 @@ class ProtoContentMapperImpl(
             is MessageContent.Composite -> packComposite(readableContent, expectsReadConfirmation, legalHoldStatus)
             is MessageContent.ButtonAction -> packButtonAction(readableContent)
 
-            is MessageContent.ButtonActionConfirmation -> TODO()
+            is MessageContent.ButtonActionConfirmation -> packButtonActionConfirmation(readableContent)
             is MessageContent.Location -> packLocation(readableContent, expectsReadConfirmation, legalHoldStatus)
         }
     }
@@ -165,6 +166,16 @@ class ProtoContentMapperImpl(
             )
         )
 
+    private fun packButtonActionConfirmation(
+        readableContent: MessageContent.ButtonActionConfirmation
+    ): GenericMessage.Content.ButtonActionConfirmation =
+        GenericMessage.Content.ButtonActionConfirmation(
+            ButtonActionConfirmation(
+                buttonId = readableContent.buttonId,
+                referenceMessageId = readableContent.referencedMessageId
+            )
+        )
+
     private fun packComposite(
         readableContent: MessageContent.Composite,
         expectsReadConfirmation: Boolean,

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/client/GetOrRegisterClientUseCase.kt

@@ -18,6 +18,7 @@
 
 package com.wire.kalium.logic.feature.client
 
+import com.wire.kalium.logger.obfuscateId
 import com.wire.kalium.logic.CoreFailure
 import com.wire.kalium.logic.data.client.ClientRepository
 import com.wire.kalium.logic.data.conversation.ClientId
@@ -28,6 +29,7 @@ import com.wire.kalium.logic.feature.featureConfig.SyncFeatureConfigsUseCase
 import com.wire.kalium.logic.feature.session.UpgradeCurrentSessionUseCase
 import com.wire.kalium.logic.functional.flatMap
 import com.wire.kalium.logic.functional.nullableFold
+import com.wire.kalium.logic.kaliumLogger
 
 /**
  * This use case is responsible for getting the client.
@@ -74,6 +76,7 @@ internal class GetOrRegisterClientUseCaseImpl(
 
         when (result) {
             is RegisterClientResult.E2EICertificateRequired -> {
+                kaliumLogger.i("Client registration blocked because E2EI certificate required")
                 clientRepository.setClientRegistrationBlockedByE2EI()
                 upgradeCurrentSessionAndPersistClient(result.client.id)
             }
@@ -86,7 +89,9 @@ internal class GetOrRegisterClientUseCaseImpl(
     }
 
     private suspend fun upgradeCurrentSessionAndPersistClient(clientId: ClientId) {
+        kaliumLogger.i("Upgrade current session for client ${clientId.value.obfuscateId()}")
         upgradeCurrentSessionUseCase(clientId).flatMap {
+            kaliumLogger.i("Persist client ${clientId.value.obfuscateId()}")
             clientRepository.persistClientId(clientId)
         }
     }

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/message/MessageScope.kt

@@ -56,7 +56,9 @@ import com.wire.kalium.logic.feature.asset.UpdateAssetMessageDownloadStatusUseCa
 import com.wire.kalium.logic.feature.asset.UpdateAssetMessageDownloadStatusUseCaseImpl
 import com.wire.kalium.logic.feature.asset.UpdateAssetMessageUploadStatusUseCase
 import com.wire.kalium.logic.feature.asset.UpdateAssetMessageUploadStatusUseCaseImpl
+import com.wire.kalium.logic.feature.message.composite.SendButtonActionConfirmationMessageUseCase
 import com.wire.kalium.logic.feature.message.composite.SendButtonActionMessageUseCase
+import com.wire.kalium.logic.feature.message.composite.SendButtonMessageUseCase
 import com.wire.kalium.logic.feature.message.ephemeral.DeleteEphemeralMessageForSelfUserAsReceiverUseCaseImpl
 import com.wire.kalium.logic.feature.message.ephemeral.DeleteEphemeralMessageForSelfUserAsSenderUseCaseImpl
 import com.wire.kalium.logic.feature.message.ephemeral.DeleteEphemeralMessagesAfterEndDateUseCase
@@ -353,6 +355,14 @@ class MessageScope internal constructor(
     val resetSession: ResetSessionUseCase
         get() = ResetSessionUseCaseImpl(proteusClientProvider, sessionResetSender, messageRepository)
 
+    val sendButtonActionConfirmationMessage: SendButtonActionConfirmationMessageUseCase
+        get() = SendButtonActionConfirmationMessageUseCase(
+            syncManager = syncManager,
+            messageSender = messageSender,
+            selfUserId = selfUserId,
+            currentClientIdProvider = currentClientIdProvider
+        )
+
     val sendButtonActionMessage: SendButtonActionMessageUseCase
         get() = SendButtonActionMessageUseCase(
             syncManager = syncManager,
@@ -361,6 +371,19 @@ class MessageScope internal constructor(
             currentClientIdProvider = currentClientIdProvider,
             messageMetadataRepository = messageMetadataRepository
         )
+
+    val sendButtonMessage: SendButtonMessageUseCase
+        get() = SendButtonMessageUseCase(
+            persistMessage = persistMessage,
+            selfUserId = selfUserId,
+            provideClientId = currentClientIdProvider,
+            slowSyncRepository = slowSyncRepository,
+            messageSender = messageSender,
+            messageSendFailureHandler = messageSendFailureHandler,
+            userPropertyRepository = userPropertyRepository,
+            scope = scope
+        )
+
     private val deleteEphemeralMessageForSelfUserAsReceiver: DeleteEphemeralMessageForSelfUserAsReceiverUseCaseImpl
         get() = DeleteEphemeralMessageForSelfUserAsReceiverUseCaseImpl(
             messageRepository = messageRepository,

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/message/composite/SendButtonActionConfirmationMessageUseCase.kt

@@ -0,0 +1,79 @@
+/*
+ * 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.message.composite
+
+import com.benasher44.uuid.uuid4
+import com.wire.kalium.logic.CoreFailure
+import com.wire.kalium.logic.data.id.ConversationId
+import com.wire.kalium.logic.data.message.Message
+import com.wire.kalium.logic.data.message.MessageContent
+import com.wire.kalium.logic.data.user.UserId
+import com.wire.kalium.logic.data.id.CurrentClientIdProvider
+import com.wire.kalium.logic.feature.message.MessageSender
+import com.wire.kalium.logic.data.message.MessageTarget
+import com.wire.kalium.logic.functional.flatMap
+import com.wire.kalium.logic.functional.fold
+import com.wire.kalium.logic.sync.SyncManager
+import com.wire.kalium.util.DateTimeUtil
+
+/**
+ * Use case for sending a button action message.
+ * @param conversationId The conversation id.
+ * @param messageId The id of the message that contains the button.
+ * @param buttonId The id of the button.
+ *
+ * the action message is sent only to the message original sender.
+ */
+class SendButtonActionConfirmationMessageUseCase internal constructor(
+    private val messageSender: MessageSender,
+    private val syncManager: SyncManager,
+    private val currentClientIdProvider: CurrentClientIdProvider,
+    private val selfUserId: UserId
+) {
+    suspend operator fun invoke(
+        conversationId: ConversationId,
+        messageId: String,
+        buttonId: String,
+        userIds: List<UserId>
+    ): Result = syncManager.waitUntilLiveOrFailure().flatMap {
+            currentClientIdProvider().flatMap { currentClientId ->
+                val regularMessage = Message.Signaling(
+                    id = uuid4().toString(),
+                    content = MessageContent.ButtonActionConfirmation(
+                        referencedMessageId = messageId,
+                        buttonId = buttonId
+                    ),
+                    conversationId = conversationId,
+                    date = DateTimeUtil.currentIsoDateTimeString(),
+                    senderUserId = selfUserId,
+                    senderClientId = currentClientId,
+                    status = Message.Status.Pending,
+                    isSelfMessage = true,
+                    expirationData = null
+                )
+                messageSender.sendMessage(regularMessage, messageTarget = MessageTarget.Users(userIds))
+            }
+    }.fold(Result::Failure, { Result.Success })
+
+    sealed interface Result {
+        data object Success : Result
+        data class Failure(
+            val error: CoreFailure
+        ) : Result
+    }
+}

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/message/composite/SendButtonMessageUseCase.kt

@@ -0,0 +1,122 @@
+/*
+ * 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.message.composite
+
+import com.benasher44.uuid.uuid4
+import com.wire.kalium.logic.CoreFailure
+import com.wire.kalium.logic.data.id.ConversationId
+import com.wire.kalium.logic.data.id.CurrentClientIdProvider
+import com.wire.kalium.logic.data.id.QualifiedID
+import com.wire.kalium.logic.data.message.Message
+import com.wire.kalium.logic.data.message.MessageContent
+import com.wire.kalium.logic.data.message.PersistMessageUseCase
+import com.wire.kalium.logic.data.message.mention.MessageMention
+import com.wire.kalium.logic.data.properties.UserPropertyRepository
+import com.wire.kalium.logic.data.sync.SlowSyncRepository
+import com.wire.kalium.logic.data.sync.SlowSyncStatus
+import com.wire.kalium.logic.feature.message.MessageSendFailureHandler
+import com.wire.kalium.logic.feature.message.MessageSender
+import com.wire.kalium.logic.functional.Either
+import com.wire.kalium.logic.functional.flatMap
+import com.wire.kalium.logic.functional.onFailure
+import com.wire.kalium.util.DateTimeUtil
+import com.wire.kalium.util.KaliumDispatcher
+import com.wire.kalium.util.KaliumDispatcherImpl
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.async
+import kotlinx.coroutines.flow.first
+
+@Suppress("LongParameterList")
+/**
+ * @sample samples.logic.MessageUseCases.sendingBasicTextMessage
+ * @sample samples.logic.MessageUseCases.sendingTextMessageWithMentions
+ */
+class SendButtonMessageUseCase internal constructor(
+    private val persistMessage: PersistMessageUseCase,
+    private val selfUserId: QualifiedID,
+    private val provideClientId: CurrentClientIdProvider,
+    private val slowSyncRepository: SlowSyncRepository,
+    private val messageSender: MessageSender,
+    private val messageSendFailureHandler: MessageSendFailureHandler,
+    private val userPropertyRepository: UserPropertyRepository,
+    private val dispatchers: KaliumDispatcher = KaliumDispatcherImpl,
+    private val scope: CoroutineScope
+) {
+
+    suspend operator fun invoke(
+        conversationId: ConversationId,
+        text: String,
+        mentions: List<MessageMention> = emptyList(),
+        quotedMessageId: String? = null,
+        buttons: List<String> = listOf()
+    ): Either<CoreFailure, Unit> = scope.async(dispatchers.io) {
+        slowSyncRepository.slowSyncStatus.first {
+            it is SlowSyncStatus.Complete
+        }
+
+        val generatedMessageUuid = uuid4().toString()
+        val expectsReadConfirmation = userPropertyRepository.getReadReceiptsStatus()
+
+        provideClientId().flatMap { clientId ->
+            val textContent = MessageContent.Text(
+                value = text,
+                mentions = mentions,
+                quotedMessageReference = quotedMessageId?.let { quotedMessageId ->
+                    MessageContent.QuoteReference(
+                        quotedMessageId = quotedMessageId,
+                        quotedMessageSha256 = null,
+                        isVerified = true
+                    )
+                }
+            )
+
+            val transform: (String) -> MessageContent.Composite.Button = { MessageContent.Composite.Button(it, it, false) }
+            val buttonContent = buttons.map(transform)
+            val content = MessageContent.Composite(textContent, buttonContent)
+
+            val message = Message.Regular(
+                id = generatedMessageUuid,
+                content = content,
+                expectsReadConfirmation = expectsReadConfirmation,
+                conversationId = conversationId,
+                date = DateTimeUtil.currentIsoDateTimeString(),
+                senderUserId = selfUserId,
+                senderClientId = clientId,
+                status = Message.Status.Pending,
+                editStatus = Message.EditStatus.NotEdited,
+                // According to proto Ephemeral it is not possible to send a Composite message with timer
+                expirationData = null,
+                isSelfMessage = true
+            )
+            persistMessage(message).flatMap {
+                messageSender.sendMessage(message)
+            }
+        }.onFailure {
+            messageSendFailureHandler.handleFailureAndUpdateMessageStatus(
+                failure = it,
+                conversationId = conversationId,
+                messageId = generatedMessageUuid,
+                messageType = TYPE
+            )
+        }
+    }.await()
+
+    companion object {
+        const val TYPE = "Text"
+    }
+}

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/mlsmigration/MLSMigrator.kt

@@ -25,15 +25,16 @@ import com.wire.kalium.logic.data.conversation.Conversation.Protocol
 import com.wire.kalium.logic.data.conversation.ConversationRepository
 import com.wire.kalium.logic.data.conversation.MLSConversationRepository
 import com.wire.kalium.logic.data.id.ConversationId
+import com.wire.kalium.logic.data.id.SelfTeamIdProvider
 import com.wire.kalium.logic.data.message.SystemMessageInserter
 import com.wire.kalium.logic.data.user.UserId
 import com.wire.kalium.logic.data.user.UserRepository
-import com.wire.kalium.logic.data.id.SelfTeamIdProvider
 import com.wire.kalium.logic.functional.Either
 import com.wire.kalium.logic.functional.flatMap
 import com.wire.kalium.logic.functional.flatMapLeft
 import com.wire.kalium.logic.functional.fold
 import com.wire.kalium.logic.functional.foldToEitherWhileRight
+import com.wire.kalium.logic.functional.right
 import com.wire.kalium.logic.kaliumLogger
 import kotlinx.coroutines.flow.first
 
@@ -107,6 +108,7 @@ internal class MLSMigratorImpl(
                         )
                     }
                 }
+                kaliumLogger.i("migrating ${conversationId.toLogString()} to mls")
                 establishConversation(conversationId)
             }.flatMapLeft {
                 kaliumLogger.w("failed to migrate ${conversationId.toLogString()} to mixed: $it")
@@ -135,16 +137,10 @@ internal class MLSMigratorImpl(
             .flatMap { protocolInfo ->
                 when (protocolInfo) {
                     is Conversation.ProtocolInfo.Mixed -> {
-                        mlsConversationRepository.establishMLSGroup(protocolInfo.groupId, emptyList())
-                            .flatMap {
-                                conversationRepository.getConversationMembers(conversationId).flatMap { members ->
-                                    mlsConversationRepository.addMemberToMLSGroup(
-                                        protocolInfo.groupId,
-                                        members,
-                                        protocolInfo.cipherSuite
-                                    )
-                                }
-                            }
+                        conversationRepository.getConversationMembers(conversationId).flatMap { members ->
+                            mlsConversationRepository.establishMLSGroup(protocolInfo.groupId, members)
+                        }
+                        Unit.right()
                     }
                     else -> Either.Right(Unit)
                 }