public async void SendNewChatNoticeAsync(ChatVm newChat, ClientConnection requestorConnection)
{
try
{
if (newChat.Users == null)
{
return;
}
foreach (var chatUser in newChat.Users)
{
var clients = connectionsService.GetUserClientConnections(chatUser.UserId);
if (clients != null)
{
IEnumerable <ClientConnection> clientConnectionsWithoutCurrent = clients.Where(connection => requestorConnection != connection);
NewChatNotice newChatNotice = new NewChatNotice(newChat);
await SendNoticeToClientsAsync(clientConnectionsWithoutCurrent, newChatNotice).ConfigureAwait(false);
}
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
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 <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 <JsonResult> SendMessage(ChatVm data)
{
try
{
using (_entities = new DBEntities())
{
var userMasterId = Convert.ToInt64(CookieHelper.GetCookie(CookieName.UserMasterId));
if (data.ProjectId == 0)
{
}
else
{
var taskModule = await _entities.TaskMasters.FindAsync(data.TaskMasterId);
var commentMaster = new CommentMaster();
commentMaster.Message = data.Message;
commentMaster.TaskMasterId = data.TaskMasterId;
commentMaster.ProjectId = taskModule.ProjectId;
commentMaster.IsDelete = false;
commentMaster.CreatedDate = data.ChatDate;
commentMaster.UserMasterId = userMasterId;
_entities.CommentMasters.Add(commentMaster);
await _entities.SaveChangesAsync();
}
return(Json(new { status = true, JsonRequestBehavior.AllowGet }));
}
}
catch (Exception)
{
return(Json(new { status = false, JsonRequestBehavior.AllowGet }));
}
}
public static ChatDto GetChatDto(ChatVm chat)
{
if (chat == null)
{
return(null);
}
return(new ChatDto
{
About = chat.About,
Id = chat.Id.GetValueOrDefault(),
Name = chat.Name,
NodesId = chat.NodesId?.ToArray(),
Photo = chat.Photo,
Tag = chat.Tag,
Visible = chat.Visible,
Type = (short)chat.Type,
Public = chat.Public,
Security = chat.Security,
ChatUsers = chat.Users?.Select(opt => new ChatUserDto
{
ChatId = chat.Id.GetValueOrDefault(),
UserId = opt.UserId,
UserRole = opt.UserRole.GetValueOrDefault(),
Banned = opt.Banned.GetValueOrDefault(),
Deleted = opt.Deleted.GetValueOrDefault(),
InviterId = opt.InviterId.GetValueOrDefault(),
IsMuted = opt.IsMuted.GetValueOrDefault(),
Joined = opt.Joined.GetValueOrDefault()
})?.ToList()
});
}
public async Task HandleAsync()
{
try
{
var chatUsers = await updateChatsService.EditChatUsersAsync(notice.ChatUsers, notice.ChatId, notice.RequestedUserId).ConfigureAwait(false);
var bannedUsers = chatUsers.Where(opt => opt.Banned == true);
if (!bannedUsers.IsNullOrEmpty())
{
foreach (var user in bannedUsers)
{
var systemMessageInfo = SystemMessageInfoFactory.CreateUserBannedMessageInfo(user.UserId);
var message = await systemMessagesService.CreateMessageAsync(ConversationType.Chat, user.ChatId.Value, systemMessageInfo);
conversationsNoticeService.SendSystemMessageNoticeAsync(message);
}
}
var deletedUsers = chatUsers.Where(opt => opt.Deleted == true);
if (!deletedUsers.IsNullOrEmpty())
{
foreach (var user in deletedUsers)
{
var systemMessageInfo = SystemMessageInfoFactory.CreateUserRemovedMessageInfo(user.UserId);
var message = await systemMessagesService.CreateMessageAsync(ConversationType.Chat, user.ChatId.Value, systemMessageInfo);
conversationsNoticeService.SendSystemMessageNoticeAsync(message);
}
}
}
catch (UserIsNotInConversationException)
{
ChatVm newChat = await nodeRequestSender.GetFullChatInformationAsync(notice.ChatId, node).ConfigureAwait(false);
await crossNodeService.NewOrEditChatAsync(newChat).ConfigureAwait(false);
}
catch (ConversationNotFoundException ex)
{
ChatVm newChat = await nodeRequestSender.GetFullChatInformationAsync(ex.ConversationId, node).ConfigureAwait(false);
await crossNodeService.NewOrEditChatAsync(newChat).ConfigureAwait(false);
}
conversationsNoticeService.SendChangeChatUsersNoticeAsync(notice.ChatUsers, notice.ChatId);
ChatVm chat = await loadChatsService.GetChatByIdAsync(notice.ChatId).ConfigureAwait(false);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateChangeUsersChatSegmetAsync(
notice.ChatUsers,
notice.ChatId,
notice.RequestedUserId,
node.Node.Id,
chat.Type,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
}
public async Task <Response> CreateResponseAsync()
{
List <ChatVm> result = new List <ChatVm>();
try
{
foreach (var chat in request.Chats)
{
ChatVm editableChat = await loadChatsService.GetChatByIdAsync(chat.Id);
ChatVm editedChat =
await updateChatsService.EditChatAsync(chat, clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
result.Add(editedChat);
if (editableChat.Name != editedChat.Name)
{
var systemMessageInfo = SystemMessageInfoFactory.CreateNameChangedMessageInfo(editableChat.Name, editedChat.Name);
var message = await systemMessagesService.CreateMessageAsync(ConversationType.Chat, editedChat.Id.Value, systemMessageInfo);
conversationsNoticeService.SendSystemMessageNoticeAsync(message);
}
List <BlockSegmentVm> segments = await BlockSegmentsService.Instance.CreateEditPrivateChatSegmentsAsync(
editedChat,
NodeSettings.Configs.Node.Id,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
if (segments.Any())
{
nodeNoticeService.SendBlockSegmentsNodeNoticeAsync(segments.ToList());
foreach (var segment in segments)
{
BlockGenerationHelper.Instance.AddSegment(segment);
}
}
editedChat.Users = null;
conversationsNoticeService.SendEditChatNoticeAsync(editedChat, clientConnection);
IEnumerable <long> chatUsersId = await loadChatsService.GetChatUsersIdAsync(chat.Id).ConfigureAwait(false);
UsersConversationsCacheService.Instance.UpdateUsersChatsAsync(chatUsersId);
}
nodeNoticeService.SendEditChatsNodeNoticeAsync(result);
return(new ChatsResponse(request.RequestId, result));
}
catch (PermissionDeniedException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "Chat not found or user does not have access to chat.", ErrorCode.PermissionDenied));
}
}
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 void SendAddUsersToChatNodeNoticeAsync(ChatVm chat, long requestorId)
{
try
{
List <long> newUsersId = chat.Users.Select(chatUser => chatUser.UserId).ToList();
AddUsersChatNodeNotice notice = new AddUsersChatNodeNotice(chat.Id.Value, newUsersId, requestorId);
await SendNoticeToNodesAsync(notice, chat.NodesId).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public ChatVm ApplyPrivacySettings(ChatVm chat, BitArray mask)
{
ChatVm result = new ChatVm
{
Users = new List <ChatUserVm>(),
Id = chat.Id,
Type = chat.Type
};
if (mask[0])
{
result.Name = chat.Name;
result.Tag = chat.Tag;
}
if (mask[1])
{
result.Photo = chat.Photo;
result.About = chat.About;
}
if (mask[2])
{
result.Public = chat.Public;
}
if (mask[3])
{
result.Security = chat.Security;
}
if (chat.Users != null)
{
if (mask[4])
{
result.Users.AddRange(chat.Users.Where(chatUser => chatUser.UserRole == UserRole.User).ToList());
}
if (mask[5])
{
result.Users.AddRange(chat.Users.Where(chatUser => chatUser.UserRole == UserRole.Admin).ToList());
}
if (mask[6])
{
result.Users.AddRange(chat.Users.Where(chatUser => chatUser.UserRole == UserRole.Moderator).ToList());
}
if (mask[7])
{
result.Users.AddRange(chat.Users.Where(chatUser => chatUser.Banned == true).ToList());
}
}
return(result);
}
private async Task HandleChatMessagesAsync(IEnumerable <MessageVm> messages)
{
foreach (var message in messages)
{
if (NodeData.Instance.RoutedMessagesId.Contains(message.GlobalId.GetValueOrDefault()))
{
continue;
}
if (message.Attachments != null)
{
foreach (var attachment in message.Attachments)
{
attachment.MessageId = 0;
}
await attachmentsService.DownloadAttachmentsPayloadAsync(message.Attachments, current).ConfigureAwait(false);
await attachmentsService.ThrowIfAttachmentsInvalidAsync(message, true).ConfigureAwait(false);
}
MessageDto sentMessage;
try
{
sentMessage = await createMessagesService.CreateChatMessageAsync(MessageConverter.GetMessageDto(message), message.SenderId.GetValueOrDefault()).ConfigureAwait(false);
}
catch (ConversationNotFoundException ex)
{
ChatVm chat = await nodeRequestSender.GetFullChatInformationAsync(ex.ConversationId, current).ConfigureAwait(false);
await crossNodeService.NewOrEditChatAsync(chat).ConfigureAwait(false);
sentMessage = await createMessagesService.CreateChatMessageAsync(MessageConverter.GetMessageDto(message), message.SenderId.GetValueOrDefault()).ConfigureAwait(false);
}
catch (UserIsNotInConversationException ex)
{
List <ChatUserVm> chatUsers = await nodeRequestSender.GetChatUsersInformationAsync(
new List <long> {
ex.UserId.GetValueOrDefault()
},
ex.ChatId.GetValueOrDefault(),
current).ConfigureAwait(false);
await crossNodeService.AddChatUsersAsync(chatUsers).ConfigureAwait(false);
sentMessage = await createMessagesService.CreateChatMessageAsync(MessageConverter.GetMessageDto(message), message.SenderId.GetValueOrDefault()).ConfigureAwait(false);
}
SendNotificationsAsync(sentMessage);
NodeData.Instance.RoutedMessagesId.Add(message.GlobalId.GetValueOrDefault());
}
}
public async Task HandleAsync()
{
try
{
ChatVm chat = await loadChatsService.GetChatByIdAsync(request.ChatId).ConfigureAwait(false);
ChatsNodeResponse response = new ChatsNodeResponse(request.RequestId, new List <ChatVm> {
chat
});
NodeWebSocketCommunicationManager.SendResponse(response, current);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
NodeWebSocketCommunicationManager.SendResponse(new ResultNodeResponse(request.RequestId, ErrorCode.UnknownError), current);
}
}
public async Task CreateChat()
{
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 expectedChat = new ChatVm
{
About = "Create chat test",
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 actualChat = await createChatsService.CreateChatAsync(expectedChat, creator.Id);
Assert.True(expectedChat.About == actualChat.About && expectedChat.Name == actualChat.Name);
}
public ActionResult Index(int id)
{
if (db.Teams.FirstOrDefault(t => t.Id == id) == null || db.Chats.FirstOrDefault(c => c.TeamId == id) == null)
{
return(HttpNotFound());
}
ChatVm model = new ChatVm()
{
Users = db.Users.ToList(),
Team = db.Teams.FirstOrDefault(t => t.Id == id),
TeamMembers = db.TeamMembers.ToList(),
Files = db.Files.ToList()
};
model.Chat = db.Chats.FirstOrDefault(c => c.TeamId == model.Team.Id);
model.Messages = db.Messages.Where(m => m.ChatId == model.Chat.Id).OrderBy(m => m.Date).ToList();
return(View(model));
}
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 void SendEditChatNoticeAsync(ChatVm editedChat, ClientConnection clientConnection)
{
try
{
IEnumerable <long> chatUsersId = await loadChatsService.GetChatUsersIdAsync(editedChat.Id.Value).ConfigureAwait(false);
EditChatNotice notice = new EditChatNotice(editedChat);
foreach (long userId in chatUsersId)
{
var clientConnections = connectionsService.GetUserClientConnections(userId);
if (clientConnections != null)
{
await SendNoticeToClientsAsync(clientConnections.Where(opt => opt != clientConnection), notice).ConfigureAwait(false);
}
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public async Task <IActionResult> Index(string profileId)
{
string userId = User.GetUserId();
ChatVm vm = new ChatVm()
{
Participants = await _context.Conversations
.Where(c => c.Participants.Any(p => p.AppUserId == userId && p.CanAccessConversation))
.Include(p => p.Participants)
.ThenInclude(p => p.AppUser)
.Include(p => p.Participants)
.ThenInclude(p => p.Conversation)
.ToAsyncEnumerable()
.Select(c => c.Participants.FirstOrDefault(p => p.AppUserId != userId))
.ToList(),
LastMessages = await GetLastMessageOfConversation(),
ProfileId = profileId
};
return(View(vm));
}
public static Chat GetChat(ChatVm chat)
{
return(chat == null
? null
: new Chat
{
About = chat.About,
Id = chat.Id.GetValueOrDefault(),
Name = chat.Name,
Photo = chat.Photo,
Public = chat.Public,
Security = chat.Security,
Visible = chat.Visible,
Type = (short)chat.Type,
NodesId = chat.NodesId?.ToArray(),
Tag = chat.Tag,
Deleted = false
/*ChatUsers = chat.Users != null
* ? ChatUserBuilder.GetChatUsers(chat.Users)
* : null*/
});
}
public async Task <Response> CreateResponseAsync()
{
List <ChatVm> chats = new List <ChatVm>();
try
{
foreach (var chat in request.Chats)
{
ChatVm newChat = await createChatsService.CreateChatAsync(chat, clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
conversationsNoticeService.SendNewChatNoticeAsync(newChat, clientConnection);
UsersConversationsCacheService.Instance.UpdateUsersChatsAsync(newChat.Users.Select(opt => opt.UserId));
chats.Add(newChat);
List <BlockSegmentVm> segments = await BlockSegmentsService.Instance.CreateNewPrivateChatSegmentsAsync(
newChat,
NodeSettings.Configs.Node.Id,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
if (segments.Any())
{
BlockGenerationHelper.Instance.AddSegments(segments);
nodeNoticeService.SendBlockSegmentsNodeNoticeAsync(segments.ToList());
}
}
nodeNoticeService.SendNewChatsNodeNoticeAsync(chats);
return(new ChatsResponse(request.RequestId, chats));
}
catch (UserBlockedException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "The user is blacklisted by another user.", ErrorCode.UserBlocked));
}
}
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 ChatVm ApplyPrivacySettings(ChatVm chat, BitArray mask)
{
return(chat);
}
public async void SendChangeChatUsersNodeNoticeAsync(IEnumerable <ChatUserVm> chatUsers, long chatId, long requestorId, ChatVm chat)
{
try
{
ChangeUsersChatNodeNotice notice = new ChangeUsersChatNodeNotice(chatUsers, chatId, requestorId);
await SendNoticeToNodesAsync(notice, chat.NodesId).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public async Task <Response> CreateResponseAsync()
{
try
{
List <ChatUserVm> chatUsers = await updateChatsService.EditChatUsersAsync(
request.ChatUsers, request.ChatId, clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
var bannedUsers = chatUsers.Where(opt => opt.Banned == true);
if (!bannedUsers.IsNullOrEmpty())
{
foreach (var user in bannedUsers)
{
var systemMessageInfo = SystemMessageInfoFactory.CreateUserBannedMessageInfo(user.UserId);
var message = await systemMessagesService.CreateMessageAsync(ConversationType.Chat, user.ChatId.Value, systemMessageInfo);
conversationsNoticeService.SendSystemMessageNoticeAsync(message);
}
}
var deletedUsers = chatUsers.Where(opt => opt.Deleted == true);
if (!deletedUsers.IsNullOrEmpty())
{
foreach (var user in deletedUsers)
{
var systemMessageInfo = SystemMessageInfoFactory.CreateUserRemovedMessageInfo(user.UserId);
var message = await systemMessagesService.CreateMessageAsync(ConversationType.Chat, user.ChatId.Value, systemMessageInfo);
conversationsNoticeService.SendSystemMessageNoticeAsync(message);
}
}
ChatVm chat = await loadChatsService.GetChatByIdAsync(request.ChatId).ConfigureAwait(false);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateChangeUsersChatSegmetAsync(
chatUsers,
request.ChatId,
clientConnection.UserId.GetValueOrDefault(),
NodeSettings.Configs.Node.Id,
chat.Type,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId)
.ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
nodeNoticeService.SendBlockSegmentsNodeNoticeAsync(new List <BlockSegmentVm> {
segment
});
conversationsNoticeService.SendChangeChatUsersNoticeAsync(chatUsers, request.ChatId, clientConnection);
nodeNoticeService.SendChangeChatUsersNodeNoticeAsync(chatUsers.ToList(), request.ChatId, clientConnection.UserId.GetValueOrDefault(), chat);
UsersConversationsCacheService.Instance.UpdateUsersChatsAsync(chatUsers.Select(opt => opt.UserId));
return(new ChatUsersResponse(request.RequestId, chatUsers));
}
catch (ChatUserBlockedException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "User blocked in chat.", ErrorCode.UserBlocked));
}
catch (UserIsNotInConversationException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "User is not in chat.", ErrorCode.UserIsNotInChat));
}
catch (EditConversationUsersException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "User does not access to the chat.", ErrorCode.PermissionDenied));
}
catch (ConversationNotFoundException ex)
{
Logger.WriteLog(ex);
return(new ResultResponse(request.RequestId, "Chat not found.", ErrorCode.ObjectDoesNotExists));
}
}
