public async Task <ChatVm> NewOrEditChatAsync(ChatVm targetChat)
{
if (targetChat == null)
{
return(null);
}
try
{
using (MessengerDbContext context = contextFactory.Create())
{
var query = from chat in context.Chats
where chat.Id == targetChat.Id
select chat;
Chat editableChat = await query.Include(opt => opt.ChatUsers).FirstOrDefaultAsync().ConfigureAwait(false);
if (editableChat == null)
{
editableChat = ChatConverter.GetChat(targetChat);
if (targetChat.Users != null)
{
editableChat.ChatUsers = ChatUserConverter.GetChatUsers(targetChat.Users).ToList();
}
await context.AddAsync(editableChat).ConfigureAwait(false);
}
else
{
editableChat = ChatConverter.GetChat(editableChat, new EditChatVm
{
About = targetChat.About,
Name = targetChat.Name,
Photo = targetChat.Photo,
Public = targetChat.Public,
Security = targetChat.Security,
Visible = targetChat.Visible
});
if (!targetChat.Users.IsNullOrEmpty())
{
editableChat.ChatUsers = ChatUserConverter.GetChatUsers(targetChat.Users);
}
context.Update(editableChat);
}
await context.SaveChangesAsync().ConfigureAwait(false);
return(ChatConverter.GetChatVm(editableChat));
}
}
catch (DbUpdateException ex)
{
Logger.WriteLog(ex);
return(targetChat);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
return(null);
}
}
public async Task <List <ChatUserDto> > GetChatUsersAsync(IEnumerable <long> usersId, long chatId)
{
using (MessengerDbContext context = contextFactory.Create())
{
var chatUsersCondition = PredicateBuilder.New <ChatUser>();
chatUsersCondition = usersId.Aggregate(chatUsersCondition,
(current, value) =>
current.Or(chatUser => chatUser.UserId == value).Expand());
var query = context.ChatUsers
.AsNoTracking()
.OrderByDescending(chatUser => chatUser.UserRole)
.ThenBy(chatUser => chatUser.UserId)
.Where(chatUsersCondition)
.Where(chatUser => chatUser.Deleted == false && chatUser.Banned == false && chatUser.ChatId == chatId);
return(ChatUserConverter.GetChatUsersDto(await query.ToListAsync().ConfigureAwait(false)));
}
}
public async Task AddChatUsersAsync(IEnumerable <ChatUserVm> chatUsers)
{
try
{
var newChatUsers = ChatUserConverter.GetChatUsers(chatUsers);
using (MessengerDbContext context = contextFactory.Create())
{
await context.ChatUsers.AddRangeAsync(newChatUsers).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public async Task <List <ChatUserVm> > GetChatUsersAsync(long chatId, long?userId, int limit = 100, long navUserId = 0)
{
using (MessengerDbContext context = contextFactory.Create())
{
if (userId != null && !await IsUserJoinedToChatAsync(chatId, userId.Value).ConfigureAwait(false))
{
throw new GetUsersException();
}
var query = context.ChatUsers
.AsNoTracking()
.Where(chatUser => chatUser.ChatId == chatId && chatUser.Deleted == false && chatUser.Chat.Deleted == false)
.OrderByDescending(chatUser => chatUser.UserRole)
.ThenBy(chatUser => chatUser.UserId)
.Where(chatUser => chatUser.UserId > navUserId)
.Take(limit);
return(ChatUserConverter.GetChatUsersVm(await query.ToListAsync().ConfigureAwait(false)));
}
}
private async Task HandleChangeUsersChatSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
if (TryDecryptPrivateData <ChangeUsersChatBlockData>(segment, out var blockData))
{
var usersCondition = PredicateBuilder.New <ChatUser>();
usersCondition = blockData.ChatUsers.Aggregate(usersCondition,
(current, value) => current.Or(chatUser => chatUser.UserId == value.UserId && chatUser.ChatId == blockData.ChatId).Expand());
var existingChatUsers = await _context.ChatUsers.Where(usersCondition).ToListAsync().ConfigureAwait(false);
var nonExistingChatUsers = blockData.ChatUsers
.Where(chatUser => !existingChatUsers.Any(opt => chatUser.UserId == opt.UserId)).ToList();
if (nonExistingChatUsers.Any())
{
await _context.ChatUsers.AddRangeAsync(ChatUserConverter.GetChatUsers(nonExistingChatUsers)).ConfigureAwait(false);
}
var updatedChatUsersVm = blockData.ChatUsers.Where(chatUser => existingChatUsers.Any(opt => opt.UserId == chatUser.UserId));
if (updatedChatUsersVm.Any())
{
var updatedChatUsers = ChatUserConverter.GetChatUsers(updatedChatUsersVm);
_context.ChatUsers.AttachRange(updatedChatUsers);
_context.ChatUsers.UpdateRange(updatedChatUsers);
}
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleChangeUsersChatSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
public async Task AddUsersToChatAsync(long chatId, IEnumerable <long> usersId, long requestorId)
{
try
{
List <ChatUser> chatUsers = new List <ChatUser>();
foreach (long userId in usersId)
{
chatUsers.Add(ChatUserConverter.GetNewChatUser(chatId, userId, requestorId));
}
using (MessengerDbContext context = contextFactory.Create())
{
await context.AddRangeAsync(chatUsers).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public async Task <ChatVm> AddUsersToChatAsync(IEnumerable <long> usersId, long chatId, long userId)
{
using (MessengerDbContext context = contextFactory.Create())
{
using (var transaction = await context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
Chat chat = await context.Chats.FirstOrDefaultAsync(opt => opt.Id == chatId).ConfigureAwait(false);
if (chat == null)
{
throw new ConversationNotFoundException(chatId);
}
User requestingUser = await context.Users.FindAsync(userId).ConfigureAwait(false);
if (requestingUser == null || requestingUser.Deleted)
{
throw new AddUserChatException();
}
ChatUser chatUser = await context.ChatUsers
.FirstOrDefaultAsync(opt => opt.ChatId == chatId && opt.UserId == userId).ConfigureAwait(false);
List <ChatUserVm> addedUsers = new List <ChatUserVm>();
if (chat.Deleted)
{
throw new ConversationIsNotValidException();
}
if (chatUser != null && chatUser.Banned)
{
throw new ChatUserBlockedException();
}
if (usersId.Count() == 1 && usersId.FirstOrDefault() == userId)
{
if (chat.Type == (int)ChatType.Private)
{
throw new AddUserChatException();
}
if (chatUser == null)
{
chatUser = ChatUserConverter.GetNewChatUser(chatId, userId, null);
await context.AddAsync(chatUser).ConfigureAwait(false);
}
else if (chatUser.Deleted)
{
chatUser.Deleted = false;
chatUser.User = requestingUser;
context.Update(chatUser);
}
if (!chat.NodesId.Contains(NodeSettings.Configs.Node.Id))
{
createMessagesService.DownloadMessageHistoryAsync(chat.NodesId.FirstOrDefault(), chat.Id, ConversationType.Chat, null, false);
}
chat.NodesId = chat.NodesId.Append(requestingUser.NodeId.Value).Distinct().ToArray();
addedUsers.Add(ChatUserConverter.GetChatUserVm(chatUser));
}
else
{
if ((chatUser?.Deleted).GetValueOrDefault(true))
{
throw new AddUserChatException();
}
if (await loadUsersService.IsUserBlacklisted(userId, usersId).ConfigureAwait(false))
{
throw new UserBlockedException();
}
ExpressionStarter <User> usersCondition = PredicateBuilder.New <User>();
usersCondition = usersId.Aggregate(usersCondition,
(current, value) => current.Or(opt => opt.Id == value).Expand());
List <User> existingUsers = await context.Users
.AsNoTracking()
.Where(usersCondition)
.ToListAsync()
.ConfigureAwait(false);
ExpressionStarter <ChatUser> chatUsersCondition = PredicateBuilder.New <ChatUser>();
chatUsersCondition = existingUsers.Select(opt => opt.Id).Aggregate(chatUsersCondition,
(current, value) => current.Or(opt => opt.UserId == value && opt.ChatId == chatId).Expand());
List <ChatUser> validChatUsers = await context.ChatUsers
.Where(chatUsersCondition)
.Include(opt => opt.User)
.ToListAsync()
.ConfigureAwait(false);
foreach (ChatUser user in validChatUsers)
{
if (!user.Banned && user.Deleted)
{
user.Deleted = false;
addedUsers.Add(ChatUserConverter.GetChatUserVm(user));
}
}
context.UpdateRange(validChatUsers);
List <long> newChatUsersId = existingUsers.Select(opt => opt.Id).Except(validChatUsers.Select(opt => opt.UserId)).ToList();
List <ChatUser> newChatUsers = newChatUsersId.Select(id => ChatUserConverter.GetNewChatUser(chatId, id, userId)).ToList();
chat.NodesId = chat.NodesId?.Concat(existingUsers.Select(opt => opt.NodeId.GetValueOrDefault())).Distinct().ToArray()
?? existingUsers.Select(opt => opt.NodeId.GetValueOrDefault()).Distinct().ToArray();
await context.ChatUsers
.AddRangeAsync(newChatUsers)
.ConfigureAwait(false);
/* foreach (ChatUser user in newChatUsers)
* {
* user.User = existingUsers.FirstOrDefault(opt => opt.Id == user.UserId);
* }*/
addedUsers.AddRange(ChatUserConverter.GetChatUsersVm(newChatUsers));
}
context.Update(chat);
transaction.Commit();
await context.SaveChangesAsync()
.ConfigureAwait(false);
ChatVm resultChat = ChatConverter.GetChatVm(chat);
resultChat.Users = addedUsers;
return(resultChat);
}
}
}
public async Task <List <ChatUserVm> > EditChatUsersAsync(IEnumerable <ChatUserVm> users, long chatId, long userId)
{
using (MessengerDbContext context = contextFactory.Create())
{
ExpressionStarter <ChatUser> usersCondition = PredicateBuilder.New <ChatUser>();
usersCondition = users.Select(chatUser => chatUser.UserId).Aggregate(usersCondition,
(current, value) => current.Or(chatUser => chatUser.UserId == value).Expand());
Chat currentChat = await context.Chats.FindAsync(chatId).ConfigureAwait(false);
if (currentChat == null || currentChat.Deleted)
{
throw new ConversationNotFoundException();
}
List <ChatUser> chatUsers = await context.ChatUsers
.Where(usersCondition)
.Where(chatUser => chatUser.ChatId == chatId)
.ToListAsync()
.ConfigureAwait(false);
List <ChatUserVm> editedChatUsers = new List <ChatUserVm>();
ChatUser requestUser = await context.ChatUsers
.FirstOrDefaultAsync(opt => opt.UserId == userId && opt.ChatId == chatId).ConfigureAwait(false);
if (requestUser != null && requestUser.Banned)
{
throw new ChatUserBlockedException();
}
if (requestUser == null || !chatUsers.Any())
{
throw new UserIsNotInConversationException();
}
foreach (ChatUser user in chatUsers)
{
ChatUserVm changedChatUser = users.FirstOrDefault(chatUser => user.UserId == chatUser.UserId);
if (changedChatUser != null)
{
if (requestUser.UserRole > changedChatUser.UserRole &&
requestUser.UserRole > user.UserRole &&
changedChatUser.UserRole < UserRole.Creator)
{
user.UserRole = changedChatUser.UserRole ?? user.UserRole;
user.Deleted = changedChatUser.Deleted ?? user.Deleted;
user.Banned = changedChatUser.Banned ?? user.Banned;
editedChatUsers.Add(ChatUserConverter.GetChatUserVm(user));
}
else if (requestUser.UserId == changedChatUser.UserId)
{
user.Deleted = changedChatUser.Deleted ?? user.Deleted;
editedChatUsers.Add(ChatUserConverter.GetChatUserVm(user));
}
else
{
throw new EditConversationUsersException();
}
}
}
if (users.Any(opt => opt.Deleted.GetValueOrDefault() || opt.Banned.GetValueOrDefault()))
{
var query = from chat in context.Chats
join chatUser in context.ChatUsers on chat.Id equals chatUser.ChatId
join user in context.Users on chatUser.UserId equals user.Id
where chat.Id == chatId && !chatUser.Banned && !chatUser.Deleted
select user.NodeId;
var chatNodesId = (await query.ToListAsync().ConfigureAwait(false)).Distinct();
currentChat.NodesId = chatNodesId.Select(id => id.GetValueOrDefault()).ToArray();
}
await context.SaveChangesAsync().ConfigureAwait(false);
return(editedChatUsers);
}
}
public async Task HandleAsync()
{
try
{
List <ChatUserDto> chatUsers = await loadChatsService.GetChatUsersAsync(request.UsersId, request.ChatId).ConfigureAwait(false);
ChatUsersNodeResponse response = new ChatUsersNodeResponse(request.RequestId, ChatUserConverter.GetChatUsersVm(chatUsers));
NodeWebSocketCommunicationManager.SendResponse(response, current);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
NodeWebSocketCommunicationManager.SendResponse(new ResultNodeResponse(request.RequestId, ObjectsLibrary.Enums.ErrorCode.UnknownError), current);
}
}
