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