Exemple #1
0
        public void Handle(Player player, Request request)
        {
            int friendsAccepted = request.ReadInt();
            var messenger       = player.Messenger;

            for (int i = 0; i < friendsAccepted; i++)
            {
                int userId = request.ReadInt();

                if (!messenger.HasRequest(userId))
                {
                    continue;
                }

                if (messenger.Friends.Count >= messenger.MaxFriendsAllowed)
                {
                    continue;
                }

                var playerData = PlayerManager.Instance.GetDataById(userId);

                if (playerData == null)
                {
                    continue;
                }

                var targetMessenger = Messenger.GetMessengerData(userId);
                var targetFriend    = new MessengerUser(playerData);

                targetMessenger.Friends.Add(messenger.MessengerUser);
                messenger.Friends.Add(targetFriend);

                targetMessenger.RemoveRequest(player.Details.Id);
                messenger.RemoveRequest(userId);

                var targetPlayer = PlayerManager.Instance.GetPlayerById(userId);

                if (targetPlayer != null)
                {
                    targetPlayer.Messenger.QueueUpdate(MessengerUpdateType.AddFriend, messenger.MessengerUser);
                    targetPlayer.Messenger.ForceUpdate();
                }

                MessengerDao.DeleteRequests(player.Details.Id, userId);
                MessengerDao.SaveFriend(new MessengerFriendData
                {
                    FriendId = userId,
                    UserId   = player.Details.Id
                });
                MessengerDao.SaveFriend(new MessengerFriendData
                {
                    UserId   = userId,
                    FriendId = player.Details.Id
                });

                messenger.QueueUpdate(MessengerUpdateType.AddFriend, targetFriend);
            }

            messenger.ForceUpdate();
        }
        public void Handle(Player player, Request request)
        {
            bool mode   = request.ReadBoolean();
            int  amount = request.ReadInt();

            if (!mode)
            {
                for (int i = 0; i < amount; i++)
                {
                    int userId = request.ReadInt();

                    if (!player.Messenger.HasRequest(userId))
                    {
                        continue;
                    }

                    MessengerDao.DeleteRequests(player.Details.Id, userId);
                    player.Messenger.RemoveRequest(userId);
                }
            }
            else
            {
                player.Messenger.Requests.Clear();
                MessengerDao.DeleteAllRequests(player.Details.Id);
            }
        }
