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