public async Task CreateDocumentCollectionIfNotExistsAsync <T>() { var packageCollection = new DocumentCollection(); packageCollection.Id = typeof(T).Name; // I don't use PartitionKey until it required. await _client.CreateDocumentCollectionIfNotExistsAsync( UriFactory.CreateDatabaseUri(_databaseId), packageCollection); }
/// <summary> /// Insert entity to database even though collection for this entity wasn't created yet. /// </summary> /// <typeparam name="T">Type of entity to insert</typeparam> /// <param name="entity">Entity to insert</param> public async Task <bool> InsertAsync <T>(T entity, string collectionName) where T : IBaseEntity { await GetDBClient(); await _documentClient.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(cosmosDBName), new DocumentCollection { Id = typeof(T).Name }); var result = await _documentClient.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(cosmosDBName, collectionName), entity); return(result.StatusCode == System.Net.HttpStatusCode.Created); }
public async Task EnsureCollectionExists() { await DocumentClient.CreateDocumentCollectionIfNotExistsAsync(DatabaseUri, new DocumentCollection { Id = _collectionName }); }
/// <summary> /// Constructor /// </summary> protected DocumentRepository( string collectionName, IOptions <AzureCosmosDbSettings> options, IDocumentClient documentClient) { _collection = collectionName; _partitionKey = options.Value.PartitionKey; _database = options.Value.Database; _documentClient = documentClient; _collectionUri = UriFactory.CreateDocumentCollectionUri(_database, _collection); DocumentCollection documentCollection = new DocumentCollection { Id = collectionName, PartitionKey = new PartitionKeyDefinition { Paths = new Collection <string> { _partitionKey } } }; Uri dbUri = UriFactory.CreateDatabaseUri(_database); documentClient .CreateDocumentCollectionIfNotExistsAsync(dbUri, documentCollection) .GetAwaiter() .GetResult(); }
private static async Task CreateCollectionIfNotExistsAsync(IDocumentClient documentClient, string collectionId, IOptions <CosmosDbOptions> settings) { try { await documentClient.ReadDocumentCollectionAsync(UriFactory.CreateDocumentCollectionUri(settings.Value.DatabaseId, collectionId)); } catch (DocumentClientException e) { if (e.StatusCode == System.Net.HttpStatusCode.NotFound) { await documentClient.CreateDocumentCollectionIfNotExistsAsync( UriFactory.CreateDatabaseUri(settings.Value.DatabaseId), new DocumentCollection { Id = collectionId, PartitionKey = new PartitionKeyDefinition { Paths = new Collection <string> { "/type" } } }, new RequestOptions { OfferThroughput = settings.Value.OfferThroughput, ConsistencyLevel = settings.Value.ConsistencyLevel }); } else { throw; } } }
public async Task GivenDocumentCollectionAlreadyExists_WhenCreatingDocumentCollectionIfNotExists_ThenIndexingPolicyShouldBeUpdated() { Uri collectionUri = new Uri("http://database/collection"); IndexingPolicy expectedIndexingPolicy = new IndexingPolicy(); DocumentCollection documentCollection = new DocumentCollection() { IndexingPolicy = expectedIndexingPolicy, }; DocumentCollection existingDocumentCollection = new DocumentCollection(); _documentClient.ReadDocumentCollectionAsync(collectionUri, Arg.Any <RequestOptions>()).Returns( new ResourceResponse <DocumentCollection>(existingDocumentCollection)); // Check to make sure the index policy is requested to be updated. _documentClient.ReplaceDocumentCollectionAsync( Arg.Is <DocumentCollection>(x => x == existingDocumentCollection && x.IndexingPolicy == expectedIndexingPolicy), Arg.Any <RequestOptions>()) .Returns(new ResourceResponse <DocumentCollection>(existingDocumentCollection)); DocumentCollection result = await _documentClient.CreateDocumentCollectionIfNotExistsAsync(new Uri("http://database"), collectionUri, documentCollection); Assert.NotNull(result); }
private static async Task <bool> CheckList(IDocumentClient client, string link) { var CreateDatabase = Environment.GetEnvironmentVariable("CreateDatabase"); if (CreateDatabase != null && CreateDatabase == "true") { var databaseDefinition = new Database { Id = DatabaseId }; await client.CreateDatabaseIfNotExistsAsync(databaseDefinition); var collectionDefinition = new DocumentCollection { Id = CollectionId }; await client.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(DatabaseId), collectionDefinition); } var response = client.CreateDocumentQuery <Item>(UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId), $"select * from c WHERE c.Url='{link}'").ToList(); if (response.Count > 0) { return(true); } await client.CreateDocumentAsync( UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId), new Item() { Url = link }); return(false); }
private async Task BuildCollection() { await _documentClient.CreateDatabaseIfNotExistsAsync(new Database { Id = databaseId }); await _documentClient.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(databaseId), new DocumentCollection { Id = collectionId }); }
public async Task <DocumentCollection> InitializeCollection(IDocumentClient documentClient) { DocumentCollection existingDocumentCollection = await documentClient.TryGetDocumentCollectionAsync(_relativeCollectionUri); if (existingDocumentCollection == null) { _logger.LogDebug("Creating document collection if not exits: {collectionId}", _collectionId); var documentCollection = new DocumentCollection { Id = _collectionId, PartitionKey = new PartitionKeyDefinition { Paths = { $"/{KnownDocumentProperties.PartitionKey}", }, }, }; var requestOptions = new RequestOptions { OfferThroughput = _initialCollectionThroughput }; existingDocumentCollection = await documentClient.CreateDocumentCollectionIfNotExistsAsync( _relativeDatabaseUri, _relativeCollectionUri, documentCollection, requestOptions); } await _upgradeManager.SetupCollectionAsync(documentClient, existingDocumentCollection); return(existingDocumentCollection); }
private static async Task <DocumentCollection> CreateDocumentCollectionIfNotExistsAsync(IDocumentClient documentClient, string databaseName, string collectionName, string partitionKey, int throughput) { Uri databaseUri = UriFactory.CreateDatabaseUri(databaseName); DocumentCollection documentCollection = new DocumentCollection { Id = collectionName }; if (!string.IsNullOrEmpty(partitionKey)) { documentCollection.PartitionKey.Paths.Add(partitionKey); } RequestOptions collectionOptions = null; if (throughput != 0) { collectionOptions = new RequestOptions { OfferThroughput = throughput }; } return(await documentClient.CreateDocumentCollectionIfNotExistsAsync(databaseUri, documentCollection, collectionOptions)); }
async Task CreateContainerAsync() { DocumentCollection collection = new DocumentCollection() { Id = config["DataStore:Containers:Identities:Id"] }; Uri dbUri = UriFactory.CreateDatabaseUri(config["DataStore:Id"]); await dbClient.CreateDocumentCollectionIfNotExistsAsync(dbUri, collection); }
private async Task <DocumentCollection> EnsureCollectionIsCreated(IDocumentClient documentClient) { await documentClient.CreateDatabaseIfNotExistsAsync(new Database { Id = DatabaseId }); ResourceResponse <DocumentCollection> collectionResponse = await documentClient .CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(DatabaseId), new DocumentCollection { Id = CollectionId }); return(collectionResponse.Resource); }
private Task EnsureDocumentCollectionAsync() { var databaseUri = _configs.DatabaseUri; var documentCollection = new DocumentCollection { Id = _configs.DocumentCollectionId }; return(_client.CreateDocumentCollectionIfNotExistsAsync(databaseUri, documentCollection)); }
private async Task CreateCollection(string database, string collection, RequestOptions requestOptions = null) { var databaseUri = UriFactory.CreateDatabaseUri(database); var documentCollection = new DocumentCollection { Id = collection }; documentCollection.PartitionKey.Paths.Add("/Language"); await _documentClient.CreateDocumentCollectionIfNotExistsAsync(databaseUri, documentCollection, requestOptions); }
public static async Task CreateCosmosDbAndCollectionIfNotExists(this IDocumentClient documentClient, ILogger logger, string databaseId, string collectionId) { logger.Info($"Creating Cosmos Db Collection if not exists for database {databaseId} with id {collectionId}"); var collection = new DocumentCollection { Id = collectionId }; var requestOptions = new RequestOptions { OfferThroughput = 400 }; await documentClient.CreateDocumentCollectionIfNotExistsAsync($"dbs/{databaseId}", collection, requestOptions); logger.Info($"Created Cosmos Db Collection for database {databaseId} with id {collectionId}"); }
/// <summary> /// Ensures that the necessary database and collection exist with the proper indexing policy and stored procedures /// </summary> /// <param name="documentClient">The <see cref="DocumentClient"/> instance to use for initialization.</param> /// <param name="cosmosDataStoreConfiguration">The data store configuration.</param> /// <returns>A task</returns> public async Task InitializeDataStore(IDocumentClient documentClient, CosmosDataStoreConfiguration cosmosDataStoreConfiguration) { EnsureArg.IsNotNull(documentClient, nameof(documentClient)); EnsureArg.IsNotNull(cosmosDataStoreConfiguration, nameof(cosmosDataStoreConfiguration)); try { _logger.LogInformation("Initializing Cosmos DB collection {CollectionUri}", cosmosDataStoreConfiguration.AbsoluteCollectionUri); if (cosmosDataStoreConfiguration.AllowDatabaseCreation) { _logger.LogDebug("CreateDatabaseIfNotExists {DatabaseId})", cosmosDataStoreConfiguration.DatabaseId); await documentClient.CreateDatabaseIfNotExistsAsync(new Database { Id = cosmosDataStoreConfiguration.DatabaseId, }); } _logger.LogDebug("CreateDocumentCollectionIfNotExists {HostDescription}", cosmosDataStoreConfiguration.AbsoluteCollectionUri); DocumentCollection existingDocumentCollection = await documentClient.TryGetDocumentCollectionAsync(cosmosDataStoreConfiguration.RelativeCollectionUri); if (existingDocumentCollection == null) { var documentCollection = new DocumentCollection { Id = cosmosDataStoreConfiguration.CollectionId, PartitionKey = new PartitionKeyDefinition { Paths = { $"/{KnownResourceWrapperProperties.PartitionKey}", }, }, }; existingDocumentCollection = await documentClient.CreateDocumentCollectionIfNotExistsAsync( cosmosDataStoreConfiguration.RelativeDatabaseUri, cosmosDataStoreConfiguration.RelativeCollectionUri, documentCollection); } await _upgradeManager.SetupCollectionAsync(documentClient, existingDocumentCollection); _logger.LogInformation("Cosmos DB collection {CollectionUri} successfully initialized", cosmosDataStoreConfiguration.AbsoluteCollectionUri); } catch (Exception ex) { _logger.LogCritical(ex, "Cosmos DB collection {CollectionUri} initialization failed", cosmosDataStoreConfiguration.AbsoluteCollectionUri); throw; } }
/// <summary> /// Creates the DocumentCollection if it does not exit otherwise returns the existing one. /// </summary> /// <param name="dbId">Database id.</param> /// <param name="documentCollection">Document collection.</param> /// <param name="requestOptions">Request options.</param> /// <returns>Created document collection.</returns> public async Task <ResourceResponse <DocumentCollection> > GetOrCreateCollectionAsync( string dbId, DocumentCollection documentCollection, RequestOptions requestOptions = null) { Code.ExpectsNotNullOrWhiteSpaceArgument(dbId, nameof(dbId), TaggingUtilities.ReserveTag(0x2381b1d1 /* tag_961hr */)); Code.ExpectsArgument(documentCollection, nameof(documentCollection), TaggingUtilities.ReserveTag(0x2381b1d2 /* tag_961hs */)); IDocumentClient client = await GetDocumentClientAsync().ConfigureAwait(false); return(await DocumentDbAdapter.ExecuteAndLogAsync(TaggingUtilities.ReserveTag(0x2381b1d3 /* tag_961ht */), () => client.CreateDocumentCollectionIfNotExistsAsync( UriFactory.CreateDatabaseUri(dbId), documentCollection, requestOptions)).ConfigureAwait(false)); }
public async Task <DocumentCollection> CreateDocumentCollectionIfNotExistsAsync( IDocumentClient client, string collectionId) { Throw.IfNull(client, nameof(client)); Throw.IfNullOrWhiteSpace(collectionId, nameof(collectionId)); var uri = UriFactory.CreateDatabaseUri(_settings.DatabaseId); var coll = new DocumentCollection { Id = collectionId }; return(await client.CreateDocumentCollectionIfNotExistsAsync(uri, coll)); }
private async Task CreateWorkerLeasesCollection() { var collectionDefinition = new DocumentCollection { Id = _options.Value.LeasesCollection }; collectionDefinition.PartitionKey.Paths.Add("/leaseType"); var leaseConstraint = new UniqueKey { Paths = new Collection <string> { "/leaseType" } }; collectionDefinition.UniqueKeyPolicy.UniqueKeys.Add(leaseConstraint); await _documentClient.CreateDocumentCollectionIfNotExistsAsync( UriFactory.CreateDatabaseUri(_options.Value.Database), collectionDefinition, new RequestOptions { OfferThroughput = _options.Value.OfferThroughput }).ConfigureAwait(false); }
public static void CreateCollection(IDocumentClient client, string databaseId, string collectionId, string partitionKeyName = "") { var result = client.CreateDatabaseIfNotExistsAsync(new Database { Id = databaseId }).GetAwaiter().GetResult(); if (result.StatusCode == System.Net.HttpStatusCode.Accepted || result.StatusCode == System.Net.HttpStatusCode.OK || result.StatusCode == System.Net.HttpStatusCode.Created) { var collection = new DocumentCollection { Id = collectionId }; if (!string.IsNullOrEmpty(partitionKeyName)) { if (!partitionKeyName.StartsWith("/")) { partitionKeyName = "/" + partitionKeyName; } collection.PartitionKey = new PartitionKeyDefinition { Paths = new Collection <string> { partitionKeyName } }; } var collectionCreationResult = client.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(databaseId), collection, new RequestOptions { OfferThroughput = DEFAULT_RUS }).GetAwaiter().GetResult(); if (collectionCreationResult.StatusCode == System.Net.HttpStatusCode.Accepted || collectionCreationResult.StatusCode == System.Net.HttpStatusCode.OK || collectionCreationResult.StatusCode == System.Net.HttpStatusCode.Created) { Task.Delay(500).GetAwaiter().GetResult(); } else { throw new NotSupportedException($"Collection '{collection}' cannot be created. ({collectionCreationResult.StatusCode})"); } } else { throw new NotSupportedException($"Database '{databaseId}' cannot be created. Wrong Url or Key? ({result.StatusCode})"); } }
private static async Task CreateCollectionIfNotExistsAsync(string DatabaseId, string CollectionId, string partitionkey = null) { await _client.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(DatabaseId), new DocumentCollection { Id = CollectionId, PartitionKey = new PartitionKeyDefinition { Paths = new Collection <string> { "/" + partitionkey } } }); }
public CosmosDbTodoRepository(Uri accountEndpoint, string accountKey) { documentClient = new DocumentClient(accountEndpoint, accountKey); documentClient.CreateDatabaseIfNotExistsAsync(new Database { Id = dbName }).Wait(); var todoList = new DocumentCollection() { Id = collectionName }; todoList.PartitionKey.Paths.Add(todoListPartitionKey); documentClient.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(dbName), todoList).Wait(); }
public async Task Run(ILogger logger) { var database = new Database { Id = DocumentSettings.DatabaseName }; var documentCollection = new DocumentCollection { Id = DocumentSettings.AccountProviderLegalEntitiesCollectionName, PartitionKey = new PartitionKeyDefinition { Paths = new Collection <string> { "/ukprn" } }, UniqueKeyPolicy = new UniqueKeyPolicy { UniqueKeys = new Collection <UniqueKey> { new UniqueKey { Paths = new Collection <string> { "/accountProviderLegalEntityId" } }, new UniqueKey { Paths = new Collection <string> { "/accountLegalEntityId" } } } } }; var requestOptions = new RequestOptions { OfferThroughput = 1000 }; //todo: logging from eas await _documentClient.CreateDatabaseIfNotExistsAsync(database); await _documentClient.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(database.Id), documentCollection, requestOptions); }
public async Task Run() { var database = new Database { Id = DocumentSettings.DatabaseName }; var documentCollection = new DocumentCollection { Id = DocumentSettings.AccountUsersCollectionName, PartitionKey = new PartitionKeyDefinition { Paths = new Collection <string> { "/accountId" } }, UniqueKeyPolicy = new UniqueKeyPolicy { UniqueKeys = new Collection <UniqueKey> { new UniqueKey { Paths = new Collection <string> { "/userRef" } } } } }; _logger.LogInformation("Creating ReadStore database and collection if they don't exist"); var createDatabaseResponse = await _documentClient.CreateDatabaseIfNotExistsAsync(database); _logger.LogInformation($"Database {(createDatabaseResponse.StatusCode == HttpStatusCode.Created ? "created" : "already existed")}"); var requestOptions = new RequestOptions { OfferThroughput = 1000 }; var createDocumentCollectionResponse = await _documentClient.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(database.Id), documentCollection, requestOptions); _logger.LogInformation($"Document collection {(createDocumentCollectionResponse.StatusCode == HttpStatusCode.Created ? "created" : "already existed")}"); }
public ProductsController(IDocumentClient client) { _cosmosClient = client; try { _cosmosClient.CreateDatabaseIfNotExistsAsync(new Database { Id = Constants.CosmosDBName }).Wait(); _cosmosClient.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(Constants.CosmosDBName), new DocumentCollection { Id = CosmosCollectionName }).Wait(); _collectionUri = UriFactory.CreateDocumentCollectionUri(Constants.CosmosDBName, CosmosCollectionName); } catch (Exception ex) { Console.WriteLine($"Error building ProductsController: {ex.ToString()}"); throw; } }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public async void Configure(IApplicationBuilder app, IHostingEnvironment env, IDocumentClient client) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { app.UseHsts(); } app.UseHttpsRedirection(); app.UseMvc(); // Init documentdb database Database shopifychallenge = await client.CreateDatabaseIfNotExistsAsync(new Database { Id = Configuration["DbConfig:DataBaseName"] }); await client.CreateDocumentCollectionIfNotExistsAsync(shopifychallenge.SelfLink, new DocumentCollection { Id = Configuration["DbConfig:CollectionName"] }); }
private async Task CreateLockClaimsCollection(IDocumentClient documentClient, CosmosDataStoreOptions cosmosDataStoreOptions) { var collectionDefinition = new DocumentCollection { Id = cosmosDataStoreOptions.DistributedLocksCollection, PartitionKey = new PartitionKeyDefinition { Paths = new Collection <string> { "/id" } } }; await documentClient.CreateDocumentCollectionIfNotExistsAsync( UriFactory.CreateDatabaseUri(cosmosDataStoreOptions.Database), collectionDefinition, new RequestOptions { OfferThroughput = cosmosDataStoreOptions.OfferThroughput }).ConfigureAwait(false); }
public async Task <HGV> method(string id) { try { var PrimaryKey = Constants.PrimaryKey; var url = Constants.Uri; _client = new DocumentClient(new Uri(url), PrimaryKey); //Inserting to cosmos var record = new HGV { HGVName = "TestHGV", Country = "United States", }; var ans = await _client.CreateDatabaseIfNotExistsAsync(new Database { Id = DatabaseId }); var collectionDefinition = new DocumentCollection { Id = CollectionId }; _client.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(DatabaseId), collectionDefinition).Wait(); var document = await _client.CreateDocumentAsync( UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId) , record); HGV hgvrecord = _client.CreateDocumentQuery <HGV>( UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId)) .Where(v => v.HGVName == "TestHGV") .AsEnumerable() .FirstOrDefault(); //Getting data from cosmos based on id HGV document1 = _client.ReadDocumentAsync <HGV>(UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id)).Result; return(document1); } catch (Exception e) { throw e; } }