public async void NewMessageUpdateUsersChannelsAsync(MessageVm message)
{
try
{
var usersId = await loadChannelsService.GetChannelUsersIdAsync(message.ConversationId.GetValueOrDefault()).ConfigureAwait(false);
foreach (long userId in usersId)
{
List <ConversationPreviewVm> channels = (await GetUserChannelsAsync(userId).ConfigureAwait(false))?.ToList();
if (channels == null || channels.All(opt => opt.ConversationId != message.ConversationId))
{
channels = (await loadChannelsService.GetUserChannelsPreviewAsync(userId).ConfigureAwait(false))?.ToList();
UpdateUserChannels(userId, channels);
continue;
}
ConversationPreviewVm updatedChannel = channels.FirstOrDefault(opt => opt.ConversationId == message.ConversationId);
if (updatedChannel != null)
{
updatedChannel.LastMessageTime = message.SendingTime;
updatedChannel.PreviewText = message.Text;
updatedChannel.LastMessageId = message.GlobalId;
updatedChannel.Read = false;
updatedChannel.AttachmentType = message.Attachments?.FirstOrDefault()?.Type;
UpdateUserChannels(userId, channels);
}
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public async void UserEditedUpdateUserDialogsAsync(UserVm user)
{
try
{
var userDialogs = await loadDialogsService.GetUserDialogsPreviewAsync(user.Id.GetValueOrDefault()).ConfigureAwait(false);
foreach (var dialog in userDialogs)
{
IEnumerable <ConversationPreviewVm> secondUserDialogs = await GetUserDialogsAsync(dialog.SecondUid.GetValueOrDefault()).ConfigureAwait(false);
ConversationPreviewVm updatedDialog = secondUserDialogs?.FirstOrDefault(opt => opt.SecondUid == user.Id.GetValueOrDefault());
if (updatedDialog != null)
{
updatedDialog.Photo = user.Photo;
updatedDialog.Title = $"{user.NameFirst} {user.NameSecond}";
secondUserDialogs = secondUserDialogs.Where(opt => opt.ConversationId != updatedDialog.ConversationId).Append(updatedDialog);
UpdateUserDialogs(dialog.SecondUid.GetValueOrDefault(), secondUserDialogs);
}
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public async void NewMessageUpdateUserChatsAsync(MessageVm message)
{
try
{
UserVm senderInfo = await loadUsersService.GetUserAsync(message.SenderId.GetValueOrDefault()).ConfigureAwait(false);
IEnumerable <long> usersId = await loadChatsService.GetChatUsersIdAsync(message.ConversationId.GetValueOrDefault()).ConfigureAwait(false);
foreach (long userId in usersId)
{
List <ConversationPreviewVm> cachedChats = (await GetUserChatsAsync(userId).ConfigureAwait(false))?.ToList();
if (cachedChats == null || cachedChats.All(opt => opt.ConversationId != message.ConversationId))
{
cachedChats = (await loadChatsService.GetUserChatPreviewAsync(userId, DateTime.UtcNow.ToUnixTime()).ConfigureAwait(false))?.ToList();
UpdateUserChats(userId, cachedChats);
continue;
}
ConversationPreviewVm updatedChat = cachedChats.FirstOrDefault(opt => opt.ConversationId == message.ConversationId);
if (updatedChat != null)
{
updatedChat.LastMessageSenderId = message.SenderId;
updatedChat.LastMessageTime = message.SendingTime;
updatedChat.LastMessageSenderName = senderInfo.NameFirst;
updatedChat.PreviewText = message.Text;
updatedChat.LastMessageId = message.GlobalId;
updatedChat.Read = false;
updatedChat.AttachmentType = (AttachmentType?)message.Attachments?.FirstOrDefault()?.Type ?? null;
UpdateUserChats(userId, cachedChats);
}
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
private async Task <List <MessageVm> > SendDialogMessagesAsync(IEnumerable <MessageVm> messages)
{
List <MessageDto> resultMessages = new List <MessageDto>();
foreach (var message in messages)
{
message.SenderId = userId;
message.GlobalId = RandomExtensions.NextGuid();
message.ConversationType = ConversationType.Dialog;
await attachmentsService.ThrowIfAttachmentsInvalidAsync(message, false).ConfigureAwait(false);
List <MessageDto> sentMessages = default;
bool saveMessageFlag = true;
if (message.Attachments?.Any() ?? false)
{
var attachment = message.Attachments.FirstOrDefault(opt => opt.Type == AttachmentType.EncryptedMessage);
if (attachment != null)
{
var ecnryptedMessage = ObjectSerializer.JsonToObject <EncryptedMessage>(attachment.Payload.ToString());
saveMessageFlag = ecnryptedMessage.SaveFlag > 0;
}
}
message.SendingTime = DateTime.UtcNow.ToUnixTime();
if (saveMessageFlag)
{
sentMessages = await createMessagesService.CreateDialogMessageAsync(MessageConverter.GetMessageDto(message)).ConfigureAwait(false);
var dialogs = await loadDialogsService.GetUsersDialogsAsync(message.SenderId.Value, message.ReceiverId.Value).ConfigureAwait(false);
var receiverDialog = dialogs.FirstOrDefault(dialog => dialog.FirstUserId == message.ReceiverId);
UsersConversationsCacheService.Instance.NewMessageUpdateUserDialogsAsync(MessageConverter.GetMessageVm(sentMessages[0], current.UserId), receiverDialog.Id);
}
else
{
List <long> dialogsId = await loadDialogsService.GetDialogsIdByUsersIdPairAsync(message.SenderId.GetValueOrDefault(), message.ReceiverId.GetValueOrDefault()).ConfigureAwait(false);
sentMessages = dialogsId.Select(opt =>
{
MessageDto tempMessage = new MessageDto(MessageConverter.GetMessageDto(message))
{
ConversationId = opt
};
return(tempMessage);
})
.ToList();
}
if (!sentMessages.Any())
{
throw new MessageException();
}
conversationsNoticeService.SendNewMessageNoticeToDialogUsers(
sentMessages,
current,
message.ReceiverId.GetValueOrDefault(),
saveMessageFlag);
nodeNoticeService.SendNewDialogMessageNodeNoticeAsync(MessageConverter.GetMessageVm(sentMessages.FirstOrDefault(), current.UserId));
IEnumerable <ConversationPreviewVm> senderDialogs = await UsersConversationsCacheService.Instance.GetUserConversationsAsync(userId, ConversationType.Dialog).ConfigureAwait(false);
if (senderDialogs == null || !senderDialogs.Any(opt => opt.SecondUid == message.ReceiverId))
{
senderDialogs = await loadDialogsService.GetUserDialogsPreviewAsync(userId).ConfigureAwait(false);
UsersConversationsCacheService.Instance.UpdateUserConversations(userId, senderDialogs);
}
ConversationPreviewVm currentDialog = senderDialogs.FirstOrDefault(dialog => dialog.SecondUid == message.ReceiverId);
resultMessages.Add(sentMessages.FirstOrDefault(mess => mess.ConversationId == currentDialog.ConversationId));
}
return(MessageConverter.GetMessagesVm(resultMessages, current.UserId));
}
public async void NewMessageUpdateUserDialogsAsync(MessageVm message, long receiverDialogId)
{
try
{
List <ConversationPreviewVm> senderDialogs = (await GetUserDialogsAsync(message.SenderId.Value).ConfigureAwait(false))?.ToList();
IEnumerable <ConversationPreviewVm> receiverDialogs = await GetUserDialogsAsync(message.ReceiverId.Value).ConfigureAwait(false);
if (senderDialogs != null)
{
ConversationPreviewVm changedSenderDialog = senderDialogs
.FirstOrDefault(opt => opt.ConversationId == message.ConversationId);
if (changedSenderDialog != null)
{
changedSenderDialog.LastMessageSenderId = message.SenderId;
changedSenderDialog.LastMessageTime = message.SendingTime;
changedSenderDialog.PreviewText = message.Text;
changedSenderDialog.AttachmentType = message.Attachments?.FirstOrDefault()?.Type;
changedSenderDialog.Read = false;
changedSenderDialog.LastMessageId = message.GlobalId;
}
else
{
senderDialogs = (await loadDialogsService.GetUserDialogsPreviewAsync(message.SenderId.Value).ConfigureAwait(false)).ToList();
}
}
else
{
senderDialogs = (await loadDialogsService.GetUserDialogsPreviewAsync(message.SenderId.Value).ConfigureAwait(false)).ToList();
}
if (receiverDialogs != null)
{
ConversationPreviewVm changedReceiverDialog = receiverDialogs
.FirstOrDefault(opt => opt.ConversationId == receiverDialogId);
if (changedReceiverDialog != null)
{
changedReceiverDialog.LastMessageSenderId = message.SenderId;
changedReceiverDialog.LastMessageTime = message.SendingTime;
changedReceiverDialog.PreviewText = message.Text;
changedReceiverDialog.AttachmentType = message.Attachments?.FirstOrDefault()?.Type;
changedReceiverDialog.Read = false;
changedReceiverDialog.LastMessageId = message.GlobalId;
receiverDialogs = receiverDialogs.Where(opt => opt.ConversationId != changedReceiverDialog.ConversationId);
receiverDialogs = receiverDialogs.Append(changedReceiverDialog);
}
else
{
receiverDialogs = await loadDialogsService.GetUserDialogsPreviewAsync(message.ReceiverId.Value).ConfigureAwait(false);
}
}
else
{
receiverDialogs = await loadDialogsService.GetUserDialogsPreviewAsync(message.ReceiverId.Value).ConfigureAwait(false);
}
UpdateUserDialogs(message.SenderId.Value, senderDialogs.OrderByDescending(opt => opt.LastMessageTime));
UpdateUserDialogs(message.ReceiverId.Value, receiverDialogs.OrderByDescending(opt => opt.LastMessageTime));
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
