public static Domain.Socioboard.Models.LinkedinCompanyPage getLinkedinCompanyPage(string LICompanyPageUserId, Helper.Cache _redisCache, Model.DatabaseRepository dbr)
{
try
{
Domain.Socioboard.Models.LinkedinCompanyPage inMemLiAcc = _redisCache.Get <Domain.Socioboard.Models.LinkedinCompanyPage>(Domain.Socioboard.Consatants.SocioboardConsts.CacheLinkedInCompanyPage + LICompanyPageUserId);
if (inMemLiAcc != null)
{
return(inMemLiAcc);
}
}
catch { }
try
{
List <Domain.Socioboard.Models.LinkedinCompanyPage> lstLiAcc = dbr.Find <Domain.Socioboard.Models.LinkedinCompanyPage>(t => t.LinkedinPageId.Equals(LICompanyPageUserId) && t.IsActive).ToList();
if (lstLiAcc != null)
{
_redisCache.Set(Domain.Socioboard.Consatants.SocioboardConsts.CacheLinkedInCompanyPage + LICompanyPageUserId, lstLiAcc.First());
return(lstLiAcc.First());
}
else
{
return(null);
}
}
catch (Exception ex)
{
return(null);
}
}
public static string DeleteCompanyPageProfile(Model.DatabaseRepository dbr, string profileId, long userId, Helper.Cache _redisCache, Helper.AppSettings _appSettings)
{
Domain.Socioboard.Models.LinkedinCompanyPage fbAcc = dbr.Find <Domain.Socioboard.Models.LinkedinCompanyPage>(t => t.LinkedinPageId.Equals(profileId) && t.UserId == userId && t.IsActive).FirstOrDefault();
if (fbAcc != null)
{
fbAcc.IsActive = false;
dbr.Update <Domain.Socioboard.Models.LinkedinCompanyPage>(fbAcc);
_redisCache.Delete(Domain.Socioboard.Consatants.SocioboardConsts.CacheLinkedInCompanyPage + profileId);
return("Deleted");
}
else
{
return("Account Not Exist");
}
}
public void ScheduleLinkedInCompanyPageMessage()
{
while (true)
{
try
{
DatabaseRepository dbr = new DatabaseRepository();
List <Domain.Socioboard.Models.ScheduledMessage> lstScheduledMessage = dbr.Find <Domain.Socioboard.Models.ScheduledMessage>(t => t.profileType == Domain.Socioboard.Enum.SocialProfileType.LinkedInComapanyPage && t.status == Domain.Socioboard.Enum.ScheduleStatus.Pending).ToList();
var newlstScheduledMessage = lstScheduledMessage.GroupBy(t => t.profileId).ToList();
foreach (var items in newlstScheduledMessage)
{
try
{
Domain.Socioboard.Models.LinkedinCompanyPage _LinkedinCompanyPage = dbr.Find <Domain.Socioboard.Models.LinkedinCompanyPage>(t => t.LinkedinPageId == items.Key && t.IsActive).FirstOrDefault();
Domain.Socioboard.Models.User _user = dbr.Single <Domain.Socioboard.Models.User>(t => t.Id == _LinkedinCompanyPage.UserId);
if (_LinkedinCompanyPage != null)
{
foreach (var item in lstScheduledMessage)
{
try
{
Console.WriteLine(item.socialprofileName + "Scheduling Started");
LinkedInCompanyPageScheduler.PostLinkedInCompanyPageMessage(item, _LinkedinCompanyPage, _user);
Console.WriteLine(item.socialprofileName + "Scheduling");
}
catch (Exception)
{
}
}
_LinkedinCompanyPage.SchedulerUpdate = DateTime.UtcNow;
dbr.Update <Domain.Socioboard.Models.LinkedinCompanyPage>(_LinkedinCompanyPage);
Thread.Sleep(60000);
}
}
catch (Exception)
{
Thread.Sleep(60000);
}
}
}
catch (Exception ex)
{
Console.WriteLine("issue in web api calling" + ex.StackTrace);
Thread.Sleep(60000);
}
}
}
public static int UpdateLinkedInComanyPageFeed(Domain.Socioboard.Models.LinkedinCompanyPage linacc, oAuthLinkedIn _oauth)
{
DatabaseRepository dbr = new DatabaseRepository();
Domain.Socioboard.Models.Groupprofiles _grpProfile = dbr.Single <Domain.Socioboard.Models.Groupprofiles>(t => t.profileId.Contains(linacc.LinkedinPageId));
apiHitsCount = 0;
if (linacc.lastUpdate.AddHours(1) <= DateTime.UtcNow)
{
if (linacc.IsActive)
{
dynamic profile = GetCompanyPageData(_oauth, linacc.LinkedinPageId);
try
{
string NuberOfFollower = profile.num_followers.ToString();
linacc.NumFollowers = Convert.ToInt16(NuberOfFollower);
}
catch {
linacc.NumFollowers = linacc.NumFollowers;
}
try
{
linacc.CompanyType = profile.company_type.ToString();
}
catch {
linacc.CompanyType = linacc.CompanyType;
}
try
{
linacc.LogoUrl = profile.logo_url.ToString();
_grpProfile.profilePic = profile.logo_url.ToString();
}
catch {
linacc.LogoUrl = linacc.LogoUrl;
_grpProfile.profilePic = linacc.LogoUrl;
}
try
{
linacc.SquareLogoUrl = profile.square_logo_url.ToString();
}
catch {
linacc.SquareLogoUrl = linacc.SquareLogoUrl;
}
try
{
linacc.BlogRssUrl = profile.blog_rss_url.ToString();
}
catch {
linacc.BlogRssUrl = linacc.BlogRssUrl;
}
try
{
linacc.UniversalName = profile.universal_name.ToString();
}
catch {
linacc.UniversalName = linacc.UniversalName;
}
dbr.Update <Domain.Socioboard.Models.LinkedinCompanyPage>(linacc);
try
{
List <LinkedinPageUpdate.CompanyPagePosts> objcompanypagepost = objLinkedinPageUpdate.GetPagePosts(_oauth, linacc.LinkedinPageId);
if (apiHitsCount < MaxapiHitsCount && objcompanypagepost != null)
{
apiHitsCount++;
LinkedinCompanyPagePosts lipagepost = new LinkedinCompanyPagePosts();
if (objcompanypagepost != null)
{
foreach (var item in objcompanypagepost)
{
lipagepost.Id = ObjectId.GenerateNewId();
lipagepost.strId = ObjectId.GenerateNewId().ToString();
lipagepost.Posts = item.Posts;
lipagepost.PostDate = Convert.ToDateTime(item.PostDate).ToString("yyyy/MM/dd HH:mm:ss");
lipagepost.EntryDate = DateTime.UtcNow.ToString("yyyy/MM/dd HH:mm:ss");
lipagepost.UserId = linacc.UserId;
lipagepost.Type = item.Type;
lipagepost.PostId = item.PostId;
lipagepost.UpdateKey = item.UpdateKey;
lipagepost.PageId = linacc.LinkedinPageId;
lipagepost.PostImageUrl = item.PostImageUrl;
lipagepost.Likes = item.Likes;
lipagepost.Comments = item.Comments;
MongoRepository _CompanyPagePostsRepository = new MongoRepository("LinkedinCompanyPagePosts");
var ret = _CompanyPagePostsRepository.Find <Domain.Socioboard.Models.Mongo.LinkedinCompanyPagePosts>(t => t.PostId == lipagepost.PostId);
var task = Task.Run(async() =>
{
return(await ret);
});
int count = task.Result.Count;
if (count < 1)
{
_CompanyPagePostsRepository.Add(lipagepost);
}
}
}
else
{
apiHitsCount = MaxapiHitsCount;
}
}
}
catch (Exception)
{
}
linacc.lastUpdate = DateTime.UtcNow;
dbr.Update <Domain.Socioboard.Models.LinkedinCompanyPage>(linacc);
}
}
else
{
apiHitsCount = 0;
}
return(0);
}
public static int AddLinkedInCompantPage(oAuthLinkedIn _oauth, dynamic profile, Model.DatabaseRepository dbr, Int64 userId, Int64 groupId, string accesstoken, Helper.Cache _redisCache, Helper.AppSettings _appSettings, ILogger _logger)
{
int isSaved = 0;
Domain.Socioboard.Models.LinkedinCompanyPage _LinkedInAccount = Repositories.LinkedInAccountRepository.getLinkedinCompanyPage(profile.Pageid.ToString(), _redisCache, dbr);
if (_LinkedInAccount != null && _LinkedInAccount.IsActive == false)
{
_LinkedInAccount.IsActive = true;
_LinkedInAccount.UserId = userId;
_LinkedInAccount.EmailDomains = profile.EmailDomains.ToString();
_LinkedInAccount.OAuthToken = accesstoken;
_LinkedInAccount.LinkedinPageName = profile.name.ToString();
_LinkedInAccount.lastUpdate = DateTime.UtcNow;
try
{
string NuberOfFollower = profile.num_followers.ToString();
_LinkedInAccount.NumFollowers = Convert.ToInt16(NuberOfFollower);
}
catch { }
try
{
_LinkedInAccount.CompanyType = profile.company_type.ToString();
}
catch { }
try
{
_LinkedInAccount.LogoUrl = profile.logo_url.ToString();
}
catch { }
try
{
_LinkedInAccount.SquareLogoUrl = profile.square_logo_url.ToString();
}
catch { }
try
{
_LinkedInAccount.BlogRssUrl = profile.blog_rss_url.ToString();
}
catch { }
try
{
_LinkedInAccount.UniversalName = profile.universal_name.ToString();
}
catch { }
isSaved = dbr.Update <Domain.Socioboard.Models.LinkedinCompanyPage>(_LinkedInAccount);
}
else
{
_LinkedInAccount = new Domain.Socioboard.Models.LinkedinCompanyPage();
_LinkedInAccount.LinkedinPageId = profile.Pageid.ToString();
_LinkedInAccount.IsActive = true;
_LinkedInAccount.UserId = userId;
_LinkedInAccount.lastUpdate = DateTime.UtcNow;
try
{
_LinkedInAccount.EmailDomains = profile.EmailDomains.ToString();
}
catch (Exception ex)
{
}
_LinkedInAccount.LinkedinPageName = profile.name.ToString();
_LinkedInAccount.OAuthToken = _oauth.Token;
_LinkedInAccount.OAuthSecret = _oauth.TokenSecret;
_LinkedInAccount.OAuthVerifier = _oauth.Verifier;
try
{
_LinkedInAccount.Description = profile.description.ToString();
}
catch { }
try
{
_LinkedInAccount.FoundedYear = profile.founded_year.ToString();
}
catch { }
try
{
_LinkedInAccount.EndYear = profile.end_year.ToString();
}
catch { }
try
{
_LinkedInAccount.Locations = profile.locations.ToString();
}
catch { }
try
{
_LinkedInAccount.Specialties = profile.Specialties.ToString();
}
catch { }
try
{
_LinkedInAccount.WebsiteUrl = profile.website_url.ToString();
}
catch { }
try
{
_LinkedInAccount.Status = profile.status.ToString();
}
catch { }
try
{
_LinkedInAccount.EmployeeCountRange = profile.employee_count_range.ToString();
}
catch { }
try
{
_LinkedInAccount.Industries = profile.industries.ToString();
}
catch { }
try
{
string NuberOfFollower = profile.num_followers.ToString();
_LinkedInAccount.NumFollowers = Convert.ToInt16(NuberOfFollower);
}
catch { }
try
{
_LinkedInAccount.CompanyType = profile.company_type.ToString();
}
catch { }
try
{
_LinkedInAccount.LogoUrl = profile.logo_url.ToString();
}
catch { }
try
{
_LinkedInAccount.SquareLogoUrl = profile.square_logo_url.ToString();
}
catch { }
try
{
_LinkedInAccount.BlogRssUrl = profile.blog_rss_url.ToString();
}
catch { }
try
{
_LinkedInAccount.UniversalName = profile.universal_name.ToString();
}
catch { }
isSaved = dbr.Add <Domain.Socioboard.Models.LinkedinCompanyPage>(_LinkedInAccount);
if (isSaved == 1)
{
List <Domain.Socioboard.Models.LinkedinCompanyPage> lstliAcc = dbr.Find <Domain.Socioboard.Models.LinkedinCompanyPage>(t => t.LinkedinPageId.Equals(_LinkedInAccount.LinkedinPageId)).ToList();
if (lstliAcc != null && lstliAcc.Count() > 0)
{
isSaved = GroupProfilesRepository.AddGroupProfile(groupId, lstliAcc.First().LinkedinPageId, lstliAcc.First().LinkedinPageName, userId, lstliAcc.First().LogoUrl, Domain.Socioboard.Enum.SocialProfileType.LinkedInComapanyPage, dbr);
if (isSaved == 1)
{
_redisCache.Delete(Domain.Socioboard.Consatants.SocioboardConsts.CacheUserProfileCount + userId);
_redisCache.Delete(Domain.Socioboard.Consatants.SocioboardConsts.CacheGroupProfiles + groupId);
new Thread(delegate()
{
LinkedInAccountRepository.SaveLinkedInCompanyPageFeed(_oauth, lstliAcc.First().LinkedinPageId, lstliAcc.First().UserId, _appSettings);
}).Start();
}
}
}
}
return(isSaved);
}
public IActionResult AddProfileToGroup(string profileId, long groupId, long userId, Domain.Socioboard.Enum.SocialProfileType profileType)
{
DatabaseRepository dbr = new DatabaseRepository(_logger, _appEnv);
List <Domain.Socioboard.Models.Groupprofiles> lstGroupProfiles = GroupProfilesRepository.getGroupProfiles(groupId, _redisCache, dbr);
if (lstGroupProfiles.Where(t => t.profileId.Equals(profileId)).Count() > 0)
{
return(BadRequest("profile already added"));
}
else
{
Domain.Socioboard.Models.Groups grp = dbr.Find <Domain.Socioboard.Models.Groups>(t => t.id == groupId).FirstOrDefault();
if (grp == null)
{
return(BadRequest("Invalid groupId"));
}
else
{
Domain.Socioboard.Models.Groupprofiles grpProfile = new Domain.Socioboard.Models.Groupprofiles();
if (profileType == Domain.Socioboard.Enum.SocialProfileType.Facebook || profileType == Domain.Socioboard.Enum.SocialProfileType.FacebookFanPage || profileType == Domain.Socioboard.Enum.SocialProfileType.FacebookPublicPage)
{
Domain.Socioboard.Models.Facebookaccounts fbAcc = Repositories.FacebookRepository.getFacebookAccount(profileId, _redisCache, dbr);
if (fbAcc == null)
{
return(BadRequest("Invalid profileId"));
}
if (fbAcc.UserId != userId)
{
return(BadRequest("profile is added by other user"));
}
grpProfile.profileName = fbAcc.FbUserName;
grpProfile.profileOwnerId = userId;
grpProfile.profilePic = "http://graph.facebook.com/" + fbAcc.FbUserId + "/picture?type=small";
grpProfile.profileType = profileType;
}
else if (profileType == Domain.Socioboard.Enum.SocialProfileType.Twitter)
{
Domain.Socioboard.Models.TwitterAccount twtAcc = Repositories.TwitterRepository.getTwitterAccount(profileId, _redisCache, dbr);
if (twtAcc == null)
{
return(BadRequest("Invalid profileId"));
}
if (twtAcc.userId != userId)
{
return(BadRequest("profile is added by other user"));
}
grpProfile.profileName = twtAcc.twitterScreenName;
grpProfile.profileOwnerId = userId;
grpProfile.profilePic = twtAcc.profileImageUrl;
grpProfile.profileType = Domain.Socioboard.Enum.SocialProfileType.Twitter;
}
else if (profileType == Domain.Socioboard.Enum.SocialProfileType.GPlus)
{
Domain.Socioboard.Models.Googleplusaccounts gplusAccount = Repositories.GplusRepository.getGPlusAccount(profileId, _redisCache, dbr);
if (gplusAccount == null)
{
return(BadRequest("Invalid ProfileId"));
}
if (gplusAccount.UserId != userId)
{
return(BadRequest("profile is added by other user"));
}
grpProfile.profileName = gplusAccount.GpUserName;
grpProfile.profileOwnerId = userId;
grpProfile.profilePic = gplusAccount.GpProfileImage;
}
else if (profileType == Domain.Socioboard.Enum.SocialProfileType.Instagram)
{
Domain.Socioboard.Models.Instagramaccounts _Instagramaccounts = Repositories.InstagramRepository.getInstagramAccount(profileId, _redisCache, dbr);
if (_Instagramaccounts == null)
{
return(BadRequest("Invalid ProfileId"));
}
if (_Instagramaccounts.UserId != userId)
{
return(BadRequest("profile is added by other user"));
}
grpProfile.profileName = _Instagramaccounts.InsUserName;
grpProfile.profileOwnerId = userId;
grpProfile.profilePic = _Instagramaccounts.ProfileUrl;
}
else if (profileType == Domain.Socioboard.Enum.SocialProfileType.LinkedIn)
{
Domain.Socioboard.Models.LinkedInAccount _LinkedInAccount = Repositories.LinkedInAccountRepository.getLinkedInAccount(profileId, _redisCache, dbr);
if (_LinkedInAccount == null)
{
return(BadRequest("Invalid ProfileId"));
}
if (_LinkedInAccount.UserId != userId)
{
return(BadRequest("profile is added by other user"));
}
grpProfile.profileName = _LinkedInAccount.LinkedinUserName;
grpProfile.profileOwnerId = userId;
grpProfile.profilePic = _LinkedInAccount.ProfileImageUrl;
}
else if (profileType == Domain.Socioboard.Enum.SocialProfileType.LinkedInComapanyPage)
{
Domain.Socioboard.Models.LinkedinCompanyPage _LinkedInAccount = Repositories.LinkedInAccountRepository.getLinkedinCompanyPage(profileId, _redisCache, dbr);
if (_LinkedInAccount == null)
{
return(BadRequest("Invalid ProfileId"));
}
if (_LinkedInAccount.UserId != userId)
{
return(BadRequest("profile is added by other user"));
}
grpProfile.profileName = _LinkedInAccount.LinkedinPageName;
grpProfile.profileOwnerId = userId;
grpProfile.profilePic = _LinkedInAccount.LogoUrl;
}
grpProfile.entryDate = DateTime.UtcNow;
grpProfile.groupId = grp.id;
grpProfile.profileId = profileId;
grpProfile.profileType = profileType;
dbr.Add <Domain.Socioboard.Models.Groupprofiles>(grpProfile);
//codes to clear cache
_redisCache.Delete(Domain.Socioboard.Consatants.SocioboardConsts.CacheGroupProfiles + groupId);
//end codes to clear cache
return(Ok("Added Successfully"));
}
}
}
