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);
}
}
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);
}
}
public async void SendSystemMessageNoticeAsync(MessageDto message)
{
switch (message.ConversationType)
{
case ConversationType.Dialog:
{
var mirrorDialog = await loadDialogsService.GetDialogAsync(message.ConversationId).ConfigureAwait(false);
var secondMessage = (MessageDto)message.Clone();
secondMessage.ConversationId = mirrorDialog.Id;
var firstUserConnections = connectionsService.GetUserClientConnections(mirrorDialog.FirstUserId);
var secondUserConnections = connectionsService.GetUserClientConnections(mirrorDialog.SecondUserId);
var firstUserNotice = new NewMessageNotice(MessageConverter.GetMessageVm(secondMessage, null), false);
var secondUserNotice = new NewMessageNotice(MessageConverter.GetMessageVm(message, null), false);
await SendNoticeToClientsAsync(firstUserConnections, firstUserNotice).ConfigureAwait(false);
await SendNoticeToClientsAsync(secondUserConnections, secondUserNotice).ConfigureAwait(false);
}
break;
case ConversationType.Chat:
{
var usersIds = await loadChatsService.GetChatUsersIdAsync(message.ConversationId).ConfigureAwait(false);
var notice = new NewMessageNotice(MessageConverter.GetMessageVm(message, null), false);
var clientsConnections = connectionsService.GetClientConnections(usersIds);
await SendNoticeToClientsAsync(clientsConnections, notice).ConfigureAwait(false);
}
break;
case ConversationType.Channel:
{
var usersIds = await loadChannelsService.GetChannelUsersIdAsync(message.ConversationId).ConfigureAwait(false);
var notice = new NewMessageNotice(MessageConverter.GetMessageVm(message, null), false);
var clientsConnections = connectionsService.GetClientConnections(usersIds);
await SendNoticeToClientsAsync(clientsConnections, notice).ConfigureAwait(false);
}
break;
}
}
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);
}
}
