/// <inheritdoc /> public async Task <UserDetailView> Handle( UserByEmailQuery request, CancellationToken cancellationToken) { var sqlQueryText = "SELECT * FROM c WHERE c.EmailAddress = @EmailAddress"; QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText) .WithParameter("@EmailAddress", request.EmailAddress); FeedIterator <UserPersistenceModel> results = container.GetItemQueryIterator <UserPersistenceModel>(queryDefinition); if (results.HasMoreResults) { FeedResponse <UserPersistenceModel> page = await results.ReadNextAsync(cancellationToken); var user = page.FirstOrDefault(); if (user != null) { return(new UserDetailView() { UserId = user.Id, Name = $"{user.FirstName} {user.MiddleName} {user.LastName}", PhoneNumber = user.PhoneNumber, EmailAddress = user.EmailAddress }); } } return(null); }
public async Task <(bool, string)> CheckActiveReindexJobsAsync(CancellationToken cancellationToken) { try { var query = _queryFactory.Create <CosmosReindexJobRecordWrapper>( _containerScope.Value, new CosmosQueryContext( new QueryDefinition(CheckActiveJobsByStatusQuery), new QueryRequestOptions { PartitionKey = new PartitionKey(CosmosDbReindexConstants.ReindexJobPartitionKey) })); FeedResponse <CosmosReindexJobRecordWrapper> result = await query.ExecuteNextAsync(); if (result.Any()) { return(true, result.FirstOrDefault().JobRecord.Id); } return(false, string.Empty); } catch (CosmosException dce) { if (dce.IsRequestRateExceeded()) { throw; } _logger.LogError(dce, "Failed to check if any reindex jobs are active."); throw; } }
public async Task <YEngine> GetEngineByNameAsync(string name, Guid userId) { try { using CosmosClient client = new CosmosClient(accountEndpoint, accountKey, clientOptions); var container = client.GetContainer(databaseName, containerName); var results = new List <YEngine>(); QueryDefinition query = new QueryDefinition( @"SELECT VALUE c FROM c WHERE (EXISTS(SELECT VALUE o FROM o IN c.Owners WHERE o.Id = @userId) OR EXISTS(SELECT VALUE o FROM o IN c.Members WHERE o.Id = @userId)) AND c.EngineName = @name") .WithParameter("@userId", userId) .WithParameter("@name", name); var resultSetIterator = container.GetItemQueryIterator <YEngine>( query, null, new QueryRequestOptions { PartitionKey = enginePartitionKey, MaxItemCount = 1 }); FeedResponse <YEngine> response = await resultSetIterator.ReadNextAsync().ConfigureAwait(false); return(response.FirstOrDefault()); } catch (Exception ex) { Debug.WriteLine(ex); return(null); } }
// no more than one alert per week public static async Task suppressDetection(EventItem eventItem, string type, string userId, string evidence) { var now = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds(); //we don't want to raise alert on old events if (eventItem.timestamp < now - TimeSpan.FromDays(7).TotalSeconds) { return; } var sqlQueryText = $"SELECT TOP 1 * FROM c WHERE c.device_id = '{eventItem.device_id}' AND " + $"c.created_at > {(now - TimeSpan.FromDays(7).TotalSeconds)} AND " + $"c.type = '{type}' order by c.created_at"; logger.LogInformation("Checking older alerts..."); QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText); FeedIterator <AlertItem> queryResultSetIterator = Resources.alert_container.GetItemQueryIterator <AlertItem>(queryDefinition); if (queryResultSetIterator.HasMoreResults) { FeedResponse <AlertItem> currentResultSet = await queryResultSetIterator.ReadNextAsync(); AlertItem alert = currentResultSet.FirstOrDefault <AlertItem>(); if (!Object.Equals(null, alert)) { logger.LogInformation("Detection was suppressed"); return; } } await createAlert(eventItem, type, userId, evidence); }
/// <summary> /// Finds an instance based on a Boolean property filter criteria. /// </summary> /// <param name="predicate">The property filter criteria which takes an instance of the type and returns a Boolean match on a property value.</param> /// <returns>An instance of the type.</returns> public virtual async Task <T> Find(Expression <Func <T, bool> > predicate) { // https://docs.microsoft.com/en-us/dotnet/api/microsoft.azure.cosmos.container.getitemlinqqueryable?view=azure-dotnet // TODO: One of the other methods may be more efficient? FeedResponse <T> response = await _cosmos.ExecuteIterator(c => c .GetItemLinqQueryable <T>(true) .Where(predicate).ToFeedIterator()); return(response?.FirstOrDefault()); }
private static async Task <CollectionVersion> GetLatestCollectionVersion(Container container, CancellationToken cancellationToken) { FeedIterator <CollectionVersion> query = container.GetItemQueryIterator <CollectionVersion>( new QueryDefinition("SELECT * FROM root r"), requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey(CollectionVersion.CollectionVersionPartition), }); FeedResponse <CollectionVersion> result = await query.ReadNextAsync(cancellationToken); return(result.FirstOrDefault() ?? new CollectionVersion()); }
public async Task <Models.User> GetUser(string UserId) { var queryText = "SELECT * FROM c WHERE c.id = '" + UserId + "'"; QueryDefinition queryDefinition = new (queryText); FeedIterator <Models.User> queryResultIterator = CosmosUserContainer.GetItemQueryIterator <Models.User>(queryDefinition); List <Models.User> userResult = new(); while (queryResultIterator.HasMoreResults) { FeedResponse <Models.User> result = await queryResultIterator.ReadNextAsync(); return(result.FirstOrDefault()); } return(null); }
public async Task CosmosConflictsIteratorBuildsSettings() { string conflictResponsePayload = @"{ 'Data':[{ id: 'Conflict1', operationType: 'Replace', resourceType: 'trigger' }]}"; CosmosClient mockClient = MockCosmosUtil.CreateMockCosmosClient( (cosmosClientBuilder) => cosmosClientBuilder.WithConnectionModeDirect()); Container container = mockClient.GetContainer("database", "container"); FeedIterator <ConflictProperties> feedIterator = container.Conflicts.GetConflictQueryIterator <ConflictProperties>(); TestHandler testHandler = new TestHandler((request, cancellationToken) => { Assert.IsTrue(request.IsPartitionedFeedOperation); Assert.AreEqual(OperationType.ReadFeed, request.OperationType); Assert.AreEqual(ResourceType.Conflict, request.ResourceType); ResponseMessage handlerResponse = TestHandler.ReturnSuccess().Result; MemoryStream stream = new MemoryStream(); StreamWriter writer = new StreamWriter(stream); writer.Write(conflictResponsePayload); writer.Flush(); stream.Position = 0; handlerResponse.Content = stream; return(Task.FromResult(handlerResponse)); }); mockClient.RequestHandler.InnerHandler = testHandler; FeedResponse <ConflictProperties> response = await feedIterator.ReadNextAsync(); Assert.AreEqual(1, response.Count()); ConflictProperties responseSettings = response.FirstOrDefault(); Assert.IsNotNull(responseSettings); Assert.AreEqual("Conflict1", responseSettings.Id); Assert.AreEqual(Cosmos.OperationKind.Replace, responseSettings.OperationKind); Assert.AreEqual(typeof(TriggerProperties), responseSettings.ResourceType); }
protected async Task <Edge> ExecuteVertexEdgeCommandAsync(string command) { Console.WriteLine($"Executing: {command} ..."); IDocumentQuery <Edge> query = this.DocumentClient.CreateGremlinQuery <Edge>(this.GraphCollection, command); while (query.HasMoreResults) { Console.Write("Results:"); FeedResponse <Edge> results = await query.ExecuteNextAsync <Edge>(); foreach (Edge edge in results) { Console.WriteLine($"\t {JsonConvert.SerializeObject(edge)}"); } Console.WriteLine(); return(results.FirstOrDefault()); } return(null); }
public async Task <IReadOnlyCollection <ReindexJobWrapper> > AcquireReindexJobsAsync(ushort maximumNumberOfConcurrentJobsAllowed, TimeSpan jobHeartbeatTimeoutThreshold, CancellationToken cancellationToken) { // TODO: Shell for testing IDocumentQuery <int> query = _documentClientScope.Value.CreateDocumentQuery <int>( CollectionUri, new SqlQuerySpec(CheckActiveJobsByStatusQuery), new FeedOptions { PartitionKey = new PartitionKey(CosmosDbReindexConstants.ReindexJobPartitionKey) }) .AsDocumentQuery(); FeedResponse <CosmosReindexJobRecordWrapper> result = await query.ExecuteNextAsync <CosmosReindexJobRecordWrapper>(); var jobList = new List <ReindexJobWrapper>(); CosmosReindexJobRecordWrapper cosmosJob = result.FirstOrDefault(); if (cosmosJob != null) { jobList.Add(new ReindexJobWrapper(cosmosJob.JobRecord, WeakETag.FromVersionId(cosmosJob.ETag))); } return(jobList); }
/// <summary> /// Finds an instance based on a query and parameters. /// </summary> /// <param name="query">The query.</param> /// <param name="parameters">The list of parameters.</param> /// <param name="partitionKey">The partition key.</param> /// <returns>An instance of the type.</returns> public virtual async Task <T> Find(string query, Dictionary <string, object> parameters = null, string partitionKey = null) { // TODO: One of the other methods may be more efficient? QueryDefinition queryDefinition = new QueryDefinition(query); if (parameters != null) { foreach (var item in parameters) { queryDefinition.WithParameter(item.Key, item.Value); } } PartitionKey key = !string.IsNullOrWhiteSpace(partitionKey) ? new PartitionKey(partitionKey) : new PartitionKey(typeof(T).Name.ToLowerInvariant()); FeedResponse <T> response = await _cosmos.ExecuteIterator(c => c .GetItemQueryIterator <T>(queryDefinition, requestOptions: new QueryRequestOptions() { PartitionKey = key })); return(response?.FirstOrDefault()); }
public async Task <GetOrderByIdResponseModel> GetItemAsync(int orderId) { try { var container = _dbClient.GetContainer(_databaseName, _readContainerName); QueryDefinition query = new QueryDefinition( "select * from orders where orders.orderId = @orderId") .WithParameter("@orderId", orderId); using (FeedIterator <GetOrderByIdResponseModel> resultSet = container.GetItemQueryIterator <GetOrderByIdResponseModel>( query, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey(orderId), MaxItemCount = 1 })) { GetOrderByIdResponseModel order = null; while (resultSet.HasMoreResults) { FeedResponse <GetOrderByIdResponseModel> response = await resultSet.ReadNextAsync(); order = response.FirstOrDefault(); break; } return(order); } } catch (CosmosException ex) when(ex.StatusCode == System.Net.HttpStatusCode.NotFound) { return(null); } }
public async Task <IAggregateSnapshot <TKey> > FindLastSnapshotAsync(TKey aggregateId, int maxVersion, CancellationToken cancellationToken = default) { string query = $@" SELECT TOP 1 VALUE c.data FROM c WHERE c.data.aggregateId = '{aggregateId}' AND c.data.aggregateVersion <= {maxVersion} ORDER BY c.data.aggregateVersion DESC"; FeedIterator <IAggregateSnapshot <TKey> > iterator = _container .GetItemQueryIterator <IAggregateSnapshot <TKey> >(new QueryDefinition(query)); if (!iterator.HasMoreResults) { return(null); } FeedResponse <IAggregateSnapshot <TKey> > response = await iterator .ReadNextAsync(cancellationToken) .ConfigureAwait(false) ; return(response.FirstOrDefault()); }
public async Task <IReadOnlyCollection <ReindexJobWrapper> > AcquireReindexJobsAsync(ushort maximumNumberOfConcurrentJobsAllowed, TimeSpan jobHeartbeatTimeoutThreshold, CancellationToken cancellationToken) { // TODO: Shell for testing var query = _queryFactory.Create <CosmosReindexJobRecordWrapper>( _containerScope.Value, new CosmosQueryContext( new QueryDefinition(CheckActiveJobsByStatusQuery), new QueryRequestOptions { PartitionKey = new PartitionKey(CosmosDbReindexConstants.ReindexJobPartitionKey) })); FeedResponse <CosmosReindexJobRecordWrapper> result = await query.ExecuteNextAsync(); var jobList = new List <ReindexJobWrapper>(); CosmosReindexJobRecordWrapper cosmosJob = result.FirstOrDefault(); if (cosmosJob != null) { jobList.Add(new ReindexJobWrapper(cosmosJob.JobRecord, WeakETag.FromVersionId(cosmosJob.ETag))); } return(jobList); }
public async Task <Guid> InsertUpdateDocument(InvestorDocumentFlat document) { using (var client = new CosmosClient(_functionSettings.CosmosDBEndpoint, _functionSettings.CosmosDBMasterKey)) { var container = client.GetContainer(_functionSettings.CosmosDBName, SQLStatements.InvestorDocuments.ContainerName); var sql = SQLStatements.InvestorDocuments.ListInvestorDocs; var query = new QueryDefinition(sql); query.WithParameter("@InvestorId", document.InvestorId); var iterator = container .GetItemQueryIterator <InvestorDocument>(query, requestOptions: new QueryRequestOptions() { MaxConcurrency = 1 }); var docDetails = new DocumentDetails() { RefId = document.RefId, Type = document.Type, AccountNo = document.AccountNo, Date = document.Date, ProductCode = document.ProductCode, ProductName = document.ProductName, Link = document.Link }; while (iterator.HasMoreResults) { var task = iterator.ReadNextAsync(); task.Wait(); FeedResponse <InvestorDocument> response = task.Result; if (response.Any()) { var item = response.FirstOrDefault(); if (item != null) { var d = item.Corro.Where(x => x.RefId == document.RefId).FirstOrDefault(); if (d == null) { item.Corro.Add(docDetails); } else { //Only update the link to document d.Link = document.Link; } await container.ReplaceItemAsync(item, item.id.ToString(), new PartitionKey(item.InvestorId)); return(item.id); } } else { break; } } var doc = new InvestorDocument() { InvestorId = document.InvestorId, id = Guid.NewGuid(), Corro = new List <DocumentDetails>() }; doc.Corro.Add(docDetails); var insertResponse = await container.CreateItemAsync(doc, new PartitionKey(doc.InvestorId)); document.id = insertResponse.Resource.id; } return(document.id); }