[wip] chat materials; some experiments with local composition and blur

core/data/src/main/kotlin/com/meloda/app/fast/data/LongPollUpdatesParser.kt

@@ -231,13 +231,13 @@ class LongPollUpdatesParser(
         Log.d("LongPollUpdatesParser", "$eventType: $event")
     }
 
-    private suspend fun <T : LongPollEvent> loadNormalMessage(
+    private suspend inline fun <reified T : LongPollEvent> loadNormalMessage(
         eventType: ApiEvent,
         messageId: Int
-    ): T? = suspendCoroutine {
+    ): T? = suspendCoroutine { continuation ->
         coroutineScope.launch(Dispatchers.IO) {
             messagesUseCase.getById(
-                messageId = messageId,
+                messageIds = listOf(messageId),
                 extended = true,
                 fields = VkConstants.ALL_FIELDS
             ).listenValue(this) { state ->
@@ -245,20 +245,26 @@ class LongPollUpdatesParser(
                     error = { error ->
                         Log.e("LongPollUpdatesParser", "loadNormalMessage: error: $error")
                     },
-                    success = { response ->
-                        response?.let { message ->
-                            VkMemoryCache[message.id] = message
-                            messagesUseCase.storeMessage(message)
+                    success = { messages ->
+                        val message = messages.singleOrNull() ?: run {
+                            continuation.resume(null)
+                            return@listenValue
+                        }
 
-                            val resumeValue: LongPollEvent? = when (eventType) {
-                                ApiEvent.MESSAGE_NEW -> LongPollEvent.VkMessageNewEvent(message)
-                                ApiEvent.MESSAGE_EDIT -> LongPollEvent.VkMessageEditEvent(message)
+                        VkMemoryCache[message.id] = message
+                        messagesUseCase.storeMessage(message)
 
-                                else -> null
+                        val resumeValue: LongPollEvent? = when (eventType) {
+                            ApiEvent.MESSAGE_NEW -> LongPollEvent.VkMessageNewEvent(message)
+                            ApiEvent.MESSAGE_EDIT -> LongPollEvent.VkMessageEditEvent(message)
+
+                            else -> {
+                                continuation.resume(null)
+                                null
                             }
+                        }
 
-                            resumeValue?.let { value -> it.resume(value as T) }
-                        } ?: it.resume(null)
+                        resumeValue?.let { value -> continuation.resume(value as T) }
                     }
                 )
             }

core/data/src/main/kotlin/com/meloda/app/fast/data/api/messages/MessagesHistoryInfo.kt

@@ -0,0 +1,9 @@
+package com.meloda.app.fast.data.api.messages
+
+import com.meloda.app.fast.model.api.domain.VkConversation
+import com.meloda.app.fast.model.api.domain.VkMessage
+
+data class MessagesHistoryInfo(
+    val messages: List<VkMessage>,
+    val conversations: List<VkConversation>
+)

core/data/src/main/kotlin/com/meloda/app/fast/data/api/messages/MessagesLocalDataSource.kt

@@ -1,16 +0,0 @@
-package com.meloda.app.fast.data.api.messages
-
-import com.meloda.app.fast.model.database.VkMessageEntity
-
-interface MessagesLocalDataSource {
-
-    suspend fun getMessages(
-        conversationId: Int,
-        offset: Int?,
-        count: Int?
-    ): List<VkMessageEntity>
-
-    suspend fun getMessage(messageId: Int): VkMessageEntity?
-
-    suspend fun storeMessages(messages: List<VkMessageEntity>)
-}

core/data/src/main/kotlin/com/meloda/app/fast/data/api/messages/MessagesLocalDataSourceImpl.kt

@@ -1,24 +0,0 @@
-package com.meloda.app.fast.data.api.messages
-
-import com.meloda.app.fast.database.dao.MessageDao
-import com.meloda.app.fast.model.database.VkMessageEntity
-
-// TODO: 05/05/2024, Danil Nikolaev: use paging for room
-class MessagesLocalDataSourceImpl(
-    private val messageDao: MessageDao
-) : MessagesLocalDataSource {
-
-    override suspend fun getMessages(
-        conversationId: Int,
-        offset: Int?,
-        count: Int?
-    ): List<VkMessageEntity> = messageDao.getAll(conversationId)
-
-    override suspend fun getMessage(
-        messageId: Int
-    ): VkMessageEntity? = messageDao.getById(messageId)
-
-    override suspend fun storeMessages(messages: List<VkMessageEntity>) {
-        messageDao.insertAll(messages)
-    }
-}

core/data/src/main/kotlin/com/meloda/app/fast/data/api/messages/MessagesNetworkDataSource.kt

@@ -1,36 +0,0 @@
-package com.meloda.app.fast.data.api.messages
-
-import com.meloda.app.fast.model.api.domain.VkAttachment
-import com.meloda.app.fast.model.api.domain.VkMessage
-import com.meloda.app.fast.network.RestApiErrorDomain
-import com.slack.eithernet.ApiResult
-
-interface MessagesNetworkDataSource {
-
-    suspend fun getMessagesHistory(
-        conversationId: Int,
-        offset: Int?,
-        count: Int?,
-    ): ApiResult<MessagesHistoryDomain, RestApiErrorDomain>
-
-    suspend fun getMessageById(
-        messagesIds: List<Int>,
-        extended: Boolean?,
-        fields: String?
-    ): ApiResult<VkMessage, RestApiErrorDomain>
-
-    suspend fun send(
-        peerId: Int,
-        randomId: Int,
-        message: String?,
-        replyTo: Int?,
-        attachments: List<VkAttachment>?
-    ): ApiResult<Int, RestApiErrorDomain>
-
-    suspend fun markAsRead(
-        peerId: Int,
-        startMessageId: Int?
-    ): ApiResult<Int, RestApiErrorDomain>
-
-    suspend fun getMessage(messageId: Int): VkMessage?
-}

core/data/src/main/kotlin/com/meloda/app/fast/data/api/messages/MessagesNetworkDataSourceImpl.kt

@@ -1,164 +0,0 @@
-package com.meloda.app.fast.data.api.messages
-
-import com.meloda.app.fast.common.VkConstants
-import com.meloda.app.fast.data.VkGroupsMap
-import com.meloda.app.fast.data.VkMemoryCache
-import com.meloda.app.fast.data.VkUsersMap
-import com.meloda.app.fast.model.api.data.VkContactData
-import com.meloda.app.fast.model.api.data.VkGroupData
-import com.meloda.app.fast.model.api.data.VkUserData
-import com.meloda.app.fast.model.api.data.asDomain
-import com.meloda.app.fast.model.api.domain.VkAttachment
-import com.meloda.app.fast.model.api.domain.VkConversation
-import com.meloda.app.fast.model.api.domain.VkMessage
-import com.meloda.app.fast.model.api.requests.MessagesGetByIdRequest
-import com.meloda.app.fast.model.api.requests.MessagesGetHistoryRequest
-import com.meloda.app.fast.model.api.requests.MessagesMarkAsReadRequest
-import com.meloda.app.fast.model.api.requests.MessagesSendRequest
-import com.meloda.app.fast.network.RestApiErrorDomain
-import com.meloda.app.fast.network.mapApiDefault
-import com.meloda.app.fast.network.mapApiResult
-import com.meloda.app.fast.network.service.messages.MessagesService
-import com.slack.eithernet.ApiResult
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-
-class MessagesNetworkDataSourceImpl(
-    private val messagesService: MessagesService
-) : MessagesNetworkDataSource {
-
-    override suspend fun getMessagesHistory(
-        conversationId: Int,
-        offset: Int?,
-        count: Int?
-    ): ApiResult<MessagesHistoryDomain, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        val requestModel = MessagesGetHistoryRequest(
-            count = count,
-            offset = offset,
-            peerId = conversationId,
-            extended = true,
-            startMessageId = null,
-            rev = null,
-            fields = VkConstants.ALL_FIELDS
-        )
-
-        messagesService.getHistory(requestModel.map).mapApiResult(
-            successMapper = { apiResponse ->
-                val response = apiResponse.requireResponse()
-
-                val profilesList = response.profiles.orEmpty().map(VkUserData::mapToDomain)
-                val groupsList = response.groups.orEmpty().map(VkGroupData::mapToDomain)
-                val contactsList = response.contacts.orEmpty().map(VkContactData::mapToDomain)
-
-                val usersMap = VkUsersMap.forUsers(profilesList)
-                val groupsMap = VkGroupsMap.forGroups(groupsList)
-
-                VkMemoryCache.appendUsers(profilesList)
-                VkMemoryCache.appendGroups(groupsList)
-                VkMemoryCache.appendContacts(contactsList)
-
-                val messages = response.items.map { item ->
-                    item.asDomain().let { message ->
-                        message.copy(
-                            user = usersMap.messageUser(message),
-                            group = groupsMap.messageGroup(message),
-                            actionUser = usersMap.messageActionUser(message),
-                            actionGroup = groupsMap.messageActionGroup(message)
-                        ).also { VkMemoryCache[message.id] = it }
-                    }
-                }
-
-                val conversations = response.conversations.orEmpty().map { item ->
-                    val message = messages.firstOrNull { it.id == item.lastMessageId }
-                    item.asDomain(message)
-                        .let { conversation ->
-                            conversation.copy(
-                                user = usersMap.conversationUser(conversation),
-                                group = groupsMap.conversationGroup(conversation)
-                            ).also { VkMemoryCache[conversation.id] = it }
-                        }
-                }
-
-                MessagesHistoryDomain(
-                    messages = messages,
-                    conversations = conversations
-                )
-            },
-            errorMapper = { error ->
-                error?.toDomain()
-            }
-        )
-    }
-
-    override suspend fun getMessageById(
-        messagesIds: List<Int>,
-        extended: Boolean?,
-        fields: String?
-    ): ApiResult<VkMessage, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        val requestModel = MessagesGetByIdRequest(
-            messagesIds = messagesIds,
-            extended = extended,
-            fields = fields
-        )
-
-        messagesService.getById(requestModel.map).mapApiResult(
-            successMapper = { apiResponse ->
-                val response = apiResponse.requireResponse()
-
-                val message = response.items.single()
-                val usersMap =
-                    VkUsersMap.forUsers(response.profiles.orEmpty().map(VkUserData::mapToDomain))
-                val groupsMap =
-                    VkGroupsMap.forGroups(response.groups.orEmpty().map(VkGroupData::mapToDomain))
-
-                message.asDomain().copy(
-                    user = usersMap.messageUser(message),
-                    group = groupsMap.messageGroup(message),
-                    actionUser = usersMap.messageActionUser(message),
-                    actionGroup = groupsMap.messageActionGroup(message)
-                )
-            },
-            errorMapper = { error -> error?.toDomain() }
-        )
-    }
-
-    override suspend fun send(
-        peerId: Int,
-        randomId: Int,
-        message: String?,
-        replyTo: Int?,
-        attachments: List<VkAttachment>?
-    ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        val requestModel = MessagesSendRequest(
-            peerId = peerId,
-            randomId = randomId,
-            message = message,
-            replyTo = replyTo,
-            attachments = attachments
-        )
-
-        messagesService.send(requestModel.map).mapApiDefault()
-    }
-
-    override suspend fun markAsRead(
-        peerId: Int,
-        startMessageId: Int?
-    ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        val requestModel = MessagesMarkAsReadRequest(
-            peerId = peerId,
-            startMessageId = startMessageId
-        )
-
-        messagesService.markAsRead(requestModel.map).mapApiDefault()
-    }
-
-    override suspend fun getMessage(messageId: Int): VkMessage? = withContext(Dispatchers.IO) {
-        // TODO: 05/05/2024, Danil Nikolaev: get message
-        null
-    }
-}
-
-data class MessagesHistoryDomain(
-    val messages: List<VkMessage>,
-    val conversations: List<VkConversation>
-)

core/data/src/main/kotlin/com/meloda/app/fast/data/api/messages/MessagesRepository.kt

@@ -1,24 +1,24 @@
 package com.meloda.app.fast.data.api.messages
 
 import com.meloda.app.fast.model.api.domain.VkAttachment
+import com.meloda.app.fast.model.api.domain.VkAttachmentHistoryMessage
 import com.meloda.app.fast.model.api.domain.VkMessage
 import com.meloda.app.fast.network.RestApiErrorDomain
 import com.slack.eithernet.ApiResult
-import kotlinx.coroutines.flow.Flow
 
 interface MessagesRepository {
 
-    suspend fun getMessagesHistory(
+    suspend fun getHistory(
         conversationId: Int,
         offset: Int?,
         count: Int?
-    ): ApiResult<MessagesHistoryDomain, RestApiErrorDomain>
+    ): ApiResult<MessagesHistoryInfo, RestApiErrorDomain>
 
-    suspend fun getMessageById(
+    suspend fun getById(
         messagesIds: List<Int>,
         extended: Boolean?,
         fields: String?
-    ): ApiResult<VkMessage, RestApiErrorDomain>
+    ): ApiResult<List<VkMessage>, RestApiErrorDomain>
 
     suspend fun send(
         peerId: Int,
@@ -33,14 +33,16 @@ interface MessagesRepository {
         startMessageId: Int?
     ): ApiResult<Int, RestApiErrorDomain>
 
-    suspend fun getMessage(messageId: Int): Flow<VkMessage?>
+    suspend fun getHistoryAttachments(
+        peerId: Int,
+        count: Int?,
+        offset: Int?,
+        attachmentTypes: List<String>,
+        conversationMessageId: Int
+    ): ApiResult<List<VkAttachmentHistoryMessage>, RestApiErrorDomain>
 
     suspend fun storeMessages(messages: List<VkMessage>)
 
-//    suspend fun getHistory(
-//        params: MessagesGetHistoryRequest
-//    ): ApiResult<MessagesGetHistoryResponse, RestApiErrorDomain>
-
 //    suspend fun markAsImportant(
 //        params: MessagesMarkAsImportantRequest
 //    ): ApiResult<List<Int>, RestApiErrorDomain>

core/data/src/main/kotlin/com/meloda/app/fast/data/api/messages/MessagesRepositoryImpl.kt

@@ -1,56 +1,132 @@
 package com.meloda.app.fast.data.api.messages
 
+import com.meloda.app.fast.common.VkConstants
+import com.meloda.app.fast.data.VkGroupsMap
+import com.meloda.app.fast.data.VkMemoryCache
+import com.meloda.app.fast.data.VkUsersMap
+import com.meloda.app.fast.database.dao.MessageDao
+import com.meloda.app.fast.model.api.data.VkAttachmentHistoryMessageData
+import com.meloda.app.fast.model.api.data.VkContactData
+import com.meloda.app.fast.model.api.data.VkGroupData
+import com.meloda.app.fast.model.api.data.VkUserData
+import com.meloda.app.fast.model.api.data.asDomain
 import com.meloda.app.fast.model.api.domain.VkAttachment
+import com.meloda.app.fast.model.api.domain.VkAttachmentHistoryMessage
 import com.meloda.app.fast.model.api.domain.VkMessage
 import com.meloda.app.fast.model.api.domain.asEntity
-import com.meloda.app.fast.model.database.asExternalModel
+import com.meloda.app.fast.model.api.requests.MessagesGetByIdRequest
+import com.meloda.app.fast.model.api.requests.MessagesGetHistoryAttachmentsRequest
+import com.meloda.app.fast.model.api.requests.MessagesGetHistoryRequest
+import com.meloda.app.fast.model.api.requests.MessagesMarkAsReadRequest
+import com.meloda.app.fast.model.api.requests.MessagesSendRequest
 import com.meloda.app.fast.network.RestApiErrorDomain
+import com.meloda.app.fast.network.mapApiDefault
+import com.meloda.app.fast.network.mapApiResult
+import com.meloda.app.fast.network.service.messages.MessagesService
 import com.slack.eithernet.ApiResult
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.withContext
 
-// TODO: 05/05/2024, Danil Nikolaev: implement syncing
 class MessagesRepositoryImpl(
-    private val networkDataSource: MessagesNetworkDataSource,
-    private val localDataSource: MessagesLocalDataSource
+    private val messagesService: MessagesService,
+    private val messageDao: MessageDao,
 ) : MessagesRepository {
 
-    override suspend fun getMessagesHistory(
+    override suspend fun getHistory(
         conversationId: Int,
         offset: Int?,
         count: Int?
-    ): ApiResult<MessagesHistoryDomain, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-//        val localMessages = localDataSource.getMessages(
-//            conversationId = conversationId,
-//            offset = offset,
-//            count = count
-//        ).map(VkMessageEntity::asExternalModel)
-//
-//        emit(localMessages)
-//
-//        val networkMessages = networkDataSource.getMessagesHistory(
-//            conversationId = conversationId,
-//            offset = offset,
-//            count = count
-//        )
-//
-//        emit(networkMessages)
+    ): ApiResult<MessagesHistoryInfo, RestApiErrorDomain> = withContext(Dispatchers.IO) {
+        val requestModel = MessagesGetHistoryRequest(
+            count = count,
+            offset = offset,
+            peerId = conversationId,
+            extended = true,
+            startMessageId = null,
+            rev = null,
+            fields = VkConstants.ALL_FIELDS
+        )
 
-        networkDataSource.getMessagesHistory(conversationId, offset, count)
+        messagesService.getHistory(requestModel.map).mapApiResult(
+            successMapper = { apiResponse ->
+                val response = apiResponse.requireResponse()
+
+                val profilesList = response.profiles.orEmpty().map(VkUserData::mapToDomain)
+                val groupsList = response.groups.orEmpty().map(VkGroupData::mapToDomain)
+                val contactsList = response.contacts.orEmpty().map(VkContactData::mapToDomain)
+
+                val usersMap = VkUsersMap.forUsers(profilesList)
+                val groupsMap = VkGroupsMap.forGroups(groupsList)
+
+                VkMemoryCache.appendUsers(profilesList)
+                VkMemoryCache.appendGroups(groupsList)
+                VkMemoryCache.appendContacts(contactsList)
+
+                val messages = response.items.map { item ->
+                    item.asDomain().let { message ->
+                        message.copy(
+                            user = usersMap.messageUser(message),
+                            group = groupsMap.messageGroup(message),
+                            actionUser = usersMap.messageActionUser(message),
+                            actionGroup = groupsMap.messageActionGroup(message)
+                        ).also { VkMemoryCache[message.id] = it }
+                    }
+                }
+
+                val conversations = response.conversations.orEmpty().map { item ->
+                    val message = messages.firstOrNull { it.id == item.lastMessageId }
+                    item.asDomain(message)
+                        .let { conversation ->
+                            conversation.copy(
+                                user = usersMap.conversationUser(conversation),
+                                group = groupsMap.conversationGroup(conversation)
+                            ).also { VkMemoryCache[conversation.id] = it }
+                        }
+                }
+
+                MessagesHistoryInfo(
+                    messages = messages,
+                    conversations = conversations
+                )
+            },
+            errorMapper = { error ->
+                error?.toDomain()
+            }
+        )
     }
 
-    override suspend fun getMessageById(
+    override suspend fun getById(
         messagesIds: List<Int>,
         extended: Boolean?,
         fields: String?
-    ): ApiResult<VkMessage, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        networkDataSource.getMessageById(
+    ): ApiResult<List<VkMessage>, RestApiErrorDomain> = withContext(Dispatchers.IO) {
+        val requestModel = MessagesGetByIdRequest(
             messagesIds = messagesIds,
             extended = extended,
             fields = fields
         )
+
+        messagesService.getById(requestModel.map).mapApiResult(
+            successMapper = { apiResponse ->
+                val response = apiResponse.requireResponse()
+
+                val messages = response.items
+                val usersMap =
+                    VkUsersMap.forUsers(response.profiles.orEmpty().map(VkUserData::mapToDomain))
+                val groupsMap =
+                    VkGroupsMap.forGroups(response.groups.orEmpty().map(VkGroupData::mapToDomain))
+
+                messages.map { message ->
+                    message.asDomain().copy(
+                        user = usersMap.messageUser(message),
+                        group = groupsMap.messageGroup(message),
+                        actionUser = usersMap.messageActionUser(message),
+                        actionGroup = groupsMap.messageActionGroup(message)
+                    )
+                }
+            },
+            errorMapper = { error -> error?.toDomain() }
+        )
     }
 
     override suspend fun send(
@@ -60,54 +136,72 @@ class MessagesRepositoryImpl(
         replyTo: Int?,
         attachments: List<VkAttachment>?
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        networkDataSource.send(
-            peerId,
-            randomId,
-            message,
-            replyTo,
-            attachments
+        val requestModel = MessagesSendRequest(
+            peerId = peerId,
+            randomId = randomId,
+            message = message,
+            replyTo = replyTo,
+            attachments = attachments
         )
+
+        messagesService.send(requestModel.map).mapApiDefault()
     }
 
     override suspend fun markAsRead(
         peerId: Int,
         startMessageId: Int?
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        networkDataSource.markAsRead(peerId, startMessageId)
+        val requestModel = MessagesMarkAsReadRequest(
+            peerId = peerId,
+            startMessageId = startMessageId
+        )
+
+        messagesService.markAsRead(requestModel.map).mapApiDefault()
     }
 
-    override suspend fun getMessage(messageId: Int): Flow<VkMessage?> = flow {
-        val localMessage = localDataSource.getMessage(messageId)?.asExternalModel()
+    override suspend fun getHistoryAttachments(
+        peerId: Int,
+        count: Int?,
+        offset: Int?,
+        attachmentTypes: List<String>,
+        conversationMessageId: Int
+    ): ApiResult<List<VkAttachmentHistoryMessage>, RestApiErrorDomain> =
+        withContext(Dispatchers.IO) {
+            val requestModel = MessagesGetHistoryAttachmentsRequest(
+                peerId = peerId,
+                extended = true,
+                count = count,
+                offset = offset,
+                preserveOrder = true,
+                attachmentTypes = attachmentTypes,
+                conversationMessageId = conversationMessageId,
+                fields = VkConstants.ALL_FIELDS
+            )
 
-        emit(localMessage)
+            messagesService.getHistoryAttachments(requestModel.map).mapApiResult(
+                successMapper = { apiResponse ->
+                    val response = apiResponse.requireResponse()
 
-        val networkMessage = networkDataSource.getMessage(messageId)
+                    val profilesList = response.profiles.orEmpty().map(VkUserData::mapToDomain)
+                    val groupsList = response.groups.orEmpty().map(VkGroupData::mapToDomain)
+                    val contactsList = response.contacts.orEmpty().map(VkContactData::mapToDomain)
 
-        emit(networkMessage)
-    }
+                    VkMemoryCache.appendUsers(profilesList)
+                    VkMemoryCache.appendGroups(groupsList)
+                    VkMemoryCache.appendContacts(contactsList)
+
+                    response.items.map(VkAttachmentHistoryMessageData::toDomain)
+                },
+                errorMapper = { error ->
+                    error?.toDomain()
+                }
+            )
+        }
 
     override suspend fun storeMessages(messages: List<VkMessage>) {
-        localDataSource.storeMessages(messages.map(VkMessage::asEntity))
+        messageDao.insertAll(messages.map(VkMessage::asEntity))
     }
 
-    //    override suspend fun getHistory(
-//        params: MessagesGetHistoryRequest
-//    ): ApiResult<MessagesGetHistoryResponse, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-//        messagesService.getHistory(params.map).mapResult(
-//            successMapper = { response -> response.requireResponse() },
-//            errorMapper = { error -> error?.toDomain() }
-//        )
-//    }
-//
-//    override suspend fun send(
-//        params: MessagesSendRequest
-//    ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-//        messagesService.send(params.map).mapResult(
-//            successMapper = { response -> response.requireResponse() },
-//            errorMapper = { error -> error?.toDomain() }
-//        )
-//    }
-//
 //    override suspend fun markAsImportant(
 //        params: MessagesMarkAsImportantRequest
 //    ): ApiResult<List<Int>, RestApiErrorDomain> = withContext(Dispatchers.IO) {
@@ -153,24 +247,6 @@ class MessagesRepositoryImpl(
 //        )
 //    }
 //
-//    override suspend fun getById(
-//        params: MessagesGetByIdRequest
-//    ): ApiResult<MessagesGetByIdResponse, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-//        messagesService.getById(params.map).mapResult(
-//            successMapper = { response -> response.requireResponse() },
-//            errorMapper = { error -> error?.toDomain() }
-//        )
-//    }
-//
-//    override suspend fun markAsRead(
-//        params: MessagesMarkAsReadRequest
-//    ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-//        messagesService.markAsRead(params.map).mapResult(
-//            successMapper = { response -> response.requireResponse() },
-//            errorMapper = { error -> error?.toDomain() }
-//        )
-//    }
-//
 //    override suspend fun getChat(
 //        params: MessagesGetChatRequest
 //    ): ApiResult<VkChatData, RestApiErrorDomain> = withContext(Dispatchers.IO) {
@@ -199,3 +275,4 @@ class MessagesRepositoryImpl(
 //        )
 //    }
 }
+

core/data/src/main/kotlin/com/meloda/app/fast/data/api/messages/MessagesUseCase.kt

@@ -2,6 +2,7 @@ package com.meloda.app.fast.data.api.messages
 
 import com.meloda.app.fast.data.State
 import com.meloda.app.fast.model.api.domain.VkAttachment
+import com.meloda.app.fast.model.api.domain.VkAttachmentHistoryMessage
 import com.meloda.app.fast.model.api.domain.VkMessage
 import kotlinx.coroutines.flow.Flow
 
@@ -11,15 +12,9 @@ interface MessagesUseCase {
         conversationId: Int,
         count: Int?,
         offset: Int?
-    ): Flow<State<MessagesHistoryDomain>>
+    ): Flow<State<MessagesHistoryInfo>>
 
     fun getById(
-        messageId: Int,
-        extended: Boolean?,
-        fields: String?
-    ): Flow<State<VkMessage?>>
-
-    fun getByIds(
         messageIds: List<Int>,
         extended: Boolean?,
         fields: String?
@@ -38,6 +33,14 @@ interface MessagesUseCase {
         startMessageId: Int
     ): Flow<State<Int>>
 
+    fun getHistoryAttachments(
+        peerId: Int,
+        count: Int?,
+        offset: Int?,
+        attachmentTypes: List<String>,
+        conversationMessageId: Int
+    ): Flow<State<List<VkAttachmentHistoryMessage>>>
+
     suspend fun storeMessage(message: VkMessage)
     suspend fun storeMessages(messages: List<VkMessage>)
 }

core/data/src/main/kotlin/com/meloda/app/fast/data/di/DataModule.kt

@@ -15,10 +15,6 @@ import com.meloda.app.fast.data.api.friends.FriendsRepository
 import com.meloda.app.fast.data.api.friends.FriendsRepositoryImpl
 import com.meloda.app.fast.data.api.longpoll.LongPollRepository
 import com.meloda.app.fast.data.api.longpoll.LongPollRepositoryImpl
-import com.meloda.app.fast.data.api.messages.MessagesLocalDataSource
-import com.meloda.app.fast.data.api.messages.MessagesLocalDataSourceImpl
-import com.meloda.app.fast.data.api.messages.MessagesNetworkDataSource
-import com.meloda.app.fast.data.api.messages.MessagesNetworkDataSourceImpl
 import com.meloda.app.fast.data.api.messages.MessagesRepository
 import com.meloda.app.fast.data.api.messages.MessagesRepositoryImpl
 import com.meloda.app.fast.data.api.oauth.OAuthRepository
@@ -59,8 +55,6 @@ val dataModule = module {
 
     singleOf(::LongPollRepositoryImpl) bind LongPollRepository::class
 
-    singleOf(::MessagesLocalDataSourceImpl) bind MessagesLocalDataSource::class
-    singleOf(::MessagesNetworkDataSourceImpl) bind MessagesNetworkDataSource::class
     singleOf(::MessagesRepositoryImpl) bind MessagesRepository::class
 
     singleOf(::OAuthRepositoryImpl) bind OAuthRepository::class