private async Task DoWork()
{
DocumentClientFactory clientFactory = new DocumentClientFactory();
MusicService musicService = new MusicService(clientFactory);
await musicService.InitializeStorage();
UserService userService = new UserService(clientFactory);
var user1 = userService.CreateNew();
user1.Id = new Guid("0e54b6da-caef-492f-bc95-b0669a8957d5").ToString();
user1.UserName = "******";
user1.FirstName = "Jack";
user1.LastName = "Blackie";
await userService.AddOrUpdate(user1);
var user2 = userService.CreateNew();
user2.Id = new Guid("d13c91fd-f8df-4470-ae30-bb6ab5797438").ToString();
user2.UserName = "******";
user2.FirstName = "Frank";
user2.LastName = "Conrad";
await userService.AddOrUpdate(user2);
var users = await userService.GetByUsername("*****@*****.**");
foreach (var user in users)
{
Console.Write("\t Read {0}", user);
}
Console.ReadKey();
user1.FirstName = "Jackie";
await userService.Update(user1);
users = await userService.GetByUsername("*****@*****.**");
foreach (var user in users)
{
Console.Write("\t Read {0}", user);
}
Console.ReadKey();
await userService.Delete(user2);
ArtistService artistService = new ArtistService(clientFactory);
var artist = artistService.CreateNew(user1);
artist.Id = "02ab6b39-4d53-45f4-8922-d118d8e27ad2";
artist.Name = "Muse";
await artistService.AddOrUpdate(artist);
artist = await artistService.GetById(artist.Id);
Console.Write("\t Read {0}", artist);
}
private async Task <IDocumentClient> GetDocumentClient()
{
var endpoint = Configuration["DocumentDB:Endpoint"];
var authKey = Configuration["DocumentDB:AuthKey"];
return(await DocumentClientFactory.CreateClient(endpoint, authKey));
}
public async void MainTest()
{
var config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
var dbSettings = Options.Create(new DocumentDbSettings
{
AuthKey = config["AuthKey"],
DatabaseId = config["DatabaseId"],
Uri = config["Uri"],
MaxRetryAttemptsOnThrottledRequests = int.Parse(config["MaxRetryAttemptsOnThrottledRequests"]),
MaxRetryWaitTimeInSeconds = int.Parse(config["MaxRetryWaitTimeInSeconds"])
});
var documentClientFactory = new DocumentClientFactory(dbSettings);
var documentClient = documentClientFactory.GetClient();
try
{
await new DatabaseProviderTestFixture(documentClientFactory).RunOrderedTest();
await new GenericCollectionProviderTestFixture(documentClientFactory).RunOrderedTest();
await new GenericRepositoryTestFixture(documentClientFactory).RunOrderedTest();
}
finally
{
documentClient.DeleteDatabaseAsync(
UriFactory.CreateDatabaseUri(documentClientFactory.GetDatabaseId()))
.Wait();
}
}
public Service(StatelessServiceContext context)
: base(context)
{
services = new ServiceCollection();
services.AutoRegisterHandlersFromAssemblyOf <CreateProfileCommandHandler>();
services.AddSingleton <IDocumentClient>(DocumentClientFactory.Create());
}
private async Task InitializeAsync()
{
_documentClient = DocumentClientFactory.Create(_configuration);
_documentDatabase = await _documentClient.CreateDatabaseIfNotExistsAsync(new Database { Id = DocumentDatabaseName });
_documentCollection = await _documentClient.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(DocumentDatabaseName), new DocumentCollection { Id = DocumentCollectionName });
}
public void Configure(IWebJobsBuilder builder)
{
string environment = Environment.GetEnvironmentVariable("AZURE_FUNCTIONS_ENVIRONMENT");
builder.Services.AddSingleton(_ => ElasticClientFactory.Create());
builder.Services.AddSingleton(_ => DocumentClientFactory.Create());
builder.Services.AddSingleton <IAttemptService, AttemptService>();
builder.Services.AddSingleton <IZoneService, ZoneService>();
builder.Services.AddSingleton <IToyDistributionProblemRepository, ToyDistributionProblemRepository>();
if (!string.Equals(environment, "Development", StringComparison.OrdinalIgnoreCase))
{
builder.Services.AddLogging(loggingBuilder => loggingBuilder
.AddSerilog(new LoggerConfiguration()
.WriteTo
.Elasticsearch(new ElasticsearchSinkOptions(ElasticClientFactory.Url)
{
AutoRegisterTemplate = true,
AutoRegisterTemplateVersion = AutoRegisterTemplateVersion.ESv7,
MinimumLogEventLevel = LogEventLevel.Information,
ModifyConnectionSettings = connection =>
{
connection.BasicAuthentication(ElasticClientFactory.Username, ElasticClientFactory.Password);
return(connection);
}
})
.CreateLogger()));
}
}
public static DocumentClient AddDefaultDocumentClientForIdentity(this IServiceCollection services, Uri serviceEndpoint, string authKeyOrResourceToken, JsonSerializerSettings serializerSettings = null, ConnectionPolicy connectionPolicy = null, ConsistencyLevel?consistencyLevel = null, Action <DocumentClient> afterCreation = null)
{
var documentClient = DocumentClientFactory.CreateClient(serviceEndpoint, authKeyOrResourceToken, serializerSettings, connectionPolicy, consistencyLevel);
afterCreation?.Invoke(documentClient);
services.AddSingleton <IDocumentClient>(documentClient);
return(documentClient);
}
public static IServiceCollection AddCosmosStore <TEntity>(this IServiceCollection services, CosmosStoreSettings settings) where TEntity : class
{
var documentClient = DocumentClientFactory.CreateDocumentClient(settings);
services.AddSingleton <ICosmosStore <TEntity> >(x => new CosmosStore <TEntity>(settings,
new CosmosDatabaseCreator(documentClient),
new CosmosCollectionCreator(documentClient)));
return(services);
}
public ISession GetSession()
{
var documentClient = DocumentClientFactory.GetDocumentClientInstance(descriptor.CosmosDbConnectionString, options);
var cosmosDbEventStore = new CosmosDbEventStore(documentClient, descriptor.DatabaseName, descriptor.CollectionName);
var eventGridClientContext = EventGridClientFactory.GetEventGridClientContext(descriptor.EventGridConnectionString);
var eventGridPublisher = new EventGridEventPublisher(eventGridClientContext.EventGridClient, eventGridClientContext.TopicHostName);
return(new Session(new Repository(cosmosDbEventStore, eventGridPublisher)));
}
public DocumentDbFixture()
{
_client = DocumentClientFactory.CreateDocumentClientAsync(DocumentClientSettings.Emulator).Result;
var script = new SimpleUptimeDbScript(_client, DatabaseConfigurations.Create());
script.DropDatabaseAsync().Wait();
script.ExecuteMigration().Wait();
_documentHelper = new DocumentHelper(_client);
}
public static void RegisterServices(IServiceCollection services)
{
// serivces
services.AddTransient <Settings>();
services.AddTransient <IHttpMonitorRepository, HttpMonitorDocumentRepository>();
services.AddTransient <IHttpMonitorCheckRepository, HttpMonitorCheckDocumentRepository>();
services.AddSingleton <IDocumentClient>(provider => DocumentClientFactory.CreateDocumentClientAsync(provider.GetService <Settings>().ConnectionStrings.CosmosDb).Result);
services.AddTransient <DatabaseConfigurations>(_ => DatabaseConfigurations.Create());
services.AddTransient <SimpleUptimeDbScript>();
services.AddTransient <ICheckHttpEndpointPublisher, CheckHttpEndpointQueuePublisher>();
services.AddTransient <IHttpEndpointCheckedPublisher, HttpEndpointCheckedQueuePublisher>();
services.AddTransient <IHttpMonitorCheckedPublisher, HttpMonitorCheckedQueuePublisher>();
services.AddTransient <JsonSerializer>(provider =>
{
var settings = new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
TypeNameHandling = TypeNameHandling.Objects,
TypeNameAssemblyFormat = FormatterAssemblyStyle.Full
};
settings.Converters.Add(new GuidValueJsonConverter());
settings.Converters.Add(new HttpMethodJsonConverter());
return(JsonSerializer.Create(settings));
});
services.AddTransient <ICheckHttpMonitorPublisherService, CheckHttpMonitorPublisherService>();
services.AddTransient <CloudStorageAccount>(provider => CloudStorageAccount.Parse(provider.GetService <Settings>().ConnectionStrings.StorageAccount));
services.AddTransient <CloudQueueClient>(provider => provider.GetService <CloudStorageAccount>().CreateCloudQueueClient());
services.AddTransient <IHttpMonitorExecutor, HttpMonitorExecutor>();
services.AddSingleton <HttpClient>();
services.AddTransient <CloudQueueFactory>();
services.AddTransient <CreateCloudQueueAsync>(provider =>
provider.GetService <CloudQueueFactory>().CreateCloudQueueAsync);
services.AddTransient <IHttpMonitorService, HttpMonitorService>();
services.AddSingleton <JsonMediaTypeFormatter>(_ => new JsonMediaTypeFormatter
{
SerializerSettings = Constants.JsonSerializerSettings
});
}
public WebApiAppFixture()
{
_client = DocumentClientFactory.CreateDocumentClientAsync(DocumentClientSettings.Emulator).Result;
_documentHelper = new DocumentHelper(_client);
new SimpleUptimeDbScript(_client, DatabaseConfigurations.Create())
.DropDatabaseAsync()
.Wait();
_server = new TestServer(new WebHostBuilder()
.UseStartup <Startup>());
HttpClient = _server.CreateClient();
}
public CosmosStore(CosmosStoreSettings settings, string overriddenCollectionName)
{
Settings = settings ?? throw new ArgumentNullException(nameof(settings));
DatabaseName = settings.DatabaseName;
var documentClient = DocumentClientFactory.CreateDocumentClient(settings);
CosmosClient = new CosmosClient(documentClient, Settings.InfiniteRetries);
if (string.IsNullOrEmpty(Settings.DatabaseName))
{
throw new ArgumentNullException(nameof(Settings.DatabaseName));
}
_collectionCreator = new CosmosCollectionCreator(CosmosClient);
_databaseCreator = new CosmosDatabaseCreator(CosmosClient);
InitialiseCosmosStore(overriddenCollectionName);
}
public CosmosClient(
Uri endpoint,
string authKeyOrResourceToken,
ConnectionPolicy connectionPolicy = null,
ConsistencyLevel?desiredConsistencyLevel = null,
bool infiniteRetrying = true)
{
DocumentClient = DocumentClientFactory.CreateDocumentClient(endpoint, authKeyOrResourceToken, connectionPolicy, desiredConsistencyLevel);
if (infiniteRetrying)
{
DocumentClient.SetupInfiniteRetries();
}
_serializerSettings = DocumentClient.GetJsonSerializerSettingsFromClient();
}
private static Task <FeedResponse <ClimateData> > QueryClimateData()
{
var client = DocumentClientFactory.Create(
Environment.GetEnvironmentVariable("CosmosDbConnectionString"));
var queryOptions = new FeedOptions {
MaxItemCount = 30, EnableCrossPartitionQuery = true
};
IDocumentQuery <ClimateData> dataQuery =
client.CreateDocumentQuery <ClimateData>(
UriFactory.CreateDocumentCollectionUri(
Environment.GetEnvironmentVariable("CosmosDbNameDeviceData"),
Environment.GetEnvironmentVariable("CosmosDbCollectionClimateData")),
queryOptions).OrderByDescending(d => d.Timestamp).AsDocumentQuery();
return(dataQuery.ExecuteNextAsync <ClimateData>());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc(options =>
{
// model binders
options.ModelBinderProviders.Insert(0, new HttpMonitorIdBinder());
})
// mvc json settings
.AddJsonOptions(opt =>
{
opt.SerializerSettings.Converters.Add(new GuidValueJsonConverter());
opt.SerializerSettings.Converters.Add(new HttpMethodJsonConverter());
});
services.Configure <RouteOptions>(options =>
{
// route constraints
options.ConstraintMap.Add(HttpMonitorIdRouteConstraint.RouteLabel, typeof(HttpMonitorIdRouteConstraint));
});
services.Configure <MvcOptions>(options =>
{
options.Filters.Add(new CorsAuthorizationFilterFactory("AllowAnyOrigin"));
});
services.AddCors(options =>
{
options.AddPolicy("AllowAnyOrigin", builder => builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
});
// settings
services.AddOptions();
services.Configure <DocumentClientSettings>(Configuration.GetSection("DocumentClientSettings"));
// serivces
services.AddTransient <IHttpMonitorService, HttpMonitorService>();
services.AddTransient <IHttpMonitorRepository, HttpMonitorDocumentRepository>();
services.AddSingleton <IDocumentClient>(provider => DocumentClientFactory.CreateDocumentClientAsync(Configuration.GetConnectionString("CosmosDb")).Result);
services.AddTransient <DatabaseConfigurations>(_ => DatabaseConfigurations.Create());
services.AddTransient <SimpleUptimeDbScript>();
services.AddTransient <IHttpMonitorExecutorService, HttpMonitorExecutorService>();
services.AddTransient <IHttpMonitorExecutor, HttpMonitorExecutor>();
services.AddSingleton <HttpClient>();
}
public DocumentDbFixture()
{
Client = DocumentClientFactory.CreateClient(
serviceEndpoint: new Uri("https://localhost:8081", UriKind.Absolute),
authKeyOrResourceToken: "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==",
connectionPolicy: new ConnectionPolicy()
{
EnableEndpointDiscovery = false
});
Normalizer = new LookupNormalizer();
DatabaseLink = UriFactory.CreateDatabaseUri(this.Database);
UserStoreCollectionLink = UriFactory.CreateDocumentCollectionUri(this.Database, this.UserStoreDocumentCollection);
RoleStoreCollectionLink = UriFactory.CreateDocumentCollectionUri(this.Database, this.RoleStoreDocumentCollection);
CreateTestDatabase();
}
public ClassificationCategoryService(DocumentClientFactory factory)
{
_documentClientFactory = factory;
}
public ArtistService(DocumentClientFactory factory)
{
_documentClientFactory = factory;
}
private static void InitializeDocumentClient()
{
_documentClient = DocumentClientFactory.Create(
Environment.GetEnvironmentVariable("CosmosDbConnectionString"));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddSingleton <IDocumentClient>(DocumentClientFactory.Create());
}
public MusicService(DocumentClientFactory factory)
{
_documentClientFactory = factory;
}
/// <summary>
/// Initialize repository and client document
/// Must be in this order
/// </summary>
static ComplianceManager()
{
ComplyNowDoumentDbDocumentClient = DocumentClientFactory.Create();
ComplyNowDoumentDbComplianceResponseRepository = new Repository <ComplianceResponseSet>(ComplyNowDoumentDbDocumentClient, DocumentDbConfig.DocDbDatabase);
}
/// <summary>
/// Initialize repository and client document
/// Must be in this order
/// </summary>
static DeviceManager()
{
ComplyNowDoumentDbDocumentClient = DocumentClientFactory.Create();
ComplyNowDoumentDbDeviceRepository = new Repository <Device>(ComplyNowDoumentDbDocumentClient, DocumentDbConfig.DocDbDatabase);
}
public static ICosmonautClient CreateCosmonautClient(CosmosStoreSettings settings)
{
return(new CosmonautClient(DocumentClientFactory.CreateDocumentClient(settings)));
}
public UserService(DocumentClientFactory factory)
{
_documentClientFactory = factory;
}
