Example #1
0
        public static Tuple <string[], string[], string[], string[]> LoadInformation(string username)
        {
            try
            {
                using (NpgsqlConnection conn = new NpgsqlConnection(Network.NpgSQLConnection))
                {
                    string text = "";

                    conn.Open();

                    NpgsqlCommand myCommand = new NpgsqlCommand("SELECT * FROM embyrfriends.friends WHERE accountname = @accountname", conn);
                    myCommand.Parameters.Add(new NpgsqlParameter(":accountname", username));
                    NpgsqlDataReader friendsReader = myCommand.ExecuteReader();
                    friendsReader.Read();

                    string friendsFromDB = friendsReader[2].ToString();

                    text = friendsFromDB;

                    string[] friends = text.Split(GlobalVar.delimiterChars, System.StringSplitOptions.RemoveEmptyEntries);

                    string requestsIn = friendsReader[3].ToString();

                    text = requestsIn;

                    string[] reqIn = text.Split(GlobalVar.delimiterChars, System.StringSplitOptions.RemoveEmptyEntries);

                    string requestsOut = friendsReader[4].ToString();

                    text = requestsOut;

                    string[] reqOut = text.Split(GlobalVar.delimiterChars, System.StringSplitOptions.RemoveEmptyEntries);

                    conn.Close();

                    string[] friendsStatus = new string[friends.Length];

                    int i = 0;

                    foreach (string friend in friends)
                    {
                        friendsStatus[i] = FriendsList.GetStatus(friend);
                        i++;
                    }

                    var tuple = new Tuple <string[], string[], string[], string[]>(friends, reqIn, reqOut, friendsStatus);

                    return(tuple);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                return(null);
            }
        }
        public async Task InvokeAsync(HttpContext context)
        {
            if (context.WebSockets.IsWebSocketRequest)
            {
                WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();

                bool clientEstablished = false;

                await Receive(webSocket, async (result, buffer) =>
                {
                    if (clientEstablished == false && result.MessageType == WebSocketMessageType.Text)
                    {
                        _manager.AddSocket(Encoding.UTF8.GetString(buffer, 0, result.Count), webSocket);
                        clientEstablished = true;
                        string username   = Encoding.UTF8.GetString(buffer, 0, result.Count);
                        await webSocket.SendAsync(Encoding.UTF8.GetBytes("{\"eventV\": \"setProfilePhoto\", \"user\": \"" + username + "\", \"photoBytes\": \"" + ProfilePhoto.GetImage(username) + "\"}"), WebSocketMessageType.Text, true, CancellationToken.None);
                        FriendsList.SetOnline(username, "true");
                        List <string> obj = new List <string>()
                        {
                            username, FriendsList.GetStatus(username)
                        };
                        List <string> friends = FriendsList.GetFriends(username).Split(GlobalVar.delimiterChars, System.StringSplitOptions.RemoveEmptyEntries).OfType <string>().ToList();
                        foreach (string friend in friends)
                        {
                            await RouteJSONMessageAsync("setStatus", obj, friend);
                            try
                            {
                                await webSocket.SendAsync(Encoding.UTF8.GetBytes("{\"eventV\": \"setProfilePhoto\", \"user\": \"" + friend + "\", \"photoBytes\": \"" + ProfilePhoto.GetImage(friend) + "\"}"), WebSocketMessageType.Text, true, CancellationToken.None);
                            }
                            catch
                            {
                                Console.WriteLine("Error Loading {0}'s Profile Photo!", friend);
                            }
                        }

                        Console.WriteLine($"WebSocket Operation: Client->EstablishedConnection");
                        Console.WriteLine("\nSet the status of: {0}\tChanged to: online", obj[0]);
                    }
                    else
                    {
                        if (result.MessageType == WebSocketMessageType.Text)
                        {
                            List <string> obj = new List <string>();
                            dynamic jsonObj   = JObject.Parse(Encoding.UTF8.GetString(buffer, 0, result.Count));
                            string job        = jsonObj.job;
                            switch (job)
                            {
                            case ("sendMessage"):
                                obj.Add((jsonObj.message).ToString());
                                obj.Add((jsonObj.sender).ToString());
                                obj.Add((jsonObj.receiver).ToString());
                                obj.Add(GlobalVar.currentDateMsg());
                                obj.Add((jsonObj.ghostMode).ToString());
                                Console.WriteLine(obj[4].ToString());
                                Console.WriteLine("Operation:\tsendMessage\n");
                                await RouteJSONMessageAsync(job, obj, obj[2]);
                                break;

                            case ("setStatus"):
                                obj.Add((jsonObj.sender).ToString());
                                obj.Add((jsonObj.status).ToString());
                                Console.WriteLine("Operation:\tsetStatus\n");
                                List <string> friends = FriendsList.GetFriends(obj[0]).Split(GlobalVar.delimiterChars, System.StringSplitOptions.RemoveEmptyEntries).OfType <string>().ToList();
                                foreach (string friend in friends)
                                {
                                    await RouteJSONMessageAsync(job, obj, friend);
                                }
                                break;

                            case ("addFriendReq"):
                                obj.Add((jsonObj.sender).ToString());
                                obj.Add((jsonObj.receiver).ToString());
                                Console.WriteLine("Operation:\taddFriendReq\n");
                                if (KeyTagID.GetUserExists(obj[1]))
                                {
                                    FriendsList flAFR = new FriendsList("ADDFR", obj[0], obj[1], KeyTagID.GrabUserKeyTag(obj[0]));
                                    await webSocket.SendAsync(Encoding.UTF8.GetBytes("{\"eventV\": \"userExists\", \"existsV\": true, \"user\": \"" + obj[1].ToString() + "\"}"), WebSocketMessageType.Text, true, CancellationToken.None);
                                    await RouteJSONMessageAsync(job, obj, obj[1]);
                                }
                                else
                                {
                                    await webSocket.SendAsync(Encoding.UTF8.GetBytes("{\"eventV\": \"userExists\", \"existsV\": false}"), WebSocketMessageType.Text, true, CancellationToken.None);
                                }
                                break;

                            case ("cancelFriendReq"):
                                obj.Add((jsonObj.sender).ToString());
                                obj.Add((jsonObj.receiver).ToString());
                                Console.WriteLine("Operation:\tcancelFriendReq\n");
                                FriendsList flRFR = new FriendsList("REMOVEFR", obj[0], obj[1], KeyTagID.GrabUserKeyTag(obj[0]));
                                await RouteJSONMessageAsync(job, obj, obj[1]);
                                break;

                            case ("acceptFriendReq"):
                                obj.Add((jsonObj.sender).ToString());
                                obj.Add((jsonObj.receiver).ToString());
                                obj.Add(ProfilePhoto.GetImage(obj[0]));
                                Console.WriteLine("Operation:\tacceptFriendReq\n");
                                FriendsList flACFR = new FriendsList("ACCEPTFR", obj[0], obj[1], KeyTagID.GrabUserKeyTag(obj[0]));
                                await RouteJSONMessageAsync(job, obj, obj[1]);
                                await webSocket.SendAsync(Encoding.UTF8.GetBytes("{\"eventV\": \"setProfilePhoto\", \"user\": \"" + obj[0] + "\", \"photoBytes\": \"" + ProfilePhoto.GetImage(obj[1]) + "\"}"), WebSocketMessageType.Text, true, CancellationToken.None);
                                break;

                            case ("declineFriendReq"):
                                obj.Add((jsonObj.sender).ToString());
                                obj.Add((jsonObj.receiver).ToString());
                                Console.WriteLine("Operation:\tdeclineFriendReq\n");
                                FriendsList flDFR = new FriendsList("DECLINEFR", obj[0], obj[1], 0);
                                await RouteJSONMessageAsync(job, obj, obj[1]);
                                break;

                            case ("removeFriend"):
                                obj.Add((jsonObj.sender).ToString());
                                obj.Add((jsonObj.receiver).ToString());
                                Console.WriteLine("Operation:\removeFriend\n");
                                FriendsList flRF = new FriendsList("REMOVE", obj[0], obj[1], 0);
                                await RouteJSONMessageAsync(job, obj, obj[1]);
                                break;

                            case ("setProfilePhoto"):
                                obj.Add((jsonObj.sender).ToString());
                                obj.Add((jsonObj.photoBytes).ToString());
                                Console.WriteLine("Operation:\tsetProfilePhoto\n");
                                ProfilePhoto.SaveImage(obj[0], obj[1]);
                                List <string> friendsPP = FriendsList.GetFriends(obj[0]).Split(GlobalVar.delimiterChars, System.StringSplitOptions.RemoveEmptyEntries).OfType <string>().ToList();
                                foreach (string friend in friendsPP)
                                {
                                    await RouteJSONMessageAsync(job, obj, friend);
                                }
                                break;
                            }
                            obj.Clear();
                        }
                        else if (result.MessageType == WebSocketMessageType.Close)
                        {
                            string id = _manager.GetAllSockets().FirstOrDefault(s => s.Value == webSocket).Key;

                            _manager.GetAllSockets().TryRemove(id, out WebSocket sock);

                            await sock.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);

                            List <string> obj = new List <string>();
                            obj.Add(id);
                            obj.Add("offline");
                            List <string> friends = FriendsList.GetFriends(obj[0]).Split(GlobalVar.delimiterChars, System.StringSplitOptions.RemoveEmptyEntries).OfType <string>().ToList();
                            foreach (string friend in friends)
                            {
                                await RouteJSONMessageAsync("setStatusOffline", obj, friend);
                            }
                            FriendsList.SetOnline(id, "false");
                            Console.WriteLine("\nSet the status of: {0}\tChanged to: {1}", obj[0], obj[1]);
                            Console.WriteLine($"WebSocket Operation: Receive->Close");
                        }
                    }
                    requestCount++;
                    Console.WriteLine("\nRequest #: " + requestCount + "\nManaged Connections: " + _manager.GetAllSockets().Count.ToString());
                    Console.WriteLine("\n\n" + GlobalVar.border + "\n");
                    return;
                });
            }
            else
            {
                await _next(context);
            }
        }