implement Broadcast and SessionManager services

Models/BroadcastModels.cs

@@ -1,9 +1,29 @@
-namespace Chtn.CSharp.SDK.Models.Call
+using Newtonsoft.Json;
+using System.Collections.Generic;
+
+namespace Chtn.CSharp.SDK.Models.Call
 {
     public class StreamRegistry
     {
-        public string StreamKey { get; set; }
+        [JsonProperty("streamKey")] public string SreamKey { get; set; }
-        public string Status { get; set; }
+        [JsonProperty("status")] public List<string> Status { get; set; }
-        public string StreamUrl { get; set; }
+        [JsonProperty("streamUrl")] public List<string> StreamUrl { get; set; }
+    }
+
+    public class CreateServerReq
+    {
+        [JsonProperty("channelId")] public List<string> ChannelId { get; set; }
+        [JsonProperty("name")] public List<string> Name { get; set; }
+    }
+
+    public class GetRtmpDataReq
+    {
+        [JsonProperty("channelId")] public List<string> ChannelId { get; set; }
+    }
+
+    public class BroadcastJoinWsRoomReq
+    {
+        [JsonProperty("connId")] public List<string> ConnId { get; set; }
+        [JsonProperty("channelId")] public List<string> ChannelId { get; set; }
     }
 }

Models/SessionManagerModels.cs

@@ -1,4 +1,9 @@
-namespace Chtn.CSharp.SDK.Models.Session
+using Newtonsoft.Json;
+
+namespace Chtn.CSharp.SDK.Models.Session
 {
-    public class ValidateSessionReq { public string Token { get; set; } }
+    public class ValidateSessionReq 
+    {
+        [JsonProperty("token")] public string Token { get; set; }
+    }
 }

Models/SessionModels.cs

@@ -1,4 +1,5 @@
-using Chtn.CSharp.SDK.Models.User;
+using System.Collections.Generic;
+using Chtn.CSharp.SDK.Models.User;
 using Newtonsoft.Json;
 
 namespace Chtn.CSharp.SDK.Models.Session
@@ -8,5 +9,8 @@ namespace Chtn.CSharp.SDK.Models.Session
         [JsonProperty("userData")] public PersonalUserData UserData { get; set; }
         [JsonProperty("token")] public string Token { get; set; }
     }
-    public class ValidateSessionResp { public bool ValidationOk { get; set; } }
+    public class ValidateSessionResp
+    {
+        [JsonProperty("validationOk")] public bool ValidationOk { get; set; }
+    }
 }

Services/AuthMethods.cs

@@ -1,7 +1,8 @@
-using System;
+using Chtn.CSharp.SDK.Core;
-using System.Threading.Tasks;
 using Chtn.CSharp.SDK.Models.Auth;
-using Chtn.CSharp.SDK.Core;
+using Chtn.CSharp.SDK.Models.Session;
+using System;
+using System.Threading.Tasks;
 
 namespace Chtn.CSharp.SDK.Services
 {
@@ -21,6 +22,7 @@ namespace Chtn.CSharp.SDK.Services
         Task<SignInSuccessResp> Register(RegisterReq req);
         Task<ResetPasswordResp> ResetPassword(ResetPasswordReq req);
         Task VerifyResetCode(VerifyPasswordResetReq req);
+        Task<ValidateSessionResp> ValidateSession(ValidateSessionReq req);
     }
 
     public class AuthServiceProvider : IAuthService
@@ -73,5 +75,8 @@ namespace Chtn.CSharp.SDK.Services
 
         public async Task VerifyResetCode(VerifyPasswordResetReq req) =>
             await _apiClient.PostAsync<VerifyPasswordResetReq, object>("user/verifyResetCode", req);
+
+        public async Task<ValidateSessionResp> ValidateSession(ValidateSessionReq req) =>
+    await _apiClient.PostAsync<ValidateSessionReq, ValidateSessionResp>("v2/user/validateSession", req);
     }
 }

