Exemple #1
0
        private static void DeleteEvent(Packets.AgendaEventPacket packet, Server server, IPEndPoint ip)
        {
            // Deleting the event of database
            using (var db = new Models.ServerDatabase())
            {
                if (db.AgendaEvents.Any(c => c.Client.Username == packet.Username &&
                                        c.Date.Equals(packet.Date) &&
                                        c.EventInfo.Equals(packet.EventInfo) &&
                                        c.EventName.Equals(packet.EventName)))
                {
                    db.AgendaEvents.DeleteAllOnSubmit(
                        db.AgendaEvents.Where(c => c.Client.Username == packet.Username &&
                                              c.Date.Equals(packet.Date) &&
                                              c.EventInfo.Equals(packet.EventInfo) &&
                                              c.EventName.Equals(packet.EventName))

                        );
                    db.SubmitChanges();
                }
                else
                {
                    server.DebugInfo("Delete Agenda Event: Unable to find on the database.");
                    server.Udp.SendError("Unable to find on the database.", ip);
                    return;
                }

                server.DebugInfo("Delete Agenda Event: Deletd event correctly");
                server.Udp.SendMessage(new Packets.AckErrorPacket(Packets.PacketTypes.DeleteAgendaEventAck, "Event deleted").Pack(), ip);
            }
        }
        public static void Alive(byte[] data, IPEndPoint ip, Server server)
        {
            string message = "";

            BasicReqPacket aPacket = Packet.Unpack <BasicReqPacket>(data);

            server.DebugInfo("Alive inf recieved.");
            server.DebugInfo("AliveInf Packet: " + aPacket.ToString());

            ClientStatus current = server.GetClient(aPacket.Username);

            if (ClientsManagement.CheckBasics(current, ClientStatus.Status.Disconnected, aPacket.Alea, out message))
            {
                // Save the last alive
                current.LastAlive = DateTime.Now;
                // Send ack
                server.Udp.SendMessage(new AckErrorPacket(PacketTypes.AliveAck, "Alive correct").Pack(), ip);
            }
            else
            {
                server.DebugInfo("Alive: Incorrect alive from " + aPacket.Username);
                server.DebugInfo(aPacket.Username + " now is disconnected.");

                if (server.ClientsOnChat.Any(d => d.Key == current.Client.Username))
                {
                    server.ClientsOnChat.Remove(current.Client.Username);
                }
                // Disconnect the client
                current.Disconnect();
                // Send error
                server.Udp.SendError(message, ip);
            }
        }
Exemple #3
0
        private static void AddEvent(Packets.AgendaEventPacket packet, Server server, IPEndPoint ip)
        {
            // Adding the event to database
            using (var db = new Models.ServerDatabase())
            {
                if (db.AgendaEvents.Any(c => c.Client.Username == packet.Username &&
                                        c.Date.Equals(packet.Date) &&
                                        c.EventInfo.Equals(packet.EventInfo) &&
                                        c.EventName.Equals(packet.EventName)))
                {
                    server.Udp.SendMessage(new Packets.AckErrorPacket(Packets.PacketTypes.Error, "New event already exists").Pack(), ip);
                    server.DebugInfo("NEw Agenda event: Event already exists.");
                    return;
                }

                db.AgendaEvents.InsertOnSubmit(new Models.AgendaEvent()
                {
                    Client    = db.Clients.Single(c => c.Username == packet.Username),
                    Date      = packet.Date,
                    EventInfo = packet.EventInfo,
                    EventName = packet.EventName
                });
                db.SubmitChanges();
            }

            server.DebugInfo("Event added correctly by " + packet.Username);
            // Send the ack
            server.Udp.SendMessage(new Packets.AckErrorPacket(Packets.PacketTypes.NewAgendaEventAck, "New event added").Pack(), ip);
        }
