private async Task HandleChannelMessagesAsync(IEnumerable <MessageVm> messages) { foreach (var message in messages) { bool hasException = true; MessageDto sentMessage = null; while (hasException) { try { if (NodeData.Instance.RoutedMessagesId.Contains(message.GlobalId.GetValueOrDefault())) { hasException = false; continue; } if (message.Attachments != null) { foreach (var attachment in message.Attachments) { attachment.MessageId = 0; } await attachmentsService.DownloadAttachmentsPayloadAsync(message.Attachments, current).ConfigureAwait(false); await attachmentsService.ThrowIfAttachmentsInvalidAsync(message, true).ConfigureAwait(false); } sentMessage = await createMessagesService.CreateChannelMessageAsync(MessageConverter.GetMessageDto(message)).ConfigureAwait(false); hasException = false; } catch (ConversationNotFoundException ex) { var channel = await nodeRequestSender.GetChannelInformationAsync(ex.ConversationId, current).ConfigureAwait(false); await createChannelsService.CreateOrUpdateUserChannelsAsync(new List <ChannelDto> { channel }).ConfigureAwait(false); hasException = true; } catch (UserNotFoundException ex) { List <UserVm> users = new List <UserVm>(await nodeRequestSender.GetUsersInfoAsync(ex.UsersId.ToList(), null, current).ConfigureAwait(false)); await crossNodeService.CreateNewUsersAsync(users).ConfigureAwait(false); hasException = true; } catch (Exception ex) { Logger.WriteLog(ex); hasException = false; } } SendChannelNotificationsAsync(sentMessage); } }
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); }
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 <Response> CreateResponseAsync() { try { var pollResults = await pollsService.GetPollVotedUsersAsync( request.PollId, request.ConversationId, request.ConversationType, request.OptionId, clientConnection.UserId.GetValueOrDefault(), 30, request.NavigationUserId.GetValueOrDefault()).ConfigureAwait(false); var usersGroups = pollResults.GroupBy(opt => opt.FirstValue.NodeId); List <Task> getUsersTasks = new List <Task>(); var resultUsers = new ConcurrentBag <VoteInfo>(); foreach (var group in usersGroups) { var nodeConnection = connectionsService.GetNodeConnection(group.Key.GetValueOrDefault()); if (nodeConnection != null) { await MetricsHelper.Instance.SetCrossNodeApiInvolvedAsync(request.RequestId).ConfigureAwait(false); getUsersTasks.Add(Task.Run(async() => { var usersInfo = await nodeRequestSender.GetUsersInfoAsync(group.Select(opt => opt.FirstValue.Id).ToList(), clientConnection.UserId, nodeConnection).ConfigureAwait(false); resultUsers.AddRange(usersInfo.Select(user => new VoteInfo(user, pollResults.FirstOrDefault(opt => opt.FirstValue.Id == user.Id).SecondValue))); })); } else if (group.Key == NodeSettings.Configs.Node.Id) { var users = UserConverter.GetUsersVm(group.Select(opt => opt.FirstValue).ToList(), clientConnection.UserId); resultUsers.AddRange(users.Select(user => new VoteInfo(user, pollResults.FirstOrDefault(opt => opt.FirstValue.Id == user.Id).SecondValue))); } } await Task.WhenAll(getUsersTasks).ConfigureAwait(false); return(new PollResultsResponse(request.RequestId, resultUsers.OrderBy(opt => opt.User.Id))); } catch (PermissionDeniedException ex) { Logger.WriteLog(ex); return(new ResultResponse(request.RequestId, "User does not have access to voted users list.", ErrorCode.PermissionDenied)); } }
public async Task <Response> CreateResponseAsync() { List <ContactDto> contactsDto = await groupsService.GetGroupContactsAsync( request.GroupId, clientConnection.UserId.GetValueOrDefault(), request.NavigationUserId.GetValueOrDefault()).ConfigureAwait(false); List <ContactVm> contactsVm = ContactConverter.GetContactsVm(contactsDto); IEnumerable <IGrouping <long, UserDto> > groupedUsers = contactsDto.Select(opt => opt.ContactUser).GroupBy(opt => opt.NodeId.GetValueOrDefault()); ConcurrentBag <UserVm> resultUsers = new ConcurrentBag <UserVm>(); List <Task> getUsersTasks = new List <Task>(); foreach (var group in groupedUsers) { getUsersTasks.Add(Task.Run(async() => { var nodeConnection = connectionsService.GetNodeConnection(group.Key); if (group.Key != NodeSettings.Configs.Node.Id && nodeConnection != null) { await MetricsHelper.Instance.SetCrossNodeApiInvolvedAsync(request.RequestId).ConfigureAwait(false); var users = await nodeRequestSender.GetUsersInfoAsync( group.Select(opt => opt.Id).ToList(), clientConnection.UserId, nodeConnection).ConfigureAwait(false); resultUsers.AddRange(users); resultUsers.AddRange(users); } else { resultUsers.AddRange(UserConverter.GetUsersVm(group.ToList(), clientConnection.UserId)); } })); } await Task.WhenAll(getUsersTasks).ConfigureAwait(false); foreach (var contact in contactsVm) { contact.ContactUser = resultUsers.FirstOrDefault(opt => opt.Id == contact.ContactUserId); } return(new ContactsResponse(request.RequestId, contactsVm)); }