public async Task <TDomainEntity> GetById(string id) { // TODO: Passing id as pk is not the correct approach! CosmosDbResponse <TDomainEntity> response = await Container.Get <TDomainEntity>(id, id); return(response.Result); }
public async Task <PagedMessages <ArchivedMessage> > Handle(GetMessages request, CancellationToken cancellationToken) { ICosmosDbContainer messagesContainer = await _cosmosDbClient.GetContainer("messages"); IQueryable <ArchivedMessage> query = messagesContainer.GetByLinq <ArchivedMessage>(); query = ApplyFilters(query, request); query = query.OrderByDescending(m => m.MessageDate); int count = await messagesContainer.ResolveCount(query); query = ApplyPaging(query, request); CosmosDbResponse <IEnumerable <ArchivedMessage> > messages = await messagesContainer.ResolveWithStreamIterator(query); if (!messages.IsSuccessful) { throw new ApplicationException($"Error fetching messages: {messages.ErrorMessage}"); } return(new PagedMessages <ArchivedMessage>() { Messages = messages.Result, PageIndex = request.MessageFilters.PageIndex, PageSize = request.MessageFilters.PageSize, TotalRecords = count }); }
private async Task TrackResponse(CosmosDbResponse resp) { if (ChargeTracker != null) { await ChargeTracker?.Track(resp.ToChargedResponse(_innerContainer.Definition.ContainerId, Feature, Tags)); } }
public async Task <CosmosDbResponse <IEnumerable <T> > > ResolveWithStreamIterator <T>(IQueryable <T> query) { CosmosDbResponse <IEnumerable <T> > resp = await _innerContainer.ResolveWithStreamIterator(query); await TrackResponse(resp); return(resp); }
public async Task <CosmosDbResponse <IEnumerable <T> > > GetAll <T>() { CosmosDbResponse <IEnumerable <T> > resp = await _innerContainer.GetAll <T>(); await TrackResponse(resp); return(resp); }
public async Task <CosmosDbResponse <IEnumerable <T> > > GetByQuery <T>(string partitionKey, string query, IReadOnlyDictionary <string, object> parameters) { CosmosDbResponse <IEnumerable <T> > resp = await _innerContainer.GetByQuery <T>(partitionKey, query, parameters); await TrackResponse(resp); return(resp); }
public async Task <CosmosDbResponse <IEnumerable <T> > > Get <T>(string partitionKey, Expression <Func <T, bool> > predicate) { CosmosDbResponse <IEnumerable <T> > resp = await _innerContainer.Get(partitionKey, predicate); await TrackResponse(resp); return(resp); }
public async Task <CosmosDbResponse <T> > Get <T>(string id) { CosmosDbResponse <T> resp = await _innerContainer.Get <T>(id); await TrackResponse(resp); return(resp); }
public async Task <CosmosDbResponse <IEnumerable <T> > > GetByQuery <T>(string partitionKey, string query) { CosmosDbResponse <IEnumerable <T> > resp = await _innerContainer.GetByQuery <T>(partitionKey, query); await TrackResponse(resp); return(resp); }
public async Task <int> Count <TResult>(Expression <Func <IQueryable <TDomainEntity>, IQueryable <TResult> > > queryExpression) { IQueryable <TDomainEntity> query = Container.GetByLinq <TDomainEntity>(); IQueryable <TResult> q = queryExpression.Compile().Invoke(query); CosmosDbResponse <int> response = await Container.ResolveCount(q); return(response.Result); }
public async Task <CosmosDbResponse <T> > Delete <T>(string partitionKey, string id) { CosmosDbResponse <T> resp = await _innerContainer.Delete <T>(partitionKey, id); await TrackResponse(resp); return(resp); }
public async Task <CosmosDbResponse <T> > Update <T>(string partitionKey, T entity) { CosmosDbResponse <T> resp = await _innerContainer.Update(partitionKey, entity); await TrackResponse(resp); return(resp); }
public async Task <TDomainEntity> Delete(TDomainEntity entity) { CosmosDbResponse <TDomainEntity> deletedEntity = await Container.Delete <TDomainEntity>(ResolvePartitionKeyValue(entity), entity.Id); if (!deletedEntity.IsSuccessful) { throw new CosmosDbException($"DELETE Error: {deletedEntity.ErrorMessage}", typeof(TDomainEntity), entity.Id); } return(deletedEntity.Result); }
public async Task <TDomainEntity> GetById(string id) { CosmosDbResponse <TDomainEntity> response = await Container.Get <TDomainEntity>(id); if (!response.IsSuccessful) { throw new CosmosDbException($"GetById Error: {response.ErrorMessage}", typeof(TDomainEntity), id); } return(response.Result); }
public async Task <IEnumerable <TDomainEntity> > Get(Expression <Func <TDomainEntity, bool> > predicate) { IQueryable <TDomainEntity> query = Container.GetByLinq <TDomainEntity>() // add the predicate .Where(predicate); CosmosDbResponse <IEnumerable <TDomainEntity> > response = await Container.Resolve(query); return(response.Result); }
public async Task <TDomainEntity> Update(TDomainEntity entity) { CosmosDbResponse <TDomainEntity> updatedEntity = await Container.Update(ResolvePartitionKeyValue(entity), entity); if (!updatedEntity.IsSuccessful) { throw new CosmosDbException($"UPDATE Error: {updatedEntity.ErrorMessage}", typeof(TDomainEntity), entity.Id); } return(updatedEntity.Result); }
public async Task <IEnumerable <TDomainEntity> > Get(Expression <Func <TDomainEntity, bool> > predicate) { IQueryable <TDomainEntity> query = Container.GetByLinq <TDomainEntity>() // add the predicate .Where(predicate); CosmosDbResponse <IEnumerable <TDomainEntity> > response = await Container.Resolve(query); if (!response.IsSuccessful) { throw new CosmosDbException($"GET Error: {response.ErrorMessage}", typeof(TDomainEntity)); } return(response.Result); }
public async Task <TDomainEntity> Add(TDomainEntity entity) { // TODO: Move the ID Value Generator and Discriminator Setter to the lower level container // always set new ID entity.Id = _idValueGenerator.Generate(entity); // always set the entity type / Discriminator entity.Discriminator = _entityType; CosmosDbResponse <TDomainEntity> response = await Container.Add(ResolvePartitionKeyValue(entity), entity); return(response.Result); }
public static CosmosDbChargedResponse ToChargedResponse(this CosmosDbResponse response, string containerId, string feature, IEnumerable <string> context) { return(new CosmosDbChargedResponse() { ContainerId = containerId, Feature = feature, Context = context, StatusCode = response.StatusCode, ExecutionTime = response.ExecutionTime, RequestCharge = response.RequestCharge }); }
public async Task <IEnumerable <HealthCheckInfo> > Handle(GetHealthCheckInfo request, CancellationToken cancellationToken) { IList <HealthCheckInfo> healthCheckInfoList = new List <HealthCheckInfo>(); //Get the latest HealthCheck Requests from Cosmos DB ICosmosDbContainer messagesContainer = await _cosmosDbClient.GetContainer("messages"); IQueryable <ArchivedMessage> query = messagesContainer.GetByLinq <ArchivedMessage>(); query = query.Where(m => m.Message.MessageType == typeof(HealthCheckRequest).AssemblyQualifiedName) .OrderByDescending(m => m.MessageDate) .Take(12); // last hour CosmosDbResponse <IEnumerable <ArchivedMessage> > messages = await messagesContainer.ResolveWithStreamIterator(query); if (!messages.IsSuccessful) { throw new ApplicationException($"Error fetching messages: {messages.ErrorMessage}"); } foreach (var message in messages.Result) { var heathCheckRequest = message.Message as HealthCheckRequest; var healthCheckInfo = new HealthCheckInfo { HealthCheckRequest = heathCheckRequest }; //Search the HealthCheck Responses using the correlationId IEnumerable <ArchivedMessage> healthCheckResponses = await GetHealthCheckResponsesByCorrelationId(message.Message.CorrelationId); foreach (var response in healthCheckResponses) { HealthCheckResponse healthCheckResponse = (HealthCheckResponse)response.Message; healthCheckResponse.ResponseStatus = healthCheckResponse.AggregateTestResults(); MarkDelayedHealthyResponseAsWarning(healthCheckResponse, heathCheckRequest.MessageDate); healthCheckInfo.HealthCheckResponses.Add(healthCheckResponse); } AddErrorsForMissingServices(healthCheckInfo); AggregateResult(healthCheckInfo); healthCheckInfoList.Add(healthCheckInfo); } return(healthCheckInfoList); }
public async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, ILogger log) { log.LogInformation("C# HTTP trigger Test Storing a message!"); var message = new ArchivedMessage(new TestMessage() { Description = "This is a test message with a random value of " + new Random().Next(0, int.MaxValue) }); ICosmosDbContainer cosmosContainer = await _cosmosClient.GetContainer <ArchivedMessage>(); CosmosDbResponse <ArchivedMessage> cosmosResponse = await cosmosContainer.Add(message.Id, message); return(new OkObjectResult($"Cosmos Response: {cosmosResponse.IsSuccessful}")); }
public async Task <TDomainEntity> Add(TDomainEntity entity) { // TODO: Move the ID Value Generator and Discriminator Setter to the lower level container // always set new ID entity.Id = _idValueGenerator.Generate(entity); // always set the entity type / Discriminator entity.Discriminator = _entityType; CosmosDbResponse <TDomainEntity> response = await Container.Add(ResolvePartitionKeyValue(entity), entity); if (!response.IsSuccessful) { throw new CosmosDbException($"Add Error: {response.ErrorMessage}", typeof(TDomainEntity), entity.Id); } return(response.Result); }
private async Task <IEnumerable <ArchivedMessage> > GetHealthCheckResponsesByCorrelationId(string correlationId) { ICosmosDbContainer messagesContainer = await _cosmosDbClient.GetContainer("messages"); IQueryable <ArchivedMessage> queryHealthCheckResponse = messagesContainer.GetByLinq <ArchivedMessage>(); queryHealthCheckResponse = queryHealthCheckResponse.Where(m => m.Message.MessageType == typeof(HealthCheckResponse).AssemblyQualifiedName && m.Message.CorrelationId == correlationId); CosmosDbResponse <IEnumerable <ArchivedMessage> > messages = await messagesContainer.ResolveWithStreamIterator(queryHealthCheckResponse); if (!messages.IsSuccessful) { throw new ApplicationException($"Error fetching messages: {messages.ErrorMessage}"); } return(messages.Result); }
public async Task Run([ServiceBusTrigger("%ServiceBusTopic%", "%ServiceBusSubscription%", Connection = "ServiceBusConnectionString")] string messageString, ILogger log) { MessageBase originalMessage = null; try { originalMessage = _messageReader.ReadMessage(messageString); var archivedMessage = new ArchivedMessage(originalMessage); if (archivedMessage.MessageTypeName.Equals(nameof(HealthCheckRequest))) { await HandleHealthCheckRequest(_messageReader.ReadMessage <HealthCheckRequest>(messageString)); } ICosmosDbContainer cosmosContainer = await _cosmosClient.GetContainer <ArchivedMessage>(); CosmosDbResponse <ArchivedMessage> cosmosResponse = await cosmosContainer.Add(archivedMessage.Id, archivedMessage); if (!cosmosResponse.IsSuccessful) { throw new ApplicationException( $"MessageStorage failed to write message {archivedMessage.Message.MessageId} of type {archivedMessage.Message.MessageType}. {cosmosResponse.ErrorMessage}"); } } catch (Exception storeException) { try { log.LogError(storeException, "exception saving to MessageStorage. OriginalMessage: " + messageString); await _messageSender.SendException(storeException, originalMessage); } catch (Exception sendException) { log.LogCritical(sendException, "Exception attempting to save an error message to the bus! This is very bad!"); } throw; } }
private async Task <IEnumerable <TDomainEntity> > Resolve(IQueryable <TDomainEntity> query) { CosmosDbResponse <IEnumerable <TDomainEntity> > resolvedQuery = await Container.Resolve(query); return(resolvedQuery.Result); }
public async Task <TDomainEntity> Update(TDomainEntity entity) { CosmosDbResponse <TDomainEntity> updatedEntity = await Container.Update(ResolvePartitionKeyValue(entity), entity); return(updatedEntity.Result); }
public async Task <TDomainEntity> Delete(TDomainEntity entity) { CosmosDbResponse <TDomainEntity> deletedEntity = await Container.Delete <TDomainEntity>(ResolvePartitionKeyValue(entity), entity.Id); return(deletedEntity.Result); }
public async Task <TDomainEntity> GetById(string id) { CosmosDbResponse <TDomainEntity> response = await Container.Get <TDomainEntity>(id); return(response.Result); }
public async Task <IEnumerable <TDomainEntity> > GetAll() { CosmosDbResponse <IEnumerable <TDomainEntity> > response = await Container.GetAll <TDomainEntity>(); return(response.Result); }