public void getProfileCount()
{
SocioBoard.Domain.User user = (User)Session["LoggedUser"];
SocialProfilesRepository objProfile = new SocialProfilesRepository();
List <SocialProfile> lstProfile = objProfile.getAllSocialProfilesOfUser(user.Id);
strProfileCOunt = lstProfile.Count().ToString();
}
public void GetUerProfile(GooglePlusAccount objgpAcc, string acces_token, string refresh_token, Guid UserId)
{
PeopleController obj = new PeopleController();
oAuthToken objtoken = new oAuthToken();
GooglePlusAccountRepository objgpRepo = new GooglePlusAccountRepository();
SocialProfilesRepository socioprofilerepo = new SocialProfilesRepository();
SocialProfile socioprofile = new SocialProfile();
socioprofile.Id = Guid.NewGuid();
socioprofile.ProfileDate = DateTime.Now;
socioprofile.ProfileId = objgpAcc.GpUserId;
socioprofile.ProfileType = "googleplus";
socioprofile.UserId = UserId;
JArray objPeopleList = obj.GetPeopleList(objgpAcc.GpUserId, acces_token, "visible");
objgpAcc.PeopleCount = objPeopleList.Count();
if (!objgpRepo.checkGooglePlusUserExists(objgpAcc.GpUserId, UserId))
{
objgpRepo.addGooglePlusUser(objgpAcc);
if (!socioprofilerepo.checkUserProfileExist(socioprofile))
{
socioprofilerepo.addNewProfileForUser(socioprofile);
}
else
{
socioprofilerepo.updateSocialProfile(socioprofile);
}
}
else
{
objgpRepo.updateGooglePlusUser(objgpAcc);
if (!socioprofilerepo.checkUserProfileExist(socioprofile))
{
socioprofilerepo.addNewProfileForUser(socioprofile);
}
else
{
socioprofilerepo.updateSocialProfile(socioprofile);
}
}
GetUserActivities(objgpAcc.GpUserId, acces_token, UserId);
}
public DataSet bindSentMessagesToDataTable(User user, string network)
{
SocialProfilesRepository socioprofrepo = new SocialProfilesRepository();
List <SocialProfile> alstprofiles = socioprofrepo.getAllSocialProfilesOfUser(user.Id);
Messages mstable = new Messages();
DataSet ds = DataTableGenerator.CreateDataSetForTable(mstable);
foreach (SocialProfile item in alstprofiles)
{
if (item.ProfileType == "facebook")
{
FacebookMessageRepository fbmsgrepo = new FacebookMessageRepository();
List <FacebookMessage> alstfbmsgs = fbmsgrepo.getAllSentMessages(item.ProfileId);
if (alstfbmsgs != null)
{
if (alstfbmsgs.Count != 0)
{
foreach (FacebookMessage facebookmsg in alstfbmsgs)
{
ds.Tables[0].Rows.Add(facebookmsg.ProfileId, "facebook", facebookmsg.FromId, facebookmsg.FromName, facebookmsg.FromProfileUrl, facebookmsg.MessageDate, facebookmsg.Message, facebookmsg.FbComment, facebookmsg.FbLike, facebookmsg.MessageId, facebookmsg.Type);
}
}
}
}
else if (item.ProfileType == "twitter")
{
TwitterDirectMessageRepository twtmsgrepo = new TwitterDirectMessageRepository();
List <TwitterDirectMessages> lstmsgtwtuser = twtmsgrepo.getAllDirectMessagesById(item.ProfileId);
foreach (TwitterDirectMessages lst in lstmsgtwtuser)
{
ds.Tables[0].Rows.Add(lst.SenderId, "twitter", lst.SenderId, lst.SenderScreenName, lst.SenderProfileUrl, lst.CreatedDate, lst.Message, "", "", lst.MessageId, lst.Type);
}
}
else if (item.ProfileType == "googleplus")
{
}
}
return(ds);
}
/// <summary>
///
/// </summary>
private void getTwitterUserProfile()
{
var requestToken = (String)Request.QueryString["oauth_token"];
var requestSecret = (String)Session["requestSecret"];
var requestVerifier = (String)Request.QueryString["oauth_verifier"];
OAuth.AccessToken = requestToken;
OAuth.AccessTokenSecret = requestVerifier;
OAuth.AccessTokenGet(requestToken, requestVerifier);
JArray profile = userinfo.Get_Users_LookUp_ByScreenName(OAuth, OAuth.TwitterScreenName);
User user = (User)Session["LoggedUser"];
SocialProfilesRepository socioprofilerepo = new SocialProfilesRepository();
SocialProfile socioprofile = new SocialProfile();
#region for managing referrals
ManageReferrals(OAuth);
#endregion
foreach (var item in profile)
{
try
{
twitterAccount.FollowingCount = Convert.ToInt32(item["friends_count"].ToString());
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
try
{
twitterAccount.FollowersCount = Convert.ToInt32(item["followers_count"].ToString());
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
twitterAccount.Id = Guid.NewGuid();
twitterAccount.IsActive = true;
twitterAccount.OAuthSecret = OAuth.AccessTokenSecret;
twitterAccount.OAuthToken = OAuth.AccessToken;
try
{
twitterAccount.ProfileImageUrl = item["profile_image_url"].ToString().TrimStart('"').TrimEnd('"');
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
try
{
twitterAccount.ProfileUrl = string.Empty;
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
try
{
twitterAccount.TwitterUserId = item["id_str"].ToString().TrimStart('"').TrimEnd('"');
}
catch (Exception er)
{
try
{
twitterAccount.TwitterUserId = item["id"].ToString().TrimStart('"').TrimEnd('"');
}
catch (Exception err)
{
Console.WriteLine(err.StackTrace);
}
Console.WriteLine(er.StackTrace);
}
try
{
twitterAccount.TwitterScreenName = item["screen_name"].ToString().TrimStart('"').TrimEnd('"');
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
twitterAccount.UserId = user.Id;
socioprofile.Id = Guid.NewGuid();
socioprofile.ProfileDate = DateTime.Now;
socioprofile.ProfileId = twitterAccount.TwitterUserId;
socioprofile.ProfileType = "twitter";
socioprofile.UserId = user.Id;
if (HttpContext.Current.Session["login"] != null)
{
if (HttpContext.Current.Session["login"].ToString().Equals("twitter"))
{
User usr = new User();
UserRepository userrepo = new UserRepository();
Registration regObject = new Registration();
usr.AccountType = "free";
usr.CreateDate = DateTime.Now;
usr.ExpiryDate = DateTime.Now.AddMonths(1);
usr.Id = Guid.NewGuid();
usr.UserName = twitterAccount.TwitterName;
usr.Password = regObject.MD5Hash(twitterAccount.TwitterName);
usr.EmailId = "";
usr.UserStatus = 1;
if (!userrepo.IsUserExist(usr.EmailId))
{
UserRepository.Add(usr);
}
}
}
TwitterStatsRepository objTwtstats = new TwitterStatsRepository();
TwitterStats objStats = new TwitterStats();
Random rNum = new Random();
objStats.Id = Guid.NewGuid();
objStats.TwitterId = twitterAccount.TwitterUserId;
objStats.UserId = user.Id;
objStats.FollowingCount = twitterAccount.FollowingCount;
objStats.FollowerCount = twitterAccount.FollowersCount;
objStats.Age1820 = rNum.Next(twitterAccount.FollowersCount);
objStats.Age2124 = rNum.Next(twitterAccount.FollowersCount);
objStats.Age2534 = rNum.Next(twitterAccount.FollowersCount);
objStats.Age3544 = rNum.Next(twitterAccount.FollowersCount);
objStats.Age4554 = rNum.Next(twitterAccount.FollowersCount);
objStats.Age5564 = rNum.Next(twitterAccount.FollowersCount);
objStats.Age65 = rNum.Next(twitterAccount.FollowersCount);
objStats.EntryDate = DateTime.Now;
if (!objTwtstats.checkTwitterStatsExists(twitterAccount.TwitterUserId, user.Id))
{
objTwtstats.addTwitterStats(objStats);
}
if (!twtrepo.checkTwitterUserExists(twitterAccount.TwitterUserId, user.Id))
{
twtrepo.addTwitterkUser(twitterAccount);
if (!socioprofilerepo.checkUserProfileExist(socioprofile))
{
socioprofilerepo.addNewProfileForUser(socioprofile);
GroupRepository objGroupRepository = new GroupRepository();
SocioBoard.Domain.Team team = (SocioBoard.Domain.Team)HttpContext.Current.Session["GroupName"];
Groups lstDetails = objGroupRepository.getGroupName(team.GroupId);
if (lstDetails.GroupName == "Socioboard")
{
TeamMemberProfileRepository objTeamMemberProfileRepository = new TeamMemberProfileRepository();
TeamMemberProfile teammemberprofile = new TeamMemberProfile();
teammemberprofile.Id = Guid.NewGuid();
teammemberprofile.TeamId = team.Id;
teammemberprofile.ProfileId = twitterAccount.TwitterUserId;
teammemberprofile.ProfileType = "twitter";
teammemberprofile.StatusUpdateDate = DateTime.Now;
objTeamMemberProfileRepository.addNewTeamMember(teammemberprofile);
}
}
else
{
socioprofilerepo.updateSocialProfile(socioprofile);
}
}
else
{
HttpContext.Current.Session["alreadyexist"] = twitterAccount;
twtrepo.updateTwitterUser(twitterAccount);
TwitterMessageRepository twtmsgreponew = new TwitterMessageRepository();
twtmsgreponew.updateScreenName(twitterAccount.TwitterUserId, twitterAccount.TwitterScreenName);
if (!socioprofilerepo.checkUserProfileExist(socioprofile))
{
socioprofilerepo.addNewProfileForUser(socioprofile);
}
else
{
socioprofilerepo.updateSocialProfile(socioprofile);
}
}
if (Session["UserAndGroupsForTwitter"] != null)
{
if (Session["UserAndGroupsForTwitter"].ToString() == "twitter")
{
try
{
if (Session["GroupName"] != null)
{
Groups group = (Groups)Session["GroupName"];
GroupProfile groupprofile = new GroupProfile();
GroupProfileRepository groupprofilerepo = new GroupProfileRepository();
groupprofile.Id = Guid.NewGuid();
groupprofile.ProfileId = socioprofile.ProfileId;
groupprofile.ProfileType = "twitter";
groupprofile.GroupOwnerId = user.Id;
groupprofile.EntryDate = DateTime.Now;
groupprofile.GroupId = group.Id;
if (!groupprofilerepo.checkGroupProfileExists(user.Id, group.Id, groupprofile.ProfileId))
{
groupprofilerepo.AddGroupProfile(groupprofile);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
}
}
}
}
protected void btnRegister_Click(object sender, ImageClickEventArgs e)
{
try
{
User user = new User();
UserRepository userrepo = new UserRepository();
UserActivation objUserActivation = new UserActivation();
Coupon objCoupon = new Coupon();
CouponRepository objCouponRepository = new CouponRepository();
Groups groups = new Groups();
GroupRepository objGroupRepository = new GroupRepository();
Team teams = new Team();
TeamRepository objTeamRepository = new TeamRepository();
SocioBoard.Helper.SessionFactory.configfilepath = Server.MapPath("~/hibernate.cfg.xml");
try
{
if (DropDownList1.SelectedValue == "Free" || DropDownList1.SelectedValue == "Standard" || DropDownList1.SelectedValue == "Deluxe" || DropDownList1.SelectedValue == "Premium" || DropDownList1.SelectedValue == "SocioBasic" || DropDownList1.SelectedValue == "SocioStandard" || DropDownList1.SelectedValue == "SocioPremium" || DropDownList1.SelectedValue == "SocioDeluxe")
{
if (TextBox1.Text.Trim() != "")
{
string resp = SBUtils.GetCouponStatus(TextBox1.Text).ToString();
if (resp != "valid")
{
ScriptManager.RegisterStartupScript(this, GetType(), "showalert", "alert('" + resp + "');", true);
return;
}
}
if (txtPassword.Text == txtConfirmPassword.Text)
{
user.PaymentStatus = "unpaid";
user.AccountType = DropDownList1.SelectedValue.ToString();
if (string.IsNullOrEmpty(user.AccountType))
{
user.AccountType = AccountType.Free.ToString();
}
user.CreateDate = DateTime.Now;
user.ExpiryDate = DateTime.Now.AddDays(30);
user.Id = Guid.NewGuid();
user.UserName = txtFirstName.Text + " " + txtLastName.Text;
user.Password = this.MD5Hash(txtPassword.Text);
user.EmailId = txtEmail.Text;
user.UserStatus = 1;
user.ActivationStatus = "0";
if (TextBox1.Text.Trim() != "")
{
user.CouponCode = TextBox1.Text.Trim().ToString();
}
if (!userrepo.IsUserExist(user.EmailId))
{
logger.Error("Before User reg");
UserRepository.Add(user);
try
{
groups.Id = Guid.NewGuid();
groups.GroupName = ConfigurationManager.AppSettings["DefaultGroupName"];
groups.UserId = user.Id;
groups.EntryDate = DateTime.Now;
objGroupRepository.AddGroup(groups);
teams.Id = Guid.NewGuid();
teams.GroupId = groups.Id;
teams.UserId = user.Id;
teams.EmailId = user.EmailId;
objTeamRepository.addNewTeam(teams);
BusinessSettingRepository busnrepo = new BusinessSettingRepository();
SocioBoard.Domain.BusinessSetting objbsnssetting = new SocioBoard.Domain.BusinessSetting();
if (!busnrepo.checkBusinessExists(user.Id, groups.GroupName))
{
objbsnssetting.Id = Guid.NewGuid();
objbsnssetting.BusinessName = groups.GroupName;
objbsnssetting.GroupId = groups.Id;
objbsnssetting.AssigningTasks = false;
objbsnssetting.AssigningTasks = false;
objbsnssetting.TaskNotification = false;
objbsnssetting.TaskNotification = false;
objbsnssetting.FbPhotoUpload = 0;
objbsnssetting.UserId = user.Id;
objbsnssetting.EntryDate = DateTime.Now;
busnrepo.AddBusinessSetting(objbsnssetting);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
logger.Error("Error : " + ex.Message);
logger.Error("Error : " + ex.StackTrace);
}
try
{
logger.Error("1 Request.QueryString[refid]");
if (Request.QueryString["refid"] != null)
{
logger.Error("3 Request.QueryString[refid]");
User UserValid = null;
if (IsUserValid(Request.QueryString["refid"].ToString(), ref UserValid))
{
logger.Error("Inside IsUserValid");
user.RefereeStatus = "1";
UpdateUserReference(UserValid);
AddUserRefreeRelation(user, UserValid);
logger.Error("IsUserValid");
}
else
{
user.RefereeStatus = "0";
}
}
logger.Error("2 Request.QueryString[refid]");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
logger.Error("btnRegister_Click" + ex.Message);
logger.Error("btnRegister_Click" + ex.StackTrace);
}
if (TextBox1.Text.Trim() != "")
{
objCoupon.CouponCode = TextBox1.Text.Trim();
List <Coupon> lstCoupon = objCouponRepository.GetCouponByCouponCode(objCoupon);
objCoupon.Id = lstCoupon[0].Id;
objCoupon.EntryCouponDate = lstCoupon[0].EntryCouponDate;
objCoupon.ExpCouponDate = lstCoupon[0].ExpCouponDate;
objCoupon.Status = "1";
objCouponRepository.SetCouponById(objCoupon);
}
Session["LoggedUser"] = user;
objUserActivation.Id = Guid.NewGuid();
objUserActivation.UserId = user.Id;
objUserActivation.ActivationStatus = "0";
UserActivationRepository.Add(objUserActivation);
//add package start
UserPackageRelation objUserPackageRelation = new UserPackageRelation();
UserPackageRelationRepository objUserPackageRelationRepository = new UserPackageRelationRepository();
PackageRepository objPackageRepository = new PackageRepository();
try
{
Package objPackage = objPackageRepository.getPackageDetails(user.AccountType);
objUserPackageRelation.Id = Guid.NewGuid();
objUserPackageRelation.PackageId = objPackage.Id;
objUserPackageRelation.UserId = user.Id;
objUserPackageRelation.ModifiedDate = DateTime.Now;
objUserPackageRelation.PackageStatus = true;
objUserPackageRelationRepository.AddUserPackageRelation(objUserPackageRelation);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
//end package
SocioBoard.Helper.MailSender.SendEMail(txtFirstName.Text, txtPassword.Text, txtEmail.Text, user.AccountType.ToString(), user.Id.ToString());
TeamRepository teamRepo = new TeamRepository();
try
{
Team team = teamRepo.getTeamByEmailId(txtEmail.Text);
if (team != null)
{
Guid teamid = Guid.Parse(Request.QueryString["tid"]);
teamRepo.updateTeamStatus(teamid);
TeamMemberProfileRepository teamMemRepo = new TeamMemberProfileRepository();
List <TeamMemberProfile> lstteammember = teamMemRepo.getAllTeamMemberProfilesOfTeam(team.Id);
foreach (TeamMemberProfile item in lstteammember)
{
try
{
SocialProfilesRepository socialRepo = new SocialProfilesRepository();
SocialProfile socioprofile = new SocialProfile();
socioprofile.Id = Guid.NewGuid();
socioprofile.ProfileDate = DateTime.Now;
socioprofile.ProfileId = item.ProfileId;
socioprofile.ProfileType = item.ProfileType;
socioprofile.UserId = user.Id;
socialRepo.addNewProfileForUser(socioprofile);
if (item.ProfileType == "facebook")
{
try
{
FacebookAccount fbAccount = new FacebookAccount();
FacebookAccountRepository fbAccountRepo = new FacebookAccountRepository();
FacebookAccount userAccount = fbAccountRepo.getUserDetails(item.ProfileId);
fbAccount.AccessToken = userAccount.AccessToken;
fbAccount.EmailId = userAccount.EmailId;
fbAccount.FbUserId = item.ProfileId;
fbAccount.FbUserName = userAccount.FbUserName;
fbAccount.Friends = userAccount.Friends;
fbAccount.Id = Guid.NewGuid();
fbAccount.IsActive = 1;
fbAccount.ProfileUrl = userAccount.ProfileUrl;
fbAccount.Type = userAccount.Type;
fbAccount.UserId = user.Id;
fbAccountRepo.addFacebookUser(fbAccount);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
logger.Error(ex.Message);
}
}
else if (item.ProfileType == "twitter")
{
try
{
TwitterAccount twtAccount = new TwitterAccount();
TwitterAccountRepository twtAccRepo = new TwitterAccountRepository();
TwitterAccount twtAcc = twtAccRepo.getUserInfo(item.ProfileId);
twtAccount.FollowersCount = twtAcc.FollowersCount;
twtAccount.FollowingCount = twtAcc.FollowingCount;
twtAccount.Id = Guid.NewGuid();
twtAccount.IsActive = true;
twtAccount.OAuthSecret = twtAcc.OAuthSecret;
twtAccount.OAuthToken = twtAcc.OAuthToken;
twtAccount.ProfileImageUrl = twtAcc.ProfileImageUrl;
twtAccount.ProfileUrl = twtAcc.ProfileUrl;
twtAccount.TwitterName = twtAcc.TwitterName;
twtAccount.TwitterScreenName = twtAcc.TwitterScreenName;
twtAccount.TwitterUserId = twtAcc.TwitterUserId;
twtAccount.UserId = user.Id;
twtAccRepo.addTwitterkUser(twtAccount);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
logger.Error(ex.Message);
}
}
else if (item.ProfileType == "instagram")
{
try
{
InstagramAccount insAccount = new InstagramAccount();
InstagramAccountRepository insAccRepo = new InstagramAccountRepository();
InstagramAccount InsAcc = insAccRepo.getInstagramAccountById(item.ProfileId);
insAccount.AccessToken = InsAcc.AccessToken;
insAccount.FollowedBy = InsAcc.FollowedBy;
insAccount.Followers = InsAcc.Followers;
insAccount.Id = Guid.NewGuid();
insAccount.InstagramId = item.ProfileId;
insAccount.InsUserName = InsAcc.InsUserName;
insAccount.IsActive = true;
insAccount.ProfileUrl = InsAcc.ProfileUrl;
insAccount.TotalImages = InsAcc.TotalImages;
insAccount.UserId = user.Id;
insAccRepo.addInstagramUser(insAccount);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
logger.Error(ex.Message);
}
}
else if (item.ProfileType == "linkedin")
{
try
{
LinkedInAccount linkAccount = new LinkedInAccount();
LinkedInAccountRepository linkedAccountRepo = new LinkedInAccountRepository();
LinkedInAccount linkAcc = linkedAccountRepo.getLinkedinAccountDetailsById(item.ProfileId);
linkAccount.Id = Guid.NewGuid();
linkAccount.IsActive = true;
linkAccount.LinkedinUserId = item.ProfileId;
linkAccount.LinkedinUserName = linkAcc.LinkedinUserName;
linkAccount.OAuthSecret = linkAcc.OAuthSecret;
linkAccount.OAuthToken = linkAcc.OAuthToken;
linkAccount.OAuthVerifier = linkAcc.OAuthVerifier;
linkAccount.ProfileImageUrl = linkAcc.ProfileImageUrl;
linkAccount.ProfileUrl = linkAcc.ProfileUrl;
linkAccount.UserId = user.Id;
linkedAccountRepo.addLinkedinUser(linkAccount);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
logger.Error(ex.Message);
}
}
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
#region SetInvitationStatusAfterSuccessfulRegistration
try
{
if (Request.QueryString["refid"] != null)
{
string refid = Request.QueryString["refid"];
int res = SetInvitationStatusAfterSuccessfulRegistration(refid, txtEmail.Text);
}
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
#endregion
try
{
lblerror.Text = "Registered Successfully !" + "<a href=\"Default.aspx\">Login</a>";
Response.Redirect("~/Home.aspx");
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
else
{
lblerror.Text = "Email Already Exists " + "<a id=\"loginlink\" href=\"#\">login</a>";
}
}
}
else
{
ScriptManager.RegisterStartupScript(this, GetType(), "showalert", "alert('Please select Account Type!');", true);
}
}
catch (Exception ex)
{
logger.Error(ex.StackTrace);
lblerror.Text = "Success!";
Console.WriteLine(ex.StackTrace);
//Response.Redirect("Home.aspx");
}
}
catch (Exception ex)
{
logger.Error(ex.StackTrace);
Console.WriteLine(ex.StackTrace);
//Response.Redirect("Home.aspx");
}
}
public IHttpActionResult DeleteUserDetails(string user)
{
GroupsRepository _GroupsRepository = new GroupsRepository();
GroupMembersRepository _GroupMembersRepository = new GroupMembersRepository();
GroupProfileRepository _GroupProfileRepository = new GroupProfileRepository();
TaskRepository _TaskRepository = new TaskRepository();
TaskCommentRepository _TaskCommentRepository = new TaskCommentRepository();
InboxMessagesRepository _InboxMessagesRepository = new InboxMessagesRepository();
FacebookAccountRepository _FacebookAccountRepository = new FacebookAccountRepository();
GoogleAnalyticsAccountRepository _GoogleAnalyticsAccountRepository = new GoogleAnalyticsAccountRepository();
GooglePlusAccountRepository _GooglePlusAccountRepository = new GooglePlusAccountRepository();
InstagramAccountRepository _InstagramAccountRepository = new InstagramAccountRepository();
LinkedInAccountRepository _LinkedInAccountRepository = new LinkedInAccountRepository();
LinkedinCompanyPageRepository _LinkedinCompanyPageRepository = new LinkedinCompanyPageRepository();
ScheduledMessageRepository _ScheduledMessageRepository = new ScheduledMessageRepository();
SocialProfilesRepository _SocialProfilesRepository = new SocialProfilesRepository();
TwitterAccountRepository _TwitterAccountRepository = new TwitterAccountRepository();
TumblrAccountRepository _TumblrAccountRepository = new TumblrAccountRepository();
YoutubeAccountRepository _YoutubeAccountRepository = new YoutubeAccountRepository();
YoutubeChannelRepository _YoutubeChannelRepository = new YoutubeChannelRepository();
try
{
Domain.Socioboard.Domain.User _User = userrepo.getUserInfoByEmail(user);
if (_User != null)
{
List <Domain.Socioboard.Domain.Groups> lstGroups = _GroupsRepository.getAllGroups(_User.Id);
foreach (Domain.Socioboard.Domain.Groups item_group in lstGroups)
{
int i = _GroupMembersRepository.DeleteGroupMember(item_group.Id.ToString());
int j = _GroupProfileRepository.DeleteAllGroupProfile(item_group.Id);
bool rt = _GroupProfileRepository.DeleteGroupReport(item_group.Id);
int k = _TaskRepository.DeleteTaskOfGroup(item_group.Id);
}
int g = _GroupMembersRepository.DeleteGroupMemberByUserId(user);
int h = _GroupsRepository.DeleteGroupsByUserid(_User.Id);
int l = _TaskCommentRepository.DeleteTaskCommentByUserid(_User.Id);
int m = _InboxMessagesRepository.DeleteInboxMessages(_User.Id);
int n = _FacebookAccountRepository.DeleteAllFacebookAccount(_User.Id);
int o = _GoogleAnalyticsAccountRepository.DeleteGoogleAnalyticsAccountByUserid(_User.Id);
int p = _GooglePlusAccountRepository.DeleteGooglePlusAccountByUserid(_User.Id);
int q = _InstagramAccountRepository.DeleteInstagramAccountByUserid(_User.Id);
int r = _LinkedInAccountRepository.DeleteLinkedInAccountByUserid(_User.Id);
int s = _LinkedinCompanyPageRepository.DeleteLinkedinCompanyPage(_User.Id);
int t = _ScheduledMessageRepository.DeleteScheduledMessageByUserid(_User.Id);
int u = _SocialProfilesRepository.DeleteSocialProfileByUserid(_User.Id);
int v = _TwitterAccountRepository.DeleteTwitterAccountByUserid(_User.Id);
int w = _TumblrAccountRepository.DeletetumblraccountByUserid(_User.Id);
int x = _YoutubeAccountRepository.DeleteYoutubeAccount(_User.Id);
int y = _YoutubeChannelRepository.DeleteYoutubeChannelByUserid(_User.Id);
int z = userrepo.DeleteUser(_User.Id);
}
else
{
return(Ok(false));
}
}
catch (Exception ex)
{
return(BadRequest(ex.StackTrace));
}
return(Ok(true));
}
public string SheduleFacebookGroupMessage(string FacebookId, string UserId, string sscheduledmsgguid)
{
string str = string.Empty;
int facint = 0;
try
{
objScheduledMessage = objScheduledMessageRepository.GetScheduledMessageDetails(Guid.Parse(sscheduledmsgguid));
GroupScheduleMessageRepository grpschedulemessagerepo = new GroupScheduleMessageRepository();
Domain.Socioboard.Domain.GroupScheduleMessage _GroupScheduleMessage = grpschedulemessagerepo.GetScheduleMessageId(objScheduledMessage.Id);
if (objFacebookAccountRepository.checkFacebookUserExists(FacebookId, Guid.Parse(UserId)))
{
objFacebookAccount = objFacebookAccountRepository.getFacebookAccountDetailsById(FacebookId, Guid.Parse(UserId));
}
else
{
objFacebookAccount = objFacebookAccountRepository.getFacebookAccountDetailsById(FacebookId);
}
if (objFacebookAccount != null)
{
FacebookClient fbclient = new FacebookClient(objFacebookAccount.AccessToken);
var args = new Dictionary<string, object>();
args["message"] = objScheduledMessage.ShareMessage;
string imagepath = objScheduledMessage.PicUrl;
var facebookpost = "";
try
{
if (!string.IsNullOrEmpty(imagepath))
{
var media = new FacebookMediaObject
{
FileName = "filename",
ContentType = "image/jpeg"
};
byte[] img = System.IO.File.ReadAllBytes(imagepath);
media.SetValue(img);
args["source"] = media;
facebookpost = fbclient.Post("v2.0/" + _GroupScheduleMessage.GroupId + "/photos", args).ToString();
}
else
{
facebookpost = fbclient.Post("v2.0/" + _GroupScheduleMessage.GroupId + "/feed", args).ToString();
}
}
catch (Exception ex)
{
objFacebookAccountRepository = new FacebookAccountRepository();
objFacebookAccount.IsActive = 2;
objFacebookAccountRepository.updateFacebookUserStatus(objFacebookAccount);
Domain.Socioboard.Domain.SocialProfile objSocialProfile = new Domain.Socioboard.Domain.SocialProfile();
SocialProfilesRepository objSocialProfilesRepository = new SocialProfilesRepository();
string errormsg = ex.Message;
if (errormsg.Contains("access token"))
{
objSocialProfile.UserId = objFacebookAccount.UserId;
objSocialProfile.ProfileId = objFacebookAccount.FbUserId;
objSocialProfile.ProfileStatus = 2;
objSocialProfilesRepository.updateSocialProfileStatus(objSocialProfile);
}
Console.WriteLine(ex.Message);
str = ex.Message;
}
if (!string.IsNullOrEmpty(facebookpost))
{
facint++;
str = "Message post on facebook for Id :" + objFacebookAccount.FbUserId + " and Message: " + objScheduledMessage.ShareMessage;
ScheduledMessage schmsg = new ScheduledMessage();
schmsg.UpdateScheduledMessageByMsgId(Guid.Parse(sscheduledmsgguid));
logger.Error("SheduleFacebookGroupMessageCount" + facint);
}
}
else
{
str = "facebook account not found for id" + objScheduledMessage.ProfileId;
}
}
catch (Exception ex)
{
str = ex.Message;
}
return str;
}
protected void Page_Load(object sender, EventArgs e)
{
oAuthTokenGa obj = new oAuthTokenGa();
Accounts objAcc = new Accounts();
Analytics objAlyt = new Analytics();
User user = (User)Session["LoggedUser"];
if (!IsPostBack)
{
if (Session["login"] == null)
{
if (user == null)
{
Response.Redirect("Default.aspx");
}
}
try
{
string strRefresh = obj.GetRefreshToken(Request.QueryString["code"].ToString());
if (!strRefresh.StartsWith("["))
{
strRefresh = "[" + strRefresh + "]";
}
JArray objArray = JArray.Parse(strRefresh);
GoogleAnalyticsAccount objGaAcc = new GoogleAnalyticsAccount();
GoogleAnalyticsAccountRepository objGaAccRepo = new GoogleAnalyticsAccountRepository();
GanalyticsHelper objGaHelper = new GanalyticsHelper();
SocialProfilesRepository socioprofilerepo = new SocialProfilesRepository();
SocialProfile socioprofile = new SocialProfile();
foreach (var item in objArray)
{
DataSet dsAccount = objAcc.getGaAccounts(item["access_token"].ToString());
objGaAcc.RefreshToken = item["refresh_token"].ToString();
objGaAcc.AccessToken = item["access_token"].ToString();
objGaAcc.EmailId = dsAccount.Tables["title"].Rows[0]["title_Text"].ToString();
objGaAcc.EntryDate = DateTime.Now;
objGaAcc.GaAccountId = dsAccount.Tables["property"].Rows[0]["value"].ToString();
objGaAcc.GaAccountName = dsAccount.Tables["property"].Rows[1]["value"].ToString();
objGaAcc.Id = Guid.NewGuid();
objGaAcc.IsActive = true;
objGaAcc.UserId = user.Id;
DataSet dsProfile = objAcc.getGaProfiles(item["access_token"].ToString(), objGaAcc.GaAccountId);
int profileCount = dsProfile.Tables["property"].Select("name='ga:profileId'").Length;
string[,] names = new string[profileCount, 2];
int tempCount = 0;
foreach (DataRow dRow in dsProfile.Tables["property"].Rows)
{
//if (dRow["name"].Equals("ga:profileId") || dRow["name"].Equals("ga:profileName"))
{
if (dRow["name"].Equals("ga:profileId"))
{
objGaAcc.GaProfileId = dRow["value"].ToString();
names[tempCount, 0] = dRow["value"].ToString();
}
if (dRow["name"].Equals("ga:profileName"))
{
names[tempCount, 1] = dRow["value"].ToString();
objGaAcc.GaProfileName = dRow["value"].ToString();
}
if (tempCount >= profileCount)
{
break;
}
if (names[tempCount, 0] != null && names[tempCount, 1] != null)
{
tempCount++;
}
}
}
socioprofile.Id = Guid.NewGuid();
socioprofile.ProfileDate = DateTime.Now;
socioprofile.ProfileId = objGaAcc.GaAccountId;
socioprofile.ProfileType = "googleanalytics";
socioprofile.UserId = user.Id;
if (!objGaAccRepo.checkGoogelAnalyticsUserExists(objGaAcc.GaAccountId, user.Id))
{
for (int i = 0; i < profileCount; i++)
{
objGaAcc.GaProfileId = names[i, 0];
objGaAcc.GaProfileName = names[i, 1];
if (!objGaAccRepo.checkGoogelAnalyticsProfileExists(objGaAcc.GaAccountId, objGaAcc.GaProfileId, user.Id))
{
objGaAccRepo.addGoogleAnalyticsUser(objGaAcc);
}
else
{
objGaAccRepo.updateGoogelAnalyticsUser(objGaAcc);
}
objGaHelper.getCountryAnalyticsApi(objGaAcc.GaProfileId, user.Id);
objGaHelper.getYearWiseAnalyticsApi(objGaAcc.GaProfileId, user.Id);
objGaHelper.getMonthWiseAnalyticsApi(objGaAcc.GaProfileId, user.Id);
objGaHelper.getDayWiseAnalyticsApi(objGaAcc.GaProfileId, user.Id);
}
if (!socioprofilerepo.checkUserProfileExist(socioprofile))
{
socioprofilerepo.addNewProfileForUser(socioprofile);
}
else
{
socioprofilerepo.updateSocialProfile(socioprofile);
}
}
else
{
//objGaAccRepo.updateGoogelAnalyticsUser(objGaAcc);
for (int i = 0; i < names.Length; i++)
{
objGaAcc.GaProfileId = names[i, 0];
objGaAcc.GaProfileName = names[i, 1];
if (!objGaAccRepo.checkGoogelAnalyticsProfileExists(objGaAcc.GaAccountId, objGaAcc.GaProfileId, user.Id))
{
objGaAccRepo.addGoogleAnalyticsUser(objGaAcc);
}
else
{
objGaAccRepo.updateGoogelAnalyticsUser(objGaAcc);
}
}
if (!socioprofilerepo.checkUserProfileExist(socioprofile))
{
socioprofilerepo.addNewProfileForUser(socioprofile);
}
else
{
socioprofilerepo.updateSocialProfile(socioprofile);
}
}
Response.Redirect("Home.aspx");
}
}
catch (Exception Err)
{
logger.Error(Err.StackTrace);
try
{
Response.Redirect("/Home.aspx");
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
}
}
protected void btnRegister_Click(object sender, ImageClickEventArgs e)
{
User user = new User();
UserRepository userrepo = new UserRepository();
SocioBoard.Helper.SessionFactory.configfilepath = Server.MapPath("~/hibernate.cfg.xml");
try
{
if (txtPassword.Text == txtConfirmPassword.Text)
{
user.PaymentStatus = "unpaid";
user.AccountType = Request.QueryString["type"];
if (user.AccountType == string.Empty)
{
user.AccountType = AccountType.Deluxe.ToString();
}
user.CreateDate = DateTime.Now;
user.ExpiryDate = DateTime.Now.AddMonths(1);
user.Id = Guid.NewGuid();
user.UserName = txtFirstName.Text + " " + txtLastName.Text;
user.Password = this.MD5Hash(txtPassword.Text);
user.EmailId = txtEmail.Text;
user.UserStatus = 1;
if (!userrepo.IsUserExist(user.EmailId))
{
UserRepository.Add(user);
SocioBoard.Helper.MailSender.SendEMail(txtFirstName.Text + " " + txtLastName.Text, txtPassword.Text, txtEmail.Text);
TeamRepository teamRepo = new TeamRepository();
Team team = teamRepo.getTeamByEmailId(txtEmail.Text);
if (team != null)
{
Guid teamid = Guid.Parse(Request.QueryString["tid"]);
teamRepo.updateTeamStatus(teamid);
TeamMemberProfileRepository teamMemRepo = new TeamMemberProfileRepository();
List <TeamMemberProfile> lstteammember = teamMemRepo.getAllTeamMemberProfilesOfTeam(team.Id);
foreach (TeamMemberProfile item in lstteammember)
{
try
{
SocialProfilesRepository socialRepo = new SocialProfilesRepository();
SocialProfile socioprofile = new SocialProfile();
socioprofile.Id = Guid.NewGuid();
socioprofile.ProfileDate = DateTime.Now;
socioprofile.ProfileId = item.ProfileId;
socioprofile.ProfileType = item.ProfileType;
socioprofile.UserId = user.Id;
socialRepo.addNewProfileForUser(socioprofile);
if (item.ProfileType == "facebook")
{
try
{
FacebookAccount fbAccount = new FacebookAccount();
FacebookAccountRepository fbAccountRepo = new FacebookAccountRepository();
FacebookAccount userAccount = fbAccountRepo.getUserDetails(item.ProfileId);
fbAccount.AccessToken = userAccount.AccessToken;
fbAccount.EmailId = userAccount.EmailId;
fbAccount.FbUserId = item.ProfileId;
fbAccount.FbUserName = userAccount.FbUserName;
fbAccount.Friends = userAccount.Friends;
fbAccount.Id = Guid.NewGuid();
fbAccount.IsActive = true;
fbAccount.ProfileUrl = userAccount.ProfileUrl;
fbAccount.Type = userAccount.Type;
fbAccount.UserId = user.Id;
fbAccountRepo.addFacebookUser(fbAccount);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
logger.Error(ex.Message);
}
}
else if (item.ProfileType == "twitter")
{
try
{
TwitterAccount twtAccount = new TwitterAccount();
TwitterAccountRepository twtAccRepo = new TwitterAccountRepository();
TwitterAccount twtAcc = twtAccRepo.getUserInfo(item.ProfileId);
twtAccount.FollowersCount = twtAcc.FollowersCount;
twtAccount.FollowingCount = twtAcc.FollowingCount;
twtAccount.Id = Guid.NewGuid();
twtAccount.IsActive = true;
twtAccount.OAuthSecret = twtAcc.OAuthSecret;
twtAccount.OAuthToken = twtAcc.OAuthToken;
twtAccount.ProfileImageUrl = twtAcc.ProfileImageUrl;
twtAccount.ProfileUrl = twtAcc.ProfileUrl;
twtAccount.TwitterName = twtAcc.TwitterName;
twtAccount.TwitterScreenName = twtAcc.TwitterScreenName;
twtAccount.TwitterUserId = twtAcc.TwitterUserId;
twtAccount.UserId = user.Id;
twtAccRepo.addTwitterkUser(twtAccount);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
logger.Error(ex.Message);
}
}
else if (item.ProfileType == "instagram")
{
try
{
InstagramAccount insAccount = new InstagramAccount();
InstagramAccountRepository insAccRepo = new InstagramAccountRepository();
InstagramAccount InsAcc = insAccRepo.getInstagramAccountById(item.ProfileId);
insAccount.AccessToken = InsAcc.AccessToken;
insAccount.FollowedBy = InsAcc.FollowedBy;
insAccount.Followers = InsAcc.Followers;
insAccount.Id = Guid.NewGuid();
insAccount.InstagramId = item.ProfileId;
insAccount.InsUserName = InsAcc.InsUserName;
insAccount.IsActive = true;
insAccount.ProfileUrl = InsAcc.ProfileUrl;
insAccount.TotalImages = InsAcc.TotalImages;
insAccount.UserId = user.Id;
insAccRepo.addInstagramUser(insAccount);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
logger.Error(ex.Message);
}
}
else if (item.ProfileType == "linkedin")
{
try
{
LinkedInAccount linkAccount = new LinkedInAccount();
LinkedInAccountRepository linkedAccountRepo = new LinkedInAccountRepository();
LinkedInAccount linkAcc = linkedAccountRepo.getLinkedinAccountDetailsById(item.ProfileId);
linkAccount.Id = Guid.NewGuid();
linkAccount.IsActive = true;
linkAccount.LinkedinUserId = item.ProfileId;
linkAccount.LinkedinUserName = linkAcc.LinkedinUserName;
linkAccount.OAuthSecret = linkAcc.OAuthSecret;
linkAccount.OAuthToken = linkAcc.OAuthToken;
linkAccount.OAuthVerifier = linkAcc.OAuthVerifier;
linkAccount.ProfileImageUrl = linkAcc.ProfileImageUrl;
linkAccount.ProfileUrl = linkAcc.ProfileUrl;
linkAccount.UserId = user.Id;
linkedAccountRepo.addLinkedinUser(linkAccount);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
logger.Error(ex.Message);
}
}
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
}
}
lblerror.Text = "Registered Successfully !" + "<a href=\"Default.aspx\">Login</a>";
}
else
{
lblerror.Text = "Email Already Exists " + "<a href=\"Default.aspx\">login</a>";
}
}
}
catch (Exception ex)
{
logger.Error(ex.StackTrace);
lblerror.Text = "Please Insert Correct Information";
Console.WriteLine(ex.StackTrace);
}
}
public string DeleteAllUsersByCreateDate(string date)
{
int i = 0;
int count = 0;
UserRepository objUserRepository = new UserRepository();
List <User> lstuser = objUserRepository.GetAllUsersByCreateDate(date);
ArchiveMessageRepository objArchiveMessageRepository = new ArchiveMessageRepository();
DiscoverySearchRepository objDiscoverySearchRepository = new DiscoverySearchRepository();
DraftsRepository objDraftsRepository = new DraftsRepository();
FacebookAccountRepository objFacebookAccountRepository = new FacebookAccountRepository();
FacebookFeedRepository objFacebookFeedRepository = new FacebookFeedRepository();
FacebookInsightPostStatsRepository objFacebookInsightPostStatsRepository = new FacebookInsightPostStatsRepository();
FacebookInsightStatsRepository objFacebookInsightStatsRepository = new FacebookInsightStatsRepository();
FacebookMessageRepository objFacebookMessageRepository = new FacebookMessageRepository();
FacebookStatsRepository objFacebookStatsRepository = new FacebookStatsRepository();
GoogleAnalyticsAccountRepository objGoogleAnalyticsAccountRepository = new GoogleAnalyticsAccountRepository();
GoogleAnalyticsStatsRepository objGoogleAnalyticsStatsRepository = new GoogleAnalyticsStatsRepository();
GooglePlusAccountRepository objGooglePlusAccountRepository = new GooglePlusAccountRepository();
GooglePlusActivitiesRepository objGooglePlusActivitiesRepository = new GooglePlusActivitiesRepository();
GroupProfileRepository objGroupProfileRepository = new GroupProfileRepository();
GroupRepository objGroupRepository = new GroupRepository();
InstagramAccountRepository objInstagramAccountRepository = new InstagramAccountRepository();
InstagramCommentRepository objInstagramCommentRepository = new InstagramCommentRepository();
InstagramFeedRepository objInstagramFeedRepository = new InstagramFeedRepository();
LinkedInAccountRepository objLinkedInAccountRepository = new LinkedInAccountRepository();
LinkedInFeedRepository objLinkedInFeedRepository = new LinkedInFeedRepository();
LogRepository objLogRepository = new LogRepository();
RssFeedsRepository objRssFeedsRepository = new RssFeedsRepository();
RssReaderRepository objRssReaderRepository = new RssReaderRepository();
ScheduledMessageRepository objScheduledMessageRepository = new ScheduledMessageRepository();
SocialProfilesRepository objSocialProfilesRepository = new SocialProfilesRepository();
TaskCommentRepository objTaskCommentRepository = new TaskCommentRepository();
TaskRepository objTaskRepository = new TaskRepository();
TeamRepository objTeamRepository = new TeamRepository();
TeamMemberProfileRepository objTeamMemberProfileRepository = new TeamMemberProfileRepository();
TwitterAccountRepository objTwitterAccountRepository = new TwitterAccountRepository();
TwitterDirectMessageRepository objTwitterDirectMessageRepository = new TwitterDirectMessageRepository();
TwitterFeedRepository objTwitterFeedRepository = new TwitterFeedRepository();
TwitterMessageRepository objTwitterMessageRepository = new TwitterMessageRepository();
TwitterStatsRepository objTwitterStatsRepository = new TwitterStatsRepository();
UserActivationRepository objUserActivationRepository = new UserActivationRepository();
UserPackageRelationRepository objUserPackageRelationRepository = new UserPackageRelationRepository();
count = lstuser.Count();
foreach (var item in lstuser)
{
i++;
try
{
if (item.EmailId == "*****@*****.**" || item.EmailId == "*****@*****.**" || item.EmailId == "*****@*****.**" || item.EmailId == "*****@*****.**" || item.EmailId == "*****@*****.**" || item.EmailId == "*****@*****.**" || item.EmailId == "*****@*****.**" || item.EmailId == "*****@*****.**" || item.EmailId == "*****@*****.**" || item.EmailId == "*****@*****.**")
{
}
else
{
objArchiveMessageRepository.DeleteArchiveMessageByUserid(item.Id);
objDiscoverySearchRepository.DeleteDiscoverySearchByUserid(item.Id);
objDraftsRepository.DeleteDraftsByUserid(item.Id);
objFacebookAccountRepository.DeleteFacebookAccountByUserid(item.Id);
objFacebookFeedRepository.DeleteFacebookFeedByUserid(item.Id);
objFacebookInsightPostStatsRepository.DeleteFacebookInsightPostStatsByUserid(item.Id);
objFacebookInsightStatsRepository.DeleteFacebookInsightStatsByUserid(item.Id);
objFacebookMessageRepository.DeleteFacebookMessageByUserid(item.Id);
objFacebookStatsRepository.DeleteFacebookStatsByUserid(item.Id);
objGoogleAnalyticsAccountRepository.DeleteGoogleAnalyticsAccountByUserid(item.Id);
objGoogleAnalyticsStatsRepository.DeleteGoogleAnalyticsStatsByUserid(item.Id);
objGooglePlusAccountRepository.DeleteGooglePlusAccountByUserid(item.Id);
objGooglePlusActivitiesRepository.DeleteGooglePlusActivitiesByUserid(item.Id);
objGroupProfileRepository.DeleteGroupProfileByUserid(item.Id);
objGroupRepository.DeleteGroupsByUserid(item.Id);
objInstagramAccountRepository.DeleteInstagramAccountByUserid(item.Id);
objInstagramCommentRepository.DeleteInstagramCommentByUserid(item.Id);
objInstagramFeedRepository.DeleteInstagramFeedByUserid(item.Id);
objLinkedInAccountRepository.DeleteLinkedInAccountByUserid(item.Id);
objLinkedInFeedRepository.DeleteLinkedInFeedByUserid(item.Id);
objLogRepository.DeleteLogByUserid(item.Id);
objRssFeedsRepository.DeleteRssFeedsByUserid(item.Id);
objRssReaderRepository.DeleteRssReaderByUserid(item.Id);
objScheduledMessageRepository.DeleteScheduledMessageByUserid(item.Id);
objSocialProfilesRepository.DeleteSocialProfileByUserid(item.Id);
objTaskCommentRepository.DeleteTaskCommentByUserid(item.Id);
objTaskRepository.DeleteTasksByUserid(item.Id);
objTeamRepository.DeleteTeamByUserid(item.Id);
objTeamMemberProfileRepository.DeleteTeamMemberProfileByUserid(item.Id);
objTwitterAccountRepository.DeleteTwitterAccountByUserid(item.Id);
objTwitterDirectMessageRepository.DeleteTwitterDirectMessagesByUserid(item.Id);
objTwitterFeedRepository.DeleteTwitterFeedByUserid(item.Id);
objTwitterMessageRepository.DeleteTwitterMessageByUserid(item.Id);
objTwitterStatsRepository.DeleteTwitterStatsByUserid(item.Id);
objUserActivationRepository.DeleteUserActivationByUserid(item.Id);
objUserPackageRelationRepository.DeleteuserPackageRelationByUserid(item.Id);
objUserRepository.DeleteUserByUserid(item.Id);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
return(i + " " + count);
}
protected void Page_Load(object sender, EventArgs e)
{
User user = (User)Session["LoggedUser"];
try
{
#region for You can use only 30 days as Unpaid User
//SocioBoard.Domain.User user = (User)Session["LoggedUser"];
if (user.PaymentStatus.ToLower() == "unpaid")
{
if (!SBUtils.IsUserWorkingDaysValid(user.ExpiryDate))
{
// ScriptManager.RegisterStartupScript(this, GetType(), "showalert", "alert('You can use only 30 days as Unpaid User !');", true);
Session["GreaterThan30Days"] = "GreaterThan30Days";
Response.Redirect("../Settings/Billing.aspx");
}
}
#endregion
}
catch (Exception ex)
{
Console.WriteLine("Error : " + ex.StackTrace);
}
if (!IsPostBack)
{
if (user == null)
{
Response.Redirect("/Default.aspx");
}
try
{
getgrphData(7);
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
}
try
{
getNewFriends(7);
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
}
try
{
getNewFollowers(7);
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
}
try
{
GetFollowersAgeWise(7);
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
}
try
{
getFollowFollowersMonth();
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
}
try
{
FacebookAccountRepository fbAccRepo = new FacebookAccountRepository();
FacebookFeedRepository fbFeedRepo = new FacebookFeedRepository();
ArrayList arrfbProfile = fbAccRepo.getAllFacebookPagesOfUser(user.Id);
long talking = 0;
foreach (FacebookAccount item in arrfbProfile)
{
FacebookClient fb = new FacebookClient();
fb.AccessToken = item.AccessToken;
pagelikes = pagelikes + fbFeedRepo.countInteractions(item.UserId, item.FbUserId, 7);
dynamic talkingabout = fb.Get(item.FbUserId);
talking = talking + talkingabout.talking_about_count;
// strinteractions = pagelikes.Count(); //(long.Parse(strinteractions) + pagelikes.talking_about_count).ToString();
}
talkingabtcount = (talking / 100) * arrfbProfile.Count;
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
}
try
{
SocialProfilesRepository objsocioRepo = new SocialProfilesRepository();
profileCount = objsocioRepo.getAllSocialProfilesOfUser(user.Id).Count();
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
}
var strgenderTwt = Session["twtGender"].ToString().Split(',');
divtwtMale.InnerHtml = strgenderTwt[0] + "%";
divtwtfeMale.InnerHtml = strgenderTwt[1] + "%";
}
}
public void ProfilesAvailabeforuser(Guid UserId)
{
string bindprofiles = string.Empty;
SocialProfilesRepository socioprofilerepo = new SocialProfilesRepository();
List <SocialProfile> lstsocialprofile = socioprofilerepo.getAllSocialProfilesOfUser(UserId);
foreach (SocialProfile item in lstsocialprofile)
{
if (item.ProfileType == "facebook")
{
if (!SelectedGroupProfiles.InnerHtml.Contains("facebook_" + item.ProfileId))
{
FacebookAccountRepository fbaccreop = new FacebookAccountRepository();
FacebookAccount facebookaccount = fbaccreop.getFacebookAccountDetailsById(item.ProfileId, UserId);
bindprofiles +=
"<div onclick=\"transfertoGroup('facebook','" + item.ProfileId + "')\" id=\"usergroups_" + item.ProfileId + "\" class=\"ws_conct active\"> <span class=\"img\"><img width=\"48\" height=\"48\" src=\"http://graph.facebook.com/" + item.ProfileId + "/picture?type=small\" alt=\"\"><i><img width=\"16\" height=\"16\" src=\"../Contents/img/fb_icon.png\" alt=\"\"></i></span><div class=\"fourfifth\">" +
"<div class=\"location-container\">" + facebookaccount.FbUserName + "</div><span class=\"add remove\">✖</span></div></div>";
}
}
else if (item.ProfileType == "twitter")
{
if (!SelectedGroupProfiles.InnerHtml.Contains("twitter_" + item.ProfileId))
{
string profileimgurl = string.Empty;
TwitterAccountRepository twtaccountrepo = new TwitterAccountRepository();
TwitterAccount twtacco = twtaccountrepo.getUserInformation(UserId, item.ProfileId);
if (twtacco.ProfileImageUrl == string.Empty)
{
profileimgurl = "../../Contents/img/blank_img.png";
}
else
{
profileimgurl = twtacco.ProfileImageUrl;
}
bindprofiles +=
"<div onclick=\"transfertoGroup('twitter','" + item.ProfileId + "')\" id=\"usergroups_" + item.ProfileId + "\" class=\"ws_conct active\"> <span class=\"img\"><img width=\"48\" height=\"48\" src=\"" + profileimgurl + "\" alt=\"\"><i><img width=\"16\" height=\"16\" src=\"../Contents/img/twticon.png\" alt=\"\"></i></span><div class=\"fourfifth\">" +
"<div class=\"location-container\">" + twtacco.TwitterScreenName + "</div><span class=\"add remove\">✖</span></div></div>";
}
}
else if (item.ProfileType == "linkedin")
{
if (!SelectedGroupProfiles.InnerHtml.Contains("linkedin_" + item.ProfileId))
{
LinkedInAccountRepository linkedaccrepo = new LinkedInAccountRepository();
LinkedInAccount linkedaccount = linkedaccrepo.getUserInformation(UserId, item.ProfileId);
string profileimgurl = string.Empty;
if (linkedaccount.ProfileUrl == string.Empty)
{
profileimgurl = "../../Contents/img/blank_img.png";
}
else
{
profileimgurl = linkedaccount.ProfileImageUrl;
}
bindprofiles += "<div onclick=\"transfertoGroup('linkedin','" + item.ProfileId + "')\" id=\"usergroups_" + item.ProfileId + "\" class=\"ws_conct active\"><span class=\"img\"><img width=\"48\" height=\"48\" alt=\"\" src=\"" + profileimgurl + "\" ><i>" +
"<img width=\"16\" height=\"16\" alt=\"\" src=\"../Contents/img/link_icon.png\"></i></span>" +
"<div class=\"fourfifth\"><div class=\"location-container\">" + linkedaccount.LinkedinUserName + "</div>" +
"<span class=\"add remove\">✖</span></div></div>";
}
}
else if (item.ProfileType == "instagram")
{
if (!SelectedGroupProfiles.InnerHtml.Contains("instagram_" + item.ProfileId))
{
string profileimgurl = string.Empty;
InstagramAccountRepository instagramrepo = new InstagramAccountRepository();
InstagramAccount instaaccount = instagramrepo.getInstagramAccountDetailsById(item.ProfileId, UserId);
if (instaaccount.ProfileUrl == string.Empty)
{
profileimgurl = "../../Contents/img/blank_img.png";
}
else
{
profileimgurl = instaaccount.ProfileUrl;
}
bindprofiles += "<div onclick=\"transfertoGroup('instagram','" + item.ProfileId + "')\" id=\"usergroups_" + item.ProfileId + "\" class=\"ws_conct active\"><span class=\"img\"><img width=\"48\" height=\"48\" src=\"" + profileimgurl + "\" alt=\"\"><i>" +
"<img width=\"16\" height=\"16\" alt=\"\" src=\"../Contents/img/instagram_24X24.png\"></i></span><div class=\"fourfifth\"><div class=\"location-container\">" + instaaccount.InsUserName + "</div>" +
"<span class=\"add remove\">✖</span></div></div>";
}
}
else if (item.ProfileType == "tumblr")
{
if (!SelectedGroupProfiles.InnerHtml.Contains("tumblr_" + item.ProfileId))
{
string profileimgurl = string.Empty;
TumblrAccountRepository tumblrrepo = new TumblrAccountRepository();
TumblrAccount tumblraccount = tumblrrepo.getTumblrAccountDetailsById(item.ProfileId, UserId);
if (tumblraccount.tblrProfilePicUrl == string.Empty)
{
profileimgurl = "../../Contents/img/blank_img.png";
}
else
{
profileimgurl = "http://api.tumblr.com/v2/blog/" + tumblraccount.tblrUserName + ".tumblr.com/avatar";
}
bindprofiles += "<div onclick=\"transfertoGroup('tumblr','" + item.ProfileId + "')\" id=\"usergroups_" + item.ProfileId + "\" class=\"ws_conct active\"><span class=\"img\"><img width=\"48\" height=\"48\" src=\"http://api.tumblr.com/v2/blog/" + tumblraccount.tblrUserName + ".tumblr.com/avatar\" alt=\"\"><i>" +
"<img width=\"16\" height=\"16\" alt=\"\" src=\"../Contents/img/tumblr.png\"></i></span><div class=\"fourfifth\"><div class=\"location-container\">" + tumblraccount.tblrUserName + "</div>" +
"<span class=\"add remove\">✖</span></div></div>";
}
}
}
AllGroupProfiles.InnerHtml = bindprofiles;
}
private void GetAccessToken()
{
try
{
User user = (User)Session["LoggedUser"];
if (user == null)
{
Response.Redirect("Default.aspx");
}
oAuthTumbler requestHelper = new oAuthTumbler();
string code = Request.QueryString["oauth_verifier"];
string AccessTokenResponse = string.Empty;
try
{
AccessTokenResponse = requestHelper.GetAccessToken(oAuthTumbler.TumblrToken, code);
}
catch (Exception ex)
{
logger.Error("AccessTokenResponse: " + ex.Message);
logger.Error("AccessTokenResponse: " + ex.StackTrace);
}
string[] tokens = AccessTokenResponse.Split('&'); //extract access token & secret from response
string accessToken = tokens[0].Split('=')[1];
string accessTokenSecret = tokens[1].Split('=')[1];
KeyValuePair <string, string> LoginDetails = new KeyValuePair <string, string>(accessToken, accessTokenSecret);
string sstr = string.Empty;
try
{
sstr = oAuthTumbler.OAuthData(Globals.UsersDashboardUrl, "GET", LoginDetails.Key, LoginDetails.Value, null);
}
catch (Exception ex)
{
logger.Error("sstr: " + ex.Message);
logger.Error("sstr: " + ex.StackTrace);
}
JObject profile = new JObject();
try
{
profile = JObject.Parse(oAuthTumbler.OAuthData(Globals.UsersInfoUrl, "GET", LoginDetails.Key, LoginDetails.Value, null));
}
catch (Exception ex)
{
logger.Error("profile: " + ex.Message);
logger.Error("profile: " + ex.StackTrace);
}
JObject UserDashboard = JObject.Parse(oAuthTumbler.OAuthData(Globals.UsersDashboardUrl, "GET", LoginDetails.Key, LoginDetails.Value, null));
TumblrAccount objTumblrAccount = new TumblrAccount();
TumblrAccountRepository objTumblrAccountRepository = new TumblrAccountRepository();
SocialProfile objSocialProfile = new SocialProfile();
SocialProfilesRepository objSocialProfilesRepository = new SocialProfilesRepository();
objSocialProfile.Id = Guid.NewGuid();
objSocialProfile.UserId = user.Id;
objSocialProfile.ProfileId = profile["response"]["user"]["name"].ToString();
objSocialProfile.ProfileType = "tumblr";
objSocialProfile.ProfileDate = DateTime.Now;
objSocialProfile.ProfileStatus = 1;
objTumblrAccount.Id = Guid.NewGuid();
objTumblrAccount.tblrUserName = profile["response"]["user"]["name"].ToString();
objTumblrAccount.UserId = user.Id;
objTumblrAccount.tblrAccessToken = accessToken;
objTumblrAccount.tblrAccessTokenSecret = accessTokenSecret;
objTumblrAccount.tblrProfilePicUrl = profile["response"]["user"]["name"].ToString();
objTumblrAccount.IsActive = 1;
if (!objSocialProfilesRepository.checkUserProfileExist(objSocialProfile))
{
objSocialProfilesRepository.addNewProfileForUser(objSocialProfile);
if (!objTumblrAccountRepository.checkTubmlrUserExists(objTumblrAccount))
{
TumblrAccountRepository.Add(objTumblrAccount);
GroupRepository objGroupRepository = new GroupRepository();
SocioBoard.Domain.Team team = (SocioBoard.Domain.Team)HttpContext.Current.Session["GroupName"];
Groups lstDetails = objGroupRepository.getGroupName(team.GroupId);
if (lstDetails.GroupName == "Socioboard")
{
TeamMemberProfileRepository objTeamMemberProfileRepository = new TeamMemberProfileRepository();
TeamMemberProfile teammemberprofile = new TeamMemberProfile();
teammemberprofile.Id = Guid.NewGuid();
teammemberprofile.TeamId = team.Id;
teammemberprofile.ProfileId = objTumblrAccount.tblrUserName;
teammemberprofile.ProfileType = "tumblr";
teammemberprofile.StatusUpdateDate = DateTime.Now;
objTeamMemberProfileRepository.addNewTeamMember(teammemberprofile);
}
}
}
else
{
if (!objTumblrAccountRepository.checkTubmlrUserExists(objTumblrAccount))
{
TumblrAccountRepository.Add(objTumblrAccount);
}
else
{
Response.Redirect("Home.aspx");
}
}
JArray objJarray = (JArray)UserDashboard["response"]["posts"];
logger.Error("objJarray: " + objJarray);
if (objJarray != null)
{
logger.Error("objJarray lenght : " + objJarray.Count);
}
else
{
logger.Error("objJarray is NULL");
}
TumblrFeed objTumblrFeed = new TumblrFeed();
TumblrFeedRepository objTumblrFeedRepository = new TumblrFeedRepository();
foreach (var item in objJarray)
{
objTumblrFeed.Id = Guid.NewGuid();
objTumblrFeed.UserId = user.Id;
try
{
objTumblrFeed.ProfileId = profile["response"]["user"]["name"].ToString();
logger.Error("objTumblrFeed.ProfileId : " + objTumblrFeed.ProfileId);
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
objTumblrFeed.blogname = item["blog_name"].ToString();
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
objTumblrFeed.blogId = item["id"].ToString();
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
objTumblrFeed.blogposturl = item["post_url"].ToString();
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
String result = item["caption"].ToString();
objTumblrFeed.description = Regex.Replace(result, @"<[^>]*>", String.Empty);
}
catch (Exception ex)
{
objTumblrFeed.description = null;
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
objTumblrFeed.slug = item["slug"].ToString();
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
objTumblrFeed.type = item["type"].ToString();
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
string test = item["date"].ToString();
DateTime dt;
if (test.Contains("GMT"))
{
test = test.Replace("GMT", "").Trim().ToString();
dt = Convert.ToDateTime(test);
}
else
{
test = test.Replace("GMT", "").Trim().ToString();
dt = Convert.ToDateTime(test);
}
objTumblrFeed.date = dt;
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
objTumblrFeed.reblogkey = item["reblog_key"].ToString();
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
string str = item["liked"].ToString();
if (str == "False")
{
objTumblrFeed.liked = 0;
}
else
{
objTumblrFeed.liked = 1;
}
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
string str = item["followed"].ToString();
if (str == "false")
{
objTumblrFeed.followed = 0;
}
else
{
objTumblrFeed.followed = 1;
}
// objTumblrDashboard.followed = Convert.ToInt16(item["followed"]);
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
objTumblrFeed.canreply = Convert.ToInt16(item["can_reply"]);
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
objTumblrFeed.sourceurl = item["source_url"].ToString();
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
objTumblrFeed.sourcetitle = item["source_title"].ToString();
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
JArray asdasd12 = (JArray)item["photos"];
foreach (var item1 in asdasd12)
{
objTumblrFeed.imageurl = item1["original_size"]["url"].ToString();
}
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
objTumblrFeed.videourl = item["permalink_url"].ToString();
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
try
{
string str = item["note_count"].ToString();
objTumblrFeed.notes = Convert.ToInt16(str);
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
Console.WriteLine(ex.Message);
}
objTumblrFeed.timestamp = DateTime.Now;
if (!objTumblrFeedRepository.checkTumblrMessageExists(objTumblrFeed))
{
try
{
logger.Error("objTumblrFeedRepository.checkTumblrMessageExists " + objTumblrAccount.Id);
TumblrFeedRepository.Add(objTumblrFeed);
}
catch (Exception ex)
{
logger.Error("Exception : objTumblrFeedRepository.checkTumblrMessageExists " + objTumblrAccount.Id);
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
}
}
}
Response.Redirect("Home.aspx");
}
catch (Exception ex)
{
logger.Error(ex.Message);
logger.Error(ex.StackTrace);
}
}
public override void PostScheduleMessage(dynamic data)
{
try
{
FacebookAccountRepository fbaccrepo = new FacebookAccountRepository();
//IEnumerable<FacebookAccount> lstfbaccount = fbaccrepo.getUserDetails(data.ProfileId);
FacebookAccount fbaccount = fbaccrepo.getUserDetails(data.ProfileId);
if (fbaccount != null)
{
//FacebookAccount fbaccount = null;
//foreach (FacebookAccount item in lstfbaccount)
//{
// fbaccount = item;
// break;
//}
FacebookClient fbclient = new FacebookClient(fbaccount.AccessToken);
var args = new Dictionary <string, object>();
args["message"] = data.ShareMessage;
//var facebookpost = fbclient.Post("/me/feed", args);
var facebookpost = "";
try
{
if (fbaccount.Type == "account")
{
facebookpost = fbclient.Post("/me/feed", args).ToString();
}
else
{
facebookpost = fbclient.Post("/" + fbaccount.FbUserId + "/feed", args).ToString();
}
}
catch (Exception ex)
{
FacebookAccount objFacebookAccount = new FacebookAccount();
FacebookAccountRepository objFacebookAccountRepository = new FacebookAccountRepository();
objFacebookAccount.FbUserId = data.ProfileId;
objFacebookAccount.UserId = fbaccount.UserId;
objFacebookAccount.IsActive = 2;
objFacebookAccountRepository.updateFacebookUserStatus(objFacebookAccount);
SocialProfile objSocialProfile = new SocialProfile();
SocialProfilesRepository objSocialProfilesRepository = new SocialProfilesRepository();
//logger.Error(ex.Message);
string errormsg = ex.Message;
if (errormsg.Contains("access token"))
{
objSocialProfile.UserId = fbaccount.UserId;
objSocialProfile.ProfileId = data.ProfileId;
objSocialProfile.ProfileStatus = 2;
objSocialProfilesRepository.updateSocialProfileStatus(objSocialProfile);
}
Console.WriteLine(ex.Message);
}
Console.WriteLine("Message post on facebook for Id :" + fbaccount.FbUserId + " and Message: " + data.ShareMessage);
ScheduledMessageRepository schrepo = new ScheduledMessageRepository();
ScheduledMessage schmsg = new ScheduledMessage();
schmsg.Id = data.Id;
schmsg.ProfileId = data.ProfileId;
schmsg.ProfileType = "";
schmsg.Status = true;
schmsg.UserId = data.UserId;
schmsg.ShareMessage = data.ShareMessage;
schmsg.ScheduleTime = data.ScheduleTime;
schmsg.ClientTime = data.ClientTime;
schmsg.CreateTime = data.CreateTime;
schmsg.PicUrl = data.PicUrl;
schrepo.updateMessage(data.Id);
}
else
{
Console.WriteLine("facebook account not found for id" + data.ProfileId);
}
}
catch (FacebookApiLimitException ex)
{
Console.WriteLine(ex.StackTrace);
}
}
public string ProfilesConnected(string UserId)
{
try
{
Guid userid = Guid.Parse(UserId);
SocialProfilesRepository socialRepo = new SocialProfilesRepository();
List <SocialProfile> lstsocioprofile = socialRepo.getAllSocialProfilesOfUser(userid);
List <profileConnected> lstProfile = new List <profileConnected>();
foreach (SocialProfile sp in lstsocioprofile)
{
profileConnected pc = new profileConnected();
pc.Id = sp.Id;
pc.ProfileDate = sp.ProfileDate;
pc.ProfileId = sp.ProfileId;
pc.ProfileStatus = sp.ProfileStatus;
pc.ProfileType = sp.ProfileType;
pc.UserId = sp.UserId;
if (sp.ProfileType == "facebook")
{
try
{
FacebookAccountRepository objFbAccRepo = new FacebookAccountRepository();
FacebookAccount objFbAcc = objFbAccRepo.getUserDetails(sp.ProfileId);
pc.ProfileName = objFbAcc.FbUserName;
pc.ProfileImgUrl = "http://graph.facebook.com/" + sp.ProfileId + "/picture?type=small";
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
else if (sp.ProfileType == "twitter")
{
try
{
TwitterAccountRepository objTwtAccRepo = new TwitterAccountRepository();
TwitterAccount objTwtAcc = objTwtAccRepo.getUserInfo(sp.ProfileId);
pc.ProfileName = objTwtAcc.TwitterScreenName;
pc.ProfileImgUrl = objTwtAcc.ProfileImageUrl;
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
else if (sp.ProfileType == "instagram")
{
try
{
InstagramAccountRepository objInsAccRepo = new InstagramAccountRepository();
InstagramAccount objInsAcc = objInsAccRepo.getInstagramAccountById(sp.ProfileId);
pc.ProfileName = objInsAcc.InsUserName;
pc.ProfileImgUrl = objInsAcc.ProfileUrl;
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
else if (sp.ProfileType == "linkedin")
{
try
{
LinkedInAccountRepository objLiAccRepo = new LinkedInAccountRepository();
LinkedInAccount objLiAcc = objLiAccRepo.getLinkedinAccountDetailsById(sp.ProfileId);
pc.ProfileName = objLiAcc.LinkedinUserName;
pc.ProfileImgUrl = objLiAcc.ProfileImageUrl;
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
else if (sp.ProfileType == "googleplus")
{
try
{
GooglePlusAccountRepository objGpAccRepo = new GooglePlusAccountRepository();
GooglePlusAccount objGpAcc = objGpAccRepo.getUserDetails(sp.ProfileId);
pc.ProfileName = objGpAcc.GpUserName;
pc.ProfileImgUrl = objGpAcc.GpProfileImage;
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
lstProfile.Add(pc);
}
return(new JavaScriptSerializer().Serialize(lstProfile));
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
return(new JavaScriptSerializer().Serialize("Please Try Again"));
}
}
public string SheduleFacebookMessage(string FacebookId, string UserId, string sscheduledmsgguid)
{
string str = string.Empty;
try
{
objScheduledMessage = objScheduledMessageRepository.GetScheduledMessageDetails(Guid.Parse(sscheduledmsgguid));
if (objFacebookAccountRepository.checkFacebookUserExists(FacebookId, Guid.Parse(UserId)))
{
objFacebookAccount = objFacebookAccountRepository.getFacebookAccountDetailsById(FacebookId, Guid.Parse(UserId));
}
else
{
objFacebookAccount = objFacebookAccountRepository.getFacebookAccountDetailsById(FacebookId);
}
if (objFacebookAccount != null)
{
FacebookClient fbclient = new FacebookClient(objFacebookAccount.AccessToken);
var args = new Dictionary<string, object>();
args["message"] = objScheduledMessage.ShareMessage;
string imagepath = objScheduledMessage.PicUrl;
var facebookpost = "";
try
{
if (!string.IsNullOrEmpty(imagepath))
{
try
{
Uri u = new Uri(imagepath);
string filename = string.Empty;
string extension = string.Empty;
extension = Path.GetExtension(u.AbsolutePath).Replace(".", "");
var media = new FacebookMediaObject
{
FileName = "filename",
ContentType = "image/" + extension
};
//byte[] img = System.IO.File.ReadAllBytes(imagepath);
var webClient = new WebClient();
byte[] img = webClient.DownloadData(imagepath);
media.SetValue(img);
args["source"] = media;
facebookpost = fbclient.Post("v2.0/" + objFacebookAccount.FbUserId + "/photos", args).ToString();
}
catch (Exception ex)
{
Console.WriteLine(imagepath + "not Found");
if (!string.IsNullOrEmpty(objScheduledMessage.Url))
{
args["link"] = objScheduledMessage.Url;
}
facebookpost = fbclient.Post("v2.0/" + objFacebookAccount.FbUserId + "/feed", args).ToString();
}
}
else
{
facebookpost = fbclient.Post("v2.0/" + objFacebookAccount.FbUserId + "/feed", args).ToString();
}
}
catch (Exception ex)
{
//FacebookAccount ObjFacebookAccount = new FacebookAccount();
//objFacebookAccount = new Domain.Socioboard.Domain.FacebookAccount();
objFacebookAccountRepository = new FacebookAccountRepository();
//objFacebookAccount.IsActive = 2;
objFacebookAccountRepository.updateFacebookUserStatus(objFacebookAccount);
Domain.Socioboard.Domain.SocialProfile objSocialProfile = new Domain.Socioboard.Domain.SocialProfile();
SocialProfilesRepository objSocialProfilesRepository = new SocialProfilesRepository();
//logger.Error(ex.Message);
string errormsg = ex.Message;
if (errormsg.Contains("access token"))
{
objSocialProfile.UserId = objFacebookAccount.UserId;
objSocialProfile.ProfileId = objFacebookAccount.FbUserId;
objSocialProfile.ProfileStatus = 2;
objSocialProfilesRepository.updateSocialProfileStatus(objSocialProfile);
}
Console.WriteLine(ex.Message);
str = ex.Message;
}
if (!string.IsNullOrEmpty(facebookpost))
{
str = "Message post on facebook for Id :" + objFacebookAccount.FbUserId + " and Message: " + objScheduledMessage.ShareMessage;
ScheduledMessage schmsg = new ScheduledMessage();
schmsg.UpdateScheduledMessageByMsgId(Guid.Parse(sscheduledmsgguid));
}
}
else
{
str = "facebook account not found for id" + objScheduledMessage.ProfileId;
}
}
catch (Exception ex)
{
str = ex.Message;
}
return str;
}
private void AccessToken()
{
SocioBoard.Domain.User user = (User)Session["LoggedUser"];
oAuthTokenYoutube ObjoAuthTokenYoutube = new oAuthTokenYoutube();
oAuthToken objToken = new oAuthToken();
//GlobusGooglePlusLib.App.Core.PeopleController obj = new GlobusGooglePlusLib.App.Core.PeopleController();
logger.Error("Error1:oAuthToken");
string refreshToken = string.Empty;
string access_token = string.Empty;
try
{
string objRefresh = string.Empty;
objRefresh = ObjoAuthTokenYoutube.GetRefreshToken(Request.QueryString["code"]);
if (!objRefresh.StartsWith("["))
{
objRefresh = "[" + objRefresh + "]";
}
JArray objArray = JArray.Parse(objRefresh);
logger.Error("Error1:GetRefreshToken");
if (!objRefresh.Contains("refresh_token"))
{
logger.Error("Error0:refresh_token");
access_token = objArray[0]["access_token"].ToString();
string abc = ObjoAuthTokenYoutube.RevokeToken(access_token);
Response.Redirect("https://accounts.google.com/o/oauth2/auth?client_id=" + System.Configuration.ConfigurationManager.AppSettings["YtconsumerKey"] + "&redirect_uri=" + System.Configuration.ConfigurationManager.AppSettings["Ytredirect_uri"] + "&scope=https://www.googleapis.com/auth/youtube+https://www.googleapis.com/auth/youtube.readonly+https://www.googleapis.com/auth/youtubepartner+https://www.googleapis.com/auth/youtubepartner-channel-audit+https://www.googleapis.com/auth/userinfo.email+https://www.googleapis.com/auth/userinfo.profile+https://www.googleapis.com/auth/plus.me&response_type=code&access_type=offline");
logger.Error("Error1:refresh_token");
}
foreach (var item in objArray)
{
logger.Error("Abhay Item :" + item);
try
{
try
{
refreshToken = item["refresh_token"].ToString();
}
catch (Exception ex)
{
logger.Error(ex.StackTrace);
logger.Error(ex.Message);
Console.WriteLine(ex.StackTrace);
}
access_token = item["access_token"].ToString();
break;
}
catch (Exception ex)
{
logger.Error(ex.StackTrace);
Console.WriteLine(ex.StackTrace);
}
}
//Get user Profile
#region <<Get user Profile>>
JArray objEmail = new JArray();
try
{
objEmail = objToken.GetUserInfo("me", access_token.ToString());
}
catch (Exception ex)
{
logger.Error("Email : " + objEmail);
logger.Error(ex.Message);
}
#endregion
GlobusGooglePlusLib.Youtube.Core.Channels ObjChannel = new GlobusGooglePlusLib.Youtube.Core.Channels();
//Get the Channels of user
JArray objarray = new JArray();
try
{
string part = (oAuthTokenYoutube.Parts.contentDetails.ToString() + "," + oAuthTokenYoutube.Parts.statistics.ToString());
string Value = ObjChannel.Get_Channel_List(access_token, part, 50, true);
logger.Error("Successfully GetValus");
logger.Error("Value :" + Value);
JObject UserChannels = JObject.Parse(@Value);
logger.Error("Successfully Convert Jobj");
logger.Error("Successfully Convert Jobj");
objarray = (JArray)UserChannels["items"];
logger.Error("Successfully Convert JArr");
}
catch (Exception ex)
{
logger.Error("UserChannels :" + ex.Message);
}
YoutubeAccount objYoutubeAccount = new YoutubeAccount();
YoutubeChannel objYoutubeChannel = new YoutubeChannel();
YoutubeChannelRepository objYoutubeChannelRepository = new YoutubeChannelRepository();
YoutubeAccountRepository objYoutubeAccountRepository = new YoutubeAccountRepository();
//put condition here to check is user already exise if exist then update else insert
string ytuerid = "";
foreach (var itemEmail in objEmail)
{
logger.Error("itemEmail :" + itemEmail);
try
{
objYoutubeAccount.Id = Guid.NewGuid();
ytuerid = itemEmail["id"].ToString();
objYoutubeAccount.Ytuserid = itemEmail["id"].ToString();
objYoutubeAccount.Emailid = itemEmail["email"].ToString();
objYoutubeAccount.Ytusername = itemEmail["given_name"].ToString();
objYoutubeAccount.Ytprofileimage = itemEmail["picture"].ToString();
objYoutubeAccount.Accesstoken = access_token;
objYoutubeAccount.Refreshtoken = refreshToken;
objYoutubeAccount.Isactive = 1;
objYoutubeAccount.Entrydate = DateTime.Now;
objYoutubeAccount.UserId = user.Id;
}
catch (Exception ex)
{
logger.Error("itemEmail1 :" + ex.Message);
logger.Error("itemEmail1 :" + ex.StackTrace);
Console.WriteLine(ex.StackTrace);
}
}
foreach (var item in objarray)
{
try
{
objYoutubeChannel.Id = Guid.NewGuid();
objYoutubeChannel.Channelid = item["id"].ToString();
objYoutubeChannel.Likesid = item["contentDetails"]["relatedPlaylists"]["likes"].ToString();
objYoutubeChannel.Favoritesid = item["contentDetails"]["relatedPlaylists"]["favorites"].ToString();
objYoutubeChannel.Uploadsid = item["contentDetails"]["relatedPlaylists"]["uploads"].ToString();
objYoutubeChannel.Watchhistoryid = item["contentDetails"]["relatedPlaylists"]["watchHistory"].ToString();
objYoutubeChannel.Watchlaterid = item["contentDetails"]["relatedPlaylists"]["watchLater"].ToString();
objYoutubeChannel.Googleplususerid = ytuerid;
try
{
string viewcnt = item["statistics"]["viewCount"].ToString();
objYoutubeChannel.ViewCount = Convert.ToInt32(viewcnt);
string videocnt = item["statistics"]["videoCount"].ToString();
objYoutubeChannel.VideoCount = Convert.ToInt32(videocnt);
string commentcnt = item["statistics"]["commentCount"].ToString();
objYoutubeChannel.CommentCount = Convert.ToInt32(commentcnt);
string Subscribercnt = item["statistics"]["subscriberCount"].ToString();
objYoutubeChannel.SubscriberCount = Convert.ToInt32(Subscribercnt);
try
{
string str = item["statistics"]["hiddenSubscriberCount"].ToString();
if (str == "false")
{
objYoutubeChannel.HiddenSubscriberCount = 0;
}
else
{
objYoutubeChannel.HiddenSubscriberCount = 1;
}
}
catch (Exception ex)
{
logger.Error("aagaya1: " + ex);
Console.WriteLine(ex.StackTrace);
}
}
catch (Exception ex)
{
logger.Error("aagaya2: " + ex);
Console.WriteLine(ex.StackTrace);
}
}
catch (Exception ex)
{
logger.Error("aagaya3: " + ex);
Console.WriteLine(ex.StackTrace);
logger.Error(ex.StackTrace);
logger.Error(ex.Message);
}
}
//YoutubeChannelRepository.Add(objYoutubeChannel);
SocialProfile objSocialProfile = new SocialProfile();
SocialProfilesRepository objSocialProfilesRepository = new SocialProfilesRepository();
objSocialProfile.Id = Guid.NewGuid();
objSocialProfile.UserId = user.Id;
objSocialProfile.ProfileId = ytuerid;
objSocialProfile.ProfileType = "youtube";
objSocialProfile.ProfileDate = DateTime.Now;
objSocialProfile.ProfileStatus = 1;
logger.Error("aagaya");
if (!objSocialProfilesRepository.checkUserProfileExist(objSocialProfile))
{
objSocialProfilesRepository.addNewProfileForUser(objSocialProfile);
if (!objYoutubeAccountRepository.checkYoutubeUserExists(objYoutubeAccount))
{
logger.Error("Abhay");
YoutubeAccountRepository.Add(objYoutubeAccount);
logger.Error("Abhay account add ho gaya");
YoutubeChannelRepository.Add(objYoutubeChannel);
logger.Error("Channel account add ho gaya");
GroupRepository objGroupRepository = new GroupRepository();
SocioBoard.Domain.Team team = (SocioBoard.Domain.Team)HttpContext.Current.Session["GroupName"];
Groups lstDetails = objGroupRepository.getGroupName(team.GroupId);
if (lstDetails.GroupName == "Socioboard")
{
TeamMemberProfileRepository objTeamMemberProfileRepository = new TeamMemberProfileRepository();
TeamMemberProfile teammemberprofile = new TeamMemberProfile();
teammemberprofile.Id = Guid.NewGuid();
teammemberprofile.TeamId = team.Id;
teammemberprofile.ProfileId = objYoutubeAccount.Ytuserid;
teammemberprofile.ProfileType = "youtube";
teammemberprofile.StatusUpdateDate = DateTime.Now;
objTeamMemberProfileRepository.addNewTeamMember(teammemberprofile);
}
}
}
else
{
logger.Error("Suraj");
if (!objYoutubeAccountRepository.checkYoutubeUserExists(objYoutubeAccount))
{
YoutubeAccountRepository.Add(objYoutubeAccount);
YoutubeChannelRepository.Add(objYoutubeChannel);
}
else
{
Response.Redirect("Home.aspx");
}
}
Response.Redirect("Home.aspx");
}
catch (Exception Err)
{
Console.Write(Err.Message.ToString());
logger.Error(Err.StackTrace);
logger.Error(Err.Message);
}
}
public void ProcessRequest()
{
if (Request.QueryString["op"] == "login")
{
try
{
string email = Request.QueryString["username"];
string password = Request.QueryString["password"];
Registration regpage = new Registration();
password = regpage.MD5Hash(password);
SocioBoard.Helper.SessionFactory.configfilepath = Server.MapPath("~/hibernate.cfg.xml");
UserRepository userrepo = new UserRepository();
LoginLogs objLoginLogs = new LoginLogs();
LoginLogsRepository objLoginLogsRepository = new LoginLogsRepository();
User user = userrepo.GetUserInfo(email, password);
if (user == null)
{
Response.Write("Invalid Email or Password");
}
else
{
if (user.UserStatus == 1)
{
Session["LoggedUser"] = user;
// List<User> lstUser = new List<User>();
if (Session["LoggedUser"] != null)
{
//SocioBoard.Domain.User.lstUser.Add((User)Session["LoggedUser"]);
//Application["OnlineUsers"] = SocioBoard.Domain.User.lstUser;
//objLoginLogs.Id = new Guid();
//objLoginLogs.UserId = user.Id;
//objLoginLogs.UserName = user.UserName;
//objLoginLogs.LoginTime = DateTime.Now.AddHours(11.50);
//objLoginLogsRepository.Add(objLoginLogs);
Groups objGroups = new Groups();
GroupRepository objGroupRepository = new GroupRepository();
Team objteam = new Team();
TeamRepository objTeamRepository = new TeamRepository();
objGroups = objGroupRepository.getGroupDetail(user.Id);
if (objGroups == null)
{
//================================================================================
//Insert into group
try
{
objGroups = new Groups();
objGroups.Id = Guid.NewGuid();
objGroups.GroupName = ConfigurationManager.AppSettings["DefaultGroupName"];
objGroups.UserId = user.Id;
objGroups.EntryDate = DateTime.Now;
objGroupRepository.AddGroup(objGroups);
objteam.Id = Guid.NewGuid();
objteam.GroupId = objGroups.Id;
objteam.UserId = user.Id;
objteam.EmailId = user.EmailId;
// teams.FirstName = user.UserName;
objTeamRepository.addNewTeam(objteam);
SocialProfile objSocialProfile = new SocialProfile();
SocialProfilesRepository objSocialProfilesRepository = new SocialProfilesRepository();
List <SocialProfile> lstSocialProfile = objSocialProfilesRepository.getAllSocialProfilesOfUser(user.Id);
if (lstSocialProfile != null)
{
if (lstSocialProfile.Count > 0)
{
foreach (SocialProfile item in lstSocialProfile)
{
try
{
TeamMemberProfile objTeamMemberProfile = new TeamMemberProfile();
TeamMemberProfileRepository objTeamMemberProfileRepository = new TeamMemberProfileRepository();
objTeamMemberProfile.Id = Guid.NewGuid();
objTeamMemberProfile.TeamId = objteam.Id;
objTeamMemberProfile.ProfileId = item.ProfileId;
objTeamMemberProfile.ProfileType = item.ProfileType;
objTeamMemberProfile.Status = item.ProfileStatus;
objTeamMemberProfile.StatusUpdateDate = DateTime.Now;
objTeamMemberProfileRepository.addNewTeamMember(objTeamMemberProfile);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
logger.Error("Error : " + ex.Message);
logger.Error("Error : " + ex.StackTrace);
}
//==========================================================================================================
}
BusinessSetting objBusinessSetting = new BusinessSetting();
BusinessSettingRepository objBusinessSettingRepository = new BusinessSettingRepository();
List <BusinessSetting> lstBusinessSetting = objBusinessSettingRepository.GetBusinessSettingByUserId(user.Id);
if (lstBusinessSetting.Count == 0)
{
try
{
List <Groups> lstGroups = objGroupRepository.getAllGroups(user.Id);
foreach (Groups item in lstGroups)
{
objBusinessSetting = new BusinessSetting();
objBusinessSetting.Id = Guid.NewGuid();
objBusinessSetting.BusinessName = item.GroupName;
//objbsnssetting.GroupId = team.GroupId;
objBusinessSetting.GroupId = item.Id;
objBusinessSetting.AssigningTasks = false;
objBusinessSetting.AssigningTasks = false;
objBusinessSetting.TaskNotification = false;
objBusinessSetting.TaskNotification = false;
objBusinessSetting.FbPhotoUpload = 0;
objBusinessSetting.UserId = user.Id;
objBusinessSetting.EntryDate = DateTime.Now;
objBusinessSettingRepository.AddBusinessSetting(objBusinessSetting);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
}
Response.Write("user");
}
else
{
Response.Write("You are Blocked by Admin Please contact Admin!");
}
}
}
catch (Exception ex)
{
Response.Write("Error: " + ex.Message);
Console.WriteLine(ex.StackTrace);
logger.Error(ex.StackTrace);
}
}
else if (Request.QueryString["op"] == "register")
{
User user = new User();
UserActivation objUserActivation = new UserActivation();
UserRepository userrepo = new UserRepository();
SocioBoard.Helper.SessionFactory.configfilepath = Server.MapPath("~/hibernate.cfg.xml");
Session["AjaxLogin"] = "******";
try
{
System.IO.StreamReader sr = new System.IO.StreamReader(Request.InputStream);
string line = "";
line = sr.ReadToEnd();
JObject jo = JObject.Parse(line);
user.PaymentStatus = "unpaid";
if (!string.IsNullOrEmpty(Request.QueryString["type"]))
{
user.AccountType = Request.QueryString["type"];
}
else
{
user.AccountType = "deluxe";
}
user.CreateDate = DateTime.Now;
user.ExpiryDate = DateTime.Now.AddMonths(1);
user.Id = Guid.NewGuid();
user.UserName = Server.UrlDecode((string)jo["firstname"]) + " " + Server.UrlDecode((string)jo["lastname"]);
user.EmailId = Server.UrlDecode((string)jo["email"]);
user.Password = Server.UrlDecode((string)jo["password"]);
user.UserStatus = 1;
if (!userrepo.IsUserExist(user.EmailId))
{
UserRepository.Add(user);
Session["LoggedUser"] = user;
Response.Write("user");
objUserActivation.Id = Guid.NewGuid();
objUserActivation.UserId = user.Id;
objUserActivation.ActivationStatus = "0";
UserActivationRepository.Add(objUserActivation);
//add value in userpackage
UserPackageRelation objUserPackageRelation = new UserPackageRelation();
UserPackageRelationRepository objUserPackageRelationRepository = new UserPackageRelationRepository();
PackageRepository objPackageRepository = new PackageRepository();
Package objPackage = objPackageRepository.getPackageDetails(user.AccountType);
objUserPackageRelation.Id = new Guid();
objUserPackageRelation.PackageId = objPackage.Id;
objUserPackageRelation.UserId = user.Id;
objUserPackageRelation.PackageStatus = true;
objUserPackageRelationRepository.AddUserPackageRelation(objUserPackageRelation);
SocioBoard.Helper.MailSender.SendEMail(user.UserName, user.Password, user.EmailId, user.AccountType.ToString(), user.Id.ToString());
//MailSender.SendEMail(user.UserName, user.Password, user.EmailId);
// lblerror.Text = "Registered Successfully !" + "<a href=\"login.aspx\">Login</a>";
}
else
{
Response.Write("Email Already Exists !");
}
}
catch (Exception ex)
{
logger.Error(ex.StackTrace);
Console.WriteLine(ex.StackTrace);
}
}
else if (Request.QueryString["op"] == "facebooklogin")
{
SessionFactory.configfilepath = Server.MapPath("~/hibernate.cfg.xml");
string redi = "http://www.facebook.com/dialog/oauth/?scope=publish_stream,read_stream,read_insights,manage_pages,user_checkins,user_photos,read_mailbox,manage_notifications,read_page_mailboxes,email,user_videos,offline_access&client_id=" + ConfigurationManager.AppSettings["ClientId"] + "&redirect_uri=" + ConfigurationManager.AppSettings["RedirectUrl"] + "&response_type=code";
Session["login"] = "******";
Response.Write(redi);
}
else if (Request.QueryString["op"] == "googlepluslogin")
{
Session["login"] = "******";
oAuthToken objToken = new oAuthToken();
Response.Write(objToken.GetAutherizationLink("https://www.googleapis.com/auth/userinfo.email+https://www.googleapis.com/auth/userinfo.profile+https://www.googleapis.com/auth/plus.me+https://www.googleapis.com/auth/plus.login"));
}
else if (Request.QueryString["op"] == "removeuser")
{
try
{
if (Session["LoggedUser"] != null)
{
SocioBoard.Domain.User.lstUser.Remove((User)Session["LoggedUser"]);
}
}
catch (Exception Err)
{
logger.Error(Err.StackTrace);
Response.Write(Err.StackTrace);
}
}
}
public void getAccessToken()
{
GlobusInstagramLib.Authentication.ConfigurationIns configi = new GlobusInstagramLib.Authentication.ConfigurationIns("https://api.instagram.com/oauth/authorize/", ConfigurationManager.AppSettings["InstagramClientKey"].ToString(), ConfigurationManager.AppSettings["InstagramClientSec"].ToString(), ConfigurationManager.AppSettings["InstagramCallBackURL"].ToString(), "http://api.instagram.com/oauth/access_token", "https://api.instagram.com/v1/", "");
SocialProfilesRepository socioprofilerepo = new SocialProfilesRepository();
SocialProfile socioprofile = new SocialProfile();
_api = oAuthInstagram.GetInstance(configi);
AccessToken access = new AccessToken();
string code = Request.QueryString["code"].ToString();
SocioBoard.Domain.User user = (SocioBoard.Domain.User)Session["LoggedUser"];
access = _api.AuthGetAccessToken(code);
UserController objusercontroller = new UserController();
InstagramResponse <GlobusInstagramLib.App.Core.User> objuser = objusercontroller.GetUserDetails(access.user.id, access.access_token);
InstagramAccount objInsAccount = new InstagramAccount();
objInsAccount.AccessToken = access.access_token;
//objInsAccount.FollowedBy=access.user.
objInsAccount.InstagramId = access.user.id;
objInsAccount.ProfileUrl = access.user.profile_picture;
objInsAccount.InsUserName = access.user.username;
objInsAccount.TotalImages = objuser.data.counts.media;
objInsAccount.FollowedBy = objuser.data.counts.followed_by;
objInsAccount.Followers = objuser.data.counts.follows;
objInsAccount.UserId = user.Id;
socioprofile.UserId = user.Id;
socioprofile.ProfileType = "instagram";
socioprofile.ProfileId = access.user.id;
socioprofile.ProfileStatus = 1;
socioprofile.ProfileDate = DateTime.Now;
socioprofile.Id = Guid.NewGuid();
if (objInsRepo.checkInstagramUserExists(access.user.id, user.Id))
{
HttpContext.Current.Session["alreadyexist"] = objInsAccount;
objInsRepo.updateInstagramUser(objInsAccount);
if (!socioprofilerepo.checkUserProfileExist(socioprofile))
{
socioprofilerepo.addNewProfileForUser(socioprofile);
}
}
else
{
objInsRepo.addInstagramUser(objInsAccount);
if (!socioprofilerepo.checkUserProfileExist(socioprofile))
{
socioprofilerepo.addNewProfileForUser(socioprofile);
GroupRepository objGroupRepository = new GroupRepository();
SocioBoard.Domain.Team team = (SocioBoard.Domain.Team)HttpContext.Current.Session["GroupName"];
Groups lstDetails = objGroupRepository.getGroupName(team.GroupId);
if (lstDetails.GroupName == "Socioboard")
{
TeamMemberProfileRepository objTeamMemberProfileRepository = new TeamMemberProfileRepository();
TeamMemberProfile teammemberprofile = new TeamMemberProfile();
teammemberprofile.Id = Guid.NewGuid();
teammemberprofile.TeamId = team.Id;
teammemberprofile.ProfileId = socioprofile.ProfileId;
teammemberprofile.ProfileType = "instagram";
teammemberprofile.StatusUpdateDate = DateTime.Now;
objTeamMemberProfileRepository.addNewTeamMember(teammemberprofile);
}
}
}
string messages = getIntagramImages(objInsAccount);
Response.Write(messages);
}
public void GetLinkedInUserProfile(dynamic data, oAuthLinkedIn _oauth, Guid user, string LinkedinUserId)
{
SocialProfile socioprofile = new SocialProfile();
SocialProfilesRepository socioprofilerepo = new SocialProfilesRepository();
LinkedInAccount objLinkedInAccount = new LinkedInAccount();
LinkedInAccountRepository objLiRepo = new LinkedInAccountRepository();
try
{
objLinkedInAccount.UserId = user;
objLinkedInAccount.LinkedinUserId = data.id.ToString();
try
{
objLinkedInAccount.EmailId = data.email.ToString();
}
catch { }
objLinkedInAccount.LinkedinUserName = data.first_name.ToString() + data.last_name.ToString();
objLinkedInAccount.OAuthToken = _oauth.Token;
objLinkedInAccount.OAuthSecret = _oauth.TokenSecret;
objLinkedInAccount.OAuthVerifier = _oauth.Verifier;
try
{
objLinkedInAccount.ProfileImageUrl = data.picture_url.ToString();
}
catch { }
try
{
objLinkedInAccount.ProfileUrl = data.profile_url.ToString();
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
objLinkedInAccount.Connections = data.connections;
objLinkedInAccount.IsActive = true;
socioprofile.UserId = user;
socioprofile.ProfileType = "linkedin";
socioprofile.ProfileId = LinkedinUserId;
socioprofile.ProfileStatus = 1;
socioprofile.ProfileDate = DateTime.Now;
socioprofile.Id = Guid.NewGuid();
}
catch
{
}
try
{
if (!socioprofilerepo.checkUserProfileExist(socioprofile))
{
socioprofilerepo.addNewProfileForUser(socioprofile);
GroupRepository objGroupRepository = new GroupRepository();
SocioBoard.Domain.Team team = (SocioBoard.Domain.Team)HttpContext.Current.Session["GroupName"];
Groups lstDetails = objGroupRepository.getGroupName(team.GroupId);
if (lstDetails.GroupName == "Socioboard")
{
TeamMemberProfileRepository objTeamMemberProfileRepository = new TeamMemberProfileRepository();
TeamMemberProfile teammemberprofile = new TeamMemberProfile();
teammemberprofile.Id = Guid.NewGuid();
teammemberprofile.TeamId = team.Id;
teammemberprofile.ProfileId = socioprofile.ProfileId;
teammemberprofile.ProfileType = "linkedin";
teammemberprofile.StatusUpdateDate = DateTime.Now;
objTeamMemberProfileRepository.addNewTeamMember(teammemberprofile);
}
}
else
{
socioprofile.ProfileId = data.id.ToString();
socioprofilerepo.updateSocialProfile(socioprofile);
}
if (!objLiRepo.checkLinkedinUserExists(LinkedinUserId, user))
{
objLiRepo.addLinkedinUser(objLinkedInAccount);
}
else
{
objLinkedInAccount.LinkedinUserId = LinkedinUserId;
objLiRepo.updateLinkedinUser(objLinkedInAccount);
}
// GetLinkedInFeeds(_oauth, data.id, user.Id);
}
catch
{
}
}
public void getFacebookUserProfile(dynamic data, string accesstoken, long friends, Guid user)
{
SocialProfile socioprofile = new SocialProfile();
SocialProfilesRepository socioprofilerepo = new SocialProfilesRepository();
FacebookAccount fbAccount = new FacebookAccount();
FacebookAccountRepository fbrepo = new FacebookAccountRepository();
try
{
try
{
fbAccount.AccessToken = accesstoken;
}
catch
{
}
try
{
fbAccount.EmailId = data["email"].ToString();
}
catch
{
}
try
{
fbAccount.FbUserId = data["id"].ToString();
}
catch
{
}
try
{
fbAccount.ProfileUrl = data["link"].ToString();
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
try
{
fbAccount.FbUserName = data["name"].ToString();
}
catch
{
}
try
{
fbAccount.Friends = Convert.ToInt32(friends);
}
catch
{
}
try
{
fbAccount.Id = Guid.NewGuid();
}
catch
{
}
fbAccount.IsActive = 1;
try
{
if (HttpContext.Current.Session["fbSocial"] != null)
{
if (HttpContext.Current.Session["fbSocial"] == "p")
{
//FacebookClient fbClient = new FacebookClient(accesstoken);
//int fancountPage = 0;
//dynamic fancount = fbClient.Get("fql", new { q = " SELECT fan_count FROM page WHERE page_id =" + fbAccount.FbUserId });
//foreach (var friend in fancount.data)
//{
// fancountPage = friend.fan_count;
//}
//fbAccount.Friends = Convert.ToInt32(fancountPage);
fbAccount.Type = "page";
}
else
{
fbAccount.Type = "account";
}
fbAccount.UserId = user;
}
if (HttpContext.Current.Session["UserAndGroupsForFacebook"] != null)
{
try
{
fbAccount.UserId = user;
fbAccount.Type = "account";
}
catch (Exception ex)
{
}
}
}
catch
{
}
#region unused
//if (HttpContext.Current.Session["login"] != null)
//{
// if (HttpContext.Current.Session["login"].ToString().Equals("facebook"))
// {
// User usr = new User();
// UserRepository userrepo = new UserRepository();
// Registration regObject = new Registration();
// usr.AccountType = "free";
// usr.CreateDate = DateTime.Now;
// usr.ExpiryDate = DateTime.Now.AddMonths(1);
// usr.Id = Guid.NewGuid();
// usr.UserName = data["name"].ToString();
// usr.Password = regObject.MD5Hash(data["name"].ToString());
// usr.EmailId = data["email"].ToString();
// usr.UserStatus = 1;
// if (!userrepo.IsUserExist(data["email"].ToString()))
// {
// UserRepository.Add(usr);
// }
// }
//}
#endregion
try
{
socioprofile.UserId = user;
}
catch
{
}
try
{
socioprofile.ProfileType = "facebook";
}
catch
{
}
try
{
socioprofile.ProfileId = data["id"].ToString();
}
catch
{
}
try
{
socioprofile.ProfileStatus = 1;
}
catch
{
}
try
{
socioprofile.ProfileDate = DateTime.Now;
}
catch
{
}
try
{
socioprofile.Id = Guid.NewGuid();
}
catch
{
}
if (HttpContext.Current.Session["fbSocial"] != null)
{
if (HttpContext.Current.Session["fbSocial"] == "p")
{
HttpContext.Current.Session["fbpagedetail"] = fbAccount;
}
else
{
if (!fbrepo.checkFacebookUserExists(fbAccount.FbUserId, user))
{
fbrepo.addFacebookUser(fbAccount);
if (!socioprofilerepo.checkUserProfileExist(socioprofile))
{
socioprofilerepo.addNewProfileForUser(socioprofile);
GroupRepository objGroupRepository = new GroupRepository();
SocioBoard.Domain.Team team = (SocioBoard.Domain.Team)HttpContext.Current.Session["GroupName"];
Groups lstDetails = objGroupRepository.getGroupName(team.GroupId);
if (lstDetails.GroupName == "Socioboard")
{
TeamMemberProfileRepository objTeamMemberProfileRepository = new TeamMemberProfileRepository();
TeamMemberProfile teammemberprofile = new TeamMemberProfile();
teammemberprofile.Id = Guid.NewGuid();
teammemberprofile.TeamId = team.Id;
teammemberprofile.ProfileId = fbAccount.FbUserId;
teammemberprofile.ProfileType = "facebook";
teammemberprofile.StatusUpdateDate = DateTime.Now;
objTeamMemberProfileRepository.addNewTeamMember(teammemberprofile);
}
}
else
{
socioprofilerepo.updateSocialProfile(socioprofile);
}
}
else
{
HttpContext.Current.Session["alreadyexist"] = fbAccount;
fbrepo.updateFacebookUser(fbAccount);
if (!socioprofilerepo.checkUserProfileExist(socioprofile))
{
socioprofilerepo.addNewProfileForUser(socioprofile);
}
else
{
socioprofilerepo.updateSocialProfile(socioprofile);
}
}
}
}
if (HttpContext.Current.Session["UserAndGroupsForFacebook"] != null)
{
if (HttpContext.Current.Session["UserAndGroupsForFacebook"].ToString() == "facebook")
{
try
{
if (!fbrepo.checkFacebookUserExists(fbAccount.FbUserId, user))
{
fbrepo.addFacebookUser(fbAccount);
if (!socioprofilerepo.checkUserProfileExist(socioprofile))
{
socioprofilerepo.addNewProfileForUser(socioprofile);
}
else
{
socioprofilerepo.updateSocialProfile(socioprofile);
}
}
else
{
fbrepo.updateFacebookUser(fbAccount);
if (!socioprofilerepo.checkUserProfileExist(socioprofile))
{
socioprofilerepo.addNewProfileForUser(socioprofile);
}
else
{
socioprofilerepo.updateSocialProfile(socioprofile);
}
}
if (HttpContext.Current.Session["GroupName"] != null)
{
GroupProfile groupprofile = new GroupProfile();
GroupProfileRepository groupprofilerepo = new GroupProfileRepository();
Groups group = (Groups)HttpContext.Current.Session["GroupName"];
groupprofile.Id = Guid.NewGuid();
groupprofile.GroupOwnerId = user;
groupprofile.ProfileId = socioprofile.ProfileId;
groupprofile.ProfileType = "facebook";
groupprofile.GroupId = group.Id;
groupprofile.EntryDate = DateTime.Now;
if (!groupprofilerepo.checkGroupProfileExists(user, group.Id, groupprofile.ProfileId))
{
groupprofilerepo.AddGroupProfile(groupprofile);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
UserRefRelationRepository objUserRefRelationRepository = new UserRefRelationRepository();
UserRepository userrepo = new UserRepository();
Registration regObject = new Registration();
TeamRepository objTeamRepo = new TeamRepository();
NewsRepository objNewsRepo = new NewsRepository();
AdsRepository objAdsRepo = new AdsRepository();
UserActivation objUserActivation = new UserActivation();
UserActivationRepository objUserActivationRepository = new UserActivationRepository();
SocialProfilesRepository objSocioRepo = new SocialProfilesRepository();
GroupRepository objGroupRepository = new GroupRepository();
TeamMemberProfileRepository objTeamMemberProfileRepository = new TeamMemberProfileRepository();
Team team = new Team();
SocioBoard.Domain.User user = (User)Session["LoggedUser"];
try
{
if (Session["GroupName"] == null)
{
Groups objGroupDetails = objGroupRepository.getGroupDetail(user.Id);
team = objTeamRepo.getAllDetails(objGroupDetails.Id, user.EmailId);
Session["GroupName"] = team;
}
else
{
team = (SocioBoard.Domain.Team)Session["GroupName"];
}
}
catch (Exception ex)
{
logger.Error("Error: " + ex.Message);
}
Session["facebooktotalprofiles"] = null;
if (user.Password == null)
{
Response.Redirect("/Pricing.aspx");
}
#region Days remaining
if (Session["days_remaining"] == null)
{
if (user.PaymentStatus == "unpaid" && user.AccountType != "Free")
{
int daysremaining = (user.ExpiryDate.Date - DateTime.Now.Date).Days;
if (daysremaining < 0)
{
daysremaining = -1;
}
Session["days_remaining"] = daysremaining;
//ScriptManager.RegisterStartupScript(this, GetType(), "showalert", "alert('You are using '" + user.AccountType + "' account only '" + daysremaining + "' days is remaining !');", true);
if (daysremaining <= -1)
{
}
else if (daysremaining == 0)
{
ScriptManager.RegisterStartupScript(this, GetType(), "showalert", "alert('Your trial " + user.AccountType + " account will expire end of the day, please upgrade to paid plan.');", true);
}
else
{
ScriptManager.RegisterStartupScript(this, GetType(), "showalert", "alert('Your trial " + user.AccountType + " account will expire in " + daysremaining + " days, please upgrade to paid plan.');", true);
}
}
}
#endregion
#region for You can use only 30 days as Unpaid User
if (user.PaymentStatus.ToLower() == "unpaid" && user.AccountType != "Free")
{
if (!SBUtils.IsUserWorkingDaysValid(user.ExpiryDate))
{
// ScriptManager.RegisterStartupScript(this, GetType(), "showalert", "alert('You can use only 30 days as Unpaid User !');", true);
Session["GreaterThan30Days"] = "GreaterThan30Days";
Response.Redirect("/Settings/Billing.aspx");
}
}
Session["GreaterThan30Days"] = null;
#endregion
if (!IsPostBack)
{
try
{
if (user == null)
{
Response.Redirect("Default.aspx");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
logger.Error(ex.StackTrace);
}
try
{
objUserActivation = objUserActivationRepository.GetUserActivationStatus(user.Id.ToString());
}
catch (Exception ex)
{
Session["objUserActivationException"] = "objUserActivationException";
Console.WriteLine(ex.Message);
logger.Error(ex.StackTrace);
}
#region Count Used Accounts
try
{
if (user.AccountType.ToString().ToLower() == AccountType.Deluxe.ToString().ToLower())
{
tot_acc = 50;
}
else if (user.AccountType.ToString().ToLower() == AccountType.Standard.ToString().ToLower())
{
tot_acc = 10;
}
else if (user.AccountType.ToString().ToLower() == AccountType.Premium.ToString().ToLower())
{
tot_acc = 20;
}
else if (user.AccountType.ToString().ToLower() == AccountType.Free.ToString().ToLower())
{
tot_acc = 5;
}
else if (user.AccountType.ToString().ToLower() == AccountType.SocioBasic.ToString().ToLower())
{
tot_acc = 100;
}
else if (user.AccountType.ToString().ToLower() == AccountType.SocioStandard.ToString().ToLower())
{
tot_acc = 200;
}
else if (user.AccountType.ToString().ToLower() == AccountType.SocioPremium.ToString().ToLower())
{
tot_acc = 500;
}
else if (user.AccountType.ToString().ToLower() == AccountType.SocioDeluxe.ToString().ToLower())
{
tot_acc = 1000;
}
profileCount = objSocioRepo.getAllSocialProfilesOfUser(user.Id).Count;
Session["ProfileCount"] = profileCount;
Session["TotalAccount"] = tot_acc;
try
{
Groups lstDetail = objGroupRepository.getGroupName(team.GroupId);
if (lstDetail.GroupName == "Socioboard")
{
usedAccount.InnerHtml = " using " + profileCount + " of " + tot_acc;
}
}
catch (Exception ex)
{
logger.Error(ex.StackTrace);
}
}
catch (Exception ex)
{
logger.Error(ex.StackTrace);
}
#endregion
try
{
Groups lstDetails = objGroupRepository.getGroupName(team.GroupId);
if (lstDetails.GroupName != "Socioboard")
{
expander.Attributes.CssStyle.Add("display", "none");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
//this is used to check whether facebok account Already Exist
if (Session["alreadyexist"] != null)
{
ScriptManager.RegisterStartupScript(this, GetType(), "showalert", "alert('This Profile is Already Added please add aother Account!');", true);
Session["alreadyexist"] = null;
}
if (Session["alreadypageexist"] != null)
{
ScriptManager.RegisterStartupScript(this, GetType(), "showalert", "alert('This Page is Already Added please add aother Page!');", true);
Session["alreadypageexist"] = null;
}
if (!string.IsNullOrEmpty(Request.QueryString["type"]))
{
try
{
userrepo.UpdateAccountType(user.Id, Request.QueryString["type"]);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
logger.Error(ex.StackTrace);
}
}
//acrossProfile.InnerHtml = "Across " + user.UserName + "'s Twitter and Facebook accounts";
teamMem.InnerHtml = "managing " + user.UserName;
try
{
News nws = objNewsRepo.getNewsForHome();
//divNews.InnerHtml = nws.NewsDetail;
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
logger.Error(Err.StackTrace);
}
try
{
ArrayList lstads = objAdsRepo.getAdsForHome();
if (lstads.Count < 1)
{
if (user.PaymentStatus.ToUpper() == "PAID")
{
bindads.InnerHtml = "<img src=\"../Contents/img/admin/ads.png\" alt=\"\" >";
}
else
{
#region ADS Script
bindads.InnerHtml = "<script async src=\"//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js\"></script>" +
"<!-- socioboard -->" +
"<ins class=\"adsbygoogle\"" +
"style=\"display:inline-block;width:250px;height:250px\"" +
"data-ad-client=\"ca-pub-7073257741073458\"" +
"data-ad-slot=\"9533254693\"></ins>" +
"<script>" +
"(adsbygoogle = window.adsbygoogle || []).push({});" +
"</script>";
#endregion
}
}
foreach (var item in lstads)
{
Array temp = (Array)item;
//imgAds.ImageUrl = temp.GetValue(2).ToString();
if (user.PaymentStatus.ToUpper() == "PAID")
{
bindads.InnerHtml = "<img src=\"" + temp.GetValue(2).ToString() + "\" alt=\"\" style=\"width:246px;height:331px\">";
}
else
{
#region ADS Script
bindads.InnerHtml = "<script async src=\"//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js\"></script>" +
"<!-- socioboard -->" +
"<ins class=\"adsbygoogle\"" +
"style=\"display:inline-block;width:250px;height:250px\"" +
"data-ad-client=\"ca-pub-7073257741073458\"" +
"data-ad-slot=\"9533254693\"></ins>" +
"<script>" +
"(adsbygoogle = window.adsbygoogle || []).push({});" +
"</script>";
#endregion
}
break;
// ads.ImageUrl;
}
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
logger.Error(Err.StackTrace);
}
#region Team Member Count
try
{
GroupRepository grouprepo = new GroupRepository();
string groupsofhome = string.Empty;
List <Groups> lstgroups = grouprepo.getAllGroups(user.Id);
if (lstgroups.Count != 0)
{
foreach (Groups item in lstgroups)
{
groupsofhome += "<li><a href=\"../Settings/InviteMember.aspx?q=" + item.Id + "\"><img src=\"../Contents/img/groups_.png\" alt=\"\" style=\" margin-right:5px;\"> " + item.GroupName + "</a></li>";
}
getAllGroupsOnHome.InnerHtml = groupsofhome;
}
}
catch (Exception ex)
{
logger.Error(ex.StackTrace);
}
#endregion
try
{
string strTeam = string.Empty;
List <Team> teams = objTeamRepo.getAllTeamsOfUser(user.Id, team.GroupId, user.EmailId);
foreach (Team item in teams)
{
strTeam += "<div class=\"userpictiny\"><a target=\"_blank\" href=\"#\">" +
"<img width=\"48\" height=\"48\" title=\"" + item.FirstName + "\" alt=\"\" src=\"../Contents/img/blank_img.png\">" +
"</a></div>";
}
team_member.InnerHtml = strTeam;
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
}
#region Add Fan Page
try
{
if (Session["fbSocial"] != null)
{
if (Session["fbSocial"] == "p")
{
FacebookAccount objFacebookAccount = (FacebookAccount)Session["fbpagedetail"];
// string strpageUrl = "https://graph.facebook.com/" + objFacebookAccount.FacebookId + "/accounts";
// objFacebookUrlBuilder = (FacebookUrlBuilder)Session["FacebookInsightUser"];
// string strData = objAuthentication.RequestUrl(strpageUrl, objFacebookAccount.Token);
// JObject output = objWebRequest.FacebookRequest(strData, "Get");
FacebookClient fb = new FacebookClient();
fb.AccessToken = objFacebookAccount.AccessToken;
dynamic output = fb.Get("/me/accounts");
// JArray data = (JArray)output["data"];
DataTable dtFbPage = new DataTable();
dtFbPage.Columns.Add("Email");
dtFbPage.Columns.Add("PageId");
dtFbPage.Columns.Add("PageName");
dtFbPage.Columns.Add("status");
dtFbPage.Columns.Add("customer_id");
string strPageDiv = string.Empty;
if (output != null)
{
foreach (var item in output["data"])
{
if (item.category.ToString() != "Application")
{
strPageDiv += "<div><a id=\"A1\" onclick=\"getInsights('" + item["id"].ToString() + "','" + item["name"].ToString() + "')\"><span>" + item["name"].ToString() + "</span> </a></div>";
fbpage.InnerHtml = strPageDiv;
}
}
}
else
{
strPageDiv += "<div>No Pages Found</div>";
}
Page.ClientScript.RegisterStartupScript(Page.GetType(), "my", " ShowDialogHome(false);", true);
Session["fbSocial"] = null;
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
logger.Error(ex.StackTrace);
}
#endregion
#region InsightsData
try
{
decimal malecount = 0, femalecount = 0, cnt = 0;
FacebookStatsRepository objfbStatsRepo = new FacebookStatsRepository();
double daysSub = (DateTime.Now - user.CreateDate).TotalDays;
int userdays;
if (daysSub > 0 && daysSub <= 1)
{
userdays = 1;
}
else
{
userdays = (int)daysSub;
}
ArrayList arrFbStats = objfbStatsRepo.getAllFacebookStatsOfUser(user.Id, userdays);
//ArrayList arrFbStats = objfbStatsRepo.getTotalFacebookStatsOfUser(user.Id);
Random rNum = new Random();
foreach (var item in arrFbStats)
{
Array temp = (Array)item;
cnt += int.Parse(temp.GetValue(3).ToString()) + int.Parse(temp.GetValue(4).ToString());
malecount += int.Parse(temp.GetValue(3).ToString());
femalecount += int.Parse(temp.GetValue(4).ToString());
}
try
{
decimal mc = (malecount / cnt) * 100;
male = Convert.ToInt16(mc);
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
logger.Error(Err.StackTrace);
}
try
{
decimal fc = (femalecount / cnt) * 100;
female = Convert.ToInt16(fc);
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
logger.Error(Err.StackTrace);
}
int twtAccCount = objSocioRepo.getAllSocialProfilesTypeOfUser(user.Id, "twitter").Count;
if (twtAccCount > 1)
{
twtmale = rNum.Next(100);
twtfemale = 100 - twtmale;
}
else if (twtAccCount == 1)
{
twtmale = 100;
twtfemale = 0;
}
Session["twtGender"] = twtmale + "," + twtfemale;
}
catch (Exception Err)
{
Console.Write(Err.Message.ToString());
logger.Error(Err.StackTrace);
}
//getgrphData();
// getNewFriends(7);
// getNewFriends();
// getNewFollowers();
#endregion
#region GetFollower
try
{
String TwtProfileId = string.Empty;
TwitterStatsRepository objtwtStatsRepo = new TwitterStatsRepository();
List <TeamMemberProfile> objTeamMemberProfile = objTeamMemberProfileRepository.getTwtTeamMemberProfileData(team.Id);
foreach (TeamMemberProfile item in objTeamMemberProfile)
{
TwtProfileId += item.ProfileId + ',';
}
TwtProfileId = TwtProfileId.Substring(0, TwtProfileId.Length - 1);
List <TwitterStats> arrTwtStats = objtwtStatsRepo.getAllAccountDetail(TwtProfileId);
//strTwtArray = "[";
int NewTweet_Count = 0;
string TotalFollower = string.Empty;
foreach (TwitterStats item in arrTwtStats)
{
NewTweet_Count += item.FollowerCount;
}
if (NewTweet_Count >= 100000)
{
TotalFollower = (System.Math.Round(((float)NewTweet_Count / 1000000), 2)) + "M";
}
else if (NewTweet_Count > 1000 && NewTweet_Count < 100000)
{
TotalFollower = (System.Math.Round(((float)NewTweet_Count / 1000), 2)) + "K";
}
else
{
TotalFollower = NewTweet_Count.ToString();
}
spanNewTweets.InnerHtml = TotalFollower;
}
catch (Exception Err)
{
Console.Write(Err.Message.ToString());
logger.Error(Err.StackTrace);
}
#endregion
#region GetFacebookFanPage
try
{
String FbProfileId = string.Empty;
FacebookStatsRepository objFacebookStatsRepository = new FacebookStatsRepository();
List <TeamMemberProfile> objTeamMemberProfile = objTeamMemberProfileRepository.getTeamMemberProfileData(team.Id);
foreach (TeamMemberProfile item in objTeamMemberProfile)
{
FbProfileId += item.ProfileId + ',';
}
FbProfileId = FbProfileId.Substring(0, FbProfileId.Length - 1);
List <FacebookStats> arrFbStats = objFacebookStatsRepository.getAllAccountDetail(FbProfileId);
//strTwtArray = "[";
int NewFbFan_Count = 0;
string TotalFriends = string.Empty;
foreach (FacebookStats item in arrFbStats)
{
NewFbFan_Count += item.FanCount;
}
if (NewFbFan_Count >= 100000)
{
TotalFriends = (System.Math.Round(((float)NewFbFan_Count / 1000000), 2)) + "M";
}
else if (NewFbFan_Count > 1000 && NewFbFan_Count < 100000)
{
TotalFriends = (System.Math.Round(((float)NewFbFan_Count / 1000), 2)) + "K";
}
else
{
TotalFriends = NewFbFan_Count.ToString();
}
spanFbFans.InnerHtml = TotalFriends;
}
catch (Exception Err)
{
Console.Write(Err.Message.ToString());
logger.Error(Err.StackTrace);
}
#endregion
#region IncomingMessages
try
{
FacebookFeedRepository fbFeedRepo = new FacebookFeedRepository();
int fbmessagescout = fbFeedRepo.countUnreadMessages(user.Id);
TwitterMessageRepository twtMsgRepo = new TwitterMessageRepository();
int twtcount = twtMsgRepo.getCountUnreadMessages(user.Id);
Session["CountMessages"] = fbmessagescout + twtcount;
}
catch (Exception ex)
{
logger.Error(ex.StackTrace);
}
#endregion
#region NewIncomingMessage
try
{
String FbProfileId = string.Empty;
String TwtProfileId = string.Empty;
List <TeamMemberProfile> objTeamMemberProfile = objTeamMemberProfileRepository.getAllTeamMemberProfilesOfTeam(team.Id);
foreach (TeamMemberProfile item in objTeamMemberProfile)
{
try
{
if (item.ProfileType == "facebook")
{
FbProfileId += item.ProfileId + ',';
}
else if (item.ProfileType == "twitter")
{
TwtProfileId += item.ProfileId + ',';
}
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
logger.Error(Err.StackTrace);
}
}
try
{
FbProfileId = FbProfileId.Substring(0, FbProfileId.Length - 1);
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
logger.Error(Err.StackTrace);
}
try
{
TwtProfileId = TwtProfileId.Substring(0, TwtProfileId.Length - 1);
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
logger.Error(Err.StackTrace);
}
FacebookFeedRepository objFacebookFeedRepository = new FacebookFeedRepository();
List <FacebookFeed> alstfb = objFacebookFeedRepository.getAllFeedDetail(FbProfileId);
// FacebookMessageRepository objFacebookMessageRepository = new FacebookMessageRepository();
TwitterMessageRepository objtwttatsRepo = new TwitterMessageRepository();
// List<FacebookMessage> alstfb = objFacebookMessageRepository.getAllMessageDetail(FbProfileId);
List <TwitterMessage> alstTwt = objtwttatsRepo.getAlltwtMessages(TwtProfileId);
int TotalFbMsgCount = 0;
int TotalTwtMsgCount = 0;
try
{
TotalFbMsgCount = alstfb.Count;
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
logger.Error(Err.StackTrace);
}
try
{
TotalTwtMsgCount = alstTwt.Count;
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
logger.Error(Err.StackTrace);
}
spanIncoming.InnerHtml = (TotalFbMsgCount + TotalTwtMsgCount).ToString();
string profileid = string.Empty;
ScheduledMessageRepository objScheduledMessageRepository = new ScheduledMessageRepository();
foreach (TeamMemberProfile item in objTeamMemberProfile)
{
profileid += item.ProfileId + ',';
}
profileid = profileid.Substring(0, profileid.Length - 1);
spanSent.InnerHtml = objScheduledMessageRepository.getAllSentMessageDetails(profileid).Count().ToString();
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
logger.Error(Err.StackTrace);
}
}
#endregion
}
catch (Exception Err)
{
Console.Write(Err.StackTrace);
}
}
public void GetPageProfile(dynamic data, oAuthLinkedIn _OAuth, string UserId, string CompanyPageId, string GroupId)
{
Domain.Socioboard.Domain.SocialProfile socioprofile = new Domain.Socioboard.Domain.SocialProfile();
Domain.Socioboard.Domain.GroupProfile grpProfile = new Domain.Socioboard.Domain.GroupProfile();
SocialProfilesRepository socioprofilerepo = new SocialProfilesRepository();
Domain.Socioboard.Domain.LinkedinCompanyPage objLinkedincmpnypage = new Domain.Socioboard.Domain.LinkedinCompanyPage();
LinkedinCompanyPageRepository objLinkedCmpnyPgeRepo = new LinkedinCompanyPageRepository();
try
{
objLinkedincmpnypage.UserId = Guid.Parse(UserId);
try
{
objLinkedincmpnypage.LinkedinPageId = data.Pageid.ToString();
}
catch
{
}
objLinkedincmpnypage.Id = Guid.NewGuid();
try
{
objLinkedincmpnypage.EmailDomains = data.EmailDomains.ToString();
}
catch { }
objLinkedincmpnypage.LinkedinPageName = data.name.ToString();
objLinkedincmpnypage.OAuthToken = _OAuth.Token;
objLinkedincmpnypage.OAuthSecret = _OAuth.TokenSecret;
objLinkedincmpnypage.OAuthVerifier = _OAuth.Verifier;
try
{
objLinkedincmpnypage.Description = data.description.ToString();
}
catch { }
try
{
objLinkedincmpnypage.FoundedYear = data.founded_year.ToString();
}
catch { }
try
{
objLinkedincmpnypage.EndYear = data.end_year.ToString();
}
catch { }
try
{
objLinkedincmpnypage.Locations = data.locations.ToString();
}
catch { }
try
{
objLinkedincmpnypage.Specialties = data.Specialties.ToString();
}
catch { }
try
{
objLinkedincmpnypage.WebsiteUrl = data.website_url.ToString();
}
catch { }
try
{
objLinkedincmpnypage.Status = data.status.ToString();
}
catch { }
try
{
objLinkedincmpnypage.EmployeeCountRange = data.employee_count_range.ToString();
}
catch { }
try
{
objLinkedincmpnypage.Industries = data.industries.ToString();
}
catch { }
try
{
string NuberOfFollower = data.num_followers.ToString();
objLinkedincmpnypage.NumFollowers = Convert.ToInt16(NuberOfFollower);
}
catch { }
try
{
objLinkedincmpnypage.CompanyType = data.company_type.ToString();
}
catch { }
try
{
objLinkedincmpnypage.LogoUrl = data.logo_url.ToString();
}
catch { }
try
{
objLinkedincmpnypage.SquareLogoUrl = data.square_logo_url.ToString();
}
catch { }
try
{
objLinkedincmpnypage.BlogRssUrl = data.blog_rss_url.ToString();
}
catch { }
try
{
objLinkedincmpnypage.UniversalName = data.universal_name.ToString();
}
catch { }
#region SocialProfiles
socioprofile.UserId = Guid.Parse(UserId);
socioprofile.ProfileType = "linkedincompanypage";
socioprofile.ProfileId = data.Pageid.ToString();;
socioprofile.ProfileStatus = 1;
socioprofile.ProfileDate = DateTime.Now;
socioprofile.Id = Guid.NewGuid();
#endregion
#region TeamMemberProfile
//Domain.Socioboard.Domain.Team objTeam = objTeamRepository.GetTeamByGroupId(Guid.Parse(GroupId));
//objTeamMemberProfile = new Domain.Socioboard.Domain.TeamMemberProfile();
//objTeamMemberProfile.Id = Guid.NewGuid();
//objTeamMemberProfile.TeamId = objTeam.Id;
//objTeamMemberProfile.Status = 1;
//objTeamMemberProfile.ProfileType = "linkedincompanypage";
//objTeamMemberProfile.StatusUpdateDate = DateTime.Now;
//objTeamMemberProfile.ProfileId = socioprofile.ProfileId;
grpProfile.Id = Guid.NewGuid();
grpProfile.GroupId = Guid.Parse(GroupId);
grpProfile.GroupOwnerId = objLinkedincmpnypage.UserId;
grpProfile.ProfileId = objLinkedincmpnypage.LinkedinPageId;
grpProfile.ProfileType = "linkedincompanypage";
grpProfile.ProfileName = objLinkedincmpnypage.LinkedinPageName;
grpProfile.EntryDate = DateTime.UtcNow;
#endregion
}
catch
{
}
try
{
if (!objSocialProfilesRepository.checkUserProfileExist(socioprofile))
{
objSocialProfilesRepository.addNewProfileForUser(socioprofile);
grpProfileRepo.AddGroupProfile(grpProfile);
}
if (!string.IsNullOrEmpty(GroupId))
{
if (!objTeamMemberProfileRepository.checkTeamMemberProfile(objTeamMemberProfile.TeamId, objLinkedincmpnypage.LinkedinPageId))
{
objTeamMemberProfileRepository.addNewTeamMember(objTeamMemberProfile);
}
}
if (!objLinkedCmpnyPgeRepo.checkLinkedinPageExists(CompanyPageId, Guid.Parse(UserId)))
{
objLinkedCmpnyPgeRepo.addLinkenCompanyPage(objLinkedincmpnypage);
}
else
{
objLinkedincmpnypage.LinkedinPageId = CompanyPageId;
objLinkedCmpnyPgeRepo.updateLinkedinPage(objLinkedincmpnypage);
}
}
catch
{
}
}
private static void RunDataService()
{
SocialProfilesRepository objSocioRepo = new SocialProfilesRepository();
while (true)
{
ThreadPool.SetMaxThreads(10, 4);
List <SocialProfile> lstUser = objSocioRepo.getAllSocialProfiles();
if (lstUser != null)
{
if (lstUser.Count != 0)
{
foreach (var item in lstUser)
{
clsSocialSiteDataFeedsFactory objclsSocialSiteDataFeedsFactory = new clsSocialSiteDataFeedsFactory(item.ProfileType);
SocialSiteDataFeeds objSocialSiteDataFeeds = objclsSocialSiteDataFeedsFactory.CreateSocialSiteDataFeedsInstance();
objSocialSiteDataFeeds.GetData((object)item.UserId);
//switch (item.ProfileType)
//{
// case "twitter":
// try
// {
// TwitterData objTwitter = new TwitterData();
// ThreadPool.QueueUserWorkItem(new WaitCallback(objTwitter.getTwitterData), (object)item.UserId);
// //// objTwitter.getTwitterData((object)item.UserId);
// // SocialSiteDataFeeds sc = new TwitterData();
// // sc.GetData((object)item.UserId);
// }
// catch (Exception err)
// {
// Console.Write(err.StackTrace);
// }
// break;
// case "facebook":
// try
// {
// FacebookData objFacebook = new FacebookData();
// ThreadPool.QueueUserWorkItem(new WaitCallback(objFacebook.GetFacebookData), (object)item.UserId);
// //objFacebook.GetFacebookData((object)item.UserId);
// }
// catch (Exception err)
// {
// Console.Write(err.StackTrace);
// }
// break;
// case "linkedin":
// try
// {
// LinkedInData objLi = new LinkedInData();
// ThreadPool.QueueUserWorkItem(new WaitCallback(objLi.GetLinkedIndata), (object)item.UserId);
// //objLi.GetLinkedIndata((object)item.UserId);
// }
// catch (Exception err)
// {
// Console.Write(err.StackTrace);
// }
// break;
// case "instagram": try
// {
// InstagramData objIns = new InstagramData();
// ThreadPool.QueueUserWorkItem(new WaitCallback(objIns.getIntagramImages), (object)item.UserId);
// }
// catch (Exception err)
// {
// Console.Write(err.StackTrace);
// }
// break;
// case "googleanalytics1": try
// {
// GoogleAnalyticsData gaData = new GoogleAnalyticsData();
// ThreadPool.QueueUserWorkItem(new WaitCallback(gaData.getAnalytics), (object)item.UserId);
// }
// catch (Exception ex)
// {
// Console.WriteLine(ex.StackTrace);
// }
// break;
// case "googleplus1": try
// {
// GplusData gpData = new GplusData();
// ThreadPool.QueueUserWorkItem(new WaitCallback(gpData.getGplusData), (object)item.UserId);
// }
// catch (Exception ex)
// {
// Console.WriteLine(ex.StackTrace);
// }
// break;
// case "tumblr": try
// {
// TumblrData tumblrData = new TumblrData();
// //try
// //{
// // using (MySql.Data.MySqlClient.MySqlConnection con = new MySql.Data.MySqlClient.MySqlConnection("Data Source=localhost;User ID= root;Password=abhay;persist security info=False;initial catalog=abhay3;pooling=false;charset=utf8;"))
// // {
// // con.Open();
// // using (MySql.Data.MySqlClient.MySqlDataAdapter da = new MySql.Data.MySqlClient.MySqlDataAdapter("Select * from TumblrAccount where UserId='" + item.UserId + "'", con))
// // {
// // System.Data.DataSet ds = new System.Data.DataSet();
// // da.Fill(ds);
// // }
// // }
// //}
// //catch (Exception ex)
// //{
// // Console.WriteLine("Error : " + ex.StackTrace);
// //}
// //ThreadPool.QueueUserWorkItem(new WaitCallback(tumblrData.GetData), (object)item.UserId);
// tumblrData.GetData((object)item.UserId);
// }
// catch (Exception ex)
// {
// Console.WriteLine(ex.StackTrace);
// }
// break;
//}
}
}
else
{
Console.WriteLine("No active record in Database");
}
}
else
{
Console.WriteLine("No active record in Database");
}
Thread.Sleep(1000 * 60 * 15);
}
}
