public async Task GetUsersById() { List <long> usersIds = fillTestDbHelper.Users.Select(opt => opt.Id).Take(3).ToList(); var expectedUsers = fillTestDbHelper.Users.Where(opt => usersIds.Contains(opt.Id)).ToList(); var actualUsers = await loadUsersService.GetUsersByIdAsync(usersIds); Assert.True(expectedUsers.Count == actualUsers.Count && expectedUsers.All(opt => actualUsers.Any(p => opt.Id == p.Id))); }
public async Task <List <UserVm> > GetUsers([FromForm] List <long> usersIds) { if (usersIds.IsNullOrEmpty()) { return(new List <UserVm>()); } return(await _loadUsersService.GetUsersByIdAsync(usersIds).ConfigureAwait(false)); }
public async Task DeleteUsers() { var usersIds = fillTestDbHelper.Users.Select(opt => opt.Id).Take(3); await deleteUsersService.DeleteUsersAsync(usersIds); var actualUsers = await loadUsersService.GetUsersByIdAsync(usersIds); Assert.Empty(actualUsers); }
public async Task <ChannelVm> CreateChannelAsync(ChannelVm channel, long creatorId, IEnumerable <ChannelUserVm> subscribers) { ChannelUser channelUser = new ChannelUser { ChannelUserRole = ChannelUserRole.Creator, SubscribedTime = DateTime.UtcNow.ToUnixTime(), UserId = creatorId, Deleted = false }; if (subscribers != null && await loadUsersService.IsUserBlacklisted(creatorId, subscribers.Select(opt => opt.UserId)).ConfigureAwait(false)) { throw new UserBlockedException(); } List <ChannelUser> channelUsers = new List <ChannelUser>() { channelUser }; if (subscribers != null) { channelUsers.AddRange(ChannelConverter.GetChannelUsers(subscribers.Where(opt => opt.UserId != creatorId))); } List <UserVm> users = await loadUsersService.GetUsersByIdAsync(channelUsers.Select(opt => opt.UserId)).ConfigureAwait(false); if (users.Count() < channelUsers.Count()) { throw new UserNotFoundException(); } Channel newChannel = new Channel { ChannelId = channel.ChannelId.GetValueOrDefault(await poolsService.GetChannelIdAsync().ConfigureAwait(false)), About = channel.About, Deleted = false, ChannelName = channel.ChannelName, CreationTime = DateTime.UtcNow.ToUnixTime(), Photo = channel.Photo, Tag = string.IsNullOrWhiteSpace(channel.Tag) ? RandomExtensions.NextString(10, "QWERTYUIOPASDFGHJKLZXCVBNM1234567890") : channel.Tag, NodesId = users.Select(opt => opt.NodeId.GetValueOrDefault()).Distinct().ToArray() }; using (MessengerDbContext context = contextFactory.Create()) { newChannel.ChannelUsers = channelUsers; var entityEntry = await context.Channels.AddAsync(newChannel).ConfigureAwait(false); await context.SaveChangesAsync().ConfigureAwait(false); var createdChannel = ChannelConverter.GetChannel(entityEntry.Entity); createdChannel.SubscribersCount = newChannel.ChannelUsers.Count(); return(createdChannel); } }
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)); } } }
public async Task HandleAsync() { NodeResponse response; try { switch (request.RequestType) { case Enums.NodeRequestType.GetChats: { IEnumerable <ChatVm> chats = await loadChatsService.GetChatsByIdAsync(request.ObjectsId, request.RequestorUserId).ConfigureAwait(false); response = new ChatsNodeResponse(request.RequestId, chats); } break; case Enums.NodeRequestType.GetUsers: { IEnumerable <UserVm> users = await loadUsersService.GetUsersByIdAsync(request.ObjectsId, request.RequestorUserId).ConfigureAwait(false); users = await privacyService.ApplyPrivacySettingsAsync(users, request.RequestorUserId).ConfigureAwait(false); response = new UsersNodeResponse(request.RequestId, users); } break; case Enums.NodeRequestType.GetChannels: { IEnumerable <ChannelDto> channels = await loadChannelsService.GetChannelsWithSubscribersAsync(request.ObjectsId).ConfigureAwait(false); response = new ChannelsNodeResponse(request.RequestId, channels); } break; case Enums.NodeRequestType.GetFiles: { IEnumerable <FileInfoVm> files = await filesService.GetFilesInfoAsync(request.FilesIds).ConfigureAwait(false); response = new FilesInformationResponse(request.RequestId, files); } break; default: response = new ResultNodeResponse(request.RequestId, ObjectsLibrary.Enums.ErrorCode.InvalidRequestData, "Unsupported request type."); break; } } catch { response = new ResultNodeResponse(request.RequestId, ObjectsLibrary.Enums.ErrorCode.UnknownError, "An error occurred while processing the request."); } NodeWebSocketCommunicationManager.SendResponse(response, nodeConnection); }
public async Task <Response> CreateResponseAsync() { List <UserVm> users = await loadUsersService.GetUsersByIdAsync(request.UsersId, request.IncludeContact?clientConnection.UserId : null).ConfigureAwait(false); List <UserVm> resultUsers = new List <UserVm>(); var groups = users.GroupBy(opt => opt.NodeId.GetValueOrDefault()); foreach (var group in groups) { if (group.Key == NodeSettings.Configs.Node.Id) { resultUsers.AddRange(await privacyService.ApplyPrivacySettingsAsync(group, clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false)); } else { var nodeConnection = connectionsService.GetNodeConnection(group.Key); if (nodeConnection != null) { await MetricsHelper.Instance.SetCrossNodeApiInvolvedAsync(request.RequestId).ConfigureAwait(false); IEnumerable <UserVm> responseUsers = await nodeRequestSender.GetUsersInfoAsync( group.Select(opt => opt.Id.GetValueOrDefault()).ToList(), clientConnection.UserId, nodeConnection).ConfigureAwait(false); if (!responseUsers.IsNullOrEmpty()) { resultUsers.AddRange(responseUsers); } } } } var otherNodesUsers = resultUsers.Where(opt => opt.NodeId != NodeSettings.Configs.Node.Id); if (otherNodesUsers != null) { foreach (var user in otherNodesUsers) { var localUser = users.FirstOrDefault(opt => opt.Id == user.Id); user.Contact = localUser?.Contact; user.Groups = localUser?.Groups; } } return(new UsersResponse(request.RequestId, resultUsers)); }
public async Task <List <ChannelUserVm> > AddUsersToChannelAsync(List <long> usersId, long channelId, long requestorId) { using (MessengerDbContext context = contextFactory.Create()) { var usersCondition = PredicateBuilder.New <ChannelUser>(); usersCondition = usersId.Aggregate(usersCondition, (current, value) => current.Or(opt => opt.UserId == value).Expand()); var requestorUser = await context.ChannelUsers .FirstOrDefaultAsync(opt => opt.ChannelUserRole >= ChannelUserRole.Administrator && opt.ChannelId == channelId && opt.UserId == requestorId && opt.Channel.Deleted == false) .ConfigureAwait(false); if (requestorUser == null && (usersId.Count() > 1 || (usersId.Count() == 1 && usersId.ElementAt(0) != requestorId))) { throw new AddUserToChannelException(); } List <ChannelUser> existingUsers = await context.ChannelUsers .Where(usersCondition) .Where(opt => opt.ChannelId == channelId) .ToListAsync() .ConfigureAwait(false); List <long> nonExistingUsersId; if (existingUsers?.Any() ?? false) { nonExistingUsersId = usersId.Where(id => !existingUsers.Any(opt => opt.UserId == id)).ToList(); } else { nonExistingUsersId = usersId; } List <ChannelUser> newChannelUsers = nonExistingUsersId.Select(id => new ChannelUser { ChannelId = channelId, ChannelUserRole = ChannelUserRole.Subscriber, SubscribedTime = DateTime.UtcNow.ToUnixTime(), UserId = id }).ToList(); var users = await loadUsersService.GetUsersByIdAsync(nonExistingUsersId).ConfigureAwait(false); Channel channel = await context.Channels.FirstOrDefaultAsync(opt => opt.ChannelId == channelId).ConfigureAwait(false); channel.NodesId = channel.NodesId.Concat(users.Select(opt => opt.NodeId.GetValueOrDefault())).Distinct().ToArray(); context.Update(channel); var updatedUsers = new List <ChannelUser>(); if (existingUsers != null) { existingUsers.ForEach(channelUser => { if (!channelUser.Banned && channelUser.Deleted) { channelUser.Deleted = false; updatedUsers.Add(channelUser); } }); context.UpdateRange(existingUsers); } await context.AddRangeAsync(newChannelUsers).ConfigureAwait(false); await context.SaveChangesAsync().ConfigureAwait(false); return(ChannelConverter.GetChannelUsers(newChannelUsers.Concat(updatedUsers))); } }