private async Task HandleNewChatBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
NewChatBlockData newChatBlockData = (NewChatBlockData)segment.PublicData;
if (!await _context.Chats.AnyAsync(chat => chat.Id == newChatBlockData.Chat.Id).ConfigureAwait(false))
{
Chat newChat = ChatConverter.GetChat(newChatBlockData.Chat);
await _context.Chats.AddAsync(newChat).ConfigureAwait(false);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleNewChatBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
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 UserService()
{
_accountConverter = new AccountDataConverter();
UserProvider = new UserProvider();
_userConverter = new UserConverter();
_chatConverter = new ChatConverter();
}
public async Task <ChatVm> EditChatAsync(EditChatVm editChat, long userId)
{
using (MessengerDbContext context = contextFactory.Create())
{
IQueryable <Chat> query = from chat in context.Chats
join chatUser in context.ChatUsers on chat.Id equals chatUser.ChatId
join chatUsers in context.ChatUsers on chat.Id equals chatUsers.ChatId
where chat.Id == editChat.Id &&
chatUser.UserId == userId &&
chatUser.UserRole >= UserRole.Admin &&
chat.Deleted == false &&
chatUser.Banned == false &&
chatUser.Deleted == false &&
chatUsers.Banned == false &&
chatUsers.Deleted == false
select chat;
Chat targetChat = await query
.FirstOrDefaultAsync()
.ConfigureAwait(false);
if (targetChat != null)
{
targetChat = ChatConverter.GetChat(targetChat, editChat);
await context.SaveChangesAsync().ConfigureAwait(false);
return(ChatConverter.GetChatVm(targetChat));
}
throw new PermissionDeniedException();
}
}
private async Task HandleEditChatBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
EditChatBlockData blockData = (EditChatBlockData)segment.PublicData;
var editedChat = await _context.Chats.FirstOrDefaultAsync(chat => chat.Id == blockData.Chat.Id).ConfigureAwait(false);
if (editedChat != null)
{
editedChat = ChatConverter.GetChat(editedChat, ChatConverter.GetChatDto(blockData.Chat));
_context.Chats.Update(editedChat);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleEditChatBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
public async Task <List <ChatVm> > FindChatsByStringQueryAsync(string searchQuery, long?navigationId = 0, bool?direction = true, long?userId = null)
{
using (MessengerDbContext context = contextFactory.Create())
{
ExpressionsHelper helper = new ExpressionsHelper();
var searchExpression = helper.GetChatExpression(searchQuery);
IQueryable <Chat> query = context.Chats
.Where(opt => !opt.Deleted)
.AsNoTracking();
if (userId == null)
{
query = query.Where(opt => (opt.Type == (short)ChatType.Public));
}
else
{
query = query.Where(opt => opt.ChatUsers
.Any(chatUser => chatUser.UserId == userId && !chatUser.Banned && !chatUser.Deleted) || (opt.Type == (short)ChatType.Public));
}
query = query.Where(searchExpression);
if (direction.GetValueOrDefault() == true)
{
query = query.OrderBy(opt => opt.Id)
.Where(opt => opt.Id > navigationId.GetValueOrDefault());
}
else
{
query = query.OrderByDescending(opt => opt.Id)
.Where(opt => opt.Id < navigationId.GetValueOrDefault());
}
List <Chat> chats = await query.ToListAsync().ConfigureAwait(false);
return(ChatConverter.GetChatsVm(chats));
}
}
public async Task <List <ChatVm> > FindChatsAsync(SearchChatVm template, int limit = 100, long navigationChatId = 0, long?nodeId = null)
{
using (MessengerDbContext context = contextFactory.Create())
{
IQueryable <Chat> query;
if (template != null)
{
ExpressionsHelper expressionsHelper = new ExpressionsHelper();
query = context.Chats
.AsNoTracking()
.OrderBy(chat => chat.Id)
.Where(expressionsHelper.GetChatExpression(template))
.Take(limit);
}
else
{
query = context.Chats
.AsNoTracking()
.OrderBy(chat => chat.Id)
.Take(limit);
}
if (nodeId != null)
{
query = query.Where(chat => chat.NodesId.Contains(nodeId.Value));
}
List <Chat> result = await query
.Where(chat => chat.Deleted == false && chat.Id > navigationChatId && (ChatType)chat.Type != ChatType.Private)
.ToListAsync()
.ConfigureAwait(false);
return(ChatConverter.GetChatsVm(result));
}
}
public ChatService()
{
ChatProvider = new ChatProvider();
MessageProvider = new MessageProvider();
_userConverter = new UserConverter();
_chatConverter = new ChatConverter();
_messageConverter = new MessageConverter();
}
public async Task <ChatVm> GetChatByIdAsync(long chatId)
{
using (MessengerDbContext context = contextFactory.Create())
{
return(ChatConverter.GetChatVm(await context.Chats
.AsNoTracking()
.Include(chat => chat.ChatUsers)
.FirstOrDefaultAsync(chat => chat.Id == chatId)
.ConfigureAwait(false)));
}
}
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));
}
}
}
private async Task HandlePrivateChatSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
bool chatExists = !await _context.Chats.AnyAsync(chat => chat.Id == segment.SegmentHeader.ObjectId).ConfigureAwait(false);
if (TryDecryptPrivateData <PrivateChatPrivateData>(segment, out var privateData))
{
Chat newChat = ChatConverter.GetChat(privateData.Chat);
if (!chatExists)
{
await _context.Chats.AddAsync(newChat).ConfigureAwait(false);
}
else
{
_context.Chats.Attach(newChat);
_context.Chats.Update(newChat);
}
}
else
{
if (!chatExists)
{
Chat emptyChat = new Chat
{
Id = segment.SegmentHeader.ObjectId,
Type = (short)ChatType.Private,
Name = "Restored-private-chat"
};
await _context.Chats.AddAsync(emptyChat).ConfigureAwait(false);
}
}
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandlePrivateChatSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
public async Task CreateChats()
{
var creator = fillTestDbHelper.Users.FirstOrDefault();
var users = fillTestDbHelper.Users.Where(opt => !opt.BlackList.Any(p => p.BadUid == creator.Id) && !creator.BlackList.Any(p => p.BadUid == opt.Id)).Take(5).ToList();
ChatVm newChat = new ChatVm
{
About = "Create chat test 2",
Name = "Chat",
Users = users.Select(opt => new ChatUserVm
{
UserId = opt.Id,
UserRole = opt.Id == creator.Id ? ObjectsLibrary.Enums.UserRole.Creator : ObjectsLibrary.Enums.UserRole.Moderator
}).ToList()
};
var userChats = fillTestDbHelper.Chats.Where(opt => opt.ChatUsers.Any(p => p.UserId == creator.Id));
var expectedChats = ChatConverter.GetChatsDto(userChats).Append(ChatConverter.GetChatDto(newChat)).ToList();
var actualChats = await createChatsService.CreateOrUpdateUserChatsAsync(expectedChats);
Assert.Equal(expectedChats.Count, actualChats.Count);
}
public async Task <List <ChatDto> > GetUserChatsAsync(long userId)
{
using (MessengerDbContext context = contextFactory.Create())
{
var query = from chat in context.Chats
join chatUser in context.ChatUsers on chat.Id equals chatUser.ChatId
where chatUser.UserId == userId &&
!chatUser.Deleted &&
!chatUser.Banned &&
!chat.Deleted
select chat;
var chats = await query.AsNoTracking()
.Include(opt => opt.ChatUsers)
.Include(opt => opt.Messages)
.ThenInclude(opt => opt.Attachments)
.ToListAsync()
.ConfigureAwait(false);
return(ChatConverter.GetChatsDto(chats));
}
}
public async Task <List <ChatDto> > CreateOrUpdateUserChatsAsync(List <ChatDto> userChats)
{
using (MessengerDbContext context = contextFactory.Create())
{
var chatsCondition = PredicateBuilder.New <Chat>();
chatsCondition = userChats.Aggregate(chatsCondition,
(current, value) => current.Or(opt => opt.Id == value.Id).Expand());
List <ChatDto> resultChats = new List <ChatDto>();
List <Chat> existingChats = await context.Chats
.Where(chatsCondition)
.ToListAsync()
.ConfigureAwait(false);
if (existingChats.Any())
{
for (int i = 0; i < existingChats.Count; i++)
{
var editedChat = userChats.FirstOrDefault(opt => opt.Id == existingChats[i].Id);
editedChat.ChatUsers = null;
existingChats[i] = ChatConverter.GetChat(existingChats[i], editedChat);
}
context.Chats.UpdateRange(existingChats);
await context.SaveChangesAsync().ConfigureAwait(false);
resultChats.AddRange(ChatConverter.GetChatsDto(existingChats));
}
List <ChatDto> nonExistingChats = userChats.Where(chat => !existingChats.Any(opt => opt.Id == chat.Id))?.ToList();
if (nonExistingChats != null && nonExistingChats.Any())
{
List <Chat> newChats = nonExistingChats.Select(chat => ChatConverter.GetChat(null, chat))?.ToList();
await context.Chats.AddRangeAsync(newChats).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
resultChats.AddRange(ChatConverter.GetChatsDto(newChats));
}
return(resultChats);
}
}
public async Task <List <ChatVm> > GetChatsNodeAsync(long userId = 0, byte limit = 100, long navigationId = 0)
{
try
{
using (MessengerDbContext context = contextFactory.Create())
{
List <Chat> chats;
if (userId == 0)
{
chats = await context.Chats
.AsNoTracking()
.OrderBy(chat => chat.Id)
.Where(chat => chat.Id > navigationId && ((ChatType)chat.Type) != ChatType.Private)
.Take(limit)
.ToListAsync()
.ConfigureAwait(false);
}
else
{
var query = from chat in context.Chats
join chatUser in context.ChatUsers on chat.Id equals chatUser.ChatId
where chatUser.UserId == userId && chatUser.Deleted == false
select chat;
chats = await query
.AsNoTracking()
.OrderBy(chat => chat.Id)
.Where(chat => chat.Id > navigationId)
.Take(limit)
.ToListAsync()
.ConfigureAwait(false);
}
return(ChatConverter.GetChatsVm(chats));
}
}
catch (Exception ex)
{
throw new GetConversationsException("Error when retrieving chat list.", ex);
}
}
public async Task <List <ChatVm> > GetChatsByIdAsync(IEnumerable <long> chatsId, long?userId)
{
using (MessengerDbContext context = contextFactory.Create())
{
var chatsCondition = PredicateBuilder.New <Chat>();
chatsCondition = chatsId.Aggregate(chatsCondition,
(current, value) => current.Or(opt => opt.Id == value && !opt.Deleted).Expand());
var query = context.Chats
.Where(chatsCondition);
if (userId != null)
{
query = query.Where(opt => opt.ChatUsers.Any(user => (user.UserId == userId && !user.Banned && !user.Deleted) || opt.Type == (short)ChatType.Public));
}
else
{
query = query.Where(opt => opt.Type == (short)ChatType.Public);
}
var chats = await query.ToListAsync().ConfigureAwait(false);
return(ChatConverter.GetChatsVm(chats));
}
}
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);
}
}
}