Exemple #4
0
        public static void Logout(byte[] data, IPEndPoint ip, Server server)
        {
            string message = "";

            BasicReqPacket logoutPacket = Packet.Unpack <BasicReqPacket>(data);

            server.DebugInfo("Logut request recieved.");
            server.DebugInfo("LogoutReq Packet: " + logoutPacket.ToString());

            ClientStatus current = server.GetClient(logoutPacket.Username);

            if (ClientsManagement.CheckBasics(current, ClientStatus.Status.Disconnected, logoutPacket.Alea, out message))
            {
                server.DebugInfo("Logout: Correct logut from " + logoutPacket.Username);
                server.DebugInfo(logoutPacket.Username + " now is disconnected.");
                if (server.ClientsOnChat.Any(d => d.Key == current.Client.Username))
                {
                    server.ClientsOnChat.Remove(current.Client.Username);
                }
                current.Disconnect();

                // Return ack
                server.Udp.SendMessage(new AckErrorPacket(PacketTypes.LogoutAck, "Logged out correctly.").Pack(), ip);
            }
            else
            {
                server.DebugInfo("Logout: Incorrect logut.");
                // Send error
                message = "Logout error: " + message;
                server.Udp.SendError(message, ip);
            }
        }
        public static void SendContactRequests(byte[] data, Server server, IPEndPoint ip)
        {
            string message = "";

            // Unpack the petition
            BasicReqPacket cPacket = Packet.Unpack <BasicReqPacket>(data);

            List <Models.ContactRequest> sent     = null;
            List <Models.ContactRequest> recieved = null;


            server.DebugInfo("Contact requests list requested by " + cPacket.Username);
            server.DebugInfo(cPacket.ToString());

            if (ClientsManagement.ContactRequestsList(cPacket,
                                                      server.GetClient(cPacket.Username),
                                                      ref sent,
                                                      ref recieved,
                                                      out message))
            {
                // List filled correctly
                server.Udp.SendMessage(new ContactReqListPacket(PacketTypes.ContactAck,
                                                                cPacket.Alea,
                                                                sent,
                                                                recieved).Pack(),
                                       ip);

                server.DebugInfo("Contact list requests sended correctly to + " + cPacket.Username);
            }
            else
            {
                server.DebugInfo("Contact requests list error: " + message);
                server.Udp.SendError(message, ip);
            }
        }
Exemple #6
0
        public static void DeleteAccount(byte[] data, IPEndPoint ip, Server server)
        {
            string message = "";

            BasicReqPacket delPacket = Packet.Unpack <BasicReqPacket>(data);

            server.DebugInfo("Delete account request recieved.");
            server.DebugInfo("DeleteAccountReq Packet: " + delPacket.ToString());

            ClientStatus current = server.GetClient(delPacket.Username);

            if (ClientsManagement.CheckBasics(current, ClientStatus.Status.Disconnected, delPacket.Alea, out message))
            {
                server.DebugInfo("Delete Account: Account was " + delPacket.Username + " correctly deleted.");

                // Send the ack first
                server.Udp.SendMessage(new AckErrorPacket(PacketTypes.DeleteAccountAck, "Account deleted correctly.").Pack(), ip);

                // Delete client from database
                server.DeleteCLientFromDataBase(delPacket.Username);
            }
            else
            {
                server.DebugInfo("Delete account: Acount can't be deleted.");
                // Send error
                message = "Delete error: " + message;
                server.Udp.SendError(message, ip);
            }
        }
