public async Task SendNotificationsAsync(Notification notificationObject)
{
var allSupscriptions = await _subscriptionsService.getAllSubscriptions();
foreach (MBSubscription subscription in allSupscriptions)
{
try
{
AngularPushNotification _notification = new AngularPushNotification
{
Title = notificationObject.Title,
Body = $"{notificationObject.Body}",
Icon = (notificationObject.Image != null) ? notificationObject.Image : ""
};
string topic = null;
int? timeToLive = null;
PushMessageUrgency urgency = PushMessageUrgency.Normal;
PushMessage notification = new PushMessage(WRAPPER_START + JsonConvert.SerializeObject(_notification, _jsonSerializerSettings) + WRAPPER_END)
{
Topic = topic,
TimeToLive = timeToLive,
Urgency = urgency
};
// fire-and-forget
var result = _pushClient.RequestPushMessageDeliveryAsync(subscription.PushSubscription, notification, CancellationToken.None);
}
catch (Exception e)
{
}
}
}
public async Task <Result> SendToOneDeviceAsync(int userId, string title, string message, string endpoint, string groupKey)
{
var sub = _pushService.Get(userId, endpoint);
if (sub is null)
{
return(Result.Failure("Couldn't find device subscription"));
}
var notification = BuildMessage(title, message, _serverUrl, groupKey);
await _client.RequestPushMessageDeliveryAsync(sub, notification.ToPushMessage());
return(Result.Success());
}
public void SendNotification(Facets.PushSubscription subscription, string message, string publicKey, string privateKey)
{
var webSubscription = new Lib.Net.Http.WebPush.PushSubscription();
webSubscription.Endpoint = subscription.Endpoint;
webSubscription.Keys = subscription.Keys;
//Need to make sure we're using right keys for subscription, maybe change to get for specific site.
var vapidAuth = new Lib.Net.Http.WebPush.Authentication.VapidAuthentication(publicKey, privateKey);
var pushMessage = new PushMessage(message);
var task = webPushClient.RequestPushMessageDeliveryAsync(webSubscription, pushMessage, vapidAuth);
try
{
task.Wait();
}
catch (AggregateException ae)
{
foreach (var e in ae.InnerExceptions)
{
throw e;
}
}
}
public async Task SendNotificationsAsync()
{
SetNotificationProperties(new SubscriptionService(DataUnitOfWork, ObjectLocator), new PushServiceClient());
AngularPushNotification _notification = new AngularPushNotification
{
Title = "Test Notification",
Body = $"This is test notification",
Icon = ""
};
string topic = null;
int? timeToLive = null;
PushMessageUrgency urgency = PushMessageUrgency.Normal;
PushMessage notification = new PushMessage(WRAPPER_START + JsonConvert.SerializeObject(_notification, _jsonSerializerSettings) + WRAPPER_END)
{
Topic = topic,
TimeToLive = timeToLive,
Urgency = urgency
};
try {
var allSupscriptions = await _subscriptionsService.getAllSubscriptions();
foreach (MBPushSubscription subscription in allSupscriptions)
{
// fire-and-forget
await _pushClient.RequestPushMessageDeliveryAsync(subscription.PushSubscription, notification);
}
}
catch (Exception e)
{
}
}
// GET: Admin/Notification
public ActionResult Send()
{
var publicKey = "BP2HjQtANkxLEBNq37OAth8Q1Oi59ZcWZO_lKbtRorfg_qY30lSlzMxGHYqH_a4S1p449HLOBy1jM2jy-bliq0o";
var privateKey = "QJoWkpOGd9H2YFkrU9PeT2jwRM1bU2I4spb3HD2Lgm8";
PushServiceClient pushClient = new PushServiceClient();
pushClient.DefaultAuthentication = new VapidAuthentication(publicKey, privateKey)
{
Subject = "https://acceleratex.org"
};
PushMessage notification = new AngularPushNotification
{
Title = "news from wiQuiz",
Body = $"eine neues Quiz ist da",
// Icon = "Assets/icon-96x96.png" - so geht es nicht, andere Art des Pfads
}.ToPushMessage();
pushClient.RequestPushMessageDeliveryAsync(MyPushSubscription.Instance.subscription, notification);
return(RedirectToAction("Index", "Dashboard", new { area = "" }));
}
public async Task SendNotificationsAsync(Subscription subscription, Notification notification)
{
PushMessage message = notification.ToPushMessage();
var pushSubscription = subscription.GetPushSubscription();
_logger.LogInformation($"Sending push notification to {subscription.Id} with content: {notification.Title}");
await _pushClient.RequestPushMessageDeliveryAsync(pushSubscription, message);
}
public async Task SendNotificationAsync(PushSubscription subscription, PushMessage message, string target)
{
try {
_logger.LogInformation($"Sending PushService push: {message.Content}");
await _pushClient.RequestPushMessageDeliveryAsync(subscription, message);
} catch (Exception ex) {
_logger?.LogError(ex, "Failed requesting push message delivery to {0}.", subscription.Endpoint);
}
}
public void Broadcast(PushNotificationModel notification, CancellationToken cancellationToken)
{
var pushMessage = notification.ToPushMessage();
foreach (PushSubscription pushSubscription in _pushSubscriptionService.GetAll())
{
_pushClient.RequestPushMessageDeliveryAsync(pushSubscription, pushMessage, cancellationToken);
}
}
public async Task <IActionResult> SendNotification(PushMessageViewModel pushMessageViewModel)
{
var message = _mapper.Map <PushMessage>(pushMessageViewModel);
await _pushSubscriptionApp.ForEachSubscriptionAsync((subscription) =>
{
_pushServiceClient.RequestPushMessageDeliveryAsync(subscription, message);
});
return(NoContent());
}
private void SendNotification(PushSubscription subscription)
{
PushMessage notification = new AngularPushNotification
{
Title = "You are registered",
Body = $"You're subscription has been registered and you will be notified in case of strong wind forecast",
Icon = "assets/icons/icon-96x96.png"
}.ToPushMessage();
_pushClient.RequestPushMessageDeliveryAsync(subscription, notification, CancellationToken.None);
}
public void SendNotification(PushSubscription subscription, string payload)
{
try
{
_pushClient.RequestPushMessageDeliveryAsync(subscription, new PushMessage(payload)).Wait();
}
catch (Exception ex)
{
_logger?.LogError(ex, "Failed requesting push message delivery to {0}.", subscription.Endpoint);
}
}
public async Task SendNotificationAsync(PushSubscription subscription, PushMessage message, CancellationToken cancellationToken)
{
try
{
await _pushClient.RequestPushMessageDeliveryAsync(subscription, message, cancellationToken);
}
catch (Exception ex)
{
await HandlePushMessageDeliveryExceptionAsync(ex, subscription);
}
}
public async Task SendNotificationAsync(PushSubscription subscription, PushMessage message, CancellationToken cancellationToken)
{
try
{
await _pushClient.RequestPushMessageDeliveryAsync(subscription, message, cancellationToken);
}
catch (Exception ex)
{
_logger?.LogError(ex, "Failed requesting push message delivery to {0}.", subscription.Endpoint);
}
}
// GET: Notification
public ActionResult SendMeANotofication()
{
var user = GetCurrentUser();
var device = user.Devices.FirstOrDefault(x => x.Platform == DevicePlatform.PWA);
if (device != null)
{
var subscription = JsonConvert.DeserializeObject <PushSubscription>(device.DeviceName);
/*
* https://tools.reactpwa.com/vapid
* {
* "subject": "mailto:[email protected]",
* "publicKey": "BPI8YpVBlwF62LYEapQb6zEj8i75ZYPHp3ugnYn0Sc8GBBX0s-pZEL-POjEAbzeIBzMQHx1bcq1yhY982hMm7oA",
* "privateKey": "yMXePWjZMvx_xwZczffh6nG1j-E6oW0fcUVHOYeXR0c"
* }
*/
var publicKey = "BPI8YpVBlwF62LYEapQb6zEj8i75ZYPHp3ugnYn0Sc8GBBX0s-pZEL-POjEAbzeIBzMQHx1bcq1yhY982hMm7oA";
var privateKey = "yMXePWjZMvx_xwZczffh6nG1j-E6oW0fcUVHOYeXR0c";
PushServiceClient pushClient = new PushServiceClient();
pushClient.DefaultAuthentication = new VapidAuthentication(publicKey, privateKey)
{
Subject = "mailto:[email protected]"
};
var notification = new AngularPushNotification
{
Title = "news from NINE",
Body = $"from nine to fillter",
// Icon = "Assets/icon-96x96.png" - so geht es nicht, andere Art des Pfads
Data = new Dictionary <string, object>(),
Icon = "img.png"
};
notification.Data["url"] = "https://nine.hm.edu";
notification.Data["room"] = "R 2.089";
notification.Data["lecturer"] = "Hinz";
var pushNMessage = notification.ToPushMessage();
pushClient.RequestPushMessageDeliveryAsync(subscription, pushNMessage);
}
return(RedirectToAction("Index", "Home"));
}
public async Task PushService_OtherClientError_ThrowsPushServiceClientException()
{
_pushSubscription.Endpoint = CLIENT_ERROR_ENDPOINT;
PushMessage pushMessage = new PushMessage(WALRUS_CONTENT);
PushServiceClient pushClient = PreparePushServiceClient();
await Assert.ThrowsAsync <PushServiceClientException>(async() =>
{
await pushClient.RequestPushMessageDeliveryAsync(_pushSubscription, pushMessage);
});
}
public async Task SendNotificationAsync(PushSubscription subscription, PushMessage message, CancellationToken cancellationToken)
{
try
{
var messageJson = JsonConvert.SerializeObject(message);
message.Content = messageJson;
await _pushClient.RequestPushMessageDeliveryAsync(subscription, message, cancellationToken);
}
catch (Exception ex)
{
_logger?.LogError(ex, "Failed requesting push message delivery to {0}.", subscription.Endpoint);
}
}
private async Task SendNotificationAsync(Lib.Net.Http.WebPush.PushSubscription subscription, PushMessage message, CancellationToken cancellationToken)
{
var _pushClient = new PushServiceClient();
_pushClient.DefaultAuthentication = new VapidAuthentication("BP3KYW8aPpClaCjP2MUceUNTwqBSaK88kTnl6SWg0k134zAy_dNNub8LfGHo83bbkm-LUGAd_aLKM0z_4cpUlY8", "SSvrSz8WiLxNJB4SOZXiBs12n3VPLyftqHR05xpobGo");
try
{
await _pushClient.RequestPushMessageDeliveryAsync(subscription, message, cancellationToken);
}
catch (Exception ex)
{
//_logger?.LogError(ex, "Failed requesting push message delivery to {0}.", subscription.Endpoint);
}
}
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 PushService_OtherClientError_PushServiceClientExceptionContainsPushSubscription()
{
_pushSubscription.Endpoint = CLIENT_ERROR_ENDPOINT;
PushMessage pushMessage = new PushMessage(WALRUS_CONTENT);
PushServiceClient pushClient = PreparePushServiceClient();
PushServiceClientException pushMessageDeliveryException = await Record.ExceptionAsync(async() =>
{
await pushClient.RequestPushMessageDeliveryAsync(_pushSubscription, pushMessage);
}) as PushServiceClientException;
Assert.Equal(_pushSubscription, pushMessageDeliveryException.PushSubscription);
}
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 PushService_TooManyRequests_MaxRetriesAfter_ThrowsPushServiceClientException()
{
_pushSubscription.Endpoint = RETRY_AFTER_ALWAYS_ENDPOINT;
PushMessage pushMessage = new PushMessage(WALRUS_CONTENT);
PushServiceClient pushClient = PreparePushServiceClient();
pushClient.MaxRetriesAfter = 1;
await Assert.ThrowsAsync <PushServiceClientException>(async() =>
{
await pushClient.RequestPushMessageDeliveryAsync(_pushSubscription, pushMessage);
});
}
public async Task PushService_TooManyRequests_DeliversPushMessageWithRetryAfter()
{
_pushSubscription.Endpoint = RETRY_AFTER_ENDPOINT;
PushMessage pushMessage = new PushMessage(WALRUS_CONTENT);
PushServiceClient pushClient = PreparePushServiceClient();
Exception pushMessageDeliveryException = await Record.ExceptionAsync(async() =>
{
await pushClient.RequestPushMessageDeliveryAsync(_pushSubscription, pushMessage);
});
Assert.Null(pushMessageDeliveryException);
}
public async Task PushService_NoError_DeliversPushMessage()
{
_pushSubscription.Endpoint = CREATED_ENDPOINT;
PushMessage pushMessage = new PushMessage(WALRUS_CONTENT);
PushServiceClient pushClient = PreparePushServiceClient();
Exception pushMessageDeliveryException = await Record.ExceptionAsync(async() =>
{
await pushClient.RequestPushMessageDeliveryAsync(_pushSubscription, pushMessage);
});
Assert.Null(pushMessageDeliveryException);
}
private void SendNotifications(int temperatureC, CancellationToken stoppingToken)
{
PushMessage notification = new AngularPushNotification
{
Title = "New Weather Forecast",
Body = $"Temp. (C): {temperatureC} | Temp. (F): {32 + (int)(temperatureC / 0.5556)}",
Icon = "assets/icons/icon-96x96.png"
}.ToPushMessage();
foreach (PushSubscription subscription in _pushSubscriptionsService.GetAll())
{
// Fire-and-forget
_pushClient.RequestPushMessageDeliveryAsync(subscription, notification, stoppingToken);
}
}
public async Task PushService_OtherClientError_PushServiceClientExceptionContainsResponseReasonPhrase()
{
_pushSubscription.Endpoint = CLIENT_ERROR_ENDPOINT;
PushMessage pushMessage = new PushMessage(WALRUS_CONTENT);
PushServiceClient pushClient = PreparePushServiceClient();
PushServiceClientException pushMessageDeliveryException = await Record.ExceptionAsync(async() =>
{
await pushClient.RequestPushMessageDeliveryAsync(_pushSubscription, pushMessage);
}) as PushServiceClientException;
Assert.Equal(FakePushServiceStartup.OTHER_CLIENT_ERROR_REASON_PHRASE, pushMessageDeliveryException.Message);
}
/// <summary>
/// Send Notification
/// </summary>
/// <param name="message">string message</param>
public void SendNotifications(string message, IEnumerable <PushSubscription> targets)
{
// Notification Push Message
PushMessage notification = new AngularPushNotification
{
Title = "Aggiornamento nella reservation", //Title
Body = message, //Body
Icon = "../ClientApp/src/assets/icons/icon-96x96.png" //Icon
}.ToPushMessage();
foreach (PushSubscription subscription in targets)
{
_pushClient.RequestPushMessageDeliveryAsync(subscription, notification);
}
}
private async Task Send(string userId, PushMessage notification)
{
foreach (var subscription in await GetUserSubscriptions(userId))
{
try
{
await client.RequestPushMessageDeliveryAsync(
subscription.ToWebPushSubscription(),
notification,
new VapidAuthentication(vapidPublicKey, vapidPrivateKey));
}
catch (Exception e) when(e.Message == "Subscription no longer valid")
{
context.AppPushSubscriptions.Remove(subscription);
await context.SaveChangesAsync();
}
}
public async Task PushService_TooManyRequests_MaxRetriesAfter_PushServiceClientExceptionStatusCodeIs429()
{
_pushSubscription.Endpoint = RETRY_AFTER_ALWAYS_ENDPOINT;
PushMessage pushMessage = new PushMessage(WALRUS_CONTENT);
PushServiceClient pushClient = PreparePushServiceClient();
pushClient.MaxRetriesAfter = 1;
PushServiceClientException pushMessageDeliveryException = await Record.ExceptionAsync(async() =>
{
await pushClient.RequestPushMessageDeliveryAsync(_pushSubscription, pushMessage);
}) as PushServiceClientException;
Assert.Equal(429, (int)pushMessageDeliveryException.StatusCode);
}
public void SendNotifications(string title, string body, CancellationToken stoppingToken)
{
PushMessage notification = new AngularPushNotification
{
Title = title,
Body = body,
Icon = "assets/icons/icon-96x96.png",
Actions = new List <NotificationAction> {
new NotificationAction("openwebsite", "Open webapp")
},
Data = new Dictionary <string, object> {
{ "url", _configuration["FrontUrl"] }
},
}.ToPushMessage();
foreach (PushSubscription subscription in _pushSubscriptionsService.GetAll())
{
// fire-and-forget
_pushClient.RequestPushMessageDeliveryAsync(subscription, notification, stoppingToken);
}
}
public static async Task Run([CosmosDBTrigger(
databaseName: "PushNotifications",
collectionName: "NotificationsCollection",
ConnectionStringSetting = "CosmosDBConnection",
LeaseCollectionName = "NotificationsLeaseCollection",
CreateLeaseCollectionIfNotExists = true)] IReadOnlyList <PushMessage> notifications,
[CosmosDB(
databaseName: "PushNotifications",
collectionName: "SubscriptionsCollection",
ConnectionStringSetting = "CosmosDBConnection")] DocumentClient cosmosDbClient,
[PushService(
PublicKeySetting = "ApplicationServerPublicKey",
PrivateKeySetting = "ApplicationServerPrivateKey",
SubjectSetting = "ApplicationServerSubject")] PushServiceClient pushServiceClient)
{
if (notifications != null)
{
IDocumentQuery <PushSubscription> subscriptionQuery = cosmosDbClient.CreateDocumentQuery <PushSubscription>(_subscriptionsCollectionUri, new FeedOptions
{
EnableCrossPartitionQuery = true,
MaxItemCount = -1
}).AsDocumentQuery();
while (subscriptionQuery.HasMoreResults)
{
foreach (PushSubscription subscription in await subscriptionQuery.ExecuteNextAsync())
{
foreach (PushMessage notification in notifications)
{
// Fire-and-forget
pushServiceClient.RequestPushMessageDeliveryAsync(subscription, notification);
}
}
}
}
}
