public async Task <IResultList <Subscription> > QueryAsync(string appId, SubscriptionQuery query, CancellationToken ct = default) { var filters = new List <FilterDefinition <MongoDbSubscription> > { Filter.Eq(x => x.AppId, appId) }; if (!string.IsNullOrWhiteSpace(query.UserId)) { filters.Add(Filter.Eq(x => x.UserId, query.UserId)); } if (!string.IsNullOrWhiteSpace(query.Query)) { var regex = new BsonRegularExpression(query.Query, "i"); filters.Add(Filter.Regex(x => x.TopicPrefix, regex)); } var filter = Filter.And(filters); var taskForItems = Collection.Find(filter).ToListAsync(query, ct); var taskForCount = Collection.Find(filter).CountDocumentsAsync(ct); await Task.WhenAll( taskForItems, taskForCount); return(ResultList.Create(taskForCount.Result, taskForItems.Result.Select(x => x.ToSubscription()))); }
public IEnumerable <NotificationSubscription> QuerySubscriptionsByEventType() { String eventType; if (!Context.TryGetValue <string>("notification.subscriptions.eventType", out eventType)) { eventType = "ms.vss-work.workitem-changed-event"; } // Setup the query SubscriptionQuery query = new SubscriptionQuery() { Conditions = new[] { new SubscriptionQueryCondition() { Flags = SubscriptionFlags.TeamSubscription, Filter = new ExpressionFilter(eventType) } } }; VssConnection connection = Context.Connection; NotificationHttpClient notificationClient = connection.GetClient <NotificationHttpClient>(); IEnumerable <NotificationSubscription> subscriptions = notificationClient.QuerySubscriptionsAsync(query).Result; foreach (NotificationSubscription subscription in subscriptions) { LogSubscription(subscription); } return(subscriptions); }
public async Task ReturnNullSubscriptionMessageIfSubscriptionHasNotBeenMade() { var queryMessage = new SubscriptionQuery(new SubscriptionId("someotheruuid")); var result = await _shardedSubscriptionManager.GetSubscriptionDetails(queryMessage); Assert.IsInstanceOf <NullSubscription>(result); }
public async Task <IResultList <Subscription> > QueryAsync(string appId, SubscriptionQuery query, CancellationToken ct) { var filters = new List <FilterDefinition <MongoDbSubscription> > { Filter.Eq(x => x.AppId, appId) }; if (!string.IsNullOrWhiteSpace(query.UserId)) { filters.Add(Filter.Eq(x => x.UserId, query.UserId)); } if (!string.IsNullOrWhiteSpace(query.Query)) { var regex = new BsonRegularExpression(query.Query, "i"); filters.Add(Filter.Regex(x => x.TopicPrefix, regex)); } var filter = Filter.And(filters); var resultItems = await Collection.Find(filter).ToListAsync(query, ct); var resultTotal = (long)resultItems.Count; if (query.ShouldQueryTotal(resultItems)) { resultTotal = await Collection.Find(filter).CountDocumentsAsync(ct); } return(ResultList.Create(resultTotal, resultItems.Select(x => x.ToSubscription()))); }
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 IActionResult Info([FromServices] SubscriptionQueryFactory queryFactory, int blogId) { var query = new SubscriptionQuery { BlogId = blogId, AccountId = _userManager.GetUserId(User) }; return(Json(new { isSubscriped = queryFactory.Build(query).Get() })); }
private void Process(SubscriptionQuery query) { if (subscriptionMessage == null) { Sender.Tell(new NullSubscription(), Context.Self); } else { Sender.Tell(subscriptionMessage, Context.Self); } }
public void ShowAllTeamSubscriptions() { VssConnection connection = Context.Connection; // // Step 1: construct query to find all subscriptions belonging to teams in the project // TeamProjectReference project = ClientSampleHelpers.FindAnyProject(this.Context); // Get all teams in the project TeamHttpClient teamClient = connection.GetClient <TeamHttpClient>(); IEnumerable <WebApiTeam> teams = teamClient.GetTeamsAsync(project.Id.ToString()).Result; // Construct a set of query conditions (one for each team) IEnumerable <SubscriptionQueryCondition> conditions = teams.Select <WebApiTeam, SubscriptionQueryCondition>(team => { return(new SubscriptionQueryCondition() { SubscriberId = team.Id }); } ); // Construct the query, making sure to return basic details for subscriptions the caller doesn't have read access to SubscriptionQuery query = new SubscriptionQuery() { Conditions = conditions, QueryFlags = SubscriptionQueryFlags.AlwaysReturnBasicInformation }; // // Part 2: query and show the results // NotificationHttpClient notificationClient = connection.GetClient <NotificationHttpClient>(); IEnumerable <NotificationSubscription> subscriptions = notificationClient.QuerySubscriptionsAsync(query).Result; var subscriptionsBySubscriber = subscriptions.GroupBy <NotificationSubscription, Guid>(sub => { return(Guid.Parse(sub.Subscriber.Id)); }); foreach (var team in teams) { // Find the corresponding team for this group var group = subscriptionsBySubscriber.First(t => t.Key == team.Id); // Show the details for each subscription owned by this team foreach (NotificationSubscription subscription in group) { LogSubscription(subscription); } } }
public async Task CreateANewSubscriptionIfTheSubscriptionDoesntExist() { var subscriptionMessage = new SubscriptionMessage( new LocalEventNotificationChannel(), new SubscriptionId(Guid.NewGuid().ToString()), new AllEventMatcher()); _shardedSubscriptionManager.CreateSubscription(subscriptionMessage); var queryMessage = new SubscriptionQuery(subscriptionMessage.SubscriptionId); var result = await _shardedSubscriptionManager.GetSubscriptionDetails(queryMessage); Assert.AreEqual(subscriptionMessage, result); }
public void UnfollowWorkItem() { // Get the temporary work item created in the "follow work item" method above WorkItem workItem; if (!this.Context.TryGetValue <WorkItem>("$followedWorkItem", out workItem)) { // should log an error } else { VssConnection connection = Context.Connection; NotificationHttpClient notificationClient = Context.Connection.GetClient <NotificationHttpClient>(); NotificationSubscription followSubscription; using (new ClientSampleHttpLoggerOutputSuppression()) { // We want to query for "artifact" (follow) subscription for the specified work item ID (for the calling user) SubscriptionQuery query = new SubscriptionQuery() { Conditions = new[] { new SubscriptionQueryCondition() { Filter = new ArtifactFilter(null) { ArtifactType = "WorkItem", ArtifactId = workItem.Id.ToString() } } } }; followSubscription = notificationClient.QuerySubscriptionsAsync(query).Result.FirstOrDefault(); } LogSubscription(followSubscription); // Delete this subscription to "unfollow" the user from the work item notificationClient.DeleteSubscriptionAsync(followSubscription.Id).SyncResult(); } }
public async Task SendNotification([ServiceBusTrigger(ApplicationSettings.JobMessagesQueue)] Guid id, TextWriter log) { try { await log.WriteLineAsync($"Sending notifications for {id}"); var query = new SubscriptionQuery(_settings, _connectionFactory); var subscription = await query.GetSubscriptionById(id); if (subscription == null || subscription.ConfirmationSentOn.HasValue) { return; } var mailMessage = _messageFactory.CreateConfirmationMessage(subscription); subscription.ConfirmationSentOn = DateTime.UtcNow; var update = new UpdateSubscriptionCommand(_settings, _connectionFactory); await update.Update(subscription, async (s, c, t) => { var updateStats = new UpdateStatisticCommands(_settings, _connectionFactory); await updateStats.AddOrUpdateDomainCount(subscription.GetDomain(), c, t); using (var smtpClient = new SmtpClient()) { await smtpClient.SendMailAsync(mailMessage); } }); await log.WriteLineAsync($"Sent email to {subscription.EmailAddress}"); } catch (Exception e) { log.Write($"GUID: {id}, Error: {e.Message}"); throw; } }
public async Task <IResultList <Subscription> > QueryAsync(string appId, SubscriptionQuery query, CancellationToken ct = default) { using (var activity = Telemetry.Activities.StartActivity("MongoDbSubscriptionRepository/QueryAsync")) { var filter = BuildFilter(appId, query); var resultItems = await Collection.Find(filter).ToListAsync(query, ct); var resultTotal = (long)resultItems.Count; if (query.ShouldQueryTotal(resultItems)) { resultTotal = await Collection.Find(filter).CountDocumentsAsync(ct); } activity?.SetTag("numResults", resultItems.Count); activity?.SetTag("numTotal", resultTotal); return(ResultList.Create(resultTotal, resultItems.Select(x => x.ToSubscription()))); } }
public static async Task ProcessMissingConfirmationEmails(TextWriter log) { await log.WriteLineAsync("Starting resend of missing confirmation emails"); var settings = new ApplicationSettings(""); var connectionFactory = new SqlConnectionFactory(); var query = new SubscriptionQuery(settings, connectionFactory); var subscriptions = await query.GetSubscriptionsWithMissingConfirmations(); var messageFactory = new MessageFactory(settings); var updater = new UpdateSubscriptionCommand(settings, connectionFactory); foreach (var subscription in subscriptions.Where(s => s.CreatedOn > DateTime.UtcNow.Date)) { await log.WriteLineAsync($"Sending confirmation email to {subscription.EmailAddress}"); subscription.ConfirmationSentOn = DateTime.UtcNow; await updater.Update(subscription, async (s, c, t) => { using (var smtpClient = new SmtpClient()) { var updateStats = new UpdateStatisticCommands(settings, connectionFactory); await updateStats.AddOrUpdateDomainCount(subscription.GetDomain(), c, t); await smtpClient.SendMailAsync(messageFactory.CreateConfirmationMessage(s)); } }); } await log.WriteLineAsync("Completed resend of missing confirmation emails"); }
public IQueryHandler <SubscriptionQuery, bool> Build(SubscriptionQuery query) { return(new SubscriptionQueryHandler(query, _queryDb)); }
private static FilterDefinition <MongoDbSubscription> BuildFilter(string appId, SubscriptionQuery query) { var filters = new List <FilterDefinition <MongoDbSubscription> > { Filter.Eq(x => x.AppId, appId) }; if (!string.IsNullOrWhiteSpace(query.UserId)) { filters.Add(Filter.Eq(x => x.UserId, query.UserId)); } if (query.Topics != null) { filters.Add(Filter.In(x => x.TopicPrefix, query.Topics)); } else if (!string.IsNullOrWhiteSpace(query.Query)) { var regex = new BsonRegularExpression(Regex.Escape(query.Query), "i"); filters.Add(Filter.Regex(x => x.TopicPrefix, regex)); } return(Filter.And(filters)); }
public async Task <SubscriptionMessage> GetSubscriptionDetails(SubscriptionQuery query) { return(await SubscriptionActorRef.Ask <SubscriptionMessage>(query, TimeSpan.FromSeconds(3))); }