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(); } } } }
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 UserService() { _accountConverter = new AccountDataConverter(); UserProvider = new UserProvider(); _userConverter = new UserConverter(); _chatConverter = new ChatConverter(); }
public async Task <ChatVm> EditChatAsync(EditChatVm editChat, long userId) { using (MessengerDbContext context = contextFactory.Create()) { IQueryable <Chat> query = from chat in context.Chats join chatUser in context.ChatUsers on chat.Id equals chatUser.ChatId join chatUsers in context.ChatUsers on chat.Id equals chatUsers.ChatId where chat.Id == editChat.Id && chatUser.UserId == userId && chatUser.UserRole >= UserRole.Admin && chat.Deleted == false && chatUser.Banned == false && chatUser.Deleted == false && chatUsers.Banned == false && chatUsers.Deleted == false select chat; Chat targetChat = await query .FirstOrDefaultAsync() .ConfigureAwait(false); if (targetChat != null) { targetChat = ChatConverter.GetChat(targetChat, editChat); await context.SaveChangesAsync().ConfigureAwait(false); return(ChatConverter.GetChatVm(targetChat)); } throw new PermissionDeniedException(); } }
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 <List <ChatVm> > FindChatsByStringQueryAsync(string searchQuery, long?navigationId = 0, bool?direction = true, long?userId = null) { using (MessengerDbContext context = contextFactory.Create()) { ExpressionsHelper helper = new ExpressionsHelper(); var searchExpression = helper.GetChatExpression(searchQuery); IQueryable <Chat> query = context.Chats .Where(opt => !opt.Deleted) .AsNoTracking(); if (userId == null) { query = query.Where(opt => (opt.Type == (short)ChatType.Public)); } else { query = query.Where(opt => opt.ChatUsers .Any(chatUser => chatUser.UserId == userId && !chatUser.Banned && !chatUser.Deleted) || (opt.Type == (short)ChatType.Public)); } query = query.Where(searchExpression); if (direction.GetValueOrDefault() == true) { query = query.OrderBy(opt => opt.Id) .Where(opt => opt.Id > navigationId.GetValueOrDefault()); } else { query = query.OrderByDescending(opt => opt.Id) .Where(opt => opt.Id < navigationId.GetValueOrDefault()); } List <Chat> chats = await query.ToListAsync().ConfigureAwait(false); return(ChatConverter.GetChatsVm(chats)); } }
public async Task <List <ChatVm> > FindChatsAsync(SearchChatVm template, int limit = 100, long navigationChatId = 0, long?nodeId = null) { using (MessengerDbContext context = contextFactory.Create()) { IQueryable <Chat> query; if (template != null) { ExpressionsHelper expressionsHelper = new ExpressionsHelper(); query = context.Chats .AsNoTracking() .OrderBy(chat => chat.Id) .Where(expressionsHelper.GetChatExpression(template)) .Take(limit); } else { query = context.Chats .AsNoTracking() .OrderBy(chat => chat.Id) .Take(limit); } if (nodeId != null) { query = query.Where(chat => chat.NodesId.Contains(nodeId.Value)); } List <Chat> result = await query .Where(chat => chat.Deleted == false && chat.Id > navigationChatId && (ChatType)chat.Type != ChatType.Private) .ToListAsync() .ConfigureAwait(false); return(ChatConverter.GetChatsVm(result)); } }
public ChatService() { ChatProvider = new ChatProvider(); MessageProvider = new MessageProvider(); _userConverter = new UserConverter(); _chatConverter = new ChatConverter(); _messageConverter = new MessageConverter(); }
public async Task <ChatVm> GetChatByIdAsync(long chatId) { using (MessengerDbContext context = contextFactory.Create()) { return(ChatConverter.GetChatVm(await context.Chats .AsNoTracking() .Include(chat => chat.ChatUsers) .FirstOrDefaultAsync(chat => chat.Id == chatId) .ConfigureAwait(false))); } }
public async Task <ChatVm> CreateChatAsync(ChatVm chatVm, long userId) { using (MessengerDbContext context = contextFactory.Create()) { List <ChatUser> chatUsers = new List <ChatUser>(); using (var transaction = await context.Database.BeginTransactionAsync().ConfigureAwait(false)) { if (chatVm.Users != null && await loadUsersService.IsUserBlacklisted(userId, chatVm.Users.Select(opt => opt.UserId)).ConfigureAwait(false)) { throw new UserBlockedException(); } Chat newChat = ChatConverter.GetChat(chatVm); newChat.Tag = RandomExtensions.NextString(10, "QWERTYUIOPASDFGHJKLZXCVBNM1234567890"); newChat.Id = await poolsService.GetChatIdAsync().ConfigureAwait(false); if (chatVm.Users != null) { chatUsers.AddRange(chatVm.Users.Where(opt => opt.UserId != userId).Select(chatUser => new ChatUser { Banned = chatUser.Banned.GetValueOrDefault(false), Deleted = chatUser.Deleted.GetValueOrDefault(false), Joined = DateTime.UtcNow.ToUnixTime(), UserId = chatUser.UserId, UserRole = chatUser.UserRole.GetValueOrDefault(UserRole.User), InviterId = userId })); } if (!chatUsers.Any(opt => opt.UserId == userId)) { chatUsers.Add(new ChatUser { Banned = false, Deleted = false, Joined = DateTime.UtcNow.ToUnixTime(), UserId = userId, UserRole = UserRole.Creator }); } newChat.ChatUsers = chatUsers; IEnumerable <UserVm> users = await loadUsersService.GetUsersByIdAsync(chatUsers.Select(chatUser => chatUser.UserId)).ConfigureAwait(false); IEnumerable <long> nodesId = users.Select(user => user.NodeId ?? 0).Distinct(); newChat.NodesId = nodesId.ToArray(); await context.Chats.AddAsync(newChat).ConfigureAwait(false); await context.SaveChangesAsync().ConfigureAwait(false); transaction.Commit(); newChat.ChatUsers = chatUsers; return(ChatConverter.GetChatVm(newChat)); } } }
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(); } } } }
public async Task CreateChats() { var creator = fillTestDbHelper.Users.FirstOrDefault(); var users = fillTestDbHelper.Users.Where(opt => !opt.BlackList.Any(p => p.BadUid == creator.Id) && !creator.BlackList.Any(p => p.BadUid == opt.Id)).Take(5).ToList(); ChatVm newChat = new ChatVm { About = "Create chat test 2", Name = "Chat", Users = users.Select(opt => new ChatUserVm { UserId = opt.Id, UserRole = opt.Id == creator.Id ? ObjectsLibrary.Enums.UserRole.Creator : ObjectsLibrary.Enums.UserRole.Moderator }).ToList() }; var userChats = fillTestDbHelper.Chats.Where(opt => opt.ChatUsers.Any(p => p.UserId == creator.Id)); var expectedChats = ChatConverter.GetChatsDto(userChats).Append(ChatConverter.GetChatDto(newChat)).ToList(); var actualChats = await createChatsService.CreateOrUpdateUserChatsAsync(expectedChats); Assert.Equal(expectedChats.Count, actualChats.Count); }
public async Task <List <ChatDto> > GetUserChatsAsync(long userId) { using (MessengerDbContext context = contextFactory.Create()) { var query = from chat in context.Chats join chatUser in context.ChatUsers on chat.Id equals chatUser.ChatId where chatUser.UserId == userId && !chatUser.Deleted && !chatUser.Banned && !chat.Deleted select chat; var chats = await query.AsNoTracking() .Include(opt => opt.ChatUsers) .Include(opt => opt.Messages) .ThenInclude(opt => opt.Attachments) .ToListAsync() .ConfigureAwait(false); return(ChatConverter.GetChatsDto(chats)); } }
public async Task <List <ChatDto> > CreateOrUpdateUserChatsAsync(List <ChatDto> userChats) { using (MessengerDbContext context = contextFactory.Create()) { var chatsCondition = PredicateBuilder.New <Chat>(); chatsCondition = userChats.Aggregate(chatsCondition, (current, value) => current.Or(opt => opt.Id == value.Id).Expand()); List <ChatDto> resultChats = new List <ChatDto>(); List <Chat> existingChats = await context.Chats .Where(chatsCondition) .ToListAsync() .ConfigureAwait(false); if (existingChats.Any()) { for (int i = 0; i < existingChats.Count; i++) { var editedChat = userChats.FirstOrDefault(opt => opt.Id == existingChats[i].Id); editedChat.ChatUsers = null; existingChats[i] = ChatConverter.GetChat(existingChats[i], editedChat); } context.Chats.UpdateRange(existingChats); await context.SaveChangesAsync().ConfigureAwait(false); resultChats.AddRange(ChatConverter.GetChatsDto(existingChats)); } List <ChatDto> nonExistingChats = userChats.Where(chat => !existingChats.Any(opt => opt.Id == chat.Id))?.ToList(); if (nonExistingChats != null && nonExistingChats.Any()) { List <Chat> newChats = nonExistingChats.Select(chat => ChatConverter.GetChat(null, chat))?.ToList(); await context.Chats.AddRangeAsync(newChats).ConfigureAwait(false); await context.SaveChangesAsync().ConfigureAwait(false); resultChats.AddRange(ChatConverter.GetChatsDto(newChats)); } return(resultChats); } }
public async Task <List <ChatVm> > GetChatsNodeAsync(long userId = 0, byte limit = 100, long navigationId = 0) { try { using (MessengerDbContext context = contextFactory.Create()) { List <Chat> chats; if (userId == 0) { chats = await context.Chats .AsNoTracking() .OrderBy(chat => chat.Id) .Where(chat => chat.Id > navigationId && ((ChatType)chat.Type) != ChatType.Private) .Take(limit) .ToListAsync() .ConfigureAwait(false); } else { var query = from chat in context.Chats join chatUser in context.ChatUsers on chat.Id equals chatUser.ChatId where chatUser.UserId == userId && chatUser.Deleted == false select chat; chats = await query .AsNoTracking() .OrderBy(chat => chat.Id) .Where(chat => chat.Id > navigationId) .Take(limit) .ToListAsync() .ConfigureAwait(false); } return(ChatConverter.GetChatsVm(chats)); } } catch (Exception ex) { throw new GetConversationsException("Error when retrieving chat list.", ex); } }
public async Task <List <ChatVm> > GetChatsByIdAsync(IEnumerable <long> chatsId, long?userId) { using (MessengerDbContext context = contextFactory.Create()) { var chatsCondition = PredicateBuilder.New <Chat>(); chatsCondition = chatsId.Aggregate(chatsCondition, (current, value) => current.Or(opt => opt.Id == value && !opt.Deleted).Expand()); var query = context.Chats .Where(chatsCondition); if (userId != null) { query = query.Where(opt => opt.ChatUsers.Any(user => (user.UserId == userId && !user.Banned && !user.Deleted) || opt.Type == (short)ChatType.Public)); } else { query = query.Where(opt => opt.Type == (short)ChatType.Public); } var chats = await query.ToListAsync().ConfigureAwait(false); return(ChatConverter.GetChatsVm(chats)); } }
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); } } }