Пример #1
0
        public void StartVerification(object parameters )
        {
            try
            {
                lstEmailVarificationThread.Add(Thread.CurrentThread);
                lstEmailVarificationThread.Distinct().ToList();
                Thread.CurrentThread.IsBackground = true;

                Array paramsArray = new object[2];
                paramsArray = (Array)parameters;

                string Email = string.Empty;
                string Password = string.Empty;
                string username = string.Empty;
                string IPAddress = string.Empty;
                string IPPort = string.Empty;
                string IPUsername = string.Empty;
                string IPpassword = string.Empty;
                string IP = string.Empty;
                string tempEmail = string.Empty;


                #region commented by prabhat 07.12.13
                //string emailData = (string)paramsArray.GetValue(0);
                //if (paramsArray.Length>1)
                //{
                //    IP = (string)paramsArray.GetValue(1);
                //}

                //if (!emailData.Contains(':'))
                //{
                //    AddToEmailVerificationLog("[ " + DateTime.Now + " ] => [ Wrong Format Of Emails :- " + emailData + " ]");
                //    return;
                //}


                //Email = emailData.Split(':')[0];
                //Password = emailData.Split(':')[1];

                //AddToEmailVerificationLog("[ " + DateTime.Now + " ] => [ Going for Email Verification : " + Email + " ]");

                //if (!string.IsNullOrEmpty(IP))
                //{
                //    try
                //    {
                //        string[] IPData = IP.Split(':');
                //        if (IPData.Count() == 2)
                //        {
                //            IPAddress = IPData[0];
                //            IPPort = IPData[1];
                //        }
                //        if (IPData.Count() == 4)
                //        {
                //            IPAddress = IPData[0];
                //            IPPort = IPData[1];
                //            IPUsername = IPData[2];
                //            IPpassword = IPData[3];
                //        }
                //    }
                //    catch (Exception)
                //    {
                //    }
                //} 
                #endregion

                counter = Lst_NonVerifiedEmailAccount.Count();
                string item = paramsArray.GetValue(0).ToString();


                try
                {
                    string[] arrItem = Regex.Split(item, ":");
                    tempEmail = arrItem[0];
                    if (arrItem.Length == 2)
                    {
                        Email = arrItem[0]; //item.Key;
                        Password = arrItem[1];//item.Value._Password;
                    }
                    else if (arrItem.Length == 4)
                    {
                        Email = arrItem[0]; //item.Key;
                        Password = arrItem[1];//item.Value._Password;
                        IPAddress = arrItem[2];//item.Value._IPAddress;
                        IPPort = arrItem[3];
                    }
                    else if (arrItem.Length == 6)
                    {
                        Email = arrItem[0]; //item.Key;
                        Password = arrItem[1];//item.Value._Password;
                        IPAddress = arrItem[2];//item.Value._IPAddress;
                        IPPort = arrItem[3];//item.Value._IPPort;
                        IPUsername = arrItem[4];//item.Value._IPUsername;
                        IPpassword = arrItem[5];//item.Value._IPpassword;
                    }
                    else
                    {
                        AddToEmailVerificationLog("[ " + DateTime.Now + " ] => [ Wrong Format For Email Password ]");
                        return;
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Error >>> " + ex.StackTrace);
                }


                Globussoft.GlobusHttpHelper globusHelper = new Globussoft.GlobusHttpHelper();
                TweetAccountManager Accountmanager = new TweetAccountManager();

                Accountmanager.logEvents.addToLogger += new EventHandler(logEvents_addToLogger);

                ClsEmailActivator EmailActivate = new ClsEmailActivator();

                try
                {
                    Accountmanager.globusHttpHelper = globusHelper;
                    Accountmanager.Username = Email.Replace(" ", "").Replace("\0", "");
                    Accountmanager.Password = Password;
                    Accountmanager.IPAddress = IPAddress;
                    Accountmanager.IPPort = IPPort;
                    Accountmanager.IPUsername = IPUsername;
                    Accountmanager.IPpassword = IPpassword;
                    Accountmanager.Login();

                    if (Accountmanager.IsLoggedIn)
                    {
                        string postData = ("authenticity_token=" + Accountmanager.postAuthenticityToken).Trim();
                        string postdataPageSource = Accountmanager.globusHttpHelper.postFormData(new Uri("https://twitter.com/account/resend_confirmation_email"), postData, "	https://twitter.com/", "", "", "", "");
                    }
                }
                catch { };


                bool verified = EmailActivate.EmailVerification(Email, Password, ref globusHelper);

                if (verified)
                {
                    try
                    {
                        string pageresponce = Accountmanager.globusHttpHelper.getHtmlfromUrl(new Uri("https://twitter.com/"), "", "");

                        //if (pageresponce.Contains("btn resend-confirmation-email-link"))
                        //{
                        //    verified = false;
                        //}
                    }
                    catch (Exception)
                    {
                        AddToEmailVerificationLog("[ " + DateTime.Now + " ] => [ Verified Account  login Failed  : " + Email + " ]");
                    }
                }
                if (verified && Accountmanager.IsLoggedIn)
                {

                    Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(Email + ":" + Password + ":" + username + ":" + IPAddress + ":" + IPPort + ":" + IPUsername + ":" + IPpassword, Globals.path_SuccessfullyVerifiedAccounts);
                    AddToEmailVerificationLog("[ " + DateTime.Now + " ] => [ Account Verified : " + Email + " ]");
                }
                else
                {
                    Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(Email + ":" + Password + ":" + username + ":" + IPAddress + ":" + IPPort + ":" + IPUsername + ":" + IPpassword, Globals.path_VerificationFailedAccounts);
                    AddToEmailVerificationLog("[ " + DateTime.Now + " ] => [ Account Couldn't be Email Verified : " + Email + " ]");
                }
            }
            catch (Exception ex)
            {
                //AddToEmailVerificationLog("[ " + DateTime.Now + " ] => [ " + ex.Message + " ]");
            }
            finally 
            {
                counter--;
                if (counter == 0)
                {
                    AddToEmailVerificationLog("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
                    AddToEmailVerificationLog("------------------------------------------------------------------------------------------------------------------------------------------");
                }
            }
        }
Пример #2
0
        public void StartResendEmailForVerification(object parameters)
        {
            try
            {
                lstEmailVarificationThread.Add(Thread.CurrentThread);
                lstEmailVarificationThread.Distinct().ToList();
                Thread.CurrentThread.IsBackground = true;

                Array paramsArray = new object[2];
                paramsArray = (Array)parameters;

                string Email = string.Empty;
                string Password = string.Empty;
                string username = string.Empty;
                string IPAddress = string.Empty;
                string IPPort = string.Empty;
                string IPUsername = string.Empty;
                string IPpassword = string.Empty;
                string IP = string.Empty;
                string tempEmail = string.Empty;
                string postdataPageSource = string.Empty;
                        
                counter = Lst_NonVerifiedEmailAccount.Count();
                string item = paramsArray.GetValue(0).ToString();


                try
                {
                    string[] arrItem = Regex.Split(item, ":");
                    tempEmail = arrItem[0];
                    if (arrItem.Length == 2)
                    {
                        Email = arrItem[0]; //item.Key;
                        Password = arrItem[1];//item.Value._Password;
                    }
                    else if (arrItem.Length == 4)
                    {
                        Email = arrItem[0]; //item.Key;
                        Password = arrItem[1];//item.Value._Password;
                        IPAddress = arrItem[2];//item.Value._IPAddress;
                        IPPort = arrItem[3];
                    }
                    else if (arrItem.Length == 6)
                    {
                        Email = arrItem[0]; //item.Key;
                        Password = arrItem[1];//item.Value._Password;
                        IPAddress = arrItem[2];//item.Value._IPAddress;
                        IPPort = arrItem[3];//item.Value._IPPort;
                        IPUsername = arrItem[4];//item.Value._IPUsername;
                        IPpassword = arrItem[5];//item.Value._IPpassword;
                    }
                    else
                    {
                        AddToEmailVerificationLog("[ " + DateTime.Now + " ] => [ Wrong Format For Email Password ]");
                        return;
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Error >>> " + ex.StackTrace);
                }


                Globussoft.GlobusHttpHelper globusHelper = new Globussoft.GlobusHttpHelper();
                TweetAccountManager Accountmanager = new TweetAccountManager();

                Accountmanager.logEvents.addToLogger += new EventHandler(logEvents_addToLogger);

                ClsEmailActivator EmailActivate = new ClsEmailActivator();

                try
                {
                    Accountmanager.globusHttpHelper = globusHelper;
                    Accountmanager.Username = Email.Replace(" ", "").Replace("\0", "");
                    Accountmanager.Password = Password;
                    Accountmanager.IPAddress = IPAddress;
                    Accountmanager.IPPort = IPPort;
                    Accountmanager.IPUsername = IPUsername;
                    Accountmanager.IPpassword = IPpassword;
                    Accountmanager.Login();

                    if (Accountmanager.IsLoggedIn)
                    {
                        string postData = ("authenticity_token=" + Accountmanager.postAuthenticityToken).Trim();
                        postdataPageSource = Accountmanager.globusHttpHelper.postFormData(new Uri("https://twitter.com/account/resend_confirmation_email"), postData, "	https://twitter.com/", "", "", "", "");
                    }
                }
                catch { };


                if (postdataPageSource.Contains("A confirmation email has been sent to you."))
                {
                    AddToEmailVerificationLog("[ " + DateTime.Now + " ] => [ Email send to confirmation for Account : " + Email + " ]");
                }
                
                else
                {
                    Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(Email + ":" + Password + ":" + username + ":" + IPAddress + ":" + IPPort + ":" + IPUsername + ":" + IPpassword, Globals.path_VerificationFailedAccounts);
                    AddToEmailVerificationLog("[ " + DateTime.Now + " ] => [ Email not send to confirmation for Account : " + Email + " ]");
                }
            }
            catch (Exception ex)
            {
                //AddToEmailVerificationLog("[ " + DateTime.Now + " ] => [ " + ex.Message + " ]");
            }
            finally
            {
                counter--;
                if (counter == 0)
                {
                    AddToEmailVerificationLog("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
                    AddToEmailVerificationLog("------------------------------------------------------------------------------------------------------------------------------------------");
                }
            }
        }
Пример #3
0
        private void StartCheckingAccount(object parameters)
        {

            TweetAccountManager tweetAccountManager = new TweetAccountManager();

            lstThreadAppFollow.Add(Thread.CurrentThread);
            lstThreadAppFollow = lstThreadAppFollow.Distinct().ToList();
            Thread.CurrentThread.IsBackground = true;

            try
            {
                Array paramsArray = new object[3];

                paramsArray = (Array)parameters;

                KeyValuePair<string, TweetAccountManager> keyValue = (KeyValuePair<string, TweetAccountManager>)paramsArray.GetValue(0);


                AddToListBox("[ " + DateTime.Now + " ] => [ Starting Checking Account : " + keyValue.Key + " ]");

                tweetAccountManager = keyValue.Value;

                if (!tweetAccountManager.IsLoggedIn)
                {
                    tweetAccountManager.Login();
                }
                if (tweetAccountManager.IsLoggedIn)
                {
                    AddToListBox("[ " + DateTime.Now + " ] => [ SuccessFully Logged In with Account:  " + keyValue.Key + " ]");
                }
                if (tweetAccountManager.AccountStatus == "Account Suspended")
                {
                    AddToListBox("[ " + DateTime.Now + " ] => [ Suspended  Account:  " + keyValue.Key + " ]");
                    clsDBQueryManager database = new clsDBQueryManager();
                    database.UpdateSuspendedAcc(tweetAccountManager.Username);
                    return;
                }

                DataTable dt = objclsFBAccount.SelectAccoutsForGridView();

                if (!Globals.IsRefreshAccountExecute)
                {
                    btnRefresh.Invoke(new MethodInvoker(delegate
                    {
                        dgvAccounts.DataSource = dt;

                    }));
                }
            }
            catch (Exception ex)
            {
                GlobusFileHelper.AppendStringToTextfileNewLine("Error --> startCheckingAccount() -- Method --> " + ex.Message, Globals.Path_TwtErrorLogs);
            }
            finally
            {
                counter_Account--;
                
                if (counter_Account == 0)
                {
                    if (btnRefresh.InvokeRequired)
                    {
                        btnRefresh.Invoke(new MethodInvoker(delegate
                        {
                            AddToListBox("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
                            AddToListBox("---------------------------------------------------------------------------------------------------------------------------");

                        }));
                    }
                }
            }
        }
Пример #4
0
        private void ScrapeMemberSeacrh()
        {
            try
            {
                lstIsStopScrapMember.Add(Thread.CurrentThread);
                lstIsStopScrapMember.Distinct();
                Thread.CurrentThread.IsBackground = true;

            }
            catch { }

            try
            {
                TwitterDataScrapper TweetData = new TwitterDataScrapper();
                GlobusHttpHelper globusHttpHelper = new GlobusHttpHelper();
                int counter = 0;
                TweetAccountManager TweetLogin = new TweetAccountManager();
               

                txtlimitScrapeUsers.Invoke(new MethodInvoker(delegate
                {

                    if (!string.IsNullOrEmpty(txtlimitScrapeUsers.Text.Trim()) && NumberHelper.ValidateNumber(txtlimitScrapeUsers.Text.Trim()))
                    {
                        noOfRecords = Convert.ToInt32(txtlimitScrapeUsers.Text.Trim());
                        if (noOfRecords == 0)
                        {
                            AddToLog_ScrapMember("[ " + DateTime.Now + " ] => [ Do not put Zero value ]");
                            AddToLog_ScrapMember("[ " + DateTime.Now + " ] => [ Default number of records is 50 ]");
                            noOfRecords = 50;
                        }
                    }
                    else
                    {
                        AddToLog_ScrapMember("[ " + DateTime.Now + " ] => [ please enter value in number of users ]");
                        return;
                    }
                }));


                foreach (KeyValuePair<string, TweetAccountManager> item in TweetAccountContainer.dictionary_TweetAccount)
                {
                    AddToLog_ScrapMember("[ " + DateTime.Now + " ] => [ Login process starting]");
                    if (counter > TweetAccountContainer.dictionary_TweetAccount.Count)
                    {
                        counter = 0;
                    }

                    TweetLogin = new TweetAccountManager();
                    TweetLogin.Username = item.Key;
                    TweetLogin.Password = item.Value.Password;
                    TweetLogin.IPAddress = item.Value.IPAddress;
                    TweetLogin.IPPort = item.Value.IPPort;
                    TweetLogin.IPUsername = item.Value.IPUsername;
                    TweetLogin.IPpassword = item.Value.IPpassword;
                    TweetLogin.Login();

                    if (!TweetLogin.IsLoggedIn)
                    {
                        continue;
                    }
                    else
                    {
                        AddToLog_ScrapMember("[ " + DateTime.Now + " ] => [ Login process successful]");
                        globusHttpHelper = TweetLogin.globusHttpHelper;
                        counter++;
                        break;
                    }
                }


                if (!TweetLogin.IsLoggedIn)
                {
                    AddToLog_ScrapMember("[ " + DateTime.Now + " ] => [ Please Upload Atleast One Working Account To Get Details ]");
                    return;
                }


                AddToLog_ScrapMember("[ " + DateTime.Now + " ] => [ Scraping User ]");

                
                    foreach (string item in lstUrl)
                    {
                        string tempItem = string.Empty;
                        if (!item.Contains("https://twitter.com"))
                        {
                            tempItem = "https://twitter.com" + item;
                        }
                        else
                        {
                            tempItem = item;
                        }

                        List<string> lstMember = new List<string>();
                        string returnStatus = string.Empty;
                        getTweetUsers(item, ref globusHttpHelper);
                        //lstMember = GetMembers(item, ref globusHttpHelper, out returnStatus);
                        AddToLog_ScrapMember("[ " + DateTime.Now + " ] => [ Scraped Member for Url " + item + "]");
                    }

            }
            catch { }
        }
Пример #5
0
        public void StartCampaign()
        {
            try
            {
                AddToLog_Follower("[ " + DateTime.Now + " ] => [ Starting Campaign ]");
                string KeywordList = string.Empty;
                string UsernameList = string.Empty;
                if (Globals.Array[3] == "Username")
                {
                    Globals.Campaign_Name = Globals.Array[0];
                    Globals.IsCampaign = true;
                    AddToLog_Follower("[ " + DateTime.Now + " ] => [ Getting Followers & Following ]");
                    UsernameList = Globals.Array[1];
                    ReloadAccountsFromDataBase();
                    Globussoft.GlobusHttpHelper globusHttpHelper = new GlobusHttpHelper();
                    if (File.Exists(UsernameList))
                    {
                        List<string> LstUsernameCampiagn = GlobusFileHelper.ReadLargeFile(UsernameList);
                        listUserIDs = new List<string>();
                        List<string> ListUsername = new List<string>();
                        foreach (KeyValuePair<string, TweetAccountManager> item in TweetAccountContainer.dictionary_TweetAccount)
                        {
                            if (counter > TweetAccountContainer.dictionary_TweetAccount.Count)
                            {
                                counter = 0;
                            }
                            TweetAccountManager TweetLogin = new TweetAccountManager();
                            TweetLogin.Username = item.Key;
                            TweetLogin.Password = item.Value.Password;
                            TweetLogin.proxyAddress = item.Value.proxyAddress;
                            TweetLogin.proxyPort = item.Value.proxyPort;
                            TweetLogin.proxyUsername = item.Value.proxyUsername;
                            TweetLogin.proxyPassword = item.Value.proxyPassword;
                            TweetLogin.Login();
                            if (!TweetLogin.IsNotSuspended)
                            {
                                continue;
                            }
                            globusHttpHelper = TweetLogin.globusHttpHelper;
                            counter++;
                            break;
                        }
                        foreach (string keyword in LstUsernameCampiagn)
                        {
                            TwitterDataScrapper dataScrapeer = new TwitterDataScrapper();
                            try
                            {
                                string FollowerStatus = string.Empty;
                                string FollowingStatus = string.Empty;
                                AddToLog_Follower("[ " + DateTime.Now + " ] => [ Scraping Followers For : " + keyword + " ]");
                                dataScrapeer.CounterDataNo = 2000;
                                dataScrapeer.logEvents.addToLogger += new EventHandler(logEvents_Follower_addToLogger);
                                List<string> followerList = dataScrapeer.GetFollowers_New(keyword, out FollowerStatus, ref globusHttpHelper);

                                if (followerList.Count != 0)
                                {
                                    try
                                    {
                                        List<string> Temp_followers = new List<string>();
                                        followerList.ForEach(s =>
                                        {
                                            if (s.Contains(":"))
                                            {
                                                Temp_followers.Add(s.Split(':')[0]);
                                            }
                                            else
                                            {
                                                Temp_followers.Add(s.ToString());
                                            }
                                        });

                                        if (Temp_followers.Count != 0)
                                        {
                                            followerList.Clear();
                                            followerList.AddRange(Temp_followers);
                                        }
                                    }
                                    catch { };
                                }
                                followerList.ForEach(s => s.Split(':'));
                                dataScrapeer.logEvents.addToLogger -= new EventHandler(logEvents_Follower_addToLogger);
                                AddToLog_Follower("[ " + DateTime.Now + " ] => [ Follower For " + keyword + " >> " + followerList.Count + " ]");
                                if (FollowerStatus == "No Error")
                                {
                                    foreach (string lst in followerList)
                                    {
                                        listUserIDs.Add(lst);
                                    }
                                }
                                Thread.Sleep(5000);
                                AddToLog_Follower("[ " + DateTime.Now + " ] => [ Scraping Followings For : " + keyword + " ]");
                                dataScrapeer.logEvents.addToLogger += new EventHandler(logEvents_Follower_addToLogger);
                                List<string> followingList = dataScrapeer.GetFollowings_New(keyword, out FollowingStatus, ref globusHttpHelper);
                                dataScrapeer.logEvents.addToLogger -= new EventHandler(logEvents_Follower_addToLogger);
                                AddToLog_Follower("[ " + DateTime.Now + " ] => [ Following For " + keyword + " >> " + followingList.Count + " ]");
                                if (FollowingStatus == "No Error")
                                {
                                    foreach (string lst in followerList)
                                    {
                                        listUserIDs.Add(lst);
                                    }
                                }
                                Thread.Sleep(5000);
                            }
                            catch (Exception ex)
                            {
                                Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> StartingCampaign() -- chkboxScrapeFollowers.Checked --> " + ex.Message, Globals.Path_ScrapeUsersErroLog);
                                Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine("Error --> StartingCampaign() -- chkboxScrapeFollowers.Checked --> " + ex.Message, Globals.Path_TwtErrorLogs);
                            }
                        }

                        StartFollowing();
                    }
                    else
                    {
                        AddToLog_Follower("[ " + DateTime.Now + " ] => [ File : " + UsernameList + ". Does Not Exsist ]");
                    }
                }
                else if (Globals.Array[3] == "Keyword")
                {
                    KeywordList = Globals.Array[2];
                    ReloadAccountsFromDataBase();
                    if (File.Exists(KeywordList))
                    {
                        List<string> KeywordListdata = GlobusFileHelper.ReadLargeFile(KeywordList);
                        List<TwitterDataScrapper.StructTweetIDs> ids = new List<TwitterDataScrapper.StructTweetIDs>();
                        foreach (string id in KeywordListdata)
                        {
                            TwitterDataScrapper dataScrpeer = new TwitterDataScrapper();
                            TwitterDataScrapper.noOfRecords = 2000;
                            AddToLog_Follower("[ " + DateTime.Now + " ] => [ Scraping Users From Keyword : " + id + " ]");
                            dataScrpeer.logEvents.addToLogger += new EventHandler(logEvents_Follower_addToLogger);
                            ids = dataScrpeer.NewKeywordStructData(id);
                            dataScrpeer.logEvents.addToLogger -= new EventHandler(logEvents_Follower_addToLogger);
                            AddToLog_Follower("[ " + DateTime.Now + " ] => [ Total Users From Keyword : " + id + " : " + ids.Count + " ]");
                            foreach (TwitterDataScrapper.StructTweetIDs lst in ids)
                            {
                                listUserIDs.Add(lst.ID_Tweet_User);
                            }
                        }
                        StartFollowing();
                    }
                    else
                    {
                        AddToLog_Follower("[ " + DateTime.Now + " ] => [ File : " + KeywordList + ".Does Not Exsist ]");
                    }
                }
            }
            catch (Exception ex)
            {
                GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> Campaign --> startFlyCreationEvent_addToLogger() --> " + ex.Message, Globals.Path_CampaignManager);
            }
        }
Пример #6
0
        public void StartProcessOfRetweetOrFavorite(object AC)
        {
            int favCount = 0;
            int RetweetCount = 0;
            try
            {
                if (!_Isfevorite)
                {
                    lstReTweetThread.Add(Thread.CurrentThread);
                    lstReTweetThread.Distinct().ToList();
                    Thread.CurrentThread.IsBackground = true;
                }
            }
            catch
            {
            }
            TweetAccountManager tweetAccountManager = new TweetAccountManager();
            KeyValuePair<string, TweetAccountManager> item = (KeyValuePair<string, TweetAccountManager>)AC;
            tweetAccountManager = item.Value;
            tweetAccountManager.logEvents.addToLogger += new EventHandler(retweetOfUrl_logEvents_addToLogger);
            try
            {
                AddToLog_RetweetAndFavorite("[ " + DateTime.Now + " ] => [ Starting Process For Account " + tweetAccountManager.Username + " ]");
                //Login from account ..
                tweetAccountManager.Login();

                //check if account is not loged In ..
                if (!tweetAccountManager.IsLoggedIn)
                {
                    //tweetAccountManager.Login();
                }
                //check Coount is loged in or Is not suspended ..
                if (tweetAccountManager.IsLoggedIn)
                {
                    //AddToLog_RetweetAndFavorite("[ " + DateTime.Now + " ] => [ Logged In With " + tweetAccountManager.Username + " ]");
                    if (tweetAccountManager.IsNotSuspended)
                    {
                        if (!chkUsingKeyWord.Checked)
                        {
                            foreach (string TUri in lst_tweetUrl)
                            {
                                try
                                {
                                    if (chk_retweetOfUrl.Checked)
                                    {
                                        retweetOfUrl(new object[] { TUri, item, tweetAccountManager });
                                    }
                                    if (chk_Favorite.Checked)
                                    {
                                        AddToLog_RetweetAndFavorite("[ " + DateTime.Now + " ] => [ Adding To Favorite : " + TUri + " from " + tweetAccountManager.Username + " ]");
                                        FavoriteOfUrl(new object[] { TUri, item, tweetAccountManager });
                                    }
                                }
                                catch (Exception)
                                {
                                }
                            }
                        }
                        else
                        {

                            //foreach (TwitterDataScrapper.StructTweetIDs TUri in TweetAccountManager.static_lst_Struct_TweetData)
                            if (TwitterDataScrapper.queTweetId.Count > 0)
                            {
                                while (TwitterDataScrapper.queTweetId.Count > 0)
                                {
                                    try
                                    {
                                        //if (chk_retweetOfUrl.Checked)
                                        //{
                                        //    AddToLog_RetweetAndFavorite("[ " + DateTime.Now + " ] => [ Retweeted : " + TUri + " from " + tweetAccountManager.Username + " ]");
                                        //    retweetOfUrl(new object[] { TUri.ID_Tweet, item, tweetAccountManager });
                                        //}
                                        string TUri = TwitterDataScrapper.queTweetId.Dequeue();
                                        if (chk_Favorite.Checked)
                                        {
                                            AddToLog_RetweetAndFavorite("[ " + DateTime.Now + " ] => [ Added To Favorite : " + TUri + " from " + tweetAccountManager.Username + " ]");
                                            favCount=FavoriteOfUrl(new object[] { TUri, item, tweetAccountManager },favCount);
                                        }
                                        if (favCount >= int.Parse(txtCountFavoriteandRetweet.Text))
                                        {
                                            break;
                                        }
                                    }
                                    catch (Exception)
                                    {
                                    }
                                }
                            }
                            else
                            {
                                AddToLog_RetweetAndFavorite("[ " + DateTime.Now + " ] => [ Zero tweet found from keyword " + txt_TweetUrl.Text + " ]");
                            }
                        }
                    }
                    else
                    {
                        AddToLog_RetweetAndFavorite("[ " + DateTime.Now + " ] => [ Account Is suspended  >" + item.Key + " ]");
                    }
                }
                else
                {
                    AddToLog_RetweetAndFavorite("[ " + DateTime.Now + " ] => [ Account Not Logged With " + item.Key + " ]");
                }

                //this.Invoke(new MethodInvoker(delegate
                //{
                //txt_TweetUrl.Text = "";
                //lst_tweetUrl.Clear();
                //}));
            }
            catch (Exception ex)
            {
                //AddToLog_RetweetAndFavorite("Error :-  > " + ex.Message);
                GlobusFileHelper.AppendStringToTextfileNewLine("Error :- Mathod Name :- StartProcessOfRetweetOrFavorite- 1; Error Text :- " + ex.Message, Globals.path_LogErrorFromRetweetAndFavorit);
            }

            finally
            {
                //AddToLog_RetweetAndFavorite("[ " + DateTime.Now + " ] => [ Completed Retweet and Favorite From " + tweetAccountManager.Username + " ]");
                tweetAccountManager.logEvents.addToLogger -= new EventHandler(retweetOfUrl_logEvents_addToLogger);
                //txt_RetweetUrlFilePath.Text = "";
                counter_Retweet--;
                if (counter_Retweet == 0)
                {
                    if (btn_start.InvokeRequired)
                    {
                        //btn_start.Cursor = Cursors.AppStarting;
                        btn_start.Invoke(new MethodInvoker(delegate
                        {
                            AddToLog_RetweetAndFavorite("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
                            AddToLog_RetweetAndFavorite("---------------------------------------------------------------------------------------------------------------------------");
                            btn_start.Cursor = Cursors.Default;
                            lst_tweetUrl.Clear();
                            //txt_TweetUrl.Text = "";

                        }));
                    }

                }

            }
        }
Пример #7
0
        public void GetUserNameToID(string exportPath)
        {
            try
            {
                int counter = 0;
                TweetAccountManager TweetLogin = new TweetAccountManager();
                GlobusHttpHelper globusHttpHelper = new GlobusHttpHelper();
                foreach (KeyValuePair<string, TweetAccountManager> item in TweetAccountContainer.dictionary_TweetAccount)
                {
                    if (counter > TweetAccountContainer.dictionary_TweetAccount.Count)
                    {
                        counter = 0;
                    }
                    TweetLogin = new TweetAccountManager();
                    TweetLogin.Username = item.Key;
                    TweetLogin.Password = item.Value.Password;
                    TweetLogin.proxyAddress = item.Value.proxyAddress;
                    TweetLogin.proxyPort = item.Value.proxyPort;
                    TweetLogin.proxyUsername = item.Value.proxyUsername;
                    TweetLogin.proxyPassword = item.Value.proxyPassword;
                    TweetLogin.Login();
                    if (!TweetLogin.IsNotSuspended)
                    {
                        continue;
                    }
                    else
                    {
                        globusHttpHelper = TweetLogin.globusHttpHelper;
                        counter++;
                        break;
                    }
                }
                string ReturnStatus = string.Empty;

                if (!TweetLogin.IsNotSuspended)
                {
                    AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Please Upload Atleast One Working Account To Get Details ]");
                    return;
                }
                AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Starting Scraping For Userids ]");
                foreach (string Username in lstUserNameID)
                {
                    AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Username : "******" ]");
                    string returnStatus = string.Empty;
                    string UserId = TwitterDataScrapper.GetUsernameToUserID_New(Username, out returnStatus, ref globusHttpHelper);
                    if (returnStatus == "No Error" && !string.IsNullOrEmpty(UserId))
                    {
                        AddToScrapeLogs("[ " + DateTime.Now + " ] => [ " + Username + " >>> " + UserId + " ]");
                        GlobusFileHelper.AppendStringToTextfileNewLine(Username + "," + UserId, exportPath);
                        lstScrapedUserID.Add(UserId);
                    }
                    else if (returnStatus == "Rate limit exceeded")
                    {
                        AddToScrapeLogs("[ " + DateTime.Now + " ] => [ " + Username + " >>> " + returnStatus + " ]");
                        break;
                    }
                    else if (returnStatus == "Sorry, that page does not exist")
                    {
                        AddToScrapeLogs("[ " + DateTime.Now + " ] => [ " + Username + " >>> " + returnStatus + " ]");
                    }
                    else if (returnStatus == "User has been suspended")
                    {
                        AddToScrapeLogs("[ " + DateTime.Now + " ] => [ " + Username + " >>> " + returnStatus + " ]");
                    }
                }
                AddToScrapeLogs("[ " + DateTime.Now + " ] => [ " + lstScrapedUserID.Count + " UserId Scraped ]");
            }
            catch (Exception ex)
            {
                Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> GetUserNameToID() --> " + ex.Message, Globals.Path_ScrapeUsersErroLog);
                Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine("Error --> GetUserNameToID() --> " + ex.Message, Globals.Path_TwtErrorLogs);
            }
        }
Пример #8
0
        public void startAccountCheckingByEmail(string Lst_EmailsForAccountChecking_item, int NoOfThreads)
        {
            try
            {
                accountCheckerThreadStartByEmail = true;
                Lst_accountCheckerThreadByEmail.Add(Thread.CurrentThread);
                Thread.CurrentThread.IsBackground = true;
            }
            catch (Exception)
            {
            }

            string email = string.Empty;
            string EmailPass = string.Empty;
            string proxyAddress = string.Empty;
            string port = string.Empty;
            string proxyusername = string.Empty;
            string proxypass = string.Empty;

            try
            {
                //Check all special carector which is not supported in twiter
                if (!Lst_EmailsForAccountChecking_item.Contains(":"))
                {
                    Regex objNotNaturalPattern = new Regex(@"[^\w\*]");
                    if (objNotNaturalPattern.IsMatch(Lst_EmailsForAccountChecking_item))
                    {
                        ThreadCount++;
                        AddToLog_Checker("[ " + DateTime.Now + " ] => [ User name is not Correct : " + Lst_EmailsForAccountChecking_item + " ]");
                        return;
                    }
                }

                if (!string.IsNullOrEmpty(Lst_EmailsForAccountChecking_item))
                {
                    string[] EmailArr = Lst_EmailsForAccountChecking_item.Split(':');

                    if (EmailArr.Count() == 2)
                    {
                        email = EmailArr[0];
                        EmailPass = EmailArr[1];
                    }
                    else if (EmailArr.Count() == 4)
                    {
                        email = EmailArr[0];
                        EmailPass = EmailArr[1];
                        proxyAddress = EmailArr[2];
                        port = EmailArr[3];
                    }
                    else if (EmailArr.Count() == 6)
                    {
                        email = EmailArr[0];
                        EmailPass = EmailArr[1];
                        proxyAddress = EmailArr[2];
                        port = EmailArr[3];
                        proxyusername = EmailArr[4];
                        proxypass = EmailArr[5];
                    }
                    else
                    {
                        ThreadCount++;
                        AddToLog_Checker("[ " + DateTime.Now + " ] => [ Uploaded Email Not in Correct Format ]");
                        return;
                    }
                }

                if (!string.IsNullOrEmpty(email) && !string.IsNullOrEmpty(EmailPass))
                {

                    TweetAccountManager AccountManager = new TweetAccountManager();

                    AccountManager.logEvents.addToLogger += new EventHandler(logEvents_addToLogger);
                    // AccountManager.logEvents.addToLogger += logEvents_addToLogger;

                    AccountManager.Username = email;
                    AccountManager.Password = EmailPass;
                    AccountManager.proxyAddress = proxyAddress;
                    AccountManager.proxyPort = port;
                    AccountManager.proxyUsername = proxyusername;
                    AccountManager.proxyPassword = proxypass;

                    AccountManager.Login();

                    //ThreadCount++;

                    if (AccountManager.IsLoggedIn && AccountManager.IsNotSuspended && !AccountManager.Isnonemailverifiedaccounts)
                    {
                        AddToLog_Checker("[ " + DateTime.Now + " ] => [ Account : " + AccountManager.Username + " is Active ]");
                        Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(AccountManager.Username + ":" + EmailPass + ":" + proxyAddress + ":" + port + ":" + proxyusername + ":" + proxypass, Globals.path_ActiveEmailAccounts);
                    }
                    else if (!AccountManager.IsLoggedIn && AccountManager.globusHttpHelper.gResponse.ResponseUri.AbsoluteUri.Contains("https://twitter.com/login/captcha"))
                    {
                        AddToLog_Checker("[ " + DateTime.Now + " ] => [ Account : " + AccountManager.Username + " Asking for captcha ]");
                        Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(AccountManager.Username + ":" + EmailPass + ":" + proxyAddress + ":" + port + ":" + proxyusername + ":" + proxypass, Globals.path_EmailisNotCurrectOrIncorrectPass);
                    }
                    //Not necesary its allready done on followercount() method in account login
                    //else if (!AccountManager.IsNotSuspended)
                    //{
                    //    AddToLog_Checker("[ " + DateTime.Now + " ] => [ Account : " + AccountManager.Username + " is suspended ]");
                    //    Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(AccountManager.Username + ":" + EmailPass + ":" + proxyAddress + ":" + port + ":" + proxyusername + ":" + proxypass, Globals.path_SuspendedEmailAccounts);
                    //}
                    else if (AccountManager.Isnonemailverifiedaccounts)
                    {
                        AddToLog_Checker("[ " + DateTime.Now + " ] => [ Account : " + AccountManager.Username + " is Required Email Verification ]");
                        Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(AccountManager.Username + ":" + EmailPass + ":" + proxyAddress + ":" + port + ":" + proxyusername + ":" + proxypass, Globals.path_RequiredEmailVerificationAccounts);
                    }
                    else
                    {
                        AddToLog_Checker("[ " + DateTime.Now + " ] => [ Email is not exist/incorrect pass : "******" ]");
                        Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(AccountManager.Username + ":" + EmailPass + ":" + proxyAddress + ":" + port + ":" + proxyusername + ":" + proxypass, Globals.path_EmailisNotCurrectOrIncorrectPass);
                    }

                    AccountManager.logEvents.addToLogger -= new EventHandler(logEvents_addToLogger);
                    AccountManager.logEvents.addToLogger -= logEvents_addToLogger;

                }
            }
            catch (Exception ex)
            {
                //ThreadCount++;
                //AddToLog_Checker("[ " + DateTime.Now + " ] => [ " + ex.Message + " ]");
                GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> CheckAccountsByEmail() --> " + ex.Message, Globals.Path_AccountCheckerErroLog);
                GlobusFileHelper.AppendStringToTextfileNewLine("Error --> CheckAccounts() --> " + ex.Message, Globals.Path_TwtErrorLogs);
            }
            finally
            {
                ThreadCount++;
                if (Lst_EmailsForAccountChecking.Count == ThreadCount)
                {
                    IsEmailProcessStart = true;
                    AddToLog_Checker("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED for Account checker by Email. ]");
                    AddToLog_Checker("------------------------------------------------------------------------------------------------------------------------------------------");
                }
                _TheadSem.Release();
            }
        }
Пример #9
0
        public void getLoginandCheckAccount()
        {
            AddToLog_Checker("[ " + DateTime.Now + " ] => [ Process start ]");

            try
            {
                Lst_GetUserNameFromAccThreads.Add(Thread.CurrentThread);
                GetUserNameFromAccThreadStart = true;
                Thread.CurrentThread.IsBackground = true;
            }
            catch { };

            try
            {
                //Get individual Email from Email list

                foreach (string item in listOfTwitterEmailIdAndPassword)
                {
                    TweetAccountManager tweetAccountManager = new TweetAccountManager();

                    GlobusHttpHelper globushttpHelper1 = new GlobusHttpHelper();

                    if (item.Contains(":") && !string.IsNullOrEmpty(item.Split(':')[0]) && !string.IsNullOrEmpty(item.Split(':')[1]))
                    {
                        string userEmail = item.Split(':')[0];
                        string userEmailPass = item.Split(':')[1];

                        tweetAccountManager.Username = userEmail;
                        tweetAccountManager.Password = userEmailPass;

                        tweetAccountManager.logEvents.addToLogger += new EventHandler(logEvents_addToLogger);
                        if (!tweetAccountManager.IsLoggedIn)
                        {
                            tweetAccountManager.Login();
                        }

                        if (tweetAccountManager.IsLoggedIn)
                        {
                            //AddToLog_Checker("Log in Success " + userEmail);

                            if (!tweetAccountManager.IsNotSuspended)
                            {
                                AddToLog_Checker("[ " + DateTime.Now + " ] => [ Account Is suspended :-" + userEmail + " ]");
                                continue;
                            }

                            String userID = tweetAccountManager.userID;

                            String ScreanName = tweetAccountManager.Screen_name;

                            if (!string.IsNullOrEmpty(userID) && !string.IsNullOrEmpty(ScreanName))
                            {
                                if (!File.Exists(Globals.Path_CheckAccountByEmail))
                                {
                                    string Header = "Email" + "," + "User Id" + "," + "Screan Name";
                                    GlobusFileHelper.AppendStringToTextfileNewLine(Header, Globals.Path_CheckAccountByEmail);
                                }

                                string CheckAccountByEmail_Data = userEmail + "," + userID + "," + ScreanName;
                                if (!string.IsNullOrEmpty(userEmail))
                                {
                                    GlobusFileHelper.AppendStringToTextfileNewLine(CheckAccountByEmail_Data, Globals.Path_CheckAccountByEmail);
                                    AddToLog_Checker("[ " + DateTime.Now + " ] => [ " + userEmail + "-" + userID + "-" + ScreanName + " ]");
                                }
                            }

                            #region Old code from API 1
                            //string URL = string.Empty;
                            ////get data from API Url ...
                            //if (!string.IsNullOrEmpty(tweetAccountManager.userID))
                            //{
                            //    string userID1 = tweetAccountManager.userID;
                            //    URL = "https://api.twitter.com/1/users/show.json?user_id=" + userID1 + "&include_entities=true";
                            //}
                            //else if (!string.IsNullOrEmpty(tweetAccountManager.Screen_name))
                            //{
                            //    string user_screen_name = tweetAccountManager.Screen_name;
                            //    URL = "https://api.twitter.com/1/users/show.json?screen_name=" + user_screen_name + "&include_entities=true";
                            //}
                            //else
                            //{
                            //    AddToLog_Checker("User Id or Screan name is Not avaliable For :- " + userEmail);
                            //    //continue;
                            //}

                            //try
                            //{
                            //    string Data = globushttpHelper1.getHtmlfromUrl(new Uri(URL), "", "");

                            //    //parse data from Json..
                            //    JObject JData = JObject.Parse(Data);
                            //    string ScreanName = (string)JData["screen_name"];
                            //    string userID = ((int)JData["id"]).ToString();
                            //    //get write data in CSV file ...
                            //    if (!string.IsNullOrEmpty(userID) && !string.IsNullOrEmpty(ScreanName))
                            //    {
                            //        if (!File.Exists(Globals.Path_CheckAccountByEmail))
                            //        {
                            //            string Header = "Email" + "," + "User Id" + "," + "Screan Name";
                            //            GlobusFileHelper.AppendStringToTextfileNewLine(Header, Globals.Path_CheckAccountByEmail);
                            //        }

                            //        string CheckAccountByEmail_Data = userEmail + "," + userID + "," + ScreanName;
                            //        if (!string.IsNullOrEmpty(userEmail))
                            //        {
                            //            GlobusFileHelper.AppendStringToTextfileNewLine(CheckAccountByEmail_Data, Globals.Path_CheckAccountByEmail);
                            //            AddToLog_Checker(userEmail + "-" + userID + "-" + ScreanName);
                            //        }
                            //    }
                            //}
                            //catch (Exception)
                            //{

                            //}
                            #endregion
                        }
                    }
                    else
                    {
                        AddToLog_Checker("[ " + DateTime.Now + " ] => [ Account Format is wrong for :- " + item + " ]");
                    }
                }
                AddToLog_Checker("[ " + DateTime.Now + " ] => [ Account Checking Finished ]");

                AddToLog_Checker("-----------------------------------------------------------------------------------------------------------------------");
            }
            catch (Exception)
            {
            }

            finally
            {
                AddToLog_Checker("[ " + DateTime.Now + " ] => [ Finished Getting Username For all Emails ]");
                AddToLog_Checker("-----------------------------------------------------------------------------------------------------------------------");
            }
        }
Пример #10
0
        private void threadStartScrapeInTweetMentionUser()
        {
            TwitterDataScrapper dataScrapeer = new TwitterDataScrapper();
            try
            {
                List<string> lst_structTweetFollowersIDs = new List<string>();
                List<string> lst_structTweetFollowingsIds = new List<string>();
                GlobusHttpHelper globusHttpHelper = new GlobusHttpHelper();
                string user_id = string.Empty;
                int counter = 0;
                TweetAccountManager TweetLogin = new TweetAccountManager();

                foreach (KeyValuePair<string, TweetAccountManager> item in TweetAccountContainer.dictionary_TweetAccount)
                {
                    if (counter > TweetAccountContainer.dictionary_TweetAccount.Count)
                    {
                        counter = 0;
                    }

                    TweetLogin = new TweetAccountManager();
                    TweetLogin.Username = item.Key;
                    TweetLogin.Password = item.Value.Password;
                    TweetLogin.proxyAddress = item.Value.proxyAddress;
                    TweetLogin.proxyPort = item.Value.proxyPort;
                    TweetLogin.proxyUsername = item.Value.proxyUsername;
                    TweetLogin.proxyPassword = item.Value.proxyPassword;
                    AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Logging Process start for scrapping User ]");
                    TweetLogin.Login();
                    if (!TweetLogin.IsLoggedIn)
                    {
                        continue;
                    }
                    else
                    {
                        AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Logged in successful]");
                        globusHttpHelper = TweetLogin.globusHttpHelper;
                        counter++;
                        break;
                    }
                }
                string ReturnStatus = string.Empty;

                if (!TweetLogin.IsLoggedIn)
                {
                    AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Please Upload Atleast One Working Account To Get Details ]");
                    return;
                }

                //foreach (string keyword in listUserIDs)//foreach (string keyword in lstscrapeUsername)
                //{
                string keyword = txtTweetScrapUserData.Text.Trim();

                dataScrapeer.CounterDataNo = 100;
                listUserIDs.Clear();

                txtlimitScrapeUsersINFollower.Invoke(new MethodInvoker(delegate
                {
                    if (!string.IsNullOrEmpty(txtTweetEnteNoofUser.Text) && NumberHelper.ValidateNumber(txtTweetEnteNoofUser.Text))
                    {
                        dataScrapeer.CounterDataNo = Convert.ToInt32(txtTweetEnteNoofUser.Text);
                    }
                }));

                if (counter > TweetAccountContainer.dictionary_TweetAccount.Count)
                {
                    counter = 0;
                }

                if (chkTweetScrapFollowers.Checked)
                {
                    try
                    {
                        if (!File.Exists(Globals.Path_ScrapedFollowersList))
                        {
                            GlobusFileHelper.AppendStringToTextfileNewLine("Name/Id , FollowersUserID , Followers User Name", Globals.Path_ScrapedFollowersList);
                        }
                        string returnStatus = string.Empty;
                        dataScrapeer.logEvents.addToLogger += new EventHandler(logEvents_Tweet_addToLogger);
                        lst_structTweetFollowersIDs = dataScrapeer.GetFollowers_New(keyword.Trim(), out ReturnStatus, ref globusHttpHelper);
                        dataScrapeer.logEvents.addToLogger -= new EventHandler(logEvents_Tweet_addToLogger);
                        AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Followers Scrapped ]");
                        //TwitterDataScrapper.logEvents.addToLogger -= new EventHandler(DataScraperlogger_addToLogger);

                        if (lst_structTweetFollowersIDs.Count > 0)
                        {
                            //listUserIDs.Clear();
                            //string item=Globals.Path_ScrapedFollowersList.Split(':')[0];
                            //if (Chk_IsFollowerUserId.Checked)
                            {
                                foreach (string item in lst_structTweetFollowersIDs)
                                {
                                    string userid = item.Split(':')[1];
                                    lst_mentionUser.Add(userid);
                                }
                            }

                            if (lst_structTweetFollowersIDs.Count > 0)
                            {
                                //listUserIDs.AddRange(lst_structTweetFollowersIDs);
                                AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Added " + lst_structTweetFollowersIDs.Count + " Followers from User: "******" ]");
                                AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Data Exported to " + Globals.Path_ScrapedFollowersList);
                            }

                        }
                        else if (ReturnStatus.Contains("Sorry, that page does not exist"))
                        {
                            AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Sorry, That User does not exist =>" + ReturnStatus.Split(':')[1] + " ]");
                            //continue;
                        }
                        else if (ReturnStatus == "Account is Suspended. ")
                        {
                            AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Account " + keyword + "  is Suspended. ]");
                        }
                        else if (ReturnStatus == "Error")
                        {
                            AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Rate Limit Exceeded.Please Try After Some Time ]");
                        }
                        else
                        {
                            AddToLog_Tweet("[ " + DateTime.Now + " ] => [ " + keyword + " does not have any Followers ]");
                        }
                    }
                    catch (Exception ex)
                    {
                        Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> btnScrapeUser_Click() -- chkboxScrapeFollowers.Checked --> " + ex.Message, Globals.Path_ScrapeUsersErroLog);
                        Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine("Error --> btnScrapeUser_Click() -- chkboxScrapeFollowers.Checked --> " + ex.Message, Globals.Path_TwtErrorLogs);
                    }
                }

                if (chkRetweetScrapFollowings.Checked)
                {
                    try
                    {
                        if (!File.Exists(Globals.Path_ScrapedFollowingsList))
                        {
                            GlobusFileHelper.AppendStringToTextfileNewLine("Name/Id , FollowersUserID , Followers User Name", Globals.Path_ScrapedFollowingsList);
                        }
                        string returnStaus = string.Empty;

                        dataScrapeer.logEvents.addToLogger += new EventHandler(logEvents_Tweet_addToLogger);
                        lst_structTweetFollowingsIds = dataScrapeer.GetFollowings_New(keyword.Trim(), out returnStaus, ref globusHttpHelper);
                        AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Following Scrapped ]");
                        if (lst_structTweetFollowingsIds.Count > 0)
                        {

                            //listUserIDs.Clear();
                            //if (Chk_IsFollowerUserId.Checked)
                            {
                                foreach (string item in lst_structTweetFollowingsIds)
                                {
                                    string userid = item.Split(':')[1];
                                    lst_mentionUser.Add(userid);
                                }
                            }

                            if (lst_structTweetFollowingsIds.Count > 0)
                            {

                                AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Added " + lst_structTweetFollowingsIds.Count + " Followings from User: "******" ]");
                                AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Data Exported to " + Globals.Path_ScrapedFollowingsList + " ]");

                            }

                        }
                        else if (ReturnStatus.Contains("Sorry, that page does not exist"))
                        {
                            AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Sorry, That User does not exist =>" + ReturnStatus.Split(':')[1] + " ]");
                            //continue;
                        }
                        else if (ReturnStatus == "Account is Suspended. ")
                        {
                            AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Account " + keyword + "  is Suspended. ]");
                        }
                        else if (ReturnStatus == "Error")
                        {
                            AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Rate Limit Exceeded.Please Try After Some Time ]");
                        }
                        else
                        {
                            AddToLog_Tweet("[ " + DateTime.Now + " ] => [ " + keyword + " User does not exist ]");
                        }
                    }
                    catch (Exception ex)
                    {
                        Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> btnScrapeKeyword_Click() -- lst_structTweetFollowingsIds foreach --> " + ex.Message, Globals.Path_ScrapeUsersErroLog);
                        Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine("Error --> btnScrapeKeyword_Click() -- lst_structTweetFollowingsIds foreach --> " + ex.Message, Globals.Path_TwtErrorLogs);
                    }
                }

            }
            catch (Exception)
            {

            }
            finally
            {
                IsStart_ScrapUser = true;
                dataScrapeer.logEvents.addToLogger -= new EventHandler(logEvents_Tweet_addToLogger);
            }
        }
