Пример #1
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;
            }
        }