Merge pull request #14 from QuickBlox/release/0.3.1

0.3.1

Author: IlliaChemolosov

Package.swift

@@ -7,7 +7,7 @@ let package = Package(
     name: "QuickBloxUIKit",
     defaultLocalization: "en",
     platforms: [
-        .iOS(.v15)
+        .iOS(.v16)
     ],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.

Sources/QuickBloxData/DTO/Dialog/RemoteDialogDTO.swift

@@ -17,7 +17,7 @@ public struct RemoteDialogDTO: Equatable {
     var participantsIds: [String] = []
     var toDeleteIds: [String] = []
     var toAddIds: [String] = []
-    var photo = ""
+    var photo = "null"
     var ownerId = ""
     var isOwnedByCurrentUser = false
 

Sources/QuickBloxData/Event/RemoteEvent.swift

@@ -9,36 +9,33 @@
 
 public enum RemoteEvent {
     case create(_ dialogId: String, byUser: Bool, message: RemoteMessageDTO)
-    case update(_ dialogId: String)
-    case leave(_ dialogId: String, byUser: Bool)
-    case removed(_ dialogId: String, byUser: Bool)
+    case update(_ message: RemoteMessageDTO)
+    case leave(_ dialogId: String)
+    case userLeave(_ message: RemoteMessageDTO)
+    case removed(_ dialogId: String)
     case newMessage(_ message: RemoteMessageDTO)
-    case history(_ messages: RemoteMessagesDTO)
     case read( _ messageID: String, dialogID: String)
     case delivered( _ messageID: String, dialogID: String)
     case typing( _ userID: UInt, dialogID: String)
     case stopTyping( _ userID: UInt, dialogID: String)
-    
+}
+
+extension RemoteEvent {
     init(_ message: RemoteMessageDTO) {
-        if message.type == .event {
+        if message.type == .event || message.type == .system {
             switch message.eventType {
             case .create:
                 self = .create(message.dialogId, byUser: message.isOwnedByCurrentUser, message: message)
             case .update:
-                self = .update(message.dialogId)
+                self = .update(message)
             case .leave:
-                if message.saveToHistory == true {
-                    self = .newMessage(message)
-                    self = .update(message.dialogId)
-                } else {
-                    self = .leave(message.dialogId, byUser: message.isOwnedByCurrentUser)
-                }
-            case .removed:
                 if message.isOwnedByCurrentUser {
-                    self = .update(message.dialogId)
+                    self = .leave(message.dialogId)
                 } else {
-                    self = .removed(message.dialogId, byUser: message.isOwnedByCurrentUser)
+                    self = .userLeave(message)
                 }
+            case .removed:
+                self = .removed(message.dialogId)
             case .message:
                 self = .newMessage(message)
             case .read:

Sources/QuickBloxData/Repository/ConnectionRepository.swift

@@ -20,9 +20,9 @@ public class ConnectionRepository {
 }
 
 extension ConnectionRepository: ConnectionRepositoryProtocol {
-    public func checkConnection() async throws {
+    public func checkConnection() async throws -> ConnectionState {
         do {
-            try await remote.checkConnection()
+           return try await remote.checkConnection()
         } catch {
             throw try error.repositoryException
         }

Sources/QuickBloxData/Repository/DialogsRepository.swift

@@ -30,17 +30,15 @@ extension DialogsRepository: DialogsRepositoryProtocol {
                 .compactMap { event in
                     switch event {
                     case .create(let dialogId, let isCurrent, let message): return .create(dialogId, byUser: isCurrent, message: Message(message))
-                    case .update(withDialogId: let dialogId): return .update(dialogId)
-                    case .leave( let dialogId, let isCurrentUser):
-                        return .leave(dialogId, byUser: isCurrentUser)
-                    case .removed(let dialogId, let isCurrentUser):
-                        return .removed(dialogId, byUser: isCurrentUser)
+                    case .update(let message): return .update(Message(message))
+                    case .leave( let dialogId):
+                        return .leave(dialogId)
+                    case .userLeave(let message):
+                        return .userLeave(Message(message))
+                    case .removed(let dialogId):
+                        return .removed(dialogId)
                     case .newMessage(let message):
                         return .newMessage(Message(message))
-                    case .history(let dto):
-                        return .history(dto.dialogId,
-                                        dto.messages.map { Message($0) })
-                    
                     case .read(let messageID, let dialogID):
                         return .read(messageID, dialogID: dialogID)
                     case .delivered(let messageID, let dialogID):

Sources/QuickBloxData/Source/Local/LocalDataSource.swift

@@ -109,7 +109,11 @@ extension LocalDataSource {
         if dto.messages.isEmpty == false {
             for new in dto.messages {
                 isUpdated = true
-                dialog.messages.insertElement(new, withSorting: .orderedAscending)
+                if let index = dialog.messages.firstIndex(where: { $0.id == new.id }) {
+                    dialog.messages[index] = new
+                } else {
+                    dialog.messages.insertElement(new, withSorting: .orderedAscending)
+                }
             }
         }
 
@@ -146,11 +150,10 @@ extension LocalDataSource {
             value.remove(at: index)
             value.insert(dialog, at: 0)
             dialogs.value = value
+            updatedDialog.value = dto.id
         } else {
             dialogs.value[index] = dialog
         }
-        
-        updatedDialog.value = dto.id
     }
 
     func getAllDialogs() async throws -> LocalDialogsDTO {