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