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); }
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()); } }