public static List <Domain.Socioboard.Models.ScheduledMessage> DeleteSocialMessages(long socioqueueId, long userId, long GroupId, Helper.Cache _redisCache, Helper.AppSettings _appSeetings, Model.DatabaseRepository dbr)
{
string[] profileids = null;
Domain.Socioboard.Models.ScheduledMessage ScheduledMessage = dbr.Find <Domain.Socioboard.Models.ScheduledMessage>(t => t.id == socioqueueId).FirstOrDefault();
ScheduledMessage.status = Domain.Socioboard.Enum.ScheduleStatus.Deleted;
dbr.Update <Domain.Socioboard.Models.ScheduledMessage>(ScheduledMessage);
List <Domain.Socioboard.Models.Groupprofiles> iMmemGroupprofiles = _redisCache.Get <List <Domain.Socioboard.Models.Groupprofiles> >(Domain.Socioboard.Consatants.SocioboardConsts.CacheGroupProfiles + GroupId);
List <Domain.Socioboard.Models.Groupprofiles> lstGroupprofiles = new List <Groupprofiles>();
if (iMmemGroupprofiles != null && iMmemGroupprofiles.Count > 0)
{
lstGroupprofiles = iMmemGroupprofiles;
}
else
{
lstGroupprofiles = dbr.Find <Domain.Socioboard.Models.Groupprofiles>(t => t.groupId == GroupId).ToList();
_redisCache.Set(Domain.Socioboard.Consatants.SocioboardConsts.CacheGroupProfiles + GroupId, lstGroupprofiles);
}
profileids = lstGroupprofiles.Select(t => t.profileId).ToArray();
List <Domain.Socioboard.Models.ScheduledMessage> lstScheduledMessage = dbr.Find <Domain.Socioboard.Models.ScheduledMessage>(t => profileids.Contains(t.profileId) && t.status == 0).ToList();
if (lstScheduledMessage != null && lstScheduledMessage.Count > 0)
{
_redisCache.Set(Domain.Socioboard.Consatants.SocioboardConsts.CacheScheduleMessage + GroupId, lstScheduledMessage);
return(lstScheduledMessage);
}
else
{
return(null);
}
}
public IActionResult GetUserGroupData(long userId, string groupId)
{
DatabaseRepository dbr = new Model.DatabaseRepository(_logger, _appEnv);
Domain.Socioboard.Models.GetUserGroupData _GetUserGroupData = new Domain.Socioboard.Models.GetUserGroupData();
List <Domain.Socioboard.Models.Groups> lstgroup = new List <Groups>();
List <Domain.Socioboard.Models.Groupmembers> lstgrpmember = new List <Groupmembers>();
lstgrpmember = dbr.Find <Groupmembers>(t => t.userId == userId && t.memberStatus == Domain.Socioboard.Enum.GroupMemberStatus.Accepted).ToList();
long[] lstgrpId = lstgrpmember.Select(t => t.groupid).ToArray();
lstgroup = dbr.Find <Domain.Socioboard.Models.Groups>(t => lstgrpId.Contains(t.id)).ToList();
List <Domain.Socioboard.Models.Groupprofiles> lstgrpProfiles = new List <Groupprofiles>();
if (string.IsNullOrEmpty(groupId))
{
long[] lstStr = lstgroup.Select(t => t.id).ToArray();
lstgrpProfiles = dbr.Find <Domain.Socioboard.Models.Groupprofiles>(t => lstStr.Contains(t.groupId)).ToList();
}
else
{
lstgrpProfiles = dbr.Find <Domain.Socioboard.Models.Groupprofiles>(t => t.groupId == Convert.ToInt32(groupId)).ToList();
}
Dictionary <long, List <Groupprofiles> > myProfiles = lstgrpProfiles.GroupBy(o => o.groupId).ToDictionary(g => g.Key, g => g.ToList());
_GetUserGroupData.lstgroup = lstgroup;
_GetUserGroupData.myProfiles = myProfiles;
return(Ok(_GetUserGroupData));
}
public static IList <Domain.Socioboard.Models.Groupprofiles> GetYtGroupChannel(Int64 userId, Helper.AppSettings settings, ILogger _logger, Model.DatabaseRepository dbr)
{
IList <Domain.Socioboard.Models.YoutubeGroupInvite> _lstMembers = dbr.Find <Domain.Socioboard.Models.YoutubeGroupInvite>(t => t.UserId == userId && t.AccessSBUserId != userId && t.Active == true);
List <Int64> userOwnerIdss = _lstMembers.Select(t => t.AccessSBUserId).ToList();
IList <Domain.Socioboard.Models.Groupprofiles> _lstchannelsss = dbr.Find <Domain.Socioboard.Models.Groupprofiles>(t => userOwnerIdss.Contains(t.profileOwnerId) && t.profileType == Domain.Socioboard.Enum.SocialProfileType.YouTube);
return(_lstchannelsss);
}
public static List <Domain.Socioboard.Models.Groupmembers> getGroupadmin(long groupId, Helper.Cache _redisCache, Model.DatabaseRepository dbr)
{
List <Domain.Socioboard.Models.Groupmembers> adminDetails = dbr.Find <Domain.Socioboard.Models.Groupmembers>(t => t.groupid == groupId && t.isAdmin).ToList();
long userID = adminDetails.First().userId;
List <Domain.Socioboard.Models.User> user = dbr.Find <Domain.Socioboard.Models.User>(t => t.Id == userID).ToList();
string Email = user.First().EmailId;
adminDetails.First().email = Email;
return(adminDetails);
}
public static List <Domain.Socioboard.ViewModels.DiscoveryViewModal> DiscoverySearchTwitter(long userId, long groupId, string keyword, Helper.Cache _redisCache, Helper.AppSettings _appSeetings, Model.DatabaseRepository dbr)
{
List <Domain.Socioboard.ViewModels.DiscoveryViewModal> iMmemDiscoveryViewModal = _redisCache.Get <List <Domain.Socioboard.ViewModels.DiscoveryViewModal> >(Domain.Socioboard.Consatants.SocioboardConsts.CacheDiscoveryTwitter + keyword);
if (iMmemDiscoveryViewModal != null && iMmemDiscoveryViewModal.Count > 0)
{
return(iMmemDiscoveryViewModal);
}
else
{
oAuthTwitter oauth = new oAuthTwitter();
Domain.Socioboard.Models.Discovery _discovery = new Domain.Socioboard.Models.Discovery();
List <Domain.Socioboard.Models.TwitterAccount> lsttwtaccount = dbr.Find <Domain.Socioboard.Models.TwitterAccount>(t => t.oAuthSecret != null).Take(20).ToList();
List <Domain.Socioboard.Models.Discovery> lstdiscovery = dbr.Find <Domain.Socioboard.Models.Discovery>(t => t.SearchKeyword.Equals(keyword) && t.userId == userId).ToList();
if (lstdiscovery.Count == 0)
{
_discovery.createTime = DateTime.UtcNow;
_discovery.GroupId = groupId;
_discovery.SearchKeyword = keyword;
_discovery.userId = userId;
dbr.Add(_discovery);
}
foreach (Domain.Socioboard.Models.TwitterAccount item in lsttwtaccount)
{
oauth.AccessToken = item.oAuthToken;
oauth.AccessTokenSecret = item.oAuthSecret;
oauth.TwitterUserId = item.twitterUserId;
oauth.TwitterScreenName = item.twitterScreenName;
SetCofigDetailsForTwitter(oauth, _appSeetings);
try
{
Users _Users = new Users();
JArray _AccountVerify = _Users.Get_Account_Verify_Credentials(oauth);
string id = (string)(_AccountVerify[0]["id_str"]);
break;
}
catch (Exception ex)
{
}
}
List <Domain.Socioboard.ViewModels.DiscoveryViewModal> lstdiscoveryDiscoveryViewModal = Helper.TwitterHelper.DiscoverySearchTwitter(oauth, keyword, userId, groupId);
if (lstdiscoveryDiscoveryViewModal.Count > 0)
{
_redisCache.Set(Domain.Socioboard.Consatants.SocioboardConsts.CacheDiscoveryTwitter + keyword, lstdiscoveryDiscoveryViewModal);
}
return(lstdiscoveryDiscoveryViewModal);
}
}
public static List <Domain.Socioboard.Models.TwitterMutualFans> twitterfans(long groupId, Model.DatabaseRepository dbr, Helper.AppSettings _appSettings)
{
string[] profileids = null;
List <Domain.Socioboard.Models.TwitterMutualFans> lstTwitterUserfans = new List <Domain.Socioboard.Models.TwitterMutualFans>();
List <Domain.Socioboard.Models.Groupprofiles> lstGroupprofiles = dbr.Find <Domain.Socioboard.Models.Groupprofiles>(t => t.groupId == groupId && t.profileType == Domain.Socioboard.Enum.SocialProfileType.Twitter).ToList();
profileids = lstGroupprofiles.Select(t => t.profileId).ToArray();
List <Domain.Socioboard.Models.TwitterAccount> lstAccRepo = dbr.Find <Domain.Socioboard.Models.TwitterAccount>(t => profileids.Contains(t.twitterUserId) && t.isActive).ToList();
oAuthTwitter oaut = null;
Users twtUser = new Users();
List <string> mutualfanlist = new List <string>();
List <string> followersId = new List <string>();
foreach (Domain.Socioboard.Models.TwitterAccount itemTwt in lstAccRepo)
{
oaut = new oAuthTwitter();
oaut.AccessToken = itemTwt.oAuthToken;
oaut.AccessTokenSecret = itemTwt.oAuthSecret;
oaut.TwitterScreenName = itemTwt.twitterScreenName;
oaut.TwitterUserId = itemTwt.twitterUserId;
oaut.ConsumerKey = _appSettings.twitterConsumerKey;
oaut.ConsumerKeySecret = _appSettings.twitterConsumerScreatKey;
JArray jarresponse = twtUser.Get_Followers_ById(oaut, itemTwt.twitterUserId);
JArray user_data = JArray.Parse(jarresponse[0]["ids"].ToString());
JArray jarrespons = twtUser.Get_Friends_ById(oaut, itemTwt.twitterUserId);
JArray user_data_2 = JArray.Parse(jarrespons[0]["ids"].ToString());
foreach (var items in user_data.Intersect(user_data_2))
{
mutualfanlist.Add(items.ToString());
}
foreach (var itemss in user_data)
{
followersId.Add(itemss.ToString());
}
List <string> fansId = followersId.Except(mutualfanlist).ToList();
foreach (var items in fansId)
{
Domain.Socioboard.Models.TwitterMutualFans objTwitterFans = new Domain.Socioboard.Models.TwitterMutualFans();
JArray userprofile = twtUser.Get_Users_LookUp(oaut, items);
foreach (var item in userprofile)
{
objTwitterFans.screen_name = item["screen_name"].ToString();
objTwitterFans.name = item["name"].ToString();
lstTwitterUserfans.Add(objTwitterFans);
}
}
}
return(lstTwitterUserfans);
}
public static List <Domain.Socioboard.Models.Draft> DeleteDraftMessage(long draftId, long userId, long GroupId, Helper.Cache _redisCache, Helper.AppSettings _appSeetings, Model.DatabaseRepository dbr)
{
Domain.Socioboard.Models.Draft _draft = dbr.Find <Domain.Socioboard.Models.Draft>(t => t.id == draftId).FirstOrDefault();
dbr.Delete <Domain.Socioboard.Models.Draft>(_draft);
List <Domain.Socioboard.Models.Draft> lstDraftMessage = dbr.Find <Domain.Socioboard.Models.Draft>(t => t.userId == userId && t.GroupId == GroupId).ToList();
if (lstDraftMessage != null && lstDraftMessage.Count > 0)
{
_redisCache.Set(Domain.Socioboard.Consatants.SocioboardConsts.CacheDraftMessage + userId, lstDraftMessage);
return(lstDraftMessage);
}
else
{
return(null);
}
}
public static void CreateFacebookPublicPageReport()
{
Helper.Cache cache = new Helper.Cache(Helper.AppSettings.RedisConfiguration);
while (true)
{
try
{
Model.DatabaseRepository dbr = new Model.DatabaseRepository();
List <Domain.Socioboard.Models.Facebookaccounts> lstFbacc = dbr.Find <Domain.Socioboard.Models.Facebookaccounts>(t => t.FbProfileType == Domain.Socioboard.Enum.FbProfileType.FacebookPublicPage && t.IsActive).ToList();
foreach (var item in lstFbacc)
{
if (item.lastpagereportgenerated.AddHours(24) <= DateTime.UtcNow)
{
CreateReport(item.FbUserId, item.Is90DayDataUpdated);
item.Is90DayDataUpdated = true;
item.lastpagereportgenerated = DateTime.UtcNow;
dbr.Update <Domain.Socioboard.Models.Facebookaccounts>(item);
}
}
}
catch (Exception ex)
{
Console.WriteLine("issue in web api calling" + ex.StackTrace);
Thread.Sleep(600000);
}
}
}
public IActionResult GetTopUserPins(string profileId, long userId, int skip, int take)
{
try
{
DatabaseRepository dbr = new Model.DatabaseRepository(_logger, _env);
UserPinData _BoardfeedData = new UserPinData();
Domain.Socioboard.Models.PinterestAccount _PinterestAccount = dbr.Find <Domain.Socioboard.Models.PinterestAccount>(t => t.username.Equals(profileId) && t.userid == userId).FirstOrDefault();
MongoRepository mongorepobd = new MongoRepository("MongoPinterestBoard", _appSettings);
var ret1 = mongorepobd.Find <Domain.Socioboard.Models.Mongo.MongoPinterestBoard>(t => t.pinterestUserId == _PinterestAccount.profileid);
var task1 = Task.Run(async() =>
{
return(await ret1);
});
IList <Domain.Socioboard.Models.Mongo.MongoPinterestBoard> lstboards = task1.Result;
MongoRepository mongorepo = new MongoRepository("MongoPinterestUserPins", _appSettings);
var builder = Builders <Domain.Socioboard.Models.Mongo.MongoPinterestUserPins> .Sort;
var sort = builder.Descending(t => t.created_at);
var ret = mongorepo.FindWithRange <Domain.Socioboard.Models.Mongo.MongoPinterestUserPins>(t => t.pinterestUserId == _PinterestAccount.profileid, sort, skip, take);
var task = Task.Run(async() =>
{
return(await ret);
});
IList <Domain.Socioboard.Models.Mongo.MongoPinterestUserPins> lstpins = task.Result;
_BoardfeedData._PinterestAccount = _PinterestAccount;
_BoardfeedData.lstMongoPinterestUserPins = lstpins.ToList();
_BoardfeedData.lstMongoPinterestUserBoards = lstboards.ToList();
return(Ok(_BoardfeedData));
}
catch (Exception)
{
return(Ok(new List <Domain.Socioboard.Models.Mongo.BoardfeedData>()));
}
}
//Custom table report data
public static List <Domain.Socioboard.Models.YoutubeReports_all> GetYtCustomTableData(string channelId, Helper.Cache _redisCache, Helper.AppSettings settings, Model.DatabaseRepository dbr)
{
List <Domain.Socioboard.Models.YoutubeReports_all> lstReportsAll = new List <Domain.Socioboard.Models.YoutubeReports_all>();
List <Domain.Socioboard.Models.YoutubeChannel> lstChannel = dbr.Find <Domain.Socioboard.Models.YoutubeChannel>(t => t.YtubeChannelId == channelId).ToList();
Domain.Socioboard.Models.YoutubeReports_all _intaReportsStats = new Domain.Socioboard.Models.YoutubeReports_all();
MongoRepository mongorepo = new MongoRepository("YoutubeVideosDetailedList", settings);
var result = mongorepo.Find <Domain.Socioboard.Models.Mongo.YoutubeVideoDetailsList>(t => t.channelId.Equals(channelId));
var task = Task.Run(async() =>
{
return(await result);
});
IList <Domain.Socioboard.Models.Mongo.YoutubeVideoDetailsList> lstVideos = task.Result;
IList <Domain.Socioboard.Models.Mongo.YoutubeVideoDetailsList> lstVideos_sorted;
try
{
lstVideos_sorted = lstVideos.OrderBy(t => Convert.ToDateTime(t.publishedAt)).ToList();
}
catch
{
lstVideos_sorted = lstVideos;
}
_intaReportsStats._YoutubeChannelss = lstChannel.First();
_intaReportsStats._YoutubeVideoss = lstVideos_sorted.ToList();
lstReportsAll.Add(_intaReportsStats);
return(lstReportsAll);
}
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 List <Domain.Socioboard.Models.Discovery> DiscoveryHistory(long userId, Model.DatabaseRepository dbr)
{
List <Domain.Socioboard.Models.Discovery> totaldata = dbr.Find <Domain.Socioboard.Models.Discovery>(t => t.userId == userId).ToList();
List <Domain.Socioboard.Models.Discovery> lstdiscovery = totaldata.OrderByDescending(t => t.createTime).ToList();
return(lstdiscovery);
}
public static List <Domain.Socioboard.Models.retaingroup> RetainGrpMber(long userId, Helper.Cache _redisCache, Model.DatabaseRepository dbr)
{
List <Domain.Socioboard.Models.retaingroup> lstgrpdetal = new List <retaingroup>();
List <Groupmembers> lstadmingrpmember = dbr.Find <Groupmembers>(t => t.userId == userId && t.memberStatus == Domain.Socioboard.Enum.GroupMemberStatus.Accepted && t.isAdmin == true).ToList();
List <long> tempLst = new List <long>();
foreach (var itemLst in lstadmingrpmember)
{
tempLst.Add(itemLst.groupid);
}
List <Groupmembers> membersAdminGrp = dbr.Find <Domain.Socioboard.Models.Groupmembers>(t => tempLst.Contains(t.groupid) && t.memberStatus == Domain.Socioboard.Enum.GroupMemberStatus.Accepted && t.isAdmin != true).ToList();
List <Groupmembers> lstnonadmingrpmember = dbr.Find <Groupmembers>(t => t.userId == userId && t.memberStatus == Domain.Socioboard.Enum.GroupMemberStatus.Accepted && t.isAdmin != true).ToList();
foreach (var item in membersAdminGrp)
{
Domain.Socioboard.Models.retaingroup lstretailgrp = new retaingroup();
Groups grp = dbr.Find <Domain.Socioboard.Models.Groups>(t => t.id == item.groupid).First();
string grpname = grp.groupName;
lstretailgrp.grpname = grpname;
lstretailgrp.username = item.firstName;
lstretailgrp.userId = item.email;
lstretailgrp.memberid = item.id;
lstretailgrp.grpid = item.groupid;
lstretailgrp.type = "You";
lstgrpdetal.Add(lstretailgrp);
}
foreach (var item in lstnonadmingrpmember)
{
Domain.Socioboard.Models.retaingroup lstretailgrp = new retaingroup();
Groups grp = dbr.Find <Domain.Socioboard.Models.Groups>(t => t.id == item.groupid).First();
string grpname = grp.groupName;
lstretailgrp.grpname = grpname;
lstretailgrp.username = item.firstName;
lstretailgrp.userId = item.email;
lstretailgrp.memberid = item.id;
lstretailgrp.grpid = item.groupid;
lstretailgrp.type = "Other";
lstgrpdetal.Add(lstretailgrp);
}
//lstretailgrp.memberofadmin = membersAdminGrp;
//lstretailgrp.memberofNonadmin = lstnonadmingrpmember;
return(lstgrpdetal);
}
public static int getAllGroupsofUserCount(long userId, Helper.Cache _redisCache, Model.DatabaseRepository dbr)
{
List <long> lstGroupIds = dbr.Find <Domain.Socioboard.Models.Groupmembers>(t => t.userId == userId && t.memberStatus == Domain.Socioboard.Enum.GroupMemberStatus.Accepted).Select(t => t.groupid).ToList();
//List<Domain.Socioboard.Models.Groups> groups = dbr.Find<Domain.Socioboard.Models.Groups>(t => lstGroupIds.Contains(t.id)).ToList();
int lstScheduledMessage = dbr.Counts <Domain.Socioboard.Models.Groups>(t => lstGroupIds.Contains(t.id));
return(lstScheduledMessage);
}
public static List <Domain.Socioboard.Models.Groups> getGroupsofUser(long userId, Helper.Cache _redisCache, Model.DatabaseRepository dbr)
{
try
{
List <Domain.Socioboard.Models.Groups> inMemGroups = _redisCache.Get <List <Domain.Socioboard.Models.Groups> >(Domain.Socioboard.Consatants.SocioboardConsts.CacheUserGroups + userId);
if (inMemGroups != null)
{
return(inMemGroups);
}
}
catch { }
List <long> lstGroupIds = dbr.Find <Domain.Socioboard.Models.Groupmembers>(t => t.userId == userId && t.memberStatus == Domain.Socioboard.Enum.GroupMemberStatus.Accepted && t.isAdmin == false).Select(t => t.groupid).ToList();
List <Domain.Socioboard.Models.Groups> groups = dbr.Find <Domain.Socioboard.Models.Groups>(t => lstGroupIds.Contains(t.id)).ToList();
_redisCache.Set(Domain.Socioboard.Consatants.SocioboardConsts.CacheUserGroups + userId, groups);
return(groups);
}
public static List <Domain.Socioboard.Models.Groupmembers> adminDelete(long groupId, Helper.Cache _redisCache, Model.DatabaseRepository dbr)
{
List <Domain.Socioboard.Models.Groupmembers> adminDetails = dbr.Find <Domain.Socioboard.Models.Groupmembers>(t => t.groupid == groupId).ToList();
foreach (Domain.Socioboard.Models.Groupmembers item in adminDetails)
{
Groupmembers user = item;
dbr.Delete <Domain.Socioboard.Models.Groupmembers>(user);
}
List <Domain.Socioboard.Models.Groups> groupName = dbr.Find <Domain.Socioboard.Models.Groups>(t => t.id == groupId).ToList();
foreach (Domain.Socioboard.Models.Groups item in groupName)
{
Groups group = item;
dbr.Delete <Domain.Socioboard.Models.Groups>(group);
}
return(adminDetails);
}
public static List <Domain.Socioboard.Models.ScheduledMessage> GetScheduledMessage(string profileId, DateTime date)
{
DatabaseRepository dbr = new Model.DatabaseRepository();
DateTime dayStart = new DateTime(date.Year, date.Month, date.Day, 0, 0, 0, DateTimeKind.Utc);
DateTime dayEnd = new DateTime(date.Year, date.Month, date.Day, 23, 59, 59, DateTimeKind.Utc);
List <Domain.Socioboard.Models.ScheduledMessage> lstScheduledMessages = dbr.Find <Domain.Socioboard.Models.ScheduledMessage>(t => (t.profileId.Equals(profileId) && t.scheduleTime > dayStart && t.scheduleTime < dayEnd)).ToList();
return(lstScheduledMessages);
}
public static List <Domain.Socioboard.Models.Groupmembers> LeaveTeam(long groupId, long userId, Helper.Cache _redisCache, Model.DatabaseRepository dbr)
{
List <Domain.Socioboard.Models.Groupmembers> leave = dbr.Find <Domain.Socioboard.Models.Groupmembers>(t => t.groupid == groupId && t.userId == userId).ToList();
foreach (Domain.Socioboard.Models.Groupmembers item in leave)
{
dbr.Delete <Domain.Socioboard.Models.Groupmembers>(item);
}
return(leave);
}
public static string IsPrimaryAccount(long userId, string profileId, Model.DatabaseRepository dbr, Helper.AppSettings _appSettings)
{
Domain.Socioboard.Models.User user = new User();
Domain.Socioboard.Models.Facebookaccounts fbAcc = dbr.Find <Domain.Socioboard.Models.Facebookaccounts>(t => t.FbUserId.Equals(profileId) && t.UserId == userId && t.IsActive).FirstOrDefault();
try
{
user = dbr.Find <Domain.Socioboard.Models.User>(t => t.Id.Equals(userId) && t.EmailId == fbAcc.EmailId && t.EmailValidateToken == "Facebook").FirstOrDefault();
}
catch (Exception ex)
{
}
if (user != null)
{
return("Primary Account");
}
else
{
return("Not Primary Account");
}
}
public IActionResult GetFbFanpageDetailsRep(long userId)
{
Model.DatabaseRepository dbr = new Model.DatabaseRepository(_logger, _appEnv);
MongoRepository mongorepo = new MongoRepository("FacaebookPageDailyReports", _appSettings);
List <Domain.Socioboard.Models.Facebookaccounts> fbacclst = dbr.Find <Domain.Socioboard.Models.Facebookaccounts>(t => t.UserId == userId && t.FbProfileType == Domain.Socioboard.Enum.FbProfileType.FacebookPage).ToList();
string[] fbaccid = fbacclst.Select(t => t.FbUserId).ToArray();
List <Domain.Socioboard.Models.Mongo.FacaebookPageDailyReports> fbreplst = new List <Domain.Socioboard.Models.Mongo.FacaebookPageDailyReports>();
fbreplst = Repositories.FacaebookPageReportsRepositories.GetFbpageDetails(fbaccid, dbr, _redisCache, _appSettings);
return(Ok(fbreplst));
}
public static int GetAllSentMessagesCount(long userId, long groupId, Model.DatabaseRepository dbr, Helper.Cache _redisCache)
{
string[] profileids = null;
List <Domain.Socioboard.Models.Groupprofiles> iMmemGroupprofiles = _redisCache.Get <List <Domain.Socioboard.Models.Groupprofiles> >(Domain.Socioboard.Consatants.SocioboardConsts.CacheGroupProfiles + groupId);
List <Domain.Socioboard.Models.Groupprofiles> lstGroupprofiles = new List <Groupprofiles>();
if (iMmemGroupprofiles != null && iMmemGroupprofiles.Count > 0)
{
lstGroupprofiles = iMmemGroupprofiles;
}
else
{
lstGroupprofiles = dbr.Find <Domain.Socioboard.Models.Groupprofiles>(t => t.groupId == groupId).ToList();
_redisCache.Set(Domain.Socioboard.Consatants.SocioboardConsts.CacheGroupProfiles + groupId, lstGroupprofiles);
}
profileids = lstGroupprofiles.Select(t => t.profileId).ToArray();
List <Domain.Socioboard.Models.ScheduledMessage> lstScheduledMessage = dbr.Find <Domain.Socioboard.Models.ScheduledMessage>(t => profileids.Contains(t.profileId) && t.status == Domain.Socioboard.Enum.ScheduleStatus.Compleated).ToList();
return(lstScheduledMessage.Count);
}
public IActionResult GetFbTotalFanpage(long userId, int days)
{
Model.DatabaseRepository dbr = new Model.DatabaseRepository(_logger, _appEnv);
MongoRepository mongorepo = new MongoRepository("FacaebookPageDailyReports", _appSettings);
List <Domain.Socioboard.Models.Facebookaccounts> lstfanpageacc = dbr.Find <Domain.Socioboard.Models.Facebookaccounts>(t => t.UserId == userId && t.FbProfileType == Domain.Socioboard.Enum.FbProfileType.FacebookPage).ToList();
List <Domain.Socioboard.Models.Mongo.totalFacebookpagefans> lstInstreport = new List <Domain.Socioboard.Models.Mongo.totalFacebookpagefans>();
lstInstreport = Repositories.FacaebookPageReportsRepositories.GetTotalFanpageDet(lstfanpageacc, days, _redisCache, _appSettings);
return(Ok(lstInstreport));
}
public IActionResult GetArticlesAndBlogsReports(string profileId, int daysCount)
{
Model.DatabaseRepository dbr = new Model.DatabaseRepository(_logger, _appEnv);
List <Domain.Socioboard.Models.GoogleAnalyticsAccount> lstGAAcc = dbr.Find <Domain.Socioboard.Models.GoogleAnalyticsAccount>(t => t.GaProfileId.Equals(profileId)).ToList();
if (lstGAAcc != null && lstGAAcc.Count() > 0)
{
Domain.Socioboard.Models.GoogleAnalyticsAccount objGoogleAnalyticsAccount = lstGAAcc.First();
return(Ok(Repositories.GoogleAnalyticsReportRepository.GetArticlesAndBlogsReports(objGoogleAnalyticsAccount.WebsiteUrl, daysCount, _redisCache, _appSettings)));
}
return(Ok());
}
public static string DeleteProfile(Model.DatabaseRepository dbr, string profileId, long userId, Helper.Cache _redisCache, Helper.AppSettings _appSettings)
{
Domain.Socioboard.Models.Instagramaccounts fbAcc = dbr.Find <Domain.Socioboard.Models.Instagramaccounts>(t => t.InstagramId.Equals(profileId) && t.UserId == userId && t.IsActive).FirstOrDefault();
if (fbAcc != null)
{
fbAcc.IsActive = false;
dbr.Update <Domain.Socioboard.Models.Instagramaccounts>(fbAcc);
_redisCache.Delete(Domain.Socioboard.Consatants.SocioboardConsts.CacheInstagramAccount + profileId);
return("Deleted");
}
else
{
return("Account Not Exist");
}
}
/// <summary>
///
/// </summary>
/// <param name="userId"></param>
/// <param name="redisCache"></param>
/// <param name="dbr"></param>
/// <returns></returns>
public static List <Groups> GetAllGroupsofUser(long userId, Helper.Cache redisCache, Model.DatabaseRepository dbr)
{
try
{
var inMemGroups = redisCache.Get <List <Groups> >(Domain.Socioboard.Consatants.SocioboardConsts.CacheUserGroups + userId);
if (inMemGroups != null)
{
return(inMemGroups);
}
var lstGroupIds = dbr.Find <Groupmembers>(t => t.userId == userId && t.memberStatus == Domain.Socioboard.Enum.GroupMemberStatus.Accepted).Select(t => t.groupid).ToList();
var groups = dbr.Find <Groups>(t => lstGroupIds.Contains(t.id)).ToList();
redisCache.Set(Domain.Socioboard.Consatants.SocioboardConsts.CacheUserGroups + userId, groups);
return(groups);
}
catch (Exception ex) {
Console.WriteLine(ex.StackTrace);
}
return(null);
}
public static List <Domain.Socioboard.Models.Groupmembers> findmember(long SBgroupId, long userId, Helper.Cache _redisCache, Model.DatabaseRepository dbr)
{
try
{
List <Domain.Socioboard.Models.Groupmembers> inMemGroupMembers = _redisCache.Get <List <Domain.Socioboard.Models.Groupmembers> >(Domain.Socioboard.Consatants.SocioboardConsts.CacheGroupMembers + userId);
if (inMemGroupMembers != null)
{
return(inMemGroupMembers);
}
}
catch { }
List <Domain.Socioboard.Models.Groupmembers> groupMembers = dbr.Find <Domain.Socioboard.Models.Groupmembers>(t => t.userId == userId && t.groupid != SBgroupId).ToList();
_redisCache.Set(Domain.Socioboard.Consatants.SocioboardConsts.CacheGroupMembers + userId, groupMembers);
return(groupMembers);
}
public static List <Domain.Socioboard.Models.Mongo.RssFeed> GetPostedRssDataByUser(long userId, long groupId, Helper.AppSettings _appSettings, Model.DatabaseRepository dbr)
{
string[] profileids = null;
MongoRepository _RssRepository = new MongoRepository("RssFeed", _appSettings);
List <Domain.Socioboard.Models.Mongo.RssFeed> lstRss = new List <Domain.Socioboard.Models.Mongo.RssFeed>();
List <Domain.Socioboard.Models.Groupprofiles> lstGroupprofiles = dbr.Find <Domain.Socioboard.Models.Groupprofiles>(t => t.groupId == groupId).ToList();
profileids = lstGroupprofiles.Select(t => t.profileId).ToArray();
var ret = _RssRepository.Find <Domain.Socioboard.Models.Mongo.RssFeed>(t => profileids.Contains(t.ProfileId));
var task = Task.Run(async() =>
{
return(await ret);
});
return(lstRss = task.Result.ToList());
}
public IActionResult GetYTChannelsSB(long groupId)
{
DatabaseRepository dbr = new Model.DatabaseRepository(_logger, _appEnv);
List <Domain.Socioboard.Models.Groupprofiles> lstGroupprofiles = dbr.Find <Domain.Socioboard.Models.Groupprofiles>(t => t.groupId == groupId).Where(t => t.profileType == Domain.Socioboard.Enum.SocialProfileType.YouTube).ToList();
List <Domain.Socioboard.Models.YoutubeChannel> lstYoutubeChannel = new List <YoutubeChannel>();
foreach (var item in lstGroupprofiles)
{
Domain.Socioboard.Models.YoutubeChannel YTChnl = Repositories.GplusRepository.getYTChannel(item.profileId, _redisCache, dbr);
if (YTChnl != null)
{
lstYoutubeChannel.Add(YTChnl);
}
}
return(Ok(lstYoutubeChannel));
}
public static List <Domain.Socioboard.Models.TwitterRecentFollower> TwitterRecentFollower(long groupId, Model.DatabaseRepository dbr, Helper.AppSettings _appSettings)
{
string[] profileids = null;
List <Domain.Socioboard.Models.TwitterRecentFollower> lstTwitterRecentFollower = new List <Domain.Socioboard.Models.TwitterRecentFollower>();
List <Domain.Socioboard.Models.Groupprofiles> lstGroupprofiles = dbr.Find <Domain.Socioboard.Models.Groupprofiles>(t => t.groupId == groupId && t.profileType == Domain.Socioboard.Enum.SocialProfileType.Twitter).ToList();
profileids = lstGroupprofiles.Select(t => t.profileId).ToArray();
List <Domain.Socioboard.Models.TwitterAccount> lstAccRepo = dbr.Find <Domain.Socioboard.Models.TwitterAccount>(t => profileids.Contains(t.twitterUserId) && t.isActive).ToList();
oAuthTwitter oauth = null;
Users twtUsers = new Users();
foreach (Domain.Socioboard.Models.TwitterAccount itemTwt in lstAccRepo)
{
oauth = new oAuthTwitter();
oauth.AccessToken = itemTwt.oAuthToken;
oauth.AccessTokenSecret = itemTwt.oAuthSecret;
oauth.TwitterScreenName = itemTwt.twitterScreenName;
oauth.TwitterUserId = itemTwt.twitterUserId;
oauth.ConsumerKey = _appSettings.twitterConsumerKey;
oauth.ConsumerKeySecret = _appSettings.twitterConsumerScreatKey;
JArray jarresponse = twtUsers.Get_Followers_ById(oauth, itemTwt.twitterUserId);
foreach (var item in jarresponse)
{
int resposecount = 0;
if (item["ids"] != null)
{
foreach (var child in item["ids"])
{
if (resposecount < 2)
{
JArray userprofile = twtUsers.Get_Users_LookUp(oauth, child.ToString());
foreach (var items in userprofile)
{
Domain.Socioboard.Models.TwitterRecentFollower objTwitterRecentFollower = new Domain.Socioboard.Models.TwitterRecentFollower();
resposecount++;
objTwitterRecentFollower.screen_name = items["screen_name"].ToString();
objTwitterRecentFollower.name = items["name"].ToString();
objTwitterRecentFollower.profile_image_url = items["profile_image_url"].ToString();
lstTwitterRecentFollower.Add(objTwitterRecentFollower);
}
}
}
}
}
}
return(lstTwitterRecentFollower);
}
public static List <Domain.Socioboard.Models.Groupprofiles> getGroupProfiles(long groupId, Helper.Cache _redisCache, Model.DatabaseRepository dbr)
{
try
{
List <Domain.Socioboard.Models.Groupprofiles> inMemGroupProfiles = _redisCache.Get <List <Domain.Socioboard.Models.Groupprofiles> >(Domain.Socioboard.Consatants.SocioboardConsts.CacheGroupProfiles + groupId);
if (inMemGroupProfiles != null)
{
return(inMemGroupProfiles);
}
}
catch { }
List <Domain.Socioboard.Models.Groupprofiles> groupProfiles = dbr.Find <Domain.Socioboard.Models.Groupprofiles>(t => t.groupId == groupId).ToList();
_redisCache.Set(Domain.Socioboard.Consatants.SocioboardConsts.CacheGroupProfiles + groupId, groupProfiles);
return(groupProfiles);
}
