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));
}