Services/BroadcastMethods.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Threading.Tasks;
+using Chtn.CSharp.SDK.Core;
+using Chtn.CSharp.SDK.Models.Call;
+
+namespace Chtn.CSharp.SDK.Services
+{
+    public interface IBroadcastService
+    {
+        Task<StreamRegistry> GetData(GetRtmpDataReq req);
+        Task CreateService(CreateServerReq req);
+        Task JoinWebSocketRoom(BroadcastJoinWsRoomReq req);
+    }
+
+    public class BroadcastServiceProvider : IBroadcastService
+    {
+        private readonly ApiClient _apiClient;
+
+        public BroadcastServiceProvider(ApiClient apiClient)
+        {
+            _apiClient = apiClient ?? throw new ArgumentNullException(nameof(apiClient));
+        }
+
+        public async Task<StreamRegistry> GetData(GetRtmpDataReq req) =>
+            await _apiClient.PostAsync<GetRtmpDataReq, StreamRegistry>("network/channel/rtmpData", req);
+        public async Task CreateService(CreateServerReq req) =>
+    await _apiClient.PostAsync<CreateServerReq, object>("network/channel/createServer", req);
+
+        public async Task JoinWebSocketRoom(BroadcastJoinWsRoomReq req) =>
+    await _apiClient.PostAsync<BroadcastJoinWsRoomReq, object>("v2/network/channel/joinWebSocketRoom", req);
+    }
+}

Services/SessionManagerMethods.cs

@@ -0,0 +1,91 @@
+using Chtn.CSharp.SDK.Core;
+using Chtn.CSharp.SDK.Models.Session;
+using Chtn.CSharpSDK.Interfaces;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Chtn.CSharp.SDK.Services
+{
+    public interface ISessionManager
+    {
+        void AddSession(Session session);
+        List<Session> LoadSessions();
+        Task<bool> ValidateSessions(IAuthService authService);
+        Session GetPreferredUser();
+        void SetPreferredUser(string userId);
+    }
+
+    public class SessionManagerProvider : ISessionManager
+    {
+        private readonly IDatabaseAPI _database;
+        private readonly IKeyringAPI _keyring;
+        private const string SESSION_KEY = "active_sessions";
+        private const string PREFERRED_USER_KEY = "preferred_user_id";
+
+        public SessionManagerProvider(IDatabaseAPI database, IKeyringAPI keyring)
+        {
+            _database = database ?? throw new ArgumentNullException(nameof(database));
+            _keyring = keyring ?? throw new ArgumentNullException(nameof(keyring));
+        }
+
+        public void AddSession(Session session)
+        {
+            var sessions = LoadSessions();
+            if (!sessions.Any(s => s.UserData.UserId == session.UserData.UserId))
+            {
+                sessions.Add(session);
+                SaveSessions(sessions);
+            }
+        }
+
+        public List<Session> LoadSessions()
+        {
+            var data = _database.Get("system", SESSION_KEY);
+            if (string.IsNullOrEmpty(data)) return new List<Session>();
+
+            try
+            {
+                return JsonConvert.DeserializeObject<List<Session>>(data);
+            }
+            catch
+            {
+                return new List<Session>();
+            }
+        }
+
+        public async Task<bool> ValidateSessions(IAuthService authService)
+        {
+            var current = GetPreferredUser();
+            if (current == null || string.IsNullOrEmpty(current.Token)) return false;
+
+            var req = new ValidateSessionReq { Token = current.Token };
+
+            var resp = await authService.ValidateSession(req);
+
+            return resp != null && resp.ValidationOk;
+        }
+
+        public Session GetPreferredUser()
+        {
+            var userId = _keyring.Get(PREFERRED_USER_KEY);
+            if (string.IsNullOrEmpty(userId)) return null;
+
+            return LoadSessions().FirstOrDefault(s => s.UserData.UserId == userId);
+        }
+
+        public void SetPreferredUser(string userId)
+        {
+            _keyring.Set(PREFERRED_USER_KEY, userId);
+        }
+
+        private void SaveSessions(List<Session> sessions)
+        {
+            var json = JsonConvert.SerializeObject(sessions);
+            _database.Set("system", SESSION_KEY, json);
+            _database.Flush();
+        }
+    }
+}