refactor: user mapper (#1795)

* refactor: consolidate user mapping functions * refactor: delete unused mapping function * refactor: rename user mapping functions for consistency * refactor: move client mappping function to ClientMapper * refactor: deleted unused function * test: resurrect test * chore: delete commented out code Co-authored-by: Vitor Hugo Schwaab <[email protected]> * chore: delete commented out code Co-authored-by: Vitor Hugo Schwaab <[email protected]> --------- Co-authored-by: Vitor Hugo Schwaab <[email protected]>
wireapp · Jun 16, 2023 · ed3bdbb · ed3bdbb
1 parent 36a0f05
commit ed3bdbb
Show file tree

Hide file tree

Showing 14 changed files with 143 additions and 240 deletions.
diff --git a/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/client/ClientMapper.kt b/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/client/ClientMapper.kt
@@ -161,6 +161,11 @@ class ClientMapper(
         ClientCapabilityDTO.LegalHoldImplicitConsent -> ClientCapability.LegalHoldImplicitConsent
     }
 
+    fun fromOtherUsersClientsDTO(otherUsersClients: List<ClientEntity>): List<OtherUserClient> =
+        otherUsersClients.map {
+            OtherUserClient(fromDeviceTypeEntity(it.deviceType), it.id, it.isValid, it.isVerified)
+        }
+
     private fun toDeviceTypeDTO(deviceType: DeviceType): DeviceTypeDTO = when (deviceType) {
         DeviceType.Phone -> DeviceTypeDTO.Phone
         DeviceType.Tablet -> DeviceTypeDTO.Tablet

diff --git a/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/client/ClientRepository.kt b/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/client/ClientRepository.kt
@@ -198,7 +198,7 @@ class ClientDataSource(
         wrapStorageRequest {
             clientDAO.getClientsOfUserByQualifiedID(userId.toDao())
         }.map { clientsList ->
-            userMapper.fromOtherUsersClientsDTO(clientsList)
+            clientMapper.fromOtherUsersClientsDTO(clientsList)
         }
 
     override suspend fun observeClientsByUserId(userId: UserId): Flow<Either<StorageFailure, List<Client>>> =

diff --git a/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/connection/ConnectionMapper.kt b/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/connection/ConnectionMapper.kt
@@ -68,14 +68,14 @@ internal class ConnectionMapperImpl(
             qualifiedToId = qualifiedToId.toModel(),
             status = statusMapper.fromDaoModel(status),
             toId = toId,
-            fromUser = otherUser?.let { publicUserMapper.fromDaoModelToPublicUser(it) }
+            fromUser = otherUser?.let { publicUserMapper.fromUserEntityToOtherUser(it) }
         )
     }
 
     override fun fromDaoToConversationDetails(connection: ConnectionEntity): ConversationDetails = with(connection) {
         ConversationDetails.Connection(
             conversationId = qualifiedConversationId.toModel(),
-            otherUser = otherUser?.let { publicUserMapper.fromDaoModelToPublicUser(it) },
+            otherUser = otherUser?.let { publicUserMapper.fromUserEntityToOtherUser(it) },
             userType = otherUser?.let { userTypeMapper.fromUserTypeEntity(it.userType) } ?: UserType.GUEST,
             lastModifiedDate = lastUpdateDate.toIsoDateTimeString(),
             connection = fromDaoToModel(this),

diff --git a/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/connection/ConnectionRepository.kt b/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/connection/ConnectionRepository.kt
@@ -26,10 +26,8 @@ import com.wire.kalium.logic.data.conversation.ConversationDetails
 import com.wire.kalium.logic.data.conversation.ConversationRepository
 import com.wire.kalium.logic.data.event.Event
 import com.wire.kalium.logic.data.id.ConversationId
-import com.wire.kalium.logic.data.id.IdMapper
 import com.wire.kalium.logic.data.id.toApi
 import com.wire.kalium.logic.data.id.toDao
-import com.wire.kalium.logic.data.publicuser.PublicUserMapper
 import com.wire.kalium.logic.data.user.Connection
 import com.wire.kalium.logic.data.user.ConnectionState
 import com.wire.kalium.logic.data.user.ConnectionState.ACCEPTED
@@ -41,6 +39,7 @@ import com.wire.kalium.logic.data.user.ConnectionState.NOT_CONNECTED
 import com.wire.kalium.logic.data.user.ConnectionState.PENDING
 import com.wire.kalium.logic.data.user.ConnectionState.SENT
 import com.wire.kalium.logic.data.user.UserId
+import com.wire.kalium.logic.data.user.UserMapper
 import com.wire.kalium.logic.data.user.type.UserEntityTypeMapper
 import com.wire.kalium.logic.di.MapperProvider
 import com.wire.kalium.logic.failure.InvalidMappingFailure
@@ -91,10 +90,9 @@ internal class ConnectionDataSource(
     private val selfUserId: UserId,
     private val selfTeamIdProvider: SelfTeamIdProvider,
     private val conversationRepository: ConversationRepository,
-    private val idMapper: IdMapper = MapperProvider.idMapper(),
     private val connectionStatusMapper: ConnectionStatusMapper = MapperProvider.connectionStatusMapper(),
     private val connectionMapper: ConnectionMapper = MapperProvider.connectionMapper(),
-    private val publicUserMapper: PublicUserMapper = MapperProvider.publicUserMapper(),
+    private val userMapper: UserMapper = MapperProvider.userMapper(),
     private val userTypeEntityTypeMapper: UserEntityTypeMapper = MapperProvider.userTypeEntityMapper()
 ) : ConnectionRepository {
 
@@ -215,8 +213,8 @@ internal class ConnectionDataSource(
                 }
             }, { userProfileDTO ->
                 wrapStorageRequest {
-                    val userEntity = publicUserMapper.fromUserApiToEntityWithConnectionStateAndUserTypeEntity(
-                        userDetailResponse = userProfileDTO,
+                    val userEntity = userMapper.fromUserProfileDtoToUserEntity(
+                        userProfile = userProfileDTO,
                         connectionState = connectionStatusMapper.toDaoModel(state = connection.status),
                         userTypeEntity = userTypeEntityTypeMapper.fromTeamAndDomain(
                             otherUserDomain = userProfileDTO.id.domain,

diff --git a/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/publicuser/PublicUserMapper.kt b/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/publicuser/PublicUserMapper.kt
@@ -18,7 +18,6 @@
 
 package com.wire.kalium.logic.data.publicuser
 
-import com.wire.kalium.logic.data.id.IdMapper
 import com.wire.kalium.logic.data.id.QualifiedID
 import com.wire.kalium.logic.data.id.TeamId
 import com.wire.kalium.logic.data.id.toDao
@@ -39,42 +38,28 @@ import com.wire.kalium.network.api.base.model.UserProfileDTO
 import com.wire.kalium.network.api.base.model.getCompleteAssetOrNull
 import com.wire.kalium.network.api.base.model.getPreviewAssetOrNull
 import com.wire.kalium.persistence.dao.BotIdEntity
-import com.wire.kalium.persistence.dao.ConnectionEntity
-import com.wire.kalium.persistence.dao.QualifiedIDEntity
-import com.wire.kalium.persistence.dao.UserAvailabilityStatusEntity
 import com.wire.kalium.persistence.dao.UserEntity
 import com.wire.kalium.persistence.dao.UserEntityMinimized
-import com.wire.kalium.persistence.dao.UserTypeEntity
 
 interface PublicUserMapper {
-    fun fromDaoModelToPublicUser(userEntity: UserEntity): OtherUser
-    fun fromPublicUserToDaoModel(otherUser: OtherUser): UserEntity
-    fun fromDaoModelToPublicUserMinimized(userEntity: UserEntityMinimized): OtherUserMinimized
-    fun fromUserDetailResponseWithUsertype(
+    fun fromUserEntityToOtherUser(userEntity: UserEntity): OtherUser
+    fun fromOtherToUserEntity(otherUser: OtherUser): UserEntity
+    fun fromUserEntityToOtherUserMinimized(userEntity: UserEntityMinimized): OtherUserMinimized
+    fun fromUserProfileDtoToOtherUser(
         userDetailResponse: UserProfileDTO,
         // UserProfileDTO has no info about userType, we need to pass it explicitly
         userType: UserType
     ): OtherUser
-
-    // TODO:I think we are making too complicated parsers,
-    // maybe a good solution will be fetching self user when we are saving other users to db?
-    fun fromUserApiToEntityWithConnectionStateAndUserTypeEntity(
-        userDetailResponse: UserProfileDTO,
-        connectionState: ConnectionEntity.State,
-        // UserProfileDTO has no info about userType, we need to pass it explicitly
-        userTypeEntity: UserTypeEntity
-    ): UserEntity
 }
 
 class PublicUserMapperImpl(
-    private val idMapper: IdMapper,
     private val availabilityStatusMapper: AvailabilityStatusMapper = MapperProvider.availabilityStatusMapper(),
     private val connectionStateMapper: ConnectionStateMapper = MapperProvider.connectionStateMapper(),
     private val domainUserTypeMapper: DomainUserTypeMapper = MapperProvider.userTypeMapper(),
     private val userEntityTypeMapper: UserEntityTypeMapper = MapperProvider.userTypeEntityMapper()
 ) : PublicUserMapper {
 
-    override fun fromDaoModelToPublicUser(userEntity: UserEntity) = OtherUser(
+    override fun fromUserEntityToOtherUser(userEntity: UserEntity) = OtherUser(
         id = userEntity.id.toModel(),
         name = userEntity.name,
         handle = userEntity.handle,
@@ -91,7 +76,7 @@ class PublicUserMapperImpl(
         deleted = userEntity.deleted
     )
 
-    override fun fromPublicUserToDaoModel(otherUser: OtherUser): UserEntity = with(otherUser) {
+    override fun fromOtherToUserEntity(otherUser: OtherUser): UserEntity = with(otherUser) {
         UserEntity(
             id = id.toDao(),
             name = name,
@@ -110,15 +95,15 @@ class PublicUserMapperImpl(
         )
     }
 
-    override fun fromDaoModelToPublicUserMinimized(userEntity: UserEntityMinimized): OtherUserMinimized =
+    override fun fromUserEntityToOtherUserMinimized(userEntity: UserEntityMinimized): OtherUserMinimized =
         OtherUserMinimized(
             id = userEntity.id.toModel(),
             name = userEntity.name,
             completePicture = userEntity.completeAssetId?.toModel(),
             userType = domainUserTypeMapper.fromUserTypeEntity(userEntity.userType),
         )
 
-    override fun fromUserDetailResponseWithUsertype(
+    override fun fromUserProfileDtoToOtherUser(
         userDetailResponse: UserProfileDTO,
         userType: UserType
     ) = OtherUser(
@@ -137,28 +122,4 @@ class PublicUserMapperImpl(
         botService = userDetailResponse.service?.let { BotService(it.id, it.provider) },
         deleted = userDetailResponse.deleted ?: false
     )
-
-    override fun fromUserApiToEntityWithConnectionStateAndUserTypeEntity(
-        userDetailResponse: UserProfileDTO,
-        connectionState: ConnectionEntity.State,
-        userTypeEntity: UserTypeEntity
-    ) = UserEntity(
-        id = idMapper.fromApiToDao(userDetailResponse.id),
-        name = userDetailResponse.name,
-        handle = userDetailResponse.handle,
-        email = userDetailResponse.email,
-        phone = null,
-        accentId = userDetailResponse.accentId,
-        team = userDetailResponse.teamId,
-        previewAssetId = userDetailResponse.assets.getPreviewAssetOrNull()
-            ?.let { QualifiedIDEntity(it.key, userDetailResponse.id.domain) },
-        completeAssetId = userDetailResponse.assets.getCompleteAssetOrNull()
-            ?.let { QualifiedIDEntity(it.key, userDetailResponse.id.domain) },
-        connectionStatus = connectionState,
-        availabilityStatus = UserAvailabilityStatusEntity.NONE,
-        userType = userTypeEntity,
-        botService = userDetailResponse.service?.let { BotIdEntity(it.id, it.provider) },
-        deleted = userDetailResponse.deleted ?: false
-    )
-
 }
diff --git a/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/publicuser/SearchUserRepository.kt b/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/publicuser/SearchUserRepository.kt
@@ -162,7 +162,7 @@ internal class SearchUserRepositoryImpl(
                 val otherUserList = if (userProfileDTOList.isEmpty()) emptyList() else {
                     val selfUser = getSelfUser()
                     userProfileDTOList.map { userProfileDTO ->
-                        publicUserMapper.fromUserDetailResponseWithUsertype(
+                        publicUserMapper.fromUserProfileDtoToOtherUser(
                             userDetailResponse = userProfileDTO,
                             userType = userTypeMapper.fromTeamAndDomain(
                                 otherUserDomain = userProfileDTO.id.domain,
@@ -190,7 +190,7 @@ internal class SearchUserRepositoryImpl(
 
                 userDAO.getUserByQualifiedID(selfUserID)
                     .filterNotNull()
-                    .map(userMapper::fromDaoModelToSelfUser)
+                    .map(userMapper::fromUserEntityToSelfUser)
             }.firstOrNull() ?: throw IllegalStateException()
     }
 
@@ -205,7 +205,7 @@ internal class SearchUserRepositoryImpl(
         }
 
         return listFlow.map {
-            UserSearchResult(it.map(publicUserMapper::fromDaoModelToPublicUser))
+            UserSearchResult(it.map(publicUserMapper::fromUserEntityToOtherUser))
         }
     }
 

diff --git a/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/publicuser/UserSearchApiWrapper.kt b/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/publicuser/UserSearchApiWrapper.kt
@@ -140,7 +140,7 @@ internal class UserSearchApiWrapperImpl(
 
                 userDAO.getUserByQualifiedID(selfUserID)
                     .filterNotNull()
-                    .map(userMapper::fromDaoModelToSelfUser)
+                    .map(userMapper::fromUserEntityToSelfUser)
             }.firstOrNull() ?: throw IllegalStateException()
     }
 }
diff --git a/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/team/TeamRepository.kt b/logic/src/commonMain/kotlin/com/wire/kalium/logic/data/team/TeamRepository.kt
@@ -21,10 +21,10 @@ package com.wire.kalium.logic.data.team
 import com.wire.kalium.logic.CoreFailure
 import com.wire.kalium.logic.data.id.ConversationId
 import com.wire.kalium.logic.data.id.TeamId
-import com.wire.kalium.logic.data.id.toApi
 import com.wire.kalium.logic.data.service.ServiceMapper
 import com.wire.kalium.logic.data.user.UserId
 import com.wire.kalium.logic.data.user.UserMapper
+import com.wire.kalium.logic.data.user.type.UserEntityTypeMapper
 import com.wire.kalium.logic.di.MapperProvider
 import com.wire.kalium.logic.functional.Either
 import com.wire.kalium.logic.functional.flatMap
@@ -34,6 +34,7 @@ import com.wire.kalium.logic.wrapStorageRequest
 import com.wire.kalium.network.api.base.authenticated.TeamsApi
 import com.wire.kalium.network.api.base.authenticated.userDetails.UserDetailsApi
 import com.wire.kalium.network.api.base.model.QualifiedID
+import com.wire.kalium.persistence.dao.ConnectionEntity
 import com.wire.kalium.persistence.dao.QualifiedIDEntity
 import com.wire.kalium.persistence.dao.ServiceDAO
 import com.wire.kalium.persistence.dao.TeamDAO
@@ -63,7 +64,8 @@ internal class TeamDataSource(
     private val serviceDAO: ServiceDAO,
     private val userMapper: UserMapper = MapperProvider.userMapper(),
     private val teamMapper: TeamMapper = MapperProvider.teamMapper(),
-    private val serviceMapper: ServiceMapper = MapperProvider.serviceMapper()
+    private val serviceMapper: ServiceMapper = MapperProvider.serviceMapper(),
+    private val userTypeEntityTypeMapper: UserEntityTypeMapper = MapperProvider.userTypeEntityMapper()
 ) : TeamRepository {
 
     override suspend fun fetchTeamById(teamId: TeamId): Either<CoreFailure, Team> = wrapApiRequest {
@@ -137,17 +139,22 @@ internal class TeamDataSource(
                 teamId = teamId,
                 userId = userId,
             )
-        }.flatMap { member ->
+        }.flatMap { _ ->
             wrapApiRequest { userDetailsApi.getUserInfo(userId = QualifiedID(userId, selfUserId.domain)) }
-                .flatMap { userProfile ->
+                .flatMap { userProfileDTO ->
                     wrapStorageRequest {
-                        val user = userMapper.apiToEntity(
-                            user = userProfile,
-                            member = member,
-                            teamId = teamId,
-                            selfUser = selfUserId.toApi()
+                        val userEntity = userMapper.fromUserProfileDtoToUserEntity(
+                            userProfile = userProfileDTO,
+                            connectionState = ConnectionEntity.State.ACCEPTED,
+                            userTypeEntity = userTypeEntityTypeMapper.fromTeamAndDomain(
+                                otherUserDomain = userProfileDTO.id.domain,
+                                selfUserTeamId = teamId,
+                                otherUserTeamId = userProfileDTO.teamId,
+                                selfUserDomain = selfUserId.domain,
+                                isService = userProfileDTO.service != null
+                            )
                         )
-                        userDAO.insertUser(user)
+                        userDAO.insertUser(userEntity)
                     }
                 }
         }