public async Task <UserDto> CreateOrUpdateUserAsync(UserDto user) { using (MessengerDbContext context = contextFactory.Create()) { User userInfo = await context.Users .Include(opt => opt.UserPublicKeys) .Include(opt => opt.Phones) .Include(opt => opt.Emails) .Include(opt => opt.BlackList) .Include(opt => opt.Tokens) .FirstOrDefaultAsync(opt => opt.Id == user.Id) .ConfigureAwait(false); if (userInfo != null) { userInfo = UserConverter.GetUser(userInfo, user); context.Update(userInfo); } else { userInfo = UserConverter.GetUser(user); await context.AddAsync(userInfo).ConfigureAwait(false); } await context.SaveChangesAsync().ConfigureAwait(false); return(UserConverter.GetUserDto(userInfo, null, null)); } }
public async Task <string> AddNewOperationAsync(long nodeId, long userId) { using (MessengerDbContext context = contextFactory.Create()) { long currentTime = DateTime.UtcNow.ToUnixTime(); var uncomplededOperation = await context.ChangeUserNodeOperations .FirstOrDefaultAsync(opt => !opt.Completed && opt.UserId == userId && opt.ExpirationTime > currentTime).ConfigureAwait(false); if (uncomplededOperation != null) { context.Remove(uncomplededOperation); } ChangeUserNodeOperation operation = new ChangeUserNodeOperation { NodeId = nodeId, UserId = userId, OperationId = RandomExtensions.NextString(64), Completed = false, RequestTime = currentTime, ExpirationTime = currentTime + (long)TimeSpan.FromDays(1).TotalSeconds }; await context.AddAsync(operation).ConfigureAwait(false); await context.SaveChangesAsync().ConfigureAwait(false); return(operation.OperationId); } }
public async Task <ChatVm> NewOrEditChatAsync(ChatVm targetChat) { if (targetChat == null) { return(null); } try { using (MessengerDbContext context = contextFactory.Create()) { var query = from chat in context.Chats where chat.Id == targetChat.Id select chat; Chat editableChat = await query.Include(opt => opt.ChatUsers).FirstOrDefaultAsync().ConfigureAwait(false); if (editableChat == null) { editableChat = ChatConverter.GetChat(targetChat); if (targetChat.Users != null) { editableChat.ChatUsers = ChatUserConverter.GetChatUsers(targetChat.Users).ToList(); } await context.AddAsync(editableChat).ConfigureAwait(false); } else { editableChat = ChatConverter.GetChat(editableChat, new EditChatVm { About = targetChat.About, Name = targetChat.Name, Photo = targetChat.Photo, Public = targetChat.Public, Security = targetChat.Security, Visible = targetChat.Visible }); if (!targetChat.Users.IsNullOrEmpty()) { editableChat.ChatUsers = ChatUserConverter.GetChatUsers(targetChat.Users); } context.Update(editableChat); } await context.SaveChangesAsync().ConfigureAwait(false); return(ChatConverter.GetChatVm(editableChat)); } } catch (DbUpdateException ex) { Logger.WriteLog(ex); return(targetChat); } catch (Exception ex) { Logger.WriteLog(ex); return(null); } }
public async Task NewOrEditNodeAsync(NodeVm targetNode) { try { using (MessengerDbContext context = contextFactory.Create()) { var node = await context.Nodes.FindAsync(targetNode.Id).ConfigureAwait(false); if (node == null) { node = NodeConverter.GetNode(targetNode); await context.AddAsync(node).ConfigureAwait(false); } else { node = NodeConverter.GetNode(targetNode); context.Update(node); } await context.SaveChangesAsync().ConfigureAwait(false); } } catch (Exception ex) { Logger.WriteLog(ex); } }
public async Task <UserChat> Add(UserChat entity) { var result = await context.AddAsync(entity); await context.SaveChangesAsync(); return(result.Entity); }
public async Task <KeyVm> SetNewSymmetricKeyForChat(KeyVm key, long chatId, long userId) { using (MessengerDbContext context = contextFactory.Create()) { ChatUser chatUser = await context.ChatUsers .Where(opt => opt.ChatId == chatId && opt.UserId == userId && opt.UserRole >= UserRole.Admin && !opt.Deleted && !opt.Banned) .FirstOrDefaultAsync() .ConfigureAwait(false); if (chatUser == null) { throw new UserIsNotInConversationException(); } Key chatKey = await context.Keys.FirstOrDefaultAsync(opt => opt.ChatId == chatId).ConfigureAwait(false); if (chatKey == null) { chatKey = KeyConverter.GetKey(key); chatKey.ChatId = chatId; chatKey.UserId = null; chatKey.KeyId = RandomExtensions.NextInt64(); await context.AddAsync(chatKey).ConfigureAwait(false); } else { chatKey.ChatId = chatId; chatKey.KeyData = key.Data; chatKey.Version = 1; chatKey.UserId = null; chatKey.GenerationTimeSeconds = key.GenerationTime; chatKey.ExpirationTimeSeconds = key.GenerationTime + key.Lifetime; context.Update(chatKey); } await context.SaveChangesAsync().ConfigureAwait(false); return(KeyConverter.GetKeyVm(chatKey)); } }
private async Task HandleNewUserBlockSegmentAsync(BlockSegmentVm segment) { using (MessengerDbContext _context = CreateContext()) { using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false)) { try { if (!await _context.Users.AnyAsync(user => user.Id == segment.SegmentHeader.ObjectId).ConfigureAwait(false)) { if (TryDecryptPrivateData <UserVm>(segment, out var userData)) { User user = UserConverter.GetUser(UserConverter.GetUserDto(userData)); await _context.Users.AddAsync(user).ConfigureAwait(false); } else { await _context.AddAsync(new User { Id = segment.SegmentHeader.ObjectId, NodeId = segment.NodeId, Confirmed = true }).ConfigureAwait(false); } await _context.SaveChangesAsync().ConfigureAwait(false); transaction.Commit(); } } catch (Exception ex) { AddErrorMessage(nameof(HandleNewUserBlockSegmentAsync), ex.ToString()); transaction.Rollback(); } } } }
public async Task <ChatVm> AddUsersToChatAsync(IEnumerable <long> usersId, long chatId, long userId) { using (MessengerDbContext context = contextFactory.Create()) { using (var transaction = await context.Database.BeginTransactionAsync().ConfigureAwait(false)) { Chat chat = await context.Chats.FirstOrDefaultAsync(opt => opt.Id == chatId).ConfigureAwait(false); if (chat == null) { throw new ConversationNotFoundException(chatId); } User requestingUser = await context.Users.FindAsync(userId).ConfigureAwait(false); if (requestingUser == null || requestingUser.Deleted) { throw new AddUserChatException(); } ChatUser chatUser = await context.ChatUsers .FirstOrDefaultAsync(opt => opt.ChatId == chatId && opt.UserId == userId).ConfigureAwait(false); List <ChatUserVm> addedUsers = new List <ChatUserVm>(); if (chat.Deleted) { throw new ConversationIsNotValidException(); } if (chatUser != null && chatUser.Banned) { throw new ChatUserBlockedException(); } if (usersId.Count() == 1 && usersId.FirstOrDefault() == userId) { if (chat.Type == (int)ChatType.Private) { throw new AddUserChatException(); } if (chatUser == null) { chatUser = ChatUserConverter.GetNewChatUser(chatId, userId, null); await context.AddAsync(chatUser).ConfigureAwait(false); } else if (chatUser.Deleted) { chatUser.Deleted = false; chatUser.User = requestingUser; context.Update(chatUser); } if (!chat.NodesId.Contains(NodeSettings.Configs.Node.Id)) { createMessagesService.DownloadMessageHistoryAsync(chat.NodesId.FirstOrDefault(), chat.Id, ConversationType.Chat, null, false); } chat.NodesId = chat.NodesId.Append(requestingUser.NodeId.Value).Distinct().ToArray(); addedUsers.Add(ChatUserConverter.GetChatUserVm(chatUser)); } else { if ((chatUser?.Deleted).GetValueOrDefault(true)) { throw new AddUserChatException(); } if (await loadUsersService.IsUserBlacklisted(userId, usersId).ConfigureAwait(false)) { throw new UserBlockedException(); } ExpressionStarter <User> usersCondition = PredicateBuilder.New <User>(); usersCondition = usersId.Aggregate(usersCondition, (current, value) => current.Or(opt => opt.Id == value).Expand()); List <User> existingUsers = await context.Users .AsNoTracking() .Where(usersCondition) .ToListAsync() .ConfigureAwait(false); ExpressionStarter <ChatUser> chatUsersCondition = PredicateBuilder.New <ChatUser>(); chatUsersCondition = existingUsers.Select(opt => opt.Id).Aggregate(chatUsersCondition, (current, value) => current.Or(opt => opt.UserId == value && opt.ChatId == chatId).Expand()); List <ChatUser> validChatUsers = await context.ChatUsers .Where(chatUsersCondition) .Include(opt => opt.User) .ToListAsync() .ConfigureAwait(false); foreach (ChatUser user in validChatUsers) { if (!user.Banned && user.Deleted) { user.Deleted = false; addedUsers.Add(ChatUserConverter.GetChatUserVm(user)); } } context.UpdateRange(validChatUsers); List <long> newChatUsersId = existingUsers.Select(opt => opt.Id).Except(validChatUsers.Select(opt => opt.UserId)).ToList(); List <ChatUser> newChatUsers = newChatUsersId.Select(id => ChatUserConverter.GetNewChatUser(chatId, id, userId)).ToList(); chat.NodesId = chat.NodesId?.Concat(existingUsers.Select(opt => opt.NodeId.GetValueOrDefault())).Distinct().ToArray() ?? existingUsers.Select(opt => opt.NodeId.GetValueOrDefault()).Distinct().ToArray(); await context.ChatUsers .AddRangeAsync(newChatUsers) .ConfigureAwait(false); /* foreach (ChatUser user in newChatUsers) * { * user.User = existingUsers.FirstOrDefault(opt => opt.Id == user.UserId); * }*/ addedUsers.AddRange(ChatUserConverter.GetChatUsersVm(newChatUsers)); } context.Update(chat); transaction.Commit(); await context.SaveChangesAsync() .ConfigureAwait(false); ChatVm resultChat = ChatConverter.GetChatVm(chat); resultChat.Users = addedUsers; return(resultChat); } } }
public async Task <NodeKeysDto> CreateNewNodeKeysAsync(long?nodeId, KeyLength keyLength, uint lifetime) { byte[] password; using (SHA256 sha256 = SHA256.Create()) { password = sha256.ComputeHash(Encoding.UTF8.GetBytes(NodeSettings.Configs.Password)); } long keyId = RandomExtensions.NextInt64(); using (MessengerDbContext context = contextFactory.Create()) { var nodeKeysId = await context.NodesKeys .Where(opt => opt.NodeId == nodeId) .Select(opt => opt.KeyId) .ToListAsync() .ConfigureAwait(false); while (nodeKeysId.Contains(keyId)) { keyId = RandomExtensions.NextInt64(); } byte[] symmetricKey = Encryptor.GetSymmetricKey(256, keyId, lifetime, password); Encryptor.KeyLengthType encKeysLength; Encryptor.KeyLengthType signKeysLength; switch (keyLength) { case KeyLength.Short: encKeysLength = Encryptor.KeyLengthType.EncryptShort; signKeysLength = Encryptor.KeyLengthType.SignShort; break; case KeyLength.Medium: encKeysLength = Encryptor.KeyLengthType.EncryptMedium; signKeysLength = Encryptor.KeyLengthType.SignMedium; break; case KeyLength.Long: default: encKeysLength = Encryptor.KeyLengthType.EncryptLong; signKeysLength = Encryptor.KeyLengthType.SignLong; break; } var asymKeys = Encryptor.GenerateAsymmetricKeys(keyId, lifetime, encKeysLength, password); var signAsymKeys = Encryptor.GenerateAsymmetricKeys(keyId, lifetime, signKeysLength, password); long generationTime = DateTime.UtcNow.ToUnixTime(); NodeKeys nodeKeys = new NodeKeys { GenerationTime = generationTime, ExpirationTime = generationTime + lifetime, KeyId = keyId, NodeId = nodeId.GetValueOrDefault(), PublicKey = asymKeys.FirstValue, PrivateKey = asymKeys.SecondValue, SymmetricKey = symmetricKey, SignPublicKey = signAsymKeys.FirstValue, SignPrivateKey = signAsymKeys.SecondValue }; await context.AddAsync(nodeKeys).ConfigureAwait(false); await context.SaveChangesAsync().ConfigureAwait(false); return(new NodeKeysDto { ExpirationTime = nodeKeys.ExpirationTime, GenerationTime = nodeKeys.GenerationTime, KeyId = nodeKeys.KeyId, NodeId = nodeKeys.NodeId, PrivateKey = nodeKeys.PrivateKey, PublicKey = nodeKeys.PublicKey, SymmetricKey = nodeKeys.SymmetricKey, SignPublicKey = nodeKeys.SignPublicKey, SignPrivateKey = nodeKeys.SignPrivateKey, Password = password }); } }