public List <AnalysisFriendData> CheckForAnyInDataBase(AccountViewModel account, List <AnalysisFriendData> friends, INotices notices, string functionName)
        {
            var friendsInDb         = new GetAllFriendByQueryHandler(new DataBaseContext()).Handle(new GetAllFriendByQuery());
            var analisysFriendsInDb = new GetAnalisysFriendsByStatusQueryHandler(new DataBaseContext()).Handle(new GetAnalisysFriendsByStatusQuery
            {
                Status = StatusesFriend.ToAdd
            });

            var refreshFriendList = new List <AnalysisFriendData>();

            notices.AddNotice(functionName, account.Id, string.Format("Друзей для проверки - {0}", friends.Count));

            foreach (var analysisFriendData in friends)
            {
                var includeInFriends        = friendsInDb.Any(data => data.FacebookId == analysisFriendData.FacebookId);
                var includeInAnalyseFriends = analisysFriendsInDb.Any(data => data.FacebookId == analysisFriendData.FacebookId);

                if (!includeInFriends)// && !includeInAnalyseFriends)
                {
                    refreshFriendList.Add(analysisFriendData);
                    continue;
                }
                if (analysisFriendData.Type == FriendTypes.Incoming)
                {
                    notices.AddNotice(functionName, account.Id, string.Format("С ним мы общались. Отменяем заявку- {0}({1})", analysisFriendData.FriendName, analysisFriendData.FacebookId));

                    new CancelFriendshipRequestEngine().Execute(new CancelFriendshipRequestModel
                    {
                        Cookie            = account.Cookie,
                        Proxy             = _accountManager.GetAccountProxy(account),
                        FriendFacebookId  = analysisFriendData.FacebookId,
                        AccountFacebookId = account.FacebookId,
                        UrlParameters     = new GetUrlParametersQueryHandler(new DataBaseContext()).Handle(new GetUrlParametersQuery
                        {
                            NameUrlParameter = NamesUrlParameter.CancelRequestFriendship
                        })
                    });
                }
            }

            return(refreshFriendList);
        }
