protected override void ProcessRecord()
{
base.ProcessRecord();
//Create subscription and set configurable properties
InstanceTypeSubscription instancetypeSubscription = new InstanceTypeSubscription(_operationtype, _class.Id, _criteria);
NotificationSubscription subscription = new NotificationSubscription(_displayname, _description, instancetypeSubscription);
subscription.Enabled = _enabled;
subscription.TemplateIds.Add(_template.Id);
subscription.Name = SMHelpers.MakeMPElementSafeUniqueIdentifier("NotificationSubscription");
//TODO: Do we need these or do they have defaults set?
//subscription.MaximumRunningTimeSeconds = 7200;
//subscription.RetryDelaySeconds = 60;
//subscription.EnableBatchProcessing = true;
//Add recipient users
if (_recipients != null)
{
foreach (EnterpriseManagementObject recipient in _recipients)
{
subscription.Recipients.Add(new NotificationSubscriptionRecipient(recipient.Id.ToString(), NotificationSubscriptionRecipientType.ToRecipient));
}
}
_mg.Subscription.InsertSubscription(_managementpack.Id, subscription);
}
public async Task <IActionResult> Delete([FromBody] NotificationSubscription notificationSubscription)
{
var userSubscriptions = await GetPushUserSubscriptionsFromFile();
var subscription = userSubscriptions.FirstOrDefault(u => JsonConvert.SerializeObject(u.PushSubscription) == JsonConvert.SerializeObject(notificationSubscription.PushSubscription));
if (subscription == null)
{
return(Gone());
}
if (subscription.RoadWays.Any(r => r.HmLocation == notificationSubscription.HmLocation))
{
subscription.RoadWays = subscription.RoadWays.Where(r => r.HmLocation != notificationSubscription.HmLocation).ToList();
}
else
{
return(Conflict());
}
if (!subscription.RoadWays.Any())
{
userSubscriptions = userSubscriptions.Where(u => JsonConvert.SerializeObject(u.PushSubscription) != JsonConvert.SerializeObject(notificationSubscription.PushSubscription)).ToList();
await WritePushUserSubscriptionsToFile(userSubscriptions);
return(NoContent());
}
await WritePushUserSubscriptionsToFile(userSubscriptions);
return(Ok());
}
public IActionResult Get(long Id)
{
NotificationSubscription obj = _service.GetById(Id);
var result = _mapper.Map <NotificationSubscriptionViewModel>(obj);
return(Json(new { notificationSubscription = result }));
}
public NotificationSubscriptionResponse UnsubscribeFromNotifications(string emailAddress)
{
try
{
NotificationSubscription subscription = Repository.Query <NotificationSubscription>(Query.Where("EmailAddress") == emailAddress).FirstOrDefault();
string uuid = string.Empty;
SubscriptionStatus status = SubscriptionStatus.NotFound;
if (subscription != null)
{
subscription.IsActive = false;
subscription = Repository.Save(subscription);
uuid = subscription.Uuid;
status = SubscriptionStatus.NotActive;
}
return(new NotificationSubscriptionResponse {
Success = true, SubscriptionStatus = status, Uuid = uuid
});
}
catch (Exception ex)
{
return(new NotificationSubscriptionResponse {
Success = false, Message = ex.Message
});
}
}
public Task <IActionResult> CreateNotificationSubscription(NotificationSubscriptionCreateRequest request)
{
var currentUserId = PlatformUtils.GetIdentityUserId(User);
var existingUser = AuthorizationLayer.GetUserById(currentUserId);
if (existingUser == null)
{
return(Task.FromResult <IActionResult>(NotFound()));
}
var model = new NotificationSubscription
{
UserId = existingUser.Id,
Url = request.Url,
P256dh = request.P256dh,
Auth = request.Auth
};
//Invocazione del service layer
var validations = BasicLayer.CreateNotificationSubscription(model);
if (validations.Count > 0)
{
return(BadRequestTask(validations));
}
//Return contract
return(Reply(new OkResponse {
Status = true
}));
}
public NotificationSubscriptionResponse SubscribeToNotifications(string emailAddress)
{
try
{
NotificationSubscription subscription = Repository.Query <NotificationSubscription>(Query.Where("EmailAddress") == emailAddress).FirstOrDefault();
if (subscription == null)
{
subscription = new NotificationSubscription();
subscription.EmailAddress = emailAddress;
}
subscription.IsActive = true;
subscription = Repository.Save(subscription);
return(new NotificationSubscriptionResponse {
Success = true, Data = subscription, SubscriptionStatus = SubscriptionStatus.Active, Uuid = subscription.Uuid
});
}
catch (Exception ex)
{
return(new NotificationSubscriptionResponse {
Success = false, Message = ex.Message
});
}
}
public async Task Delete(NotificationSubscription sub)
{
Subscriptions.Remove(sub);
await DB.Connection.DeleteAsync(sub);
OnPropertyChanged(nameof(ShowEmptyView));
}
public async Task TestAddPushNotificationSubscriptionAsync()
{
//Setup
TestingContext testingContext = new TestingContext();
SetUpTestingContext(testingContext);
INotificationService notificationService = testingContext.GetService <NotificationService>();
NotificationSubscriptionDto dto = new NotificationSubscriptionDto()
{
Endpoint = "Test",
Keys = new KeyDto()
{
Auth = "TestAut",
P256dh = "testp256",
},
ExpirationTime = DateTime.Today.AddYears(3),
};
//Act
await notificationService.AddPushNotificationSubscriptionAsync(dto);
//Assert
ApplicationDbContext dbContext = testingContext.GetSimple <ApplicationDbContext>();
NotificationSubscription sub = await dbContext.Notifications.LastAsync();
Assert.Equal(dto.Endpoint, sub.Endpoint);
Assert.True(sub.Id > 0);
}
private async Task DeactivateSubscription(int id)
{
NotificationSubscription entity = await this._context.Notifications.FindAsync(id);
entity.Active = false;
_context.SaveChanges();
}
public override void Handle(Connection connection)
{
var account = connection.Session.Account;
var notification = Program.NotificationManager.Get(DeviceToken);
if (notification == null)
{
connection.SendSysMessage("This device is not registered for push notifications.");
return;
}
if (notification.UserId != account.Id)
{
connection.SendSysMessage("This device is not registered with your account.");
return;
}
notification.Remove();
Program.NotificationsDirty = true;
var notificationSubscription = new NotificationSubscription();
notificationSubscription.DeviceToken = DeviceToken;
notificationSubscription.RegexPattern = RegexPattern;
notificationSubscription.Registered = false;
connection.Send(notificationSubscription);
}
private static async Task SendNotificationAsync(Order order,
NotificationSubscription subscription, string message)
{
// En una aplicación real puedes generar tus propias llaves en
// https://tools.reactpwa.com/vapid
var PublicKey =
"BLC8GOevpcpjQiLkO7JmVClQjycvTCYWm6Cq_a7wJZlstGTVZvwGFFHMYfXt6Njyvgx_GlXJeo5cSiZ1y4JOx1o";
var PrivateKey =
"OrubzSz3yWACscZXjFQrrtDwCKg-TGFuWhluQ2wLXDo";
var PushSubscription =
new PushSubscription(
subscription.Url, subscription.P256dh, subscription.Auth);
// Aquí puedes colocar tu propio correo en <*****@*****.**>
var VapidDetails =
new VapidDetails("mailto:[email protected]",
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 al enviar la notificación push: {ex.Message}");
}
}
public async Task <IActionResult> UpdateNotificationData([FromBody] NotificationSubscription notificationSubscription)
{
var notificationSubscriptionString = JsonConvert.SerializeObject(notificationSubscription);
var result = await _userService.UpdateNotificationData(this.GetCurrentUserId(), notificationSubscriptionString);
return(Ok(_mapper.Map <UserDto>(result)));
}
public override void Handle(Connection connection)
{
if (Program.DelayManager.AddAndCheck(connection, DelayManager.Database))
{
return;
}
if (connection.Session == null)
{
connection.SendSysMessage("You need to be logged in to do that.");
return;
}
var notification = Program.NotificationManager.Get(DeviceToken);
if (notification == null)
{
connection.SendSysMessage("This device is not registered for push notifications.");
return;
}
notification.Remove();
Program.NotificationsDirty = true;
var notificationSubscription = new NotificationSubscription();
notificationSubscription.DeviceToken = DeviceToken;
notificationSubscription.RegexPattern = RegexPattern;
notificationSubscription.Registered = false;
connection.Send(notificationSubscription);
}
public override void Handle(Connection connection)
{
var account = connection.Session.Account;
var notification = Program.NotificationManager.Get(DeviceToken);
if (notification == null)
{
connection.SendSysMessage("This device is not registered for push notifications.");
return;
}
if (notification.UserId != account.Id)
{
connection.SendSysMessage("This device is not registered with your account.");
return;
}
notification.Remove();
Program.NotificationsDirty = true;
var notificationSubscription = new NotificationSubscription();
notificationSubscription.DeviceToken = DeviceToken;
notificationSubscription.RegexPattern = RegexPattern;
notificationSubscription.Registered = false;
connection.Send(notificationSubscription);
}
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 e)
{
Console.Error.WriteLine("Error sending push notification: " + e.Message);
}
}
public void Test_QueryCreateUpdateDeleteSubscription()
{
NotificationSubscription sub = ClientSample.CreateUpdateDeleteSubscription();
Assert.AreEqual("Someone is waiting on one of my pull requests", sub.Description);
Assert.AreEqual(SubscriptionStatus.PendingDeletion, sub.Status);
Assert.AreEqual(GetCurrentUserId(), Guid.Parse(sub.Subscriber.Id));
}
protected void LogSubscription(NotificationSubscription subscription)
{
Context.Log(" {0} {1} {2} {3}",
subscription.Id.PadRight(8),
subscription.Description.PadRight(60),
subscription.ModifiedDate.ToShortDateString().PadRight(10),
subscription.LastModifiedBy?.DisplayName);
}
/// <summary>
/// Save the existing subscription info.
/// </summary>
public async Task UpdateSubscription(NotificationSubscription subscription)
{
using (var database = uow.Create())
{
database.NotificationSubscriptions.Update(subscription);
await database.SaveChangesAsync();
}
}
private void CopyDataSubscription(NotificationSubscriptionDto dto, NotificationSubscription entity)
{
entity.Endpoint = dto.Endpoint;
entity.Auth = dto.Keys?.Auth;
entity.P256DiffHell = dto.Keys?.P256dh;
entity.ExpirationTime = dto.ExpirationTime;
entity.AsString = dto.AsString;
}
public NotificationSubscription UnfollowWorkItem()
{
NotificationSubscription newFollowSubscription;
// Step 1: Get a work item to follow. For this sample, just create a temporary work item.
WorkItem newWorkItem;
using (new ClientSampleHttpLoggerOutputSuppression())
{
WorkItemsSample witSample = new WorkItemsSample();
witSample.Context = this.Context;
newWorkItem = witSample.CreateWorkItem();
}
string workItemArtifactUri = "vstfs:///WorkItemTracking/WorkItem/" + newWorkItem.Id;
// Step 2: Follow this workitem by creating a subscription
NotificationSubscriptionCreateParameters createParams = new NotificationSubscriptionCreateParameters()
{
Filter = new ArtifactFilter(workItemArtifactUri),
Channel = new UserSubscriptionChannel()
};
VssConnection connection = Context.Connection;
NotificationHttpClient notificationClient = Context.Connection.GetClient <NotificationHttpClient>();
newFollowSubscription = notificationClient.CreateSubscriptionAsync(createParams).Result;
LogSubscription(newFollowSubscription);
// Step 3: Query for the follow subscription
SubscriptionQuery query = new SubscriptionQuery()
{
Conditions = new[]
{
new SubscriptionQueryCondition()
{
Filter = new ArtifactFilter(workItemArtifactUri)
}
}
};
NotificationSubscription followSubscription = notificationClient.QuerySubscriptionsAsync(query).Result.FirstOrDefault();
// Step 4: Now, unfollow the above workitem, by deleting the subscription
if (followSubscription != null)
{
notificationClient.DeleteSubscriptionAsync(followSubscription.Id).SyncResult();
}
// Step 5: Cleanup the temporary work item
using (new ClientSampleHttpLoggerOutputSuppression())
{
WorkItemTrackingHttpClient witClient = connection.GetClient <WorkItemTrackingHttpClient>();
witClient.DeleteWorkItemAsync(newWorkItem.Id.Value, destroy: true);
}
return(followSubscription);
}
public SubscriptionViewModel(NotificationSubscription subscription, List <EmployeeViewModel> employeeOptions)
{
EmployeeId = subscription.EmployeeId;
Name = subscription.Employee.Name;
Email = subscription.Employee.Email;
NotificationSubscriptionId = subscription.NotificationSubscriptionId;
this.InitOptions(employeeOptions);
}
public NotificationSubscription Subscribe(NotificationSubscription subscription)
{
subscription.UserId = GetCurrentUser();
_subscriptionRepository.Save(subscription);
Send(subscription, "Subscription created");
return(subscription);
}
public bool Save(NotificationSubscription obj, ref string message)
{
if (obj.Id == 0)
{
return(Add(obj, ref message));
}
else
{
return(Update(obj.Id, obj));
}
}
private async Task <PushSubscription> GetPushSubsciption(int id)
{
NotificationSubscription sub = await _context.FindAsync <NotificationSubscription>(id);
PushSubscription subscription = new PushSubscription();
subscription.P256DH = sub.P256DiffHell;
subscription.Auth = sub.Auth;
subscription.Endpoint = sub.Endpoint;
return(subscription);
}
public async Task <IActionResult> AddNotificationSubscription(NotificationSubscription subscription)
{
string userAgent = HttpContext.Request.Headers.TryGetValue("User-Agent", out var browser) ? browser : "";
await notificationService.Subscribe(
subscription with {
UserAgent = userAgent
},
User.GetUserId());
return(NoContent());
}
private static async Task TrackAndSendNotificationsAsync(Order order, NotificationSubscription subscription)
{
await Task.Delay(OrderWithStatus.PreparationDuration);
await SendNotificationsAsync(order, subscription, "Your order has been dispatched");
await Task.Delay(OrderWithStatus.DeliveryDuration);
await SendNotificationsAsync(order,
subscription,
"Your order is now delivered. Enjoy!");
}
public async Task Subscribe(NotificationSubscription subscription, string userId)
{
var removeExistingSubscription = Builders <Profile> .Update
.PullFilter(p => p.NotificationSubscriptions, ns => ns.UserAgent == subscription.UserAgent);
await dbContext.Profiles.FindOneAndUpdateAsync(ud => ud.UserId == userId, removeExistingSubscription);
var insertNewSubscription = Builders <Profile> .Update
.Push(p => p.NotificationSubscriptions, subscription);
await dbContext.Profiles.FindOneAndUpdateAsync(ud => ud.UserId == userId, insertNewSubscription);
}
public async Task <IActionResult> Put([FromBody] UserProfileDto dto)
{
try
{
_logger.Trace(() => $"{GetType().Name}.{nameof(Put)}({nameof(dto)} = {JsonConvert.SerializeObject(dto)})");
var currentUserId = Thread.CurrentPrincipal.GetCurrentUserId();
var user = await _dbContext.Users.FirstOrDefaultAsync(x => x.Id == currentUserId);
if (user == null)
{
_logger.Warn(() => $"Entity not found with id: {dto.Id}");
return(NotFound());
}
// update the email address
user.EmailAddress = dto.Email;
// add/update/remove any of the notifications subscriptions
var subscriptions = await _dbContext.NotificationSubscription.Where(x => x.UserId == user.Id).ToListAsync();
foreach (var dtoSubscription in dto.Subscriptions)
{
var foundItem = subscriptions.FirstOrDefault(x => x.Type == (short)dtoSubscription.Type);
if (dtoSubscription.Notify != NotifyType.None && foundItem == null)
{
var subscription = new NotificationSubscription()
{
Id = Guid.NewGuid(),
UserId = user.Id,
Type = (short)dtoSubscription.Type,
IncludeApp = true,
IncludeEmail = (dtoSubscription.Notify == NotifyType.AppAndEmail)
};
_dbContext.NotificationSubscription.Add(subscription);
}
else if (foundItem != null)
{
foundItem.IncludeApp = (dtoSubscription.Notify != NotifyType.None);
foundItem.IncludeEmail = (dtoSubscription.Notify == NotifyType.AppAndEmail);
}
}
await _dbContext.SaveChangesAsync();
return(Ok(dto));
}
catch (Exception ex)
{
_logger.Error(ex, $"{GetType().Name}.{nameof(Put)}");
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
private static async Task TrackAndSendNotificationsAsync(Order order, NotificationSubscription subscription)
{
// In a realistic case, some other backend process would track
// order delivery progress and send us notifications when it
// changes. Since we don't have any such process here, fake it.
await Task.Delay(OrderWithStatus.PreparationDuration);
await SendNotificationAsync(order, subscription, "Vaše objednávka se vypravila na cestu!");
await Task.Delay(OrderWithStatus.DeliveryDuration);
await SendNotificationAsync(order, subscription, "Vaše objednávka je doručena. Dobrou chuť!");
}
private static async Task TrackAndSendNotificationsAsync(Order order, NotificationSubscription subscription)
{
// In a realistic case, some other backend process would track
// order delivery progress and send us notifications when it
// changes. Since we don't have any such process here, fake it.
await Task.Delay(OrderWithStatus.PreparationDuration);
await SendNotificationAsync(order, subscription, "Your order has been dispatched!");
await Task.Delay(OrderWithStatus.DeliveryDuration);
await SendNotificationAsync(order, subscription, "Your order is now delivered. Enjoy!");
}
public async Task <NotificationSubscription> WriteNotificationSubscription(NotificationSubscription subscription)
{
// Check if there is already a subscription
NotificationSubscription storedSubscription = (await _cosmosDbRepository.GetItems(s => s.Url.Equals(subscription.Url))).FirstOrDefault();
if (null != storedSubscription)
{
subscription.Id = storedSubscription.Id;
}
subscription.TimeToLive = Constants.SUBSCRIPTION_TTL;
return(await _cosmosDbRepository.UpsertItem(subscription));
}
public void AddNotificationListener(ObjectName name, NotificationCallback callback, NotificationFilterCallback filterCallback, object handback)
{
int listenerId = _connection.AddNotificationListener(_token, name, filterCallback);
NotificationSubscription subscr = new NotificationSubscription(callback, filterCallback, handback);
_listenerProxys[subscr] = listenerId;
_reverseListenerProxys[listenerId] = subscr;
List<int> listenerGroup;
if (_listenerGroupProxys.TryGetValue(callback, out listenerGroup))
{
listenerGroup.Add(listenerId);
}
else
{
listenerGroup = new List<int>();
listenerGroup.Add(listenerId);
_listenerGroupProxys[callback] = listenerGroup;
}
}
public void RemoveNotificationListener(ObjectName name, NotificationCallback callback, NotificationFilterCallback filterCallback, object handback)
{
int listenerId;
NotificationSubscription key = new NotificationSubscription(callback, filterCallback, handback);
if (_listenerProxys.TryGetValue(key, out listenerId))
{
_connection.RemoveNotificationListener(_token, name, listenerId);
_reverseListenerProxys.Remove(listenerId);
_listenerProxys.Remove(key);
List<int> listenerGroup = _listenerGroupProxys[callback];
listenerGroup.Remove(listenerId);
if (listenerGroup.Count == 0)
{
_listenerGroupProxys.Remove(callback);
}
}
else
{
throw new ListenerNotFoundException(name.ToString());
}
}