Exemple #7
0
        public static void Register(byte[] data, IPEndPoint ip, Server server)
        {
            Models.Client current = null;   //< Who is doing the request
            string        message = "";

            // Unpack the packet in the correct format
            ProfilePacket regPacket = Packet.Unpack <ProfilePacket>(data);

            server.DebugInfo("Register request recieved.");
            server.DebugInfo("RegisterReq Packet: " + regPacket.ToString());
            // Send a package depending on registration success
            if (ClientsManagement.RegisterClient(regPacket, ip, ref current, out message))
            {
                // Send RegisterAck if all data is correct
                server.Udp.SendMessage(new AckErrorPacket(
                                           PacketTypes.RegisterAck,
                                           "Congratulations now you are registered.").Pack(),
                                       ip);

                server.DebugInfo(regPacket.FirstName + " " + regPacket.LastName + " has been registered as " + regPacket.Username);
                server.Clients.Add(new ClientStatus(current));
            }
            else
            {
                // Send the error
                server.DebugInfo("Register: " + regPacket.FirstName + " " + regPacket.LastName + " request not accepted");
                server.Udp.SendError(message, ip);
            }
        }
        public static void ClientsQuery(byte[] data, Server server, IPEndPoint ip)
        {
            string message = "";

            // Unpack the petition
            Packets.ClientQueryPacket cPacket = Packet.Unpack <ClientQueryPacket>(data);

            List <Models.Client> queryResult = null;

            server.DebugInfo("Client query  list requested by " + cPacket.Username);
            server.DebugInfo(cPacket.ToString());

            if (ClientsManagement.GetClientsQueryResult(cPacket, server.GetClient(cPacket.Username),
                                                        ref queryResult, cPacket.Query, out message))
            {
                // List filled correctly
                server.Udp.SendMessage(new ClientQueryPacket(PacketTypes.ClientsQueryAck,
                                                             cPacket.Alea,
                                                             queryResult).Pack(),
                                       ip);

                server.DebugInfo("Client list query requests sended correctly to + " + cPacket.Username);
            }
            else
            {
                server.DebugInfo("Client list query requests error: " + message);
                server.Udp.SendError(message, ip);
            }
        }
        public static void AnswerContactRequest(byte[] data, Server server, IPEndPoint ip, bool ack)
        {
            string message = "";

            // Unpack the petition
            ContactReqPacket cPacket = Packet.Unpack <ContactReqPacket>(data);

            ClientStatus current = server.GetClient(cPacket.To);

            if (ClientsManagement.AckOrRegContactReq(cPacket, current, ack, out message))
            {
                server.DebugInfo("Answer Contact request: " + (ack
                                                                ? "Request accepted correctly."
                                                                : "Request refused correctly."));

                if (ack)
                {
                    server.DebugInfo("New Contact added: " + cPacket.From + " - " + cPacket.To);
                }

                // Send the ack
                server.Udp.SendMessage(new AckErrorPacket(PacketTypes.ContactAck, "Answered correctly").Pack(), ip);
            }
            else
            {
                server.DebugInfo("Answer Contact request: Incorrect contact request.");
                // Send error
                server.Udp.SendError(message, ip);
            }
        }
Exemple #10
0
        public static void ReadyChatClient(byte[] data, TcpClient client, Server server)
        {
            string message = "";
            // Unpack the data
            BasicReqPacket packet = Packet.Unpack <BasicReqPacket>(data);

            // Get the client who is requesting
            ClientStatus c = server.GetClient(packet.Username);

            // Check the basics
            if (ClientsManagement.CheckBasics(c, ClientStatus.Status.Disconnected, packet.Alea, out message))
            {
                // Add client to dicctionary with his respective tcpclient
                server.ClientsOnChat.Add(c.Client.Username, client);

                server.DebugInfo("Client Ready for chat: " + c.Client.Username + " is ready for chatting.");

                // Send ack
                server.Tcp.SendMessage(new AckErrorPacket(PacketTypes.ReadyChatAck, "Now you are ready for chat").Pack(), client);
            }
            else
            {
                server.DebugInfo("Client Ready for chat error: " + message);
                server.Tcp.SendError(message, client);
            }
        }
Exemple #11
0
        public static void ProfileUpdate(byte[] data, IPEndPoint ip, Server server)
        {
            ProfilePacket pPacket = Packet.Unpack <ProfilePacket>(data);

            server.DebugInfo("Update profile recieved.");
            server.DebugInfo("Update profile Packet: " + pPacket.ToString());

            ClientStatus current = server.GetClient(pPacket.Username);

            if (ClientsManagement.UpdateProfile(pPacket, ref current, out string message))
            {
                // Profile updated
                server.DebugInfo("Update Profile: " + pPacket.Username + "'s profile updated.");

                // Return user profile with the ack
                server.Udp.SendMessage(new ProfilePacket(
                                           PacketTypes.ProfileUpdateAck,
                                           current.Alea,  // New alea generated
                                           current.Client.FirstName,
                                           current.Client.LastName,
                                           current.Client.Age,
                                           current.Client.PhoneNumber,
                                           current.Client.Gender,
                                           current.Client.Username,
                                           current.Client.Password,
                                           current.Client.Email,
                                           server.GetContacts(current),
                                           server.GetUnreadMessages(current),
                                           server.GetAgendaEvents(current.Client.Username),
                                           server.GetSocialNetworks(current.Client.Username)
                                           ).Pack(), ip);

                server.MarkReadMessages(current);
            }
            else
            {
                server.DebugInfo("Profile Update: Request not accepted");
                server.Udp.SendError(message, ip);
            }
        }
