public async Task <Response> CreateResponseAsync()
{
List <UserVm> users = await loadUsersService.GetUsersAsync(request.User, 100, request.NavigationUserId.GetValueOrDefault()).ConfigureAwait(false);
users = await privacyService.ApplyPrivacySettingsAsync(users).ConfigureAwait(false);
return(new FoundUsersResponse(request.RequestId, request.User, users));
}
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 ApplyPrivacySettingsGroupsAndContacts()
{
var user = fillTestDbHelper.Users.FirstOrDefault();
var firstUser = UserConverter.GetUserVm(fillTestDbHelper.Users.FirstOrDefault());
var secondUser = UserConverter.GetUserVm(fillTestDbHelper.Users.Skip(1).FirstOrDefault());
var thirdUser = UserConverter.GetUserVm(fillTestDbHelper.Users.Skip(2).FirstOrDefault());
var fourthUser = UserConverter.GetUserVm(fillTestDbHelper.Users.Skip(3).FirstOrDefault());
await contactsService.RemoveContactsAsync(user.Contacts.Select(opt => opt.ContactId).ToList(), user.Id);
var secondContact = await contactsService.CreateOrEditContactAsync(new ContactDto
{
ContactUserId = secondUser.Id.Value,
UserId = firstUser.Id.Value
});
var thirdContact = await contactsService.CreateOrEditContactAsync(new ContactDto
{
ContactUserId = thirdUser.Id.Value,
UserId = firstUser.Id.Value
});
var group = await gropsService.CreateOrEditGroupAsync(new GroupDto
{
UserId = firstUser.Id.Value,
UsersId = new List <long> {
thirdContact.ContactUserId
},
PrivacySettings = int.MaxValue
});
firstUser.ContactsPrivacy[1] = true;
var filteredBySecondUser = (await privacyService.ApplyPrivacySettingsAsync(new List <UserVm> {
firstUser
}, secondUser.Id)).FirstOrDefault();
Assert.True(filteredBySecondUser.NameFirst != null &&
filteredBySecondUser.NameSecond != null &&
filteredBySecondUser.Tag != null &&
filteredBySecondUser.About == null &&
filteredBySecondUser.Photo == null &&
filteredBySecondUser.Phones == null &&
filteredBySecondUser.Emails == null);
var filteredByThirdUser = (await privacyService.ApplyPrivacySettingsAsync(new List <UserVm> {
firstUser
}, thirdUser.Id)).FirstOrDefault();
Assert.True(filteredByThirdUser.NameFirst != null &&
filteredByThirdUser.NameSecond != null &&
filteredByThirdUser.Tag != null &&
filteredByThirdUser.About != null &&
filteredByThirdUser.Photo != null &&
filteredByThirdUser.Phones != null &&
filteredByThirdUser.Emails != null);
var filteredByFourthUser = (await privacyService.ApplyPrivacySettingsAsync(new List <UserVm> {
firstUser
}, fourthUser.Id)).FirstOrDefault();
Assert.True(filteredByFourthUser.NameFirst == null &&
filteredByFourthUser.NameSecond == null &&
filteredByFourthUser.Tag == null &&
filteredByFourthUser.About == null &&
filteredByFourthUser.Photo == null &&
filteredByFourthUser.Phones == null &&
filteredByFourthUser.Emails == null);
}