logic/com.wire.kalium.logic.data.client/ClientDataSource

ClientDataSource

internal class ClientDataSource(clientRemoteRepository: ClientRemoteRepository, clientRegistrationStorage: ClientRegistrationStorage, clientDAO: ClientDAO, newClientDAO: NewClientDAO, selfUserID: UserId, clientApi: ClientApi, clientMapper: ClientMapper = MapperProvider.clientMapper()) : ClientRepository

Constructors

ClientDataSource

constructor(clientRemoteRepository: ClientRemoteRepository, clientRegistrationStorage: ClientRegistrationStorage, clientDAO: ClientDAO, newClientDAO: NewClientDAO, selfUserID: UserId, clientApi: ClientApi, clientMapper: ClientMapper = MapperProvider.clientMapper())

Functions

clearClientHasConsumableNotifications

open suspend override fun clearClientHasConsumableNotifications(): Either<CoreFailure, Unit>

clearClientRegistrationBlockedByE2EI

open suspend override fun clearClientRegistrationBlockedByE2EI(): Either<CoreFailure, Unit>

clearCurrentClientId

open suspend override fun clearCurrentClientId(): Either<CoreFailure, Unit>

clearHasRegisteredMLSClient

open suspend override fun clearHasRegisteredMLSClient(): Either<CoreFailure, Unit>

clearNewClients

open suspend override fun clearNewClients()

clearRetainedClientId

open suspend override fun clearRetainedClientId(): Either<CoreFailure, Unit>

currentClientId

open suspend override fun currentClientId(): Either<CoreFailure, ClientId>

deleteClient

open suspend override fun deleteClient(param: DeleteClientParam): Either<NetworkFailure, Unit>

deregisterToken

open suspend override fun deregisterToken(token: String): Either<NetworkFailure, Unit>

getClientsByConversationId

open suspend override fun getClientsByConversationId(conversationId: ConversationId): Either<StorageFailure, Map<UserId, List<Client>>>

getClientsByUserId

open suspend override fun getClientsByUserId(userId: UserId): Either<StorageFailure, List<OtherUserClient>>

hasRegisteredMLSClient

open suspend override fun hasRegisteredMLSClient(): Either<CoreFailure, Boolean>

isClientRegistrationBlockedByE2EI

open suspend override fun isClientRegistrationBlockedByE2EI(): Either<CoreFailure, Boolean>

observeClientHasConsumableNotifications

open suspend override fun observeClientHasConsumableNotifications(): Flow<Boolean>

observeClientsByUserId

open override fun observeClientsByUserId(userId: UserId): Flow<Either<StorageFailure, List<Client>>>

observeClientsByUserIdAndClientId

open suspend override fun observeClientsByUserIdAndClientId(userId: UserId, clientId: ClientId): Flow<Either<StorageFailure, Client>>

observeCurrentClientId

open suspend override fun observeCurrentClientId(): Flow<ClientId?>

observeIsClientRegistrationBlockedByE2EI

open suspend override fun observeIsClientRegistrationBlockedByE2EI(): Flow<Boolean>

observeNewClients

open override fun observeNewClients(): Flow<Either<StorageFailure, List<Client>>>

persistClientHasConsumableNotifications

open suspend override fun persistClientHasConsumableNotifications(hasConsumableNotifications: Boolean): Either<CoreFailure, Unit>

persistClientId

open suspend override fun persistClientId(clientId: ClientId): Either<CoreFailure, Unit>

persistRetainedClientId

open suspend override fun persistRetainedClientId(clientId: ClientId): Either<CoreFailure, Unit>

registerClient

open suspend override fun registerClient(param: RegisterClientParameters): Either<NetworkFailure, Client>

registerMLSClient

open suspend override fun registerMLSClient(clientId: ClientId, publicKey: ByteArray, cipherSuite: CipherSuite): Either<CoreFailure, Unit>

registerToken

open suspend override fun registerToken(senderId: String, client: String, token: String, transport: String): Either<NetworkFailure, Unit>

removeClientsAndReturnUsersWithNoClients

open suspend override fun removeClientsAndReturnUsersWithNoClients(redundantClientsOfUsers: Map<UserId, List<ClientId>>): Either<StorageFailure, List<UserId>>

retainedClientId

open suspend override fun retainedClientId(): Either<CoreFailure, ClientId>

saveNewClientEvent

open suspend override fun saveNewClientEvent(newClientEvent: Event.User.NewClient): Either<CoreFailure, Unit>

selfListOfClients

open suspend override fun selfListOfClients(): Either<NetworkFailure, List<Client>>

fetches the clients from the backend and stores them in the database

setClientRegistrationBlockedByE2EI

open suspend override fun setClientRegistrationBlockedByE2EI(): Either<CoreFailure, Unit>

setHasRegisteredMLSClient

open suspend override fun setHasRegisteredMLSClient(): Either<CoreFailure, Unit>

storeMapOfUserToClientId

open suspend override fun storeMapOfUserToClientId(userToClientMap: Map<UserId, List<ClientId>>): Either<StorageFailure, Unit>

storeUserClientIdList

open suspend override fun storeUserClientIdList(userId: UserId, clients: List<ClientId>): Either<StorageFailure, Unit>

storeUserClientListAndRemoveRedundantClients

open suspend override fun storeUserClientListAndRemoveRedundantClients(clients: List<InsertClientParam>): Either<StorageFailure, Unit>

tryMarkClientsAsValid

open suspend override fun tryMarkClientsAsValid(userToClientMap: Map<UserId, List<ClientId>>): Either<StorageFailure, Unit>

updateClientProteusVerificationStatus

open suspend override fun updateClientProteusVerificationStatus(userId: UserId, clientId: ClientId, verified: Boolean): Either<StorageFailure, Unit>