feat: add channel batch updates support

src/Clients/ChannelBatchUpdater.cs

@@ -0,0 +1,202 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using StreamChat.Models;
+
+namespace StreamChat.Clients
+{
+    /// <summary>
+    /// Provides convenience methods for batch channel operations.
+    /// </summary>
+    public class ChannelBatchUpdater
+    {
+        private readonly IChannelClient _client;
+
+        public ChannelBatchUpdater(IChannelClient client)
+        {
+            _client = client;
+        }
+
+        /// <summary>
+        /// Adds members to channels matching the filter.
+        /// </summary>
+        public async Task<AsyncOperationResponse> AddMembersAsync(ChannelsBatchFilters filter, IEnumerable<ChannelBatchMemberRequest> members)
+        {
+            var options = new ChannelsBatchOptions
+            {
+                Operation = ChannelBatchOperation.AddMembers,
+                Filter = filter,
+                Members = members?.ToList(),
+            };
+            return await _client.UpdateChannelsBatchAsync(options);
+        }
+
+        /// <summary>
+        /// Removes members from channels matching the filter.
+        /// </summary>
+        public async Task<AsyncOperationResponse> RemoveMembersAsync(ChannelsBatchFilters filter, IEnumerable<ChannelBatchMemberRequest> members)
+        {
+            var options = new ChannelsBatchOptions
+            {
+                Operation = ChannelBatchOperation.RemoveMembers,
+                Filter = filter,
+                Members = members?.ToList(),
+            };
+            return await _client.UpdateChannelsBatchAsync(options);
+        }
+
+        /// <summary>
+        /// Invites members to channels matching the filter.
+        /// </summary>
+        public async Task<AsyncOperationResponse> InviteMembersAsync(ChannelsBatchFilters filter, IEnumerable<ChannelBatchMemberRequest> members)
+        {
+            var options = new ChannelsBatchOptions
+            {
+                Operation = ChannelBatchOperation.InviteMembers,
+                Filter = filter,
+                Members = members?.ToList(),
+            };
+            return await _client.UpdateChannelsBatchAsync(options);
+        }
+
+        /// <summary>
+        /// Assigns roles to members in channels matching the filter.
+        /// </summary>
+        public async Task<AsyncOperationResponse> AssignRolesAsync(ChannelsBatchFilters filter, IEnumerable<ChannelBatchMemberRequest> members)
+        {
+            var options = new ChannelsBatchOptions
+            {
+                Operation = ChannelBatchOperation.AssignRoles,
+                Filter = filter,
+                Members = members?.ToList(),
+            };
+            return await _client.UpdateChannelsBatchAsync(options);
+        }
+
+        /// <summary>
+        /// Adds moderators to channels matching the filter.
+        /// </summary>
+        public async Task<AsyncOperationResponse> AddModeratorsAsync(ChannelsBatchFilters filter, IEnumerable<ChannelBatchMemberRequest> members)
+        {
+            var options = new ChannelsBatchOptions
+            {
+                Operation = ChannelBatchOperation.AddModerators,
+                Filter = filter,
+                Members = members?.ToList(),
+            };
+            return await _client.UpdateChannelsBatchAsync(options);
+        }
+
+        /// <summary>
+        /// Removes moderator role from members in channels matching the filter.
+        /// </summary>
+        public async Task<AsyncOperationResponse> DemoteModeratorsAsync(ChannelsBatchFilters filter, IEnumerable<ChannelBatchMemberRequest> members)
+        {
+            var options = new ChannelsBatchOptions
+            {
+                Operation = ChannelBatchOperation.DemoteModerators,
+                Filter = filter,
+                Members = members?.ToList(),
+            };
+            return await _client.UpdateChannelsBatchAsync(options);
+        }
+
+        /// <summary>
+        /// Hides channels matching the filter for the specified members.
+        /// </summary>
+        public async Task<AsyncOperationResponse> HideAsync(ChannelsBatchFilters filter, IEnumerable<ChannelBatchMemberRequest> members)
+        {
+            var options = new ChannelsBatchOptions
+            {
+                Operation = ChannelBatchOperation.Hide,
+                Filter = filter,
+                Members = members?.ToList(),
+            };
+            return await _client.UpdateChannelsBatchAsync(options);
+        }
+
+        /// <summary>
+        /// Shows channels matching the filter for the specified members.
+        /// </summary>
+        public async Task<AsyncOperationResponse> ShowAsync(ChannelsBatchFilters filter, IEnumerable<ChannelBatchMemberRequest> members)
+        {
+            var options = new ChannelsBatchOptions
+            {
+                Operation = ChannelBatchOperation.Show,
+                Filter = filter,
+                Members = members?.ToList(),
+            };
+            return await _client.UpdateChannelsBatchAsync(options);
+        }
+
+        /// <summary>
+        /// Archives channels matching the filter for the specified members.
+        /// </summary>
+        public async Task<AsyncOperationResponse> ArchiveAsync(ChannelsBatchFilters filter, IEnumerable<ChannelBatchMemberRequest> members)
+        {
+            var options = new ChannelsBatchOptions
+            {
+                Operation = ChannelBatchOperation.Archive,
+                Filter = filter,
+                Members = members?.ToList(),
+            };
+            return await _client.UpdateChannelsBatchAsync(options);
+        }
+
+        /// <summary>
+        /// Unarchives channels matching the filter for the specified members.
+        /// </summary>
+        public async Task<AsyncOperationResponse> UnarchiveAsync(ChannelsBatchFilters filter, IEnumerable<ChannelBatchMemberRequest> members)
+        {
+            var options = new ChannelsBatchOptions
+            {
+                Operation = ChannelBatchOperation.Unarchive,
+                Filter = filter,
+                Members = members?.ToList(),
+            };
+            return await _client.UpdateChannelsBatchAsync(options);
+        }
+
+        /// <summary>
+        /// Updates data on channels matching the filter.
+        /// </summary>
+        public async Task<AsyncOperationResponse> UpdateDataAsync(ChannelsBatchFilters filter, ChannelDataUpdate data)
+        {
+            var options = new ChannelsBatchOptions
+            {
+                Operation = ChannelBatchOperation.UpdateData,
+                Filter = filter,
+                Data = data,
+            };
+            return await _client.UpdateChannelsBatchAsync(options);
+        }
+
+        /// <summary>
+        /// Adds filter tags to channels matching the filter.
+        /// </summary>
+        public async Task<AsyncOperationResponse> AddFilterTagsAsync(ChannelsBatchFilters filter, IEnumerable<string> tags)
+        {
+            var options = new ChannelsBatchOptions
+            {
+                Operation = ChannelBatchOperation.AddFilterTags,
+                Filter = filter,
+                FilterTagsUpdate = tags?.ToList(),
+            };
+            return await _client.UpdateChannelsBatchAsync(options);
+        }
+
+        /// <summary>
+        /// Removes filter tags from channels matching the filter.
+        /// </summary>
+        public async Task<AsyncOperationResponse> RemoveFilterTagsAsync(ChannelsBatchFilters filter, IEnumerable<string> tags)
+        {
+            var options = new ChannelsBatchOptions
+            {
+                Operation = ChannelBatchOperation.RemoveFilterTags,
+                Filter = filter,
+                FilterTagsUpdate = tags?.ToList(),
+            };
+            return await _client.UpdateChannelsBatchAsync(options);
+        }
+    }
+}

