public async Task <List <Product> > GetProductsAsync(string Id) { Shop res = null; try { res = await client.ReadDocumentAsync <Shop>(UriFactory.CreateDocumentUri(databaseName, collectionName, Id)); } catch { throw new System.Exception($"Shop with id:{Id} was not found"); } return(res.Products.Values.ToList()); }
public async Task Send <T>(ConsumeContext <T> context, ISagaPolicy <TSaga, T> policy, IPipe <SagaConsumeContext <TSaga, T> > next) where T : class { if (!context.CorrelationId.HasValue) { throw new SagaException("The CorrelationId was not specified", typeof(TSaga), typeof(T)); } Document document = null; if (policy.PreInsertInstance(context, out var instance)) { document = await PreInsertSagaInstance(context, instance).ConfigureAwait(false); } if (instance == null) { try { ResourceResponse <Document> response = await _client .ReadDocumentAsync(UriFactory.CreateDocumentUri(_databaseName, _collectionName, context.CorrelationId.ToString()), _requestOptions) .ConfigureAwait(false); document = response.Resource; } catch (DocumentClientException e) when(e.StatusCode == System.Net.HttpStatusCode.NotFound) { // Couldn't find the document, swallowing exception } if (document != null) { instance = JsonConvert.DeserializeObject <TSaga>(document.ToString()); } } if (instance == null) { var missingSagaPipe = new MissingPipe <TSaga, T>(_client, _databaseName, _collectionName, next, _documentDbSagaConsumeContextFactory, _requestOptions); await policy.Missing(context, missingSagaPipe).ConfigureAwait(false); } else { await SendToInstance(context, policy, next, instance, document).ConfigureAwait(false); } }
public async Task <TModel> FetchItemAsync(string id) { var documentUri = UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id); var resourceResponse = await documentClient.ReadDocumentAsync(documentUri); return((TModel)((dynamic)resourceResponse.Resource)); }
public async Task <Document> ReadDocumentAsync(string documentId, RequestOptions options = null, CancellationToken cancellationToken = default(CancellationToken)) { var uri = UriFactory.CreateDocumentUri(_databaseName, _collectionName, documentId); return(await _documentClient.ReadDocumentAsync(uri, options, cancellationToken)); }
/// <summary> /// Generic version of ReadDocumentAsync that returns the queried document deserialized into the given generic type /// </summary> /// <typeparam name="T">The Type of the Document to read from DocumentDb</typeparam> /// <param name="client">The <see cref="IDocumentClient"/> this extension method is executed on</param> /// <param name="documentUri">The <see cref="Uri"/> of the document to read from DocumentDB</param> /// <param name="requestOptions">The <see cref="RequestOptions"/> used for calling DocumentDB</param> /// <returns>The Document read from DocumentDB, deserialized into the given generic Type</returns> internal static async Task <T> ReadDocumentAsync <T>(this IDocumentClient client, Uri documentUri, RequestOptions requestOptions) { ResourceResponse <Document> response; if (documentUri == null) { throw new ArgumentNullException(nameof(documentUri)); } try { response = await client.ReadDocumentAsync(documentUri, requestOptions); } catch (DocumentClientException dce) { if (dce.StatusCode == HttpStatusCode.NotFound) { return(default(T)); } throw; } return(JsonConvert.DeserializeObject <T>(response.Resource.ToString())); }
/// <inheritdoc/> public async Task <T> GetAsync <T>(string id) where T : BaseEntity { Uri documentUri = UriFactory.CreateDocumentUri(_database, _collection, id); return(await _documentClient.ReadDocumentAsync <T>(documentUri, new RequestOptions { PartitionKey = new PartitionKey(_partitionKey) })); }
/// <inheritdoc/> public async Task <T> GetAsync <T>(string id) where T : BaseEntity { Uri documentUri = UriFactory.CreateDocumentUri(_database, _collection, id); return(await _documentClient.ReadDocumentAsync <T>(documentUri)); }
public async Task <ResourceResponse <Document> > UpdateState(DeviceState source, ILogger log) { log.LogInformation("Processing change message for device ID {DeviceId}", source.DeviceId); DeviceState target = null; try { var response = await client.ReadDocumentAsync(UriFactory.CreateDocumentUri(cosmosDBDatabase, cosmosDBCollection, source.DeviceId), new RequestOptions { PartitionKey = new PartitionKey(source.DeviceId) }); target = (DeviceState)(dynamic)response.Resource; // Merge properties target.Battery = source.Battery ?? target.Battery; target.FlightMode = source.FlightMode ?? target.FlightMode; target.Latitude = source.Latitude ?? target.Latitude; target.Longitude = source.Longitude ?? target.Longitude; target.Altitude = source.Altitude ?? target.Altitude; target.AccelerometerOK = source.AccelerometerOK ?? target.AccelerometerOK; target.GyrometerOK = source.GyrometerOK ?? target.GyrometerOK; target.MagnetometerOK = source.MagnetometerOK ?? target.MagnetometerOK; } catch (DocumentClientException ex) { if (ex.StatusCode == System.Net.HttpStatusCode.NotFound) { target = source; } } var collectionLink = UriFactory.CreateDocumentCollectionUri(cosmosDBDatabase, cosmosDBCollection); return(await client.UpsertDocumentAsync(collectionLink, target)); }
public async Task <TModel> FetchItemAsync(string id) { var documentUri = UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id); var document = await documentClient.ReadDocumentAsync(documentUri); return(document as TModel); }
public async Task <ResourceResponse <Document> > LoadNoReplace( IAmDocument doc) { ResourceResponse <Document> r; try { r = await client.ReadDocumentAsync( UriFactory.CreateDocumentUri( databaseId, collectionId, doc.Id), new RequestOptions { PartitionKey = new PartitionKey(doc.PartitionKey) }); } catch (DocumentClientException de) { if (de.StatusCode == HttpStatusCode.NotFound) { r = await client.CreateDocumentAsync( UriFactory.CreateDocumentCollectionUri( databaseId, collectionId), doc); } else { throw; } } return(r); }
public async Task <TResult> QueryById <TResult>(string id, Domain.RequestOptions options = null) where TResult : class { if (_databaseName == null) { throw new DataStoreException("Connect must be called to query CosmosDB"); } try { var response = await _client.ReadDocumentAsync(UriFactory.CreateDocumentUri(_databaseName, _collectionName, id), options.ToRequestOptions(), _cancellationToken); if (response.StatusCode != HttpStatusCode.OK) { return(null); } return((TResult)(dynamic)response.Resource); } catch (DocumentClientException e) { if (e.StatusCode == HttpStatusCode.NotFound) { return(null); } throw; } }
async Task<BotData> IBotDataStore<BotData>.LoadAsync(IAddress key, BotStoreType botStoreType, CancellationToken cancellationToken) { try { var entityKey = DocDbBotDataEntity.GetEntityKey(key, botStoreType); var response = await documentClient.ReadDocumentAsync(UriFactory.CreateDocumentUri(databaseId, collectionId, entityKey)); // The Resource property of the response, of type IDynamicMetaObjectProvider, has a dynamic nature, // similar to DynamicTableEntity in Azure storage. When casting to a static type, properties that exist in the static type will be // populated from the dynamic type. DocDbBotDataEntity entity = (dynamic)response.Resource; return new BotData(response?.Resource.ETag, entity?.Data); } catch (DocumentClientException e) { if (e.StatusCode.HasValue && e.StatusCode.Value == HttpStatusCode.NotFound) { return new BotData(string.Empty, null); } throw new HttpException(e.StatusCode.HasValue ? (int)e.StatusCode.Value : 0, e.Message, e); } }
public async Task <LocationRecord> Get(Guid memberId, Guid recordId) { var result = await _documentClient.ReadDocumentAsync(GetLocationsDocumentUri(recordId), new RequestOptions { PartitionKey = new PartitionKey(memberId.ToString()) }); return((LocationRecord)(dynamic)result.Resource); }
public async Task <IActionResult> Get(string id) { var link = UriFactory.CreateDocumentUri("social", "results", id); try { var doc = await _documentClient.ReadDocumentAsync(link); var result = new Result() { id = id, score = doc.Resource.GetPropertyValue <double>("score") }; return(Ok(result)); } catch (DocumentClientException ex) { if (ex.StatusCode == System.Net.HttpStatusCode.NotFound) { // Text Analytics result is not ready yet return(Ok(null)); } throw ex; } }
public static async Task <ResourceResponse <Document> > HandleEntityRetrieveAsync(string tableName, string partitionKey, string rowKey, IDocumentClient client, RequestOptions requestOptions, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); Uri uri = UriFactory.CreateDocumentUri("TablesDB", tableName, rowKey); requestOptions = SetPartitionKey(requestOptions, partitionKey); return(await client.ReadDocumentAsync(uri.ToString(), requestOptions, cancellationToken)); }
public async Task <Recipe> GetAsync(Guid id) { var response = await client.ReadDocumentAsync(UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id.ToString())); Recipe recipe = (dynamic)response.Resource; return(recipe); }
public async Task <TModel> FetchItemAsync(TKey partitionKey, string id) { var documentUri = UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id); var resourceResponse = await documentClient.ReadDocumentAsync(documentUri, BuildRequestOptions(partitionKey)); logger.LogDebug($"Read cost (in RU/s) : {resourceResponse.RequestCharge}"); return((TModel)((dynamic)resourceResponse.Resource)); }
public async Task <T> Get <T>(string id) where T : class, IDocument { try { var response = await _client.ReadDocumentAsync(UriFactory.CreateDocumentUri(_databaseId, _documentCollection.Id, GenerateDocumentId <T>(id))); var adapter = JsonConvert.DeserializeObject <DocumentAdapter <T> >(response.Resource.ToString()); return(adapter?.Document); } catch (DocumentClientException exception) { if (exception.StatusCode == HttpStatusCode.NotFound) { return(null); } throw; } }
public async Task <DataResult <T> > Get(string id) { var documentUri = UriFactory.CreateDocumentUri(_dataAccessOptions.DatabaseName, _dataAccessOptions.CollectionName, id); var response = await _documentClient.ReadDocumentAsync <T>(documentUri); var isSuccessful = true; return(new DataResult <T>(isSuccessful, response.Document)); }
public async Task <IResourceResponse <Document> > ReadAsync( IDocumentClient client, StorageConfig cfg, string docId) { var collectionLink = $"/dbs/{cfg.DocumentDbDatabase}/colls/{cfg.DocumentDbCollection}"; return(await client.ReadDocumentAsync($"{collectionLink}/docs/{docId}")); }
public async Task <Todo> GetTodoAsync(string userId, string id) { var doc = await documentClient.ReadDocumentAsync <Todo>(UriFactory.CreateDocumentUri(dbName, collectionName, id) , new RequestOptions() { PartitionKey = new PartitionKey(userId) }); return(doc.Document); }
public async Task UpdateAvailableInventoryAsync(IDocumentClient documentClient, OrderLineItem lineItem) { var documentUri = UriFactory.CreateDocumentUri(_databaseName, _containerName, lineItem.ProductId); var productResponse = await documentClient.ReadDocumentAsync <Product>(documentUri, new RequestOptions { PartitionKey = new PartitionKey(lineItem.Category) }); productResponse.Document.AvailableInventory -= lineItem.Quantity; await documentClient.UpsertDocumentAsync(_containerUri, productResponse.Document); }
public async Task <TEntity> Get(string id) { try { return((await _documentClient.ReadDocumentAsync <TEntity>(CreateDocumentUri(id), RequestOptions)).Document); } catch (DocumentClientException e) when(e.StatusCode == HttpStatusCode.NotFound) { return(null); } }
public async Task <T> Read(string id) { try { var response = await _documentClient.ReadDocumentAsync(GetUri(id)); EntityDocument <T> responseDocument = (dynamic)response.Resource; return(responseDocument.Entity); } catch (DocumentClientException dce) when(dce.StatusCode == HttpStatusCode.NotFound) { return(default !);
public async Task <Stop> GetStop(string stopId) { var stop = await _client.ReadDocumentAsync <Stop>( UriFactory.CreateDocumentUri(_settings.CosmosDatabaseName, _settings.CosmosCollectionName, stopId), new RequestOptions { PartitionKey = new PartitionKey("TFStop") } ); return(stop.Document); }
public virtual async Task <TDocument> GetById(Guid id, RequestOptions requestOptions = null, CancellationToken cancellationToken = default) { try { var response = await DocumentClient.ReadDocumentAsync <TDocument>(UriFactory.CreateDocumentUri(DatabaseName, CollectionName, id.ToString()), requestOptions, cancellationToken).ConfigureAwait(false); return(response.Document); } catch (DocumentClientException ex) { if (ex.StatusCode == HttpStatusCode.NotFound) { return(default);
public async Task <IActionResult> GetProduct(string id) { try { var documentResponse = await _cosmosClient.ReadDocumentAsync <Product>(UriFactory.CreateDocumentUri(Constants.CosmosDBName, CosmosCollectionName, id)); return(Ok(documentResponse.Document)); } catch (Exception ex) { Console.WriteLine($"Error getting document with id <{id}>: {ex.ToString()}"); return(StatusCode(501)); } }
public virtual async Task <T> GetAsync(string id) { try { Document document = await _client.ReadDocumentAsync(_settings.CreateDocumentUri(id)); return((T)(dynamic)document); } catch (DocumentClientException e) when(e.StatusCode == HttpStatusCode.NotFound) { return(null); } }
public async Task PerformTest(IDocumentClient documentClient, CosmosDataStoreConfiguration configuration, CosmosCollectionConfiguration cosmosCollectionConfiguration) { var requestOptions = new RequestOptions { ConsistencyLevel = ConsistencyLevel.Session, PartitionKey = _partitionKey }; ResourceResponse <Document> resourceResponse = await documentClient.UpsertDocumentAsync( configuration.GetRelativeCollectionUri(cosmosCollectionConfiguration.CollectionId), _document, requestOptions); requestOptions.SessionToken = resourceResponse.SessionToken; await documentClient.ReadDocumentAsync(resourceResponse.Resource.SelfLink, requestOptions); }
public async Task <Account> GetAccount(string email) { try { var entity = await _documentClient.ReadDocumentAsync <DocumentDbAccountEntity>( CreateDocumentUri(email), new RequestOptions { PartitionKey = new PartitionKey("FYP") }); return(ToAccount(entity)); } catch (DocumentClientException e) { throw new StorageErrorException($"Failed to fetch account with email {email}", (int)e.StatusCode); } }