public void StartDMMultiThreadedSearchOpenGroups(object parameter)
{
try
{
if (IsStop)
{
return;
}
if (!IsStop)
{
lstJoinSearchGroupThread.Add(Thread.CurrentThread);
lstJoinSearchGroupThread.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
}
catch
{
}
Array paramsArray = new object[1];
int notLoged = 0;
paramsArray = (Array)parameter;
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
Groups.JoinSearchGroup obj_JoinSearchGroup = new Groups.JoinSearchGroup(Login.accountUser, Login.accountPass, Login.proxyAddress, Login.proxyPort, Login.proxyUserName, Login.proxyPassword);
Login.logger.addToLogger += new EventHandler(logger_SearchGroupaddToLogger);
obj_JoinSearchGroup.logger.addToLogger += new EventHandler(logger_SearchGroupaddToLogger);
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
if (!Login.IsLoggedIn)
{
Login.LoginHttpHelper(ref HttpHelper);
}
AddLoggerSearchGroup("[ " + DateTime.Now + " ] => [ Searching Groups Process Running..Please wait for sometimes.. ]");
if (Login.IsLoggedIn)
{
GroupStatus dataScrape = new GroupStatus();
try
{
Result = obj_JoinSearchGroup.PostAddOpenGroups(ref HttpHelper, txtSearchKeyword.Text.ToString().Trim(), item.Value._Username);
int count = 5;
if (!string.IsNullOrEmpty(txtBoxGroupCount.Text) && NumberHelper.ValidateNumber(txtBoxGroupCount.Text))
{
count = Convert.ToInt32(txtBoxGroupCount.Text);
}
LinkdInContacts.Add(Login.accountUser, Result);
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Search Groups --> StartDMMultiThreadedSearchOpenGroups() ---1--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Search Groups --> StartDMMultiThreadedSearchOpenGroups() ---1--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinAddSearchGroupErrorLogs);
}
try
{
if (Result.Count == 0)
{
AddLoggerSearchGroup("[ " + DateTime.Now + " ] => [ Sorry, there are no group Search results matching your search criteria.. ]");
}
else
{
AddLoggerSearchGroup("[ " + DateTime.Now + " ] => [ Groups..Searched Successfully..For " + Login.accountUser + " ]");
if (cmbSearchGroup.InvokeRequired)
{
new Thread(() =>
{
cmbSearchGroup.Invoke(new MethodInvoker(delegate
{
cmbSearchGroup.Items.Add(Login.accountUser);
}));
}).Start();
}
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Search Groups --> StartDMMultiThreadedSearchOpenGroups() ---2--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Search Groups --> StartDMMultiThreadedSearchOpenGroups() ---2--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinAddSearchGroupErrorLogs);
}
finally
{
obj_JoinSearchGroup.logger.addToLogger -= new EventHandler(logger_SearchGroupaddToLogger);
counter_GroupMemberSearch--;
int aaa = counter_GroupMemberSearch - notLoged;
if (counter_GroupMemberSearch == aaa)
{
if (cmbSearchGroup.InvokeRequired)
{
cmbSearchGroup.Invoke(new MethodInvoker(delegate
{
AddLoggerSearchGroup("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddLoggerSearchGroup("----------------------------------------------------------------------------------------------------------------------------------------");
cmbSearchGroup.Enabled = true;
btnAddSearchGroup.Cursor = Cursors.Default;
}));
}
}
}
}
else
{
AddLoggerSearchGroup("[ " + DateTime.Now + " ] => [ Account : " + Login.accountUser + " Not Logged In ]");
if (notLoged == 0)
{
notLoged = 1;
}
else
{
notLoged = +notLoged;
}
}
}
public void EndorsingPerDay(object parameter)
{
try
{
lstEndorsementThread.Add(Thread.CurrentThread);
lstEndorsementThread = lstEndorsementThread.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
int NoOfEndorsementPerDay = 10;
int Counter = 0;
int MinDelay = 20;
int MaxDelay = 25;
List<string> LstFriendId = new List<string>();
//NoOfEndorsementPerDay = int.Parse(txtNoOfEndorsementPerDay.Text);
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
NoOfEndorsementPerDay = (int)paramsArray.GetValue(1);
EndorsePeople.no_of_Skils = (int)paramsArray.GetValue(2);
MinDelay = (int)paramsArray.GetValue(3);
MaxDelay = (int)paramsArray.GetValue(4);
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
AddLoggerEndorsePeople("[ " + DateTime.Now + " ] => [ Logging In With " + item.Key + " ]");
if (!item.Value.IsLoggedIn)
{
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
Login.LoginHttpHelper(ref HttpHelper);
if (Login.IsLoggedIn)
{
AddLoggerEndorsePeople("[ " + DateTime.Now + " ] => [ Logged In With " + item.Key + " ]");
}
else
{
AddLoggerEndorsePeople("[ " + DateTime.Now + " ] => [ Not Logged In With " + item.Key + " ]");
return;
}
if (Login.IsLoggedIn)
{
//GroupStatus dataScrape = new GroupStatus();
string query = "Select * From tb_endorsement WHERE (Username = '******')";
DataSet ds = DataBaseHandler.SelectQuery(query, "tb_endorsement");
DataTable dt = ds.Tables["tb_endorsement"];
string Username = string.Empty;
if (dt.Rows.Count > 0)
{
Username = dt.Rows[0]["Username"].ToString();
}
if (Username != item.Key)
{
AddLoggerEndorsePeople("[ " + DateTime.Now + " ] => [ Scraping 1st Connection from Account : " + item.Key + " ]");
GroupStatus MemberScrape = new GroupStatus();
GroupStatus.moduleLog = "endorsecamp";
Dictionary<string, string> Result = MemberScrape.PostAddMembers(ref HttpHelper, Login.accountUser);
AddLoggerEndorsePeople("[ " + DateTime.Now + " ] => [ Scraping process completed from Account : " + item.Key + " ]");
}
AddLoggerEndorsePeople("[ " + DateTime.Now + " ] => [ Starting Endorsing People ]");
string SelectQuery = "select * from tb_endorsement where Username = '******' and Status=0";
DataSet dst = DataBaseHandler.SelectQuery(SelectQuery, "tb_endorsement");
DataTable dt1 = dst.Tables["tb_endorsement"];
foreach (DataRow dr in dt1.Rows)
{
if (Counter <= NoOfEndorsementPerDay)
{
string FriendId = dr["FriendId"].ToString();
LstFriendId.Add(FriendId);
Counter++;
}
else
{
break;
}
}
}
EndorsePeople EnorsePeople = new EndorsePeople();
EnorsePeople.Username = item.Key;
foreach (string _FriendId in LstFriendId)
{
int delay = RandomNumberGenerator.GenerateRandom(MinDelay, MaxDelay);
try
{
EnorsePeople.EndorsingPeople(ref HttpHelper, _FriendId);
string strQuery = "UPDATE tb_endorsement SET Status='" + "1" + "' WHERE Status='0' AND FriendId ='" + _FriendId + "' AND Username ='******' ";
DataBaseHandler.UpdateQuery(strQuery, "tb_endorsement");
AddLoggerEndorsePeople("[ " + DateTime.Now + " ] => [ Delay for : " + delay + " Seconds ]");
Thread.Sleep(delay * 1000);
}
catch { }
}
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error -->EndorsingPeople() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> EndorsingPeople() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.path_EndorsePeople);
}
finally
{
Count_Endorse--;
if (Count_Endorse == 0)
{
btnstartEndorse.Invoke(new MethodInvoker(delegate
{
AddLoggerEndorsePeople("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddLoggerEndorsePeople("-------------------------------------------------------------------------------------------------------------------------------");
btnStartCampaingEndorsement.Cursor = Cursors.Default;
}));
}
}
}
public void StartDMMultiThreadedGroupUser(object parameter)
{
try
{
try
{
if (!IsStop)
{
lstGroupUpdateThread.Add(Thread.CurrentThread);
lstGroupUpdateThread.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
}
catch
{
}
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
Groups.GroupUpdate obj_GroupUpdate = new Groups.GroupUpdate(Login.accountUser, Login.accountPass, Login.proxyAddress, Login.proxyPort, Login.proxyUserName, Login.proxyPassword);
obj_GroupUpdate.logger.addToLogger += new EventHandler(AddToLogger_GroupStatus);
Login.logger.addToLogger += new EventHandler(AddToLogger_GroupStatus);
if (!Login.IsLoggedIn)
{
Login.LoginHttpHelper(ref HttpHelper);
}
AddLoggerGroupStatus("[ " + DateTime.Now + " ] => [ Starting Search For Groups >>> To Send Group Messages ]");
try
{
if (Login.IsLoggedIn)
{
GroupStatus dataScrape = new GroupStatus();
Dictionary<string, string> Data = new Dictionary<string, string>();
Data.Clear();
Data = obj_GroupUpdate.PostCreateGroupNames(ref HttpHelper, Login.accountUser);
GrpMess.Add(Login.accountUser, Data);
obj_GroupUpdate.logger.addToLogger -= new EventHandler(AddToLogger_GroupStatus);
if (cmbGroupUser.InvokeRequired)
{
new Thread(() =>
{
cmbGroupUser.Invoke(new MethodInvoker(delegate
{
cmbGroupUser.Items.Add(Login.accountUser);
}));
}).Start();
}
AddLoggerGroupStatus("[ " + DateTime.Now + " ] => [ Groups Added in : " + item.Value._Username + "]");
}
else
{
AddLoggerGroupStatus("[ " + DateTime.Now + " ] => [ LinkedIn account : " + Login.accountUser + " has been temporarily restricted ]");
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Group Update --> StartDMMultiThreadedGroupUser() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Group Update --> StartDMMultiThreadedGroupUser() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinGetGroupMemberErrorLogs);
}
finally
{
counter_GroupMemberSearch--;
if (counter_GroupMemberSearch == 0)
{
if (cmbGroupUser.InvokeRequired)
{
cmbGroupUser.Invoke(new MethodInvoker(delegate
{
AddLoggerGroupStatus("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddLoggerGroupStatus("-------------------------------------------------------------------------------------------------------------------------");
cmbGroupUser.Enabled = true;
btnGetUser.Cursor = Cursors.Default;
}));
}
//btnGetUser.Invoke(new MethodInvoker(delegate
//{
// AddLoggerGroupStatus("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
// AddLoggerGroupStatus("-------------------------------------------------------------------------------------------------------------------------");
// btnGetUser.Cursor = Cursors.Default;
//}));
}
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Group Update --> StartDMMultiThreadedGroupUser() >>>> " + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Group Update --> StartDMMultiThreadedGroupUser() >>>> " + ex.StackTrace, Globals.Path_LinkedinGetGroupMemberErrorLogs);
}
}
public void StartDMMultiThreadedMemmbersGroupAdd(object parameter)
{
try
{
try
{
if (!IsStop)
{
lstJoinFriendGroupThread.Add(Thread.CurrentThread);
lstJoinFriendGroupThread.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
}
catch
{
}
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
string SelectedEmail = string.Empty;
this.Invoke(new MethodInvoker(delegate
{
SelectedEmail = cmbUser.SelectedItem.ToString();
}));
if (!Login.IsLoggedIn)
{
Login.LoginHttpHelper(ref HttpHelper);
}
AddLoggerGroupAdd("[ " + DateTime.Now + " ] => [ Add Groups Process Running..Please wait.. ]");
if (Login.IsLoggedIn)
{
List<string> SelectedItem = new List<string>();
try
{
foreach (KeyValuePair<string, Dictionary<string, string>> UserValue in LinkdInContacts)
{
string SelectedValue = SelectedEmail;
if (UserValue.Key.Contains(SelectedValue))
{
foreach (KeyValuePair<string, string> GroupValue in UserValue.Value)
{
foreach (string Userid in chkMembers.CheckedItems)
{
if (GroupValue.Value.Replace(",", string.Empty).Contains(Userid))
{
MemId.Add(GroupValue.Key.Split(':')[1]);
}
}
}
}
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> StartDMMultiThreadedMemmbersGroupAdd() ---1--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> StartDMMultiThreadedMemmbersGroupAdd() ---1--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinAddFriendsGroupErrorLogs);
}
}
GroupStatus dataScrape = new GroupStatus();
Dictionary<string, string> Groups = dataScrape.PostAddGroupNames(ref HttpHelper, MemId);
try
{
GrpAdd.Add(Login.accountUser, Groups);
AddLoggerGroupAdd("[ " + DateTime.Now + " ] => [ Groups..Added Successfully.. ]");
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> StartDMMultiThreadedMemmbersGroupAdd() ---2--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> StartDMMultiThreadedMemmbersGroupAdd() ---2--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinAddFriendsGroupErrorLogs);
}
string GetUserID = string.Empty;
this.Invoke(new MethodInvoker(delegate
{
chkExistGroup.Items.Clear();
GetUserID = cmbUser.SelectedItem.ToString();
}));
try
{
foreach (KeyValuePair<string, Dictionary<string, string>> Grps in GrpAdd)
{
try
{
if (GetUserID.Contains(Grps.Key))
{
Dictionary<string, string> GmUserIDs = Grps.Value;
AddLoggerGroupAdd("[ " + DateTime.Now + " ] => [ " + GmUserIDs.Count() + " Groups in List ]");
foreach (KeyValuePair<string, string> item1 in Grps.Value)
{
try
{
chkExistGroup.Invoke(new MethodInvoker(delegate
{
chkExistGroup.Items.Add(item1.Key);
GetUserID = cmbUser.SelectedItem.ToString();
}));
}
catch (Exception ex)
{
}
}
}
}
catch (Exception ex)
{
}
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> StartDMMultiThreadedMemmbersGroupAdd() ---3--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> StartDMMultiThreadedMemmbersGroupAdd() ---3--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinAddFriendsGroupErrorLogs);
}
AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ Finished Adding Groups of Users ]");
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> StartDMMultiThreadedMemmbersGroupAdd() ---4--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> StartDMMultiThreadedMemmbersGroupAdd() ---4--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinAddFriendsGroupErrorLogs);
}
finally
{
this.Invoke(new MethodInvoker(delegate
{
AddLoggerGroupAdd("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddLoggerGroupAdd("------------------------------------------------------------------------------------------------------------------------------------");
btnAddGroups.Cursor = Cursors.Default;
}));
}
}
private void btn_GroupStatusUpdate_GetGroups_Click_1(object sender, RoutedEventArgs e)
{
GroupStatus objGroupStatus = new GroupStatus();
Thread objThread = new Thread(objGroupStatus.ThreadStartGroupStatus);
objThread.Start();
}
public void StartDMMultiThreadedGroupMemmberAdd(object parameter)
{
try
{
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
Login.logger.addToLogger += new EventHandler(GroupStatus_addToLogger);
if (!Login.IsLoggedIn)
{
Login.LoginHttpHelper(ref HttpHelper);
}
if (Login.IsLoggedIn)
{
GroupStatus dataScrape = new GroupStatus();
GroupStatus.moduleLog = "FriendsGroup";
Dictionary<string, string> Result = dataScrape.PostAddMembers(ref HttpHelper, Login.accountUser);
LinkdInContacts.Add(Login.accountUser, Result);
try
{
if (Result.Count > 0)
{
AddLoggerGroupAdd("[ " + DateTime.Now + " ] => [ Friends List..Added Successfully..in " + Login.accountUser + " ]");
}
else
{
AddLoggerGroupAdd("[ " + DateTime.Now + " ] => [ Friends List..Not Available..in " + Login.accountUser + " ]");
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> StartDMMultiThreadedGroupMemmberAdd() >> 1 >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> StartDMMultiThreadedGroupMemmberAdd() >> 2 >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinAddFriendsGroupErrorLogs);
}
if (cmbUser.InvokeRequired)
{
new Thread(() =>
{
cmbUser.Invoke(new MethodInvoker(delegate
{
cmbUser.Items.Add(Login.accountUser);
}));
}).Start();
}
}
else
{
AddLoggerGroupAdd("[ " + DateTime.Now + " ] => [ LinkedIn Account : " + Login.accountUser + " has been temporarily restricted ]");
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> StartDMMultiThreadedGroupMemmberAdd() >> 2 >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> StartDMMultiThreadedGroupMemmberAdd() >> 2>>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinAddFriendsGroupErrorLogs);
}
finally
{
counter_GroupMemberSearch--;
if (counter_GroupMemberSearch == 0)
{
if (btnAddGroups.InvokeRequired)
{
btnAddGroups.Invoke(new MethodInvoker(delegate
{
btnAddGroups.Enabled = true;
AddLoggerGroupAdd("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddLoggerGroupAdd("------------------------------------------------------------------------------------------------------------------------------------");
btnExistGroup.Cursor = Cursors.Default;
}));
}
}
}
}
public void StartCrawlSpecificGroupUserPages(object parameter)
{
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
if (!Login.IsLoggedIn)
{
Login.LoginHttpHelper(ref HttpHelper);
}
try
{
if (Login.IsLoggedIn)
{
GroupStatus dataScrape = new GroupStatus();
GroupPages = dataScrape.PageNoSpecGroup(ref HttpHelper, SpeGroupIdFPages);
if (txtPages.InvokeRequired)
{
new Thread(() =>
{
txtPages.Invoke(new MethodInvoker(delegate
{
txtPages.Text = GroupPages;
}));
}).Start();
}
//AddLoggerGroupMemMessage("Loggin In With Email : " + item.Value._Username);
AddLoggerLinkedingrp("[ " + DateTime.Now + " ] => [ Loggin In With Email : " + item.Value._Username + " ]");
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Group Update --> StartDMMultiThreadedGroupUser() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Group Update --> StartDMMultiThreadedGroupUser() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinGetGroupMemberErrorLogs);
}
finally
{
counter_GroupMemberSearch--;
if (counter_GroupMemberSearch == 0)
{
if (cmbAllUser.InvokeRequired)
{
cmbAllUser.Invoke(new MethodInvoker(delegate
{
AddLoggerLinkedingrp("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddLoggerLinkedingrp("--------------------------------------------------------------------------------------------------------------------------");
cmbAllUser.Enabled = true;
cmbMemberGroup.Cursor = Cursors.Default;
}));
}
}
}
}
public void PostAddGroupUrl(object parameter)
{
try
{
try
{
if (IsStop)
{
return;
}
if (!IsStop)
{
lstLinkedinJoinGroupUrlThraed.Add(Thread.CurrentThread);
lstLinkedinJoinGroupUrlThraed.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
}
catch { }
if (!string.IsNullOrEmpty(txtNumberOfGroupsPerAccount.Text) && NumberHelper.ValidateNumber(txtNumberOfGroupsPerAccount.Text))
{
Groups.JoinSearchGroup.CountPerAccount = Convert.ToInt32(txtNumberOfGroupsPerAccount.Text);
}
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
List<string> lstJoinGroupUrl = (List<string>)paramsArray.GetValue(1);
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
Groups.JoinSearchGroup obj_JoinSearchGroup = new Groups.JoinSearchGroup(Login.accountUser, Login.accountPass, Login.proxyAddress, Login.proxyPort, Login.proxyUserName, Login.proxyPassword);
Login.logger.addToLogger += new EventHandler(logger_SearchGroupaddToLogger);
int minDelay = 20;
int maxDelay = 25;
if (!string.IsNullOrEmpty(txtSearchGroupMinDelay.Text) && NumberHelper.ValidateNumber(txtSearchGroupMinDelay.Text))
{
minDelay = Convert.ToInt32(txtSearchGroupMinDelay.Text);
}
if (!string.IsNullOrEmpty(txtSearchGroupMaxDelay.Text) && NumberHelper.ValidateNumber(txtSearchGroupMaxDelay.Text))
{
maxDelay = Convert.ToInt32(txtSearchGroupMaxDelay.Text);
}
//if (lstJoinGroupUrl.Count > 0)
//{
// JoinSearchGroup.JoinSearchGroup.lstLinkedinGroupURL = lstJoinGroupUrl;
//}
if (!Login.IsLoggedIn)
{
Login.LoginHttpHelper(ref HttpHelper);
}
if (Login.IsLoggedIn)
{
GroupStatus dataScrape = new GroupStatus();
Dictionary<string, string> Result = obj_JoinSearchGroup.PostAddOpenGroupsUsingUrl(ref HttpHelper, Login.accountUser, minDelay, maxDelay, lstJoinGroupUrl, IsDevideData);
LinkdInContacts.Add(Login.accountUser, Result);
}
//AddLoggerJoinGroupUrl("[ " + DateTime.Now + " ] => [ Now Joining Groups Process Running ]");
//string MessagePosted = obj_JoinSearchGroup.PostAddGroupUsingUrl(ref HttpHelper,LinkdInContacts, Login.accountUser, Login.accountPass, minDelay, maxDelay);
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Search Groups --> PostAddSearchGroups() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Search Groups --> PostAddSearchGroups() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinAddSearchGroupErrorLogs);
}
finally
{
counter_JoinGroupUrlID--;
if (counter_JoinGroupUrlID == 0)
{
btnJoinSearchGroup.Invoke(new MethodInvoker(delegate
{
AddLoggerJoinGroupUrl("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddLoggerJoinGroupUrl("----------------------------------------------------------------------------------------------------------");
btnJoinSearchGroup.Cursor = Cursors.Default;
}));
}
}
}
public void PostMessageGroupMembers(object parameter)
{
try
{
try
{
if (IsStop)
{
return;
}
if (!IsStop)
{
lstGroupMessageThread.Add(Thread.CurrentThread);
lstGroupMessageThread.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
}
catch (Exception ex)
{
Console.WriteLine("Error >>> " + ex.StackTrace);
}
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
AddLoggerGroupMemMessage("[ " + DateTime.Now + " ] => [ Sending Message From Account : " + item.Key + " ]");
string selectedusername = item.Key;
try
{
if (!Login.IsLoggedIn)
{
Login.LoginHttpHelper(ref HttpHelper);
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Compose Message --> PostMessageBulk() --> Login Process >>>>" + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Compose Message --> PostMessageBulk() --> Login Process >>>>" + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinComposeMessageErrorLogs);
}
try
{
if (Login.IsLoggedIn)
{
AddLoggerGroupMemMessage("[ " + DateTime.Now + " ] => [ Getting Contacts to Send Message ]");
List<string> SelectedItem = new List<string>();
string Userid = string.Empty;
if (cmbMemberGroup.InvokeRequired)
{
cmbMemberGroup.Invoke(new MethodInvoker(delegate
{
if (GroupStatus.selectAllGroup == false)
{
Userid = cmbMemberGroup.SelectedItem.ToString();
}
}));
}
GroupStatus MemberScrape = new GroupStatus();
string FromEmailId = MemberScrape.FromEmailCodeMsgGroupMem(ref HttpHelper, SpeGroupId);
string FromEmailName = MemberScrape.FromName(ref HttpHelper);
FromemailId = FromEmailId;
FromEmailNam = FromEmailName;
Dictionary<string, string> SelectedGroupMem = new Dictionary<string, string>();
foreach (KeyValuePair<string, Dictionary<string, string>> contacts in GrpMemNameWithGid)
{
if (contacts.Key.Trim() == item.Key.Trim())
{
foreach (KeyValuePair<string, string> Details in contacts.Value)
{
foreach (string itemChecked in chkListGroupMembers.CheckedItems)
{
if (itemChecked == Details.Value)
{
try
{
string id = Details.Key;
SelectedGroupMem.Add(id, Details.Value);
}
catch
{
}
}
}
}
}
}
string msgSub = txtSubject.Text;
string msgBody = txtBody.Text;
if (chkUseSpintax_GroupMessage.Checked)
{
try
{
msgSub = GrpMemSubjectlist[RandomNumberGenerator.GenerateRandom(0, GrpMemSubjectlist.Count - 1)];
msgBody = GrpMemMessagelist[RandomNumberGenerator.GenerateRandom(0, GrpMemMessagelist.Count - 1)];
}
catch
{
}
}
int minDelay = 20;
int maxDelay = 25;
if (!string.IsNullOrEmpty(txtMsgGroupMemMinDelay.Text) && NumberHelper.ValidateNumber(txtMsgGroupMemMinDelay.Text))
{
minDelay = Convert.ToInt32(txtMsgGroupMemMinDelay.Text);
}
if (!string.IsNullOrEmpty(txtMsgGroupMemMaxDelay.Text) && NumberHelper.ValidateNumber(txtMsgGroupMemMaxDelay.Text))
{
maxDelay = Convert.ToInt32(txtMsgGroupMemMaxDelay.Text);
}
try
{
Groups.MessageGroupMember obj_MessageGroupMember = new Groups.MessageGroupMember();
obj_MessageGroupMember.logger.addToLogger += new EventHandler(GroupMemMessage_addToLogger);
obj_MessageGroupMember.PostFinalMsgGroupMember_1By1(ref HttpHelper, SelectedGroupMem, GrpMemSubjectlist, GrpMemMessagelist, msgSub, msgBody, selectedusername, FromemailId, FromEmailNam, _SelectedGroupName_MessageGroupMember, SpeGroupId, mesg_with_tag, msg_spintaxt, minDelay, maxDelay, preventMsgSameGroup, preventMsgWithoutGroup, preventMsgGlobal);
obj_MessageGroupMember.logger.addToLogger -= new EventHandler(GroupMemMessage_addToLogger);
}
catch
{
}
finally
{
if (btnGroupMessage.InvokeRequired)
{
btnGroupMessage.Invoke(new MethodInvoker(delegate
{
AddLoggerGroupMemMessage("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddLoggerGroupMemMessage("----------------------------------------------------------------------------------------------------------------------------------------");
btnGroupMessage.Cursor = Cursors.Default;
}));
}
}
}
else if (!Login.IsLoggedIn)
{
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Compose Message --> PostMessageBulk() --> PostFinalMsg >>>>" + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Compose Message --> PostMessageBulk() --> PostFinalMsg >>>>" + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinComposeMessageErrorLogs);
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Compose Message --> PostMessageBulk() --> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Compose Message --> PostMessageBulk() --> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinComposeMessageErrorLogs);
}
}
public void StartCrawlSpecificGroupUser(object parameter)
{
try
{
try
{
if (IsStop)
{
return;
}
if (!IsStop)
{
lstGroupMessageThread.Add(Thread.CurrentThread);
lstGroupMessageThread.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
}
catch (Exception ex)
{
Console.WriteLine("Error >>> " + ex.StackTrace);
}
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
if (!Login.IsLoggedIn)
{
Login.LoginHttpHelper(ref HttpHelper);
}
try
{
if (Login.IsLoggedIn)
{
string selecteduser = string.Empty;
GroupStatus dataScrape = new GroupStatus();
dataScrape.loggerGroupMem.addToLogger += new EventHandler(GroupMemMessage_addToLogger);
cmbAllUser.Invoke(new MethodInvoker(delegate
{
selecteduser = cmbAllUser.SelectedItem.ToString();
}));
if (Login.accountUser == selecteduser)
{
//Login.LoginHttpHelper(ref HttpHelper);
if (GroupStatus.withExcelInput == true)
{
GroupMemData = dataScrape.AddSpecificGroupUserWithExcelInput(ref HttpHelper, Login.accountUser, SpeGroupId);
}
else
{
//GroupStatus.GroupMemUrl
if (chkAllAcounts.Checked)
{
foreach (var SpeGroupId1 in GroupStatus.GroupMemUrl)
{
Dictionary<string, string> GroupMem = dataScrape.AddSpecificGroupUser(ref HttpHelper, Login.accountUser, SpeGroupId1);
foreach (var GroupMem_item in GroupMem)
{
try
{
string GrpMemberKey = GroupMem_item.Key;
string GrpMemberValue = GroupMem_item.Value;
GroupMemData.Add(GrpMemberKey, GrpMemberValue);
}
catch { };
}
}
}
else
{
//SpeGroupId = GroupStatus.GroupMemUrl[0];
// GroupMemData = dataScrape.AddSpecificGroupUser(ref HttpHelper, Login.accountUser, SpeGroupId);
GroupMemData = dataScrape.AddSpecificGroupUser(ref HttpHelper, Login.accountUser, Specgroupdetails);
}
}
if (GroupMemData.Count == 0)
{
string[] SelUser = selectedSpeUser.Split(':');
AddLoggerLinkedingrp("[ " + DateTime.Now + " ] => [ Group : " + SelUser[1] + " Has No Other Member than You ]");
return;
}
GrpMemNameWithGid.Add(Login.accountUser, GroupMemData);
}
if (chkListGroupMembers.InvokeRequired)
{
new Thread(() =>
{
chkListGroupMembers.Invoke(new MethodInvoker(delegate
{
foreach (var itemM in GroupMemData)
{
chkListGroupMembers.Items.Add(itemM.Value);
}
}));
}).Start();
}
AddLoggerLinkedingrp("[ " + DateTime.Now + " ] => [ Added Group Members of : " + item.Value._Username + " ]");
}
else
{
AddLoggerLinkedingrp("[ " + DateTime.Now + " ] => [ LinkedIn account : " + Login.accountUser + " has been temporarily restricted ]");
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Group Update --> StartDMMultiThreadedGroupUser() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Group Update --> StartDMMultiThreadedGroupUser() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinGetGroupMemberErrorLogs);
}
}
catch (Exception ex)
{
Console.WriteLine("Error >>> " + ex.StackTrace);
}
}
public void PostMessageBulk(object parameter)
{
try
{
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
ComposeMessage.ComposeMessage obj_ComposeMessage = new ComposeMessage.ComposeMessage();
obj_ComposeMessage.logger.addToLogger += new EventHandler(ComposeMessage_addToLogger);
AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ Sending Message From Account : " + item.Key + " ]");
string UserEmail = string.Empty;
UserEmail = item.Key;
try
{
if (!Login.IsLoggedIn)
{
Login.LoginHttpHelper(ref HttpHelper);
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Compose Message --> PostMessageBulk() --> Login Process >>>>" + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Compose Message --> PostMessageBulk() --> Login Process >>>>" + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinComposeMessageErrorLogs);
}
try
{
if (Login.IsLoggedIn)
{
AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ Logged In With Email : " + item.Value._Username + " ]");
AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ Getting Contacts to Send Message ]");
List<string> SelectedItem = new List<string>();
string Userid = string.Empty;
if (cmbMsgFrom.InvokeRequired)
{
cmbMsgFrom.Invoke(new MethodInvoker(delegate
{
Userid = cmbMsgFrom.SelectedItem.ToString();
}));
}
GroupStatus MemberScrape = new GroupStatus();
//string FromEmailId = MemberScrape.FromEmailCode(ref HttpHelper, SpeGroupId);
string FromEmailId = MemberScrape.FromEmailCodeComposeMsg(ref HttpHelper, Userid);
string FromEmailName = MemberScrape.FromName(ref HttpHelper);
Dictionary<string, string> SelectedContacts = new Dictionary<string, string>();
foreach (KeyValuePair<string, Dictionary<string, string>> contacts in MessageContacts)
{
if (contacts.Key == item.Key)
{
foreach (KeyValuePair<string, string> Details in contacts.Value)
{
foreach (string itemChecked in chkMessageTo.CheckedItems)
{
if (itemChecked == Details.Value)
{
try
{
string id = Regex.Split(Details.Key, ":")[1];
SelectedContacts.Add(id, Details.Value);
}
catch
{
SelectedContacts.Add(Details.Key, Details.Value);
}
}
if (!(itemChecked == Details.Value))
{
try
{
string Value = Details.Value.Replace(",", string.Empty);
if (itemChecked == Value)
{
try
{
string id = Regex.Split(Details.Key, ":")[1];
SelectedContacts.Add(id, Details.Value);
}
catch
{
}
}
}
catch
{ }
}
}
}
}
}
string msgBodyCompose = txtMsgBody.Text;
string msgSubCompose = txtMsgSubject.Text;
if (chkSpinTaxComposeMsg.Checked)
{
try
{
//msgBodyCompose = MessagelistCompose[RandomNumberGenerator.GenerateRandom(0, MessagelistCompose.Count - 1)];
msgBodyCompose = GlobusSpinHelper.spinLargeText(new Random(), txtMsgBody.Text);
msgBodycomposePass = txtMsgBody.Text;
msgSubCompose = subjectlistCompose[RandomNumberGenerator.GenerateRandom(0, subjectlistCompose.Count - 1)];
}
catch
{
}
}
// Calling PostFinalMsg(ref HttpHelper, SelectedContacts, txtMsgSubject.Text, msgBodyCompose.ToString(),UserEmail); from Compose Messge Module
int minDelay = 20;
int maxDelay = 25;
if (!string.IsNullOrEmpty(txtComposeMsgMinDelay.Text) && NumberHelper.ValidateNumber(txtComposeMsgMinDelay.Text))
{
minDelay = Convert.ToInt32(txtComposeMsgMinDelay.Text);
}
if (!string.IsNullOrEmpty(txtComposeMsgMaxDelay.Text) && NumberHelper.ValidateNumber(txtComposeMsgMaxDelay.Text))
{
maxDelay = Convert.ToInt32(txtComposeMsgMaxDelay.Text);
}
if (RdbMessagingWithTag_ComposeMessage.Checked)
{
// obj_ComposeMessage.PostFinalMsg_1By1(ref HttpHelper, SelectedContacts, txtMsgSubject.Text, msgBodyCompose.ToString(), UserEmail, FromemailId, FromEmailNam, minDelay, maxDelay);
obj_ComposeMessage.PostFinalMsg_1By1(ref HttpHelper, SelectedContacts, subjectlistCompose, msgBodycomposePass, msgSubCompose.ToString(), msgBodyCompose.ToString(), UserEmail, FromEmailId, FromEmailName, msg_spintaxt, minDelay, maxDelay, preventMsgSameUser, preventMsgGlobalUser);
}
else
{
//obj_ComposeMessage.PostFinalMsg(ref HttpHelper, SelectedContacts, txtMsgSubject.Text, msgBodyCompose.ToString(), UserEmail, FromemailId, FromEmailNam, minDelay, maxDelay);
obj_ComposeMessage.PostFinalMsg(ref HttpHelper, SelectedContacts, msgBodycomposePass, subjectlistCompose, msgSubCompose.ToString(), msgBodyCompose.ToString(), UserEmail, FromEmailId, FromEmailName, msg_spintaxt, minDelay, maxDelay, preventMsgSameUser, preventMsgGlobalUser);
int counter = ComposeMessage.ComposeMessage.SlectedContacts1.Count();
if (counter > 0)
{
do
{
// obj_ComposeMessage.PostFinalMsg(ref HttpHelper, ComposeMessage.ComposeMessage.SlectedContacts1, txtMsgSubject.Text, msgBodyCompose.ToString(), UserEmail, FromemailId, FromEmailNam, minDelay, maxDelay);
obj_ComposeMessage.PostFinalMsg(ref HttpHelper, ComposeMessage.ComposeMessage.SlectedContacts1, msgBodycomposePass, subjectlistCompose, msgSubCompose.ToString(), msgBodyCompose.ToString(), UserEmail, FromEmailId, FromEmailNam, msg_spintaxt, minDelay, maxDelay, preventMsgSameUser, preventMsgGlobalUser);
counter = ComposeMessage.ComposeMessage.SlectedContacts1.Count();
} while (counter > 0);
}
}
obj_ComposeMessage.logger.addToLogger -= new EventHandler(ComposeMessage_addToLogger);
//PostFinalMsg(ref HttpHelper, SelectedContacts, txtMsgSubject.Text, msgBodyCompose.ToString(),UserEmail);
}
else if (!Login.IsLoggedIn)
{
AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ Couldn't Login With Email : " + item.Value._Username + "]");
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Compose Message --> PostMessageBulk() --> PostFinalMsg >>>>" + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Compose Message --> PostMessageBulk() --> PostFinalMsg >>>>" + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinComposeMessageErrorLogs);
}
#region old code
//AddLoggerComposeMessage("Compose Message From: " + Userid);
//string Mposted = MessagePosted.Split(':')[0];
//if (Mposted.Contains("Your message was successfully sent."))
//{
// AddLoggerComposeMessage("Message Posted To : All Selected Accounts");
//}
//else if (MessagePosted.Contains("Error"))
//{
// AddLoggerComposeMessage("Error in Post");
//}
//else
//{
// AddLoggerComposeMessage("Message Not Posted");
//}
#endregion
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Compose Message --> PostMessageBulk() --> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Compose Message --> PostMessageBulk() --> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinComposeMessageErrorLogs);
}
finally
{
if (chkSelectAll.Checked)
{
NoOfAccountsLoggedin--;
if (NoOfAccountsLoggedin == 0)
{
if (btnSendMsg.InvokeRequired)
{
btnSendMsg.Invoke(new MethodInvoker(delegate
{
AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddLoggerComposeMessage("-------------------------------------------------------------------------------------------------------------------------------");
btnSendMsg.Cursor = Cursors.Default;
}));
}
}
}
else
{
if (btnSendMsg.InvokeRequired)
{
btnSendMsg.Invoke(new MethodInvoker(delegate
{
AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddLoggerComposeMessage("-----------------------------------------------------------------------------------------------------------------------------------");
btnSendMsg.Cursor = Cursors.Default;
}));
}
}
}
}
public void PostAddGroups(object parameter)
{
try
{
try
{
if (IsStop)
{
return;
}
if (!IsStop)
{
lstJoinFriendGroupThread.Add(Thread.CurrentThread);
lstJoinFriendGroupThread.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
}
catch
{
}
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
GroupStatus obj_GroupStatus = new GroupStatus(Login.accountUser, Login.accountPass, Login.proxyAddress, Login.proxyPort, Login.proxyUserName, Login.proxyPassword);
if (!Login.IsLoggedIn)
{
Login.LoginHttpHelper(ref HttpHelper);
}
List<string> SelectedItem = new List<string>();
try
{
if (IsallaccChecked)
{
try
{
if (MemId.Count > 0)
{
GroupStatus.MemId = MemId;
}
foreach (string SelectedGrp in chkExistGroup.CheckedItems)
{
try
{
lstExistGroup.Add(SelectedGrp);
}
catch
{
}
}
if (lstExistGroup.Count > 0)
{
try
{
GroupStatus.lstExistGroup = lstExistGroup;
}
catch
{
}
}
try
{
GroupStatus.GrpAdd = GrpAdd;
}
catch
{
}
int minDelay = 20;
int maxDelay = 25;
if (!string.IsNullOrEmpty(txtGroupjoinMinDelay.Text) && NumberHelper.ValidateNumber(txtGroupjoinMinDelay.Text))
{
minDelay = Convert.ToInt32(txtGroupjoinMinDelay.Text);
}
if (!string.IsNullOrEmpty(txtGroupjoinMaxDelay.Text) && NumberHelper.ValidateNumber(txtGroupjoinMaxDelay.Text))
{
maxDelay = Convert.ToInt32(txtGroupjoinMaxDelay.Text);
}
string MessagePosted = obj_GroupStatus.PostGroupAddFinal(Login.accountUser, Login.accountPass, minDelay, maxDelay);
Thread.Sleep(2000);
}
catch
{
}
}
else
{
if (label48.Text == Login.accountUser)
{
try
{
if (MemId.Count > 0)
{
GroupStatus.MemId = MemId;
}
foreach (string SelectedGrp in chkExistGroup.CheckedItems)
{
try
{
lstExistGroup.Add(SelectedGrp);
}
catch
{
}
}
if (lstExistGroup.Count > 0)
{
try
{
GroupStatus.lstExistGroup = lstExistGroup;
}
catch
{
}
}
try
{
GroupStatus.GrpAdd = GrpAdd;
}
catch
{
}
int minDelay = 20;
int maxDelay = 25;
if (!string.IsNullOrEmpty(txtGroupjoinMinDelay.Text) && NumberHelper.ValidateNumber(txtGroupjoinMinDelay.Text))
{
minDelay = Convert.ToInt32(txtGroupjoinMinDelay.Text);
}
if (!string.IsNullOrEmpty(txtGroupjoinMaxDelay.Text) && NumberHelper.ValidateNumber(txtGroupjoinMaxDelay.Text))
{
maxDelay = Convert.ToInt32(txtGroupjoinMaxDelay.Text);
}
string MessagePosted = obj_GroupStatus.PostGroupAddFinal(Login.accountUser, Login.accountPass, minDelay, maxDelay);
Thread.Sleep(2000);
}
catch
{
}
}
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> PostAddGroups() ---1--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> PostAddGroups() ---1--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinAddFriendsGroupErrorLogs);
}
finally
{
counter_GroupMemberSearch--;
if (counter_GroupMemberSearch == 0)
{
if (btnJoinMemGroup.InvokeRequired)
{
btnJoinMemGroup.Invoke(new MethodInvoker(delegate
{
AddLoggerGroupAdd("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddLoggerGroupAdd("------------------------------------------------------------------------------------------------------------------------------------");
btnJoinMemGroup.Enabled = true;
btnJoinMemGroup.Cursor = Cursors.Default;
}));
}
}
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> PostAddGroups() ---2--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> PostAddGroups() ---2--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinAddFriendsGroupErrorLogs);
}
}
private void btn_GroupStatusUpdate_GetGroups_Click(object sender, RoutedEventArgs e)
{
try
{
if(!string.IsNullOrEmpty(GlobalsGroups.selectedAccount))
{
GroupStatus objGroupStatus=new GroupStatus();
Thread thrThreadStartGroupStatus = new Thread(objGroupStatus.ThreadStartGroupStatus);
thrThreadStartGroupStatus.Start();
}
else
{
GlobusLogHelper.log.Info("Please select Account first.");
MessageBox.Show("Please select Account first.");
}
}
catch (Exception ex)
{
}
}
//****************for Search Group**********************//
#region AddSearchGroup
public void AddSearchGroup(ref GlobusHttpHelper GlobusHttpHelper, string Email, string Password, string proxyAddress, int ProxyPort, string proxyUsername, string proxyPassword)
{
LinkedinLogin Login = new LinkedinLogin();
try
{
if (!string.IsNullOrEmpty(CampainGroupCreate.GroupCount) && NumberHelper.ValidateNumber(CampainGroupCreate.GroupCount))
{
Groups.JoinSearchGroup.BoxGroupCount = Convert.ToInt32(CampainGroupCreate.GroupCount);
}
else
{
if (string.IsNullOrEmpty(CampainGroupCreate.GroupCount))
{
}
else
{
MessageBox.Show("Enter No. of Group in Numeric Form !");
return;
}
}
lstJoinSearchGroupThread.Clear();
if (CampainGroupCreate.SearchKeyword == string.Empty)
{
AddLoggerLinkedInProfileManager("[ " + DateTime.Now + " ] => [ Please Enter Keyword to Search.. ]");
MessageBox.Show("Please Enter Keyword to Search..");
txtSearchKeyword.Focus();
return;
}
AddLoggerLinkedInProfileManager("[ " + DateTime.Now + " ] => [ Starting Search for Groups.. ]");
Login.accountUser = Email;
Login.accountPass = Password;
Login.proxyAddress = proxyAddress;
Login.proxyPort = ProxyPort.ToString();
Login.proxyUserName = proxyUsername;
Login.proxyPassword = proxyPassword;
Groups.JoinSearchGroup obj_JoinSearchGroup = new Groups.JoinSearchGroup(Email, Password, proxyAddress, ProxyPort.ToString(), proxyUsername, proxyPassword);
obj_JoinSearchGroup.logger.addToLogger += new EventHandler(logger_LinkedInProfileManageraddToLogger);
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
if (!Login.IsLoggedIn)
{
Login.LoginHttpHelper(ref HttpHelper);
AddLoggerLinkedInProfileManager("[ " + DateTime.Now + " ] => [ Logging In With Email : " + Email + " ]");
}
AddLoggerLinkedInProfileManager("[ " + DateTime.Now + " ] => [ Searching Groups Process Running..Please wait.. ]");
if (Login.IsLoggedIn)
{
GroupStatus dataScrape = new GroupStatus();
try
{
CampainGroupCreate.Result = obj_JoinSearchGroup.PostAddOpenGroups(ref HttpHelper, CampainGroupCreate.SearchKeyword.ToString().Trim(), Email);
int count = 5;
if (!string.IsNullOrEmpty(CampainGroupCreate.GroupCount) && NumberHelper.ValidateNumber(CampainGroupCreate.GroupCount))
{
count = Convert.ToInt32(CampainGroupCreate.GroupCount);
}
CampainGroupCreate.LinkdInContacts.Add(Login.accountUser, CampainGroupCreate.Result);
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Search Groups --> --1--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Search Groups --> --1--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinAddSearchGroupErrorLogs);
}
if (CampainGroupCreate.Result.Count == 0)
{
AddLoggerLinkedInProfileManager("[ " + DateTime.Now + " ] => [ Sorry, there are no group Search results matching your search criteria.. ]");
}
else
{
AddLoggerLinkedInProfileManager("[ " + DateTime.Now + " ] => [ Groups..Searched Successfully..For " + Login.accountUser + " ]");
}
foreach (var item in CampainGroupCreate.Result)
{
CampainGroupCreate.lstSearchGroup.Add(item.Key + ":" + item.Value);
}
AddLoggerLinkedInProfileManager("[ " + DateTime.Now + " ] => [ Now Joining Groups ]");
string MessagePosted = obj_JoinSearchGroup.PostSearchGroupAddFinal(ref HttpHelper, Email, Password, CampainGroupCreate.lstSearchGroup,0,0);
Login.logger.addToLogger -= new EventHandler(logger_LinkedInProfileManageraddToLogger);
obj_JoinSearchGroup.logger.addToLogger -= new EventHandler(logger_LinkedInProfileManageraddToLogger);
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Search Groups --> btnAddSearchGroup_Click() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Search Groups --> btnAddSearchGroup_Click() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinAddSearchGroupErrorLogs);
}
}
public void StartDMMultiThreadedComposeMessage(object parameter)
{
try
{
if (Globals.IsStop)
{
if (IsStopMessage)
{
return;
}
return;
}
Globals.lstComposeMessageThread.Add(Thread.CurrentThread);
Globals.lstComposeMessageThread.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
catch
{ }
string Account = string.Empty;
try
{
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
Account = item.Key;
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
GroupStatus MemberScrape = new GroupStatus();
Login.logger.addToLogger += new EventHandler(ComposeMessage_addToLogger);
MemberScrape.loggergrpupdate.addToLogger += new EventHandler(ComposeMessage_addToLogger);
if (!Login.IsLoggedIn)
{
//AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ Logging In With Email : " + item.Value._Username + " ]");
// AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ Login Process is Running... ]");
Login.LoginHttpHelper(ref HttpHelper);
if (Login.IsLoggedIn)
{
//AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ LoggedIn With Email : " + item.Value._Username + "]");
}
else
{
Login.LoginHttpHelper(ref HttpHelper);
}
}
try
{
if (Login.IsLoggedIn)
{
//GroupStatus MemberScrape = new GroupStatus();
AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ Process Adding Members From Uploaded Emails is Running... ]");
if (GroupStatus.withExcelInput == true)
{
chkMessageTo.Invoke(new MethodInvoker(delegate
{
chkMessageTo.Items.Clear();
MessageContacts.Clear();
}));
Dictionary<string, string> Result = MemberScrape.PostaddMembersWithExcelInput(ref HttpHelper, Login.accountUser);
MessageContacts.Add(Login.accountUser, Result);
}
else
{
chkMessageTo.Invoke(new MethodInvoker(delegate
{
chkMessageTo.Items.Clear();
MessageContacts.Clear();
}));
GroupStatus.moduleLog = "composemsg";
Dictionary<string, string> Result = MemberScrape.PostAddMembers(ref HttpHelper, Login.accountUser);
MessageContacts.Add(Login.accountUser, Result);
}
AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ Member Added Successfully : " + Login.accountUser + " ]");
if (cmbMsgFrom.InvokeRequired)
{
new Thread(() =>
{
cmbMsgFrom.Invoke(new MethodInvoker(delegate
{
cmbMsgFrom.Items.Add(Login.accountUser);
cmbMsgFrom.SelectedIndex = 0;
}));
}).Start();
}
}
else
{
AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ Account : " + Login.accountUser + " Not Logged In ]");
}
Login.logger.addToLogger -= new EventHandler(ComposeMessage_addToLogger);
MemberScrape.loggergrpupdate.addToLogger += new EventHandler(ComposeMessage_addToLogger);
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> StartDMMultiThreadedComposeMessage() --> Getting Contact Values --> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> StartDMMultiThreadedComposeMessage() --> Getting Contact Values -->" + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinComposeMessageErrorLogs);
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> StartDMMultiThreadedComposeMessage() --> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> StartDMMultiThreadedComposeMessage() --> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinComposeMessageErrorLogs);
}
finally
{
if (IsStopMessage)
{
AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ Finished Adding Contacts To Email : " + Account + " ]");
counter_compose_msg--;
if (counter_compose_msg == 0)
{
if (btnMsgFrom.InvokeRequired)
{
btnMsgFrom.Invoke(new MethodInvoker(delegate
{
AddLoggerComposeMessage("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddLoggerComposeMessage("--------------------------------------------------------------------------------------------------------------------------------");
btnMsgFrom.Cursor = Cursors.Default;
}));
}
}
}
}
}
private void btn_GroupStatusUpdate_SendUpdate_Click(object sender, RoutedEventArgs e)
{
#region Settings
try
{
if(!string.IsNullOrEmpty(txt_GroupStatusUpdate_MinDelay.Text)&&!string.IsNullOrEmpty(txt_GroupStatusUpdate_MaxDelay.Text))
{
GlobalsGroups.minDelay = Convert.ToInt32(txt_GroupStatusUpdate_MinDelay.ToString());
GlobalsGroups.maxDelay=Convert.ToInt32(txt_GroupStatusUpdate_MaxDelay.ToString());
}
else
{
GlobusLogHelper.log.Info("Delay field can't be empty.");
}
if(chk_GroupStatusUpdate_GetGroups.IsChecked==true)
{
GlobalsGroups.chkGroup = true;
}
else
{
GlobalsGroups.chkGroup = false;
}
}
catch (Exception ex)
{
}
#endregion
try
{
GroupStatus objGroupStatus = new GroupStatus();
Thread thrThreadStartGroupStatus = new Thread(objGroupStatus.ThreadStartGroupStatus);
thrThreadStartGroupStatus.Start();
}
catch (Exception ex)
{
}
}
public void StartDMMultiThreadedGroupMemberUser(object parameter)
{
try
{
try
{
if (IsStop)
{
return;
}
if (!IsStop)
{
lstGroupMessageThread.Add(Thread.CurrentThread);
lstGroupMessageThread.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
}
catch (Exception ex)
{
Console.WriteLine("Error >>> " + ex.StackTrace);
}
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
Login.logger.addToLogger += new EventHandler(LinkedingrpLogEvents_addToLogger);
if (!Login.IsLoggedIn)
{
Login.LoginHttpHelper(ref HttpHelper);
}
try
{
if (Login.IsLoggedIn)
{
GroupStatus dataScrape = new GroupStatus();
Thread.Sleep(2000);
Dictionary<string, string> Data = dataScrape.PostCreateGroupNames(ref HttpHelper, Login.accountUser);
GrpMemMess.Add(Login.accountUser, Data);
if (cmbAllUser.InvokeRequired)
{
new Thread(() =>
{
cmbAllUser.Invoke(new MethodInvoker(delegate
{
if (!cmbAllUser.Items.Contains(Login.accountUser))
{
cmbAllUser.Items.Add(Login.accountUser);
}
}));
}).Start();
}
}
else
{
//AddLoggerGroupMemMessage("LinkedIn account : " + Login.accountUser + " has been temporarily restricted");
//AddLoggerLinkedingrp("[ " + DateTime.Now + " ] => [ LinkedIn account : " + Login.accountUser + " has been temporarily restricted ]");
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> frmmain() --> StartDMMultiThreadedGroupMemberUser() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> frmmain() --> StartDMMultiThreadedGroupMemberUser() >>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinGetGroupMemberErrorLogs);
}
finally
{
counter_GroupMemberSearch--;
if (counter_GroupMemberSearch == 0)
{
if (cmbAllUser.InvokeRequired)
{
cmbAllUser.Invoke(new MethodInvoker(delegate
{
cmbAllUser.Enabled = true;
AddLoggerLinkedingrp("[ " + DateTime.Now + " ] => [ PROCESS COMPLETE..Please select Account ]");
AddLoggerLinkedingrp("----------------------------------------------------------------------------------------------------------------------------------------");
btnGetGroup.Cursor = Cursors.Default;
}));
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("Error >>> " + ex.StackTrace);
}
}
public void GetGroupMember(ref GlobusHttpHelper httpHelper)
{
try
{
foreach (string item in LstGroupURL)
{
try
{
if (!isPathCreated)
{
//File Path At Runtime
isPathCreated = true;
Globals.path_ScrappedMembersFromGroup = DateTime.Now.ToString("MM_dd_yyyy hh_mm_ss");
}
Log("[ " + DateTime.Now + " ] => [ Start Finding Group Member With The URL >>> " + item + " With Username >>> " + _UserName + " ]");
string groupId = string.Empty;
string groupIdPart = item.Substring(item.IndexOf("/groups"), item.Length - item.IndexOf("/groups")).Trim();
int startindex = groupIdPart.IndexOf("&gid=");
if (startindex < 0)
{
startindex = groupIdPart.IndexOf("gid=");
}
string start = groupIdPart.Substring(startindex).Replace("&gid=", string.Empty).Replace("gid=", string.Empty);
int endindex = start.IndexOf("&");
if (endindex < 0)
{
start = start + "&";
endindex = start.IndexOf("&");
}
string end = start.Substring(0, endindex);
groupId = end.Trim();
//if (item.Contains("gid") && item.Contains("/groups"))
//{
// string groupIdPart = item.Substring(item.IndexOf("/groups"), item.Length - item.IndexOf("/groups")).Trim();
// string[] numArr = Regex.Split(groupIdPart, "^[0-9]*$");
// foreach (string item1 in numArr)
// {
// try
// {
// if (!string.IsNullOrEmpty(item1))
// {
// groupId = item1.Trim();
// break;
// }
// }
// catch (Exception ex)
// {
// }
// }
//}
//if (item.Contains("/groups"))
//{
// string groupIdPart = item.Substring(item.IndexOf("/groups"), item.Length - item.IndexOf("/groups")).Trim();
// string[] numArr = Regex.Split(groupIdPart, "[^0-9]");
// foreach (string item1 in numArr)
// {
// try
// {
// if (!string.IsNullOrEmpty(item1))
// {
// groupId = item1.Trim();
// break;
// }
// }
// catch (Exception ex)
// {
// }
// }
//}
Log("[ " + DateTime.Now + " ] => [ Please Wait........Process is Running ]");
GroupStatus dataScrape = new GroupStatus();
List<string> lstGrpMemberProfileURLs = dataScrape.GetAllGrpMember(ref httpHelper, groupId);
//Dictionary<string,string> dicGrpMem=dataScrape.AddSpecificGroupUser(ref httpHelper, groupId, 25);
//GetGroupMemberInfo(ref httpHelper, lstGrpMemberProfileURLs);
}
catch (Exception ex)
{
Console.WriteLine("Error : " + ex.StackTrace);
}
}
Log("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED of Finding Member With Username >>> " + _UserName + " ]");
Log("-----------------------------------------------------------------------------------------------------------------------------------");
}
catch (Exception ex)
{
Console.WriteLine("Error : " + ex.StackTrace);
}
}
public void PostRemovePendingGroups(object parameter)
{
try
{
try
{
if (IsStop)
{
return;
}
if (!IsStop)
{
lstRemovePendingGroupThread.Add(Thread.CurrentThread);
lstRemovePendingGroupThread.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
}
catch
{
}
Array paramsArray = new object[1];
paramsArray = (Array)parameter;
KeyValuePair<string, LinkedInMaster> item = (KeyValuePair<string, LinkedInMaster>)paramsArray.GetValue(0);
GlobusHttpHelper HttpHelper = new GlobusHttpHelper();
LinkedinLogin Login = new LinkedinLogin();
Login.accountUser = item.Key;
Login.accountPass = item.Value._Password;
Login.proxyAddress = item.Value._ProxyAddress;
Login.proxyPort = item.Value._ProxyPort;
Login.proxyUserName = item.Value._ProxyUsername;
Login.proxyPassword = item.Value._ProxyPassword;
GroupStatus obj_GroupStatus = new GroupStatus();
obj_GroupStatus = new GroupStatus(Login.accountUser, Login.accountPass, Login.proxyAddress, Login.proxyPort, Login.proxyUserName, Login.proxyPassword);
obj_GroupStatus.loggerRemPendingGroup.addToLogger += new EventHandler(GroupStatus_addToLogger);
if (!Login.IsLoggedIn)
{
Login.LoginHttpHelper(ref HttpHelper);
}
List<string> SelectedItem = new List<string>();
try
{
if (label1.Text == Login.accountUser)
{
#region old commented code
//if (IsallaccChecked)
//{
// try
// {
// foreach (string SelectedGrp in chkPendingGroup.CheckedItems)
// {
// foreach (var itemID in LinkdInContacts)
// {
// if (SelectedGrp.Split(':')[0] == itemID.Key)
// {
// if (label1.Text == itemID.Key)
// {
// foreach (KeyValuePair<string, string> itemGid in itemID.Value)
// {
// if (SelectedGrp.Split(':')[1] == itemGid.Key.Split(':')[1])
// {
// try
// {
// lstPendingGroup.Add(itemGid.Key + ":" + itemGid.Value);
// }
// catch
// {
// }
// }
// }
// }
// }
// }
// }
// if (lstPendingGroup.Count > 0)
// {
// try
// {
// GroupStatus.lstPendingGroup = lstPendingGroup;
// }
// catch
// {
// }
// }
// int minDelay = 20;
// int maxDelay = 25;
// if (!string.IsNullOrEmpty(txtPendingGroupMinDelay.Text) && NumberHelper.ValidateNumber(txtPendingGroupMinDelay.Text))
// {
// minDelay = Convert.ToInt32(txtPendingGroupMinDelay.Text);
// }
// if (!string.IsNullOrEmpty(txtPendingGroupMaxDelay.Text) && NumberHelper.ValidateNumber(txtPendingGroupMaxDelay.Text))
// {
// maxDelay = Convert.ToInt32(txtPendingGroupMaxDelay.Text);
// }
// string MessagePosted = obj_GroupStatus.PostRemovePendingGroups(Login.accountUser, Login.accountPass, minDelay, maxDelay);
// Thread.Sleep(2000);
// }
// catch
// {
// }
//}
//else
//{
#endregion
try
{
foreach (string SelectedGrp in chkPendingGroup.CheckedItems)
{
foreach (var itemID in LinkdInContacts)
{
foreach (KeyValuePair<string, string> itemGid in itemID.Value)
{
if (SelectedGrp.Split(':')[1] == itemID.Key)
{
if (SelectedGrp.Split(':')[0] == itemGid.Key.Split(':')[0])
{
try
{
lstPendingGroup.Add(itemGid.Key + ":" + itemGid.Value);
}
catch
{
}
}
}
}
}
}
if (lstPendingGroup.Count > 0)
{
try
{
GroupStatus.lstPendingGroup = lstPendingGroup;
}
catch
{
}
}
int minDelay = 20;
int maxDelay = 25;
if (!string.IsNullOrEmpty(txtPendingGroupMinDelay.Text) && NumberHelper.ValidateNumber(txtPendingGroupMinDelay.Text))
{
minDelay = Convert.ToInt32(txtPendingGroupMinDelay.Text);
}
if (!string.IsNullOrEmpty(txtPendingGroupMaxDelay.Text) && NumberHelper.ValidateNumber(txtPendingGroupMaxDelay.Text))
{
maxDelay = Convert.ToInt32(txtPendingGroupMaxDelay.Text);
}
string MessagePosted = obj_GroupStatus.PostRemovePendingGroups(Login.accountUser, Login.accountPass, minDelay, maxDelay);
Thread.Sleep(2000);
}
catch
{
}
//}
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Pending Groups --> PostRemovePendingGroups() ---1--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Pending Groups --> PostRemovePendingGroups() ---1--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinPendingGroupErrorLogs);
}
}
catch (Exception ex)
{
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> PostAddGroups() ---2--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinErrorLogs);
GlobusFileHelper.AppendStringToTextfileNewLine("DateTime :- " + DateTime.Now + " :: Error --> Add Friends Groups --> PostAddGroups() ---2--->>>> " + ex.Message + "StackTrace --> >>>" + ex.StackTrace, Globals.Path_LinkedinPendingGroupErrorLogs);
}
finally
{
counter_PendGroupRemoved--;
if (counter_PendGroupRemoved == 0)
{
if (btnRemovePendingGroup.InvokeRequired)
{
btnRemovePendingGroup.Invoke(new MethodInvoker(delegate
{
AddLoggerPendingGroups("[ " + DateTime.Now + " ] => [ PROCESS COMPLETED ]");
AddLoggerPendingGroups("------------------------------------------------------------------------------------------------------------------------------------");
btnRemovePendingGroup.Enabled = true;
btnRemovePendingGroup.Cursor = Cursors.Default;
}));
}
}
}
}
