Refactor: Update NetworkService with proper initializer and REST methods (GET, POST, PATCH, DELETE)

Core/ApiClient.cs

@@ -32,5 +32,29 @@ namespace Chtn.CSharp.SDK.Core
 
             return JsonConvert.DeserializeObject<TResponse>(responseJson);
         }
+        public async Task<TResponse> GetAsync<TResponse>(string endpoint)
+        {
+            var response = await _httpClient.GetAsync(endpoint);
+            response.EnsureSuccessStatusCode();
+            var content = await response.Content.ReadAsStringAsync();
+            return JsonConvert.DeserializeObject<TResponse>(content);
+        }
+        public async Task<TResponse> PatchAsync<TRequest, TResponse>(string endpoint, TRequest data)
+        {
+            var json = JsonConvert.SerializeObject(data);
+            var content = new StringContent(json, Encoding.UTF8, "application/json");
+            var request = new HttpRequestMessage(new HttpMethod("PATCH"), endpoint) { Content = content };
+            var response = await _httpClient.SendAsync(request);
+            response.EnsureSuccessStatusCode();
+            var responseContent = await response.Content.ReadAsStringAsync();
+            return JsonConvert.DeserializeObject<TResponse>(responseContent);
+        }
+        public async Task<TResponse> DeleteAsync<TResponse>(string endpoint)
+        {
+            var response = await _httpClient.DeleteAsync(endpoint);
+            response.EnsureSuccessStatusCode();
+            var content = await response.Content.ReadAsStringAsync();
+            return JsonConvert.DeserializeObject<TResponse>(content);
+        }
     }
 }

Models/FileUploadModels.cs

@@ -32,4 +32,17 @@ namespace Chtn.CSharp.SDK.Models.Media
     {
         [JsonProperty("uploadId")] public string UploadId { get; set; }
     }
+
+    public class FileData
+    {
+        public string FileId { get; set; }
+        public string Name { get; set; }
+        public string Type { get; set; }
+        public byte[] Data { get; set; }
+    }
+
+    public interface IFileUploadProgressListener
+    {
+        void FileProgressUpdate(string tempMsgId, string fileId, int totalChunks, int currentChunk);
+    }
 }

Models/NetworkModels.cs

@@ -176,6 +176,7 @@ namespace Chtn.CSharp.SDK.Models.Network
     { 
         [JsonProperty("networkId")] public string NetworkId { get; set; } 
         [JsonProperty("targetId")] public string TargetId { get; set; }
+        [JsonProperty("userId")] public string UserId { get; set; }
     }
     public class GetBannedMembersReq { [JsonProperty("networkId")] public string NetworkId { get; set; } }
     public class AssignRankToMemberReq 
@@ -187,6 +188,8 @@ namespace Chtn.CSharp.SDK.Models.Network
     { 
         [JsonProperty("rankId")] public string RankId { get; set; } 
         [JsonProperty("targetId")] public string TargetId { get; set; }
+        [JsonProperty("networkId")] public string NetworkId { get; set; }
+        [JsonProperty("userId")] public string UserId { get; set; }
     }
     #endregion
 

Services/FileUploadMethods.cs

@@ -1,34 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using Chtn.CSharp.SDK.Core;
-using Chtn.CSharp.SDK.Models.Media;
-
-namespace Chtn.CSharp.SDK.Services
-{
-    public interface IFileUploadService
-    {
-        Task<RegisterUploadResp> UploadFiles(RegisterUploadReq req);
-        Task<RegisterUploadResp> UploadFile(RegisterUploadReq req);
-        Task UploadChunk(ChunkUploadReq req);
-    }
-
-    public class FileUploadServiceProvider : IFileUploadService
-    {
-        private readonly ApiClient _apiClient;
-        
-        public FileUploadServiceProvider(ApiClient apiClient)
-        {
-            _apiClient = apiClient ?? throw new ArgumentNullException(nameof(apiClient));
-        }
-
-        public async Task<RegisterUploadResp> UploadFiles(RegisterUploadReq req) =>
-            await _apiClient.PostAsync<RegisterUploadReq, RegisterUploadResp>("chat/cdnRegisterUpload", req);
-
-        public async Task<RegisterUploadResp> UploadFile(RegisterUploadReq req) =>
-            await UploadFiles(req);
-
-        public async Task UploadChunk(ChunkUploadReq req) =>
-            await _apiClient.PostAsync<ChunkUploadReq, object>("chat/uploadChunk", req);
-    }
-}