Exemple #12
0
        public static void DeleteLinkSocialNet(byte[] data, IPEndPoint ip, Server server)
        {
            try
            {
                Packets.LinkSocialNetworkPacket packet = Packets.Packet.Unpack <Packets.LinkSocialNetworkPacket>(data);

                server.DebugInfo("Social Network Link Delete Request: Request recieved");
                server.DebugInfo("Packet DeleteLinkSocialNetworkReq: " + packet.ToString());

                // Who is making the query
                ClientLogic.ClientStatus client = server.GetClient(packet.ClientUsername);

                // Check the basics of connection
                if (ClientLogic.ClientsManagement.CheckBasics(client, ClientLogic.ClientStatus.Status.Disconnected, packet.Alea, out string message))
                {
                    // Check if the link already exists
                    using (var db = new Models.ServerDatabase())
                    {
                        if (db.LinkedSocialNetworks
                            .Any(l => l.Client.Username.Equals(packet.ClientUsername) &&
                                 l.SocialNetwork.Name.Equals(packet.SocialNetName)))
                        {
                            // If exist delete
                            db.LinkedSocialNetworks.DeleteOnSubmit(
                                db.LinkedSocialNetworks
                                .Single(l => l.Client.Username.Equals(packet.ClientUsername) &&
                                        l.SocialNetwork.Name.Equals(packet.SocialNetName)));

                            server.DebugInfo("Delete Social Network Link: The link has been deleted.");

                            // Submit changes
                            db.SubmitChanges();

                            // Send the ack
                            server.Udp.SendMessage(new Packets.AckErrorPacket(Packets.PacketTypes.DeleteLinkSocialNetAck,
                                                                              "Social net deleted correctly.").Pack(), ip);
                            return;
                        }
                        else
                        {
                            server.DebugInfo("Delete Social Network Link: Social net doesn't exist, can't be deleted.");
                            // Send the ack
                            server.Udp.SendMessage(new Packets.AckErrorPacket(Packets.PacketTypes.Error,
                                                                              "Social net doesn't exist.").Pack(), ip);
                        }
                    }
                }
                else
                {
                    server.DebugInfo("Delete Social Network Link: " + message);
                    server.Udp.SendError(message, ip);
                }
            }
            catch (SqlException)
            {
                server.DebugInfo("Delete Social Network Link: Database error.");
                server.Udp.SendError("Database error. Probably no social net found on database.", ip);
                return;
            }
        }
        public static void NewContactRequest(byte[] data, Server server, IPEndPoint ip)
        {
            string message = "";

            // Unpack the petition
            ContactReqPacket cPacket = Packet.Unpack <ContactReqPacket>(data);

            ClientStatus current = server.GetClient(cPacket.From);

            if (ClientsManagement.NewContactRequest(cPacket, current, out message))
            {
                server.DebugInfo(cPacket.From + " made a contact request to " + cPacket.To);

                // Send the ack
                server.Udp.SendMessage(new AckErrorPacket(PacketTypes.ContactAck, "New contact request added to database").Pack(), ip);
            }
            else
            {
                server.DebugInfo("New Contact Request: Incorrect contact request.");
                // Send error
                server.Udp.SendError(message, ip);
            }
        }
