implemented mute command

Author: martinmitrevski

Sources/StreamChatSwiftUI/ChatChannel/Composer/MessageComposerViewModel.swift

@@ -148,6 +148,19 @@ public class MessageComposerViewModel: ObservableObject {
         editedMessage: ChatMessage?,
         completion: @escaping () -> Void
     ) {
+        if let composerCommand = composerCommand {
+            commandsHandler.executeOnMessageSent(
+                composerCommand: composerCommand
+            ) { [weak self] _ in
+                self?.clearInputData()
+                completion()
+            }
+            
+            if composerCommand.replacesMessageSent {
+                return
+            }
+        }
+        
         if let editedMessage = editedMessage {
             edit(message: editedMessage, completion: completion)
             return
@@ -206,7 +219,13 @@ public class MessageComposerViewModel: ObservableObject {
     }
 
     public var sendButtonEnabled: Bool {
-        !addedAssets.isEmpty ||
+        if let composerCommand = composerCommand,
+           let handler = commandsHandler.canShowSuggestions(for: composerCommand) {
+            return handler
+                .canBeExecuted(composerCommand: composerCommand)
+        }
+        
+        return !addedAssets.isEmpty ||
             !text.isEmpty ||
             !addedFileURLs.isEmpty ||
             !addedCustomAttachments.isEmpty
@@ -406,7 +425,15 @@ public class MessageComposerViewModel: ObservableObject {
 
     private func checkTypingSuggestions() {
         if composerCommand?.displayInfo?.isInstant == true {
-            // If an instant command is selected, don't check again.
+            let typingSuggestion = TypingSuggestion(
+                text: text,
+                locationRange: NSRange(
+                    location: 0,
+                    length: selectedRangeLocation
+                )
+            )
+            composerCommand?.typingSuggestion = typingSuggestion
+            showTypingSuggestions()
             return
         }
         composerCommand = commandsHandler.canHandleCommand(

Sources/StreamChatSwiftUI/ChatChannel/Composer/Suggestions/CommandsConfig.swift

@@ -38,11 +38,14 @@ public class DefaultCommandsConfig: CommandsConfig {
             commandSymbol: mentionsSymbol,
             mentionAllAppUsers: false
         )
-        let giphyCommand = GiphyCommandHandler(
+        let giphyCommand = GiphyCommandHandler(commandSymbol: "/giphy")
+        let muteCommand = MuteCommandHandler(
             channelController: channelController,
-            commandSymbol: "/giphy"
+            commandSymbol: "/mute"
+        )
+        let instantCommands = InstantCommandsHandler(
+            commands: [giphyCommand, muteCommand]
         )
-        let instantCommands = InstantCommandsHandler(commands: [giphyCommand])
         return CommandsHandler(commands: [mentionsCommand, instantCommands])
     }
 }

Sources/StreamChatSwiftUI/ChatChannel/Composer/Suggestions/CommandsHandler.swift

@@ -24,6 +24,8 @@ public protocol CommandHandler {
         caretLocation: Int
     ) -> ComposerCommand?
 
+    func canShowSuggestions(for command: ComposerCommand) -> CommandHandler?
+    
     /// Shows suggestions for the provided command.
     /// - Parameter command: the command whose suggestions will be shown.
     /// - Returns: `Future` with the suggestions, or an error.
@@ -43,15 +45,37 @@ public protocol CommandHandler {
         command: Binding<ComposerCommand?>,
         extraData: [String: Any]
     )
+    
+    func canBeExecuted(composerCommand: ComposerCommand) -> Bool
+    
+    func executeOnMessageSent(
+        composerCommand: ComposerCommand,
+        completion: @escaping (Error?) -> Void
+    )
+}
+
+extension CommandHandler {
+    
+    public func executeOnMessageSent(
+        composerCommand: ComposerCommand,
+        completion: @escaping (Error?) -> Void
+    ) {
+        // optional method.
+    }
+    
+    public func canBeExecuted(composerCommand: ComposerCommand) -> Bool {
+        !composerCommand.typingSuggestion.text.isEmpty
+    }
 }
 
 /// Model for the composer's commands.
 public struct ComposerCommand {
     /// Identifier of the command.
     let id: String
     /// Typing suggestion that invokes the command.
-    let typingSuggestion: TypingSuggestion
+    var typingSuggestion: TypingSuggestion
     let displayInfo: CommandDisplayInfo?
+    var replacesMessageSent: Bool = false
 }
 
 /// Provides information about the suggestion.
@@ -94,13 +118,21 @@ public class CommandsHandler: CommandHandler {
         return nil
     }
 
+    public func canShowSuggestions(for command: ComposerCommand) -> CommandHandler? {
+        for handler in commands {
+            if handler.canShowSuggestions(for: command) != nil {
+                return handler
+            }
+        }
+        
+        return nil
+    }
+    
     public func showSuggestions(
         for command: ComposerCommand
     ) -> Future<SuggestionInfo, Error> {
-        for handler in commands {
-            if handler.id == command.id {
-                return handler.showSuggestions(for: command)
-            }
+        if let handler = canShowSuggestions(for: command) {
+            return handler.showSuggestions(for: command)
         }
 
         return StreamChatError.wrongConfig.asFailedPromise()
@@ -112,16 +144,37 @@ public class CommandsHandler: CommandHandler {
         command: Binding<ComposerCommand?>,
         extraData: [String: Any]
     ) {
-        for handler in commands {
-            let commandValue = command.wrappedValue
-            if handler.id == commandValue?.id {
-                handler.handleCommand(
-                    for: text,
-                    selectedRangeLocation: selectedRangeLocation,
-                    command: command,
-                    extraData: extraData
-                )
-            }
+        guard let commandValue = command.wrappedValue else {
+            return
+        }
+
+        if let handler = canShowSuggestions(for: commandValue), handler.id != id {
+            handler.handleCommand(
+                for: text,
+                selectedRangeLocation: selectedRangeLocation,
+                command: command,
+                extraData: extraData
+            )
         }
     }
+    
+    public func executeOnMessageSent(
+        composerCommand: ComposerCommand,
+        completion: @escaping (Error?) -> Void
+    ) {
+        if let handler = canShowSuggestions(for: composerCommand) {
+            handler.executeOnMessageSent(
+                composerCommand: composerCommand,
+                completion: completion
+            )
+        }
+    }
+    
+    public func canBeExecuted(composerCommand: ComposerCommand) -> Bool {
+        if let handler = canShowSuggestions(for: composerCommand), handler.id != id {
+            return handler.canBeExecuted(composerCommand: composerCommand)
+        }
+        
+        return !composerCommand.typingSuggestion.text.isEmpty
+    }
 }

Sources/StreamChatSwiftUI/ChatChannel/Composer/Suggestions/InstantCommands/GiphyCommandHandler.swift

@@ -16,16 +16,12 @@ public struct GiphyCommandHandler: CommandHandler {
     public var displayInfo: CommandDisplayInfo?
 
     private let typingSuggester: TypingSuggester
-    
-    private let channelController: ChatChannelController
-        
+            
     init(
-        channelController: ChatChannelController,
         commandSymbol: String,
         id: String = "/giphy"
     ) {
         self.id = id
-        self.channelController = channelController
         typingSuggester = TypingSuggester(
             options:
             TypingSuggestionOptions(
@@ -66,6 +62,10 @@ public struct GiphyCommandHandler: CommandHandler {
         extraData: [String: Any]
     ) {}
 
+    public func canShowSuggestions(for command: ComposerCommand) -> CommandHandler? {
+        nil
+    }
+    
     public func showSuggestions(
         for command: ComposerCommand
     ) -> Future<SuggestionInfo, Error> {

Sources/StreamChatSwiftUI/ChatChannel/Composer/Suggestions/InstantCommands/InstantCommandsHandler.swift

@@ -54,7 +54,20 @@ public class InstantCommandsHandler: CommandHandler {
         }
     }
 
+    public func canShowSuggestions(for command: ComposerCommand) -> CommandHandler? {
+        for instant in commands {
+            if instant.canShowSuggestions(for: command) != nil {
+                return instant
+            }
+        }
+        
+        return command.id == id ? self : nil
+    }
+    
     public func showSuggestions(for command: ComposerCommand) -> Future<SuggestionInfo, Error> {
+        if let handler = canShowSuggestions(for: command), handler.id != id {
+            return handler.showSuggestions(for: command)
+        }
         let suggestionInfo = SuggestionInfo(key: id, value: commands)
         return resolve(with: suggestionInfo)
     }
@@ -65,9 +78,40 @@ public class InstantCommandsHandler: CommandHandler {
         command: Binding<ComposerCommand?>,
         extraData: [String: Any]
     ) {
+        if let commandValue = command.wrappedValue,
+           let handler = canShowSuggestions(for: commandValue), handler.id != id {
+            handler.handleCommand(
+                for: text,
+                selectedRangeLocation: selectedRangeLocation,
+                command: command,
+                extraData: extraData
+            )
+            return
+        }
+        
         guard let instantCommand = extraData["instantCommand"] as? ComposerCommand else {
             return
         }
         command.wrappedValue = instantCommand
     }
+    
+    public func executeOnMessageSent(
+        composerCommand: ComposerCommand,
+        completion: @escaping (Error?) -> Void
+    ) {
+        if let handler = canShowSuggestions(for: composerCommand) {
+            handler.executeOnMessageSent(
+                composerCommand: composerCommand,
+                completion: completion
+            )
+        }
+    }
+    
+    public func canBeExecuted(composerCommand: ComposerCommand) -> Bool {
+        if let handler = canShowSuggestions(for: composerCommand), handler.id != id {
+            return handler.canBeExecuted(composerCommand: composerCommand)
+        }
+        
+        return !composerCommand.typingSuggestion.text.isEmpty
+    }
 }