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 Mock <IDependencyResolver> MockDependecyResolverForTestingUpdateConversation(Conversation conversation, FbHookChange change, FbMessage fbMessage, SocialUser sender, SocialUser receiver)
{
var fbClientMock = new Mock <IFbClient>();
fbClientMock.Setup(t => t.GetMessagesFromConversationId("token", change.Value.ThreadId, 10)).ReturnsAsync(
new List <FbMessage>
{
fbMessage
});
var messageServiceMock = new Mock <IMessageService>();
messageServiceMock.Setup(t => t.FindAll()).Returns(new List <Message>().AsQueryable());
var socialUserServiceMock = new Mock <ISocialUserService>();
socialUserServiceMock.Setup(t => t.GetOrCreateFacebookUser("token", fbMessage.SenderId)).ReturnsAsync(sender);
socialUserServiceMock.Setup(t => t.GetOrCreateFacebookUser("token", fbMessage.ReceiverId)).ReturnsAsync(receiver);
var conversationServiceMock = new Mock <IConversationService>();
// If we can find a un-closed conversation, then we will add the new message to un-closed conversation.
conversationServiceMock.Setup(t => t.GetUnClosedConversation(change.Value.ThreadId)).Returns(conversation);
var dependencyResolverMock = new Mock <IDependencyResolver>();
dependencyResolverMock.Setup(t => t.Resolve <IFbClient>()).Returns(fbClientMock.Object);
dependencyResolverMock.Setup(t => t.Resolve <IMessageService>()).Returns(messageServiceMock.Object);
dependencyResolverMock.Setup(t => t.Resolve <ISocialUserService>()).Returns(socialUserServiceMock.Object);
dependencyResolverMock.Setup(t => t.Resolve <IConversationService>()).Returns(conversationServiceMock.Object);
return(dependencyResolverMock);
}
public async override Task <FacebookProcessResult> Process(SocialAccount socialAccount, FbHookChange change)
{
var result = new FacebookProcessResult(NotificationManager);
if (!socialAccount.IfConvertMessageToConversation)
{
return(result);
}
IList <FbMessage> fbMessages = await FbClient.GetMessagesFromConversationId(socialAccount.Token, change.Value.ThreadId, 10);
string[] orgiginalIds = fbMessages.Select(t => t.Id).ToArray();
List <Message> existedMessages = MessageService.FindAll().Where(t => t.Source == MessageSource.FacebookMessage && orgiginalIds.Contains(t.OriginalId)).ToList();
// remove duplicated messages.
fbMessages = fbMessages.Where(t => !existedMessages.Any(m => m.OriginalId == t.Id)).OrderByDescending(t => t.SendTime).ToList();
foreach (var fbMessage in fbMessages)
{
await Process(result, fbMessage, socialAccount, change);
}
return(result);
}
public override bool IsMatch(FbHookChange change)
{
return(change.Field == "conversations" && change.Value.ThreadId != null);
}
public abstract Task <FacebookProcessResult> Process(SocialAccount socialAccount, FbHookChange change);
public abstract bool IsMatch(FbHookChange change);
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);
}
