public Task PushAsync(IEnumerable <Device> devices, object payload, string triggerEmail = "*****@*****.**")
{
string vapidPublicKey = _configuration.GetSection("VapidKeys")["PublicKey"];
string vapidPrivateKey = _configuration.GetSection("VapidKeys")["PrivateKey"];
// Push to all devices.
var pushTasks = new ConcurrentBag <Task>();
foreach (var device in devices)
{
async Task PushToDevice()
{
try
{
var pushSubscription = new PushSubscription(device.PushEndpoint, device.PushP256DH, device.PushAuth);
var vapidDetails = new VapidDetails("mailto:" + triggerEmail, vapidPublicKey, vapidPrivateKey);
var payloadToken = JsonConvert.SerializeObject(payload, new JsonSerializerSettings()
{
DateTimeZoneHandling = DateTimeZoneHandling.Utc,
ContractResolver = new CamelCasePropertyNamesContractResolver(),
});
await _webPushClient.SendNotificationAsync(pushSubscription, payloadToken, vapidDetails);
}
catch (WebPushException e)
{
_dbContext.Devices.Remove(device);
await _dbContext.SaveChangesAsync();
_logger.LogCritical(e, "An WebPush error occured while calling WebPush API: " + e.Message);
_logger.LogCritical(e, e.Message);
}
catch (Exception e)
{
_logger.LogCritical(e, "An error occured while calling WebPush API: " + e.Message);
}
}
pushTasks.Add(PushToDevice());
}
return(Task.WhenAll(pushTasks));
}
public static void SendNotification(string message, string pushEndpoint, string p256dh, string auth)
{
var webPushClient = new WebPushClient();
var pushSubscription = new PushSubscription(pushEndpoint, p256dh, auth);
try
{
//var notification = new WebPushNotification
//{
// title = "New notification",
// body = message,
// vibrate = new[] {100, 50, 100},
// data = new Data
// {
// dateOfArrival = DateTime.Now.ToShortTimeString(),
// primaryKey = 1
// },
// actions = new[]
// {
// new Action
// {
// action = "explore",
// title = "go to to"
// },
// }
//};
var notification = "{\"notification\":{\"title\":\"Ktoś zaczął srać\",\"body\":\"{MESSAGE}\",\"icon\":\"https://cdn3.iconfinder.com/data/icons/object-emoji/50/Poop-512.png\",\"vibrate\":[100,50,100],\"data\":{\"url\":\"https://medium.com/@arjenbrandenburgh/angulars-pwa-swpush-and-swupdate-15a7e5c154ac\"}}}";
notification = notification.Replace("{MESSAGE}", message);
webPushClient.SendNotification(pushSubscription, notification, new VapidDetails
{
Subject = "mailto:[email protected]",
PublicKey = "BPJC0G2ZjJvF-eEdN5qiUVTTz4zBX3kC2k5KzyziRl2mKt9Tj5yulvAwNXfgr1B2CpNyX5p_M4UfS4bqxDiSMDE",
PrivateKey = "iZoBvDdIsFiAfabJGCIqmtjaAH7N4Nwp-mNwobNlkPY"
});
}
catch (Exception ex)
{
Log.Logger.Error(ex.ToString());
}
}
public async Task PushAsync(IEnumerable <Device> devices, string triggerEmail, string payload)
{
using (var scope = _scopeFactory.CreateScope())
{
var dbContext = scope.ServiceProvider.GetRequiredService <KahlaDbContext>();
string vapidPublicKey = _configuration.GetSection("VapidKeys")["PublicKey"];
string vapidPrivateKey = _configuration.GetSection("VapidKeys")["PrivateKey"];
// Push to all devices.
var pushTasks = new List <Task>();
foreach (var device in devices)
{
async Task PushToDevice()
{
try
{
var pushSubscription = new PushSubscription(device.PushEndpoint, device.PushP256DH, device.PushAuth);
var vapidDetails = new VapidDetails("mailto:" + triggerEmail, vapidPublicKey, vapidPrivateKey);
await _webPushClient.SendNotificationAsync(pushSubscription, payload, vapidDetails);
}
catch (WebPushException e)
{
dbContext.Devices.Remove(device);
await dbContext.SaveChangesAsync();
_logger.LogCritical(e, "A WebPush error occured while calling WebPush API: " + e.Message);
_logger.LogCritical(e, e.Message);
}
catch (Exception e)
{
_logger.LogCritical(e, "An error occured while calling WebPush API: " + e.Message);
}
}
pushTasks.Add(PushToDevice());
}
await Task.WhenAny(
Task.WhenAll(pushTasks),
Task.Delay(2000));
}
}
private async Task NofityUser(PushNotificationModel model, string payload)
{
var client = new WebPushClient();
var subs = new PushSubscription(model.Endpoint, model.Keys.P256dh, model.Keys.Auth);
try
{
await client.SendNotificationAsync(subs, payload, vapidDetails);
_logger.LogDebug("Message Sent email:" + model.IdentityEmail + payload);
}
catch (WebPushException ex)
{
if (ex.StatusCode == HttpStatusCode.Gone || ex.StatusCode == HttpStatusCode.NotFound)
{
await _mongoRepo.RemoveAsync(model.Id);
_logger.LogError(payload);
}
}
}
public async Task <IActionResult> SavePushSubscription([FromBody] PushSubscriptionDto sub)
{
try
{
var subToSave = new PushSubscription()
{
Endpoint = sub.Endpoint,
P256 = sub.Keys.ElementAt(0).Value,
Auth = sub.Keys.ElementAt(1).Value
};
await this.context.PushSubscription.AddAsync(subToSave);
await this.context.SaveChangesAsync();
return(Ok(sub));
}
catch (Exception e)
{
return(StatusCode(500, e));
}
}
public static void SendNotification(List <BellumGensPushSubscription> subs, TeamApplication notification, NotificationState state)
{
var subject = @"https://bellumgens.com";
foreach (BellumGensPushSubscription sub in subs)
{
var subscription = new PushSubscription(sub.endpoint, sub.p256dh, sub.auth);
var vapidDetails = new VapidDetails(subject, NotificationsService._publicVapidKey, NotificationsService._privateVapidKey);
var webPushClient = new WebPushClient();
var payload = new BellumGensNotificationWrapper(notification, state);
try
{
webPushClient.SendNotification(subscription, payload.ToString(), vapidDetails);
}
catch (WebPushException exception)
{
Console.WriteLine(exception);
}
}
}
public async Task <IActionResult> CreatePushSubscription(string token)
{
try
{
var push = new PushSubscription()
{
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now,
Token = token,
ActiveFlag = true
};
await _notificationService.SavePushSubscription(push);
return(Json(new { success = true }));
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(BadRequest());
}
}
public async Task <PushSubscription?> Delete([FromBody] PushSubscription subscription)
{
// The supplied PushSubscription is from the browser's PushSubscription type.
// Thus, it has no ID. We generate an ID from the subscription's unique endpoint. Use that to delete it.
var subscriptionId = PushSubscription.GetRavenIdFromEndpoint(subscription.Endpoint);
var existingSub = await DbSession.LoadOptionalAsync <PushSubscription>(subscriptionId);
if (existingSub != null)
{
DbSession.Delete(existingSub);
using (logger.BeginKeyValueScope("subscription", subscription))
{
logger.LogInformation("Deleted push subscription");
}
return(existingSub);
}
logger.LogWarning("Attempted to deleted push subscription {id}, but no such subscription was found", subscriptionId);
return(null);
}
public async Task SendNotificationToUserAsync(NotificationDto notification)
{
WebPushClient client = new WebPushClient();
PushSubscription sub = await GetPushSubsciption(notification.SubscriptionId);
VapidDetails vapiData = GetVapiData();
string message = GetMessage(notification.Title, notification.Text);
try
{
await client.SendNotificationAsync(sub, message, vapiData);
}
catch (WebPushException exception)
{
if (exception.Message == "Subscription no longer valid")
{
await DeactivateSubscription(notification.SubscriptionId);
}
throw exception;
}
}
public async Task <IActionResult> Create(ItemModel item)
{
await repository.InsertOneAsync(item);
var subscribers = await pushRepository.GetAllAsync();
string vapidPublicKey = _config.GetSection("VapidKeys")["PublicKey"];
string vapidPrivateKey = _config.GetSection("VapidKeys")["PrivateKey"];
PushPayloadModel payload = new PushPayloadModel {
message = item.Description, title = "Nuovo articolo pubblicato"
};
foreach (var device in subscribers)
{
var pushSubscription = new PushSubscription(device.PushEndpoint, device.PushP256DH, device.PushAuth);
var vapidDetails = new VapidDetails("mailto:[email protected]", vapidPublicKey, vapidPrivateKey);
var webPushClient = new WebPushClient();
webPushClient.SendNotification(pushSubscription, JsonConvert.SerializeObject(payload), vapidDetails);
}
return(RedirectToAction("Index"));
}
public async Task SendNotificationAsync(List <BellumGensPushSubscription> subs, TeamInvite notification)
{
var subject = @"https://bellumgens.com";
foreach (BellumGensPushSubscription sub in subs)
{
var subscription = new PushSubscription(sub.Endpoint, sub.P256dh, sub.Auth);
var vapidDetails = new VapidDetails(subject, _publicVapidKey, _privateVapidKey);
var webPushClient = new WebPushClient();
var payload = new BellumGensNotificationWrapper(notification);
try
{
await webPushClient.SendNotificationAsync(subscription, payload.ToString(), vapidDetails);
}
catch (WebPushException exception)
{
Console.WriteLine(exception);
}
}
}
public async Task <IActionResult> Create([FromBody] PushNotificationSubscription subscription)
{
var pushSubscription = new PushSubscription(subscription.Endpoint, subscription.Keys.P256dh, subscription.Keys.Auth);
var vapidDetails = new VapidDetails(
"mailto:[email protected]",
"BAvyBimPt4GhPo5qWR-6GhPo6kMlwsmxGgVyRvuRYtEck0Hz4kLOG8lc23p3K_mRH1bgqUU5BdWzxMXb6boVzi4",
"WgOFGuwBA8tVzVOQn2M-oFqtgZvlmvJtFLC1VHq-Pho");
var webPushClient = new WebPushClient();
webPushClient.SetVapidDetails(vapidDetails);
//TODO; store pushsubscription for later use
// send notification
var payload = new PushNotificationPayload
{
notification = new PushNotification
{
title = "Titulo",
body = "Teste de notificacao",
icon = "assets/icon-128x128.png"
}
};
var payloadSerialized = JsonConvert.SerializeObject(payload);
try
{
await webPushClient.SendNotificationAsync(pushSubscription, payloadSerialized, vapidDetails);
}
catch (WebPushException exception)
{
var statusCode = exception.StatusCode;
return(new StatusCodeResult((int)statusCode));
}
return(new OkResult());
}
public async Task <Result> RemoveSubscriptionAsync(int userId, PushSubscription sub, bool save)
{
try
{
var device = await _db.PushSubscriptionDevices.FindAsync(userId, sub.Endpoint);
if (device != null)
{
_db.PushSubscriptionDevices.Remove(device);
if (save)
{
await _db.SaveChangesAsync();
}
}
return(Result.Success());
}
catch (Exception e)
{
_logger.LogError(e, $"Failed to delete sub for user {userId}");
return(Result.Failure("Failed to delete subscription"));
}
}
public async Task <bool> Sender(SubscriptionModel item, string payload, string subject, string privatekey,
string publickey)
{
var subscription = new PushSubscription(item.endpoint, item.keys.p256dh, item.keys.auth);
var vapidDetalis = new VapidDetails(subject, publickey, privatekey);
var webPushClient = new WebPushClient();
try
{
Console.WriteLine($"payload {payload}");
Console.WriteLine($"data: ${JsonConvert.SerializeObject(item)}");
await webPushClient.SendNotificationAsync(subscription, payload, vapidDetalis);
return(true);
}
catch (Exception e)
{
Console.WriteLine($"WEB-PUSH SENDMESSAGE : {e.Message}");
return(false);
}
}
public void TestGcmApiKeyInOptions()
{
var gcmAPIKey = @"teststring";
var subscription = new PushSubscription(TestGcmEndpoint, TestPublicKey, TestPrivateKey);
var options = new Dictionary <string, object>();
options[@"gcmAPIKey"] = gcmAPIKey;
var message = client.GenerateRequestDetails(subscription, @"test payload", options);
var authorizationHeader = message.Headers.GetValues(@"Authorization").First();
Assert.AreEqual("key=" + gcmAPIKey, authorizationHeader);
// Test previous incorrect casing of gcmAPIKey
var options2 = new Dictionary <string, object>();
options2[@"gcmApiKey"] = gcmAPIKey;
Assert.ThrowsException <ArgumentException>(delegate
{
client.GenerateRequestDetails(subscription, "test payload", options2);
});
}
public void TriggerPush()
{
var subject = @"mailto:[email protected]";
var publicKey = @"BGARDFzAbeYjcJIAL-0I5dj9B19W5ge6EGrB9rTFTCYBxvYv52r5j709jLnjKHPvFFsD9AVNAYI8oMR1Fu75SBo";
var privateKey = @"pX2Jv8Gx5zcpV5692eWl5CpeeFucgWxyiKnXIeQq2wg";
var subscription = new PushSubscription(pushEndpoint, p256dh, auth);
var vapidDetails = new VapidDetails(subject, publicKey, privateKey);
//var gcmAPIKey = @"[your key here]";
var webPushClient = new WebPushClient();
try
{
webPushClient.SendNotification(subscription, "payload", vapidDetails);
//webPushClient.SendNotification(subscription, "payload", gcmAPIKey);
}
catch (WebPushException exception)
{
Console.WriteLine("Http STATUS code" + exception.StatusCode);
}
}
public async Task <PushSubscription> SavePushSubscription(PushSubscription push)
{
try
{
if (push.Id == 0)
{
await _dbContext.AddAsync(push);
}
else
{
_dbContext.Update(push);
}
await _dbContext.SaveChangesAsync();
return(push);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Saves the push subscription.
/// </summary>
/// <returns>The subscribed device.</returns>
/// <param name="p_pushSubscription">P push subscription.</param>
public async Task <Device> SavePushSubscription(PushSubscription p_pushSubscription)
{
if (p_pushSubscription == null)
{
throw new ArgumentNullException(nameof(p_pushSubscription), "Push subscription cannot be null");
}
Device v_device = new Device(p_pushSubscription);
if (this.DbContext.Devices.Any(s => s.Auth == v_device.Auth && s.Endpoint == v_device.Endpoint && s.P256DH == v_device.P256DH))
{
v_device = this.DbContext.Devices.First(s => s.Auth == v_device.Auth && s.Endpoint == v_device.Endpoint && s.P256DH == v_device.P256DH);
}
else
{
await this.DbContext.Devices.AddAsync(v_device);
await this.DbContext.SaveChangesAsync();
}
return(v_device);
}
public static async Task SendPushNotificationAsync(VXUserPushNotification pushNotification, PushMessage pushMessage)
{
var subject = @"mailto:[email protected]";
const string publicKey = @"BAHU3QNr2PvPSufR9hKYgV7daemnktvh6AYqBqta9brwWK6S064nzJQCadUT4LD3fyJMs5FiKh9uW_v_t4aU4eI";
const string privateKey = @"hoIs3IDTJvGbPUgK2qhwFuREX5deqKhBVNAN0a70_dg";
var subscription = new PushSubscription(pushNotification.Endpoint, pushNotification.ReceiverKey, pushNotification.AuthKey);
var vapidDetails = new VapidDetails(subject, publicKey, privateKey);
var webPushClient = new WebPushClient();
try
{
await webPushClient.SendNotificationAsync(subscription, JsonConvert.SerializeObject(pushMessage), vapidDetails);
}
catch (AggregateException ae)
{
ae.Handle((ex) =>
{
if (ex is WebPushException)
{
var xpe = (WebPushException)ex;
switch (xpe.StatusCode)
{
case System.Net.HttpStatusCode.Gone:
//TODO: Delete endpoint from VXUserPushNotification
return(true);
default:
PXTrace.WriteError(ex);
return(false);
}
}
PXTrace.WriteError(ex);
return(false);
});
}
}
public IActionResult SendMessage([FromBody] SendMessageModel sendMessageModel)
{
var webPushOptions = GetWebPushOptions();
var webPushClient = new WebPushClient();
var savedSubscriptions = _context.WebPushSubscriptions.ToList();
foreach (var savedSubscription in savedSubscriptions)
{
try
{
var webPushSubscription = new PushSubscription(savedSubscription.EndPoint, savedSubscription.P256dH, savedSubscription.Auth);
webPushClient.SendNotification(webPushSubscription, sendMessageModel.Message, webPushOptions);
}
catch (WebPushException ex)
{
var sss = 1;
//figure out what to do here -- delete from server?
}
}
return(Ok());
}
public async Task PushAsync(string receiverId, string triggerEmail, string payload)
{
var devices = await _dbContext.Devices.Where(t => t.UserId == receiverId).ToListAsync();
string vapidPublicKey = _configuration.GetSection("VapidKeys")["PublicKey"];
string vapidPrivateKey = _configuration.GetSection("VapidKeys")["PrivateKey"];
// Push to all devices.
var pushTasks = new List <Task>();
foreach (var device in devices)
{
async Task PushToDevice()
{
try
{
var pushSubscription = new PushSubscription(device.PushEndpoint, device.PushP256DH, device.PushAuth);
var vapidDetails = new VapidDetails("mailto:" + triggerEmail, vapidPublicKey, vapidPrivateKey);
_logger.LogInformation($"Trying to call WebPush API to push a new event to {receiverId}, Event content is '{payload}', Device ID is {device.Id}");
await _webPushClient.SendNotificationAsync(pushSubscription, payload, vapidDetails);
}
catch (WebPushException e)
{
_dbContext.Devices.Remove(device);
_logger.LogCritical(e, "A WebPush error occured while calling WebPush API: " + e.Message);
_telemetry.TrackException(e);
}
catch (Exception e)
{
_telemetry.TrackException(e);
_logger.LogCritical(e, "An error occured while calling WebPush API: " + e.Message);
}
}
pushTasks.Add(PushToDevice());
}
await Task.WhenAll(pushTasks);
}
public async Task TestSendNotificationAboutQuestionAsync()
{
TestingContext testingContext = new TestingContext();
SetUpTestingContext(testingContext);
ApplicationDbContext dbContext = testingContext.GetSimple <ApplicationDbContext>();
Question first = await dbContext.Questions.LastAsync();
await AddSampleSubscriptions(testingContext, first.User);
string messageSent = string.Empty;
PushSubscription psSent = null;
VapidDetails vapiDetSent = null;
Mock <IWebPushClient> webPushClientMock = new Mock <IWebPushClient>(MockBehavior.Loose);
webPushClientMock.Setup(x => x.SendNotificationAsync(It.IsAny <PushSubscription>(),
It.IsAny <string>(), It.IsAny <VapidDetails>()))
.Callback <PushSubscription, string, VapidDetails>((ps, message, vapiDet) => {
messageSent = message;
psSent = ps;
vapiDetSent = vapiDet;
})
.Returns(Task.CompletedTask);
testingContext.DependencyMap[typeof(IWebPushClient)] = webPushClientMock.Object;
INotificationService notificationService = testingContext.GetService <NotificationService>();
// Act
await notificationService.SendNotificationAboutQuestionAsync(first.Id, "MessageAkzeptiert", "Some");
//Assert
webPushClientMock.Verify(x => x.SendNotificationAsync(It.IsAny <PushSubscription>(),
It.IsAny <string>(), It.IsAny <VapidDetails>()), Times.Once());
}
public async Task <IActionResult> Send(int id, string payload)
{
var sub = await _context.Subs.SingleOrDefaultAsync(m => m.ID == id);
string vapidPublicKey = _configuration.GetSection("VapidKeys")["PublicKey"];
string vapidPrivateKey = _configuration.GetSection("VapidKeys")["PrivateKey"];
var vapidDetails = new VapidDetails("mailto:[email protected]", vapidPublicKey, vapidPrivateKey);
var pushSubscription = new PushSubscription(sub.PushEndpoint, sub.PushP256DH, sub.PushAuth);
try
{
var webPushClient = new WebPushClient();
webPushClient.SendNotification(pushSubscription, payload, vapidDetails);
}
catch (WebPushException ex)
{
var statusCode = ex.StatusCode;
return(new StatusCodeResult((int)statusCode));
}
return(View());
}
public async Task SendNotificationAsync(PushSubscription subscription, PushMessage message, string target)
{
_logger.LogInformation($"Sending firebase push: {message.Content}");
var fb_message = new {
notification = new {
title = message.Topic,
body = message.Content,
icon = _options.ImageUrl,
click_action = target,
},
to = subscription.Endpoint
};
var data = JsonConvert.SerializeObject(fb_message);
var content = new StringContent(data, Encoding.UTF8, "application/json");
var client = _httpClientFactory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"key",
$"={_options.PrivateKey}");
var result = await client.PostAsync(subscription.Endpoint, /*_options.PushUrl, */ content);
_logger.LogInformation("FCM: ", result.Content);
}
private async Task HandlePushMessageDeliveryException(Exception exception, PushSubscription subscription)
{
PushServiceClientException pushServiceClientException = exception as PushServiceClientException;
if (pushServiceClientException is null)
{
_logger?.LogError(exception, "Failed requesting push message delivery to {0}.", subscription.Endpoint);
}
else
{
if (pushServiceClientException.StatusCode == HttpStatusCode.NotFound ||
pushServiceClientException.StatusCode == HttpStatusCode.Gone)
{
using (IPushSubscriptionStoreAccessor subscriptionStoreAccessor =
_subscriptionStoreAccessorProvider.GetPushSubscriptionStoreAccessor())
{
await subscriptionStoreAccessor.PushSubscriptionStore.DiscardSubscriptionAsync(subscription.Endpoint);
}
_logger?.LogInformation("Subscription has expired or is no longer valid and has been removed.");
}
}
}
public async Task <IActionResult> Send(int id)
{
var payload = Request.Form["payload"];
var subscription = await _context.Subscriptions.SingleOrDefaultAsync(m => m.SubscriptionId == id);
string vapidPublicKey = _configuration.GetSection("VapidKeys")["PublicKey"];
string vapidPrivateKey = _configuration.GetSection("VapidKeys")["PrivateKey"];
var pushSubscription = new PushSubscription(subscription.Endpoint, subscription.P256DH, subscription.Auth);
var vapidDetails = new VapidDetails("mailto:[email protected]", vapidPublicKey, vapidPrivateKey);
try
{
var webPushClient = new WebPushClient();
webPushClient.SendNotification(pushSubscription, payload, vapidDetails);
}
catch (WebPushException wex)
{
return(View(wex.Message));
}
return(View());
}
private async void sendPushNotificationClient(string endPoint, string publicKey, string privateKey, string jsonsubdata, string url)
{
//await when fetching from DB
var pushSubscription = new PushSubscription(endPoint.Trim(), publicKey.Trim(), privateKey.Trim());
var webPushClient = new WebPushClient();
//vapid keys generated once on startup of server first time
webPushClient.SetVapidDetails(url.Trim(), vapidPublicKEY, vapidPrivateKey);
//db query external msg
Subscriber sub = GetSubscriberData(publicKey);
string title = sub.Header.Trim();
string body = sub.Message.Trim();
JObject payloadjs = new JObject(
new JProperty("title", title),
new JProperty("body", body)
);
webPushClient.SendNotification(pushSubscription, payloadjs.ToString());//,"test",vapidDetails);
}
public IActionResult CreateOrder(CreateOrderModel orderModel)
{
orderModel.OrderDetails.RemoveAll(od => od.IsDeleted);
var order = _mapper.Map <Data.Models.Order>(orderModel);
order.IsSpecialPromo = _promotionRepository.CheckPromotionBuy1Get1();
var success = _orderRepository.Create(order);
if (success)
{
_hubContext.Clients.All.SendAsync("ReceiveNewOrder", $"{order.LastName} {order.MiddleName} {order.FirstName}", order.PhoneNumber, order.OrderDeliveried.ToString("HH:mm dd/MM"));
foreach (var device in _deviceRepository.GetAll())
{
try
{
var payload = "{\"title\":\"Đơn hàng mới\",\"message\":\"Họ tên: " + $"{order.LastName} {order.MiddleName} {order.FirstName}" + "\\nThời gian giao: " + order.OrderDeliveried.ToString("HH:mm dd/MM") + "\\nĐiện thoại: " + order.PhoneNumber + "\"}";
string vapidPublicKey = _configuration.GetSection("VapidKeys")["PublicKey"];
string vapidPrivateKey = _configuration.GetSection("VapidKeys")["PrivateKey"];
var pushSubscription = new PushSubscription(device.PushEndpoint,
device.PushP256DH,
device.PushAuth);
var vapidDetails = new VapidDetails("https://admin.ninjasaigon.com/Orders", vapidPublicKey, vapidPrivateKey);
var webPushClient = new WebPushClient();
webPushClient.SendNotification(pushSubscription, payload, vapidDetails);
}
catch
{
//fail device
}
}
}
return(Json(new { success }));
}
private static async Task SendNotificationAsync(Order order, NotificationSubscription subscription, string message)
{
// For a real application, generate your own
var publicKey = "BLC8GOevpcpjQiLkO7JmVClQjycvTCYWm6Cq_a7wJZlstGTVZvwGFFHMYfXt6Njyvgx_GlXJeo5cSiZ1y4JOx1o";
var privateKey = "OrubzSz3yWACscZXjFQrrtDwCKg-TGFuWhluQ2wLXDo";
var pushSubscription = new PushSubscription(subscription.Url, subscription.P256dh, subscription.Auth);
var vapidDetails = new VapidDetails("mailto:<*****@*****.**>", publicKey, privateKey);
var webPushClient = new WebPushClient();
try
{
var payload = JsonSerializer.Serialize(new
{
message,
url = $"myorders/{order.OrderId}",
});
await webPushClient.SendNotificationAsync(pushSubscription, payload, vapidDetails);
}
catch (Exception ex)
{
Console.Error.WriteLine("Error sending push notification: " + ex.Message);
}
}
public void SendNotification(FirstResponder responder, Intervention intervention)
{
var pushEndpoint = responder.PushEndpoint;
var p256dh = responder.PushKey;
var auth = responder.PushAuth;
var subject = @"mailto:[email protected]";
var publicKey = @"BOYIC7mz-ejuM6Nq4AFlZn3lYfA4NpxHI62RwubkdOEcY1qysVLGvtWXXKdoZYg6mMVujYYNfvMvGr7P8ChtII4";
var privateKey = @"hgg0q6HVAtKwb1AKeYJlIkyQbqRfxujp6hULhflh6f8";
var subscription = new PushSubscription(pushEndpoint, p256dh, auth);
var vapidDetails = new VapidDetails(subject, publicKey, privateKey);
var webPushClient = new WebPushClient();
try
{
webPushClient.SendNotification(subscription, "{\"id\": " + intervention.Id + ", \"userid\": " + responder.Id + ", \"overview\": \"" + intervention.Overview + "\"}", vapidDetails);
}
catch (WebPushException exception)
{
Console.WriteLine("Http STATUS code" + exception.StatusCode);
}
}