Example #2
0
        public bool GetCurrentFriends(AccountViewModel accountViewModel)
        {
            const string functionName = "Обновление текущего списка друзей";

            var account = _accountManager.GetAccountById(accountViewModel.Id);

            try
            {
                _notice.AddNotice(functionName, account.Id, "Начинаем обновлять список друзей");

                var userAgent = new GetUserAgentQueryHandler(new DataBaseContext()).Handle(new GetUserAgentQuery
                {
                    UserAgentId = account.UserAgentId
                });

                var groupId = account.GroupSettingsId;

                if (groupId == null)
                {
                    _notice.AddNotice(functionName, account.Id, "Ошибка! Группа не выбрана.");
                    return(false);
                }

                var settings           = _accountSettingsManager.GetSettings((long)groupId);
                var accountInformation = _accountManager.GetAccountInformation((long)groupId);

                var friends = new GetCurrentFriendsBySeleniumEngine().Execute(new GetCurrentFriendsBySeleniumModel
                {
                    Cookie            = account.Cookie,
                    AccountFacebookId = account.FacebookId,
                    Driver            = _seleniumManager.RegisterNewDriver(new AccountViewModel
                    {
                        Proxy         = account.Proxy,
                        ProxyLogin    = account.ProxyLogin,
                        ProxyPassword = account.ProxyPassword,
                        UserAgentId   = userAgent.Id
                    }),
                    Proxy     = _accountManager.GetAccountProxy(account),
                    UserAgent = userAgent.UserAgentString
                });

                _notice.AddNotice(functionName, account.Id, "Список текущих друзей получен, количество - " + friends.Count);

                _notice.AddNotice(functionName, account.Id, string.Format("Учитываем погрешность {0}%", settings.AllowedRemovalPercentage));

                var notError = _friendManager.RecountError(accountInformation.CountCurrentFriends, friends.Count, settings.AllowedRemovalPercentage);

                if (!notError)
                {
                    _notice.AddNotice(functionName, account.Id, string.Format("Ошибка получения друзей. Получено - {0}, текущее колиство в базе - {1}, погрешность - {2}%", friends.Count, accountInformation.CountCurrentFriends, settings.AllowedRemovalPercentage));

                    return(false);
                }

                var outgoingFriendships =
                    new GetFriendsByAccountIdQueryHandler(new DataBaseContext()).Handle(new GetFriendsByAccountIdQuery
                {
                    AccountId   = account.Id,
                    FriendsType = FriendTypes.Outgoig
                });


                if (friends.Count == 0)
                {
                    _notice.AddNotice(functionName, account.Id, "Нет друзей. Обновление друзей завершено.");

                    return(true);
                }

                _notice.AddNotice(functionName, account.Id, "Сверяем друзей с исходящими заявками");
                foreach (var newFriend in friends)
                {
                    if (outgoingFriendships.All(data => data.FacebookId != newFriend.FacebookId))
                    {
                        continue;
                    }

                    _notice.AddNotice(functionName, account.Id, newFriend.FriendName + "добавился в друзья ");

                    new DeleteAnalysisFriendByIdHandler(new DataBaseContext()).Handle(new DeleteAnalysisFriendById
                    {
                        AnalysisFriendFacebookId = newFriend.FacebookId
                    });

                    new AddOrUpdateAccountStatisticsCommandHandler(new DataBaseContext()).Handle(
                        new AddOrUpdateAccountStatisticsCommand
                    {
                        AccountId = account.Id,
                        CountOrdersConfirmedFriends = 1
                    });

                    _notice.AddNotice(functionName, account.Id, "Сверяем друзей с исходящими заявками");
                }

                // drop blocked users
                _notice.AddNotice(functionName, account.Id, "Сверяем друзей с черным списком");

                var newFriendList = (from friend in friends
                                     let isBlocked =
                                         new CheckForFriendBlacklistedQueryHandler().Handle(new CheckForFriendBlacklistedQuery
                {
                    FriendFacebookId = friend.FacebookId,
                    GroupSettingsId = (long)groupId
                })
                                         where !isBlocked
                                         select new FriendData
                {
                    FacebookId = friend.FacebookId,
                    FriendName = friend.FriendName,
                    Href = friend.Uri,
                    Gender = friend.Gender
                }).ToList();

                _notice.AddNotice(functionName, account.Id, "Совпадений с черным списком - " + (friends.Count - newFriendList.Count));

                _notice.AddNotice(functionName, account.Id, "Сохраняем друзей");

                new SaveUserFriendsCommandHandler(new DataBaseContext()).Handle(new SaveUserFriendsCommand
                {
                    AccountId = account.Id,
                    Friends   = newFriendList
                });

                new AddAccountInformationCommandHandler(new DataBaseContext()).Handle(new AddAccountInformationCommand
                {
                    AccountId = account.Id,
                    AccountInformationData = new AccountInformationDataDbModel
                    {
                        CountCurrentFriends = friends.Count
                    }
                });

                _notice.AddNotice(functionName, account.Id, "Обновление друзей завершено.");
            }
            catch (Exception ex)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("Ошибка - {0}", ex.Message));
            }
            return(true);
        }
        public void SendMessageToUnread(AccountViewModel accountViewModel)
        {
            const string functionName = "Ответ на непрочитанные сообщения";

            _notice.AddNotice(functionName, accountViewModel.Id, string.Format("Начинаем отвечать"));

            var account = _accountManager.GetAccountById(accountViewModel.Id);

            try
            {
                var unreadMessagesList = GetUnreadMessages(account);

                _notice.AddNotice(functionName, accountViewModel.Id, string.Format("Получено {0} непрочитанных сообщений", unreadMessagesList.UnreadMessages.Count));

                ChangeMessageStatus(unreadMessagesList, account);

                var i = 1;

                foreach (var unreadMessage in unreadMessagesList.UnreadMessages)
                {
                    _notice.AddNotice(functionName, accountViewModel.Id, string.Format("Отвечаем на непрочитанные сообщения друзьям {0}/{1}", i, unreadMessagesList.UnreadMessages.Count));

                    var friend = _friendManager.GetFriendByFacebookId(unreadMessage.FriendFacebookId);

                    new SendMessageCore(_notice).SendMessageToUnread(account, friend);

                    Thread.Sleep(3000);
                    i++;
                }
                _notice.AddNotice(functionName, accountViewModel.Id, string.Format("Успешно завершено"));
            }
            catch (Exception ex)
            {
                _notice.AddNotice(functionName, accountViewModel.Id, string.Format("Возникла ошибка {0}", ex.Message));
            }
        }
        public void SendMessageToUnread(AccountViewModel accountViewModel)
        {
            const string functionName = "Ответ на непрочитанные сообщения";

            _notice.AddNotice(functionName, accountViewModel.Id, string.Format("Начинаем отвечать"));

            try
            {
                var account = _accountManager.GetAccountById(accountViewModel.Id);
                if (account.GroupSettingsId == null)
                {
                    _notice.AddNotice(functionName, account.Id, "Ошибка! Не указана группа настроек.");
                    return;
                }

                var settings = _accountSettingsManager.GetSettings((long)account.GroupSettingsId);

                var unreadMessagesList = GetUnreadMessages(account);
                _notice.AddNotice(functionName, accountViewModel.Id, string.Format("Получено {0} непрочитанных сообщений", unreadMessagesList.UnreadMessages.Count));
                SendMessages(unreadMessagesList.UnreadMessages, account, functionName);

                if (settings.GetMessagesFromThoseConnectedToMessenger)
                {
                    var newMessangerMessagesList = GetMessangerMessages(account);
                    _notice.AddNotice(functionName, accountViewModel.Id, string.Format("Получено {0} сообщений о добавлении пользователя в мессенджер", newMessangerMessagesList.UnreadMessages.Count));
                    SendMessages(newMessangerMessagesList.UnreadMessages, account, functionName);
                }

                _notice.AddNotice(functionName, accountViewModel.Id, string.Format("Успешно завершено"));
            }
            catch (Exception ex)
            {
                _notice.AddNotice(functionName, accountViewModel.Id, string.Format("Возникла ошибка {0}", ex.Message));
            }
        }