Exemple #3
0
 /// <summary>
 /// Load messenger data by given useer id
 /// </summary>
 private void LoadMessengerData(int userId)
 {
     Friends    = MessengerDao.GetFriends(userId).Select(data => Wrap(data.FriendData)).ToList();
     Requests   = MessengerDao.GetRequests(userId).Select(data => Wrap(data.FriendData)).ToList();
     Categories = MessengerDao.GetCategories(userId);
     Queue      = new ConcurrentQueue <MessengerUpdate>();
 }
        public void Handle(Player player, Request request)
        {
            List <PlayerData> resultSet = MessengerDao.SearchMessenger(request.ReadString().FilterInput(), player.Details.Id);

            var friends = resultSet.Where(data => player.Messenger.HasFriend(data.Id))
                          .Select(data => new MessengerUser(data)).ToList();

            var users = resultSet.Where(data => !player.Messenger.HasFriend(data.Id))
                        .Select(data => new MessengerUser(data)).ToList();

            player.Send(new SearchMessengerComposer(friends, users));
        }
        public void Handle(Player player, Request request)
        {
            int friendsToDelete = request.ReadInt();
            var messenger       = player.Messenger;

            for (int i = 0; i < friendsToDelete; i++)
            {
                int userId = request.ReadInt();

                if (!messenger.HasFriend(userId))
                {
                    continue;
                }

                if (messenger.Friends.Count >= messenger.MaxFriendsAllowed)
                {
                    continue;
                }

                var playerData = PlayerManager.Instance.GetDataById(userId);

                if (playerData == null)
                {
                    continue;
                }

                var targetMessenger = Messenger.GetMessengerData(userId);

                targetMessenger.RemoveFriend(player.Details.Id);
                messenger.RemoveFriend(userId);

                var targetPlayer = PlayerManager.Instance.GetPlayerById(userId);

                if (targetPlayer != null)
                {
                    targetPlayer.Messenger.QueueUpdate(MessengerUpdateType.RemoveFriend, messenger.MessengerUser);
                    targetPlayer.Messenger.ForceUpdate();
                }

                MessengerDao.DeleteRequests(player.Details.Id, userId);
                MessengerDao.DeleteFriends(player.Details.Id, userId);

                messenger.QueueUpdate(MessengerUpdateType.RemoveFriend, Messenger.Wrap(playerData));
            }

            messenger.ForceUpdate();
        }
        public void Handle(Player player, Request request)
        {
            int userId = UserDao.GetIdByName(request.ReadString());

            if (userId < 1)
            {
                return;
            }

            var targetMessenger = Messenger.GetMessengerData(userId);
            var targetPlayer    = PlayerManager.Instance.GetPlayerById(userId);

            if (targetMessenger == null ||
                targetMessenger.HasFriend(player.Details.Id) ||
                targetMessenger.HasRequest(player.Details.Id))
            {
                return;
            }

            if (!targetMessenger.FriendRequestsEnabled)
            {
                player.Send(new MessengerRequestErrorComposer(MessengerRequestError.FriendRequestsDisabled));
                return;
            }

            if (player.Messenger.Friends.Count >= player.Messenger.MaxFriendsAllowed)
            {
                player.Send(new MessengerRequestErrorComposer(MessengerRequestError.FriendListFull));
                return;
            }

            var messengerRequest = new MessengerRequestData
            {
                FriendId = player.Details.Id,
                UserId   = userId
            };

            MessengerDao.SaveRequest(messengerRequest);

            targetMessenger.Requests.Add(player.Messenger.MessengerUser);

            if (targetPlayer != null)
            {
                targetPlayer.Send(new MessengerRequestComposer(player.Details));
            }
        }
Exemple #7
0
        public void Handle(Player player, Request request)
        {
            int userId = request.ReadInt();

            try
            {
                if (!player.Messenger.HasFriend(userId))
                {
                    player.Send(new InstantChatErrorComposer(InstantChatError.NotFriend, userId));
                    return;
                }

                var friend      = player.Messenger.GetFriend(userId);
                var chatMessage = request.ReadString().FilterInput(false);

                var chatMessageData = new MessengerChatData
                {
                    UserId   = player.Details.Id,
                    FriendId = userId,
                    Message  = chatMessage,
                    IsRead   = friend.IsOnline
                };

                MessengerDao.SaveMessage(chatMessageData);

                if (!friend.IsOnline)
                {
                    player.Send(new InstantChatErrorComposer(InstantChatError.FriendOffline, userId));
                    return;
                }

                friend.Player.Send(new InstantChatComposer(player.Details.Id, chatMessage));
            }
            catch
            {
                player.Send(new InstantChatErrorComposer(InstantChatError.SendingFailed, userId));
            }
        }
        public void Handle(Player player, Request request)
        {
            player.Send(new InitMessengerComposer(
                            ValueManager.Instance.GetInt("max.friends.normal"),
                            ValueManager.Instance.GetInt("max.friends.hc"),
                            ValueManager.Instance.GetInt("max.friends.vip"),
                            player.Messenger.Categories,
                            player.Messenger.Friends
                            ));

            player.Send(new MessengerRequestsComposer(player.Messenger.Requests));

            var unreadMessages = MessengerDao.GetUneadMessages(player.Details.Id);

            if (unreadMessages.Count > 0)
            {
                foreach (var unreadMessage in unreadMessages)
                {
                    player.Send(new InstantChatComposer(unreadMessage.UserId, unreadMessage.Message));
                }

                MessengerDao.SetReadMessages(player.Details.Id);
            }
        }
 internal MessengerRepository(MessengerDao messengerDao)
 {
     _messengerDao = messengerDao;
 }
Exemple #10
0
 public Messenger(int userId)
 {
     subscription          = SubscriptionDao.GetSubscription(userId);
     FriendRequestsEnabled = MessengerDao.GetAcceptsFriendRequests(userId);
     LoadMessengerData(userId);
 }