private void ThreadPoolMethod_Reply(object parameters)
{
try
{
Array paramsArray = new object[2];
paramsArray = (Array)parameters;
KeyValuePair<string, TweetAccountManager> keyValue = (KeyValuePair<string, TweetAccountManager>)paramsArray.GetValue(0);
string tweetMessage = (string)paramsArray.GetValue(1);
TweetAccountManager tweetAccountManager = keyValue.Value;
//Add to Threads Dictionary
AddThreadToDictionary(strModule(Module.Reply), tweetAccountManager.Username);
//string accountUser = tweetAccountManager.Username;
//string accountPass = tweetAccountManager.Password;
//string proxyAddress = tweetAccountManager.proxyAddress;
//string proxyPort = tweetAccountManager.proxyPort;
//string proxyUserName = tweetAccountManager.proxyUsername;
//string proxyPassword = tweetAccountManager.proxyPassword;
//tweetAccountManager = new TweetAccountManager();
//tweetAccountManager.Username = accountUser;
//tweetAccountManager.Password = accountPass;
//tweetAccountManager.proxyAddress = proxyAddress;
//tweetAccountManager.proxyPort = proxyPort;
//tweetAccountManager.proxyUsername = proxyUserName;
//tweetAccountManager.proxyPassword = proxyPassword;
tweetAccountManager.logEvents.addToLogger += new EventHandler(logEvents_Tweet_addToLogger);
//tweetAccountManager.logEvents.addToLogger += logEvents_Tweet_addToLogger;
tweetAccountManager.tweeter.logEvents.addToLogger += logEvents_Tweet_addToLogger;
if (GlobusRegex.ValidateNumber(txtMinDelay_Tweet.Text))
{
replyMinDealy = Convert.ToInt32(txtMinDelay_Tweet.Text);
}
if (GlobusRegex.ValidateNumber(txtMaxDelay_Tweet.Text))
{
replyMaxDealy = Convert.ToInt32(txtMaxDelay_Tweet.Text);
}
if (chkboxReplyPerDay.Checked)
{
TweetAccountManager.ReplyPerDay = true;
if (!string.IsNullOrEmpty(txtMaximumNoRetweet.Text) && NumberHelper.ValidateNumber(txtMaximumNoRetweet.Text))
{
TweetAccountManager.NoOFReplyPerDay = Convert.ToInt32(txtMaximumNoRetweet.Text);
}
else
{
TweetAccountManager.NoOFReplyPerDay = 10;
AddToTweetCreatorLogs("Adding Default Maximum No Of Retweet 10");
}
clsDBQueryManager DbQueryManager = new clsDBQueryManager();
DataSet Ds = DbQueryManager.SelectMessageData(keyValue.Key, "Reply");
int TodayReply = Ds.Tables["tb_MessageRecord"].Rows.Count;
tweetAccountManager.AlreadyReply = TodayReply;
if (TodayReply >= TweetAccountManager.NoOFReplyPerDay)
{
AddToLog_Tweet("Already Retweeted " + TodayReply);
return;
}
}
tweetAccountManager.Reply(tweetMessage, replyMinDealy, replyMaxDealy);
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_Reply() --> " + ex.Message, Globals.Path_TweetingErroLog);
GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ThreadPoolMethod_Reply() --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
}
public void StartDirectMessagingMultithreaded(object parameter)
{
try
{
int MinimumDelay = 15;
int MaximumDelay = 25;
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
KeyValuePair<string, TweetAccountManager> item = (KeyValuePair<string, TweetAccountManager>)paramsArray.GetValue(0);
TweetAccountManager AccountManager = item.Value;
AccountManager.Username = item.Value.Username;
AccountManager.Password = item.Value.Password;
AccountManager.proxyAddress = item.Value.proxyAddress;
AccountManager.proxyPort = item.Value.proxyPort;
AccountManager.proxyUsername = item.Value.proxyUsername;
AccountManager.proxyPassword = item.Value.proxyPassword;
if (!AccountManager.IsLoggedIn)
{
AccountManager.Login();
}
List<string> SelectedItem = new List<string>();
if (chklstDirectMessage.InvokeRequired)
{
chklstDirectMessage.Invoke(new MethodInvoker(delegate
{
foreach (string Userid in chklstDirectMessage.CheckedItems)
{
SelectedItem.Add(Userid);
}
}));
}
int MaximumMsgPerDay = 10;
if (!string.IsNullOrEmpty(txtMessagePerDay.Text) && NumberHelper.ValidateNumber(txtMessagePerDay.Text))
{
MaximumMsgPerDay = Convert.ToInt32(txtMessagePerDay.Text);
}
clsDBQueryManager DbQueryManager = new clsDBQueryManager();
DataSet Ds = DbQueryManager.SelectMessageData(item.Value.Username, "Message");
int TodayMessage = Ds.Tables["tb_MessageRecord"].Rows.Count;
AddToLog_Tweet(TodayMessage + " Already Messaged today");
#region Delay
if (!string.IsNullOrEmpty(txtMinDMDelay.Text) && NumberHelper.ValidateNumber(txtMinDMDelay.Text))
{
MinimumDelay = Convert.ToInt32(txtMinDMDelay.Text);
}
else
{
AddToDMLog("Minimum Delay Value Incorrect");
AddToDMLog("Assinging Defauly Value = 15");
}
if (!string.IsNullOrEmpty(txtMaxDMDelay.Text) && NumberHelper.ValidateNumber(txtMaxDMDelay.Text))
{
MaximumDelay = Convert.ToInt32(txtMaxDMDelay.Text);
}
else
{
AddToDMLog("Minimum Delay Value Incorrect");
AddToDMLog("Assinging Defauly Value = 25");
}
#endregion
foreach (string Userid in SelectedItem)
{
if (TodayMessage >= MaximumMsgPerDay)
{
AddToDMLog("Already Messaged " + TodayMessage);
break;
}
AddToDMLog("Direct Message To " + Userid);
int Delay = RandomNumberGenerator.GenerateRandom(MinimumDelay, MaximumDelay);
string MessagePosted = AccountManager.DirectMessage(Userid);
if (MessagePosted.Contains("Success"))
{
string[] Array = Regex.Split(MessagePosted, ":");
AddToDMLog("Message Posted :"+ Array[1]);
}
else if (MessagePosted.Contains("Error"))
{
AddToDMLog("Error in Post");
}
else
{
AddToDMLog("Message Not Posted");
}
AddToDMLog("Delay For : " + Delay);
Thread.Sleep(Delay);
TodayMessage++;
}
}
catch (Exception ex)
{
Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> StartDirectMessagingMultithreaded() --> " + ex.Message, Globals.Path_DMErroLog);
Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine("Error --> StartDirectMessagingMultithreaded() --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
}
private void StartTweetingMultithreaded(object parameters)
{
try
{
Array paramsArray = new object[2];
paramsArray = (Array)parameters;
KeyValuePair<string, TweetAccountManager> keyValue = (KeyValuePair<string, TweetAccountManager>)paramsArray.GetValue(0);
//string userIDToFollow = (string)paramsArray.GetValue(1);
//string tweetMessage = (string)paramsArray.GetValue(1);
List<string> lst_tweetMessage = (List<string>)paramsArray.GetValue(1);
TweetAccountManager tweetAccountManager = keyValue.Value;
//Add to Threads Dictionary
AddThreadToDictionary(strModule(Module.Tweet), tweetAccountManager.Username);
//string accountUser = tweetAccountManager.Username;
//string accountPass = tweetAccountManager.Password;
//string proxyAddress = tweetAccountManager.proxyAddress;
//string proxyPort = tweetAccountManager.proxyPort;
//string proxyUserName = tweetAccountManager.proxyUsername;
//string proxyPassword = tweetAccountManager.proxyPassword;
//tweetAccountManager = new TweetAccountManager();
//tweetAccountManager.Username = accountUser;
//tweetAccountManager.Password = accountPass;
//tweetAccountManager.proxyAddress = proxyAddress;
//tweetAccountManager.proxyPort = proxyPort;
//tweetAccountManager.proxyUsername = proxyUserName;
//tweetAccountManager.proxyPassword = proxyPassword;
tweetAccountManager.tweeter.logEvents.addToLogger += new EventHandler(logEvents_Tweet_addToLogger);
tweetAccountManager.logEvents.addToLogger += logEvents_Tweet_addToLogger;
if (GlobusRegex.ValidateNumber(txtMinDelay_Tweet.Text))
{
tweetMinDealy = Convert.ToInt32(txtMinDelay_Tweet.Text);
}
if (GlobusRegex.ValidateNumber(txtMaxDelay_Tweet.Text))
{
tweetMaxDealy = Convert.ToInt32(txtMaxDelay_Tweet.Text);
}
//tweetAccountManager.Login();
//tweetAccountManager.Tweet(tweetMessage);
if (ChkboxTweetPerday.Checked)
{
TweetAccountManager.NoOfTweets = 0;
TweetAccountManager.TweetPerDay = true;
if (!string.IsNullOrEmpty(txtMaximumTweet.Text) && NumberHelper.ValidateNumber(txtMaximumTweet.Text))
{
TweetAccountManager.NoOfTweetPerDay = Convert.ToInt32(txtMaximumTweet.Text);
AddToLog_Tweet(TweetAccountManager.NoOfTweetPerDay + " Maximum No Of Tweets Per Day");
}
else
{
TweetAccountManager.NoOfTweetPerDay = 10;
AddToLog_Tweet("Setting Maximum No Of Tweets Per Day as 10");
}
clsDBQueryManager DbQueryManager = new clsDBQueryManager();
DataSet Ds = DbQueryManager.SelectMessageData(keyValue.Key, "Tweet");
int TodayTweet = Ds.Tables["tb_MessageRecord"].Rows.Count;
tweetAccountManager.AlreadyTweeted = TodayTweet;
AddToLog_Tweet(TodayTweet + " Already tweeted today");
if (TodayTweet >= TweetAccountManager.NoOfTweetPerDay)
{
AddToLog_Tweet("Already Tweeted " + TweetAccountManager.NoOfTweetPerDay);
return;
}
}
if (IsTweetScheduled)
{
try
{
DateTime d1 = dateTimePicker_tweeterStart.Value.ToLocalTime();
DateTime d2 = dateTimePicker_TwetterEnd.Value.ToLocalTime();
TweetAccountManager.StartTime = d1;
TweetAccountManager.EndTime = d2;
TimeSpan T = d2 - d1;
int Delay = T.Minutes;
int TotalTweets = 0;
if (!string.IsNullOrEmpty(txtNoOfTweets.Text) && NumberHelper.ValidateNumber(txtNoOfTweets.Text))
{
TotalTweets = Convert.ToInt32(txtNoOfTweets.Text);
}
else
{
TotalTweets = TweetAccountManager.NoOfTweetPerDay - tweetAccountManager.AlreadyTweeted;
}
int TotalDelay = (Delay * 60) / TotalTweets;
TweetAccountManager.DelayTweet = TotalDelay;
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> StartTweetingMultithreaded() -- Tweet Scheduled --> " + ex.Message, Globals.Path_TweetingErroLog);
GlobusFileHelper.AppendStringToTextfileNewLine("Error --> StartTweetingMultithreaded() -- TweetScheduled --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
}
tweetAccountManager.Tweet(lst_tweetMessage, tweetMinDealy, tweetMaxDealy);
tweetAccountManager.tweeter.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
tweetAccountManager.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
}
catch (Exception ex)
{
ErrorLogger.AddToErrorLogText(ex.Message);
GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> StartTweetingMultithreaded() --> " + ex.Message, Globals.Path_TweetingErroLog);
GlobusFileHelper.AppendStringToTextfileNewLine("Error --> StartTweetingMultithreaded() --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
}
private void ThreadpoolMethod_Retweet(object parameters)
{
try
{
Thread.CurrentThread.IsBackground = true;
Array paramsArray = new object[1];
paramsArray = (Array)parameters;
KeyValuePair<string, TweetAccountManager> keyValue = (KeyValuePair<string, TweetAccountManager>)paramsArray.GetValue(0);
TweetAccountManager tweetAccountManager = keyValue.Value;
if(chkBoxUseGroup.Checked && !string.IsNullOrEmpty(txtTweetUseGroup.Text))
{
if(tweetAccountManager.GroupName != txtTweetUseGroup.Text)
{
return;
}
}
else
{
AddToLog_Tweet("Please Enter A Tweet Keyword");
}
//Add to Threads Dictionary
AddThreadToDictionary(strModule(Module.Retweet), tweetAccountManager.Username);
//string accountUser = tweetAccountManager.Username;
//string accountPass = tweetAccountManager.Password;
//string proxyAddress = tweetAccountManager.proxyAddress;
//string proxyPort = tweetAccountManager.proxyPort;
//string proxyUserName = tweetAccountManager.proxyUsername;
//string proxyPassword = tweetAccountManager.proxyPassword;
//tweetAccountManager = new TweetAccountManager();
//tweetAccountManager.Username = accountUser;
//tweetAccountManager.Password = accountPass;
//tweetAccountManager.proxyAddress = proxyAddress;
//tweetAccountManager.proxyPort = proxyPort;
//tweetAccountManager.proxyUsername = proxyUserName;
//tweetAccountManager.proxyPassword = proxyPassword;
tweetAccountManager.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
tweetAccountManager.tweeter.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
tweetAccountManager.logEvents.addToLogger += new EventHandler(logEvents_Tweet_addToLogger);
//tweetAccountManager.logEvents.addToLogger += logEvents_Tweet_addToLogger;
tweetAccountManager.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);
AddToLog_Tweet("Maximum No Of ReTweet Per day " + TweetAccountManager.NoOFRetweetPerDay);
}
else
{
TweetAccountManager.NoOFRetweetPerDay = 10;
AddToLog_Tweet("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("Already Retweeted " + tweetAccountManager.AlreadyRetweeted + " For UserName : "******"", 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);
}
}
private void ThreadpoolMethod_Retweet(object parameters)
{
TweetAccountManager tweetAccountManager = 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;
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 .
tweetAccountManager.logEvents.addToLogger += new EventHandler(logEvents_Tweet_addToLogger);
//tweetAccountManager.logEvents.addToLogger += logEvents_Tweet_addToLogger;
tweetAccountManager.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());
startAgain:
TweetAccountManager.static_lst_Struct_TweetData = tweetScrapper.TweetExtractor_ByUserName_New_New(txtTweetKeyword.Text.Trim());
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(txtTweetKeyword.Text.Trim());
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;
}
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;
}
}
private void ThreadPoolMethod_Reply(object parameters)
{
try
{
Array paramsArray = new object[2];
paramsArray = (Array)parameters;
TweetAccountManager keyValue = (TweetAccountManager)paramsArray.GetValue(0);
TweetAccountManager tweetAccountManager = keyValue;//keyValue.Value;
//try
//{
// dictionary_Threads.Add(tweetAccountManager.Username, Thread.CurrentThread);
//}
//catch { };
//Add to Threads Dictionary
AddThreadToDictionary(strModule(Module.Reply), tweetAccountManager.Username);
tweetAccountManager.logEvents.addToLogger += new EventHandler(logEvents_Tweet_addToLogger);
//tweetAccountManager.logEvents.addToLogger += logEvents_Tweet_addToLogger;
tweetAccountManager.tweeter.logEvents.addToLogger += logEvents_Tweet_addToLogger;
if (GlobusRegex.ValidateNumber(txtMinDelay_Tweet.Text))
{
replyMinDealy = Convert.ToInt32(txtMinDelay_Tweet.Text);
}
if (GlobusRegex.ValidateNumber(txtMaxDelay_Tweet.Text))
{
replyMaxDealy = Convert.ToInt32(txtMaxDelay_Tweet.Text);
}
if (chkboxReplyPerDay.Checked)
{
TweetAccountManager.ReplyPerDay = true;
if (!string.IsNullOrEmpty(txtMaximumNoRetweet.Text) && NumberHelper.ValidateNumber(txtMaximumNoRetweet.Text))
{
TweetAccountManager.NoOFReplyPerDay = Convert.ToInt32(txtMaximumNoRetweet.Text);
}
else
{
TweetAccountManager.NoOFReplyPerDay = 10;
AddToTweetCreatorLogs("[ " + DateTime.Now + " ] => [ Adding Default Maximum No Of Retweet 10 ]");
}
clsDBQueryManager DbQueryManager = new clsDBQueryManager();
DataSet Ds = DbQueryManager.SelectMessageData(keyValue.Username, "Reply");
int TodayReply = Ds.Tables["tb_MessageRecord"].Rows.Count;
tweetAccountManager.AlreadyReply = TodayReply;
if (TodayReply >= TweetAccountManager.NoOFReplyPerDay)
{
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Already Replied " + TodayReply + " ]");
return;
}
}
if (chkCheckDatabaseInEvery2Minutes.Checked == true)
{
while (true)
{
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.Username + " ]");
TweetAccountManager.static_lst_Struct_TweetData = tweetScrapper.TweetExtractor_ByUserName_New_New(txtTweetKeyword.Text.Trim());
int count = TweetAccountContainer.dictionary_TweetAccount.Count();
foreach (TwitterDataScrapper.StructTweetIDs item in TweetAccountManager.static_lst_Struct_TweetData)
{
for (int i = 1; i <= count; i++)
{
TweetAccountManager.que_lst_Struct_TweetData.Enqueue(item);
tempQueue.Enqueue(item);
}
}
if (TweetAccountManager.que_lst_Struct_TweetData.Count > 0)
{
item1 = tempQueue.Dequeue();
}
clsDBQueryManager DbQueryManager = new clsDBQueryManager();
DataSet Ds = DbQueryManager.SelectMessageDataForRetweet(keyValue.Username, item1.ID_Tweet, "Reply");
int count_NO_RoWs = Ds.Tables[0].Rows.Count;
if (count_NO_RoWs == 0)
{
tweetAccountManager.Reply(listTweetMessages, replyMinDealy, replyMaxDealy);
}
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Search tweets after 3 minutes ");
Thread.Sleep(3 * 60 * 1000);
}
}
else
{
tweetAccountManager.Reply("", replyMinDealy, replyMaxDealy);
}
tweetAccountManager.Reply("", replyMinDealy, replyMaxDealy);
//tweetAccountManager.getmentions();
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_Reply() --> " + ex.Message, Globals.Path_TweetingErroLog);
GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ThreadPoolMethod_Reply() --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
finally
{
counter_AccountFollwer--;
if (counter_AccountFollwer == 0)
{
if (btnStartFollowing.InvokeRequired)
{
btnStartReplying.Invoke(new MethodInvoker(delegate
{
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddToLog_Tweet("---------------------------------------------------------------------------------------------------------------------------");
}));
}
}
}
}
private void StartTweetingMultithreaded(object parameters)
{
Interlocked.Increment(ref countTweetMessageAccount);
TweetAccountManager tweetAccountManager = new TweetAccountManager();
try
{
Array paramsArray = new object[2];
paramsArray = (Array)parameters;
KeyValuePair<string, TweetAccountManager> keyValue = (KeyValuePair<string, TweetAccountManager>)paramsArray.GetValue(0);
//string userIDToFollow = (string)paramsArray.GetValue(1);
//string tweetMessage = (string)paramsArray.GetValue(1);
List<string> lst_tweetMessage = (List<string>)paramsArray.GetValue(1);
//TweetAccountManager tweetAccountManager = keyValue.Value;
tweetAccountManager = keyValue.Value;
try
{
Thread.CurrentThread.Name = "Tweet_" + tweetAccountManager.Username;
Thread.CurrentThread.IsBackground = true;
dictionary_Threads.Add("Tweet_" + tweetAccountManager.Username, Thread.CurrentThread);
}
catch { }
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Starting Tweet For Account :" + keyValue.Key + " ]");
if (IsTweetScheduled)
{
try
{
DateTime d1 = dateTimePicker_tweeterStart.Value;
DateTime d2 = dateTimePicker_TwetterEnd.Value;
TimeSpan t = d2 - DateTime.Now;
if (t.TotalSeconds <= 0)
{
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Time Already Completed Stopping For Account : " + tweetAccountManager.Username + " ]");
return;
}
TweetAccountManager.StartTime = d1;
TweetAccountManager.EndTime = d2;
TimeSpan T = d2 - d1;
int Delay = T.Minutes;
int TotalTweets = 0;
if (!string.IsNullOrEmpty(txtNoOfTweets.Text) && NumberHelper.ValidateNumber(txtNoOfTweets.Text))
{
TotalTweets = Convert.ToInt32(txtNoOfTweets.Text);
}
else
{
TotalTweets = TweetAccountManager.NoOfTweetPerDay - tweetAccountManager.AlreadyTweeted;
}
int TotalDelay = (Delay * 60) / TotalTweets;
TweetAccountManager.DelayTweet = TotalDelay;
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> StartTweetingMultithreaded() -- Tweet Scheduled --> " + ex.Message, Globals.Path_TweetingErroLog);
GlobusFileHelper.AppendStringToTextfileNewLine("Error --> StartTweetingMultithreaded() -- TweetScheduled --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
}
if (chkBoxUseGroup.Checked && !string.IsNullOrEmpty(txtTweetUseGroup.Text))
{
if ((txtTweetUseGroup.Text).ToLower() == (tweetAccountManager.GroupName).ToLower())
{
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Group Name Matching ]");
}
else if (txtTweetUseGroup.Text != tweetAccountManager.GroupName)
{
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Group Name does not Match. ]");
return;
}
}
if (chkbosUseHashTags.Checked)
{
tweetAccountManager.UseHashTags = true;
foreach (string Data in Globals.HashTags)
{
tweetAccountManager.que_TweetMessages_Hashtags.Enqueue(Data);
}
}
else
{
tweetAccountManager.UseHashTags = false;
}
//Add to Threads Dictionary
AddThreadToDictionary(strModule(Module.Tweet), tweetAccountManager.Username);
///Adding Logs to Logger
tweetAccountManager.tweeter.logEvents.addToLogger += new EventHandler(logEvents_Tweet_addToLogger);
tweetAccountManager.logEvents.addToLogger += logEvents_Tweet_addToLogger;
if (!string.IsNullOrEmpty(txtMinDelay_Tweet.Text) && NumberHelper.ValidateNumber(txtMinDelay_Tweet.Text))
{
tweetMinDealy = Convert.ToInt32(txtMinDelay_Tweet.Text);
}
if (!string.IsNullOrEmpty(txtMaxDelay_Tweet.Text) && NumberHelper.ValidateNumber(txtMaxDelay_Tweet.Text))
{
tweetMaxDealy = Convert.ToInt32(txtMaxDelay_Tweet.Text);
}
//tweetAccountManager.Login();
//tweetAccountManager.Tweet(tweetMessage);
if (ChkboxTweetPerday.Checked)
{
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Checking Tweets Per Day ]");
TweetAccountManager.NoOfTweetPerDay = 0;
TweetAccountManager.TweetPerDay = true;
if (!string.IsNullOrEmpty(txtMaximumTweet.Text) && NumberHelper.ValidateNumber(txtMaximumTweet.Text))
{
TweetAccountManager.NoOfTweetPerDay = Convert.ToInt32(txtMaximumTweet.Text);
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ " + TweetAccountManager.NoOfTweetPerDay + " Maximum No Of Tweets Per Day ]");
}
else
{
TweetAccountManager.NoOfTweetPerDay = 10;
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Setting Maximum No Of Tweets Per Day as 10 ]");
}
clsDBQueryManager DbQueryManager = new clsDBQueryManager();
DataSet Ds = DbQueryManager.SelectMessageData(keyValue.Key, "Tweet");
int TodayTweet = Ds.Tables["tb_MessageRecord"].Rows.Count;
tweetAccountManager.AlreadyTweeted = TodayTweet;
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ " + TodayTweet + " Already tweeted today ]");
if (TodayTweet >= TweetAccountManager.NoOfTweetPerDay)
{
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Already Tweeted " + TweetAccountManager.NoOfTweetPerDay + " ]");
return;
}
}
if (chkAllTweetsPerAccount.Checked)
{
foreach (string item in lst_tweetMessage)
{
tweetAccountManager.que_TweetMessages_PerAccount.Enqueue(item);
}
}
tweetAccountManager.Tweet(lst_tweetMessage, tweetMinDealy, tweetMaxDealy);
//tweetAccountManager.tweeter.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
//tweetAccountManager.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
}
catch (Exception ex)
{
ErrorLogger.AddToErrorLogText(ex.Message);
GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> StartTweetingMultithreaded() --> " + ex.Message, Globals.Path_TweetingErroLog);
GlobusFileHelper.AppendStringToTextfileNewLine("Error --> StartTweetingMultithreaded() --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
finally
{
counter_AccountFollwer--;
tweetAccountManager.tweeter.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
tweetAccountManager.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
Interlocked.Decrement(ref countTweetMessageAccount);
lock (lockerThreadsTweetFeature)
{
Monitor.Pulse(lockerThreadsTweetFeature);
}
if (counter_AccountFollwer == 0)
{
if (btnStartFollowing.InvokeRequired)
{
Globals.TweetRunningText = string.Empty;
GlobusFileHelper.AppendStringToTextfileNewLine("Module Tweet count Total: " + Globals.totalcountTweet, Globals.path_CountNoOfProcessDone);
btnStartFollowing.Invoke(new MethodInvoker(delegate
{
AddToLog_Follower("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddToLog_Follower("---------------------------------------------------------------------------------------------------------------------------");
}));
}
}
}
}
