logic/com.wire.kalium.logic.data.message/MessageDataSource

MessageDataSource

internal class MessageDataSource(selfUserId: UserId, messageApi: MessageApi, mlsMessageApi: MLSMessageApi, messageDAO: MessageDAO, sendMessageFailureMapper: SendMessageFailureMapper = MapperProvider.sendMessageFailureMapper(), messageMapper: MessageMapper = MapperProvider.messageMapper(selfUserId), linkPreviewMapper: LinkPreviewMapper = MapperProvider.linkPreviewMapper(), messageMentionMapper: MessageMentionMapper = MapperProvider.messageMentionMapper(selfUserId), receiptModeMapper: ReceiptModeMapper = MapperProvider.receiptModeMapper(), sendMessagePartialFailureMapper: SendMessagePartialFailureMapper = MapperProvider.sendMessagePartialFailureMapper(), notificationMapper: LocalNotificationMessageMapper = LocalNotificationMessageMapperImpl()) : MessageRepository

Constructors

MessageDataSource

internal constructor(selfUserId: UserId, messageApi: MessageApi, mlsMessageApi: MLSMessageApi, messageDAO: MessageDAO, sendMessageFailureMapper: SendMessageFailureMapper = MapperProvider.sendMessageFailureMapper(), messageMapper: MessageMapper = MapperProvider.messageMapper(selfUserId), linkPreviewMapper: LinkPreviewMapper = MapperProvider.linkPreviewMapper(), messageMentionMapper: MessageMentionMapper = MapperProvider.messageMentionMapper(selfUserId), receiptModeMapper: ReceiptModeMapper = MapperProvider.receiptModeMapper(), sendMessagePartialFailureMapper: SendMessagePartialFailureMapper = MapperProvider.sendMessagePartialFailureMapper(), notificationMapper: LocalNotificationMessageMapper = LocalNotificationMessageMapperImpl())

Properties

extensions

open override val extensions: MessageRepositoryExtensions

Functions

broadcastEnvelope

open suspend override fun broadcastEnvelope(envelope: MessageEnvelope, messageOption: BroadcastMessageOption): Either<CoreFailure, Instant>

claimFailedMessageForRetry

open suspend override fun claimFailedMessageForRetry(conversationId: ConversationId, messageUuid: String): Either<StorageFailure, Boolean>

deleteMessage

open suspend override fun deleteMessage(messageUuid: String, conversationId: ConversationId): Either<CoreFailure, Unit>

getAllAlreadyEndedEphemeralMessages

open suspend override fun getAllAlreadyEndedEphemeralMessages(): Either<CoreFailure, List<Message>>

getAllAssetIdsFromConversationId

open suspend override fun getAllAssetIdsFromConversationId(conversationId: ConversationId): Either<StorageFailure, List<String>>

getAllPendingEphemeralMessages

open suspend override fun getAllPendingEphemeralMessages(): Either<CoreFailure, List<Message>>

getAllPendingMessagesFromUser

open suspend override fun getAllPendingMessagesFromUser(senderUserId: UserId): Either<CoreFailure, List<Message>>

getImageAssetMessagesByConversationId

open suspend override fun getImageAssetMessagesByConversationId(conversationId: ConversationId, limit: Int, offset: Int): List<AssetMessage>

getLastMessagesForConversationIds

open suspend override fun getLastMessagesForConversationIds(conversationIdList: List<ConversationId>): Either<StorageFailure, Map<ConversationId, Message>>

getMessageAssetTransferStatus

open suspend override fun getMessageAssetTransferStatus(messageId: String, conversationId: ConversationId): Either<StorageFailure, AssetTransferStatus>

getMessageById

open suspend override fun getMessageById(conversationId: ConversationId, messageUuid: String): Either<StorageFailure, Message>

getMessagesByConversationIdAndVisibility

open override fun getMessagesByConversationIdAndVisibility(conversationId: ConversationId, limit: Int, offset: Int, visibility: List<Message.Visibility> = Message.Visibility.entries): Flow<List<Message>>