Exemple #14
0
        public static void AgendaEvent(byte[] data, Server server, bool delete, IPEndPoint ip)
        {
            Console.WriteLine(Encoding.ASCII.GetString(data));
            try
            {
                string message = "";
                // Unpack the data
                Packets.AgendaEventPacket packet = Packets.Packet.Unpack <Packets.AgendaEventPacket>(data);
                server.DebugInfo("Agenda Event Req: " + packet.ToString());

                // Get the client who is making the request
                ClientLogic.ClientStatus current = server.GetClient(packet.Username);

                // Check the basics
                if (ClientLogic.ClientsManagement.CheckBasics(current, ClientLogic.ClientStatus.Status.Disconnected, packet.Alea, out message))
                {
                    if (!delete)
                    {
                        AddEvent(packet, server, ip);
                    }
                    else
                    {
                        DeleteEvent(packet, server, ip);
                    }
                }
                else
                {
                    server.DebugInfo("Adding agenda event error: " + message);
                    server.Udp.SendError(message, ip);
                }
            }
            catch (SqlException)
            {
                server.DebugInfo("Add new agenda event database error");
                server.Udp.SendError("Unexpected database error", ip);
            }
        }
Exemple #15
0
        public static void Login(byte[] data, IPEndPoint ip, Server server)
        {
            Models.Client current = null;   //< Who is doing the request

            // Unpack
            LoginReqPacket logPacket = Packet.Unpack <LoginReqPacket>(data);

            server.DebugInfo("Login request recieved.");
            server.DebugInfo("LoginReq Packet: " + logPacket.ToString());


            if (ClientsManagement.LoginClient(logPacket, ref current, out string message))
            {
                if (server.GetClient(current.Username).Stat == ClientStatus.Status.Logged)
                {
                    server.DebugInfo("Login: User is already logged");
                    message = "USer is already logged";
                    server.Udp.SendError(message, ip);
                    return;
                }

                // Client login
                server.DebugInfo("Client " + current.ToString() + " is now logged in.");
                string alea = Server.GenerateAlea();
                server.SetStatus(logPacket.Username, ClientStatus.Status.Logged, alea, DateTime.Now);

                // Send the profile info of the database to client
                server.DebugInfo("Sending profile info to " + logPacket.Username + ".");

                // Return user profile with the ack
                server.Udp.SendMessage(new ProfilePacket(
                                           PacketTypes.LoginAck,
                                           alea,  // New alea generated
                                           current.FirstName,
                                           current.LastName,
                                           current.Age,
                                           current.PhoneNumber,
                                           current.Gender,
                                           current.Username,
                                           current.Password,
                                           current.Email,
                                           server.GetContacts(server.GetClient(current.Username)),
                                           server.GetUnreadMessages(server.GetClient(current.Username)),
                                           server.GetAgendaEvents(current.Username),
                                           server.GetSocialNetworks(current.Username)
                                           ).Pack(), ip);

                // Mark messages as read
                server.MarkReadMessages(server.GetClient(current.Username));
            }
            else
            {
                server.DebugInfo("Login: Request not accepted");
                server.Udp.SendError(message, ip);
            }
        }
 public static void CheckAlives(Server server)
 {
     foreach (ClientStatus cs in server.Clients.Where(c => c.Stat != ClientStatus.Status.Disconnected))
     {
         TimeSpan since = DateTime.Now - cs.LastAlive;
         if (since.Seconds > 12)
         {
             if (server.ClientsOnChat.Any(d => d.Key == cs.Client.Username))
             {
                 server.ClientsOnChat.Remove(cs.Client.Username);
             }
             cs.Disconnect();
             server.DebugInfo(cs.Client.Username + " now is disconnected because he is inactive.");
         }
     }
 }
