public static string ComposeLinkedInMessage(string ImageUrl, long userid, string comment, string ProfileId, string imagepath, Domain.Socioboard.Models.LinkedInAccount _objLinkedInAccount, Model.DatabaseRepository dbr, Domain.Socioboard.Models.User _user)
{
string json = "";
var img = "";
Domain.Socioboard.Models.LinkedInAccount _LinkedInAccount = _objLinkedInAccount;
oAuthLinkedIn _oauth = new oAuthLinkedIn();
_oauth.ConsumerKey = AppSettings.LinkedinConsumerKey;
_oauth.ConsumerSecret = AppSettings.LinkedinConsumerSecret;
_oauth.Token = _LinkedInAccount.OAuthToken;
string PostUrl = "https://api.linkedin.com/v1/people/~/shares?format=json";
if (string.IsNullOrEmpty(ImageUrl))
{
json = _oauth.LinkedProfilePostWebRequest("POST", PostUrl, comment);
}
else
{
json = _oauth.LinkedProfilePostWebRequestWithImage("POST", PostUrl, comment, ImageUrl);
}
if (!string.IsNullOrEmpty(json))
{
string msg = "feed shared successfully";
return(msg);
}
else
{
string msg = "feed has not posted";
return(msg);
}
}
public static Domain.Socioboard.Models.LinkedInAccount getLinkedInAccount(string LIUserId, Helper.Cache _redisCache, Model.DatabaseRepository dbr)
{
try
{
Domain.Socioboard.Models.LinkedInAccount inMemLiAcc = _redisCache.Get <Domain.Socioboard.Models.LinkedInAccount>(Domain.Socioboard.Consatants.SocioboardConsts.CacheLinkedInAccount + LIUserId);
if (inMemLiAcc != null)
{
return(inMemLiAcc);
}
}
catch { }
try
{
List <Domain.Socioboard.Models.LinkedInAccount> lstLiAcc = dbr.Find <Domain.Socioboard.Models.LinkedInAccount>(t => t.LinkedinUserId.Equals(LIUserId) && t.IsActive).ToList();
if (lstLiAcc != null)
{
_redisCache.Set(Domain.Socioboard.Consatants.SocioboardConsts.CacheLinkedInAccount + LIUserId, lstLiAcc.First());
return(lstLiAcc.First());
}
else
{
return(null);
}
}
catch (Exception ex)
{
return(null);
}
}
public static void UpdateLinkedIn(Domain.Socioboard.Models.LinkedInAccount linacc, oAuthLinkedIn _oauth)
{
apiHitsCount = 0;
if (linacc.LastUpdate.AddHours(1) <= DateTime.UtcNow)
{
DatabaseRepository dbr = new DatabaseRepository();
Domain.Socioboard.Models.Groupprofiles _grpProfile = dbr.Single <Domain.Socioboard.Models.Groupprofiles>(t => t.profileId.Contains(linacc.LinkedinUserId));
if (linacc.IsActive)
{
try
{
dynamic profile = getLinkedInProfile(_oauth);
try
{
linacc.Connections = Convert.ToInt32(profile.connections.ToString());
}
catch (Exception)
{
linacc.Connections = linacc.Connections;
}
try
{
linacc.EmailId = profile.email.ToString();
}
catch (Exception ex)
{
linacc.EmailId = linacc.EmailId;
}
try
{
linacc.ProfileImageUrl = profile.picture_url.ToString();
_grpProfile.profilePic = profile.picture_url.ToString();
}
catch (Exception ex)
{
linacc.ProfileImageUrl = linacc.ProfileImageUrl;
_grpProfile.profilePic = linacc.ProfileImageUrl;
}
try
{
linacc.ProfileUrl = profile.profile_url.ToString();
}
catch (Exception ex)
{
linacc.ProfileUrl = linacc.ProfileUrl;
}
linacc.LastUpdate = DateTime.UtcNow;
dbr.Update <Domain.Socioboard.Models.LinkedInAccount>(linacc);
dbr.Update <Domain.Socioboard.Models.Groupprofiles>(_grpProfile);
}
catch (Exception)
{
}
}
}
}
public static string DeleteProfile(Model.DatabaseRepository dbr, string profileId, long userId, Helper.Cache _redisCache, Helper.AppSettings _appSettings)
{
Domain.Socioboard.Models.LinkedInAccount fbAcc = dbr.Find <Domain.Socioboard.Models.LinkedInAccount>(t => t.LinkedinUserId.Equals(profileId) && t.UserId == userId && t.IsActive).FirstOrDefault();
if (fbAcc != null)
{
fbAcc.IsActive = false;
dbr.Update <Domain.Socioboard.Models.LinkedInAccount>(fbAcc);
_redisCache.Delete(Domain.Socioboard.Consatants.SocioboardConsts.CacheLinkedInAccount + profileId);
return("Deleted");
}
else
{
return("Account Not Exist");
}
}
//public static Semaphore objSemaphoreacc = new Semaphore(5, 10);
//public static Semaphore objSemaphorepage = new Semaphore(5, 10);
public void ScheduleLinkedInMessage()
{
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.LinkedIn && t.status == Domain.Socioboard.Enum.ScheduleStatus.Pending) && t.scheduleTime <= DateTime.UtcNow).ToList();
var newlstScheduledMessage = lstScheduledMessage.GroupBy(t => t.profileId).ToList();
foreach (var items in newlstScheduledMessage)
{
try
{
Domain.Socioboard.Models.LinkedInAccount _LinkedInAccount = dbr.Find <Domain.Socioboard.Models.LinkedInAccount>(t => t.LinkedinUserId == items.Key && t.IsActive).FirstOrDefault();
Domain.Socioboard.Models.User _user = dbr.Single <Domain.Socioboard.Models.User>(t => t.Id == _LinkedInAccount.UserId);
if (_LinkedInAccount != null)
{
foreach (var item in items)
{
try
{
Console.WriteLine(item.socialprofileName + "Scheduling Started");
LinkedInScheduler.PostLinkedInMessage(item, _LinkedInAccount, _user);
Console.WriteLine(item.socialprofileName + "Scheduling");
}
catch (Exception)
{
}
}
_LinkedInAccount.SchedulerUpdate = DateTime.UtcNow;
dbr.Update <Domain.Socioboard.Models.LinkedInAccount>(_LinkedInAccount);
Thread.Sleep(60000);
}
}
catch (Exception)
{
Thread.Sleep(60000);
}
}
}
catch (Exception ex)
{
Console.WriteLine("issue in web api calling" + ex.StackTrace);
Thread.Sleep(60000);
}
}
}
private static void TwitterSchedulemessage(object o)
{
try
{
MongoRepository mongorepo = new Helper.MongoRepository("ContentFeedsShareathon");
int pageapiHitsCount;
object[] arr = o as object[];
FacebookPageFeedShare shareathon = (FacebookPageFeedShare)arr[0];
Model.DatabaseRepository dbr = (Model.DatabaseRepository)arr[1];
MongoRepository _ShareathonRepository = (MongoRepository)arr[2];
string[] ids = shareathon.socialProfiles.Split(',');
foreach (string id in ids)
{
Domain.Socioboard.Models.TwitterAccount _TwitterAccount = dbr.Single <Domain.Socioboard.Models.TwitterAccount>(t => t.twitterUserId == id && t.isActive);
Domain.Socioboard.Models.LinkedInAccount _LinkedinAcc = dbr.Single <Domain.Socioboard.Models.LinkedInAccount>(t => t.LinkedinUserId == id && t.IsActive);
Domain.Socioboard.Models.User _user = dbr.Single <Domain.Socioboard.Models.User>(t => t.Id == _TwitterAccount.userId);
MongoRepository mongoshare = new Helper.MongoRepository("FacebookPageFeedShare");
if (_TwitterAccount != null || _LinkedinAcc != null)
{
var resultshare = _ShareathonRepository.Find <FacebookPageFeedShare>(t => t.pageId == shareathon.pageId && t.status != Domain.Socioboard.Enum.RealTimeShareFeedStatus.deleted);
var task = Task.Run(async() =>
{
return(await resultshare);
});
int count = task.Result.Count;
var feedsData = task.Result.ToList();
if (count != 0)
{
foreach (var item in feedsData)
{
if (item.socialmedia.StartsWith("tw"))
{
try
{
Console.WriteLine(item.socialProfiles + "Scheduling Started");
PostTwitterMessage(item, _TwitterAccount, null, _user);
Console.WriteLine(item.socialProfiles + "Scheduling");
}
catch (Exception)
{
Thread.Sleep(60000);
}
}
if (item.socialmedia.StartsWith("lin"))
{
try
{
Console.WriteLine(item.socialProfiles + "Scheduling Started");
PostTwitterMessage(item, null, _LinkedinAcc, _user);
Console.WriteLine(item.socialProfiles + "Scheduling");
}
catch (Exception)
{
Thread.Sleep(60000);
}
}
}
//fbAcc.contenetShareathonUpdate = DateTime.UtcNow;
//facebookPage.contenetShareathonUpdate = DateTime.UtcNow;
//dbr.Update<Domain.Socioboard.Models.Facebookaccounts>(fbAcc);
//dbr.Update<Domain.Socioboard.Models.Facebookaccounts>(facebookPage);
}
//_TwitterAccount.SchedulerUpdate = DateTime.UtcNow;
// dbr.Update<Domain.Socioboard.Models.TwitterAccount>(_TwitterAccount);
}
}
}
catch (Exception ex)
{
Thread.Sleep(60000);
}
finally
{
noOfthreadRunning--;
objSemaphore.Release();
Console.WriteLine(Thread.CurrentThread.Name + " Is Released");
}
}
public static void PostTwitterMessage(Domain.Socioboard.Models.Mongo.FacebookPageFeedShare fbPagefeedshare, Domain.Socioboard.Models.TwitterAccount _TwitterAccount, Domain.Socioboard.Models.LinkedInAccount _LinkedinAcc, Domain.Socioboard.Models.User _user)
{
try
{
DatabaseRepository dbr = new DatabaseRepository();
MongoRepository _mongofbpostdata = new Helper.MongoRepository("MongoFacebookFeed");
MongoRepository mongofacebooksharedata = new Helper.MongoRepository("FacebookPageFeedShare");
var result = _mongofbpostdata.Find <Domain.Socioboard.Models.Mongo.MongoFacebookFeed>(t => t.ProfileId == fbPagefeedshare.pageId && t.shareStatus == false);
var task = Task.Run(async() =>
{
return(await result);
});
IList <Domain.Socioboard.Models.Mongo.MongoFacebookFeed> lstfbpagefeeds = task.Result.ToList();
foreach (var item in lstfbpagefeeds)
{
string twitterdata = null;
string linkedindata = null;
try
{
if (fbPagefeedshare.scheduleTime <= DateTime.UtcNow)
{
if (_TwitterAccount != null)
{
twitterdata = ComposeTwitterMessage(item.FeedDescription, item.ProfileId, fbPagefeedshare.userId, item.Picture, false, dbr, _TwitterAccount, _user);
}
else
{
linkedindata = ComposeLinkedInMessage(item.Picture, fbPagefeedshare.userId, item.FeedDescription, item.ProfileId, "", _LinkedinAcc, dbr, _user);
}
if (!string.IsNullOrEmpty(twitterdata) && twitterdata != "feed has not posted" || !string.IsNullOrEmpty(linkedindata) && linkedindata != "feed has not posted")
{
apiHitsCount++;
item.shareStatus = true;
fbPagefeedshare.lastsharestamp = DateTime.UtcNow;
FilterDefinition <BsonDocument> filter = new BsonDocument("FeedId", item.FeedId);
var updatemongo = Builders <BsonDocument> .Update.Set("shareStatus", true);
_mongofbpostdata.Update <MongoFacebookFeed>(updatemongo, filter);
}
else if (twitterdata == "Message not posted")
{
}
}
}
catch (Exception ex)
{
}
}
FilterDefinition <BsonDocument> filters = new BsonDocument("strId", fbPagefeedshare.strId); //new BsonDocument("FeedId", item.FeedId);
var updatefbshare = Builders <BsonDocument> .Update.Set("status", Domain.Socioboard.Enum.RealTimeShareFeedStatus.running).Set("scheduleTime", DateTime.UtcNow);
mongofacebooksharedata.Update <FacebookPageFeedShare>(updatefbshare, filters);
}
catch (Exception ex)
{
apiHitsCount = MaxapiHitsCount;
}
}
public static int AddLinkedInAccount(oAuthLinkedIn _oauth, dynamic profile, Model.DatabaseRepository dbr, Int64 userId, Int64 groupId, string accessToken, Helper.Cache _redisCache, Helper.AppSettings settings, ILogger _logger)
{
int isSaved = 0;
Domain.Socioboard.Models.LinkedInAccount _LinkedInAccount = Repositories.LinkedInAccountRepository.getLinkedInAccount(profile.id.ToString(), _redisCache, dbr);
if (_LinkedInAccount != null && _LinkedInAccount.IsActive == false)
{
_LinkedInAccount.IsActive = true;
_LinkedInAccount.UserId = userId;
_LinkedInAccount.EmailId = profile.email.ToString();
_LinkedInAccount.OAuthToken = accessToken;
_LinkedInAccount.Connections = Convert.ToInt32(profile.connections.ToString());
_LinkedInAccount.LastUpdate = DateTime.UtcNow;
isSaved = dbr.Update <Domain.Socioboard.Models.LinkedInAccount>(_LinkedInAccount);
}
else
{
_LinkedInAccount = new Domain.Socioboard.Models.LinkedInAccount();
_LinkedInAccount.LinkedinUserId = profile.id.ToString();
_LinkedInAccount.IsActive = true;
_LinkedInAccount.UserId = userId;
_LinkedInAccount.Connections = Convert.ToInt32(profile.connections.ToString());
_LinkedInAccount.LastUpdate = DateTime.UtcNow;
try
{
_LinkedInAccount.EmailId = profile.email.ToString();
}
catch (Exception ex)
{
}
_LinkedInAccount.LinkedinUserName = profile.first_name.ToString() + profile.last_name.ToString();
_LinkedInAccount.OAuthToken = _oauth.Token;
_LinkedInAccount.OAuthSecret = _oauth.TokenSecret;
_LinkedInAccount.OAuthVerifier = _oauth.Verifier;
try
{
_LinkedInAccount.ProfileImageUrl = profile.picture_url.ToString();
}
catch (Exception ex)
{
}
try
{
_LinkedInAccount.ProfileUrl = profile.profile_url.ToString();
}
catch (Exception ex)
{
}
isSaved = dbr.Add <Domain.Socioboard.Models.LinkedInAccount>(_LinkedInAccount);
if (isSaved == 1)
{
List <Domain.Socioboard.Models.LinkedInAccount> lstliAcc = dbr.Find <Domain.Socioboard.Models.LinkedInAccount>(t => t.LinkedinUserId.Equals(_LinkedInAccount.LinkedinUserId)).ToList();
if (lstliAcc != null && lstliAcc.Count() > 0)
{
isSaved = GroupProfilesRepository.AddGroupProfile(groupId, lstliAcc.First().LinkedinUserId, lstliAcc.First().LinkedinUserName, userId, lstliAcc.First().ProfileImageUrl, Domain.Socioboard.Enum.SocialProfileType.LinkedIn, dbr);
if (isSaved == 1)
{
_redisCache.Delete(Domain.Socioboard.Consatants.SocioboardConsts.CacheUserProfileCount + userId);
_redisCache.Delete(Domain.Socioboard.Consatants.SocioboardConsts.CacheGroupProfiles + groupId);
}
}
}
}
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"));
}
}
}