getMessagesByConversationIdAndVisibilityAfterDate

open override fun getMessagesByConversationIdAndVisibilityAfterDate(conversationId: ConversationId, date: String, visibility: List<Message.Visibility> = Message.Visibility.entries): Flow<List<Message>>

getNextAudioMessageInConversation

open suspend override fun getNextAudioMessageInConversation(conversationId: ConversationId, messageId: String): Either<CoreFailure, String>

getNotificationMessage

open suspend override fun getNotificationMessage(messageSizePerConversation: Int = 10): Either<CoreFailure, List<LocalNotification>>

getPendingConfirmationMessagesByConversationAfterDate

open suspend override fun getPendingConfirmationMessagesByConversationAfterDate(conversationId: ConversationId, afterDateTime: Instant, untilDateTime: Instant, visibility: List<Message.Visibility> = Message.Visibility.entries): Either<CoreFailure, Map<UserId, List<String>>>

getReceiptModeFromGroupConversationByQualifiedID

open suspend override fun getReceiptModeFromGroupConversationByQualifiedID(conversationId: ConversationId): Either<CoreFailure, Conversation.ReceiptMode?>

getSearchedConversationMessagePosition

open suspend override fun getSearchedConversationMessagePosition(conversationId: ConversationId, messageId: String): Either<StorageFailure, Int>

getSenderNameByMessageId

open suspend override fun getSenderNameByMessageId(conversationId: ConversationId, messageId: String): Either<CoreFailure, String>

markMessageAsDeleted

open suspend override fun markMessageAsDeleted(messageUuid: String, conversationId: ConversationId): Either<StorageFailure, Unit>

markProteusMessagesAsDecryptionResolved

open suspend override fun markProteusMessagesAsDecryptionResolved(userId: UserId, clientId: ClientId): Either<CoreFailure, Unit>

markSelfDeletionEndDate

open suspend override fun markSelfDeletionEndDate(conversationId: ConversationId, messageUuid: String, deletionEndDate: Instant): Either<CoreFailure, Unit>

moveMessagesToAnotherConversation

open suspend override fun moveMessagesToAnotherConversation(originalConversation: ConversationId, targetConversation: ConversationId): Either<StorageFailure, Unit>

observeAssetStatuses

open override fun observeAssetStatuses(): Flow<Either<StorageFailure, List<AssetTransferStatus>>>

open override fun observeAssetStatuses(conversationId: ConversationId): Flow<Either<StorageFailure, List<MessageAssetStatus>>>

observeMessageById

open override fun observeMessageById(conversationId: ConversationId, messageUuid: String): Flow<Either<StorageFailure, Message>>

observeMessageVisibility

open override fun observeMessageVisibility(messageUuid: String, conversationId: ConversationId): Flow<Either<StorageFailure, MessageEntity.Visibility>>

persistMessage

open suspend override fun persistMessage(message: Message.Standalone, updateConversationModifiedDate: Boolean = false): Either<CoreFailure, InsertMessageResult>

this fun should never be used directly, use PersistMessageUseCase() instead

persistNoClientsToDeliverFailure

open suspend override fun persistNoClientsToDeliverFailure(conversationId: ConversationId, messageUuid: String, usersWithFailedDeliveryList: List<UserId>): Either<CoreFailure, Unit>

Persist a list of users ids whose clients are missing and could not be retrieved RecipientFailureTypeEntity.NO_CLIENTS_TO_DELIVER

persistRecipientsDeliveryFailure

open suspend override fun persistRecipientsDeliveryFailure(conversationId: ConversationId, messageUuid: String, usersWithFailedDeliveryList: List<UserId>): Either<CoreFailure, Unit>

Persist a list of users ids that failed to receive the message RecipientFailureTypeEntity.MESSAGE_DELIVERY_FAILED

persistSystemMessageToAllConversations

open suspend override fun persistSystemMessageToAllConversations(message: Message.System): Either<CoreFailure, Unit>

