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