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 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());
}
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);
}
}
public async Task ShouldGetLatestMessageFromConversation()
{
MessageStrategy facebookService = DependencyResolver.Resolve <MessageStrategy>();
FbMessage message = await FacebookService.GetLastMessageFromConversationId
(TestFacebookAccount.Token, "t_mid.$cAAdZrm4k4UZh9X1vd1bxDgkg7Bo9");
Assert.NotNull(message);
Assert.NotEmpty(message.Id);
Assert.NotEmpty(message.SenderId);
Assert.NotEmpty(message.ReceiverId);
//Assert.NotNull(message.SenderEmail);
//Assert.NotNull(message.FacebookConversationId);
}
public async Task ShouldUpdateConversatonAndSaveChanges()
{
// 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"
};
var conversation = new Conversation {
OriginalId = fbChange.Value.ThreadId
};
Mock <IDependencyResolver> dependencyResolverMock = MockDependecyResolverForTestingUpdateConversation(conversation, fbChange, fbMessage, sender, 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(fbChange.Value.ThreadId)).Returns(conversation);
dependencyResolverMock.Setup(t => t.Resolve <IConversationService>()).Returns(conversationServiceMock.Object);
var strategy = new NewMessageStrategy(dependencyResolverMock.Object);
var uowMock = new Mock <IUnitOfWork>();
var uowManagerMock = new Mock <IUnitOfWorkManager>();
uowManagerMock.Setup(t => t.Current).Returns(uowMock.Object);
strategy.UnitOfWorkManager = uowManagerMock.Object;
var socialAccount = new SocialAccount {
Token = "token", IfConvertMessageToConversation = true, SocialUser = new SocialUser {
Id = 3
}
};
// Act
var processResult = await strategy.Process(socialAccount, fbChange);
// Assert
conversationServiceMock.Verify(t => t.UpdateAsync(It.IsAny <Conversation>()), "Should update conversation to db.");
uowMock.Verify(t => t.SaveChangesAsync(), "Should save changes.");
}
public async Task ShouldAddMessageToUnClosedConversation()
{
// 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"
};
var conversation = new Conversation {
OriginalId = fbChange.Value.ThreadId
};
IDependencyResolver dependencyResolver = MockDependecyResolverForTestingUpdateConversation(conversation, fbChange, fbMessage, sender, receiver).Object;
var strategy = new NewMessageStrategy(dependencyResolver);
strategy.UnitOfWorkManager = MockUnitOfWorkManager().Object;
var socialAccount = new SocialAccount {
Token = "token", IfConvertMessageToConversation = true, SocialUser = new SocialUser {
Id = 3
}
};
// Act
var processResult = await strategy.Process(socialAccount, fbChange);
// Assert
var message = processResult.UpdatedConversations.First().Messages.FirstOrDefault(t => t.OriginalId == fbMessage.Id);
Assert.NotNull(message);
Assert.Equal(MessageSource.FacebookMessage, message.Source);
Assert.Equal(fbMessage.Id, message.OriginalId);
Assert.Equal(sender.Id, message.SenderId);
Assert.Equal(receiver.Id, message.ReceiverId);
Assert.Equal(fbMessage.Content, message.Content);
}
public int CopyFromRealtimeDB(string business_id, string thread_id, Paging page)
{
int count = 0;
foreach (var tt in _fbMessageRepository.GetMessagesByThread(business_id, page, thread_id).Result)
{
FbMessage t = tt.Object;
count++;
Message m = new Message();
m.id = t.id;
m.created_time = t.created_time;
m.updated_time = t.updated_time <= DateTime.MinValue ? null : t.updated_time;
m.ext_id = t.ext_id;
m.url = t.url;
m.file_name = t.file_name;
m.size = t.size;
m.subject = t.subject;
m.message = t.message;
m.agent_id = t.agent_id;
m.thread_id = t.thread_id;
m.conversation_ext_id = t.conversation_ext_id;
m.sender_id = t.sender_id;
m.sender_ext_id = t.sender_ext_id;
m.sender_name = t.sender_name;
m.sender_avatar = t.sender_avatar;
m.recipient_id = t.recipient_id;
m.recipient_ext_id = t.recipient_ext_id;
m.recipient_avatar = t.recipient_avatar;
m.recipient_name = t.recipient_name;
m.author = t.author;
m.customer_id = t.customer_id;
m.type = t.type;
m.timestamp = t.timestamp > 9999999999 ? t.timestamp / 1000 : t.timestamp;
m.business_id = t.business_id;
m.channel_id = t.channel_id;
m.channel_ext_id = t.channel_ext_id;
m.channel_type = t.channel_type;
//m.urls = JsonConvert.SerializeObject(t.urls);
_messageRepository.Upsert(m);
}
return(count);
}
public void ShouldConvertFbMessageToEntity()
{
// Arrange
var fbAttachment = MakeFbAttachment(1);
var fbMessage = new FbMessage
{
Id = "Test_Id",
Content = "Test Message",
SendTime = new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc),
Attachments = new List <FbMessageAttachment>
{
fbAttachment
}
};
var sender = new SocialUser {
Id = 2
};
var receiver = new SocialUser {
Id = 3
};
var conveter = new FacebookConverter();
// Act
Message message = conveter.ConvertMessage(fbMessage, sender, receiver);
// Assert
Assert.Equal(fbMessage.Id, message.OriginalId);
Assert.Equal(fbMessage.SendTime, message.SendTime);
Assert.Equal(fbMessage.Content, message.Content);
Assert.Equal(MessageSource.FacebookMessage, message.Source);
Assert.Equal(sender.Id, message.SenderId);
Assert.Equal(receiver.Id, message.ReceiverId);
Assert.Equal(fbAttachment.Id, message.Attachments[0].OriginalId);
Assert.Equal(fbAttachment.Name, message.Attachments[0].Name);
Assert.Equal(fbAttachment.MimeType, message.Attachments[0].MimeType);
Assert.Equal(fbAttachment.Type, message.Attachments[0].Type);
Assert.Equal(fbAttachment.Size, message.Attachments[0].Size);
Assert.Equal(fbAttachment.Url, message.Attachments[0].Url);
Assert.Equal(fbAttachment.PreviewUrl, message.Attachments[0].PreviewUrl);
}
public async Task ShouldUpdateConversatonWhenAddNewMessageToUnClosedConversation()
{
// 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"
};
var conversation = new Conversation {
OriginalId = fbChange.Value.ThreadId
};
IDependencyResolver dependencyResolver = MockDependecyResolverForTestingUpdateConversation(conversation, fbChange, fbMessage, sender, receiver).Object;
var strategy = new NewMessageStrategy(dependencyResolver);
strategy.UnitOfWorkManager = MockUnitOfWorkManager().Object;
var socialAccount = new SocialAccount {
Token = "token", IfConvertMessageToConversation = true, SocialUser = new SocialUser {
Id = 3
}
};
// Act
var processResult = await strategy.Process(socialAccount, fbChange);
// Assert
Assert.Equal(1, processResult.UpdatedConversations.Count());
Assert.Equal(false, conversation.IfRead);
Assert.Equal(ConversationStatus.PendingInternal, conversation.Status);
Assert.Equal(sender.Id, conversation.LastMessageSenderId);
Assert.Equal(fbMessage.SendTime, conversation.LastMessageSentTime);
}
public async Task ShouldAddMessageWhenCreateNewConversation()
{
// Arrange
var fbChange = new FbHookChange {
Value = new FbHookChangeValue {
ThreadId = "original_conversation_id"
}
};
var fbMessage = new FbMessage {
Id = "fb_1", Link = "http://test.com", 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
var messages = processResult.NewConversations.First().Messages;
Assert.Equal(1, messages.Count());
var message = messages.First();
Assert.Equal(MessageSource.FacebookMessage, message.Source);
Assert.Equal(fbMessage.Id, message.OriginalId);
Assert.Equal(sender.Id, message.SenderId);
Assert.Equal(receiver.Id, message.ReceiverId);
Assert.Equal(fbMessage.Content, message.Content);
}
public async Task ShouldSetValueForNewConversation()
{
// 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
var converssation = processResult.NewConversations.First();
Assert.Equal(ConversationSource.FacebookMessage, converssation.Source);
Assert.Equal(ConversationStatus.New, converssation.Status);
Assert.Equal("original_conversation_id", converssation.OriginalId);
Assert.Equal(ConversationPriority.Normal, converssation.Priority);
Assert.Equal(1, converssation.LastMessageSenderId);
Assert.Equal(fbMessage.SendTime, converssation.LastMessageSentTime);
Assert.Equal("Test_Message", converssation.Subject);
}
public async Task ShouldNotUpdateLastMessageIfMessageIsOlderThanExistingMessage()
{
// 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 = new DateTime(1999, 1, 1, 0, 0, 0, DateTimeKind.Utc)
};
var sender = new SocialUser {
Id = 1, OriginalId = "user_1"
};
var receiver = new SocialUser {
Id = 2, OriginalId = "user_2"
};
var conversation = new Conversation {
OriginalId = fbChange.Value.ThreadId, LastMessageSenderId = 888, LastMessageSentTime = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc)
};
IDependencyResolver dependencyResolver = MockDependecyResolverForTestingUpdateConversation(conversation, fbChange, fbMessage, sender, receiver).Object;
var strategy = new NewMessageStrategy(dependencyResolver);
strategy.UnitOfWorkManager = MockUnitOfWorkManager().Object;
var socialAccount = new SocialAccount {
Token = "token", IfConvertMessageToConversation = true, SocialUser = new SocialUser {
Id = 3
}
};
// Act
var processResult = await strategy.Process(socialAccount, fbChange);
// Assert
Assert.Equal(888, conversation.LastMessageSenderId);
Assert.Equal(new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc), conversation.LastMessageSentTime);
}
public IEnumerable <FbMessage> GetMessages(FbMessageFolder folder)
{
Authenticate();
string call_id = GetNextCallNr();
var query = new StringBuilder();
query.Append("{");
query.Append("\"threads\":\"SELECT thread_id, subject, recipients, updated_time, parent_message_id, parent_thread_id, unread FROM thread WHERE folder_id = 0\",");
query.Append("\"messages\":\"SELECT thread_id, body, author_id, created_time, attachment FROM message WHERE thread_id IN (SELECT thread_id FROM #threads)\",");
query.Append("\"users\":\"SELECT uid, name FROM user WHERE uid IN (SELECT author_id FROM #messages)\"");
query.Append("}");
Dictionary <string, string> requestParams = new Dictionary <string, string>();
requestParams.Add("method", "fql.multiquery");
requestParams.Add("api_key", apiKey);
requestParams.Add("session_key", sessionKey);
requestParams.Add("call_id", call_id);
requestParams.Add("v", "1.0");
requestParams.Add("queries", query.ToString());
var result = channel.ExecuteMultiQueries(apiKey, sessionKey, call_id, GenerateSignature(requestParams, sessionSecret), query.ToString());
XNamespace ns = result.GetDefaultNamespace();
// Fire one call to retreive names for all recipients in messages
var uids = result.Descendants(ns + "recipients").Elements(ns + "uid").Select(n => n.Value).ToArray();
var addresses = GetAddresses(String.Join(", ", uids)).ToList();
foreach (XElement messageElement in result.Descendants(ns + "message"))
{
FbMessage message = new FbMessage();
try
{
var threadid = messageElement.Element(ns + "thread_id").Value;
var from = messageElement.Element(ns + "author_id").Value;
//if (String.IsNullOrEmpty(from))
// System.Diagnostics.Debugger.Break();
// Find the associated thread which contains the subject and readstate
var threadElement = result.Descendants(ns + "thread").FirstOrDefault(t => t.Element(ns + "thread_id").Value == threadid);
var senderElement = result.Descendants(ns + "user").FirstOrDefault(u => u.Element(ns + "uid").Value == from);
if (threadElement == null || senderElement == null)
{
Logger.Error("Unable to determine sender for Facebook message, ignoring", LogSource.Channel);
continue;
}
message.ThreadId = threadid;
message.Subject = threadElement.Element(ns + "subject").Value;
message.Body = messageElement.Element(ns + "body").Value;
message.From = new SourceAddress(senderElement.Element(ns + "uid").Value, senderElement.Element(ns + "name").Value);
message.To = new SourceAddressCollection();
message.Read = threadElement.Element(ns + "unread").Value == "0";
message.DateCreated = Int64.Parse(threadElement.Element(ns + "updated_time").Value).ToUnixTime();
foreach (XElement recipientElement in threadElement.Element(ns + "recipients").Elements())
{
message.To.Add(addresses.FirstOrDefault(a => a.Address == recipientElement.Value));
}
message.MessageId = message.ThreadId + message.From.Address;
}
catch (Exception ex)
{
Logger.Error("Unable to retreive mesaage. Result = {0}. Exception = {1}", LogSource.Channel, messageElement.Value, ex);
continue;
}
yield return(message);
}
}
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);
}
