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 <List <ChatUserDto> > GetChatUsersAsync(IEnumerable <long> usersId, long chatId) { using (MessengerDbContext context = contextFactory.Create()) { var chatUsersCondition = PredicateBuilder.New <ChatUser>(); chatUsersCondition = usersId.Aggregate(chatUsersCondition, (current, value) => current.Or(chatUser => chatUser.UserId == value).Expand()); var query = context.ChatUsers .AsNoTracking() .OrderByDescending(chatUser => chatUser.UserRole) .ThenBy(chatUser => chatUser.UserId) .Where(chatUsersCondition) .Where(chatUser => chatUser.Deleted == false && chatUser.Banned == false && chatUser.ChatId == chatId); return(ChatUserConverter.GetChatUsersDto(await query.ToListAsync().ConfigureAwait(false))); } }
public async Task AddChatUsersAsync(IEnumerable <ChatUserVm> chatUsers) { try { var newChatUsers = ChatUserConverter.GetChatUsers(chatUsers); using (MessengerDbContext context = contextFactory.Create()) { await context.ChatUsers.AddRangeAsync(newChatUsers).ConfigureAwait(false); await context.SaveChangesAsync().ConfigureAwait(false); } } catch (Exception ex) { Logger.WriteLog(ex); } }
public async Task <List <ChatUserVm> > GetChatUsersAsync(long chatId, long?userId, int limit = 100, long navUserId = 0) { using (MessengerDbContext context = contextFactory.Create()) { if (userId != null && !await IsUserJoinedToChatAsync(chatId, userId.Value).ConfigureAwait(false)) { throw new GetUsersException(); } var query = context.ChatUsers .AsNoTracking() .Where(chatUser => chatUser.ChatId == chatId && chatUser.Deleted == false && chatUser.Chat.Deleted == false) .OrderByDescending(chatUser => chatUser.UserRole) .ThenBy(chatUser => chatUser.UserId) .Where(chatUser => chatUser.UserId > navUserId) .Take(limit); return(ChatUserConverter.GetChatUsersVm(await query.ToListAsync().ConfigureAwait(false))); } }
private async Task HandleChangeUsersChatSegmentAsync(BlockSegmentVm segment) { using (MessengerDbContext _context = CreateContext()) { using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false)) { try { if (TryDecryptPrivateData <ChangeUsersChatBlockData>(segment, out var blockData)) { var usersCondition = PredicateBuilder.New <ChatUser>(); usersCondition = blockData.ChatUsers.Aggregate(usersCondition, (current, value) => current.Or(chatUser => chatUser.UserId == value.UserId && chatUser.ChatId == blockData.ChatId).Expand()); var existingChatUsers = await _context.ChatUsers.Where(usersCondition).ToListAsync().ConfigureAwait(false); var nonExistingChatUsers = blockData.ChatUsers .Where(chatUser => !existingChatUsers.Any(opt => chatUser.UserId == opt.UserId)).ToList(); if (nonExistingChatUsers.Any()) { await _context.ChatUsers.AddRangeAsync(ChatUserConverter.GetChatUsers(nonExistingChatUsers)).ConfigureAwait(false); } var updatedChatUsersVm = blockData.ChatUsers.Where(chatUser => existingChatUsers.Any(opt => opt.UserId == chatUser.UserId)); if (updatedChatUsersVm.Any()) { var updatedChatUsers = ChatUserConverter.GetChatUsers(updatedChatUsersVm); _context.ChatUsers.AttachRange(updatedChatUsers); _context.ChatUsers.UpdateRange(updatedChatUsers); } await _context.SaveChangesAsync().ConfigureAwait(false); transaction.Commit(); } } catch (Exception ex) { AddErrorMessage(nameof(HandleChangeUsersChatSegmentAsync), ex.ToString()); transaction.Rollback(); } } } }
public async Task AddUsersToChatAsync(long chatId, IEnumerable <long> usersId, long requestorId) { try { List <ChatUser> chatUsers = new List <ChatUser>(); foreach (long userId in usersId) { chatUsers.Add(ChatUserConverter.GetNewChatUser(chatId, userId, requestorId)); } using (MessengerDbContext context = contextFactory.Create()) { await context.AddRangeAsync(chatUsers).ConfigureAwait(false); await context.SaveChangesAsync().ConfigureAwait(false); } } catch (Exception ex) { Logger.WriteLog(ex); } }
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 <List <ChatUserVm> > EditChatUsersAsync(IEnumerable <ChatUserVm> users, long chatId, long userId) { using (MessengerDbContext context = contextFactory.Create()) { ExpressionStarter <ChatUser> usersCondition = PredicateBuilder.New <ChatUser>(); usersCondition = users.Select(chatUser => chatUser.UserId).Aggregate(usersCondition, (current, value) => current.Or(chatUser => chatUser.UserId == value).Expand()); Chat currentChat = await context.Chats.FindAsync(chatId).ConfigureAwait(false); if (currentChat == null || currentChat.Deleted) { throw new ConversationNotFoundException(); } List <ChatUser> chatUsers = await context.ChatUsers .Where(usersCondition) .Where(chatUser => chatUser.ChatId == chatId) .ToListAsync() .ConfigureAwait(false); List <ChatUserVm> editedChatUsers = new List <ChatUserVm>(); ChatUser requestUser = await context.ChatUsers .FirstOrDefaultAsync(opt => opt.UserId == userId && opt.ChatId == chatId).ConfigureAwait(false); if (requestUser != null && requestUser.Banned) { throw new ChatUserBlockedException(); } if (requestUser == null || !chatUsers.Any()) { throw new UserIsNotInConversationException(); } foreach (ChatUser user in chatUsers) { ChatUserVm changedChatUser = users.FirstOrDefault(chatUser => user.UserId == chatUser.UserId); if (changedChatUser != null) { if (requestUser.UserRole > changedChatUser.UserRole && requestUser.UserRole > user.UserRole && changedChatUser.UserRole < UserRole.Creator) { user.UserRole = changedChatUser.UserRole ?? user.UserRole; user.Deleted = changedChatUser.Deleted ?? user.Deleted; user.Banned = changedChatUser.Banned ?? user.Banned; editedChatUsers.Add(ChatUserConverter.GetChatUserVm(user)); } else if (requestUser.UserId == changedChatUser.UserId) { user.Deleted = changedChatUser.Deleted ?? user.Deleted; editedChatUsers.Add(ChatUserConverter.GetChatUserVm(user)); } else { throw new EditConversationUsersException(); } } } if (users.Any(opt => opt.Deleted.GetValueOrDefault() || opt.Banned.GetValueOrDefault())) { var query = from chat in context.Chats join chatUser in context.ChatUsers on chat.Id equals chatUser.ChatId join user in context.Users on chatUser.UserId equals user.Id where chat.Id == chatId && !chatUser.Banned && !chatUser.Deleted select user.NodeId; var chatNodesId = (await query.ToListAsync().ConfigureAwait(false)).Distinct(); currentChat.NodesId = chatNodesId.Select(id => id.GetValueOrDefault()).ToArray(); } await context.SaveChangesAsync().ConfigureAwait(false); return(editedChatUsers); } }
public async Task HandleAsync() { try { List <ChatUserDto> chatUsers = await loadChatsService.GetChatUsersAsync(request.UsersId, request.ChatId).ConfigureAwait(false); ChatUsersNodeResponse response = new ChatUsersNodeResponse(request.RequestId, ChatUserConverter.GetChatUsersVm(chatUsers)); NodeWebSocketCommunicationManager.SendResponse(response, current); } catch (Exception ex) { Logger.WriteLog(ex); NodeWebSocketCommunicationManager.SendResponse(new ResultNodeResponse(request.RequestId, ObjectsLibrary.Enums.ErrorCode.UnknownError), current); } }