Feature/expose channel freezing to state client (#132)

* Fix state update after `channel.truncated` event with a past date

* Add waiting for new message.received event when truncating in a unit test + add max waiting of 60s for a condition

* Add IStreamChannel.FreezeAsync & IStreamChannel.UnfreezeAsync + add unit tests

Author: sierpinskid

Assets/Plugins/StreamChat/Core/InternalDTO/Requests/UpdateChannelPartialRequestInternalDTO.cs

@@ -17,10 +17,10 @@ namespace StreamChat.Core.InternalDTO.Requests
     internal partial class UpdateChannelPartialRequestInternalDTO
     {
         [Newtonsoft.Json.JsonProperty("set", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
-        public System.Collections.Generic.Dictionary<string, object> Set { get; set; } = new System.Collections.Generic.Dictionary<string, object>();
+        public System.Collections.Generic.Dictionary<string, object> Set { get; set; }
 
         [Newtonsoft.Json.JsonProperty("unset", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
-        public System.Collections.Generic.List<string> Unset { get; set; } = new System.Collections.Generic.List<string>();
+        public System.Collections.Generic.List<string> Unset { get; set; }
 
         [Newtonsoft.Json.JsonProperty("user", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
         public UserObjectRequestInternalDTO User { get; set; }

Assets/Plugins/StreamChat/Core/StatefulModels/IStreamChannel.cs

@@ -500,6 +500,18 @@ Task TruncateAsync(DateTimeOffset? truncatedAt = default, string systemMessage =
         /// </summary>
         Task StopWatchingAsync();
 
+        /// <summary>
+        /// Freezing a channel will disallow sending new messages and sending / deleting reactions
+        /// </summary>
+        /// <remarks>https://getstream.io/chat/docs/unity/disabling_channels/?language=unity#freeze-a-channel</remarks>
+        Task FreezeAsync();
+        
+        /// <summary>
+        /// Unfreeze this channel
+        /// </summary>
+        /// <remarks>https://getstream.io/chat/docs/unity/disabling_channels/?language=unity#unfreeze-a-channel</remarks>
+        Task UnfreezeAsync();
+
         /// <summary>
         /// Delete this channel. By default channel is soft deleted. You can hard delete it only by using a server-side SDK due to security
         /// </summary>

Assets/Plugins/StreamChat/Core/StatefulModels/StreamChannel.cs

@@ -568,6 +568,32 @@ public Task StopWatchingAsync()
             => LowLevelClient.InternalChannelApi.StopWatchingChannelAsync(Type, Id,
                 new ChannelStopWatchingRequestInternalDTO());
 
+        public async Task FreezeAsync()
+        {
+            var response = await LowLevelClient.InternalChannelApi.UpdateChannelPartialAsync(Type, Id,
+                new UpdateChannelPartialRequestInternalDTO()
+                {
+                    Set = new Dictionary<string, object>
+                    {
+                        { "frozen", true }
+                    }
+                });
+            Cache.TryCreateOrUpdate(response.Channel);
+        }
+        
+        public async Task UnfreezeAsync()
+        {
+            var response = await LowLevelClient.InternalChannelApi.UpdateChannelPartialAsync(Type, Id,
+                new UpdateChannelPartialRequestInternalDTO()
+                {
+                    Set = new Dictionary<string, object>
+                    {
+                        { "frozen", false }
+                    }
+                });
+            Cache.TryCreateOrUpdate(response.Channel);
+        }
+
         public Task DeleteAsync()
             => LowLevelClient.InternalChannelApi.DeleteChannelAsync(Type, Id, isHardDelete: false);
 

Assets/Plugins/StreamChat/Samples/ChannelsCodeSamples.cs

@@ -713,7 +713,7 @@ public async Task HideAndShowChannel()
         /// </summary>
         public async Task DisableChannel()
         {
-            //StreamTodo: IMPLEMENT disable channel
+            // Feature only available via a server-side SDK
             await Task.CompletedTask;
         }
 
@@ -722,17 +722,17 @@ public async Task DisableChannel()
         /// </summary>
         public async Task FreezeChannel()
         {
-            //StreamTodo: IMPLEMENT freeze channel
-            await Task.CompletedTask;
+            var channel = await Client.GetOrCreateChannelWithIdAsync(ChannelType.Messaging, channelId: "my-channel-id");
+            await channel.FreezeAsync();
         }
 
         /// <summary>
         /// https://getstream.io/chat/docs/unity/disabling_channels/?language=unity#unfreeze-a-channel
         /// </summary>
         public async Task UnfreezeChannel()
         {
-            //StreamTodo: IMPLEMENT unfreeze channel
-            await Task.CompletedTask;
+            var channel = await Client.GetOrCreateChannelWithIdAsync(ChannelType.Messaging, channelId: "my-channel-id");
+            await channel.UnfreezeAsync();
         }
 
         /// <summary>

Assets/Plugins/StreamChat/Tests/StatefulClient/ChannelsTests.cs

@@ -7,6 +7,7 @@
 using NUnit.Framework;
 using StreamChat.Core.LowLevelClient.Requests;
 using StreamChat.Core;
+using StreamChat.Core.Models;
 using StreamChat.Core.QueryBuilders.Filters;
 using StreamChat.Core.QueryBuilders.Filters.Channels;
 using StreamChat.Core.QueryBuilders.Filters.Users;
@@ -551,6 +552,60 @@ await WaitWithTimeoutAsync(taskCompletionSource.Task, maxSeconds: 3,
         //     await WaitWithTimeout(taskCompletionSource.Task, maxSeconds: 3,
         //         $"Event {nameof(otherClient.ChannelInviteReceived)} was not received");
         // }
+        
+        [UnityTest]
+        public IEnumerator When_freezing_a_channel_expect_channel_frozen()
+            => ConnectAndExecute(When_freezing_a_channel_expect_channel_frozen_Async);
+
+        private async Task When_freezing_a_channel_expect_channel_frozen_Async()
+        {
+            var channel = await CreateUniqueTempChannelAsync();
+            await channel.FreezeAsync();
+            Assert.IsTrue(channel.Frozen);
+        }
+        
+        [UnityTest]
+        public IEnumerator When_sending_message_to_frozen_channel_expect_error_message_returned()
+            => ConnectAndExecute(When_sending_message_to_frozen_channel_expect_error_message_returned_Async);
+
+        private async Task When_sending_message_to_frozen_channel_expect_error_message_returned_Async()
+        {
+            var channel = await CreateUniqueTempChannelAsync();
+
+            await channel.SendNewMessageAsync("Test1");
+            var lastNormalMessage = channel.Messages.LastOrDefault();
+            Assert.IsNotNull(lastNormalMessage);
+            Assert.AreNotEqual(StreamMessageType.Error, lastNormalMessage.Type);
+            
+            await channel.FreezeAsync();
+            Assert.IsTrue(channel.Frozen);
+            
+            await channel.SendNewMessageAsync("MessageAfterFrozenChannel");
+
+            var lastMessage = channel.Messages.LastOrDefault();
+            
+            Assert.IsNotNull(lastMessage);
+            Assert.AreEqual(StreamMessageType.Error, lastMessage.Type);
+        }
+        
+        [UnityTest]
+        public IEnumerator When_unfreezing_a_frozen_channel_expect_channel_unfrozen()
+            => ConnectAndExecute(When_unfreezing_a_frozen_channel_expect_channel_unfrozen_Async);
+
+        private async Task When_unfreezing_a_frozen_channel_expect_channel_unfrozen_Async()
+        {
+            var channel = await CreateUniqueTempChannelAsync();
+            await channel.FreezeAsync();
+            Assert.IsTrue(channel.Frozen);
+            await channel.UnfreezeAsync();
+            Assert.IsFalse(channel.Frozen);
+            
+            await channel.SendNewMessageAsync("MessageAfterUnfrozenChannel");
+            var lastMessage = channel.Messages.LastOrDefault();
+            Assert.IsNotNull(lastMessage);
+            Assert.AreEqual("MessageAfterUnfrozenChannel", lastMessage.Text);
+            Assert.AreNotEqual(StreamMessageType.Error, lastMessage.Type);
+        }
     }
 }