public async Task <Response> CreateResponseAsync()
{
try
{
ChannelVm editableChannel = await loadChannelsService.GetChannelByIdAsync(request.Channel.ChannelId.Value);
ChannelVm channel = await updateChannelsService.EditChannelAsync(request.Channel, clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
if (editableChannel.ChannelName != channel.ChannelName)
{
var systemMessageInfo = SystemMessageInfoFactory.CreateNameChangedMessageInfo(editableChannel.ChannelName, channel.ChannelName);
var message = await systemMessagesService.CreateMessageAsync(ObjectsLibrary.Enums.ConversationType.Channel, channel.ChannelId.Value, systemMessageInfo);
conversationsNoticeService.SendSystemMessageNoticeAsync(message);
}
IEnumerable <long> usersId = await loadChannelsService.GetChannelUsersIdAsync(channel.ChannelId.GetValueOrDefault()).ConfigureAwait(false);
conversationsNoticeService.SendChannelNoticeAsync(channel, usersId.ToList(), clientConnection);
UsersConversationsCacheService.Instance.UpdateUsersChannelsAsync(usersId.ToList());
nodeNoticeService.SendChannelNodeNoticeAsync(channel, clientConnection.UserId.GetValueOrDefault(), null);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateChannelSegmentAsync(channel, NodeSettings.Configs.Node.Id).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
return(new ChannelsResponse(request.RequestId, channel));
}
catch (PermissionDeniedException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "Channel not found or user does not have access to the channel.", ObjectsLibrary.Enums.ErrorCode.PermissionDenied));
}
}
public async Task <Response> CreateResponseAsync()
{
try
{
List <long> deletedFilesId =
await filesService.DeleteFilesAsync(request.FilesId, clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
foreach (long fileId in deletedFilesId)
{
BlockSegmentVm segment =
await BlockSegmentsService.Instance.CreateDeleteFileSegmentAsync(fileId,
NodeSettings.Configs.Node.Id).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
}
nodeNoticeService.SendDeleteFilesNodeNoticeAsync(deletedFilesId.ToList());
return(new ResultResponse(request.RequestId));
}
catch (ObjectDoesNotExistsException ex)
{
Logger.WriteLog(ex);
return(new ResultResponse(request.RequestId, "Files not found.", ObjectsLibrary.Enums.ErrorCode.DeleteFilesProblem));
}
}
public async Task <Response> CreateResponseAsync()
{
try
{
request.Channel.ChannelId = null;
request.Channel.Tag = null;
ChannelVm channel = await createChannelsService.CreateChannelAsync(request.Channel, clientConnection.UserId.GetValueOrDefault(), request.Subscribers).ConfigureAwait(false);
List <long> usersId = await loadChannelsService.GetChannelUsersIdAsync(channel.ChannelId.GetValueOrDefault()).ConfigureAwait(false);
conversationsNoticeService.SendChannelNoticeAsync(channel, usersId, clientConnection);
UsersConversationsCacheService.Instance.UpdateUsersChannelsAsync(usersId);
nodeNoticeService.SendChannelNodeNoticeAsync(channel, clientConnection.UserId.Value, request.Subscribers);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateChannelSegmentAsync(channel, NodeSettings.Configs.Node.Id).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
return(new ChannelsResponse(request.RequestId, channel));
}
catch (UserNotFoundException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "Users not found.", ErrorCode.ObjectDoesNotExists));
}
catch (UserBlockedException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "The user is blacklisted by another user.", ErrorCode.UserBlocked));
}
}
private async Task HandleEditChatBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
EditChatBlockData blockData = (EditChatBlockData)segment.PublicData;
var editedChat = await _context.Chats.FirstOrDefaultAsync(chat => chat.Id == blockData.Chat.Id).ConfigureAwait(false);
if (editedChat != null)
{
editedChat = ChatConverter.GetChat(editedChat, ChatConverter.GetChatDto(blockData.Chat));
_context.Chats.Update(editedChat);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleEditChatBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
public async Task <Response> CreateResponseAsync()
{
try
{
List <long> usersId = await updateUsersService.DeleteUsersFromBlackListAsync(request.UsersId, clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
if (usersId.Any())
{
nodeNoticeService.SendUsersRemovedFromBlacklistNodeNoticeAsync(usersId.ToList(), clientConnection.UserId.GetValueOrDefault());
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateUsersRemovedFromUserBlacklistSegmentAsync(
usersId,
clientConnection.UserId.GetValueOrDefault(),
NodeSettings.Configs.Node.Id,
NodeData.Instance.NodeKeys.PrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
UsersConversationsCacheService.Instance.UpdateUsersDialogsAsync(usersId.Append(clientConnection.UserId.GetValueOrDefault()));
nodeNoticeService.SendBlockSegmentsNodeNoticeAsync(new List <BlockSegmentVm> {
segment
});
}
return(new ResultResponse(request.RequestId));
}
catch (ObjectDoesNotExistsException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "Users not found.", ErrorCode.ObjectDoesNotExists));
}
}
private async Task HandleNewChatBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
NewChatBlockData newChatBlockData = (NewChatBlockData)segment.PublicData;
if (!await _context.Chats.AnyAsync(chat => chat.Id == newChatBlockData.Chat.Id).ConfigureAwait(false))
{
Chat newChat = ChatConverter.GetChat(newChatBlockData.Chat);
await _context.Chats.AddAsync(newChat).ConfigureAwait(false);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleNewChatBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
private async Task HandleDeleteUserKeyBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
DeleteUserKeysBlockData blockData = (DeleteUserKeysBlockData)segment.PublicData;
var keysCondition = PredicateBuilder.New <Key>();
keysCondition = blockData.KeysId.Aggregate(keysCondition,
(current, value) => current.Or(opt => opt.KeyId == value && opt.UserId == blockData.UserId).Expand());
var keys = await _context.Keys.Where(keysCondition).ToListAsync().ConfigureAwait(false);
if (keys.Any())
{
_context.Keys.RemoveRange(keys);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleDeleteUserKeyBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
private async Task HandleNewFileBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
if (TryDecryptPrivateData <FilePrivateData>(segment, out var filePrivateData))
{
var fileInfo = _context.FilesInfo
.FirstOrDefaultAsync(file => file.Id == filePrivateData.File.FileId && file.NumericId == file.NumericId);
if (fileInfo == null)
{
await _context.FilesInfo.AddAsync(new FileInfo(
filePrivateData.File,
filePrivateData.File.Url,
filePrivateData.File.UploaderId.GetValueOrDefault())).ConfigureAwait(false);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleNewFileBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
private async Task HandleDeleteFileBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
DeleteFileBlockData blockData = (DeleteFileBlockData)segment.PublicData;
var fileInfo = await _context.FilesInfo.FirstOrDefaultAsync(file => file.NumericId == blockData.FileId).ConfigureAwait(false);
if (fileInfo != null)
{
fileInfo.Deleted = true;
_context.FilesInfo.Update(fileInfo);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleDeleteFileBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
private async Task HandleEditNodeBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
EditNodeBlockData blockData = (EditNodeBlockData)segment.PublicData;
var editedNode = NodeConverter.GetNode(blockData.Node);
if (await _context.Nodes.AnyAsync(node => node.Id == editedNode.Id).ConfigureAwait(false))
{
_context.Nodes.Attach(editedNode);
_context.Nodes.Update(editedNode);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleEditNodeBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
private async Task HandleRemoveNodeBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
DeleteNodeBlockData blockData = (DeleteNodeBlockData)segment.PublicData;
var deletedNode = await _context.Nodes
.Include(node => node.DomainNodes)
.FirstOrDefaultAsync(node => node.Id == segment.NodeId).ConfigureAwait(false);
if (deletedNode != null)
{
deletedNode.DomainNodes = null;
_context.Nodes.Update(deletedNode);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleRemoveNodeBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
private async Task HandleNodeChangedBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
UserNodeChangedBlockData blockData = (UserNodeChangedBlockData)segment.PublicData;
var user = await _context.Users.FindAsync(blockData.UserId).ConfigureAwait(false);
if (user != null)
{
user.NodeId = blockData.NodeId;
_context.Users.Update(user);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleNodeChangedBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
private async Task HandleRemovedFromBlacklistBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
if (TryDecryptPrivateData <UsersRemovedFromUserBlacklistBlockData>(segment, out var blockData))
{
var blockedCondition = PredicateBuilder.New <BadUser>();
blockedCondition = blockData.UsersId.Aggregate(blockedCondition,
(current, value) => current.Or(blocked => blocked.BadUid == value && blocked.Uid == blockData.UserId).Expand());
List <BadUser> badUsers = await _context.BadUsers.Where(blockedCondition).ToListAsync().ConfigureAwait(false);
_context.BadUsers.RemoveRange(badUsers);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleRemovedFromBlacklistBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
private async Task HandleChannelBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
ChannelBlockData blockData = (ChannelBlockData)segment.PublicData;
var channel = await _context.Channels.FirstOrDefaultAsync(opt => opt.ChannelId == blockData.Channel.ChannelId).ConfigureAwait(false);
if (channel == null)
{
channel = ChannelConverter.GetChannel(blockData.Channel);
await _context.Channels.AddAsync(channel).ConfigureAwait(false);
}
else
{
channel = ChannelConverter.GetChannel(channel, blockData.Channel);
_context.Channels.Update(channel);
}
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleChannelBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
private async Task HandleNewUserKeysBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
NewUserKeysBlockData blockData = (NewUserKeysBlockData)segment.PublicData;
var keysCondition = PredicateBuilder.New <Key>();
keysCondition = blockData.Keys.Aggregate(keysCondition,
(current, value) => current.Or(opt => opt.KeyId == value.KeyId && opt.UserId == value.UserId).Expand());
var existingKeys = await _context.Keys.Where(keysCondition).ToListAsync().ConfigureAwait(false);
var nonExistingKeys = blockData.Keys.Where(key => !existingKeys.Any(opt => opt.KeyId == key.KeyId && opt.UserId == blockData.UserId));
if (nonExistingKeys.Any())
{
var newKeys = KeyConverter.GetKeys(nonExistingKeys);
await _context.Keys.AddRangeAsync(newKeys).ConfigureAwait(false);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleNewUserKeysBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
private async Task HandleDeleteChatBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
DeleteChatBlockData blockData = (DeleteChatBlockData)segment.PublicData;
if (NodeSettings.Configs.Node.Id == blockData.NodeId)
{
var deletedChat = await _context.Chats.FirstOrDefaultAsync(chat => chat.Id == blockData.ChatId).ConfigureAwait(false);
if (deletedChat != null)
{
deletedChat.Deleted = true;
_context.Chats.Update(deletedChat);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleDeleteChatBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
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()
{
await filesService.DeleteFilesAsync(notice.FilesIds).ConfigureAwait(false);
foreach (long fileId in notice.FilesIds)
{
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateDeleteFileSegmentAsync(fileId, nodeConnection.Node.Id).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
}
}
public async void AddBlockSegment(BlockSegmentVm blockSegment)
{
try
{
await cacheRepository.AddObject(LIST_BLOCK_SEGMENTS_KEY, blockSegment).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public async Task HandleAsync()
{
List <KeyVm> deletedKeys = await keysService.DeleteUserKeysAsync(notice.KeysId, notice.UserId).ConfigureAwait(false);
if (deletedKeys.Any())
{
List <long> deletedKeysId = deletedKeys.Select(opt => opt.KeyId).ToList();
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateDeleteUserKeysSegmentAsync(deletedKeysId, notice.UserId, current.Node.Id).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
}
}
public async void SendNewUsersNodeNoticeAsync(ShortUser user, BlockSegmentVm blockSegment)
{
try
{
CreateOrEditUsersNodeNotice notice = new CreateOrEditUsersNodeNotice(Enums.NodeNoticeCode.NewUsers, user, blockSegment);
await SendNoticeToNodesAsync(notice).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public async Task <Response> CreateResponseAsync()
{
try
{
switch (request.ConversationType)
{
case ConversationType.Dialog:
{
var users = await loadDialogsService.GetDialogUsersAsync(request.ConversationId).ConfigureAwait(false);
await deleteDialogsService.DeleteDialogAsync(request.ConversationId, clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
UsersConversationsCacheService.Instance.UpdateUsersDialogsAsync(users.Select(opt => opt.Id.Value));
}
break;
case ConversationType.Chat:
{
List <long> usersId = await loadChatsService.GetChatUsersIdAsync(request.ConversationId).ConfigureAwait(false);
await deleteChatsService.DeleteChatAsync(request.ConversationId, clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
UsersConversationsCacheService.Instance.UpdateUsersChatsAsync(usersId);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateDeleteChatSegmentAsync(
request.ConversationId, NodeSettings.Configs.Node.Id).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
}
break;
case ConversationType.Channel:
{
List <long> usersId = await loadChannelsService.GetChannelUsersIdAsync(request.ConversationId).ConfigureAwait(false);
await deleteChannelsService.DeleteChannelAsync(request.ConversationId, clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
UsersConversationsCacheService.Instance.UpdateUsersChannelsAsync(usersId);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateDeleteChannelSegmentAsync(
request.ConversationId, NodeSettings.Configs.Node.Id).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
}
break;
}
nodeNoticeService.SendDeleteConversationsNodeNoticeAsync(request.ConversationId, request.ConversationType, clientConnection.UserId.GetValueOrDefault());
return(new ResultResponse(request.RequestId));
}
catch (PermissionDeniedException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "Conversation not found or user does not have access to conversation.", ErrorCode.DeleteConversationProblem));
}
}
public async Task HandleAsync()
{
var keysGroup = notice.Keys.GroupBy(opt => opt.UserId);
foreach (var group in keysGroup)
{
var keys = await keysService.AddNewUserKeysAsync(notice.Keys, notice.UserId).ConfigureAwait(false);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateNewUserKeysSegmentAsync(keys.ToList(), group.Key.GetValueOrDefault(), current.Node.Id).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
}
}
public async Task <Response> CreateResponseAsync()
{
try
{
if (await verificationCodesService.IsVerificationCodeValidAsync(clientConnection.UserId.GetValueOrDefault().ToString(), clientConnection.UserId, request.VCode).ConfigureAwait(false))
{
await deleteUsersService.DeleteUserAsync(clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
nodeNoticeService.SendDeleteUsersNodeNoticeAsync(clientConnection.UserId.GetValueOrDefault());
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateDeleteUserSegmentAsync(
clientConnection.UserId.GetValueOrDefault(),
new List <long> {
NodeSettings.Configs.Node.Id
},
NodeSettings.Configs.Node.Id).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
Task disconnectTask = new Task(async() =>
{
try
{
List <ClientConnection> clientConnections = connectionsService
.GetClientConnections(new List <long> {
clientConnection.UserId.Value
})
.Where(connection => connection != clientConnection)
.ToList();
foreach (var connection in clientConnections)
{
await connection.ClientSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "User deleted.", CancellationToken.None).ConfigureAwait(false);
}
await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(false);
await clientConnection.ClientSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "User deleted.", CancellationToken.None).ConfigureAwait(false);
}
catch
{
return;
}
});
disconnectTask.Start();
return(new ResultResponse(request.RequestId));
}
return(new ResultResponse(request.RequestId, null, ObjectsLibrary.Enums.ErrorCode.WrongVerificationCode));
}
catch (Exception ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "Can't delete user.", ObjectsLibrary.Enums.ErrorCode.DeleteUserProblem));
}
}
private async Task HandleAddedToBlacklistBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
if (TryDecryptPrivateData <UsersAddedToUserBlacklistBlockData>(segment, out var blockData))
{
var usersCondition = PredicateBuilder.New <User>();
usersCondition = blockData.UsersId.Aggregate(usersCondition,
(current, value) => current.Or(user => user.Id == value).Expand());
var usersIds = await _context.Users.Where(usersCondition).Select(user => user.Id).ToListAsync().ConfigureAwait(false);
var userBlockedIds = (await _context.Users
.Include(user => user.BlackList)
.Where(user => user.Id == blockData.UserId)
.Select(user => user.BlackList)
.FirstOrDefaultAsync().ConfigureAwait(false))
?.Select(opt => opt.BadUid);
List <long> newBlockedUsersIds = new List <long>();
if (userBlockedIds != null)
{
newBlockedUsersIds = usersIds.Except(userBlockedIds).ToList();
}
else
{
newBlockedUsersIds = usersIds;
}
await _context.BadUsers.AddRangeAsync(newBlockedUsersIds.Select(id => new BadUser
{
BadUid = id,
Uid = blockData.UserId
})).ConfigureAwait(false);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleAddedToBlacklistBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
public async Task HandleAsync()
{
bool hasException = true;
List <ChannelUserVm> channelUsers = null;
while (hasException)
{
try
{
channelUsers = await createChannelsService.CreateOrEditChannelUsersAsync(notice.ChannelUsers, notice.RequestorId).ConfigureAwait(false);
hasException = false;
}
catch (UserNotFoundException)
{
List <long> usersId = notice.ChannelUsers.Select(opt => opt.UserId).Append(notice.RequestorId).ToList();
List <UserVm> users = await nodeRequestSender.GetUsersInfoAsync(usersId, null, current).ConfigureAwait(false);
await crossNodeService.CreateNewUsersAsync(users).ConfigureAwait(false);
hasException = true;
}
catch (ConversationNotFoundException)
{
ChannelDto channel = await nodeRequestSender.GetChannelInformationAsync(notice.ChannelId, current).ConfigureAwait(false);
await createChannelsService.CreateOrUpdateUserChannelsAsync(new List <ChannelDto> {
channel
}).ConfigureAwait(false);
hasException = true;
}
catch (Exception ex)
{
Logger.WriteLog(ex);
hasException = false;
}
}
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateChannelUsersSegmentAsync(
channelUsers,
current.Node.Id,
notice.ChannelId,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
}
private async Task HandleEditUserBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
var user = await _context.Users.FirstOrDefaultAsync(_user => _user.Id == segment.SegmentHeader.ObjectId).ConfigureAwait(false);
if (user != null)
{
if (TryDecryptPrivateData <UserVm>(segment, out var userData))
{
user = UserConverter.GetUser(UserConverter.GetUserDto(userData));
user.Confirmed = true;
_context.Users.Update(user);
}
}
else
{
if (TryDecryptPrivateData <UserVm>(segment, out var userData))
{
user = UserConverter.GetUser(UserConverter.GetUserDto(userData));
}
else
{
user = new User
{
Id = segment.SegmentHeader.ObjectId,
NodeId = segment.NodeId,
Confirmed = true
};
}
await _context.Users.AddAsync(user).ConfigureAwait(false);
}
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleNewUserBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
private async Task HandlePrivateChatSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
bool chatExists = !await _context.Chats.AnyAsync(chat => chat.Id == segment.SegmentHeader.ObjectId).ConfigureAwait(false);
if (TryDecryptPrivateData <PrivateChatPrivateData>(segment, out var privateData))
{
Chat newChat = ChatConverter.GetChat(privateData.Chat);
if (!chatExists)
{
await _context.Chats.AddAsync(newChat).ConfigureAwait(false);
}
else
{
_context.Chats.Attach(newChat);
_context.Chats.Update(newChat);
}
}
else
{
if (!chatExists)
{
Chat emptyChat = new Chat
{
Id = segment.SegmentHeader.ObjectId,
Type = (short)ChatType.Private,
Name = "Restored-private-chat"
};
await _context.Chats.AddAsync(emptyChat).ConfigureAwait(false);
}
}
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandlePrivateChatSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
private async Task HandleChannelUsersBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
if (TryDecryptPrivateData <ChannelUsersBlockData>(segment, out var blockData))
{
var channelUserCondition = PredicateBuilder.New <ChannelUser>();
channelUserCondition = blockData.ChannelUsers.Aggregate(channelUserCondition,
(current, value) => current.Or(opt => opt.ChannelId == value.ChannelId && opt.UserId == value.UserId).Expand());
var existingChannelUsers = await _context.ChannelUsers.Where(channelUserCondition).ToListAsync().ConfigureAwait(false);
if (existingChannelUsers.Any())
{
foreach (var channelUser in existingChannelUsers)
{
var editedChannelUser = blockData.ChannelUsers.FirstOrDefault(opt => opt.UserId == channelUser.UserId);
if (editedChannelUser != null)
{
channelUser.Banned = editedChannelUser.Banned ?? channelUser.Banned;
channelUser.Deleted = editedChannelUser.Deleted ?? channelUser.Deleted;
channelUser.ChannelUserRole = editedChannelUser.ChannelUserRole ?? channelUser.ChannelUserRole;
}
}
_context.ChannelUsers.UpdateRange(existingChannelUsers);
}
var nonExistingChannelUsers = blockData.ChannelUsers.Where(channelUser => !existingChannelUsers.Any(opt => opt.UserId == channelUser.UserId));
if (nonExistingChannelUsers.Any())
{
var newChannelUsers = ChannelConverter.GetChannelUsers(nonExistingChannelUsers);
await _context.ChannelUsers.AddRangeAsync(newChannelUsers).ConfigureAwait(false);
}
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleChannelUsersBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
public async Task <Response> CreateResponseAsync()
{
List <ChannelUserVm> resultChannelsUsers = new List <ChannelUserVm>();
List <BlockSegmentVm> segments = new List <BlockSegmentVm>();
foreach (long channelId in request.ChannelsId)
{
try
{
ChannelVm channel = await loadChannelsService.GetChannelByIdAsync(channelId).ConfigureAwait(false);
var existingUsers = await loadChannelsService.GetChannelUsersAsync(channelId, null, null).ConfigureAwait(false);
if (!existingUsers.Any(opt => opt.ChannelUserRole == ChannelUserRole.Creator))
{
var nodeConnection = connectionsService.GetNodeConnection(channel.NodesId.FirstOrDefault(id => id != NodeSettings.Configs.Node.Id));
if (nodeConnection != null)
{
await nodeRequestSender.GetChannelInformationAsync(channelId, nodeConnection).ConfigureAwait(false);
}
}
List <ChannelUserVm> channelUsers =
await updateChannelsService.AddUsersToChannelAsync(request.UsersId.ToList(), channelId, clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
resultChannelsUsers.AddRange(channelUsers);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateChannelUsersSegmentAsync(
channelUsers,
NodeSettings.Configs.Node.Id,
channelId,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
segments.Add(segment);
conversationsNoticeService.SendNewChannelNoticesAsync(channelUsers, channelId, clientConnection);
nodeNoticeService.SendChannelUsersNodeNoticeAsync(channelUsers, clientConnection.UserId.Value, channel);
}
catch (Exception ex)
{
Logger.WriteLog(ex, request);
}
}
BlockGenerationHelper.Instance.AddSegments(segments);
return(new ChannelUsersResponse(request.RequestId, null, resultChannelsUsers, null));
}