public async Task <bool> InitiateSupportRequest(ChatViewModel message)
{
if (!string.IsNullOrEmpty(_chatSettings.CurrentChatUser))
{
var user = await _userManager.FindByEmailAsync(_chatSettings.CurrentChatUser);
if (!string.IsNullOrEmpty(user?.Id))
{
//send firebase message to notify via web worker
var pushMessage = new PushMessage(message.Message)
{
Topic = "New support chat message",
Urgency = PushMessageUrgency.Normal
};
await _subscriptionStore.ForEachSubscriptionAsync(user.Id, (PushSubscription subscription) => {
_notificationService.SendNotificationAsync(subscription, pushMessage, string.Empty);
});
// await _hub.SendUserAsync(user.Id, "support-message", new object[] { message });
//send slack message
var slackResult = await _slackSupport.NotifyUser(message);
return(true);
}
}
return(false);
}
public async Task <IActionResult> SendNotification([FromBody] string payload)
{
// TODO: This should be scheduled in background
await _subscriptionStore.ForEachSubscriptionAsync((PushSubscription subscription) => _notificationService.SendNotification(subscription, payload));
return(NoContent());
}
public async Task <IActionResult> SendNotification([FromBody] PushMessageViewModel message)
{
PushMessage pushMessage = new PushMessage(message.Notification)
{
Topic = message.Topic,
Urgency = message.Urgency
};
// TODO: This should be scheduled in background
await _subscriptionStore.ForEachSubscriptionAsync((PushSubscription subscription) => _notificationService.SendNotification(subscription, pushMessage));
return(NoContent());
}
public async void SendNotificationAsync(PushMessage message)
{
await _subscriptionStore.ForEachSubscriptionAsync(async (subscription) =>
{
try
{
await _pushClient.RequestPushMessageDeliveryAsync(subscription, message);
}
catch (Exception ex)
{
await HandlePushMessageDeliveryException(ex, subscription);
}
});
}
public async Task <string> ServerPush(string message)
{
var response = new StringBuilder();
var pushMessage = new WP.PushMessage(message)
{
Topic = "Debug",
Urgency = WP.PushMessageUrgency.Normal
};
await _subscriptionStore.ForEachSubscriptionAsync(_applicationUser.Id, (subscription) => {
_notificationService.SendNotificationAsync(subscription, pushMessage, "http://fergl.ie");
response.Append($"Sent: {subscription.Endpoint}");
});
return(response.ToString());
}
public async Task <IActionResult> SendNotification([FromBody] PushMessageViewModel messageVM)
{
var message = new PushMessage(messageVM.Notification)
{
Topic = messageVM.Topic,
Urgency = messageVM.Urgency
};
await _subscriptionStore.ForEachSubscriptionAsync((PushSubscription subscription) =>
{
_pushClient.RequestPushMessageDeliveryAsync(subscription, message);
});
return(NoContent());
}
public async Task <IActionResult> SendNotification([FromBody] PushMessageViewModel message)
{
_logger.LogInformation($"Sending targeted push for: {message.Target} - {message.Notification}");
var pushMessage = new WP.PushMessage(message.Notification)
{
Topic = message.Topic,
Urgency = message.Urgency
};
// TODO: This should be scheduled in background
await _subscriptionStore.ForEachSubscriptionAsync(message.Target, (WP.PushSubscription subscription) => {
_logger.LogInformation($"Found subscription: {subscription}");
_notificationService.SendNotificationAsync(subscription, pushMessage, message.Target);
});
return(NoContent());
}
public async Task <ActionResult <ChatViewModel> > Initialise([FromBody] ChatViewModel message)
{
var chatUser = await _userManager.FindByEmailAsync(_chatSettings.CurrentChatUser);
if (chatUser != null)
{
var chat = _mapper.Map <ChatMessage>(message);
chat.FromUser = _applicationUser;
chat.ToUser = chatUser;
if (chat.FromUser != null)
{
_chatRepository.AddOrUpdate(chat);
await _unitOfWork.CompleteAsync();
}
else
{
// it's an anonymous chat, we don't need to save item
chat.Id = System.Guid.NewGuid();
}
var filledMessage = _mapper.Map <ChatViewModel>(chat);
filledMessage.FromUserName = _applicationUser == null ?
message.FromUserName :
_applicationUser.GetBestGuessName();
//send push message to whoever is registered as admin
await _subscriptionStore.ForEachSubscriptionAsync(chatUser.Id, (PushSubscription subscription) => {
_notificationService.SendNotificationAsync(
subscription,
new PushMessage("New SUPPORT Request")
{
Urgency = PushMessageUrgency.High,
Topic = "NewSupport"
},
_appSettings.SiteUrl);
});
if (await _supportChatService.InitiateSupportRequest(filledMessage))
{
await _hub.SendUserAsync(filledMessage.ToUserId, "support-message", new object[] { filledMessage });
return(Ok(filledMessage));
}
}
return(StatusCode(503));
}
internal void NotifySubscribers(IPushNotificationsQueue pushNotificationsQueue, IPushSubscriptionStore subscriptionStore, string districtWiseCasesUrl)
{
subscriptionStore.ForEachSubscriptionAsync((subscription) =>
{
var currentDistrictCases = GetLatestCountForDistrict(subscription.District, districtWiseCasesUrl);
if (currentDistrictCases > subscription.LatestConfirmedCase)
{
pushNotificationsQueue.Enqueue(new Lib.Net.Http.WebPush.PushMessage($"Cases in your District {subscription.District} has increased the new number is {currentDistrictCases}")
{
Topic = "Covid 19 Alert",
Urgency = Lib.Net.Http.WebPush.PushMessageUrgency.High
});
subscription.LatestConfirmedCase = currentDistrictCases;
subscriptionStore.UpdateSubscriptionAsync(subscription);
}
});
}
private async Task DequeueMessagesAsync()
{
while (!_stopTokenSource.IsCancellationRequested)
{
PushMessage message = await _messagesQueue.DequeueAsync(_stopTokenSource.Token);
if (!_stopTokenSource.IsCancellationRequested)
{
using (IServiceScope serviceScope = _serviceProvider.CreateScope())
{
IPushSubscriptionStore subscriptionStore = serviceScope.ServiceProvider.GetRequiredService <IPushSubscriptionStore>();
await subscriptionStore.ForEachSubscriptionAsync((PushSubscription subscription) =>
{
// Fire-and-forget
_notificationService.SendNotificationAsync(subscription, message, _stopTokenSource.Token);
}, _stopTokenSource.Token);
}
}
}
}