Services/FileUploadService.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Chtn.CSharp.SDK.Core;
+using Chtn.CSharp.SDK.Models.Media;
+using Chtn.CSharp.SDK.Models;
+
+namespace Chtn.CSharp.SDK.Services
+{
+    public interface IFileUploadService
+    {
+        Task<string> UploadFiles(string tempMsgId, string roomId, string userId, List<FileData> files, IFileUploadProgressListener listener);
+    }
+
+    public class FileUploadService : IFileUploadService
+    {
+        private readonly ApiClient _apiClient;
+        private readonly ApiClient _cdnClient;
+        private const int MIN_CHUNK_SIZE = 25000000;
+
+        public FileUploadService(ApiClient apiClient, ApiClient cdnClient)
+        {
+            _apiClient = apiClient ?? throw new ArgumentNullException(nameof(apiClient));
+            _cdnClient = cdnClient ?? throw new ArgumentNullException(nameof(cdnClient));
+        }
+
+        private int CalculateChunkSize(long totalSize)
+        {
+            long chunks = totalSize / MIN_CHUNK_SIZE;
+            if (chunks == 0) return (int)totalSize;
+            long chunkSize = (long)Math.Ceiling((double)totalSize / chunks);
+            return (int)Math.Max(chunkSize, MIN_CHUNK_SIZE);
+        }
+
+        public async Task<string> UploadFiles(string tempMsgId, string roomId, string userId, List<FileData> files, IFileUploadProgressListener listener)
+        {
+            var registrations = files.Select(f => new FileUploadRegistration
+            {
+                FileId = f.FileId,
+                Name = f.Name,
+                Type = f.Type,
+                Size = f.Data.Length
+            }).ToList();
+
+            var regReq = new RegisterUploadReq
+            {
+                RoomId = roomId,
+                UserId = userId, 
+                Files = registrations
+            };
+
+            var resp = await _apiClient.PostAsync<RegisterUploadReq, RegisterUploadResp>("chat/cdnRegisterUpload", regReq);
+            string uploadId = resp.UploadId;
+
+            for (int i = 0; i < files.Count; i++)
+            { 
+                await UploadFileInternal(tempMsgId, uploadId, roomId, userId, files[i], registrations[i], listener);
+            }
+
+            await FinishUploadInternal(roomId, userId, uploadId);
+
+            return uploadId;
+        }
+
+        private async Task UploadFileInternal(string tempMsgId, string uploadId, string roomId, string userId, FileData file, FileUploadRegistration registration, IFileUploadProgressListener listener)
+        {
+            int chunkSize = CalculateChunkSize(file.Data.Length);
+            int totalChunks = (int)Math.Ceiling((double)file.Data.Length / chunkSize);
+
+            for (int i = 0; i < totalChunks; i++)
+            {
+                int start = i * chunkSize;
+                int length = (int)Math.Min(chunkSize, file.Data.Length - start);
+
+                byte[] chunkData = new byte[length];
+                Array.Copy(file.Data, start, chunkData, 0, length);
+
+                var chunkReq = new ChunkUploadReq
+                {
+                    UploadId = uploadId,
+                    ChunkIndex = i,
+                    Data = chunkData
+                };
+
+                await _cdnClient.PostAsync<ChunkUploadReq, object>("chat/uploadChunk", chunkReq);
+                listener?.FileProgressUpdate(tempMsgId, file.FileId, totalChunks, i);
+            }
+        }
+
+        private async Task FinishUploadInternal(string roomId, string userId, string uploadId)
+        {
+            var finishReq = new FinishUploadReq
+            {
+                UploadId = uploadId
+            };
+
+            await _cdnClient.PostAsync<FinishUploadReq, object>("chat/finishUpload", finishReq);
+        }
+    }
+}

Services/NetworkService.cs

