public async void SendNewUsersAddedToChatNoticeAsync(ChatVm chat, ClientConnection clientConnection)
{
try
{
List <ChatUserVm> filteredUsers = new List <ChatUserVm>(privacyService.ApplyPrivacySettings(chat.Users));
List <long> newUsersId = new List <long>(chat.Users.Select(chatUser => chatUser.UserId));
List <long> allUsersId = new List <long>((await loadChatsService.GetChatUsersIdAsync(chat.Id.Value).ConfigureAwait(false)).Except(newUsersId));
foreach (long chatUserId in allUsersId)
{
var clientConnections = connectionsService.GetUserClientConnections(chatUserId);
if (clientConnections != null)
{
if (clientConnection != null)
{
clientConnections = clientConnections.Where(opt => opt != clientConnection).ToList();
}
UsersAddedNotice notice = new UsersAddedNotice(filteredUsers, chat);
await SendNoticeToClientsAsync(clientConnections, notice).ConfigureAwait(false);
}
}
foreach (long chatUserId in newUsersId)
{
var clientConnections = connectionsService.GetUserClientConnections(chatUserId);
if (clientConnections != null)
{
NewChatNotice notice = new NewChatNotice(chat);
await SendNoticeToClientsAsync(clientConnections, notice).ConfigureAwait(false);
}
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public async Task <Response> CreateResponseAsync()
{
var users = new ConcurrentBag <UserVm>();
var getUsersTasks = new List <Task>
{
Task.Run(async() =>
{
users.AddRange(privacyService.ApplyPrivacySettings(await loadUsersService.FindUsersByPhonesAsync(request.Phones).ConfigureAwait(false), request.Phones, clientConnection.UserId));
})
};
var nodeConnections = connectionsService.GetNodeConnections();
foreach (var connection in nodeConnections)
{
getUsersTasks.Add(Task.Run(async() =>
{
if (connection.IsEncryptedConnection && connection.NodeWebSocket.State == WebSocketState.Open)
{
users.AddRange(await nodeRequestSender.BatchPhonesSearchAsync(connection, request.Phones, clientConnection.UserId).ConfigureAwait(false));
}
}));
}
await Task.WhenAll(getUsersTasks).ConfigureAwait(false);
return(new UsersResponse(request.RequestId, users));
}
public async Task HandleAsync()
{
var users = await loadUsersService.FindUsersByPhonesAsync(request.Phones).ConfigureAwait(false);
NodeWebSocketCommunicationManager.SendResponse(
new UsersNodeResponse(request.RequestId, privacyService.ApplyPrivacySettings(users, request.Phones, request.RequestorId)),
current);
}
public async Task <Response> CreateResponseAsync()
{
try
{
List <ChatUserVm> chatUsers = await loadChatsService.GetChatUsersAsync(
request.ChatId,
clientConnection.UserId.GetValueOrDefault(),
100,
request.NavigationUserId.GetValueOrDefault()).ConfigureAwait(false);
if (!chatUsers.Any(user => user.UserRole == UserRole.Creator))
{
var nodesIds = await loadChatsService.GetChatNodeListAsync(request.ChatId).ConfigureAwait(false);
var nodeConnection = connectionsService.GetNodeConnection(nodesIds.FirstOrDefault(id => id != NodeSettings.Configs.Node.Id));
if (nodeConnection != null)
{
var chat = await nodeRequestSender.GetFullChatInformationAsync(request.ChatId, nodeConnection).ConfigureAwait(false);
if (chat != null)
{
await crossNodeService.NewOrEditChatAsync(chat).ConfigureAwait(false);
chatUsers = chat.Users?.Take(100).ToList();
}
}
}
chatUsers.ForEach(item =>
{
if (item.UserInfo != null)
{
item.UserInfo = privacyService.ApplyPrivacySettings(
item.UserInfo,
item.UserInfo.Privacy);
}
});
return(new ChatUsersResponse(request.RequestId, chatUsers));
}
catch (GetUsersException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "User does not have access to the chat.", ErrorCode.PermissionDenied));
}
}
public async Task HandleAsync()
{
try
{
List <UserVm> users = null;
List <ChatVm> chats = null;
List <ChannelVm> channels = null;
foreach (var searchType in request.SearchTypes)
{
switch (searchType)
{
case SearchType.Users:
users = await loadUsersService.FindUsersByStringQueryAsync(request.SearchQuery, request.NavigationId, request.Direction).ConfigureAwait(false);
break;
case SearchType.Chats:
chats = await loadChatsService.FindChatsByStringQueryAsync(request.SearchQuery, request.NavigationId, request.Direction, request.RequestorId).ConfigureAwait(false);
break;
case SearchType.Channels:
channels = await loadChannelsService.FindChannelsByStringQueryAsync(request.SearchQuery, request.NavigationId, request.Direction).ConfigureAwait(false);
break;
default:
continue;
}
}
SearchNodeResponse response = new SearchNodeResponse(
request.RequestId,
privacyService.ApplyPrivacySettings(users, request.SearchQuery, request.RequestorId),
channels,
chats);
NodeWebSocketCommunicationManager.SendResponse(response, current);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
NodeWebSocketCommunicationManager.SendResponse(new ResultNodeResponse(request.RequestId, ErrorCode.UnknownError, ex.ToString()), current);
}
}
public void UserApplyPrivacySettings()
{
var user = UserConverter.GetUserVm(fillTestDbHelper.Users.FirstOrDefault());
var hiddenUser = privacyService.ApplyPrivacySettings(user, user.Privacy);
user.Privacy[1] = true;
user.Privacy[2] = true;
var publicUser = privacyService.ApplyPrivacySettings(user, user.Privacy);
Assert.True(hiddenUser.About == null &&
hiddenUser.NameFirst == null &&
hiddenUser.NameSecond == null &&
hiddenUser.Tag == null &&
hiddenUser.Photo == null &&
hiddenUser.Emails == null &&
hiddenUser.Phones == null &&
publicUser.NameFirst != null &&
publicUser.NameSecond != null &&
publicUser.Tag != null &&
publicUser.About != null &&
publicUser.Photo != null);
}
public async Task <Response> CreateResponseAsync()
{
ConcurrentBag <UserVm> foundUsers = new ConcurrentBag <UserVm>();
ConcurrentBag <ChannelVm> foundChannels = new ConcurrentBag <ChannelVm>();
ConcurrentBag <ChatVm> foundChats = new ConcurrentBag <ChatVm>();
var nodesInfo = await nodesService.GetAllNodesInfoAsync().ConfigureAwait(false);
List <Task> searchTasks = new List <Task>();
foreach (var node in nodesInfo)
{
Task task = Task.Run(async() =>
{
var nodeConnection = connectionsService.GetNodeConnection(node.Id);
if (nodeConnection != null)
{
SearchNodeResponse searchNodeResponse = await nodeRequestSender.GetSearchResponseAsync(
request.SearchQuery, request.NavigationId, request.Direction, request.SearchTypes, clientConnection.UserId, nodeConnection).ConfigureAwait(false);
if (searchNodeResponse?.Users != null)
{
foundUsers.AddRange(searchNodeResponse.Users);
}
if (searchNodeResponse?.Chats != null)
{
foundChats.AddRange(searchNodeResponse.Chats);
}
if (searchNodeResponse?.Channels != null)
{
foundChannels.AddRange(searchNodeResponse.Channels);
}
await MetricsHelper.Instance.SetCrossNodeApiInvolvedAsync(request.RequestId).ConfigureAwait(false);
}
else if (NodeSettings.Configs.Node.Id == node.Id)
{
foreach (var searchType in request.SearchTypes.Distinct())
{
switch (searchType)
{
case SearchType.Users:
{
List <UserVm> users = await loadUsersService.FindUsersByStringQueryAsync(
request.SearchQuery,
request.NavigationId.GetValueOrDefault(),
request.Direction.GetValueOrDefault(true)).ConfigureAwait(false);
foundUsers.AddRange(privacyService.ApplyPrivacySettings(users, request.SearchQuery, clientConnection.UserId));
}
break;
case SearchType.Chats:
{
List <ChatVm> chats = await loadChatsService.FindChatsByStringQueryAsync(
request.SearchQuery,
request.NavigationId.GetValueOrDefault(),
request.Direction.GetValueOrDefault(true),
clientConnection.UserId).ConfigureAwait(false);
foundChats.AddRange(chats);
}
break;
case SearchType.Channels:
{
List <ChannelVm> channels = await loadChannelsService.FindChannelsByStringQueryAsync(
request.SearchQuery,
request.NavigationId.GetValueOrDefault(),
request.Direction.GetValueOrDefault(true)).ConfigureAwait(false);
foundChannels.AddRange(channels);
}
break;
default:
continue;
}
}
}
});
searchTasks.Add(task);
}
await Task.WhenAll(searchTasks).ConfigureAwait(false);
foundChats = new ConcurrentBag <ChatVm>(foundChats.DistinctBy(opt => opt.Id));
foundChannels = new ConcurrentBag <ChannelVm>(foundChannels.DistinctBy(opt => opt.ChannelId));
return(new SearchResponse(request.RequestId,
request.Direction.GetValueOrDefault(true) ? foundUsers.OrderBy(opt => opt.Id) : foundUsers.OrderByDescending(opt => opt.Id),
request.Direction.GetValueOrDefault(true) ? foundChats.OrderBy(opt => opt.Id) : foundChats.OrderByDescending(opt => opt.Id),
request.Direction.GetValueOrDefault(true) ? foundChannels.OrderBy(opt => opt.ChannelId) : foundChannels.OrderByDescending(opt => opt.ChannelId)));
}