src/Clients/ChannelClient.cs

@@ -38,6 +38,14 @@ public async Task<AsyncOperationResponse> DeleteChannelsAsync(IEnumerable<string
                 HttpStatusCode.Created,
                 new { cids = cids, hard_delete = hardDelete });
 
+        public async Task<AsyncOperationResponse> UpdateChannelsBatchAsync(ChannelsBatchOptions options)
+            => await ExecuteRequestAsync<AsyncOperationResponse>("channels/batch",
+                HttpMethod.PUT,
+                HttpStatusCode.Created,
+                options);
+
+        public ChannelBatchUpdater BatchUpdater() => new ChannelBatchUpdater(this);
+
         public async Task<ApiResponse> HideAsync(string channelType, string channelId, string userId, bool clearHistory = false)
             => await ExecuteRequestAsync<ApiResponse>($"channels/{channelType}/{channelId}/hide",
                 HttpMethod.POST,

src/Clients/IChannelClient.cs

@@ -50,6 +50,18 @@ Task<UpdateChannelResponse> AssignRolesAsync(string channelType, string channelI
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_delete/?language=csharp</remarks>
         Task<AsyncOperationResponse> DeleteChannelsAsync(IEnumerable<string> cids, bool hardDelete = false);
 
+        /// <summary>
+        /// <para>Updates channels in batch based on the provided options.</para>
+        /// This is an asynchronous operation and the returned value is a task Id.
+        /// You can use <see cref="ITaskClient.GetTaskStatusAsync"/> to check the status of the task.
+        /// </summary>
+        Task<AsyncOperationResponse> UpdateChannelsBatchAsync(ChannelsBatchOptions options);
+
+        /// <summary>
+        /// Returns a <see cref="ChannelBatchUpdater"/> instance for convenient batch channel operations.
+        /// </summary>
+        ChannelBatchUpdater BatchUpdater();
+
         /// <summary>
         /// Takes away moderators status from given user ids.
         /// </summary>

src/Models/Channel.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Runtime.Serialization;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
 
 namespace StreamChat.Models
 {
@@ -155,4 +157,110 @@ public class ChannelUnmuteRequest : ChannelMuteRequest
     public class ChannelUnmuteResponse : ChannelMuteResponse
     {
     }
+
+    [JsonConverter(typeof(StringEnumConverter))]
+    public enum ChannelBatchOperation
+    {
+        [EnumMember(Value = "addMembers")]
+        AddMembers,
+
+        [EnumMember(Value = "removeMembers")]
+        RemoveMembers,
+
+        [EnumMember(Value = "inviteMembers")]
+        InviteMembers,
+
+        [EnumMember(Value = "assignRoles")]
+        AssignRoles,
+
+        [EnumMember(Value = "addModerators")]
+        AddModerators,
+
+        [EnumMember(Value = "demoteModerators")]
+        DemoteModerators,
+
+        [EnumMember(Value = "hide")]
+        Hide,
+
+        [EnumMember(Value = "show")]
+        Show,
+
+        [EnumMember(Value = "archive")]
+        Archive,
+
+        [EnumMember(Value = "unarchive")]
+        Unarchive,
+
+        [EnumMember(Value = "updateData")]
+        UpdateData,
+
+        [EnumMember(Value = "addFilterTags")]
+        AddFilterTags,
+
+        [EnumMember(Value = "removeFilterTags")]
+        RemoveFilterTags,
+    }
+
+    public class ChannelBatchMemberRequest
+    {
+        [JsonProperty("user_id")]
+        public string UserId { get; set; }
+
+        [JsonProperty("channel_role")]
+        public string ChannelRole { get; set; }
+    }
+
+    public class ChannelDataUpdate
+    {
+        [JsonProperty("frozen")]
+        public bool? Frozen { get; set; }
+
+        [JsonProperty("disabled")]
+        public bool? Disabled { get; set; }
+
+        [JsonProperty("custom")]
+        public Dictionary<string, object> Custom { get; set; }
+
+        [JsonProperty("team")]
+        public string Team { get; set; }
+
+        [JsonProperty("config_overrides")]
+        public Dictionary<string, object> ConfigOverrides { get; set; }
+
+        [JsonProperty("auto_translation_enabled")]
+        public bool? AutoTranslationEnabled { get; set; }
+
+        [JsonProperty("auto_translation_language")]
+        public string AutoTranslationLanguage { get; set; }
+    }
+
+    public class ChannelsBatchFilters
+    {
+        [JsonProperty("cids")]
+        public object Cids { get; set; }
+
+        [JsonProperty("types")]
+        public object Types { get; set; }
+
+        [JsonProperty("filter_tags")]
+        public object FilterTags { get; set; }
+    }
+
+    public class ChannelsBatchOptions
+    {
+        [JsonProperty("operation", DefaultValueHandling = DefaultValueHandling.Include)]
+        public ChannelBatchOperation Operation { get; set; }
+
+        [JsonProperty("filter")]
+        public ChannelsBatchFilters Filter { get; set; }
+
+        [JsonProperty("members")]
+        public IEnumerable<ChannelBatchMemberRequest> Members { get; set; }
+
+        [JsonProperty("data")]
+        public ChannelDataUpdate Data { get; set; }
+
+        [JsonProperty("filter_tags_update")]
+        public IEnumerable<string> FilterTagsUpdate { get; set; }
+    }
 }