Пример #11
0
        private void threadStartScrape()
        {
            TwitterDataScrapper dataScrapeer = new TwitterDataScrapper();
            try
            {
                List<string> lst_structTweetFollowersIDs = new List<string>();
                List<string> lst_structTweetFollowingsIds = new List<string>();
                GlobusHttpHelper globusHttpHelper = new GlobusHttpHelper();
                string user_id = string.Empty;
                int counter = 0;
                TweetAccountManager TweetLogin = new TweetAccountManager();
                string ReturnStatus = string.Empty;
                Globals.IsMobileVersion = true;
                if (!Globals.IsMobileVersion)
                {
                    foreach (KeyValuePair<string, TweetAccountManager> item in TweetAccountContainer.dictionary_TweetAccount)
                    {
                        if (counter > TweetAccountContainer.dictionary_TweetAccount.Count)
                        {
                            counter = 0;
                        }

                        TweetLogin = new TweetAccountManager();
                        TweetLogin.Username = item.Key;
                        TweetLogin.Password = item.Value.Password;
                        TweetLogin.proxyAddress = item.Value.proxyAddress;
                        TweetLogin.proxyPort = item.Value.proxyPort;
                        TweetLogin.proxyUsername = item.Value.proxyUsername;
                        TweetLogin.proxyPassword = item.Value.proxyPassword;
                        TweetLogin.Login();

                        if (!TweetLogin.IsLoggedIn)
                        {
                            continue;
                        }
                        else
                        {
                            globusHttpHelper = TweetLogin.globusHttpHelper;
                            counter++;
                            break;
                        }
                    }

                    if (!TweetLogin.IsLoggedIn)
                    {
                        AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Please Upload Atleast One Working Account To Get Details ]");
                        return;
                    }

                }

                foreach (string keyword in lstscrapeUsername)
                {

                    dataScrapeer.CounterDataNo = 500;

                    txtlimitScrapeUsers.Invoke(new MethodInvoker(delegate
                    {
                        if (!string.IsNullOrEmpty(txtlimitScrapeUsers.Text) && NumberHelper.ValidateNumber(txtlimitScrapeUsers.Text))
                        {
                            dataScrapeer.CounterDataNo = Convert.ToInt32(txtlimitScrapeUsers.Text);
                        }
                    }));

                    if (counter > TweetAccountContainer.dictionary_TweetAccount.Count)
                    {
                        counter = 0;
                    }

                    if (chkboxScrapeFollowers.Checked)
                    {
                        try
                        {
                            if (!File.Exists(Globals.Path_ScrapedFollowersList))
                            {
                               // GlobusFileHelper.AppendStringToTextfileNewLine("Name/Id , FollowersUserID , Followers User Name", Globals.Path_ScrapedFollowersList);
                                GlobusFileHelper.AppendStringToTextfileNewLine("Name/Id ,  Followers User Name", Globals.Path_ScrapedFollowersList);
                            }

                            try
                            {
                                dataScrapeer.logEvents.addToLogger += new EventHandler(DataScraperlogger_addToLogger);
                                if (!Globals.IsMobileVersion)
                                {
                                    lst_structTweetFollowersIDs = dataScrapeer.GetFollowers_New(keyword.Trim(), out ReturnStatus, ref globusHttpHelper);
                                }
                                else
                                {
                                    lst_structTweetFollowersIDs = dataScrapeer.GetFollowers_New_ForMobileVersion(keyword.Trim(), out ReturnStatus, ref globusHttpHelper);
                                }
                                dataScrapeer.logEvents.addToLogger -= new EventHandler(DataScraperlogger_addToLogger);
                            }
                            catch (Exception ex)
                            {

                            }
                            if (lst_structTweetFollowersIDs.Count > 0)
                            {
                                //AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Adding To DataBase and File ]");
                                //AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Added " + lst_structTweetFollowersIDs.Count + " Followers to list ]");

                                //foreach (string data in lst_structTweetFollowersIDs)
                                //{
                                //    try
                                //    {
                                //        string[] arr_data = data.Split(':');
                                //        Globals.lstScrapedUserIDs.Add(arr_data[0]);
                                //        GlobusFileHelper.AppendStringToTextfileNewLine(keyword + "," + arr_data[0] + "," + arr_data[1], Globals.Path_ScrapedFollowersList);
                                //    }
                                //    catch (Exception ex)
                                //    {
                                //        Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> btnScrapeKeyword_Click() -- lst_structTweetFollowersIDs foreach  --> " + ex.Message, Globals.Path_ScrapeUsersErroLog);
                                //        Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine("Error --> btnScrapeKeyword_Click() -- lst_structTweetFollowersIDs foreach --> " + ex.Message, Globals.Path_TwtErrorLogs);
                                //    }
                                //}

                                AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Added " + lst_structTweetFollowersIDs.Count + " Followers from User: "******" ]");
                                AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Data Exported to " + Globals.Path_ScrapedFollowersList);
                                if (Globals.IsDirectedFromFollower)
                                {
                                    AddToLog_Follower("[ " + DateTime.Now + " ] => [ Added " + lst_structTweetFollowersIDs.Count + " Followers from User: "******" ]");
                                    Thread.Sleep(1000);
                                }
                            }
                            else if (ReturnStatus.Contains("Sorry, that page does not exist"))
                            {
                                AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Sorry, That User does not exist =>" + ReturnStatus.Split(':')[1] + " ]");
                                continue;
                            }
                            else if (ReturnStatus == "Account is Suspended. ")
                            {
                                AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Account " + keyword + "  is Suspended. ]");
                            }
                            else if (ReturnStatus == "Error")
                            {
                                AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Rate Limit Exceeded.Please Try After Some Time ]");
                            }
                            else
                            {
                                AddToScrapeLogs("[ " + DateTime.Now + " ] => [ " + keyword + " User does not exist ]");
                            }
                        }
                        catch (Exception ex)
                        {
                            Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> btnScrapeUser_Click() -- chkboxScrapeFollowers.Checked --> " + ex.Message, Globals.Path_ScrapeUsersErroLog);
                            Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine("Error --> btnScrapeUser_Click() -- chkboxScrapeFollowers.Checked --> " + ex.Message, Globals.Path_TwtErrorLogs);
                        }
                    }

                    if (chkboxScrapeFollowings.Checked)
                    {
                        try
                        {
                            if (!File.Exists(Globals.Path_ScrapedFollowingsList))
                            {
                              //  GlobusFileHelper.AppendStringToTextfileNewLine("Name/Id , FollowingsUserID , Following User Name", Globals.Path_ScrapedFollowingsList);
                                GlobusFileHelper.AppendStringToTextfileNewLine("Name/Id , Following User Name", Globals.Path_ScrapedFollowingsList);

                            }
                            string returnStaus = string.Empty;
                            string Screen_name = string.Empty;
                            dataScrapeer.logEvents.addToLogger += new EventHandler(DataScraperlogger_addToLogger);
                           // GlobusHttpHelper globusHttpHelper1 = new GlobusHttpHelper();
                            if (!Globals.IsMobileVersion)
                            {
                                lst_structTweetFollowingsIds = dataScrapeer.GetFollowings_New(keyword.Trim(), out returnStaus, ref  globusHttpHelper);

                            }
                            else
                            {
                                lst_structTweetFollowingsIds = dataScrapeer.GetFollowings_NewForMobileVersion(keyword.Trim(), out returnStaus, ref  globusHttpHelper);
                            }

                            if (lst_structTweetFollowingsIds.Count > 0)
                            {

                                if (lst_structTweetFollowingsIds.Count > 0)
                                {

                                    AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Added " + lst_structTweetFollowingsIds.Count + " Followings from User: "******" ]");
                                    AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Data Exported to " + Globals.Path_ScrapedFollowingsList + " ]");
                                    if (Globals.IsDirectedFromFollower)
                                    {
                                        AddToLog_Follower("[ " + DateTime.Now + " ] => [ Added " + lst_structTweetFollowingsIds.Count + " Followings from User: "******" ]");
                                        Thread.Sleep(1000);
                                        //Tb_AccountManager.Invoke(new MethodInvoker(delegate
                                        //{
                                        //    Tb_AccountManager.SelectedIndex = 2;
                                        //}));
                                        //tabMain.SelectedIndex = 2;
                                    }
                                }
                                else if (returnStaus == "Error")
                                {
                                    AddToScrapeLogs("[ " + DateTime.Now + " ] => [ Rate Limit Exceeded.Please Try After Some Time ]");
                                    break;
                                }
                            }
                            else
                            {
                                AddToScrapeLogs("[ " + DateTime.Now + " ] => [ " + keyword + " User does not have any followings ]");
                            }
                        }
                        catch (Exception ex)
                        {
                            Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> btnScrapeKeyword_Click() -- lst_structTweetFollowingsIds foreach --> " + ex.Message, Globals.Path_ScrapeUsersErroLog);
                            Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine("Error --> btnScrapeKeyword_Click() -- lst_structTweetFollowingsIds foreach --> " + ex.Message, Globals.Path_TwtErrorLogs);
                        }
                    }

                    Globals.lstScrapedUserIDs = Globals.lstScrapedUserIDs.Distinct().ToList();
                }

                Globals.IsMobileVersion = false;
                new Thread(() =>
                {
                    try
                    {
                        List<string> temp = new List<string>();
                        foreach (string item in Globals.lstScrapedUserIDs)
                        {
                            temp.Add(item);
                        }

                        foreach (string data in temp)
                        {
                            try
                            {
                                clsDBQueryManager DataBase = new clsDBQueryManager();
                                DataBase.InsertOrUpdateScrapeSetting(data, "", "");
                            }
                            catch (Exception ex)
                            {
                                Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> lstScrapedUserIDs --> " + ex.Message, Globals.Path_ScrapeUsersErroLog);
                                Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine("Error --> lstScrapedUserIDs --> " + ex.Message, Globals.Path_TwtErrorLogs);
                            }
                        }
                    }
                    catch (Exception)
                    {
                    }

                }).Start();

                AddToScrapeLogs("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
                AddToScrapeLogs("------------------------------------------------------------------------------------------------------------------------------------------");

                //if (IsUserScrapedDatalist)
                //{
                //    Tb_AccountManager.Invoke(new MethodInvoker(delegate
                //    {
                //        Tb_AccountManager.SelectedIndex = 0;
                //        //Tb_AccountManager.SelectedTab.Name = "tabFollower";
                //    }));
                //}
            }
            catch (Exception)
            {

            }
            finally
            {
                IsStart_ScrapUser = true;
                dataScrapeer.logEvents.addToLogger -= new EventHandler(DataScraperlogger_addToLogger);
            }
        }