@@ -10,19 +10,19 @@ namespace Chtn.CSharp.SDK.Services
     {
         // General & Discovery
         Task<NetworkInvite> CreateInvite(CreateInviteReq req);
-        Task<List<NetworkInvite>> GetInvites(GetInvitesReq req);
+        Task<List<NetworkInvite>> GetInvites();
         Task Create(CreateNetworkReq req);
-        Task<List<Network>> GetNetworks(GetNetworksReq req);
+        Task<List<Network>> GetNetworks();
         Task AcceptInvite(AcceptInviteReq req);
         Task JoinPublicNetwork(JoinPublicNetworkReq req);
-        Task Leave(LeaveNetworkReq req);
-        Task Delete(DeleteNetworkReq req);
-        Task<Network> GetFromInvite(GetFromInviteReq req);
+        Task Leave();
+        Task Delete();
+        Task<Network> GetFromInvite(string inviteCode);
         Task<NetworkDiscovery> GetDiscovery();
 
         // Categories
         Task CreateCategory(CreateCategoryReq req);
-        Task DeleteCategory(DeleteCategoryReq req);
+        Task DeleteCategory(string categoryId);
         Task MoveCategory(MoveCategoryReq req);
         Task EditCategory(EditCategoryReq req);
         Task ToggleCategoryMute(ToggleCategoryMuteReq req);
@@ -47,14 +47,14 @@ namespace Chtn.CSharp.SDK.Services
         Task UnbanMember(UnbanMemberReq req);
         Task<List<BannedMember>> GetBannedMembers(GetBannedMembersReq req);
 
-        //Permissions & Overwrites
+        // Permissions & Overwrites
         Task ModifyRankPermissions(ModifyPermissionsReq req);
         Task OverwritePermission(OverwritePermissionReq req);
         Task OverwriteChannelPermission(OverwriteChannelPermissionReq req);
         Task<List<PermissionOverwrite>> GetOverwrites(GetOverwritesReq req);
         Task<List<PermissionOverwrite>> GetChannelOverwrites(GetChannelOverwritesReq req);
 
-        // Settings & Realtime
+        // Settings & Real-time
         Task UploadNewPic(UploadNewPictureReq req);
         Task ChangeVisibility(ChangeVisibilityReq req);
         Task EditName(EditNameReq req);
@@ -62,47 +62,68 @@ namespace Chtn.CSharp.SDK.Services
         Task JoinWebSocketRoom(JoinWebSocketRoomReq req);
     }
 