promoteMessageToSentUpdatingServerTime

open suspend override fun promoteMessageToSentUpdatingServerTime(conversationId: ConversationId, messageUuid: String, serverDate: Instant?, millis: Long): Either<CoreFailure, Unit>

resetAssetTransferStatus

open suspend override fun resetAssetTransferStatus()

searchMessagesByText

open suspend override fun searchMessagesByText(conversationId: ConversationId, searchQuery: String, limit: Int, offset: Int): Either<StorageFailure, List<Message.Standalone>>

Search messages in a conversation by text content.

searchMessagesByTextGlobally

open suspend override fun searchMessagesByTextGlobally(searchQuery: String, limit: Int, offset: Int): Either<StorageFailure, List<Message.Standalone>>

Search messages across all conversations by text content.

sendEnvelope

open suspend override fun sendEnvelope(conversationId: ConversationId, envelope: MessageEnvelope, messageTarget: MessageTarget): Either<CoreFailure, MessageSent>

sendMLSMessage

open suspend override fun sendMLSMessage(message: MLSMessageApi.Message): Either<CoreFailure, MessageSent>

updateAssetMessageTransferStatus

open suspend override fun updateAssetMessageTransferStatus(transferStatus: AssetTransferStatus, conversationId: ConversationId, messageUuid: String): Either<CoreFailure, Unit>

updateAudioMessageNormalizedLoudness

open suspend override fun updateAudioMessageNormalizedLoudness(conversationId: ConversationId, messageId: String, normalizedLoudness: ByteArray): Either<CoreFailure, Unit>

updateCompositeMessage

open suspend override fun updateCompositeMessage(conversationId: ConversationId, messageContent: MessageContent.CompositeEdited, newMessageId: MessageId, editInstant: Instant): Either<StorageFailure, Unit>

updateLegalHoldMessageMembers

open suspend override fun updateLegalHoldMessageMembers(messageId: String, conversationId: ConversationId, newMembers: List<UserId>): Either<CoreFailure, Unit>

updateLinkPreviewImageLocalPath

open suspend override fun updateLinkPreviewImageLocalPath(conversationId: ConversationId, messageId: String, urlOffset: Int, localPath: String): Either<CoreFailure, Unit>

updateMessagesStatus

open suspend override fun updateMessagesStatus(messageStatus: MessageEntity.Status, conversationId: ConversationId, messageUuids: List<String>): Either<StorageFailure, Unit>

updateMessagesStatusIfNotRead

open suspend override fun updateMessagesStatusIfNotRead(messageStatus: MessageEntity.Status, conversationId: ConversationId, messageIds: List<String>): Either<CoreFailure, Unit>

updateMessageStatus

open suspend override fun updateMessageStatus(messageStatus: MessageEntity.Status, conversationId: ConversationId, messageUuid: String): Either<StorageFailure, Unit>

updateMessageStatusIfNotAcknowledged

open suspend override fun updateMessageStatusIfNotAcknowledged(messageStatus: MessageEntity.Status, conversationId: ConversationId, messageUuid: String): Either<StorageFailure, Unit>

updateMultipartMessage

open suspend override fun updateMultipartMessage(conversationId: ConversationId, messageContent: MessageContent.MultipartEdited, newMessageId: String, editInstant: Instant): Either<CoreFailure, Unit>

updatePendingTextPolicy

open suspend override fun updatePendingTextPolicy(conversationId: ConversationId, messageId: String, expireAfterMillis: Long?, expectsReadConfirmation: Boolean): Either<CoreFailure, Unit>

updateTextMessage

open suspend override fun updateTextMessage(conversationId: ConversationId, messageId: String, messageContent: MessageContent.Text): Either<CoreFailure, Unit>

open suspend override fun updateTextMessage(conversationId: ConversationId, messageContent: MessageContent.TextEdited, newMessageId: String, editInstant: Instant): Either<CoreFailure, Unit>