public async Task HandleAsync()
{
try
{
var chatUsers = await updateChatsService.EditChatUsersAsync(notice.ChatUsers, notice.ChatId, notice.RequestedUserId).ConfigureAwait(false);
var bannedUsers = chatUsers.Where(opt => opt.Banned == true);
if (!bannedUsers.IsNullOrEmpty())
{
foreach (var user in bannedUsers)
{
var systemMessageInfo = SystemMessageInfoFactory.CreateUserBannedMessageInfo(user.UserId);
var message = await systemMessagesService.CreateMessageAsync(ConversationType.Chat, user.ChatId.Value, systemMessageInfo);
conversationsNoticeService.SendSystemMessageNoticeAsync(message);
}
}
var deletedUsers = chatUsers.Where(opt => opt.Deleted == true);
if (!deletedUsers.IsNullOrEmpty())
{
foreach (var user in deletedUsers)
{
var systemMessageInfo = SystemMessageInfoFactory.CreateUserRemovedMessageInfo(user.UserId);
var message = await systemMessagesService.CreateMessageAsync(ConversationType.Chat, user.ChatId.Value, systemMessageInfo);
conversationsNoticeService.SendSystemMessageNoticeAsync(message);
}
}
}
catch (UserIsNotInConversationException)
{
ChatVm newChat = await nodeRequestSender.GetFullChatInformationAsync(notice.ChatId, node).ConfigureAwait(false);
await crossNodeService.NewOrEditChatAsync(newChat).ConfigureAwait(false);
}
catch (ConversationNotFoundException ex)
{
ChatVm newChat = await nodeRequestSender.GetFullChatInformationAsync(ex.ConversationId, node).ConfigureAwait(false);
await crossNodeService.NewOrEditChatAsync(newChat).ConfigureAwait(false);
}
conversationsNoticeService.SendChangeChatUsersNoticeAsync(notice.ChatUsers, notice.ChatId);
ChatVm chat = await loadChatsService.GetChatByIdAsync(notice.ChatId).ConfigureAwait(false);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateChangeUsersChatSegmetAsync(
notice.ChatUsers,
notice.ChatId,
notice.RequestedUserId,
node.Node.Id,
chat.Type,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
}
public async Task HandleAsync()
{
foreach (var chat in notice.Chats)
{
var editableChat = await loadChatsService.GetChatByIdAsync(chat.Id.Value).ConfigureAwait(false);
var editedChat = await crossNodeService.NewOrEditChatAsync(chat).ConfigureAwait(false);
if (editableChat.Name != editedChat.Name)
{
var systemMessageInfo = SystemMessageInfoFactory.CreateNameChangedMessageInfo(editableChat.Name, editedChat.Name);
var message = await systemMessagesService.CreateMessageAsync(ConversationType.Chat, editedChat.Id.Value, systemMessageInfo);
conversationsNoticeService.SendSystemMessageNoticeAsync(message);
}
List <BlockSegmentVm> segments =
await BlockSegmentsService.Instance.CreateEditPrivateChatSegmentsAsync(
editedChat,
nodeConnection.Node.Id,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
if (segments.Any())
{
nodeNoticeService.SendBlockSegmentsNodeNoticeAsync(segments.ToList());
BlockGenerationHelper.Instance.AddSegments(segments);
}
editedChat.Users = null;
conversationsNoticeService.SendEditChatNoticeAsync(editedChat, null);
UsersConversationsCacheService.Instance.UpdateUsersChatsAsync(await loadChatsService.GetChatUsersIdAsync(editedChat.Id.GetValueOrDefault()).ConfigureAwait(false));
}
}
public async Task HandleAsync()
{
foreach (var chat in notice.Chats)
{
await crossNodeService.NewOrEditChatAsync(chat).ConfigureAwait(false);
conversationsNoticeService.SendNewChatNoticeAsync(chat, null);
UsersConversationsCacheService.Instance.UpdateUsersChatsAsync(chat.Users.Select(opt => opt.UserId));
List <BlockSegmentVm> segments =
await BlockSegmentsService.Instance.CreateNewPrivateChatSegmentsAsync(
chat,
NodeSettings.Configs.Node.Id,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
if (segments.Any())
{
nodeNoticeService.SendBlockSegmentsNodeNoticeAsync(segments.ToList());
foreach (var segment in segments)
{
BlockGenerationHelper.Instance.AddSegment(segment);
}
}
}
}
public async Task HandleAsync()
{
ChatVm chat;
try
{
chat = await updateChatsService.AddUsersToChatAsync(notice.UsersId, notice.ChatId, notice.RequestorId).ConfigureAwait(false);
}
catch (AddUserChatException)
{
chat = await nodeRequestSender.GetFullChatInformationAsync(notice.ChatId, node).ConfigureAwait(false);
await crossNodeService.NewOrEditChatAsync(chat).ConfigureAwait(false);
}
catch (ConversationNotFoundException ex)
{
chat = await nodeRequestSender.GetFullChatInformationAsync(ex.ConversationId, node).ConfigureAwait(false);
await crossNodeService.NewOrEditChatAsync(chat).ConfigureAwait(false);
UsersConversationsCacheService.Instance.UpdateUsersChatsAsync(notice.UsersId);
}
foreach (var userId in notice.UsersId)
{
var message = await systemMessagesService.CreateMessageAsync(ConversationType.Chat, chat.Id.Value, SystemMessageInfoFactory.CreateUserAddedMessageInfo(userId));
conversationsNoticeService.SendSystemMessageNoticeAsync(message);
}
conversationsNoticeService.SendNewUsersAddedToChatNoticeAsync(chat, null);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateAddUsersChatSegmentAsync(
notice.UsersId,
notice.ChatId,
notice.RequestorId,
node.Node.Id,
chat.Type,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
}
public async Task HandleAsync()
{
try
{
foreach (var chat in response.Chats)
{
await crossNodeService.NewOrEditChatAsync(chat).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
private async Task HandleChatMessagesAsync(IEnumerable <MessageVm> messages)
{
foreach (var message in messages)
{
if (NodeData.Instance.RoutedMessagesId.Contains(message.GlobalId.GetValueOrDefault()))
{
continue;
}
if (message.Attachments != null)
{
foreach (var attachment in message.Attachments)
{
attachment.MessageId = 0;
}
await attachmentsService.DownloadAttachmentsPayloadAsync(message.Attachments, current).ConfigureAwait(false);
await attachmentsService.ThrowIfAttachmentsInvalidAsync(message, true).ConfigureAwait(false);
}
MessageDto sentMessage;
try
{
sentMessage = await createMessagesService.CreateChatMessageAsync(MessageConverter.GetMessageDto(message), message.SenderId.GetValueOrDefault()).ConfigureAwait(false);
}
catch (ConversationNotFoundException ex)
{
ChatVm chat = await nodeRequestSender.GetFullChatInformationAsync(ex.ConversationId, current).ConfigureAwait(false);
await crossNodeService.NewOrEditChatAsync(chat).ConfigureAwait(false);
sentMessage = await createMessagesService.CreateChatMessageAsync(MessageConverter.GetMessageDto(message), message.SenderId.GetValueOrDefault()).ConfigureAwait(false);
}
catch (UserIsNotInConversationException ex)
{
List <ChatUserVm> chatUsers = await nodeRequestSender.GetChatUsersInformationAsync(
new List <long> {
ex.UserId.GetValueOrDefault()
},
ex.ChatId.GetValueOrDefault(),
current).ConfigureAwait(false);
await crossNodeService.AddChatUsersAsync(chatUsers).ConfigureAwait(false);
sentMessage = await createMessagesService.CreateChatMessageAsync(MessageConverter.GetMessageDto(message), message.SenderId.GetValueOrDefault()).ConfigureAwait(false);
}
SendNotificationsAsync(sentMessage);
NodeData.Instance.RoutedMessagesId.Add(message.GlobalId.GetValueOrDefault());
}
}
public async Task <Response> CreateResponseAsync()
{
try
{
List <ChatUserVm> chatUsers = await loadChatsService.GetChatUsersAsync(
request.ChatId,
clientConnection.UserId.GetValueOrDefault(),
100,
request.NavigationUserId.GetValueOrDefault()).ConfigureAwait(false);
if (!chatUsers.Any(user => user.UserRole == UserRole.Creator))
{
var nodesIds = await loadChatsService.GetChatNodeListAsync(request.ChatId).ConfigureAwait(false);
var nodeConnection = connectionsService.GetNodeConnection(nodesIds.FirstOrDefault(id => id != NodeSettings.Configs.Node.Id));
if (nodeConnection != null)
{
var chat = await nodeRequestSender.GetFullChatInformationAsync(request.ChatId, nodeConnection).ConfigureAwait(false);
if (chat != null)
{
await crossNodeService.NewOrEditChatAsync(chat).ConfigureAwait(false);
chatUsers = chat.Users?.Take(100).ToList();
}
}
}
chatUsers.ForEach(item =>
{
if (item.UserInfo != null)
{
item.UserInfo = privacyService.ApplyPrivacySettings(
item.UserInfo,
item.UserInfo.Privacy);
}
});
return(new ChatUsersResponse(request.RequestId, chatUsers));
}
catch (GetUsersException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "User does not have access to the chat.", ErrorCode.PermissionDenied));
}
}
