public LocationsController(IMemoryCache cache, CosmosClient client) { countryCache = cache; docClient = client; docContainer = docClient.GetContainer( "m3globocdb", "globolocations"); }
public static async Task <List <CityCount> > AggCityCount( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "agg-city-count")] HttpRequestMessage request, ILogger log) { cosmosClient = new CosmosClient(EndpointUri, PrimaryKey); database = cosmosClient.GetDatabase(databaseId); container = database.GetContainer(containerId); List <CityCount> eventsCountArray = new List <CityCount>() { }; var sqlQueryText = "SELECT c.city as name, count(c.event_id) as y from c " + "GROUP BY c.city"; Console.WriteLine("Running query: {0}\n", sqlQueryText); QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText); FeedIterator <CityCount> queryResultSetIterator = container.GetItemQueryIterator <CityCount>(queryDefinition); while (queryResultSetIterator.HasMoreResults) { FeedResponse <CityCount> currentResultSet = await queryResultSetIterator.ReadNextAsync(); foreach (CityCount i in currentResultSet) { Console.WriteLine("\tRead {0}\n", i); eventsCountArray.Add(i); } } return(eventsCountArray); }
public static async Task <List <NumOfInjuredCount> > AggInjuredCount( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "agg-injured--count")] HttpRequestMessage request, [SignalR(HubName = "CounterHub")] IAsyncCollector <SignalRMessage> signalRMessages, ILogger log) { cosmosClient = new CosmosClient(EndpointUri, PrimaryKey); database = cosmosClient.GetDatabase(databaseId); container = database.GetContainer(containerId); List <NumOfInjuredCount> eventsCountArray = new List <NumOfInjuredCount>() { }; var sqlQueryText = "SELECT c.num_of_injured as label, count(c.event_id) as y from c " + "WHERE c.is_false_alarm = 'False' " + "GROUP BY c.num_of_injured"; Console.WriteLine("Running query: {0}\n", sqlQueryText); QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText); FeedIterator <NumOfInjuredCount> queryResultSetIterator = container.GetItemQueryIterator <NumOfInjuredCount>(queryDefinition); while (queryResultSetIterator.HasMoreResults) { FeedResponse <NumOfInjuredCount> currentResultSet = await queryResultSetIterator.ReadNextAsync(); foreach (NumOfInjuredCount i in currentResultSet) { Console.WriteLine("\tRead {0}\n", i); eventsCountArray.Add(i); } } return(eventsCountArray); }
public static async Task <List <EventdayCount> > AggEventsEachDay( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "agg-event-day")] HttpRequestMessage request, [SignalR(HubName = "CounterHub")] IAsyncCollector <SignalRMessage> signalRMessages, ILogger log) { cosmosClient = new CosmosClient(EndpointUri, PrimaryKey); database = cosmosClient.GetDatabase(databaseId); container = database.GetContainer(containerId); List <EventdayCount> eventsCountArray = new List <EventdayCount>() { }; var sqlQueryText = "SELECT table.time as x, count(table.event_id) as y from" + " (SELECT c.event_id as event_id, SUBSTRING(c.time, 0, 10) as time FROM c) as table" + " GROUP BY table.time"; Console.WriteLine("Running query: {0}\n", sqlQueryText); QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText); FeedIterator <EventdayCount> queryResultSetIterator = container.GetItemQueryIterator <EventdayCount>(queryDefinition); while (queryResultSetIterator.HasMoreResults) { FeedResponse <EventdayCount> currentResultSet = await queryResultSetIterator.ReadNextAsync(); foreach (EventdayCount i in currentResultSet) { Console.WriteLine("\tRead {0}\n", i); eventsCountArray.Add(i); } } eventsCountArray.Sort((x, y) => DateTime.Compare(x.x, y.x)); return(eventsCountArray); }
public static async Task <List <Events> > GetHistoryEvents( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "get_history_events")] HttpRequestMessage request, ILogger log) { cosmosClient = new CosmosClient(EndpointUri, PrimaryKey); database = cosmosClient.GetDatabase(databaseId); container = database.GetContainer(containerId); List <Events> eventsCountArray = new List <Events>() { }; var sqlQueryText = "SELECT * from c"; Console.WriteLine("Running query: {0}\n", sqlQueryText); QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText); FeedIterator <Events> queryResultSetIterator = container.GetItemQueryIterator <Events>(queryDefinition); while (queryResultSetIterator.HasMoreResults) { FeedResponse <Events> currentResultSet = await queryResultSetIterator.ReadNextAsync(); foreach (Events i in currentResultSet) { Console.WriteLine("\tRead {0}\n", i); eventsCountArray.Add(i); } } return(eventsCountArray); }
public CosmosDbService( CosmosClient dbClient, string databaseName, string containerName) { this._container = dbClient.GetContainer(databaseName, containerName); }
public LocationsController(IMemoryCache cache, CosmosClient client) { countryCache = cache; docClient = client; //In Azure Cosmos DB, we create a database and inside that database, we have a container and inside that container, we will have items. //A database is analogous to a namespace. It is the unit of management for a set of containers. docContainer = docClient.GetContainer("sample-database", "sample-container"); }
/// <summary> /// Initializes a new instance of the <see cref="CosmosUserRepository{T}"/> class. /// </summary> /// <param name="cosmosConfiguration">Configuration to create connection with an Azure Cosmos DB Database</param> /// <param name="loggerFactory">Logger factory to create a logger</param> public CosmosUserRepository(CosmosConfiguration cosmosConfiguration, ILoggerFactory loggerFactory) : base(cosmosConfiguration, loggerFactory) { this.Logger.LogTrace("Beginning construction of Cosmos User Repository"); this.container = this.CosmosClient.GetContainer(this.DatabaseId, UserBase.ContainerId); this.Logger.LogTrace("Construction of Cosmos User Repository complete"); }
public MasterRepository(TelemetryLogger logger, IRepositoryClient repositoryClient, IRepositoryCosmosClient repositoryCosmosClient) { client = repositoryClient.Client; databaseId = repositoryClient.DatabaseId; collectionId = repositoryClient.CollectionId; collectionUri = repositoryClient.CollectionUri; //documentCollection = repositoryClient.DocumentCollection; container = repositoryCosmosClient.Container; this.logger = logger; }
public static async Task <DateTime> UpdateLastRun(ILogger log) { // Set variable to keep lastRun time DateTime lastRun; // Bootstrap object to update DB with new date BotLastRun freshDeskBotLastRun = new BotLastRun() { Id = "0" }; try { //Connect to DB await EnsureCosmosDBAsync(log); // Create LastRun container in DB if not existing lastRunContainer = await database.CreateContainerIfNotExistsAsync("LastRun", "/id"); // Read the item to see if it exists. ItemResponse <BotLastRun> freshDeskBotLastRunResponse; freshDeskBotLastRunResponse = await lastRunContainer.ReadItemAsync <BotLastRun>(freshDeskBotLastRun.Id, new PartitionKey(freshDeskBotLastRun.Id)); log.LogInformation("Last run time (GMT) was: {0}\n", freshDeskBotLastRunResponse.Resource.LastRun); // Keep the last run time as return parameter of the function lastRun = freshDeskBotLastRunResponse.Resource.LastRun; // Update the lastrun time in DB freshDeskBotLastRun.LastRun = DateTime.Now.ToUniversalTime(); freshDeskBotLastRunResponse = await lastRunContainer.ReplaceItemAsync <BotLastRun>(freshDeskBotLastRun, freshDeskBotLastRun.Id, new PartitionKey(freshDeskBotLastRun.Id)); return(lastRun); } catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.NotFound) { try { lastRun = DateTime.Now; // Set current time as initial value in DB log.LogInformation("Setting initial last run time to: {0}", freshDeskBotLastRun.LastRun); freshDeskBotLastRun.LastRun = DateTime.Now.ToUniversalTime(); ItemResponse <BotLastRun> botConversationStateResponse = await lastRunContainer.CreateItemAsync(freshDeskBotLastRun, new PartitionKey(freshDeskBotLastRun.Id)); return(lastRun); } catch (Exception ex2) { log.LogError("Exception occurred in ReplaceFreshDeskBotStateAsync: {1}", ex2); throw; } } }
//Method for Bulk insert records using createAsync method public async void BulkInsertCreateAsyncMethod(List <PricePaidData> lstPricedata) { //Define the conectivity option to cosmos client CosmosClientOptions options = new CosmosClientOptions() { AllowBulkExecution = true, ConnectionMode = ConnectionMode.Direct, MaxRequestsPerTcpConnection = -1, MaxTcpConnectionsPerEndpoint = -1, ConsistencyLevel = ConsistencyLevel.Eventual, MaxRetryAttemptsOnRateLimitedRequests = 999, MaxRetryWaitTimeOnRateLimitedRequests = TimeSpan.FromHours(1), }; #region CosmosDB Connection settings CosmosClient client = new CosmosClient(EndpointUrl, AuthorizationKey, options); Database database = await client.CreateDatabaseIfNotExistsAsync(DatabaseName); //Container container = await database.CreateContainerIfNotExistsAsync(ContainerName, "/Postcode"); Container container = await database.DefineContainer(ContainerName, "/Postcode").WithIndexingPolicy() .WithIndexingMode(IndexingMode.Consistent).WithIncludedPaths().Attach() .WithExcludedPaths().Path("/*").Attach().Attach() .CreateIfNotExistsAsync(5000); //database.ReplaceThroughputAsync() //ThroughputResponse throughput = await container.ReplaceThroughputAsync(20000); #endregion int cnt = 0; List <Task> tasks = new List <Task>(); foreach (var item in lstPricedata) { cnt++; // only used for debugging to see current record index being processed tasks.Add(container.CreateItemAsync <PricePaidData>(item, new PartitionKey(item.Postcode))); } await Task.WhenAll(tasks); //throughput = await container.ReplaceThroughputAsync(400); }
static async Task Main(string[] args) { _database = _client.GetDatabase("AppStore"); _container = _database.GetContainer("Apps"); //Console.WriteLine("Adding Item...."); //Console.WriteLine("Updating Item...."); //Console.WriteLine("Deleting Item...."); Console.WriteLine("Getting Items...."); await GetAppsAsync(); //await CreateAppAsync(); //await UpdateAppAsync(); //await DeleteAppAsync(); Console.ReadKey(); }
private static async Task EnsureCosmosDBAsync(ILogger log) { try { //Create a new instance of the Cosmos Client cosmosClient = new CosmosClient(cosmosDBEndpointUri, cosmosDBPrimaryKey); //create database and container if not existing database = await cosmosClient.CreateDatabaseIfNotExistsAsync(cosmosDBDatabaseId); botStateContainer = await database.CreateContainerIfNotExistsAsync(cosmosDBContainerId, "/id"); } catch (Exception ex) { log.LogError("Exception occurred in EnsureCosmosDBAsync: {1}", ex); throw; } }
public TenantBaseManager(string containerName, IHttpContextAccessor httpContextAccessor, IConfiguration configuration, IWebHostEnvironment webHostEnvironment) { _moniker = httpContextAccessor.HttpContext.Request.RouteValues["moniker"] != null ? httpContextAccessor.HttpContext.Request.RouteValues["moniker"].ToString() : string.Empty; //_tenant = customerService.GetItemAsync(_moniker); if (_tenant == null) { return; // No tenant, no entry! } SetConnectionParameters(configuration, webHostEnvironment); if (!string.IsNullOrEmpty(_uri) && !string.IsNullOrEmpty(_primaryKey)) { CosmosClientBuilder clientBuilder = new CosmosClientBuilder(_uri, _primaryKey); _dbClient = clientBuilder.WithConnectionModeDirect().Build(); _container = _dbClient.GetContainer(_databaseName, containerName); } }
private async Task InitClientsAsync() { CosmosClientPool.CreateClient(this.cosmosDBSettings.Producer); CosmosClientPool.CreateClient(this.cosmosDBSettings.Lease); //await CosmosExtension.SetupCosmosDBEntitiesAsync(this.cosmosDBSettings.Producer); await CosmosExtension.SetupCosmosDBEntitiesAsync(this.cosmosDBSettings.Lease); Microsoft.Azure.Cosmos.Container leaseContainer = CosmosClientPool.GetCosmosClient(this.cosmosDBSettings.Lease).GetContainer(this.cosmosDBSettings.Lease.Database, this.cosmosDBSettings.Lease.Container); Microsoft.Azure.Cosmos.Container sourceContainer = CosmosClientPool.GetCosmosClient(this.cosmosDBSettings.Producer).GetContainer(this.cosmosDBSettings.Producer.Database, this.cosmosDBSettings.Producer.Container); this.changeFeedProcessor = sourceContainer .GetChangeFeedProcessorBuilder <EventDataModel>("changeFeedBeginning", this.changesHandler) .WithInstanceName("EventprocessingConsole") .WithLeaseContainer(leaseContainer) .WithStartTime(DateTime.MinValue.ToUniversalTime()) .Build(); await this.changeFeedProcessor.StartAsync(); }
public static async Task UpdateEventTable( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "add-event/{device_id}/{country}/{city}/{email}/{latitude}/{longitude}/{time_str}/{is_false_alarm_str}/{event_details}/{num_of_injured}")] HttpRequestMessage request, [SignalR(HubName = "CounterHub")] IAsyncCollector <SignalRMessage> signalRMessages, string device_id, string country, string city, string email, string latitude, string longitude, string time_str, string is_false_alarm_str, string event_details, string num_of_injured, ILogger log) { cosmosClient = new CosmosClient(EndpointUri, PrimaryKey); database = cosmosClient.GetDatabase(databaseId); container = database.GetContainer(containerId); int event_id = await GetMaxId(container) + 1; Events newEvent = new Events { id = event_id.ToString(), event_id = event_id, device_id = device_id, email = email, country = country, city = city, latitude = latitude, longitude = longitude, is_false_alarm = is_false_alarm_str, event_details = event_details, num_of_injured = num_of_injured, time = time_str }; log.LogInformation(newEvent.id.ToString()); try { // Read the item to see if it exists. ItemResponse <Events> newEventResponse = await container.CreateItemAsync <Events>(newEvent, new PartitionKey(newEvent.email)); log.LogInformation("Item with id: {0} and email {1} was added\n", newEventResponse.Resource.id, newEventResponse.Resource.email); } catch (CosmosException ex) { log.LogInformation("Error adding item to events table: {0}\n", ex); } }
public CosmosDbRepository(ICosmosDbContainerFactory cosmosDbContainerFactory) { this._cosmosDbContainerFactory = cosmosDbContainerFactory ?? throw new ArgumentNullException(nameof(ICosmosDbContainerFactory)); this._container = this._cosmosDbContainerFactory.GetContainer(ContainerName)._container; }
static async Task CreateContainerAsync() { container = await database.CreateContainerIfNotExistsAsync(containerId, "/Country"); }
public CosmosDbService(string connectionString) { _client = new CosmosClient(connectionString); _container = _client.GetContainer("coreDB", "MyItem"); }
public PrayerGroupRepository(CosmosClientService cosmosClientService) { this._container = cosmosClientService.CosmosClient.GetContainer(cosmosClientService.DatabaseName, CONTAINER_NAME); }