public async Task GetDialogsIdByUsersIdPair()
{
var dialog = fillTestDbHelper.Dialogs.FirstOrDefault();
var mirrorDialog = fillTestDbHelper.Dialogs.FirstOrDefault(opt => opt.FirstUID == dialog.SecondUID && opt.SecondUID == dialog.FirstUID);
var dialogsIds = await loadDialogsService.GetDialogsIdByUsersIdPairAsync(dialog.FirstUID, dialog.SecondUID);
Assert.True(dialogsIds.Contains(dialog.Id) && dialogsIds.Contains(mirrorDialog.Id));
}
public async Task <bool> IsDialogMessageExistsAsync(Guid messageId, long senderId, long receiverId)
{
using (MessengerDbContext context = contextFactory.Create())
{
IEnumerable <long> dialogsId = await loadDialogsService.GetDialogsIdByUsersIdPairAsync(senderId, receiverId).ConfigureAwait(false);
if (dialogsId == null)
{
return(false);
}
return(await context.Messages
.Where(opt => opt.ExpiredAt > DateTime.UtcNow.ToUnixTime() || opt.ExpiredAt == null)
.AnyAsync(message => message.GlobalId == messageId &&
message.DialogId == dialogsId.FirstOrDefault())
.ConfigureAwait(false));
}
}
public async Task HandleAsync()
{
switch (notice.ConversationType)
{
case ConversationType.Dialog:
{
List <long> dialogsId = await loadDialogsService.GetDialogsIdByUsersIdPairAsync(notice.RequestingUserId, notice.ConversationId).ConfigureAwait(false);
await deleteDialogsService.DeleteDialogAsync(dialogsId.FirstOrDefault(), notice.RequestingUserId).ConfigureAwait(false);
UsersConversationsCacheService.Instance.UpdateUsersDialogsAsync(notice.RequestingUserId, notice.ConversationId);
}
break;
case ConversationType.Chat:
{
var usersId = await loadChatsService.GetChatUsersIdAsync(notice.ConversationId).ConfigureAwait(false);
await deleteChatsService.DeleteChatAsync(notice.ConversationId, notice.RequestingUserId).ConfigureAwait(false);
UsersConversationsCacheService.Instance.UpdateUsersChatsAsync(usersId);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateDeleteChatSegmentAsync(notice.ConversationId, notice.NodeId).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
}
break;
case ConversationType.Channel:
{
var usersId = await loadChannelsService.GetChannelUsersIdAsync(notice.ConversationId).ConfigureAwait(false);
await deleteChannelsService.DeleteChannelAsync(notice.ConversationId, notice.RequestingUserId).ConfigureAwait(false);
UsersConversationsCacheService.Instance.UpdateUsersChannelsAsync(usersId);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateDeleteChannelSegmentAsync(notice.ConversationId, notice.NodeId).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
}
break;
}
}
private async Task <bool> ValidateForwardedMessagesAttachment(AttachmentVm forwardedMessagesAttachment, long?userId, bool anotherNodeMessage)
{
ForwardedMessagesInfo fMessagesInfo = null;
if (forwardedMessagesAttachment.Payload is string)
{
fMessagesInfo = ObjectSerializer.JsonToObject <ForwardedMessagesInfo>(forwardedMessagesAttachment.Payload.ToString());
}
else if (forwardedMessagesAttachment.Payload is List <MessageVm> messages)
{
if (!messages.Any())
{
return(true);
}
var message = messages.FirstOrDefault();
if (anotherNodeMessage)
{
await _createMessagesService.SaveForwardedMessagesAsync(MessageConverter.GetMessagesDto(messages)).ConfigureAwait(false);
forwardedMessagesAttachment.Payload = new ForwardedMessagesInfo(
messages.Select(opt => opt.GlobalId.Value),
message.ConversationType == ConversationType.Dialog
? (await _loadDialogsService.GetDialogsIdByUsersIdPairAsync(message.SenderId.Value, message.ReceiverId.Value).ConfigureAwait(false)).FirstOrDefault()
: message.ConversationId,
message.ConversationType);
return(true);
}
switch (message.ConversationType)
{
case ConversationType.Dialog:
{
var dialogsId = await _loadDialogsService.GetDialogsIdByUsersIdPairAsync(message.SenderId.Value, message.ReceiverId.Value).ConfigureAwait(false);
if (dialogsId.Any())
{
fMessagesInfo = new ForwardedMessagesInfo(messages.Select(opt => opt.GlobalId.Value), dialogsId[0], ConversationType.Dialog);
}
else
{
fMessagesInfo = new ForwardedMessagesInfo(messages.Select(opt => opt.GlobalId.Value), null, ConversationType.Dialog);
}
}
break;
case ConversationType.Chat:
{
var chat = await _loadChatsService.GetChatByIdAsync(message.ConversationId.GetValueOrDefault()).ConfigureAwait(false);
if (chat.Type == ChatType.Private)
{
return(false);
}
}
break;
case ConversationType.Channel:
fMessagesInfo = new ForwardedMessagesInfo(messages.Select(opt => opt.GlobalId.Value), message.ConversationId.GetValueOrDefault(), message.ConversationType);
break;
}
}
else
{
fMessagesInfo = ObjectSerializer.JsonToObject <ForwardedMessagesInfo>(ObjectSerializer.ObjectToJson(forwardedMessagesAttachment.Payload));
}
if (fMessagesInfo == null)
{
return(false);
}
return(await _loadMessagesService.CanUserGetMessageAsync(fMessagesInfo.ConversationType, fMessagesInfo.ConversationId, userId).ConfigureAwait(false));
}
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));
}