Example #5
0
        public void InviteToGroup(AccountViewModel account)
        {
            const string functionName = "Пригласить в группу";

            _notice.AddNotice(functionName, account.Id, "Отправляем приглашения в группы...");

            if (account.GroupSettingsId == null)
            {
                return;
            }

            var settings   = _accountSettingsManager.GetSettings((long)account.GroupSettingsId);
            var statistics =
                new GetCommunityStatisticsQueryHandler(new DataBaseContext()).Handle(new GetCommunityStatisticsQuery
            {
                GroupId = (long)account.GroupSettingsId
            });

            var limitMinJoinGroupLastDay  = settings.MinFriendsJoinGroupInDay;
            var limitMaxJoinGroupLastDay  = settings.MaxFriendsJoinGroupInDay;
            var limitMinJoinGroupLastHour = settings.MinFriendsJoinGroupInHour;
            var limitMaxJoinGroupLastHour = settings.MaxFriendsJoinGroupInHour;

            var countJoinGroupLastDay  = statistics.Sum(data => data.CountOfGroupInvitations);
            var countJoinGroupLastHour =
                statistics.Where(
                    model =>
                    (DateTime.Now - model.UpdateDateTime).Hours * 60 + (DateTime.Now - model.UpdateDateTime).Minutes <
                    60).Sum(data => data.CountOfGroupInvitations);

            if (countJoinGroupLastDay >= limitMaxJoinGroupLastDay)
            {
                _notice.AddNotice(functionName, account.Id, "Достигнут лимит максимального количества добавлений в группу в день!");
                return;
            }

            if (countJoinGroupLastHour >= limitMaxJoinGroupLastHour)
            {
                _notice.AddNotice(functionName, account.Id, "Достигнут лимит максимального количества добавлений в группу в час!");
                return;
            }

            var allowedToInviteHour = limitMaxJoinGroupLastHour - countJoinGroupLastHour;
            var allowedToInviteDay  = limitMaxJoinGroupLastDay - countJoinGroupLastDay;


            var friends =
                new GetFriendsForAddedToGroupQueryHandler(new DataBaseContext()).Handle(new GetFriendsForAddedToGroupQuery
            {
                AccountId = account.Id,
                Count     =
                    (int)
                    (allowedToInviteDay < allowedToInviteHour ? allowedToInviteDay : limitMaxJoinGroupLastHour)
            });

            if (friends.Count < limitMinJoinGroupLastHour)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("Недостаточно людей для добавления! Получено {0} людей для добавления! Мин. кол-во - {1}", friends.Count, limitMinJoinGroupLastHour));
                return;
            }

            var groups = ConvertStringToList(settings.FacebookGroups);

            _notice.AddNotice(functionName, account.Id, string.Format("Начинаем добавлять {0} друзей в группы", friends.Count));

            if (friends.Count > 50)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("Друзей оказалось больше, берем 50 из них."));
                friends = new List <FriendData>(friends.Take(50));
            }

            var userAgent = new GetUserAgentQueryHandler(new DataBaseContext()).Handle(new GetUserAgentQuery
            {
                UserAgentId = account.UserAgentId
            });

            foreach (var @group in groups)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("Добавляем {0} друзей в группу - {1}", friends.Count, @group));

                new AddToGroupEngine().Execute(new AddToGroupModel
                {
                    Cookie           = account.Cookie,
                    FacebookId       = account.FacebookId,
                    Proxy            = _accountManager.GetAccountProxy(account),
                    FacebookGroupUrl = @group,
                    FriendsList      = friends.Select(data => new FriendModel
                    {
                        FacebookId = data.FacebookId,
                        FriendName = data.FriendName
                    }).ToList(),
                    UrlParameters =
                        new GetUrlParametersQueryHandler(new DataBaseContext()).Handle(new GetUrlParametersQuery
                    {
                        NameUrlParameter = NamesUrlParameter.AddFriendsToGroup
                    }),
                    UserAgent = userAgent.UserAgentString
                });
            }

            foreach (var friend in friends)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("Отмечаем друзей как добавленные в группы"));
                new MarkAddToGroupFriendCommandHandler(new DataBaseContext()).Handle(new MarkAddToGroupFriendCommand
                {
                    AccountId = account.Id,
                    FriendId  = friend.Id
                });
            }

            _notice.AddNotice(functionName, account.Id, string.Format("Добавлено {0} друзей в группы", friends.Count));
            new AddCommunityStatisticsCommandHandler(new DataBaseContext()).Handle(new AddCommunityStatisticsCommand
            {
                AccountId = account.Id,
                GroupId   = (long)account.GroupSettingsId,
                CountOfGroupInvitations = friends.Count
            });
        }