Exemple #17
0
        public static void SendMessage(byte[] data, TcpClient client, Server server)
        {
            try
            {
                string message = "";

                // Unpack the data
                MessagePacket packet = Packet.Unpack <MessagePacket>(data);

                server.DebugInfo("SendMessageReq Recieved: " + packet.ToString());

                // Who is making the query
                ClientStatus c = server.GetClient(packet.From.Username);

                // Check te basics again and again
                if (ClientsManagement.CheckBasics(c, ClientStatus.Status.Disconnected, packet.Alea, out message))
                {
                    // Check if destination exists
                    if (!server.Clients.Any(d => d.Client.Username == packet.To.Username))
                    {
                        server.DebugInfo("Send Message Error: " + "Destination doesn't exist");
                        server.Tcp.SendError("Destination doesn't exist", client);
                        return;
                    }

                    // Store the message on database
                    using (var db = new Models.ServerDatabase())
                    {
                        // Create the message
                        Models.Message m = new Models.Message()
                        {
                            From    = db.Clients.Single(n => n.Username == c.Client.Username),
                            To      = db.Clients.Single(n => n.Username == packet.To.Username),
                            Date    = packet.Date,
                            Content = packet.Content
                        };

                        // Check if destination is on chat
                        if (server.ClientsOnChat.Any(d => d.Key.Equals(packet.To.Username)))
                        {
                            // If exist save the message and send him as well as readed message
                            m.Read = true;
                            server.DebugInfo("Message from : " + packet.From.Username + " sended to: " + packet.To.Username);
                            // Send the message to destination changing the type of package
                            packet.Type = (byte)PacketTypes.SendMessageAck;
                            server.Tcp.SendMessage(packet.Pack(), server.ClientsOnChat[packet.To.Username]);
                        }
                        else
                        {
                            m.Read = false;
                        }


                        db.Messages.InsertOnSubmit(m);
                        db.SubmitChanges();
                    }
                }
                else
                {
                    server.DebugInfo("Send Message Error: " + message);
                    server.Tcp.SendError(message, client);
                }
            }
            catch (SqlException)
            {
                server.DebugInfo("Send Message Error: database error.");
                server.Tcp.SendError("Database error", client);
            }
        }
Exemple #18
0
        public static void LinkSocialNet(byte[] data, IPEndPoint ip, Server server)
        {
            try {
                Packets.LinkSocialNetworkPacket packet = Packets.Packet.Unpack <Packets.LinkSocialNetworkPacket>(data);

                server.DebugInfo("Social Network Link: Request recieved");
                server.DebugInfo("Packet LinkSocialNetworkReq: " + packet.ToString());

                // Who is making the query
                ClientLogic.ClientStatus client = server.GetClient(packet.ClientUsername);

                // Check the basics of connection
                if (ClientLogic.ClientsManagement.CheckBasics(client, ClientLogic.ClientStatus.Status.Disconnected, packet.Alea, out string message))
                {
                    // Check if the link already exists
                    using (var db = new Models.ServerDatabase())
                    {
                        if (db.LinkedSocialNetworks
                            .Any(l => l.Client.Username.Equals(packet.ClientUsername) &&
                                 l.SocialNetwork.Name.Equals(packet.SocialNetName)))
                        {
                            // Link exists on database -> Override it
                            var sn = db.LinkedSocialNetworks.Single(l => l.Client.Username.Equals(packet.ClientUsername) &&
                                                                    l.SocialNetwork.Name.Equals(packet.SocialNetName));

                            sn.Username = packet.SocialNetUsername;
                            sn.Password = packet.SocialNetPassword;

                            server.DebugInfo("Social Network Link: The link already exists, overriding it.");
                            return;
                        }
                        else
                        {
                            server.DebugInfo("Social Network Link: Social net linked correctly.");
                            db.LinkedSocialNetworks.InsertOnSubmit(new Models.LinkedSocialNetwork()
                            {
                                Client        = db.Clients.Single(c => c.Username.Equals(packet.ClientUsername)),
                                SocialNetwork = db.SocialNetworks.Single(c => c.Name.Equals(packet.SocialNetName)),
                                Username      = packet.SocialNetUsername,
                                Password      = packet.SocialNetPassword
                            });
                        }

                        // Submit changes
                        db.SubmitChanges();

                        // Send the ack
                        server.Udp.SendMessage(new Packets.AckErrorPacket(Packets.PacketTypes.LinkSocialNetworkAck,
                                                                          "Social net linked correctly.").Pack(), ip);
                    }
                }
                else
                {
                    server.DebugInfo("Social Network Link: " + message);
                    server.Udp.SendError(message, ip);
                }
            }
            catch (SqlException e)
            {
                server.DebugInfo("Social Network Link: Database error.");
                server.Udp.SendError("Database error. Probably no social net found on database.", ip);
                return;
            }
        }