Create Client.cs

Author: hackinghackers

Client.cs

@@ -0,0 +1,183 @@
+using System;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using LeanCloud;
+using LeanCloud.Storage;
+using LeanCloud.Realtime;
+
+namespace ChatStack
+{
+    public class Client
+    {
+
+        public bool Beep = true;
+
+        LCIMClient UserClient;
+        LCIMConversation Chatroom;
+
+        Dictionary<string, string> UsernameIndex = new Dictionary<string, string>();
+
+        // TODO: Detect if the user is typing.
+        // Queue<LCIMTextMessage> MessageBuffer = new Queue<LCIMTextMessage>();
+
+
+        public static void InitApp(string appId, string appKey, string url = null)
+        {
+            // Initialize the app with the LeanCloud credentials.
+            LCApplication.Initialize(appId, appKey, url);
+        }
+
+        public static async Task<LCUser> LoginUserAsync(string username, string password)
+        {
+            // Check if the username is an email address.
+            if (new System.ComponentModel.DataAnnotations.EmailAddressAttribute().IsValid(username))
+            {
+                return await LCUser.LoginByEmail(username, password);
+            }
+            return await LCUser.Login(username, password);
+        }
+
+        public async Task LoginClientAsync(string username, string password)
+        {
+            // Log in to client using LCUser.
+            UserClient = new LCIMClient(await LoginUserAsync(username, password));
+
+            await InitClientAsync();
+        }
+
+        public async Task InitClientAsync()
+        {
+            // Initiate the client with the server.
+            await UserClient.Open();
+        }
+
+        public async Task GetChatroomAsync()
+        {
+            // Query the ChatStack chatroom.
+            var conversationQuery = UserClient.GetQuery()
+                .WhereEqualTo("name", "ChatStack")
+                .WhereEqualTo("tr", true);
+            var queryResult = await conversationQuery.Find();
+
+            Chatroom = queryResult[0];
+        }
+
+        public async Task StartChatAsync()
+        {
+
+            // Join the chat.
+            await Chatroom.Join();
+
+            // TODO: Fetch previous messages.
+
+            // Print the prompt and the number of online users in the chatroom.
+            Console.WriteLine("You are now in the chat. Type /exit or /quit to exit.");
+            Console.WriteLine(await Chatroom.GetMembersCount() + " people online.");
+
+            // Listen for messages.
+            UserClient.OnMessage = async (_, message) =>
+            {
+                // If the message received is text, assign it to textMessage.
+                if (message is LCIMTextMessage textMessage)
+                {
+
+                    if (!UsernameIndex.ContainsKey(textMessage.FromClientId))
+                    {
+                        // Query and save the sender's username if it's not in the index.
+                        LCQuery<LCUser> senderQuery = LCUser.GetQuery();
+                        UsernameIndex[textMessage.FromClientId] = (await senderQuery.Get(textMessage.FromClientId)).Username;
+                    }
+
+                    // TODO: Detect if the user is typing.
+                    // // Peek the input stream without reading it.
+                    // if ((new StreamReader(Console.OpenStandardInput()).Peek() == -1))
+                    // {
+                    //     // If the user hasn't typed anything, print the message.
+                    //     PrintMessage(textMessage);
+
+                    //     // Print the prompt again.
+                    //     Console.Write("> ");
+                    // }
+                    // else
+                    // {
+                    //     // If the user is typing, save the message to the buffer.
+                    //     MessageBuffer.Enqueue(textMessage);
+                    // }
+
+                    PrintMessage(textMessage);
+
+                }
+            };
+
+            // Ask for message input constantly.
+            await AskForMessageInputAsync();
+
+        }
+
+        async Task AskForMessageInputAsync()
+        {
+            while (true)
+            {
+
+                // Print prompt and get input.
+                Console.Write("> ");
+                string input = await Task.Run(() => Console.ReadLine().Trim());
+
+                // TODO: Detect if the user is typing.
+                // Clear message buffer.
+                // while (MessageBuffer.Count > 0)
+                //     PrintMessage(MessageBuffer.Dequeue());
+
+                // Check the input for exit commands.
+                if (input == "/exit" || input == "/quit") break;
+
+                // Send the message if the input is not empty.
+                if (!string.IsNullOrWhiteSpace(input))
+                {
+                    _ = await Chatroom.Send(new LCIMTextMessage(input));
+                }
+
+            }
+        }
+
+        void PrintMessage(LCIMTextMessage message)
+        {
+
+            // Play a beep sound if beep is enabled.
+            if (Beep)
+                Console.Beep();
+
+            // TODO: Detect if the user is typing.
+            // Set cursor position to the beginning of the line.
+            // Console.SetCursorPosition(0, Console.CursorTop);
+            Console.WriteLine();
+
+            // Print the message sender's username and the message content.
+            Console.WriteLine($"* {UsernameIndex[message.FromClientId]}: {message.Text}");
+
+            // Print the prompt again.
+            Console.Write("> ");
+
+        }
+
+        // public static void DebugLogger(LCLogLevel level, string info)
+        // {
+        //     switch (level)
+        //     {
+        //         case LCLogLevel.Debug:
+        //             Console.WriteLine("[DEBUG] " + info);
+        //             break;
+        //         case LCLogLevel.Warn:
+        //             Console.WriteLine("[WARNING] " + info);
+        //             break;
+        //         case LCLogLevel.Error:
+        //             Console.WriteLine("[ERROR] " + info);
+        //             break;
+        //         default:
+        //             Console.WriteLine(info);
+        //             break;
+        //     }
+        // }
+
+    }
+}