Example #6
0
        public void SendMessageToUnread(AccountViewModel account, FriendData friend)
        {
            const string functionName = "Ответ на непрочитанные сообщения";

            if (friend.Deleted || friend.DialogIsCompleted)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("Ошибка! Друг {0}({1}) удален, либо переписка с ним закончилась.", friend.FriendName, friend.FacebookId));
                return;
            }

            if (account.GroupSettingsId == null)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("Ошибка! Не указана группа настроек."));
                return;
            }

            var friendIsBlocked = _friendsBlackListManager.CheckForFriendBlacklist(friend.FacebookId, (long)account.GroupSettingsId);

            if (friendIsBlocked)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("Ошибка! Друг {0}({1}) находится в черном списке.", friend.FriendName, friend.FacebookId));
                return;
            }

            var message = String.Empty;

            var messageData = friend.MessageRegime == MessageRegime.BotFirstMessage
            ? _messageManager.GetAllMessagesWhereBotWritesFirst(account.Id)
            : _messageManager.GetAllMessagesWhereUserWritesFirst(account.Id);

            _notice.AddNotice(functionName, account.Id, string.Format("Загружаем сообщения для ответа"));

            if (messageData.Count == 0)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("У данного пользователя нет сообщений для ответа"));
                return;
            }

            var numberLastBotMessage = _messageManager.GetLasBotMessageOrderNumber(messageData, account.Id);

            //

            var lastFriendMessages = _facebookMessageManager.GetLastFriendMessageModel(account.Id, friend.Id);

            if (lastFriendMessages == null)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("Возникла ошибка при ответе. Сообщение друга не найдено в базе."));
                return;
            }

            var lastBotMessage = _facebookMessageManager.GetLastBotMessageModel(account.Id, friend.Id);

            int orderNumber;

            if (lastBotMessage != null && lastFriendMessages.OrderNumber == lastBotMessage.OrderNumber && lastFriendMessages.MessageDateTime > lastBotMessage.MessageDateTime)
            {
                orderNumber = lastFriendMessages.OrderNumber + 1;
            }
            else
            {
                orderNumber = lastFriendMessages.OrderNumber;
            }

            if (orderNumber == 1 && friend.MessageRegime == null)
            {
                new ChangeMessageRegimeCommandHandler(new DataBaseContext()).Handle(new ChangeMessageRegimeCommand
                {
                    AccountId     = account.Id,
                    FriendId      = friend.Id,
                    MessageRegime = MessageRegime.UserFirstMessage
                });

                friend.MessageRegime = MessageRegime.UserFirstMessage;
            }

            _notice.AddNotice(functionName, account.Id, string.Format("Сверяем сообщение друга со стоп-словами"));

            var emergencyFactor = _stopWordsManager.CheckMessageOnEmergencyFaktor(lastFriendMessages);

            _notice.AddNotice(functionName, account.Id, string.Format("Получаем сообщение для ответа с порядковым номером - {0}. (Стоп-фактор - {1})", orderNumber, emergencyFactor));

            var messageModel = _messageManager.GetRandomMessage(account.Id, orderNumber, emergencyFactor, friend.MessageRegime);

            if (messageModel != null)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("Подставляем значения в сообщение бота"));

                message = new CalculateMessageTextQueryHandler(new DataBaseContext()).Handle(new CalculateMessageTextQuery
                {
                    TextPattern = messageModel.Message,
                    AccountId   = account.Id,
                    FriendId    = lastFriendMessages.FriendId,
                });
            }
            var userAgent = new GetUserAgentQueryHandler(new DataBaseContext()).Handle(new GetUserAgentQuery
            {
                UserAgentId = account.UserAgentId
            });

            if (message != String.Empty)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("Отправляем сообщение"));

                new SendMessageEngine().Execute(new SendMessageModel
                {
                    AccountId     = account.FacebookId,
                    Cookie        = account.Cookie,
                    FriendId      = friend.FacebookId,
                    Message       = message,
                    Proxy         = _accountManager.GetAccountProxy(account),
                    UrlParameters =
                        new GetUrlParametersQueryHandler(new DataBaseContext()).Handle(new GetUrlParametersQuery
                    {
                        NameUrlParameter = NamesUrlParameter.SendMessage
                    }),
                    UserAgent = userAgent.UserAgentString
                });

                new SaveSentMessageCommandHandler(new DataBaseContext()).Handle(new SaveSentMessageCommand()
                {
                    AccountId       = account.Id,
                    FriendId        = friend.FacebookId,
                    OrderNumber     = orderNumber,
                    Message         = message,
                    MessageDateTime = DateTime.Now,
                });

                _notice.AddNotice(functionName, account.Id, string.Format("Сообщение пользователю {0}({1}) отправлено", friend.FriendName, friend.FacebookId));
            }

            if (messageData == null || orderNumber < numberLastBotMessage)
            {
                return;
            }

            if (account.GroupSettingsId == null)
            {
                return;
            }

            _notice.AddNotice(functionName, account.Id, string.Format("Переписка завершена. Блокируем пользователя {0}({1})", friend.FriendName, friend.FacebookId));

            new MarkAddToEndDialogCommandHandler(new DataBaseContext()).Handle(new MarkAddToEndDialogCommand
            {
                AccountId = account.Id,
                FriendId  = friend.FacebookId
            });

            _friendManager.AddFriendToBlackList((long)account.GroupSettingsId, friend.FacebookId);
        }
