feat: handle adding participants while some of their backends are down (WPB-462)

logic/src/commonMain/kotlin/com/wire/kalium/logic/CoreFailure.kt

@@ -38,6 +38,10 @@ sealed interface CoreFailure {
                 && this.kaliumException is KaliumException.InvalidRequestError
                 && this.kaliumException.errorResponse.code == HttpStatusCode.NotFound.value
 
+    val hasUnreachableDomainsError: Boolean
+        get() = this is NetworkFailure.FederatedBackendFailure
+                && this.label == "federation-unreachable-domains-error" && this.domains.isNotEmpty()
+
     /**
      * The attempted operation requires that this client is registered.
      */
@@ -106,7 +110,7 @@ sealed class NetworkFailure : CoreFailure {
     /**
      * Failure due to a federated backend context
      */
-    object FederatedBackendFailure : NetworkFailure()
+    class FederatedBackendFailure(val label: String, val domains: List<String> = emptyList()) : NetworkFailure()
 }
 
 interface MLSFailure : CoreFailure {
@@ -151,7 +155,8 @@ internal inline fun <T : Any> wrapApiRequest(networkCall: () -> NetworkResponse<
             val exception = result.kException
             when {
                 exception is KaliumException.FederationError -> {
-                    Either.Left(NetworkFailure.FederatedBackendFailure)
+                    val cause = exception.errorResponse.cause
+                    Either.Left(NetworkFailure.FederatedBackendFailure(exception.errorResponse.label, cause?.domains.orEmpty()))
                 }
 
                 // todo SocketException is platform specific so need to wrap it in our own exceptions

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

@@ -0,0 +1,58 @@
+/*
+ * Wire
+ * Copyright (C) 2023 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.data.conversation
+
+import com.wire.kalium.logic.NetworkFailure
+import com.wire.kalium.logic.data.user.UserId
+
+internal interface AddingMembersFailureMapper {
+    /**
+     * Will map the [initialUsersIds] and split accordingly excluding users with domain failures.
+     * @param initialUsersIds the list of users that were initially requested to be added to the conversation
+     * @param federatedBackendFailure the [NetworkFailure.FederatedBackendFailure] that contains the domains that failed
+     * @param previousUserIdsExcluded the previous attempt of list of users that cannot be added to the conversation
+     */
+    fun mapToUsersRequestState(
+        initialUsersIds: List<UserId>,
+        federatedBackendFailure: NetworkFailure.FederatedBackendFailure,
+        previousUserIdsExcluded: Set<UserId> = emptySet(),
+    ): AddingMembersRequestState
+}
+
+internal class AddingMembersFailureMapperImpl : AddingMembersFailureMapper {
+    override fun mapToUsersRequestState(
+        initialUsersIds: List<UserId>,
+        federatedBackendFailure: NetworkFailure.FederatedBackendFailure,
+        previousUserIdsExcluded: Set<UserId>
+    ): AddingMembersRequestState {
+        val domainsToExclude = federatedBackendFailure.domains
+        // splitting the initialUsersIds into users with failures[true] and users without failures[false]
+        val groupedUsersWithFailure = initialUsersIds.groupBy {
+            domainsToExclude.contains(it.domain)
+        }
+        return AddingMembersRequestState(
+            usersThatCanBeAdded = groupedUsersWithFailure[false]?.toSet().orEmpty(),
+            usersThatCannotBeAdded = groupedUsersWithFailure[true]?.toSet().orEmpty() + previousUserIdsExcluded
+        )
+    }
+}
+
+data class AddingMembersRequestState(
+    val usersThatCanBeAdded: Set<UserId>,
+    val usersThatCannotBeAdded: Set<UserId>,
+)

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

@@ -87,6 +87,7 @@ internal class ConversationGroupRepositoryImpl(
     private val conversationMapper: ConversationMapper = MapperProvider.conversationMapper(),
     private val eventMapper: EventMapper = MapperProvider.eventMapper(),
     private val protocolInfoMapper: ProtocolInfoMapper = MapperProvider.protocolInfoMapper(),
+    private val addingMembersFailureMapper: AddingMembersFailureMapper = MapperProvider.addingMembersFailureMapper(),
 ) : ConversationGroupRepository {
 
     override suspend fun createGroupConversation(
@@ -140,7 +141,7 @@ internal class ConversationGroupRepositoryImpl(
             .flatMap { protocol ->
                 when (protocol) {
                     is ConversationEntity.ProtocolInfo.Proteus ->
-                        addMembersToCloudAndStorage(userIdList, conversationId)
+                        tryAddMembersToCloudAndStorage(userIdList, conversationId)
 
                     is ConversationEntity.ProtocolInfo.MLS -> {
                         mlsConversationRepository.addMemberToMLSGroup(GroupID(protocol.groupId), userIdList)
@@ -174,20 +175,51 @@ internal class ConversationGroupRepositoryImpl(
                 }
             }
 
-    private suspend fun addMembersToCloudAndStorage(userIdList: List<UserId>, conversationId: ConversationId): Either<CoreFailure, Unit> =
-        wrapApiRequest {
+    private suspend fun tryAddMembersToCloudAndStorage(
+        userIdList: List<UserId>,
+        conversationId: ConversationId,
+        previousUserIdsExcluded: Set<UserId> = emptySet(),
+    ): Either<CoreFailure, Unit> {
+        val apiResult = wrapApiRequest {
             val users = userIdList.map { it.toApi() }
             val addParticipantRequest = AddConversationMembersRequest(users, ConversationDataSource.DEFAULT_MEMBER_ROLE)
             conversationApi.addMember(
                 addParticipantRequest, conversationId.toApi()
             )
-        }.onSuccess { response ->
-            if (response is ConversationMemberAddedResponse.Changed) {
-                memberJoinEventHandler.handle(eventMapper.conversationMemberJoin(LocalId.generate(), response.event, true))
+        }
+
+        return when (apiResult) {
+            is Either.Left -> {
+                if (apiResult.value.hasUnreachableDomainsError) {
+                    val usersReqState = addingMembersFailureMapper.mapToUsersRequestState(
+                        userIdList,
+                        apiResult.value as NetworkFailure.FederatedBackendFailure,
+                        previousUserIdsExcluded
+                    )
+                    // retry adding, only with filtered available members to the conversation
+                    tryAddMembersToCloudAndStorage(
+                        usersReqState.usersThatCanBeAdded.toList(), conversationId, usersReqState.usersThatCannotBeAdded
+                    )
+                } else {
+                    Either.Left(apiResult.value)
+                }
+            }
+
+            is Either.Right -> {
+                if (apiResult.value is ConversationMemberAddedResponse.Changed) {
+                    memberJoinEventHandler.handle(
+                        eventMapper.conversationMemberJoin(LocalId.generate(), apiResult.value.event, true)
+                    )
+                }
+                if (previousUserIdsExcluded.isNotEmpty()) {
+                    newGroupConversationSystemMessagesCreator.value.conversationFailedToAddMembers(
+                        conversationId, previousUserIdsExcluded
+                    )
+                }
+                Either.Right(Unit)
             }
-        }.map {
-            Either.Right(Unit)
         }
+    }
 
     override suspend fun deleteMember(
         userId: UserId,

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

@@ -48,6 +48,11 @@ internal interface NewGroupConversationSystemMessagesCreator {
         conversationId: ConversationIDEntity,
         conversationResponse: ConversationResponse
     ): Either<CoreFailure, Unit>
+
+    suspend fun conversationFailedToAddMembers(
+        conversationId: ConversationId,
+        userIdList: Set<UserId>
+    ): Either<CoreFailure, Unit>
 }
 
 internal class NewGroupConversationSystemMessagesCreatorImpl(
@@ -156,6 +161,23 @@ internal class NewGroupConversationSystemMessagesCreatorImpl(
         }
     }
 
+    override suspend fun conversationFailedToAddMembers(
+        conversationId: ConversationId,
+        userIdList: Set<UserId>
+    ): Either<CoreFailure, Unit> {
+        val messageFailedToAddMembers = Message.System(
+            uuid4().toString(),
+            MessageContent.MemberChange.FailedToAdd(userIdList.toList()),
+            conversationId,
+            DateTimeUtil.currentIsoDateTimeString(),
+            selfUserId,
+            Message.Status.SENT,
+            Message.Visibility.VISIBLE,
+            expirationData = null
+        )
+        return persistMessage(messageFailedToAddMembers)
+    }
+
     private suspend fun createFailedToAddSystemMessage(conversationResponse: ConversationResponse) {
         if (conversationResponse.failedToAdd.isNotEmpty()) {
             val messageStartedWithFailedMembers = Message.System(

logic/src/commonMain/kotlin/com/wire/kalium/logic/di/MapperProvider.kt

@@ -33,6 +33,8 @@ import com.wire.kalium.logic.data.connection.ConnectionMapper
 import com.wire.kalium.logic.data.connection.ConnectionMapperImpl
 import com.wire.kalium.logic.data.connection.ConnectionStatusMapper
 import com.wire.kalium.logic.data.connection.ConnectionStatusMapperImpl
+import com.wire.kalium.logic.data.conversation.AddingMembersFailureMapper
+import com.wire.kalium.logic.data.conversation.AddingMembersFailureMapperImpl
 import com.wire.kalium.logic.data.conversation.ConversationMapper
 import com.wire.kalium.logic.data.conversation.ConversationMapperImpl
 import com.wire.kalium.logic.data.conversation.ConversationRoleMapper
@@ -80,10 +82,10 @@ import com.wire.kalium.logic.data.prekey.PreKeyMapper
 import com.wire.kalium.logic.data.prekey.PreKeyMapperImpl
 import com.wire.kalium.logic.data.publicuser.PublicUserMapper
 import com.wire.kalium.logic.data.publicuser.PublicUserMapperImpl
+import com.wire.kalium.logic.data.service.ServiceMapper
 import com.wire.kalium.logic.data.session.SessionMapper
 import com.wire.kalium.logic.data.session.SessionMapperImpl
 import com.wire.kalium.logic.data.session.SessionRepository
-import com.wire.kalium.logic.data.service.ServiceMapper
 import com.wire.kalium.logic.data.team.TeamMapper
 import com.wire.kalium.logic.data.team.TeamMapperImpl
 import com.wire.kalium.logic.data.user.AvailabilityStatusMapper
@@ -170,7 +172,7 @@ internal object MapperProvider {
     fun protocolInfoMapper(): ProtocolInfoMapper = ProtocolInfoMapperImpl()
     fun receiptModeMapper(): ReceiptModeMapper = ReceiptModeMapperImpl()
     fun sendMessagePartialFailureMapper(): SendMessagePartialFailureMapper = SendMessagePartialFailureMapperImpl()
-
     fun serviceMapper(): ServiceMapper = ServiceMapper()
+    fun addingMembersFailureMapper(): AddingMembersFailureMapper = AddingMembersFailureMapperImpl()
 
 }

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/auth/LoginUseCase.kt

@@ -136,7 +136,7 @@ internal class LoginUseCaseImpl internal constructor(
                 when (it) {
                     is NetworkFailure.ProxyError -> AuthenticationResult.Failure.SocketError
                     is NetworkFailure.ServerMiscommunication -> handleServerMiscommunication(it, isEmail, cleanUserIdentifier)
-                    is NetworkFailure.NoNetworkConnection, NetworkFailure.FederatedBackendFailure ->
+                    is NetworkFailure.NoNetworkConnection, is NetworkFailure.FederatedBackendFailure ->
                         AuthenticationResult.Failure.Generic(it)
                 }
             }, {

logic/src/commonTest/kotlin/com/wire/kalium/logic/data/conversation/AddingMembersFailureMapperTest.kt

@@ -0,0 +1,70 @@
+/*
+ * Wire
+ * Copyright (C) 2023 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.data.conversation
+
+import com.wire.kalium.logic.NetworkFailure
+import com.wire.kalium.logic.framework.TestUser
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class AddingMembersFailureMapperTest {
+
+    private val addingMembersFailureMapper = AddingMembersFailureMapperImpl()
+
+    @Test
+    fun givenUsersIdsAndDomainsError_whenMapping_thenShouldSplitIntoValidAndNotValidUserIds() {
+        // When
+        val mappedRequestState = addingMembersFailureMapper.mapToUsersRequestState(
+            initialUsersIds = initialUserIdList,
+            federatedBackendFailure = NetworkFailure.FederatedBackendFailure("federated-label", unreachableDomains)
+        )
+
+        // Then
+        assertEquals(TestUser.OTHER_USER_ID, mappedRequestState.usersThatCanBeAdded.first())
+        assertEquals(TestUser.OTHER_FEDERATED_USER_ID, mappedRequestState.usersThatCannotBeAdded.first())
+    }
+
+    @Test
+    fun givenUsersIdsADomainsErrorAndPreviousFailedIds_whenMapping_thenShouldSplitConsideringPreviousFailedIds() {
+        // When
+        val mappedRequestState = addingMembersFailureMapper.mapToUsersRequestState(
+            initialUsersIds = initialUserIdList,
+            federatedBackendFailure = NetworkFailure.FederatedBackendFailure("federated-label", unreachableDomains),
+            previousUserIdsExcluded = previousFailedIds
+        )
+
+        // Then
+        assertEquals(TestUser.OTHER_USER_ID, mappedRequestState.usersThatCanBeAdded.first())
+        assertEquals(2, mappedRequestState.usersThatCannotBeAdded.size)
+        assertTrue {
+            mappedRequestState.usersThatCannotBeAdded.containsAll(
+                listOf(
+                    TestUser.OTHER_FEDERATED_USER_ID,
+                    TestUser.OTHER_FEDERATED_USER_ID_2
+                )
+            )
+        }
+    }
+
+    private companion object {
+        val initialUserIdList = listOf(TestUser.OTHER_USER_ID, TestUser.OTHER_FEDERATED_USER_ID)
+        val previousFailedIds = setOf(TestUser.OTHER_FEDERATED_USER_ID_2)
+        val unreachableDomains = listOf("otherDomain")
+    }
+}