-    public class NetworkServiceProvider : INetworkService
+    public class NetworkService : INetworkService
     {
         private readonly ApiClient _apiClient;
+        private readonly string _userId;
+        private readonly string _token;
+        private readonly string _networkId;
+        private readonly string _database;
 
-        public NetworkServiceProvider(ApiClient apiClient)
+        public NetworkService(ApiClient apiClient, string userId, string token, string networkId, string database)
         {
             _apiClient = apiClient ?? throw new ArgumentNullException(nameof(apiClient));
+            _userId = userId ?? throw new ArgumentNullException(nameof(userId));
+            _token = token ?? throw new ArgumentNullException(nameof(token));
+            _networkId = networkId ?? throw new ArgumentNullException(nameof(networkId));
+            _database = database ?? throw new ArgumentNullException(nameof(database));
         }
 
         #region General & Discovery
         public async Task<NetworkInvite> CreateInvite(CreateInviteReq req) =>
             await _apiClient.PostAsync<CreateInviteReq, NetworkInvite>("network/createInvite", req);
-        public async Task<List<NetworkInvite>> GetInvites(GetInvitesReq req) => 
-            await _apiClient.PostAsync<GetInvitesReq, List<NetworkInvite>>("network/invites", req);
+
+        public async Task<List<NetworkInvite>> GetInvites() =>
+            await _apiClient.GetAsync<List<NetworkInvite>>($"network/invites?networkId={_networkId}");
+
         public async Task Create(CreateNetworkReq req) =>
             await _apiClient.PostAsync<CreateNetworkReq, object>("network/create", req);
-        public async Task<List<Network>> GetNetworks(GetNetworksReq req) => 
-            await _apiClient.PostAsync<GetNetworksReq, List<Network>>("network/get", req);
+
+        public async Task<List<Network>> GetNetworks() =>
+            await _apiClient.GetAsync<List<Network>>("network/get");
+
         public async Task AcceptInvite(AcceptInviteReq req) =>
             await _apiClient.PostAsync<AcceptInviteReq, object>("network/acceptInvite", req);
+
         public async Task JoinPublicNetwork(JoinPublicNetworkReq req) =>
             await _apiClient.PostAsync<JoinPublicNetworkReq, object>("network/joinNetworkDiscovery", req);
-        public async Task Leave(LeaveNetworkReq req) => 
-            await _apiClient.PostAsync<LeaveNetworkReq, object>("network/leave", req);
-        public async Task Delete(DeleteNetworkReq req) =>
-            await _apiClient.PostAsync<DeleteNetworkReq, object>("network/delete", req);
-        public async Task<Network> GetFromInvite(GetFromInviteReq req) => 
-            await _apiClient.PostAsync<GetFromInviteReq, Network>("network/fromInvite", req);
+
+        public async Task Leave() =>
+            await _apiClient.DeleteAsync<object>($"network/leave/{_networkId}/{_userId}");
+
+        public async Task Delete() =>
+            await _apiClient.DeleteAsync<object>($"network/delete/{_networkId}");
+
+        public async Task<Network> GetFromInvite(string inviteCode) =>
+            await _apiClient.GetAsync<Network>($"network/fromInvite?code={inviteCode}");
+
         public async Task<NetworkDiscovery> GetDiscovery() =>
-            await _apiClient.PostAsync<object, NetworkDiscovery>("network/discovery", new { });
+            await _apiClient.GetAsync<NetworkDiscovery>("network/discovery");
         #endregion
 
         #region Categories
         public async Task CreateCategory(CreateCategoryReq req) =>
             await _apiClient.PostAsync<CreateCategoryReq, object>("network/createCategory", req);
-        public async Task DeleteCategory(DeleteCategoryReq req) => 
-            await _apiClient.PostAsync<DeleteCategoryReq, object>("network/deleteCategory", req);
+
+        public async Task DeleteCategory(string categoryId) =>
+            await _apiClient.DeleteAsync<object>($"network/deleteCategory/{_networkId}/{categoryId}");
+
         public async Task MoveCategory(MoveCategoryReq req) =>
-            await _apiClient.PostAsync<MoveCategoryReq, object>("network/moveCategory", req);
+            await _apiClient.PatchAsync<MoveCategoryReq, object>("network/moveCategory", req);
+
         public async Task EditCategory(EditCategoryReq req) =>
-            await _apiClient.PostAsync<EditCategoryReq, object>("network/editCategory", req);
+            await _apiClient.PatchAsync<EditCategoryReq, object>("network/editCategory", req);
+
         public async Task ToggleCategoryMute(ToggleCategoryMuteReq req) =>
             await _apiClient.PostAsync<ToggleCategoryMuteReq, object>("network/toggleCatMute", req);
         #endregion
@@ -110,8 +131,10 @@ namespace Chtn.CSharp.SDK.Services
         #region Channels
         public async Task CreateChannel(CreateChannelReq req) =>
             await _apiClient.PostAsync<CreateChannelReq, object>("network/createChannel", req);
+
         public async Task EditChannel(EditChannelReq req) =>
-            await _apiClient.PostAsync<EditChannelReq, object>("network/editChannel", req);
+            await _apiClient.PatchAsync<EditChannelReq, object>("network/editChannel", req);
+
         public async Task ToggleChannelMute(ToggleChannelMuteReq req) =>
             await _apiClient.PostAsync<ToggleChannelMuteReq, object>("network/toggleChanMute", req);
         #endregion
@@ -119,53 +142,70 @@ namespace Chtn.CSharp.SDK.Services
         #region Ranks & Members
         public async Task CreateRank(CreateRankReq req) =>
             await _apiClient.PostAsync<CreateRankReq, object>("network/createRank", req);
+
         public async Task DeleteRank(DeleteRankReq req) =>
-            await _apiClient.PostAsync<DeleteRankReq, object>("network/deleteRank", req);
+            await _apiClient.DeleteAsync<object>($"network/deleteRank/{_networkId}/{req.RankId}");
+
         public async Task MoveRank(MoveRankReq req) =>
-            await _apiClient.PostAsync<MoveRankReq, object>("network/moveRank", req);
+            await _apiClient.PatchAsync<MoveRankReq, object>("network/moveRank", req);
+
         public async Task EditRank(EditRankReq req) =>
-            await _apiClient.PostAsync<EditRankReq, object>("network/editRank", req);
+            await _apiClient.PatchAsync<EditRankReq, object>("network/editRank", req);
+
         public async Task AssignRankToMember(AssignRankToMemberReq req) =>
             await _apiClient.PostAsync<AssignRankToMemberReq, object>("network/assignRankToMember", req);
+
         public async Task RemoveRankFromMember(RemoveRankFromMemberReq req) =>
-            await _apiClient.PostAsync<RemoveRankFromMemberReq, object>("network/removeRankFromMember", req);
+            await _apiClient.DeleteAsync<object>($"network/removeRankFromMember/{_networkId}/{req.UserId}/{req.RankId}");
+
         public async Task<List<NetworkMember>> GetMembers(GetMembersReq req) =>
-            await _apiClient.PostAsync<GetMembersReq, List<NetworkMember>>("network/getMembers", req);
+            await _apiClient.GetAsync<List<NetworkMember>>($"network/getMembers?networkId={_networkId}");
         #endregion
 
         #region Moderation
         public async Task KickMember(KickMemberReq req) =>
             await _apiClient.PostAsync<KickMemberReq, object>("network/kickMember", req);
+
         public async Task BanMember(BanMemberReq req) =>
             await _apiClient.PostAsync<BanMemberReq, object>("network/banMember", req);
+
         public async Task UnbanMember(UnbanMemberReq req) =>
-            await _apiClient.PostAsync<UnbanMemberReq, object>("network/unbanMember", req);
+            await _apiClient.DeleteAsync<object>($"network/unbanMember/{_networkId}/{req.UserId}");
+
         public async Task<List<BannedMember>> GetBannedMembers(GetBannedMembersReq req) =>
-            await _apiClient.PostAsync<GetBannedMembersReq, List<BannedMember>>("network/getBannedMembers", req);
+            await _apiClient.GetAsync<List<BannedMember>>($"network/getBannedMembers?networkId={_networkId}");
         #endregion
 
         #region Permissions & Overwrites
         public async Task ModifyRankPermissions(ModifyPermissionsReq req) =>
-            await _apiClient.PostAsync<ModifyPermissionsReq, object>("network/modifyPermissions", req);
+            await _apiClient.PatchAsync<ModifyPermissionsReq, object>("network/modifyPermissions", req);
+
         public async Task OverwritePermission(OverwritePermissionReq req) =>
             await _apiClient.PostAsync<OverwritePermissionReq, object>("network/overwritePermission", req);
+
         public async Task OverwriteChannelPermission(OverwriteChannelPermissionReq req) =>
             await _apiClient.PostAsync<OverwriteChannelPermissionReq, object>("network/overwriteChannelPermission", req);
+
         public async Task<List<PermissionOverwrite>> GetOverwrites(GetOverwritesReq req) =>
-            await _apiClient.PostAsync<GetOverwritesReq, List<PermissionOverwrite>>("network/getOverwrites", req);
+            await _apiClient.GetAsync<List<PermissionOverwrite>>($"network/getOverwrites?networkId={_networkId}");
+
         public async Task<List<PermissionOverwrite>> GetChannelOverwrites(GetChannelOverwritesReq req) =>
-            await _apiClient.PostAsync<GetChannelOverwritesReq, List<PermissionOverwrite>>("network/getChannelOverwrites", req);
+            await _apiClient.GetAsync<List<PermissionOverwrite>>($"network/getChannelOverwrites?channelId={req.ChannelId}");
         #endregion
 
         #region Settings & Real-time
         public async Task UploadNewPic(UploadNewPictureReq req) =>
             await _apiClient.PostAsync<UploadNewPictureReq, object>("v2/network/uploadNewPic", req);
+
         public async Task ChangeVisibility(ChangeVisibilityReq req) =>
-            await _apiClient.PostAsync<ChangeVisibilityReq, object>("network/changeVisibility", req);
+            await _apiClient.PatchAsync<ChangeVisibilityReq, object>("network/changeVisibility", req);
+
         public async Task EditName(EditNameReq req) =>
-            await _apiClient.PostAsync<EditNameReq, object>("network/editName", req);
+            await _apiClient.PatchAsync<EditNameReq, object>("network/editName", req);
+
         public async Task ToggleMute(ToggleNetworkMuteReq req) =>
             await _apiClient.PostAsync<ToggleNetworkMuteReq, object>("network/toggleNetMute", req);
+
         public async Task JoinWebSocketRoom(JoinWebSocketRoomReq req) =>
             await _apiClient.PostAsync<JoinWebSocketRoomReq, object>("v2/network/joinWebSocketRoom", req);
         #endregion