private void StartArabFollowMultithreaded(object parameters)
{
try
{
if (IsstopAppFollow)
{
return;
}
lstThreadAppFollow.Add(Thread.CurrentThread);
lstThreadAppFollow = lstThreadAppFollow.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
catch
{ }
try
{
Array paramsArray = new object[2];
paramsArray = (Array)parameters;
KeyValuePair <string, TweetAccountManager> keyValue = (KeyValuePair <string, TweetAccountManager>)paramsArray.GetValue(0);
GlobusHttpHelper objGlobusHttpHelper = new GlobusHttpHelper();
TweetAccountManager tweetAccountManager = keyValue.Value;
tweetAccountManager.logEventsArabFollower.addToLogger += new EventHandler(logEvents_Follower_addToLogger);
//tweetAccountManager.logEventsArabFollower.addToLogger += logEvents_Follower_addToLogger;
//if (!tweetAccountManager.IsLoggedIn)
{
tweetAccountManager.LoginApplicationFollow();
}
}
catch { }
finally
{
counter_Account--;
if (counter_Account == 0)
{
AddtoLoggerViewAccounts("Process completed.");
}
}
}
private void Star_ScrapTweetAndReplyMultithreaded(object parameters)
{
try
{
Array paramsArray = new object[2];
paramsArray = (Array)parameters;
KeyValuePair <string, TweetAccountManager> keyValue = (KeyValuePair <string, TweetAccountManager>)paramsArray.GetValue(0);
List <string> list_userIDsToFollow = new List <string>();//(List<string>)paramsArray.GetValue(1);
TweetAccountManager tweetAccountManager = keyValue.Value;
//tweetAccountManager.unFollower.logEvents.addToLogger += new EventHandler(logEvents_UnFollower_addToLogger);
tweetAccountManager.logEvents.addToLogger += new EventHandler(ReplyInterface_AddToLogger);
if (!tweetAccountManager.IsLoggedIn)
{
tweetAccountManager.Login();
}
if (tweetAccountManager.AccountStatus == "Account Suspended")
{
clsDBQueryManager database = new clsDBQueryManager();
database.UpdateSuspendedAcc(tweetAccountManager.Username);
AddToReplyInterfaceLog("[ " + DateTime.Now + " ] => [ Account Suspended With User Name : " + tweetAccountManager.Username + " ]");
return;
}
tweetAccountManager.Mention_ScrapTweetAndReply();
BindData();
tweetAccountManager.logEvents.addToLogger -= ReplyInterface_AddToLogger;
}
catch
{
}
}
private void StartUnFollowingMultithreaded(object parameters)
{
try
{
if (IsStopFollowYourFollowers)
{
return;
}
// if (!IsStopFollowYourFollowers)
{
lstIsStopFollowYourFollowers.Add(Thread.CurrentThread);
lstIsStopFollowYourFollowers.Distinct();
Thread.CurrentThread.IsBackground = true;
}
Array paramsArray = new object[2];
paramsArray = (Array)parameters;
int NoOfFollwos = 0;
KeyValuePair <string, TweetAccountManager> keyValue = (KeyValuePair <string, TweetAccountManager>)paramsArray.GetValue(0);
string NofUnfollows = (string)paramsArray.GetValue(1);
if (!string.IsNullOrEmpty(NofUnfollows) && NumberHelper.ValidateNumber(NofUnfollows))
{
NoOfFollwos = Int32.Parse(NofUnfollows);
}
bool OtherUser = false;
frmMain_NewUI.IsFollowerScreenName = true;
List <string> list_userIDsToFollow = new List <string>();
TweetAccountManager tweetAccountManager = keyValue.Value;
AddToLog_follow("[ " + DateTime.Now + " ] => [following Process Started For Account : " + keyValue.Key + " ]");
//Add to Threads Dictionary
//AddThreadToDictionary(strModule(Module.Follow), tweetAccountManager.Username);
tweetAccountManager.unFollower.logEvents.addToLogger += new EventHandler(logEvents_Follower_addToLogger);
tweetAccountManager.logEvents.addToLogger += logEvents_Follower_addToLogger;
if (!tweetAccountManager.IsLoggedIn)
{
tweetAccountManager.Login();
}
if (!tweetAccountManager.IsLoggedIn)
{
AddToLog_follow("[ " + DateTime.Now + " ] => [ Not Logged In With Account : " + keyValue.Key + " ]");
return;
}
//////////////temp mehtod
{
}
//AddToLog_Unfollow("Checking for Persons Not Followed Back");
Thread thread_UnFollowing = null;
//Check Test box and anf useing feature box is checked
TwitterDataScrapper objTwitterDataScrapper = new TwitterDataScrapper();
//if (rdoFollowYourFollowers.Checked)
//thread_UnFollowing = new Thread(() =>
//{
// list_userIDsToFollow = tweetAccountManager.GetFollowYourFollowersList();
//});
list_userIDsToFollow = tweetAccountManager.GetFollowYourFollowersList();
if (GlobusRegex.ValidateNumber(txtfollowMinDelay.Text))
{
followMinDelay = Convert.ToInt32(txtfollowMinDelay.Text);
}
if (GlobusRegex.ValidateNumber(txtfollowMaxDelay.Text))
{
followMaxDelay = Convert.ToInt32(txtfollowMaxDelay.Text);
}
if (list_userIDsToFollow.Count > 0)
{
tweetAccountManager.FollowUsingURLs(list_userIDsToFollow, followMinDelay, followMaxDelay, OtherUser);
}
else
{
AddToLog_follow("[ " + DateTime.Now + " ] => [ No user id is available for Account : " + keyValue.Key + " ]");
}
tweetAccountManager.unFollower.logEvents.addToLogger -= logEvents_Follower_addToLogger;
tweetAccountManager.logEvents.addToLogger -= logEvents_Follower_addToLogger;
}
catch (Exception ex)
{
ErrorLogger.AddToErrorLogText(ex.Message);
GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> StartUnFollowingMultithreaded() --> " + ex.Message, Globals.Path_UnfollowerErroLog);
GlobusFileHelper.AppendStringToTextfileNewLine("Error --> StartUnFollowingMultithreaded() --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
finally
{
counter_Account--;
if (counter_Account == 0)
{
if (btnStartFollow.InvokeRequired)
{
btnStartFollow.Invoke(new MethodInvoker(delegate
{
AddToLog_follow("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddToLog_follow("---------------------------------------------------------------------------------------------------------------------------");
btnStartFollow.Cursor = Cursors.Default;
}));
}
}
}
}
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 { }
}
/// <summary>
/// Gets the Accounts from "tb_FBAccount" and adds to Dictionary
/// </summary>
private void ReloadAccountsFromDataBase()
{
try
{
clsFBAccount objclsFBAccount = new clsFBAccount();
DataTable dt = objclsFBAccount.SelectAccoutsForGridView();
if (dt.Rows.Count > 0)
{
Globals.listAccounts.Clear();
TweetAccountContainer.dictionary_TweetAccount.Clear();
///Add Twitter instances to TweetAccountContainer.dictionary_TweetAccount
foreach (DataRow dRow in dt.Rows)
{
try
{
TweetAccountManager facebooker = new TweetAccountManager();
facebooker.Username = dRow[0].ToString();
facebooker.Password = dRow[1].ToString();
facebooker.proxyAddress = dRow[2].ToString();
facebooker.proxyPort = dRow[3].ToString();
facebooker.proxyUsername = dRow[4].ToString();
facebooker.proxyPassword = dRow[5].ToString();
if (!string.IsNullOrEmpty(dRow[7].ToString()))
{
facebooker.profileStatus = int.Parse(dRow[7].ToString());
}
Globals.listAccounts.Add(facebooker.Username + ":" + facebooker.Password + ":" + facebooker.proxyAddress + ":" + facebooker.proxyPort + ":" + facebooker.proxyUsername + ":" + facebooker.proxyPassword);
TweetAccountContainer.dictionary_TweetAccount.Add(facebooker.Username, facebooker);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> ReloadAccountsFromDataBase() -- Rows From DB --> " + ex.Message, Globals.Path_ProxySettingErroLog);
Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ReloadAccountsFromDataBase() -- Rows From DB --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
}
Console.WriteLine(Globals.listAccounts.Count + " Accounts loaded");
AddToGeneralLogs(Globals.listAccounts.Count + " Accounts loaded");
}
}
catch(Exception ex)
{
Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> ReloadAccountsFromDataBase() --> " + ex.Message, Globals.Path_ProxySettingErroLog);
Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ReloadAccountsFromDataBase() --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
}
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("------------------------------------------------------------------------------------------------------------------------------------------");
}
}
}
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("------------------------------------------------------------------------------------------------------------------------------------------");
}
}
}
/// <summary>
/// Gets the Accounts from "tb_FBAccount" and adds to Dictionary
/// </summary>
private void ReloadAccountsFromDataBase()
{
try
{
clsFBAccount objclsFBAccount = new clsFBAccount();
DataTable dt = objclsFBAccount.SelectAccoutsForGridView();
if (dt.Rows.Count > 0)
{
Globals.listAccounts.Clear();
TweetAccountContainer.dictionary_TweetAccount.Clear();
///Add Twitter instances to TweetAccountContainer.dictionary_TweetAccount
foreach (DataRow dRow in dt.Rows)
{
try
{
TweetAccountManager facebooker = new TweetAccountManager();
facebooker.Username = dRow[0].ToString();
facebooker.Password = dRow[1].ToString();
facebooker.proxyAddress = dRow[2].ToString();
facebooker.proxyPort = dRow[3].ToString();
facebooker.proxyUsername = dRow[4].ToString();
facebooker.proxyPassword = dRow[5].ToString();
if (!string.IsNullOrEmpty(dRow[8].ToString()))
{
facebooker.profileStatus = int.Parse(dRow[8].ToString());
}
Globals.listAccounts.Add(facebooker.Username + ":" + facebooker.Password + ":" + facebooker.proxyAddress + ":" + facebooker.proxyPort + ":" + facebooker.proxyUsername + ":" + facebooker.proxyPassword);
TweetAccountContainer.dictionary_TweetAccount.Add(facebooker.Username, facebooker);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
Console.WriteLine(Globals.listAccounts.Count + " Accounts loaded");
AddToGeneralLogs(Globals.listAccounts.Count + " Accounts loaded");
}
}
catch { }
}
private void StartWebsiteLikeMultiThread(object parameters)
{
try
{
if (IsStopWebsiteLiker)
{
return;
}
LstWebsiteLikeThread.Add(Thread.CurrentThread);
LstWebsiteLikeThread = LstWebsiteLikeThread.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
catch
{ };
Array paramsArray = new object[2];
paramsArray = (Array)parameters;
int NumberOfWebsiteTobeLiked = 0;
KeyValuePair <string, TweetAccountManager> keyValue = (KeyValuePair <string, TweetAccountManager>)paramsArray.GetValue(0);
NumberOfWebsiteTobeLiked = (int)paramsArray.GetValue(1);
bool OtherUser = false;
TweetAccountManager tweetAccountManager = keyValue.Value;
if (!tweetAccountManager.IsLoggedIn)
{
AddToWebsiteLikeLog("[ " + DateTime.Now + " ] => [ Logging With Account : " + keyValue.Key + " ]");
tweetAccountManager.Login();
}
if (!tweetAccountManager.IsLoggedIn)
{
AddToWebsiteLikeLog("[ " + DateTime.Now + " ] => [ Not Logged In With Account : " + keyValue.Key + " ]");
return;
}
AddToWebsiteLikeLog("[ " + DateTime.Now + " ] => [ Logged In With Account : " + keyValue.Key + " ]");
foreach (string item in LstWebsiteLink)
{
string Pagesource = string.Empty;
string Response = string.Empty;
string Text = string.Empty;
string AuthencityToken = string.Empty;
string tw_p = string.Empty;
string via = string.Empty;
string OrignalReferer = string.Empty;
try
{
string Url = "https://about.twitter.com/resources/buttons#tweet";
Pagesource = tweetAccountManager.globusHttpHelper.getHtmlfromUrl(new Uri(Url), "", "");
Response = tweetAccountManager.globusHttpHelper.getHtmlfromUrl(new Uri("https://twitter.com/intent/tweet?original_referer=https%3A%2F%2Fabout.twitter.com%2Fresources%2Fbuttons&text=Twitter%20Buttons%20%7C%20About&tw_p=tweetbutton&url=http%3A%2F%2Fwww.globussoft.com&via=WhitentonSkoff"), "", "");
try
{
Text = getBetween(Response, "name=\"text\" type=\"hidden\" value=\"", "\"");
}
catch { };
try
{
AuthencityToken = getBetween(Response, "authenticity_token\" value=\"", "\"");
}
catch { };
try
{
tw_p = getBetween(Response, "\"tw_p\" type=\"hidden\" value=\"", "\"");
}
catch { };
try
{
via = getBetween(Response, "\"via\" type=\"hidden\" value=\"", "\"");
}
catch
{ };
try
{
OrignalReferer = getBetween(Response, "original_referer=", "&");
}
catch { };
try
{
string postData = "Url=" + Uri.EscapeDataString(item) + "&Text=" + Uri.EscapeDataString(Text).Replace(" ", "+") + "&original_referer=" + Uri.EscapeDataString(OrignalReferer) + "&via=" + via + "&tw_p=" + tw_p + "&authenticity_token=" + AuthencityToken + "&status=Twitter+Buttons+%7C+About" + Uri.EscapeDataString(item) + "via" + Uri.EscapeDataString(via);
string postUrl = "https://twitter.com/intent/tweet/update";
string PostRequest = tweetAccountManager.globusHttpHelper.postFormData(new Uri(postUrl), postData, "", "", "", "", "");
if (PostRequest.Contains("Your Tweet has been posted!"))
{
AddToWebsiteLikeLog("[ " + DateTime.Now + " ] => [ Your Tweet has been posted ]");
Globussoft.GlobusFileHelper.AppendStringToTextfileNewLine(item, Globals.Path_SuccessfullyTweetedUrls);
}
else if (PostRequest.Contains("You have already sent this Tweet"))
{
AddToWebsiteLikeLog("[ " + DateTime.Now + " ] => [ You have already sent this Tweet]");
}
else
{
AddToWebsiteLikeLog("[ " + DateTime.Now + " ] => [ Your Tweet has not been posted ]");
}
}
catch { };
}
catch
{ };
}
AddToWebsiteLikeLog("[ " + DateTime.Now + " ] => [ Process Completed ........ ]");
}
private void btn_FollowByKeyWordStart_Click(object sender, EventArgs e)
{
TweetAccountManager TweetAccountManager = new TweetAccountManager();
TwitterDataScrapper TwitterDataScrapper = new TwitterDataScrapper();
int FollowLimitCounter = 0;
int AccountCounter = 0;
if (TweetAccountContainer.dictionary_TweetAccount.Count > 0)
{
try
{
foreach (KeyValuePair<string, TweetAccountManager> item in TweetAccountContainer.dictionary_TweetAccount)
{
string profileUsername = string.Empty;
string profileUserpass = string.Empty;
profileUsername = item.Key;
profileUserpass = item.Value.Password;
//******search profile By keyWords
string SeachKey = string.Empty;
List<TwitterDataScrapper.StructTweetIDs> KeywordStructData = new List<TwitterDataScrapper.StructTweetIDs>();
if (FollowtweetKeywordList.Count != 0)
{
SeachKey = FollowtweetKeywordList[AccountCounter];
KeywordStructData = TwitterDataScrapper.KeywordStructData(SeachKey);
}
else
{
MessageBox.Show("Please Upload Keywords");
break;
}
//*************
try
{
if (KeywordStructData.Count > 0)
{
foreach (var item1 in KeywordStructData)
{
//accordint to get Follow users limits
if (FollowLimitCounter >= (int.Parse(txt_FollowByPerAccount.Text)))
{
FollowLimitCounter = 0;
break;
}
else
{
FollowLimitCounter++;
}
//Get follow from user
string AccountId = item1.ID_Tweet_User;
getFollowUserBySearch(new object[] { item, AccountId });
}
}
else
{
//Message List is Empty
AddToLog_Follower("Key Word File is Empty or Wrong Formate");
break;
}
}
catch (Exception)
{
}
//if (AccountCounter > FollowtweetKeywordList.Count)
// AccountCounter = 0;
if (AccountCounter > TweetAccountContainer.dictionary_TweetAccount.Count)
{
AccountCounter = 0;
}
else
{
AccountCounter++;
}
}
}
catch (Exception)
{
}
}
else
{
MessageBox.Show("Please Upload Twitter Account");
AddToLog_Follower("Please Upload Twitter Account");
}
}
public void getLoginandCheckAccount()
{
AddToLog_Checker("Process start");
try
{
//Get individual Email from Email list
foreach (string item in listOfTwitterEmailIdAndPassword)
{
TweetAccountManager tweetAccountManager = new TweetAccountManager();
GlobusHttpHelper globushttpHelper1 = new GlobusHttpHelper();
string userEmail = item.Split(':')[0];
string userEmailPass = item.Split(':')[1];
tweetAccountManager.Username = userEmail;
tweetAccountManager.Password = userEmailPass;
if (!tweetAccountManager.IsLoggedIn)
{
tweetAccountManager.Login();
}
if (tweetAccountManager.IsLoggedIn)
{
AddToLog_Checker("Log in Success " + userEmail);
//get data from API Url ...
string userID = tweetAccountManager.userID;
string URL = "https://api.twitter.com/1/users/show.json?user_id=" + userID + "&include_entities=true";
try
{
string Data = globushttpHelper1.getHtmlfromUrl(new Uri(URL), "", "");
//parse data from Json..
JObject JData = JObject.Parse(Data);
string ScreanName = (string)JData["screen_name"];
//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)
{
}
}
}
AddToLog_Checker("Finished Account Checking");
AddToLog_Checker("------------------------------------------------------------------------------------------------------------------------------------------");
}
catch (Exception)
{
}
finally
{
AddToLog_Checker("Finish Account Checking For all Emails");
}
}
private void StartTweetingMultithreaded(object parameters)
{
try
{
Thread.CurrentThread.IsBackground = true;
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;
if (chkBoxUseGroup.Checked && !string.IsNullOrEmpty(txtTweetUseGroup.Text))
{
if (txtTweetUseGroup.Text != tweetAccountManager.GroupName)
{
return;
}
else if (txtTweetUseGroup.Text == tweetAccountManager.GroupName)
{
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Group Name Matching ]");
}
}
//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.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
tweetAccountManager.tweeter.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
tweetAccountManager.tweeter.logEvents.addToLogger += new EventHandler(logEvents_Tweet_addToLogger);
//tweetAccountManager.tweeter.logEvents.addToLogger += 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);
}
if (chkbosUseHashTags.Checked)
{
tweetAccountManager.UseHashTags = true;
foreach (string Data in Globals.HashTags)
{
tweetAccountManager.que_TweetMessages_Hashtags.Enqueue(Data);
}
}
else
{
tweetAccountManager.UseHashTags = false;
}
//tweetAccountManager.Login();
//tweetAccountManager.Tweet(tweetMessage);
//if (chkbosUseHashTags.Checked)
//{
// tweetAccountManager.UseHashTags = true;
// foreach (string Data in Globals.HashTags)
// {
// tweetAccountManager.que_TweetMessages_Hashtags.Enqueue(Data);
// }
//}
//else
//{
// tweetAccountManager.UseHashTags = false;
//}
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;
}
}
else if (!ChkboxTweetPerday.Checked)
{
TweetAccountManager.TweetPerDay = false;
}
if (IsTweetScheduled)
{
try
{
DateTime d1 = dateTimePicker_tweeterStart.Value;
DateTime d2 = dateTimePicker_TwetterEnd.Value;
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
{
TweetAccountManager Tweet = new TweetAccountManager();
TotalTweets = TweetAccountManager.NoOfTweetPerDay - tweetAccountManager.AlreadyTweeted;
}
float TotalDelay = (Delay * 60) / TotalTweets;
TweetAccountManager.DelayTweet = Convert.ToInt32(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 (chkAllTweetsPerAccount.Checked)
{
foreach (string item in listTweetMessages)
{
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);
}
}
private void Start_ReplyMultithreaded(object parameters)
{
try
{
Array paramsArray = new object[2];
paramsArray = (Array)parameters;
KeyValuePair <string, TweetAccountManager> keyValue = (KeyValuePair <string, TweetAccountManager>)paramsArray.GetValue(0);
List <string> list_userIDsToFollow = new List <string>();//(List<string>)paramsArray.GetValue(1);
TweetAccountManager tweetAccountManager = keyValue.Value;
if (tweetAccountManager.Username == userName)
{
if (userDisplayName.Length + screenName.Length + message.Length < 140)
{
//tweetAccountManager.unFollower.logEvents.addToLogger += new EventHandler(logEvents_UnFollower_addToLogger);
tweetAccountManager.logEvents.addToLogger += new EventHandler(ReplyInterface_AddToLogger);
if (!tweetAccountManager.IsLoggedIn)
{
tweetAccountManager.Login();
}
if (tweetAccountManager.AccountStatus == "Account Suspended")
{
clsDBQueryManager database = new clsDBQueryManager();
database.UpdateSuspendedAcc(tweetAccountManager.Username);
AddToReplyInterfaceLog("[ " + DateTime.Now + " ] => [ Account Suspended With User Name : " + tweetAccountManager.Username + " ]");
return;
}
tweetAccountManager.Reply_MentionReplyInterface(PostAuthenticityToken, statusId, userDisplayName, screenName, message, userName);
tweetAccountManager.logEvents.addToLogger -= ReplyInterface_AddToLogger;
BindData();
}
else
{
MessageBox.Show("Please Edit The Message Of Edit Message Box . Since The Message Length Is Greater Than 140 Characters !");
return;
}
}
}
catch
{
}
finally
{
try
{
// BindData();
}
catch
{
}
}
}
private void StartMessagingMultithreaded(object parameters)
{
try
{
if (IsStopDirectMessages)
{
return;
}
if (!IsStopDirectMessages)
{
lstIsStopMessaging.Add(Thread.CurrentThread);
lstIsStopMessaging.Distinct();
Thread.CurrentThread.IsBackground = true;
}
List <string> list_userIDsToFollow = new List <string>();
Array paramsArray = new object[2];
paramsArray = (Array)parameters;
int NoOfFollwos = 0;
KeyValuePair <string, TweetAccountManager> keyValue = (KeyValuePair <string, TweetAccountManager>)paramsArray.GetValue(0);
string NofUnfollows = (string)paramsArray.GetValue(1);
if (!string.IsNullOrEmpty(NofUnfollows) && NumberHelper.ValidateNumber(NofUnfollows))
{
NoOfFollwos = Int32.Parse(NofUnfollows);
}
bool OtherUser = false;
//frmMain_NewUI.IsFollowerScreenName = true;
GlobusHttpHelper objGlobusHttpHelper = new GlobusHttpHelper();
TweetAccountManager tweetAccountManager = keyValue.Value;
tweetAccountManager.unFollower.logEvents.addToLogger += new EventHandler(logEvents_Follower_addToLogger);
tweetAccountManager.logEvents.addToLogger += logEvents_Follower_addToLogger;
if (!tweetAccountManager.IsLoggedIn)
{
tweetAccountManager.Login();
}
if (!tweetAccountManager.IsLoggedIn)
{
AddToLog_follow("[ " + DateTime.Now + " ] => [ Not Logged In With Account : " + keyValue.Key + " ]");
return;
}
if (GlobusRegex.ValidateNumber(txtDirectMessageMinDelay.Text))
{
followMinDelay = Convert.ToInt32(txtDirectMessageMinDelay.Text);
}
if (GlobusRegex.ValidateNumber(txtDirectMessageMaxDelay.Text))
{
followMaxDelay = Convert.ToInt32(txtDirectMessageMaxDelay.Text);
}
//TwitterDataScrapper objTwitterDataScrapper = new TwitterDataScrapper();
if (list_userIDsToFollowForDirectMessage.Count > 0 && chkFollowers.Checked)
{
list_userIDsToFollow.AddRange(list_userIDsToFollowForDirectMessage);
}
else
{
list_userIDsToFollow = tweetAccountManager.GetFollowerListForDirectMessage();
}
if (list_userIDsToFollow.Count > 0)
{
tweetAccountManager.PostDirectMessage(list_userIDsToFollow, followMinDelay, followMaxDelay, OtherUser);
}
else
{
AddToLog_follow("[ " + DateTime.Now + " ] => [ No user id is available for Account : " + keyValue.Key + " ]");
}
tweetAccountManager.unFollower.logEvents.addToLogger -= logEvents_Follower_addToLogger;
tweetAccountManager.logEvents.addToLogger -= logEvents_Follower_addToLogger;
}
catch (Exception ex)
{
ErrorLogger.AddToErrorLogText(ex.Message);
GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> StartUnFollowingMultithreaded() --> " + ex.Message, Globals.Path_UnfollowerErroLog);
GlobusFileHelper.AppendStringToTextfileNewLine("Error --> StartUnFollowingMultithreaded() --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
finally
{
counter_Account--;
if (counter_Account == 0)
{
if (btnStartMessaging.InvokeRequired)
{
btnStartMessaging.Invoke(new MethodInvoker(delegate
{
AddToLog_follow("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddToLog_follow("---------------------------------------------------------------------------------------------------------------------------");
btnStartMessaging.Cursor = Cursors.Default;
}));
}
}
}
}