Example #7
0
        public FriendViewModel GetFriendToWink(AccountViewModel account)
        {
            const string functionName = "Получение друзей для подмигивания";

            _notice.AddNotice(functionName, account.Id, "Получаем друга для подмигиваний");
            var groupId = account.GroupSettingsId;

            if (groupId == null)
            {
                return(null);
            }

            var settings = _accountSettingsManager.GetSettings((long)groupId);

            var model = new GetFriendToWinkQueryHandler(new DataBaseContext()).Handle(new GetFriendToWinkQuery
            {
                AccountId       = account.Id,
                GroupSettingsId = (long)groupId
            });

            if (model == null)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("Нет ниодного подходящего друга."));
                return(null);
            }

            _notice.AddNotice(functionName, account.Id, string.Format("Получили {0}({1})", model.FriendName, model.FacebookId));

            var testedFriendsId = new List <long> {
                model.FacebookId
            };

            var considerGeoForWink = settings.ConsiderGeoForWinkFriends;

            if (!considerGeoForWink)
            {
                return(new FriendViewModel
                {
                    AddDateTime = model.AddedDateTime,
                    Id = model.Id,
                    Deleted = model.Deleted,
                    FacebookId = model.FacebookId,
                    MessagesEnded = model.DialogIsCompleted,
                    Name = model.FriendName,
                    Href = model.Href,
                    IsAddedToGroups = model.IsAddedToGroups,
                    IsAddedToPages = model.IsAddedToPages,
                    IsWinked = model.IsWinked,
                    MessageRegime = model.MessageRegime,
                    AddedToRemoveDateTime = model.AddedToRemoveDateTime
                });
            }

            var driver = _seleniumManager.RegisterNewDriver(account); // открываем драйвер

            _notice.AddNotice(functionName, account.Id, string.Format("Проверяем гео данные для {0}({1})", model.FriendName, model.FacebookId));

            var isSuccces = new SpyService(null).AnalizeFriend(account, model.FacebookId, settings, driver);

            while (!isSuccces && settings.ConsiderGeoForWinkFriends)
            {
                _notice.AddNotice(functionName, account.Id, string.Format("Не прошел провергу по Гео {0}({1}), берем другого", model.FriendName, model.FacebookId));
                model = new GetFriendToWinkQueryHandler(new DataBaseContext()).Handle(new GetFriendToWinkQuery
                {
                    AccountId       = account.Id,
                    GroupSettingsId = (long)groupId,
                    TestedFriendsId = testedFriendsId
                });

                testedFriendsId.Add(model.FacebookId);

                _notice.AddNotice(functionName, account.Id, string.Format("Проверяем гео данные для {0}({1})", model.FriendName, model.FacebookId));

                isSuccces = new SpyService(null).AnalizeFriend(account, model.FacebookId, settings, driver);

                settings = _accountSettingsManager.GetSettings((long)groupId); //Обновляем настройки
            }

            driver.Quit(); //Закрываем драйвер

            _notice.AddNotice(functionName, account.Id, string.Format("Получили {0}({1})", model.FriendName, model.FacebookId));
            return(new FriendViewModel
            {
                AddDateTime = model.AddedDateTime,
                Id = model.Id,
                Deleted = model.Deleted,
                FacebookId = model.FacebookId,
                MessagesEnded = model.DialogIsCompleted,
                Name = model.FriendName,
                Href = model.Href,
                IsAddedToGroups = model.IsAddedToGroups,
                IsAddedToPages = model.IsAddedToPages,
                IsWinked = model.IsWinked,
                MessageRegime = model.MessageRegime,
                AddedToRemoveDateTime = model.AddedToRemoveDateTime
            });
        }