public async void SendNewMessageNoticeToChatUsersAsync(MessageDto newMessage, ClientConnection connection, bool sendPush = true) { try { List <ChatUserVm> chatUsers = await loadChatsService.GetChatUsersAsync(newMessage.ConversationId, null).ConfigureAwait(false); if (sendPush) { pushNotificationsService.SendMessageNotificationAsync( newMessage, chatUsers.Select(opt => new NotificationUser(opt.UserId, opt.IsMuted.Value)).ToList()); } List <Task> noticeTasks = new List <Task>(); foreach (var chatUser in chatUsers) { var clientConnections = connectionsService.GetUserClientConnections(chatUser.UserId); if (clientConnections != null) { noticeTasks.Add(Task.Run(async() => { NewMessageNotice notice = new NewMessageNotice( MessageConverter.GetMessageVm(newMessage, chatUser.UserId), MarkdownHelper.ContainsMarkdownUserCalling(newMessage.Text, chatUser.UserId)); await SendNoticeToClientsAsync(clientConnections.Where(clientConnection => clientConnection != connection), notice).ConfigureAwait(false); })); } } await Task.WhenAll(noticeTasks).ConfigureAwait(false); } catch (Exception ex) { Logger.WriteLog(ex); } }
private async Task SendChannelMessageNotificationAsyhc(MessageDto message, List <NotificationUser> notificationsUsers) { try { var administratorsChannel = await loadChannelsService.GetAdministrationChannelUsersAsync(message.ConversationId).ConfigureAwait(false); IEnumerable <TokenVm> tokens = await tokensService.GetAllUsersTokensAsync( notificationsUsers.Where(user => user.UserId != message.SenderId).Select(user => user.UserId)).ConfigureAwait(false); foreach (var user in notificationsUsers) { bool isCall = MarkdownHelper.ContainsMarkdownUserCalling(message.Text, user.UserId); var userTokens = GetOfflineUserTokens(tokens.ToList(), user.UserId); List <TokenVm> adminTokens = tokens.Where(token => administratorsChannel.Any(admin => admin.UserId == token.UserId))?.ToList(); if (adminTokens != null && adminTokens.Any()) { adminTokens = GetOfflineUserTokens(adminTokens, user.UserId); var messageVm = MessageConverter.GetMessageVm(message, user.UserId); if (messageVm.Attachments?.Any(attach => attach.Type == AttachmentType.EncryptedMessage) ?? false) { messageVm.Attachments = null; } if (adminTokens != null && (!user.IsMuted || isCall)) { await SendNotificationRequestAsync( adminTokens.Select(opt => opt.DeviceTokenId), new NewMessageNotice(messageVm, isCall)) .ConfigureAwait(false); } } else if (!user.IsMuted || isCall) { MessageVm subMessage = MessageConverter.GetMessageVm(message, user.UserId); subMessage.SenderId = null; await SendNotificationRequestAsync( userTokens.Select(opt => opt.DeviceTokenId), new NewMessageNotice(subMessage, isCall)) .ConfigureAwait(false); } } } catch (Exception ex) { Logger.WriteLog(ex); } }
public async void SendNewMessageNoticeToChannelUsersAsync(MessageDto newMessage, ClientConnection clientConnection = null, bool sendPush = true) { try { var channelUsers = await loadChannelsService.GetChannelUsersAsync(newMessage.ConversationId, null, null).ConfigureAwait(false); if (sendPush) { pushNotificationsService.SendMessageNotificationAsync( newMessage, channelUsers.Select(opt => new NotificationUser(opt.UserId, opt.IsMuted.Value)).ToList()); } var administrationUsers = await loadChannelsService.GetAdministrationChannelUsersAsync(newMessage.ConversationId).ConfigureAwait(false); foreach (var channelUser in channelUsers) { var clientConnections = connectionsService.GetUserClientConnections(channelUser.UserId); if (clientConnections != null) { clientConnections = clientConnections.Where(opt => opt != clientConnection).ToList(); NewMessageNotice notice; if (channelUser.UserId == newMessage.SenderId || administrationUsers.Any(opt => opt.UserId == channelUser.UserId)) { notice = new NewMessageNotice( MessageConverter.GetMessageVm(newMessage, channelUser.UserId), MarkdownHelper.ContainsMarkdownUserCalling(newMessage.Text, channelUser.UserId)); } else { MessageVm tempMessage = new MessageVm(MessageConverter.GetMessageVm(newMessage, channelUser.UserId)) { SenderId = null }; notice = new NewMessageNotice( tempMessage, MarkdownHelper.ContainsMarkdownUserCalling(tempMessage.Text, channelUser.UserId)); } await SendNoticeToClientsAsync(clientConnections, notice).ConfigureAwait(false); } } } catch (Exception ex) { Logger.WriteLog(ex); } }
private async Task SendChatMessageNotificationAsync(MessageDto message, List <NotificationUser> notificationsUsers) { try { IEnumerable <TokenVm> tokens = await tokensService.GetAllUsersTokensAsync( notificationsUsers.Where(option => option.UserId != message.SenderId).Select(option => option.UserId), true).ConfigureAwait(false); List <Task> noticeTasks = new List <Task>(); foreach (var user in notificationsUsers) { noticeTasks.Add(Task.Run(async() => { var userTokens = GetOfflineUserTokens(tokens.ToList(), user.UserId); var messageVm = MessageConverter.GetMessageVm(message, user.UserId); if (messageVm.Attachments?.Any(attach => attach.Type == AttachmentType.EncryptedMessage) ?? false) { messageVm.Attachments = null; } bool isCall = MarkdownHelper.ContainsMarkdownUserCalling(message.Text, user.UserId); if (isCall || !user.IsMuted) { await SendNotificationRequestAsync( userTokens.Select(opt => opt.DeviceTokenId), new NewMessageNotice(messageVm, isCall)).ConfigureAwait(false); } })); } await Task.WhenAll(noticeTasks).ConfigureAwait(false); } catch (Exception ex) { Logger.WriteLog(ex); } }
private async Task SendDialogMessageNotificationAsync(NotificationUser notificationUser, MessageDto message) { try { List <TokenVm> tokens = await tokensService.GetAllUsersTokensAsync(new List <long> { notificationUser.UserId }).ConfigureAwait(false); var clientConnections = connectionsService.GetUserClientConnections(notificationUser.UserId); if (clientConnections != null) { tokens = GetOfflineUserTokens(tokens, notificationUser.UserId); } if (tokens.Any()) { var messageVm = MessageConverter.GetMessageVm(message, notificationUser.UserId); if (messageVm.Attachments?.Any(attach => attach.Type == AttachmentType.EncryptedMessage) ?? false) { messageVm.Attachments = null; } bool isCall = MarkdownHelper.ContainsMarkdownUserCalling(message.Text, notificationUser.UserId); if (!notificationUser.IsMuted || isCall) { await SendNotificationRequestAsync( tokens.Select(opt => opt.DeviceTokenId), new NewMessageNotice(messageVm, isCall)) .ConfigureAwait(false); } } } catch (Exception ex) { Logger.WriteLog(ex); } }
public async void SendNewMessageNoticeToDialogUsers(IEnumerable <MessageDto> messages, ClientConnection senderClientConnection, long receiverId, bool saveMessageFlag = true) { try { long senderId = messages.FirstOrDefault().SenderId.GetValueOrDefault(); var dialogs = await loadDialogsService.GetUsersDialogsAsync(senderId, receiverId); var currentDialog = dialogs.FirstOrDefault(dial => dial.FirstUserId == receiverId); Notice senderNotice = default; if (senderId != receiverId) { var message = messages.FirstOrDefault(mess => mess.ConversationId != currentDialog.Id); senderNotice = new NewMessageNotice( MessageConverter.GetMessageVm(message, senderId), MarkdownHelper.ContainsMarkdownUserCalling(message.Text, receiverId)); } else { var message = messages.FirstOrDefault(); senderNotice = new NewMessageNotice( MessageConverter.GetMessageVm(message, senderId), MarkdownHelper.ContainsMarkdownUserCalling(message.Text, receiverId)); } var senderClients = connectionsService.GetUserClientConnections(messages.ElementAt(0).SenderId.GetValueOrDefault()); if (senderClients != null) { IEnumerable <ClientConnection> senderConnectionsExceptCurrent = senderClients.Where(connection => !Equals(senderClientConnection, connection)); await SendNoticeToClientsAsync(senderConnectionsExceptCurrent, senderNotice).ConfigureAwait(false); } if (messages.Count() == 2) { var message = messages.FirstOrDefault(mess => mess.ConversationId == currentDialog.Id); var receiverClients = connectionsService.GetUserClientConnections(receiverId); Notice receiverNotice = new NewMessageNotice( MessageConverter.GetMessageVm(message, receiverId), MarkdownHelper.ContainsMarkdownUserCalling(message.Text, receiverId)); if (receiverClients != null && receiverClients.Any()) { await SendNoticeToClientsAsync(receiverClients, receiverNotice).ConfigureAwait(false); } else { var receiver = await loadUsersService.GetUserAsync(receiverId).ConfigureAwait(false); if (receiver.NodeId == NodeSettings.Configs.Node.Id && !saveMessageFlag) { await pendingMessagesService.AddUserPendingMessageAsync(receiverId, receiverNotice, message.GlobalId).ConfigureAwait(false); } } } DialogDto dialog = await loadDialogsService.GetDialogAsync(currentDialog.Id).ConfigureAwait(false); pushNotificationsService.SendMessageNotificationAsync( messages.FirstOrDefault(opt => opt.ConversationId == currentDialog.Id), new List <NotificationUser> { new NotificationUser(dialog.FirstUserId, dialog.IsMuted) }); } catch (Exception ex) { Logger.WriteLog(ex); } }