private static async Task <CosmosDbService <GardenStory> > InitializeCosmosClientInstanceAsync(AppSettings appSettings)
{
CosmosClient client = new CosmosClient(appSettings.CosmosDbConnectionString);
CosmosDbService <GardenStory> cosmosDbService = new CosmosDbService <GardenStory>(client, appSettings.CosmosDbName, appSettings.CosmosDbContainerName);
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(appSettings.CosmosDbName);
await database.Database.CreateContainerIfNotExistsAsync(appSettings.CosmosDbContainerName, appSettings.CosmosDbPartitionKey);
return(cosmosDbService);
}
public CosmosDatabaseFixture()
{
this.Client = new CosmosClient(ConnectionString);
this.Service = CosmosDbService <TestItem>
.InitializeCosmosClientInstanceAsync(DatabaseName, ConnectionString)
.GetAwaiter()
.GetResult();
Assert.NotNull(Service);
}
// Initialize Cosmos Client
private static ICosmosDbService InitializeCosmos()
{
var config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build(); // Expect appsettings.json in output directory
var dbId = config["CosmosDB"];
var containerId = config["CosmosContainer"];
var endpoint = config["CosmosEndpoint"];
var masterKey = config["CosmosMasterKey"];
var client = new CosmosClient(endpoint, masterKey);
var cosmosDbService = new CosmosDbService(client, dbId, containerId);
return(cosmosDbService);
}
/// <summary>
/// Creates a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(CosmosConfig cosmosConfig)
{
var clientBuilder = new Microsoft.Azure.Cosmos.Fluent.CosmosClientBuilder(cosmosConfig.Account, cosmosConfig.Key);
var client = clientBuilder
.WithConnectionModeDirect()
.Build();
var cosmosDbService = new CosmosDbService(client, cosmosConfig.DatabaseName, cosmosConfig.ContainerName);
var database = await client.CreateDatabaseIfNotExistsAsync(cosmosConfig.DatabaseName);
await database.Database.CreateContainerIfNotExistsAsync(cosmosConfig.ContainerName, "/pk");
return(cosmosDbService);
}
/// <summary>
/// Creates a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(string connectionStrings, string databaseName, string containerName)
{
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(connectionStrings);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id");
return(cosmosDbService);
}
private static CosmosDbService InitializeCosmosClientInstance(CosmosConfig cosmosConfig)
{
Microsoft.Azure.Cosmos.Fluent.CosmosClientBuilder clientBuilder = new Microsoft.Azure.Cosmos.Fluent.CosmosClientBuilder(cosmosConfig.ConnectionString);
Microsoft.Azure.Cosmos.CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
CosmosDbService cosmosDbService = new CosmosDbService(client, cosmosConfig.DatabaseName, cosmosConfig.ContainerName);
//Microsoft.Azure.Cosmos.DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
//await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id");
return(cosmosDbService);
}
private async Task <CosmosDbService <T> > InitializeCosmosClientInstanceAsync <T>(string containerName, string partitionKey)
{
string databaseName = "AzureCosmosDbDocumentDb";
string account = Configuration["CosmosDbAccount"];
string key = Configuration["CosmosDbPrimaryKey"];
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder.WithConnectionModeDirect().Build();
CosmosDbService <T> cosmosDbService = new CosmosDbService <T>(client, databaseName, containerName);
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, partitionKey);
return(cosmosDbService);
}
/// <summary>
/// Retrieves a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static CosmosDbService InitializeCosmosClientInstance(IConfiguration configuration)
{
var databaseName = configuration["DatabaseName"];
var containerName = configuration["ContainerName"];
var connectionString = configuration["CosmosDBConnection"];
var cosmosDbConnectionString = new CosmosDbConnectionString(connectionString);
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(cosmosDbConnectionString.ServiceEndpoint.OriginalString, cosmosDbConnectionString.AuthKey);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
return(cosmosDbService);
}
/// <summary>
/// Creates a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(IConfigurationSection configurationSection)
{
string databaseName = configurationSection.GetSection("DatabaseName").Value;
string containerName = configurationSection.GetSection("ContainerName").Value;
string account = configurationSection.GetSection("Account").Value;
string key = configurationSection.GetSection("Key").Value;
CosmosClient client = new CosmosClient(account, key);
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/HostName");
return(cosmosDbService);
}
public static async Task <CosmosDbService <CitizenAccount> > InitializeCitizenAccountCosmosClientAsync(IConfigurationSection configurationSection, CosmosClient cosmosClient)
{
string databaseName = configurationSection.GetSection("DatabaseName").Value;
string containerName = configurationSection.GetSection("CitizenAccountContainerName").Value;
CosmosDbService <CitizenAccount> cosmosDbService = new CosmosDbService <CitizenAccount>(cosmosClient, databaseName, containerName);
DatabaseResponse database = await cosmosClient.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/publicAddress");
//InitializeCitizenAccountData(cosmosDbService);
return(cosmosDbService);
}
private async Task seedDatabase(IConfigurationSection configurationSection)
{
var cosmosDbService = await CosmosDbService.InitializeCosmosClientInstanceAsync(configurationSection);
// clear out database
var users = await cosmosDbService.GetItemsAsync <User>("SELECT * FROM c");
foreach (User u in users)
{
await cosmosDbService.DeleteItemAsync(u.id);
}
// populate database with fresh data
await cosmosDbService.AddItemAsync <User>(new User()
{
firstName = "Mark",
middleName = "Thomas",
lastName = "Jewell",
phoneNumber = "123-456-7890",
emailAddress = "*****@*****.**"
});
await cosmosDbService.AddItemAsync <User>(new User()
{
firstName = "Nelson",
middleName = "Jacob",
lastName = "Packer",
phoneNumber = "123-456-7890",
emailAddress = "*****@*****.**"
});
await cosmosDbService.AddItemAsync <User>(new User()
{
firstName = "Bob",
middleName = "George",
lastName = "Smith",
phoneNumber = "123-456-7890",
emailAddress = "*****@*****.**"
});
await cosmosDbService.AddItemAsync <User>(new User()
{
firstName = "Julie",
middleName = "Ann",
lastName = "Jeffries",
phoneNumber = "123-456-7890",
emailAddress = "*****@*****.**"
});
}
private static CosmosDbService InitializeCosmosClientInstance()
{
string username = Environment.GetEnvironmentVariable("RESOURCECONNECTOR_TESTCASSANDRASECRETCONNECTIONSUCCEEDED_USERNAME");
string password = Environment.GetEnvironmentVariable("RESOURCECONNECTOR_TESTCASSANDRASECRETCONNECTIONSUCCEEDED_PASSWORD");
string contactPoints = Environment.GetEnvironmentVariable("RESOURCECONNECTOR_TESTCASSANDRASECRETCONNECTIONSUCCEEDED_CONTACTPOINT");
int port = int.Parse(Environment.GetEnvironmentVariable("RESOURCECONNECTOR_TESTCASSANDRASECRETCONNECTIONSUCCEEDED_PORT"));
CosmosDbService cosmosDbService = new CosmosDbService(
username,
password,
contactPoints,
port);
return(cosmosDbService);
}
private static CosmosDbService InitializeCosmosClientInstance()
{
string hostname = Environment.GetEnvironmentVariable("RESOURCECONNECTOR_TESTGREMLINSECRETCONNECTIONSUCCEEDED_HOSTNAME");
int port = int.Parse(Environment.GetEnvironmentVariable("RESOURCECONNECTOR_TESTGREMLINSECRETCONNECTIONSUCCEEDED_PORT"));
string username = Environment.GetEnvironmentVariable("RESOURCECONNECTOR_TESTGREMLINSECRETCONNECTIONSUCCEEDED_USERNAME");
string password = Environment.GetEnvironmentVariable("RESOURCECONNECTOR_TESTGREMLINSECRETCONNECTIONSUCCEEDED_PASSWORD");
CosmosDbService cosmosDbService = new CosmosDbService(
hostname,
port,
username,
password);
return(cosmosDbService);
}
/// <summary>
/// Creates a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(IConfigurationSection configurationSection)
{
string databaseName = Environment.GetEnvironmentVariable("DATABASE_NAME"); // configurationSection.GetSection("DatabaseName").Value;
string containerName = Environment.GetEnvironmentVariable("CONTAINER_NAME"); // configurationSection.GetSection("ContainerName").Value;
string account = Environment.GetEnvironmentVariable("ACCOUNT"); // configurationSection.GetSection("Account").Value;
string key = Environment.GetEnvironmentVariable("COSMOS_DB_KEY"); // configurationSection.GetSection("Key").Value;
Microsoft.Azure.Cosmos.CosmosClient client = new Microsoft.Azure.Cosmos.CosmosClient(account, key);
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
Microsoft.Azure.Cosmos.DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id");
return(cosmosDbService);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers().AddFluentValidation(fv => fv.RegisterValidatorsFromAssemblyContaining <UserValidator>());
services.AddTransient <IValidator <User>, UserValidator>();
services.AddProblemDetails();
var mapper = services.AddAutoMapper(typeof(Startup).Assembly);
IDbService dbService = CosmosDbService.InitializeCosmosClientInstanceAsync(Configuration.GetSection("CosmosDb")).GetAwaiter().GetResult();
services.AddSingleton <IDbService>(dbService);
services.AddSingleton <IUserRepository>(new UserRepository(dbService));
}
private static async Task <CosmosDbService> SetupCosmosDbAsync(IConfigurationSection configurationSection)
{
string databaseName = configurationSection.GetSection("DatabaseName").Value;
string containerName = configurationSection.GetSection("ContainerName").Value;
string account = configurationSection.GetSection("Account").Value;
string key = configurationSection.GetSection("Key").Value;
Microsoft.Azure.Cosmos.CosmosClient client = new Microsoft.Azure.Cosmos.CosmosClient(account, key);
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
Microsoft.Azure.Cosmos.DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id");
return(cosmosDbService);
}
private static async Task <ICosmosDbService <T> > InitializeCosmosClientInstanceAsync <T>(
IConfigurationSection configurationSection)
{
var databaseName = configurationSection.GetSection("DatabaseName").Value;
var containerName = configurationSection.GetSection("ContainerName").Value;
var account = configurationSection.GetSection("Account").Value;
var key = configurationSection.GetSection("Key").Value;
var client = new CosmosClient(account, key);
var cosmosDbService = new CosmosDbService <T>(client, databaseName, containerName);
var database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id");
return(cosmosDbService);
}
/// <summary>
/// Creates a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(IConfigurationSection configurationSection)
{
var databaseName = configurationSection["DatabaseName"];
var containerName = configurationSection["ContainerName"];
var account = configurationSection["Account"];
var key = configurationSection["Key"];
var client = new Microsoft.Azure.Cosmos.CosmosClient(account, key);
var database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id");
var cosmosDbService = new CosmosDbService(client, databaseName, containerName);
return(cosmosDbService);
}
/// <summary>
/// Creates a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static async Task <CosmosDbService <SensorS1Data> > InitializeCosmosClientInstanceSensorDataAsync(IConfigurationSection configurationSection)
{
string databaseName = configurationSection.GetSection("DatabaseName").Value;
string containerName = configurationSection.GetSection("SensorsContainerName").Value;
string account = configurationSection.GetSection("Account").Value;
string key = configurationSection.GetSection("Key").Value;
Microsoft.Azure.Cosmos.CosmosClient client = new Microsoft.Azure.Cosmos.CosmosClient(account, key);
CosmosDbService <SensorS1Data> cosmosDbService = new CosmosDbService <SensorS1Data>(client, databaseName, containerName);
Microsoft.Azure.Cosmos.DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/_partitionKey");
return(cosmosDbService);
}
/// <summary>
/// Creates a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(string url, string key)
{
string databaseName = Environment.GetEnvironmentVariable("CosmosDbName");
string containerName = Environment.GetEnvironmentVariable("CosmosDbContainerName");
Microsoft.Azure.Cosmos.CosmosClient client = new Microsoft.Azure.Cosmos.CosmosClient(url, key);
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
Microsoft.Azure.Cosmos.DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id");
await database.Database.CreateContainerIfNotExistsAsync("Identity", "/id");
return(cosmosDbService);
}
/// <summary>
/// Creates a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync()
{
string databaseName = Environment.GetEnvironmentVariable("CosmosDatabase");
string containerName = Environment.GetEnvironmentVariable("CosmosContainer");
string account = Environment.GetEnvironmentVariable("CosmosEndpoint");
string key = Environment.GetEnvironmentVariable("CosmosAuthKey");
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, Environment.GetEnvironmentVariable("CosmosPartitionKey"));
return(cosmosDbService);
}
private async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(IConfigurationSection configurationSection)
{
string databaseName = configurationSection.GetSection("DbName").Value;
string containerName = configurationSection.GetSection("Container").Value;
string account = configurationSection.GetSection("Account").Value;
string key = configurationSection.GetSection("Key").Value;
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id");
return(cosmosDbService);
}
private static CosmosDbService InitializeCosmosClientInstance()
{
string connectionString = Environment.GetEnvironmentVariable("RESOURCECONNECTOR_TESTTABLESECRETCONNECTIONSUCCEEDED_CONNECTIONSTRING");
CosmosDbService cosmosDbService = new CosmosDbService(connectionString);
//MyItem item = new MyItem()
//{
// PartitionKey = "somePk",
// RowKey = Guid.NewGuid().ToString(),
// ItemId = "123",
// Name = "vbbbb"
//};
//cosmosDbService.AddItemAsync(item).Wait();
return(cosmosDbService);
}
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync()
{
string databaseName = "DatingAppDB";
string containerName = "UserDb";
string cosmosEndpoint = "https://localhost:8081";
string key = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==";
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(cosmosEndpoint, key);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/Username");
return(cosmosDbService);
}
// Singleton injection
private static ICosmosDbService InitializeCosmosClientInstanceAsync()
{
string dbId = Environment.GetEnvironmentVariable("COSMOS_DB_NAME", EnvironmentVariableTarget.Process);
string containerId = Environment.GetEnvironmentVariable("COSMOS_CONTAINER_NAME", EnvironmentVariableTarget.Process);
string account = Environment.GetEnvironmentVariable("COSMOS_ACCOUNT", EnvironmentVariableTarget.Process);
string key = Environment.GetEnvironmentVariable("COSMOS_PRIMARY_KEY", EnvironmentVariableTarget.Process);
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
ICosmosDbService cosmosDbService = new CosmosDbService(client, dbId, containerId);
//DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
//await database.Database.CreateContainerIfNotExistsAsync(containerName, "/app");
return(cosmosDbService);
}
private async Task CreateCustomers(CosmosDbService cosmosDbService, int max)
{
var customers = new List <Customer>();
for (int i = 0; i < max; i++)
{
var customer = new Customer
{
FirstName = "fn_" + i,
LastName = "ln_" + i,
Age = i,
};
customers.Add(customer);
}
await cosmosDbService.Create(customers);
}
/// <summary>
/// Creates a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static async Task <ICosmosDbService> InitializeCosmosClientInstanceAsync()
{
Microsoft.Azure.Cosmos.CosmosClient client = new Microsoft.Azure.Cosmos.CosmosClient(account, key);
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
AuditStatus a = new AuditStatus {
id = "0C805497-2BA1-4524-9D41-E5D556488F9D", BatchId = "C8F9F1C1-4BD1-447F-9F0E-D8E96DF8A1E7", Status = "start", TimeStamp = DateTime.Now
};
Microsoft.Azure.Cosmos.DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id");
await cosmosDbService.AddAuditStatusAsync(a);
return(cosmosDbService);
}
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(IConfigurationSection section)
{
string databaseName = section.GetSection("DatabaseName").Value;
string containerName = section.GetSection("ContainerName").Value;
string account = section.GetSection("Account").Value;
string key = section.GetSection("Key").Value;
string partionId = section.GetSection("PartionId").Value;
CosmosClient client = new CosmosClient(account, key, new CosmosClientOptions()
{
ApplicationName = "Autino"
});
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, partionId);
return(cosmosDbService);
}
/// <summary>
/// Azure CosmosDBの初期化
/// </summary>
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(IConfigurationSection configurationSection)
{
// 設定ファイルからDB名・接続文字列等を取得
string databaseName = configurationSection.GetSection("DatabaseName").Value;
string contairName = configurationSection.GetSection("ContainerName").Value;
string account = configurationSection.GetSection("Account").Value;
string key = configurationSection.GetSection("Key").Value;
// 取得した設定を元にCosmosDBサービスを立ち上げ
CosmosClient client = new CosmosClient(account, key);
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, contairName);
// 指定のDB、コンテナがなければ作る
DatabaseResponse databaseResponse = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await databaseResponse.Database.CreateContainerIfNotExistsAsync(contairName, "/id");
return(cosmosDbService);
}
/// <summary>
/// Creates a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(IConfigurationSection configurationSection)
{
string databaseName = configurationSection.GetSection("DatabaseName").Value;
string containerName = configurationSection.GetSection("ContainerName").Value;
string account = configurationSection.GetSection("Account").Value;
string key = configurationSection.GetSection("Key").Value;
Microsoft.Azure.Cosmos.CosmosClient client = new Microsoft.Azure.Cosmos.CosmosClient(account, key);
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
Microsoft.Azure.Cosmos.DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.DefineContainer(name : containerName, partitionKeyPath : "/id")
.WithUniqueKey()
.Path("/emailAddress")
.Attach()
.CreateIfNotExistsAsync();
return(cosmosDbService);
}