Пример #12
0
        private void StartFollowingMultithreaded(object parameters)
        {
            TweetAccountManager tweetAccountManager = new TweetAccountManager();
            try
            {
                Array paramsArray = new object[3];

                paramsArray = (Array)parameters;

                KeyValuePair<string, TweetAccountManager> keyValue = (KeyValuePair<string, TweetAccountManager>)paramsArray.GetValue(0);

                List<string> list_userIDsToFollow = (List<string>)paramsArray.GetValue(1);

                bool OtherUser = (bool)paramsArray.GetValue(2);
                int strMinDelay = (int)paramsArray.GetValue(3);
                int strMaxDelay = (int)paramsArray.GetValue(4);

                int intMinDelay = strMinDelay;
                int intMaxDelay = strMaxDelay;

                List<string> lstFollowers = new List<string>();
                List<string> lstFollowings = new List<string>();

                AddToLog_Follower("[ " + DateTime.Now + " ] => [ Starting Follower For Account : " + keyValue.Key + " ]");

                tweetAccountManager = keyValue.Value;
                TweetAccountManager.FileFollowUrlPath = txtPathUserIDs.Text.ToString();

                if (chkboxUseGroups.Checked)
                {
                    if (tweetAccountManager.GroupName != txtUseGroup.Text)
                    {
                        AddToLog_Follower("[ " + DateTime.Now + " ] => [ " + keyValue.Key + " Group Name Does Not Match ]");
                        return;
                    }
                }

                //Add to Threads Dictionary
                AddThreadToDictionary(strModule(Module.Follow), tweetAccountManager.Username);
                tweetAccountManager.follower.logEvents.addToLogger += new EventHandler(logEvents_Follower_addToLogger);
                tweetAccountManager.logEvents.addToLogger += logEvents_Follower_addToLogger;

                if (!tweetAccountManager.IsLoggedIn)
                {
                    tweetAccountManager.Login();
                }

                if (tweetAccountManager.AccountStatus == "Account Suspended")
                {
                    clsDBQueryManager database = new clsDBQueryManager();
                    database.UpdateSuspendedAcc(tweetAccountManager.Username);
                    return;
                }

                try
                {
                    AddToLog_Follower("[ " + DateTime.Now + " ] => [ " + list_userIDsToFollow.Count() + " user id in List ]");
                }
                catch (Exception)
                {
                }

                if (list_userIDsToFollow.Count > 0)
                {

                    tweetAccountManager.FollowUsingURLs(list_userIDsToFollow, intMinDelay, intMaxDelay, OtherUser);
                }
                else
                {
                    AddToLog_Follower("[ " + DateTime.Now + " ] => [ No ID's To Follow ]");
                }

                // tweetAccountManager.follower.logEvents.addToLogger -= logEvents_Follower_addToLogger;
                //tweetAccountManager.logEvents.addToLogger -= logEvents_Follower_addToLogger;
            }
            catch (Exception ex)
            {
                ErrorLogger.AddToErrorLogText(ex.Message);
                GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> StartFollowingMultithreaded() --> " + ex.Message, Globals.Path_FollowerErroLog);
                GlobusFileHelper.AppendStringToTextfileNewLine("Error --> StartFollowingMultithreaded() --> " + ex.Message, Globals.Path_TwtErrorLogs);
            }

            finally
            {
                counter_AccountFollwer--;
                //TweetAccountManager tweetAccountManager = new TweetAccountManager();
                tweetAccountManager.follower.logEvents.addToLogger -= new EventHandler(logEvents_Follower_addToLogger);
                tweetAccountManager.logEvents.addToLogger -= logEvents_Follower_addToLogger;

                if (counter_AccountFollwer == 0)
                {
                    if (btnStartFollowing.InvokeRequired)
                    {
                        btnStartFollowing.Invoke(new MethodInvoker(delegate
                        {
                            Globals.FollowerRunningText = string.Empty;
                            GlobusFileHelper.AppendStringToTextfileNewLine("Module Follow count Total: " + Globals.totalcountFollower , Globals.path_CountNoOfProcessDone);
                            AddToLog_Follower("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
                            AddToLog_Follower("---------------------------------------------------------------------------------------------------------------------------");

                        }));
                    }
                }
            }
        }
Пример #13
0
        private void  ThreadpoolMethod_Retweet(object parameters)
        {
            TweetAccountManager tweetAccountManager = new TweetAccountManager();
            TweetAccountManager objTweetAccountManager = new TweetAccountManager();
            try
            {
                Array paramsArray = new object[1];

                paramsArray = (Array)parameters;

                KeyValuePair<string, TweetAccountManager> keyValue = (KeyValuePair<string, TweetAccountManager>)paramsArray.GetValue(0);
                List<TwitterDataScrapper.StructTweetIDs> lst_DivideTweets = new List<TwitterDataScrapper.StructTweetIDs>();
                if (TweetAccountManager.IsRetweetDivideRetweet)
                {
                     lst_DivideTweets = (List<TwitterDataScrapper.StructTweetIDs>)paramsArray.GetValue(1);
                }
                tweetAccountManager = keyValue.Value;
                try
                 {
                    objTweetAccountManager.TweetAccountManager1(keyValue.Value.Username, keyValue.Value.Password);                  
                }
                catch { };

                AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Starting ReTweet For Account : " + keyValue.Key + " ]");

                //Add to Threads Dictionary
                AddThreadToDictionary(strModule(Module.Retweet), tweetAccountManager.Username);
                try
                {
                    //Thread.CurrentThread.Name = "ReTweet_" + tweetAccountManager.Username;
                    //Thread.CurrentThread.IsBackground = true;
                    //dictionary_Threads.Add("ReTweet_" + tweetAccountManager.Username, Thread.CurrentThread);
                    AddThreadToDictionary(strModule(Module.Retweet), tweetAccountManager.Username);
                }
                catch { }

                //Create logger Event for lof MSg's previous.
                //tweetAccountManager.logEvents.addToLogger += new EventHandler(logEvents_Tweet_addToLogger);
                //tweetAccountManager.tweeter.logEvents.addToLogger += logEvents_Tweet_addToLogger;

                objTweetAccountManager.logEvents.addToLogger += new EventHandler(logEvents_Tweet_addToLogger);
                //tweetAccountManager.logEvents.addToLogger += logEvents_Tweet_addToLogger;
                objTweetAccountManager.tweeter.logEvents.addToLogger += logEvents_Tweet_addToLogger;


                if (GlobusRegex.ValidateNumber(txtMinDelay_Tweet.Text))
                {
                    retweetMinDealy = Convert.ToInt32(txtMinDelay_Tweet.Text);
                }
                if (GlobusRegex.ValidateNumber(txtMaxDelay_Tweet.Text))
                {
                    retweetMaxDealy = Convert.ToInt32(txtMaxDelay_Tweet.Text);
                }

                if (chkboxRetweetPerDay.Checked)
                {
                    TweetAccountManager.RetweetPerDay = true;
                    if (!string.IsNullOrEmpty(txtMaximumNoRetweet.Text) && NumberHelper.ValidateNumber(txtMaximumNoRetweet.Text))
                    {
                        TweetAccountManager.NoOFRetweetPerDay = Convert.ToInt32(txtMaximumNoRetweet.Text);
                    }
                    else
                    {
                        TweetAccountManager.NoOFRetweetPerDay = 10;
                        AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Setting Maximum No Of ReTweets Per Day as 10 ]");
                    }

                    clsDBQueryManager DbQueryManager = new clsDBQueryManager();
                    DataSet Ds = DbQueryManager.SelectMessageData(keyValue.Key, "ReTweet");

                    int TodayReTweet = Ds.Tables["tb_MessageRecord"].Rows.Count;
                    tweetAccountManager.AlreadyRetweeted = TodayReTweet;

                    if (TodayReTweet >= TweetAccountManager.NoOFRetweetPerDay)
                    {
                        AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Already Retweeted " + tweetAccountManager.AlreadyRetweeted + " ]");
                        return;
                    }
                }

                if (chkCheckDatabaseInEvery2Minutes.Checked == true || chkAutoFavorite.Checked == true)
                {
                    while (true)
                    {
                        try
                        {
                            string count_tweet = string.Empty;
                            string count_tweet1 = string.Empty;

                            TwitterDataScrapper tweetScrapper = new TwitterDataScrapper();
                            TwitterDataScrapper.StructTweetIDs item1 = new TwitterDataScrapper.StructTweetIDs();
                            TweetAccountManager.que_lst_Struct_TweetData.Clear();
                            Queue<TwitterDataScrapper.StructTweetIDs> tempQueue = new Queue<TwitterDataScrapper.StructTweetIDs>();
                            TwitterDataScrapper.noOfRecords = 1;
                            AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Searching tweets for  " + keyValue.Key + " ]");
                            //count_tweet = tweetScrapper.countNoOfTweet(txtTweetKeyword.Text.Trim());
                            #region sonu commented code
                        //    List<string> twtKeyword = GlobusFileHelper.ReadFiletoStringList(txtTweetKeyword.Text);

                        //startAgain:
                        //    foreach (string keyword in twtKeyword)
                        //    {
                        //        count_tweet = tweetScrapper.countNoOfTweet(keyword);

                        //        //count_tweet = tweetScrapper.countNoOfTweet(GlobusFileHelper.ReadFiletoStringList);
                        //    #endregion



                        //        TweetAccountManager.static_lst_Struct_TweetData = tweetScrapper.TweetExtractor_ByUserName_New_New(keyword);

                        //        int count = TweetAccountContainer.dictionary_TweetAccount.Count();
                        //        foreach (TwitterDataScrapper.StructTweetIDs item in TweetAccountManager.static_lst_Struct_TweetData)
                        //        {
                        //            //for (int i = 1; i <= count * TweetAccountManager.static_lst_Struct_TweetData.Count(); i++)
                        //            {
                        //                TweetAccountManager.que_lst_Struct_TweetData.Enqueue(item);
                        //                tempQueue.Enqueue(item);
                        //            }

                        //        }
                        //        try
                        //        {
                        //            if (TweetAccountManager.que_lst_Struct_TweetData.Count > 0)
                        //            {
                        //                item1 = tempQueue.Dequeue();
                        //            }
                        //        }
                        //        catch (Exception ex)
                        //        {
                        //            ErrorLogger.AddToErrorLogText(ex.Message);
                        //            GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TweetingErroLog);
                        //            GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TwtErrorLogs);
                        //        }

                        //        try
                        //        {
                        //            clsDBQueryManager DbQueryManager = new clsDBQueryManager();
                        //            DataSet Ds = DbQueryManager.SelectMessageDataForRetweet(keyValue.Key, item1.ID_Tweet, "ReTweet");
                        //            int count_NO_RoWs = Ds.Tables[0].Rows.Count;
                        //            if (count_NO_RoWs == 0)
                        //            {
                        //                if (chkCheckDatabaseInEvery2Minutes.Checked)
                        //                {
                        //                    tweetAccountManager.ReTweet("", retweetMinDealy, retweetMaxDealy);
                        //                }
                        //                if (chkAutoFavorite.Checked && tweetAccountManager.IsNotSuspended && tweetAccountManager.IsLoggedIn)
                        //                {
                        //                    string TUri = item1.ID_Tweet.ToString();
                        //                    AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Added To Favorite : " + TUri + " from " + tweetAccountManager.Username + " ]");
                        //                    FavoriteOfUrl(new object[] { TUri, keyValue, tweetAccountManager });
                        //                }
                        //            }

                        //            //AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Searching new tweets will start after 3 minutes from " + tweetAccountManager.Username + " ]");
                        //            //Thread.Sleep(3 * 60 * 1000);
                        //            count_tweet1 = tweetScrapper.countNoOfTweet(keyword);
                        //            if (Convert.ToInt32(count_tweet) == Convert.ToInt32(count_tweet1))
                        //            {
                        //                TwitterDataScrapper.noOfRecords = 1;
                        //            }
                        //            else if (Convert.ToInt32(count_tweet1) > Convert.ToInt32(count_tweet))
                        //            {
                        //                TwitterDataScrapper.noOfRecords = Convert.ToInt32(count_tweet1) - Convert.ToInt32(count_tweet);
                        //            }
                        //            else
                        //            {
                        //                TwitterDataScrapper.noOfRecords = 1;
                        //            }
                        //            TweetAccountManager.static_lst_Struct_TweetData.Clear();
                        //            TweetAccountManager.que_lst_Struct_TweetData.Clear();
                        //            tempQueue.Clear();
                        //            count_tweet = count_tweet1;
                        //        }
                        //        catch (Exception ex)
                        //        {
                        //            ErrorLogger.AddToErrorLogText(ex.Message);
                        //            GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TweetingErroLog);
                        //            GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TwtErrorLogs);
                        //        }
                        //        //goto startAgain;
                        //    }
                        //    AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Searching new tweets will start after 3 minutes from " + tweetAccountManager.Username + " ]");
                        //    Thread.Sleep(3 * 60 * 1000);
                        //    goto startAgain;
                            #endregion


                            #region sonu edited
                            List<string> twtKeyword = GlobusFileHelper.ReadFiletoStringList(txtTweetKeyword.Text);
                        //  TweetAccountManager objTweetAccountManager = new TweetAccountManager();
                        startAgain:
                            try
                            {

                                // foreach (string keyword in twtKeyword)
                                //  {
                                //    count_tweet = tweetScrapper.countNoOfTweet(keyword);

                                //count_tweet = tweetScrapper.countNoOfTweet(GlobusFileHelper.ReadFiletoStringList);
                            #endregion



                                //  TweetAccountManager.static_lst_Struct_TweetData = tweetScrapper.TweetExtractor_ByUserName_New_New(keyword);
                                try
                                {
                                    int count = TweetAccountContainer.dictionary_TweetAccount.Count();
                                }
                                catch { };
                                //  TweetAccountManager.que_lst_Struct_TweetData.Clear();

                                // que_lst_Struct_TweetData1
                                List<TwitterDataScrapper.StructTweetIDs> static_lst_Struct_TweetData12 = TweetAccountManager.static_lst_Struct_TweetData;
                                foreach (TwitterDataScrapper.StructTweetIDs item in static_lst_Struct_TweetData12)
                                {
                                    //for (int i = 1; i <= count * TweetAccountManager.static_lst_Struct_TweetData.Count(); i++)
                                    {
                                        try
                                        {
                                            objTweetAccountManager.que_lst_Struct_TweetData1.Enqueue(item);
                                            TweetAccountManager.que_lst_Struct_TweetData.Enqueue(item);
                                            tempQueue.Enqueue(item);
                                        }
                                        catch { };
                                    }

                                }
                                try
                                {
                                    if (objTweetAccountManager.que_lst_Struct_TweetData1.Count > 0)
                                    {
                                        Queue<TwitterDataScrapper.StructTweetIDs> que_lst_Struct_TweetData12 = new Queue<TwitterDataScrapper.StructTweetIDs>();
                                        que_lst_Struct_TweetData12.Clear();
                                        foreach (TwitterDataScrapper.StructTweetIDs item in objTweetAccountManager.que_lst_Struct_TweetData1)
                                        {
                                            item1 = item;
                                            clsDBQueryManager DbQueryManager = new clsDBQueryManager();
                                            DataSet Ds = DbQueryManager.SelectMessageDataForRetweet(keyValue.Key, item1.ID_Tweet, "ReTweet");
                                            int count_NO_RoWs = Ds.Tables[0].Rows.Count;
                                            if (count_NO_RoWs == 0)
                                            {
                                                que_lst_Struct_TweetData12.Enqueue(item);
                                            }

                                        }
                                        try
                                        {
                                            objTweetAccountManager.que_lst_Struct_TweetData1.Clear();
                                            objTweetAccountManager.que_lst_Struct_TweetData1 = que_lst_Struct_TweetData12;
                                        }
                                        catch { };
                                    }
                                }
                                catch (Exception ex)
                                {
                                    ErrorLogger.AddToErrorLogText(ex.Message);
                                    GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TweetingErroLog);
                                    GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TwtErrorLogs);
                                }

                                try
                                {
                                    clsDBQueryManager DbQueryManager = new clsDBQueryManager();
                                    DataSet Ds = DbQueryManager.SelectMessageDataForRetweet(keyValue.Key, item1.ID_Tweet, "ReTweet");
                                    int count_NO_RoWs = Ds.Tables[0].Rows.Count;
                                    if (objTweetAccountManager.que_lst_Struct_TweetData1.Count > 0)
                                    {
                                        //if (chkCheckDatabaseInEvery2Minutes.Checked)
                                        //{
                                        //    try
                                        //    {
                                        //        objTweetAccountManager.ReTweet1(ref objTweetAccountManager, retweetMinDealy, retweetMaxDealy);
                                        //    }
                                        //    catch { };
                                        //}
                                        //if (chkAutoFavorite.Checked && tweetAccountManager.IsNotSuspended && tweetAccountManager.IsLoggedIn)
                                        //{
                                        //    string TUri = item1.ID_Tweet.ToString();
                                        //    AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Added To Favorite : " + TUri + " from " + tweetAccountManager.Username + " ]");
                                        //    FavoriteOfUrl(new object[] { TUri, keyValue, tweetAccountManager });
                                        //}


                                        if (chkCheckDatabaseInEvery2Minutes.Checked)
                                        {
                                            try
                                            {
                                                objTweetAccountManager.ReTweet1(ref objTweetAccountManager, retweetMinDealy, retweetMaxDealy);
                                            }
                                            catch { };
                                        }
                                        if (chkAutoFavorite.Checked && tweetAccountManager.IsNotSuspended && tweetAccountManager.IsLoggedIn)
                                        {
                                            string TUri = item1.ID_Tweet.ToString();
                                            AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Added To Favorite : " + TUri + " from " + tweetAccountManager.Username + " ]");
                                            FavoriteOfUrl(new object[] { TUri, keyValue, tweetAccountManager });
                                        }
                                        else if (chkAutoFavorite.Checked)
                                        {
                                            tweetAccountManager.Login();
                                            if (tweetAccountManager.IsLoggedIn)
                                            {
                                                string TUri = item1.ID_Tweet.ToString();
                                                AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Added To Favorite : " + TUri + " from " + tweetAccountManager.Username + " ]");
                                                FavoriteOfUrl(new object[] { TUri, keyValue, tweetAccountManager });
                                            }

                                        }
                                    }

                                    // AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Searching new tweets will start after 3 minutes from " + tweetAccountManager.Username + " ]");
                                    //Thread.Sleep(2 * 60 * 1000);
                                    //count_tweet1 = tweetScrapper.countNoOfTweet(txtTweetKeyword.Text.Trim());
                                    //  count_tweet1 = tweetScrapper.countNoOfTweet(keyword);
                                    try
                                    {
                                        if (Convert.ToInt32(count_tweet) == Convert.ToInt32(count_tweet1))
                                        {
                                            TwitterDataScrapper.noOfRecords = 1;
                                        }
                                        else if (Convert.ToInt32(count_tweet1) > Convert.ToInt32(count_tweet))
                                        {
                                            TwitterDataScrapper.noOfRecords = Convert.ToInt32(count_tweet1) - Convert.ToInt32(count_tweet);
                                        }
                                        else
                                        {
                                            TwitterDataScrapper.noOfRecords = 1;
                                        }
                                    }
                                    catch { };
                                    // TweetAccountManager.static_lst_Struct_TweetData.Clear();
                                    // TweetAccountManager.que_lst_Struct_TweetData.Clear();
                                    try
                                    {
                                        objTweetAccountManager.que_lst_Struct_TweetData1.Clear();
                                        tempQueue.Clear();
                                        count_tweet = count_tweet1;
                                    }
                                    catch { };
                                }
                                catch (Exception ex)
                                {
                                    ErrorLogger.AddToErrorLogText(ex.Message);
                                    GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TweetingErroLog);
                                    GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TwtErrorLogs);
                                }

                                //  }
                                //   AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Searching new tweets will start after 3 minutes from " + tweetAccountManager.Username + " ]");
                                AddToLog_Tweet("[ " + DateTime.Now + " ] => [Delay For Account - " + tweetAccountManager.Username + " 2 Minutes ]");
                                Thread.Sleep(2 * 60 * 1000);
                            }
                            catch { };
                            goto startAgain;




                        }
                        catch (Exception ex)
                        {
                            ErrorLogger.AddToErrorLogText(ex.Message);
                            GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TweetingErroLog);
                            GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TwtErrorLogs);
                        }
                    
                    }
                }
                else
                {

                    if (TweetAccountManager.IsRetweetDivideRetweet)
                    {
                        tweetAccountManager.ReTweetDivideRetweet(lst_DivideTweets, retweetMinDealy, retweetMaxDealy);
                    }
                    else
                    {
                        tweetAccountManager.ReTweet("", retweetMinDealy, retweetMaxDealy);
                    }
                }

                tweetAccountManager.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
                tweetAccountManager.tweeter.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
            }
            catch (Exception ex)
            {
                ErrorLogger.AddToErrorLogText(ex.Message);
                GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TweetingErroLog);
                GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TwtErrorLogs);
            }

            finally
            {
                tweetAccountManager.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
                tweetAccountManager.tweeter.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
            }
        }