public override async Task <FacebookProcessResult> Process(SocialAccount socialAccount, FbHookChange change)
{
var result = new FacebookProcessResult(NotificationManager);
if (IsWallPost(change) && !socialAccount.IfConvertWallPostToConversation)
{
return(result);
}
if (!IsWallPost(change) && !socialAccount.IfConvertVisitorPostToConversation)
{
return(result);
}
string token = socialAccount.Token;
if (IsDuplicatedMessage(MessageSource.FacebookPost, change.Value.PostId))
{
return(result);
}
FbPost post = await FbClient.GetPost(socialAccount.Token, change.Value.PostId);
SocialUser sender = await GetOrCreateFacebookUser(socialAccount.Token, post.from.id);
Message message = FacebookConverter.ConvertToMessage(post);
message.SenderId = sender.Id;
if (message.SenderId != socialAccount.Id)
{
message.ReceiverId = socialAccount.Id;
}
var conversation = new Conversation
{
OriginalId = change.Value.PostId,
Source = ConversationSource.FacebookVisitorPost,
Priority = ConversationPriority.Normal,
Status = ConversationStatus.New,
Subject = GetSubject(message.Content),
LastMessageSenderId = message.SenderId,
LastMessageSentTime = message.SendTime
};
if (change.Value.Verb == "add" && message.SenderId == socialAccount.Id)
{
conversation.Source = ConversationSource.FacebookWallPost;
conversation.IsHidden = true;
}
conversation.Messages.Add(message);
await AddConversation(socialAccount, conversation);
await CurrentUnitOfWork.SaveChangesAsync();
if (!conversation.IsHidden)
{
result.WithNewConversation(conversation);
}
return(result);
}
public override async Task <SocialUser> GetUserInfoAsync(Account account)
{
SocialUser user = null;
string token = account.Properties["access_token"];
string refreshToke = account.Properties["refresh_token"];
int expriesIn;
int.TryParse(account.Properties["expires_in"], out expriesIn);
var request = new OAuth2Request("GET", UserInfoUri, null, account);
var response = await request.GetResponseAsync();
if (response != null && response.StatusCode == HttpStatusCode.OK)
{
string userJson = await response.GetResponseTextAsync();
var googleUser = JsonConvert.DeserializeObject <GoogleUser>(userJson);
user = new SocialUser
{
SocialId = googleUser.Sub,
Token = token,
RefreshToken = null,
Name = googleUser.Name,
Email = googleUser.Email,
ExpiresIn = DateTime.UtcNow.Add(new TimeSpan(expriesIn)),
PictureUrl = googleUser.Picture,
Provider = SocialProvider.Google,
LoggedInWithSocialAccount = true,
};
}
return(user);
}
protected void bt_register_Click(object sender, EventArgs e)
{
// Response.Redirect("/asd.aspx");
SocialUser social = new SocialUser();
social.email = Email.Text;
social.username = LoginName.Text;
social.id = hidden_id.Value;
InsertNewUser(social);
try
{
using (WebClient client = new WebClient())
{
byte[] response =
client.UploadValues("https://api.madmimi.com/audience_lists/Owners/add", new NameValueCollection()
{
{ "username", "*****@*****.**" },
{ "api_key", "9881316569391d3dbfba35b71670b4b2" },
{ "email", Email.Text },
{ "first_name", LoginName.Text }
});
//string result = System.Text.Encoding.UTF8.GetString(response);
}
}
catch
{
}
}
private static void ValidateSocialUser(SocialUser socialUser, string email)
{
if (socialUser == null || socialUser.Email == null || email == null || socialUser.Email.ToLower() != email.ToLower())
{
throw new BusinessException("Invalid parameters");
}
}
/// <summary>
/// 修改指定的数据
/// <param name="e">修改后的数据实体对象</param>
/// <para>数据对应的主键必须在实例中设置</para>
/// </summary>
public void Update(SocialUser e)
{
MySqlConnection oc = ConnectManager.Create();
MySqlCommand _cmdUpdateSocialUser = cmdUpdateSocialUser.Clone() as MySqlCommand;
_cmdUpdateSocialUser.Connection = oc;
try
{
if (oc.State == ConnectionState.Closed)
{
oc.Open();
}
_cmdUpdateSocialUser.Parameters["@SocialUserType"].Value = e.SocialUserType;
_cmdUpdateSocialUser.Parameters["@AccessToken"].Value = e.AccessToken;
_cmdUpdateSocialUser.Parameters["@AccessTokenSecret"].Value = e.AccessTokenSecret;
_cmdUpdateSocialUser.Parameters["@Uid"].Value = e.Uid;
_cmdUpdateSocialUser.Parameters["@UserId"].Value = e.UserId;
_cmdUpdateSocialUser.ExecuteNonQuery();
}
finally
{
oc.Close();
oc.Dispose();
oc = null;
_cmdUpdateSocialUser.Dispose();
_cmdUpdateSocialUser = null;
GC.Collect();
}
}
/// <summary>
/// 添加数据
/// <param name="es">数据实体对象数组</param>
/// <returns></returns>
/// </summary>
public bool Insert(SocialUser e)
{
MySqlConnection oc = ConnectManager.Create();
MySqlCommand _cmdInsertSocialUser = cmdInsertSocialUser.Clone() as MySqlCommand;
bool returnValue = false;
_cmdInsertSocialUser.Connection = oc;
try
{
if (oc.State == ConnectionState.Closed)
{
oc.Open();
}
_cmdInsertSocialUser.Parameters["@SocialUserType"].Value = e.SocialUserType;
_cmdInsertSocialUser.Parameters["@AccessToken"].Value = e.AccessToken;
_cmdInsertSocialUser.Parameters["@AccessTokenSecret"].Value = e.AccessTokenSecret;
_cmdInsertSocialUser.Parameters["@Uid"].Value = e.Uid;
_cmdInsertSocialUser.Parameters["@UserId"].Value = e.UserId;
_cmdInsertSocialUser.ExecuteNonQuery();
return(returnValue);
}
finally
{
oc.Close();
oc.Dispose();
oc = null;
_cmdInsertSocialUser.Dispose();
_cmdInsertSocialUser = null;
}
}
/// <summary>
/// 判断是否绑定了社交账户，如果有绑定则自动登录，并返回token
/// </summary>
/// <param name="socialUser"></param>
/// <returns></returns>
public AdvancedResult <string> IsBindSocialUser(SocialUser socialUser)
{
AdvancedResult <string> result = new AdvancedResult <string>();
try
{
SocialUser suer = SocialUserAccessor.Instance.Get(socialUser.Uid, socialUser.SocialUserType);
if (suer != null)
{
//刷新access_token
suer.AccessToken = socialUser.AccessToken;
suer.AccessTokenSecret = socialUser.AccessTokenSecret;
SocialUserAccessor.Instance.Update(suer);
result.Error = AppError.ERROR_SUCCESS;
result.Data = SecurityHelper.GetToken(suer.UserId.ToString());
}
else
{
result.Error = AppError.ERROR_FAILED;
}
}
catch (Exception e)
{
result.Error = AppError.ERROR_FAILED;
result.ExMessage = e.ToString();
}
return(result);
}
public async Task ShouldIgnoreDuplicatedMessage()
{
// Arrange
var fbHookChange = MakeFbHootChangeForComment();
var fbComment = MakeFbComment();
var sender = new SocialUser {
Id = 1, OriginalId = "user_1"
};
var dependencyResolverMock = MockDependencyResolver(fbHookChange, fbComment, sender);
var messageServiceMock = new Mock <IMessageService>();
// make duplicate message
messageServiceMock.Setup(t => t.FindAll()).Returns(new List <Message> {
new Message {
OriginalId = fbComment.id
}
}.AsQueryable());
dependencyResolverMock.Setup(t => t.Resolve <IMessageService>()).Returns(messageServiceMock.Object);
var strategy = new NewCommentStrategy(dependencyResolverMock.Object);
var socialAccount = new SocialAccount {
Token = "token", IfConvertVisitorPostToConversation = true
};
// Act
var processResult = await strategy.Process(socialAccount, fbHookChange);
// Assert
Assert.False(processResult.NewMessages.Any());
Assert.False(processResult.NewConversations.Any());
Assert.False(processResult.UpdatedConversations.Any());
}
public ActionResult CallBack()
{
var verifier = Request.QueryString["code"];
string state = Session["requeststate"].ToString();
WeiboAuthenticationTicket ticket = new WeiboAuthenticationTicket()
{
Code = verifier,
Tag = "Weibo"
};
ticket = _tencentHandler.PreAuthorization(ticket);
ticket = _tencentHandler.AuthenticateCore(ticket);
UserClaim userClaim = getUserClaimByOpenIdOrUnionId(ticket.OpenId, "", ticket.Tag);
if (userClaim != null)
{
FormsAuthentication.SetAuthCookie(userClaim.User.UserName, true);
if (Session["returnUrl"] != null && string.IsNullOrEmpty(Session["returnUrl"].ToString()))
{
return(Redirect(Session["returnUrl"].ToString()));
}
return(RedirectToAction("Index", "Home"));
}
SocialUser user = _tencentHandler.GetUserInfo(ticket);
Session["social.current"] = user;
return(RedirectToAction("social", "members"));
}
public async override Task <FacebookProcessResult> Process(SocialAccount socialAccount, FbHookChange change)
{
var result = new FacebookProcessResult(NotificationManager);
string token = socialAccount.Token;
if (IsDuplicatedMessage(change.Value.CommentId))
{
return(result);
}
FbComment comment = FbClient.GetComment(socialAccount.Token, change.Value.CommentId);
SocialUser sender = await GetOrCreateFacebookUser(socialAccount.Token, comment.from.id);
var conversation = GetConversation(change.Value.PostId);
if (conversation == null)
{
return(result);
}
Message message = FacebookConverter.ConvertToMessage(comment);
message.SenderId = sender.Id;
var parent = GetParent(change.Value.PostId, comment);
if (parent != null)
{
message.ParentId = parent.Id;
message.ReceiverId = parent.SenderId;
bool ifParentIsComment = parent.ParentId != null;
if (ifParentIsComment)
{
message.Source = MessageSource.FacebookPostReplyComment;
}
}
message.ConversationId = conversation.Id;
conversation.IfRead = false;
conversation.Status = sender.Id != socialAccount.Id ? ConversationStatus.PendingInternal : ConversationStatus.PendingExternal;
conversation.LastMessageSenderId = message.SenderId;
conversation.LastMessageSentTime = message.SendTime;
if (conversation.TryToMakeWallPostVisible(socialAccount))
{
result.WithNewConversation(conversation);
}
conversation.Messages.Add(message);
await UpdateConversation(conversation);
await CurrentUnitOfWork.SaveChangesAsync();
if (!conversation.IsHidden)
{
result.WithNewMessage(message);
}
return(result);
}
public Message ConvertMessage(FbMessage fbMessage, SocialUser Sender, SocialUser Receiver)
{
Message message = new Message
{
SenderId = Sender.Id,
ReceiverId = Receiver.Id,
Source = MessageSource.FacebookMessage,
OriginalId = fbMessage.Id,
SendTime = fbMessage.SendTime,
Content = fbMessage.Content
};
foreach (var attachment in fbMessage.Attachments)
{
message.Attachments.Add(new MessageAttachment
{
OriginalId = attachment.Id,
Name = attachment.Name,
MimeType = attachment.MimeType,
Type = attachment.Type,
Size = attachment.Size,
Url = attachment.Url,
PreviewUrl = attachment.PreviewUrl
});
}
return(message);
}
public async Task ShouldCreateMessageForComment()
{
// Arrange
var fbHookChange = MakeFbHootChangeForComment();
var fbComment = MakeFbComment();
var sender = new SocialUser {
Id = 1, OriginalId = "user_1"
};
var dependencyResolverMock = MockDependencyResolver(fbHookChange, fbComment, sender);
var strategy = new NewCommentStrategy(dependencyResolverMock.Object);
strategy.UnitOfWorkManager = MockUnitOfWorkManager().Object;
var socialAccount = new SocialAccount {
Token = "token", IfConvertVisitorPostToConversation = true
};
// Act
var processResult = await strategy.Process(socialAccount, fbHookChange);
// Assert
var message = processResult.UpdatedConversations.First().Messages.First(t => t.OriginalId == "comment_1");
Assert.NotNull(message);
Assert.Equal(MessageSource.FacebookPostComment, message.Source);
Assert.Equal(fbComment.id, message.OriginalId);
Assert.Equal(sender.Id, message.SenderId);
Assert.Equal(fbComment.message, message.Content);
}
private void OnLoginGameCenterSuccess(EnumLoginState state, SocialUser user)
{
if (state == EnumLoginState.Success)
{
buttonFirebase.gameObject.SetActive(true);
}
}
public async Task ShouldNotifyNewMessage()
{
// Arrange
var fbHookChange = MakeFbHootChangeForComment();
var fbComment = MakeFbComment();
var sender = new SocialUser {
Id = 1, OriginalId = "user_1"
};
var dependencyResolverMock = MockDependencyResolver(fbHookChange, fbComment, sender);
var strategy = new NewCommentStrategy(dependencyResolverMock.Object);
strategy.UnitOfWorkManager = MockUnitOfWorkManager().Object;
var socialAccount = new SocialAccount {
Token = "token", IfConvertVisitorPostToConversation = true
};
// Act
var processResult = await strategy.Process(socialAccount, fbHookChange);
// Assert
Assert.Equal(0, processResult.NewConversations.Count());
Assert.Equal(1, processResult.UpdatedConversations.Count());
Assert.Equal(1, processResult.NewMessages.Count());
}
public async Task ShouldUpdateConversation()
{
// Arrange
var fbHookChange = MakeFbHootChangeForComment();
var fbComment = MakeFbComment();
var sender = new SocialUser {
Id = 1, OriginalId = "user_1"
};
var dependencyResolverMock = MockDependencyResolver(fbHookChange, fbComment, sender);
var strategy = new NewCommentStrategy(dependencyResolverMock.Object);
strategy.UnitOfWorkManager = MockUnitOfWorkManager().Object;
var socialAccount = new SocialAccount {
Token = "token", IfConvertVisitorPostToConversation = true
};
// Act
var processResult = await strategy.Process(socialAccount, fbHookChange);
// Assert
var conversation = processResult.UpdatedConversations.First();
Assert.NotNull(conversation);
Assert.Equal(sender.Id, conversation.LastMessageSenderId);
Assert.Equal(fbComment.created_time, conversation.LastMessageSentTime);
Assert.Equal(ConversationStatus.PendingInternal, conversation.Status);
}
public async Task ShouldNofityNewConversation()
{
// Arrange
var fbChange = new FbHookChange {
Value = new FbHookChangeValue {
ThreadId = "original_conversation_id"
}
};
var fbMessage = new FbMessage {
Id = "fb_1", Content = "Test_Message", SenderId = "user_1", ReceiverId = "user_2", SendTime = DateTime.UtcNow
};
var sender = new SocialUser {
Id = 1, OriginalId = "user_1"
};
var receiver = new SocialUser {
Id = 2, OriginalId = "user_2"
};
IDependencyResolver dependencyResolver = MockDependecyResolverForTestingCreateConversation(fbChange, fbMessage, sender, receiver).Object;
var strategy = new NewMessageStrategy(dependencyResolver);
strategy.UnitOfWorkManager = MockUnitOfWorkManager().Object;
var socialAccount = new SocialAccount {
Token = "token", IfConvertMessageToConversation = true
};
// Act
var processResult = await strategy.Process(socialAccount, fbChange);
// Assert
Assert.Equal(1, processResult.NewConversations.Count());
Assert.Equal(0, processResult.UpdatedConversations.Count());
Assert.Equal(0, processResult.NewMessages.Count());
}
public IActionResult _login(LoginModel model, bool p = false)
{
SocialUser user = null;
if (model.Email != null)
{
user = DbContext.SocialUsers.FirstOrDefault(x => x.Email.ToLower() == model.Email.ToLower());
if (user == null)
{
//Email doesn't exist
ModelState.AddModelError("Email", "There is no account for this email.");
}
else if (model.Password != null && user.Password != model.Password)
{
//Wrong password
ModelState.AddModelError("Password", "Wrong password. It's case-sensitive!");
}
if (ModelState.IsValid)
{
//Success
return(PartialView("_LoginRedirect", user));
}
}
model.IsPost = true;
return(PartialView(model));
}
public HttpResponseMessage AddSocialUser(SocialUser user)
{
List <User> u = new List <Models.User>();
var dbUser = _db.Users.FirstOrDefault(p => p.SocialID == user.Mail);
if (dbUser != null)
{
u.Add(dbUser);
}
else
{
User _user = new Models.User();
_user.User_Email = user.Mail;
_user.SocialID = user.Mail;
_user.User_ImgPath = user.ImgPath;
_user.User_Password = user.Password;
_user.UserType_ID = 1;
_user.User_Name = user.Name;
_user.User_SignUpDate = DateTime.Now;
_db.Users.Add(_user);
_db.SaveChanges();
u.Add(_user);
}
return(Request.CreateResponse(HttpStatusCode.OK, getUsers(u)));
}
public ActionResult CallBack()
{
try
{
var verifier = Request.Params["code"];
string state = Session["requeststate"].ToString();
if (!state.Contains(Request.Params["state"].ToString()))
{
return(Content("错误,请稍后重试"));
}
WechatAuthenticationTicket ticket = new WechatAuthenticationTicket()
{
Code = verifier
};
ticket = _tencentHandler.PreAuthorization(ticket);
ticket = _tencentHandler.AuthenticateCore(ticket);
SocialUser user = _tencentHandler.GetUserInfo(ticket);
if (null != user)
{
return(Content(""));
}
}
catch (SocialExeception ex)
{
return(Content(""));
}
return(Content(""));
}
public override async Task <SocialUser> GetUserInfoAsync(Account account)
{
SocialUser user = null;
string token = account.Properties["access_token"];
string refreshToke = account.Properties["refresh_token"];
int expriesIn;
int.TryParse(account.Properties["expires_in"], out expriesIn);
Dictionary <string, string> dictionary = new Dictionary <string, string> {
{ "Authorization", token }
};
var request = new OAuth2Request("POST", UserInfoUri, dictionary, account);
var response = await request.GetResponseAsync();
if (response != null && response.StatusCode == HttpStatusCode.OK)
{
string userJson = await response.GetResponseTextAsync();
var lineUser = JsonConvert.DeserializeObject <LineUser>(userJson);
user = new SocialUser
{
SocialId = lineUser.Id,
Token = token,
RefreshToken = refreshToke,
Name = lineUser.Name,
ExpiresIn = DateTime.UtcNow.Add(new TimeSpan(expriesIn)),
PictureUrl = lineUser.ProfileImage,
Provider = SocialProvider.Line,
LoggedInWithSocialAccount = true,
};
}
return(user);
}
public async Task ShouldSetParentForComment()
{
// Arrange
var fbHookChange = MakeFbHootChangeForComment();
var fbComment = MakeFbComment();
fbComment.parent = null;
var sender = new SocialUser {
Id = 1, OriginalId = "user_1"
};
var dependencyResolverMock = MockDependencyResolver(fbHookChange, fbComment, sender);
var messageServiceMock = new Mock <IMessageService>();
// mock parent data
messageServiceMock.Setup(t => t.FindByOriginalId(MessageSource.FacebookPost, fbComment.PostId)).Returns(new Message {
Id = 111, SenderId = 222
});
dependencyResolverMock.Setup(t => t.Resolve <IMessageService>()).Returns(messageServiceMock.Object);
var strategy = new NewCommentStrategy(dependencyResolverMock.Object);
strategy.UnitOfWorkManager = MockUnitOfWorkManager().Object;
var socialAccount = new SocialAccount {
Token = "token", IfConvertVisitorPostToConversation = true
};
// Act
var processResult = await strategy.Process(socialAccount, fbHookChange);
// Assert
var message = processResult.UpdatedConversations.First().Messages.First(t => t.OriginalId == "comment_1");
Assert.Equal(111, message.ParentId);
Assert.Equal(222, message.ReceiverId);
}
public ActionResult FacebookCallback(string code)
{
var fb = new FacebookClient();
dynamic result = fb.Post("oauth/access_token", new
{
client_id = "1743513262532791",
client_secret = "a52e7a8814110c005ed94e3a0a94e32d",
redirect_uri = RedirectUri.AbsoluteUri,
code = code
});
var accessToken = result.access_token;
fb.AccessToken = accessToken;
Session["AccessToken"] = accessToken;
dynamic me = fb.Get("me?fields=first_name,middle_name,last_name,email,gender,locale,timezone,currency,verified,picture,age_range,id");
string email = me.email;
string firstName = me.first_name;
string lastName = me.middle_name + " " + me.last_name;
string gender = me.gender;
string picture = me.picture.data.url;
var socialUser = db.SocialUsers.Any(c => c.Email == email);
if (!socialUser)
{
SocialUser acc = new SocialUser()
{
Email = email,
FirstName = firstName,
LastName = lastName,
Gender = gender,
Picture = picture,
SocialSiteName = "Facebook"
};
db.SocialUsers.Add(acc);
db.SaveChanges();
}
var users = db.SocialUsers.Where(c => c.Email == email);
foreach (var value in users)
{
Session["user"] = new SocialUser()
{
Id = value.Id,
Email = email,
FirstName = firstName,
LastName = lastName
};
}
Session["userType"] = "socialUser";
FormsAuthentication.SetAuthCookie(email, false);
return(RedirectToAction("Index", "Home"));
}
public ActionResult DeleteConfirmed(int id)
{
SocialUser socialUser = db.SocialUsers.Find(id);
db.SocialUsers.Remove(socialUser);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private void BindUserMessage(SocialUser fbpageInboxUserInfo)
{
if (!SelectedUsers.Any(m => m.InboxUserName.Equals(fbpageInboxUserInfo.InboxUserName)))
{
SelectedUsers.Add(fbpageInboxUserInfo);
fbpageInboxUserInfo.Messages = _dbHelper.GetMessengerUserComments(fbpageInboxUserInfo.InboxUserId);
}
}
protected void bt_register_Click(object sender, EventArgs e)
{
SocialUser social = new SocialUser();
social.email = Email.Text;
social.username = LoginName.Text;
social.id = hidden_id.Value;
InsertNewUser(social);
}
private void BindUserMessage(SocialUser fbpageInboxUserInfo)
{
if (!SelectedUsers.Any(m => m.InboxUserId.Equals(fbpageInboxUserInfo.InboxUserId)))
{
SelectedUsers.Add(fbpageInboxUserInfo);
//LinkToSend=fbpageInboxUserInfo.InboxNavigationUrl;
fbpageInboxUserInfo.Messages = _dbHelper.GetMessengerUserComments(fbpageInboxUserInfo.InboxUserId, fbpageInboxUserInfo.PageId);
}
}
public async Task <ActionResult <LoginSuccessUser> > Login([FromBody] SocialUser socialUser)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
return(await _userService.Authenticate(socialUser.IdToken, socialUser.Email));
}
private void OnLoginFacebookSuccess(EnumLoginState state, SocialUser user)
{
text += $"\nLogin: {state}";
if (state == EnumLoginState.Success)
{
loginFirebase.credentialUser = user;
text += $"\nInfo: {user.DebugString()}";
buttonFirebase.gameObject.SetActive(true);
}
}
private async Task Process(FacebookProcessResult result, FbMessage fbMessage, SocialAccount socialAccount, FbHookChange change)
{
SocialUser sender = await GetOrCreateFacebookUser(socialAccount.Token, fbMessage.SenderId);
SocialUser receiver = await GetOrCreateFacebookUser(socialAccount.Token, fbMessage.ReceiverId);
var existingConversation = GetUnClosedConversation(change.Value.ThreadId);
if (existingConversation != null)
{
Message message = FacebookConverter.ConvertMessage(fbMessage, sender, receiver);
message.ConversationId = existingConversation.Id;
bool isNewMessage = fbMessage.SendTime > existingConversation.LastMessageSentTime;
if (isNewMessage)
{
existingConversation.IfRead = false;
existingConversation.Status = sender.Id != socialAccount.SocialUser.Id ? ConversationStatus.PendingInternal : ConversationStatus.PendingExternal;
existingConversation.LastMessageSenderId = message.SenderId;
existingConversation.LastMessageSentTime = message.SendTime;
}
existingConversation.Messages.Add(message);
await UpdateConversation(existingConversation);
await CurrentUnitOfWork.SaveChangesAsync();
result.WithNewMessage(message);
}
else
{
if (sender.Id == socialAccount.Id)
{
return;
}
Message message = FacebookConverter.ConvertMessage(fbMessage, sender, receiver);
var conversation = new Conversation
{
OriginalId = change.Value.ThreadId,
Source = ConversationSource.FacebookMessage,
Priority = ConversationPriority.Normal,
Status = ConversationStatus.New,
Subject = GetSubject(message.Content),
LastMessageSenderId = message.SenderId,
LastMessageSentTime = message.SendTime
};
conversation.Messages.Add(message);
await AddConversation(socialAccount, conversation);
await CurrentUnitOfWork.SaveChangesAsync();
result.WithNewConversation(conversation);
}
}
private void OnSelectedUserChanged(SocialUser socialUser)
{
if (SelectedUsers == null)
{
SelectedUsers = new ObservableCollection <SocialUser>();
}
if (SelectedUsers.FirstOrDefault(s => s.InboxUserId == socialUser.InboxUserId) == null)
{
SelectedUsers.Add(socialUser);
}
}
private List<SocialUser> LoadSocialUsers(SocialUserType type, SocialUserFilter filter)
{
List<SocialUser> users = new List<SocialUser>();
using (ClientContext ctx = TokenHelper.GetClientContextWithContextToken(hdnHostWeb.Value, hdnContextToken.Value, Request.Url.Authority))
{
//Get social users
ClientResult<SocialActor[]> socialActors = null;
SocialFollowingManager followingManager = new SocialFollowingManager(ctx);
ctx.Load(followingManager);
if (type == SocialUserType.Follower)
socialActors = followingManager.GetFollowers();
if (type == SocialUserType.Followed)
socialActors = followingManager.GetFollowed(SocialActorTypes.Users);
ctx.ExecuteQuery();
//Build a collection of users
foreach (var socialActor in socialActors.Value)
{
SocialUser user = new SocialUser();
user.AccountName = socialActor.AccountName;
user.Name = socialActor.Name;
user.ImageUrl = socialActor.ImageUri;
users.Add(user);
}
}
//Filter the users
return FilterFollowed(users, filter);
}
private List<SocialUser> FilterFollowed(List<SocialUser> users, SocialUserFilter filter)
{
List<SocialUser> includedUsers = new List<SocialUser>();
foreach (SocialUser user in users)
{
bool include = false;
List<SocialPost> posts = GetPosts(user.AccountName);
switch (filter)
{
case SocialUserFilter.All:
include = true;
break;
case SocialUserFilter.Week:
foreach (SocialPost post in posts)
{
if (post.CreatedDate.AddDays(7) >= DateTime.Today)
{
include = true;
break;
}
}
break;
case SocialUserFilter.Liked:
foreach (SocialPost post in posts)
{
if (post.LikedByMe)
{
include = true;
break;
}
}
break;
}
if (include)
{
SocialUser includedUser = new SocialUser();
includedUser.AccountName = user.AccountName;
includedUser.ImageUrl = user.ImageUrl;
includedUser.Name = user.Name;
includedUsers.Add(user);
}
}
return includedUsers;
}
private List<SocialUser> LoadSocialUsers(SocialUserType type, SocialUserFilter filter)
{
List<SocialUser> users = new List<SocialUser>();
//Create the endpoint for the REST call
string endpoint;
if (type == SocialUserType.Followed)
endpoint = hdnHostWeb.Value + "/_api/social.following/my/Followed(types=1)";
else
endpoint = hdnHostWeb.Value + "/_api/social.following/my/Followers";
//Make the request
XDocument responseDoc = GetDataREST(endpoint);
//Parse the response
XNamespace d = "http://schemas.microsoft.com/ado/2007/08/dataservices";
XNamespace m = "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata";
XNamespace georss = "http://www.georss.org/georss";
XNamespace gml = "http://www.opengis.net/gml";
var followedUsers = from e in responseDoc.Root.Descendants(d + "element")
select new
{
AccountName = e.Element(d + "AccountName").Value.Split('|')[2],
Name = e.Element(d + "Name").Value,
ImageUrl = e.Element(d + "ImageUri").Value
};
//Build a collection of users
foreach (var followedUser in followedUsers)
{
SocialUser user = new SocialUser();
user.AccountName = followedUser.AccountName;
user.Name = followedUser.Name;
user.ImageUrl = followedUser.ImageUrl;
users.Add(user);
}
//Filter the users
return FilterFollowed(users, filter);
}
