/// <summary> /// Generates the starts with filter condition. /// </summary> /// <param name="startsWithField">The table field for filter.</param> /// <param name="startsWithPattern">The starts with pattern for filter.</param> /// <returns> /// string /// </returns> public static string GenerateStartsWithFilterCondition(string startsWithField, string startsWithPattern) { var length = startsWithPattern.Length - 1; var lastChar = startsWithPattern[length]; var nextLastChar = (char)(lastChar + 1); var startsWithEndPattern = startsWithPattern.Substring(0, length) + nextLastChar; var startsWithCondition = TableQuery.CombineFilters( TableQuery.GenerateFilterCondition(startsWithField, QueryComparisons.GreaterThanOrEqual, startsWithPattern), TableOperators.And, TableQuery.GenerateFilterCondition(startsWithField, QueryComparisons.LessThan, startsWithEndPattern) ); return(startsWithCondition); }
/// <summary> /// This method returns all the groups whose notifications are active and due date is not past. /// </summary> /// <returns>list of Group activity details.</returns> public async Task <IList <GroupActivityEntity> > GetAllActiveGroupNotificationsAsync() { await this.EnsureInitializedAsync(); string isNotificationActiveCondition = TableQuery.GenerateFilterConditionForBool("IsNotificationActive", QueryComparisons.Equal, true); string dueDateCondition = TableQuery.GenerateFilterConditionForDate("DueDate", QueryComparisons.GreaterThanOrEqual, DateTime.UtcNow.Date); string combinedFilter = TableQuery.CombineFilters(isNotificationActiveCondition, TableOperators.And, dueDateCondition); var query = new TableQuery <GroupActivityEntity>().Where(combinedFilter); TableContinuationToken continuationToken = null; var groupNotifications = new List <GroupActivityEntity>(); do { var queryResult = await this.cloudTable.ExecuteQuerySegmentedAsync(query, continuationToken); groupNotifications.AddRange(queryResult?.Results); continuationToken = queryResult?.ContinuationToken; }while (continuationToken != null); return(groupNotifications); }
public ActionResult Map(string searchBox) { ViewBag.Message = searchBox; string BINGMAPS_KEY = ConfigurationManager.AppSettings["BINGMAPS_KEY"]; ViewBag.BingMapsKey = BINGMAPS_KEY; string searchURL = "http://dev.virtualearth.net/REST/v1/Locations/{locationQuery}?includeNeighborhood={includeNeighborhood}&maxResults={maxResults}&include={includeValue}&key=" + BINGMAPS_KEY; CloudTable table = DataAccess.GetDataTable("incidents"); //TableQuery<IncidentEntity> query = new TableQuery<IncidentEntity>(); TableQuery <IncidentEntity> query = new TableQuery <IncidentEntity>().Where( TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "injury"), TableOperators.And, TableQuery.GenerateFilterCondition("State", QueryComparisons.Equal, "WASHINGTON"))); var items = table.ExecuteQuery(query).ToList(); return(View(items)); }
private static TableQuery <CandleHistoryEntity> GetTableQuery( CandlePriceType priceType, CandleTimeInterval interval, DateTime from, DateTime to) { var partitionKey = CandleHistoryEntity.GeneratePartitionKey(priceType); var rowKeyFrom = CandleHistoryEntity.GenerateRowKey(from, interval); var rowKeyTo = CandleHistoryEntity.GenerateRowKey(to, interval); var pkeyFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey); var rowkeyFromFilter = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThanOrEqual, rowKeyFrom); var rowkeyToFilter = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThanOrEqual, rowKeyTo); var rowkeyFilter = TableQuery.CombineFilters(rowkeyFromFilter, TableOperators.And, rowkeyToFilter); return(new TableQuery <CandleHistoryEntity> { FilterString = TableQuery.CombineFilters(pkeyFilter, TableOperators.And, rowkeyFilter) }); }
/// <summary> /// Delete initial occurrences belonging to an event. /// </summary> /// <param name="eventId">The event id.</param> /// <returns>The occurrence entities meet the criteria.</returns> public async Task DeleteInitialOccurrencesByEventIdAsync(string eventId) { var filter1 = TableQuery.GenerateFilterCondition( nameof(OccurrenceEntity.EventId), QueryComparisons.Equal, eventId); var filter2 = TableQuery.GenerateFilterConditionForInt( nameof(OccurrenceEntity.OccurrenceStateAsInt), QueryComparisons.Equal, (int)OccurrenceState.Initial); var combinedFilter = TableQuery.CombineFilters(filter1, TableOperators.And, filter2); var occurrences = await this.GetWithFilterAsync(combinedFilter); foreach (var occurrence in occurrences) { await this.DeleteAsync(occurrence); } }
public async Task <PointInTimeProvider> GetProviderAsync(long ukprn, DateTime?pointInTime, CancellationToken cancellationToken) { if (!pointInTime.HasValue) { return(await RetrieveAsync(ukprn.ToString(), "current", cancellationToken)); } var query = new TableQuery <ProviderEntity>() .Where(TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, ukprn.ToString()), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThanOrEqual, pointInTime.Value.ToString("yyyyMMdd")))) .OrderByDesc("RowKey") .Take(1); var results = await QueryProvidersAsync(query, cancellationToken); // Could be more than 1 result if used a point in time. Take the most recent return(results .OrderByDescending(x => x.PointInTime) .FirstOrDefault()); }
TableQuery <DynamicTableEntity> PrepareQuery() { var rowKeyStart = partition.EventVersionRowKey(startVersion); var rowKeyEnd = partition.EventVersionRowKey(startVersion + sliceSize - 1); var filter = TableQuery.CombineFilters( TableQuery.GenerateFilterCondition(nameof(DynamicTableEntity.PartitionKey), QueryComparisons.Equal, partition.PartitionKey), TableOperators.And, TableQuery.CombineFilters( TableQuery.GenerateFilterCondition(nameof(DynamicTableEntity.RowKey), QueryComparisons.Equal, partition.StreamRowKey()), TableOperators.Or, TableQuery.CombineFilters( TableQuery.GenerateFilterCondition(nameof(DynamicTableEntity.RowKey), QueryComparisons.GreaterThanOrEqual, rowKeyStart), TableOperators.And, TableQuery.GenerateFilterCondition(nameof(DynamicTableEntity.RowKey), QueryComparisons.LessThanOrEqual, rowKeyEnd) ) ) ); return(new TableQuery <DynamicTableEntity>().Where(filter)); }
/// <summary> /// Query Table Storage /// </summary> /// <param name="identifier">Identifier</param> /// <param name="version">Version</param> /// <param name="fileName">File Name</param> /// <returns></returns> public virtual async Task <IEnumerable <IDictionary <string, object> > > Query(Guid?identifier = null, string version = null, string fileName = null) { var partitionFilter = identifier.HasValue ? TableQuery.GenerateFilterCondition(TableStorage.PartitionKey, QueryComparisons.Equal, identifier.Value.ToString()) : null; var rowFilter = !string.IsNullOrWhiteSpace(version) ? TableQuery.GenerateFilterCondition(TableStorage.RowKey, QueryComparisons.Equal, version) : null; var query = new TableQuery(); if (null != partitionFilter && null != rowFilter) { query.Where(TableQuery.CombineFilters(partitionFilter, TableOperators.And, rowFilter)); } else if (null != partitionFilter) { query.Where(partitionFilter); } else if (null != rowFilter) { query.Where(rowFilter); } var images = await this.table.Query(query); if (null != images) { images = images.Where(i => string.IsNullOrWhiteSpace(fileName) || fileName == (string)i["FileName"]); foreach (var data in images) { data.Add("Identifier", data[TableStorage.PartitionKey]); data.Add("Version", data[TableStorage.RowKey]); data.Add("CreatedOn", data[TableStorage.Timestamp]); data.Remove(TableStorage.PartitionKey); data.Remove(TableStorage.Timestamp); data.Remove(TableStorage.RowKey); data.Remove(TableStorage.ETag); } } return(images); }
/// <summary> /// The GetAll. /// </summary> /// <param name="schoolId">The schoolId<see cref="string"/>.</param> /// <param name="classId">The classId<see cref="string"/>.</param> /// <returns>The <see cref="Task{IEnumerable{StudentResponse}}"/>.</returns> public async Task <IEnumerable <StudentResponse> > GetAll(string schoolId, string classId) { var filterString = TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, schoolId), TableOperators.And, TableQuery.GenerateFilterCondition("ClassId", QueryComparisons.Equal, classId) ); TableQuery <Entites.Student> studentQuery = new TableQuery <Entites.Student>().Where(filterString); var students = await _tableStorage.QueryAsync <Entites.Student>("Student", studentQuery); var studentList = from student in students where student.Active.GetValueOrDefault(false) orderby student.UpdatedOn descending select new StudentResponse { Id = student.RowKey, FirstName = student.FirstName, LastName = student.LastName, EnrolmentNo = student.EnrolmentNo, Address1 = student.Address1, Address2 = student.Address2, Country = student.Country, State = student.State, City = student.City, Zip = student.Zip, SchoolId = student.PartitionKey, ClassId = student.ClassId, Gender = student.Gender, ProfileStoragePath = student.ProfileStoragePath, TrainStudentModel = student.TrainStudentModel }; return(studentList); }
public string getTitle(string url) { Uri uri; try { uri = new Uri(url); } catch (Exception e) { return(e.Message); } CloudStorageAccount storageAccount = CloudStorageAccount.Parse( ConfigurationManager.AppSettings["StorageConnectionString"]); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); CloudTable statsTable = tableClient.GetTableReference("crawltable"); try { TableQuery <UriEntity> counterquery = new TableQuery <UriEntity>() .Where(TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, uri.Host), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, uri.AbsolutePath.GetHashCode().ToString()))); List <UriEntity> bean = statsTable.ExecuteQuery(counterquery).ToList(); if (bean.Count != 0) { return(bean.ElementAt(0).Title); } } catch (Exception e) { return("Could not access table: " + e.Message); } return("Could not find URL..."); }
public async Task Test_21_QueryWithCompinedFilters() { var table = _client.GetTableReference("testnewtable"); bool tableExists = await table.ExistsAsync(); Check.That(tableExists).IsTrue(); var query = new TableQuery <Customer>() .Where( TableQuery.CombineFilters( TableQuery.GenerateFilterCondition( "PartitionKey", QueryComparisons.Equal, "Meikopoulos" ), TableOperators.And, TableQuery.GenerateFilterCondition( "RowKey", QueryComparisons.Equal, "Orestis" ) ) ); var customerEntities = new List <Customer>(); TableContinuationToken tct = null; do { var queryResult = await table.ExecuteQuerySegmentedAsync(query, tct); tct = queryResult.ContinuationToken; customerEntities.AddRange(queryResult.Results); }while (tct != null); Check.That(customerEntities.Count).IsEqualTo(1); }
/// <summary> /// method to get required backends /// </summary> /// <param name="userbackendslist">takes userbackend list as input to get backendids</param> /// <returns>returns required backends</returns> public List <BackendEntity> GetRequiredBackends(IEnumerable <UserBackendEntity> userbackendslist) { string callerMethodName = string.Empty; try { //Get Caller Method name from CallerInformation class callerMethodName = CallerInformation.TrackCallerMethodName(); string finalfilter = string.Empty; //partionkey filter string partitionkeyfilter = TableQuery.GenerateFilterCondition(CoreConstants.AzureTables.PartitionKey, QueryComparisons.Equal, CoreConstants.AzureTables.Backend); //loop through each userbackend to generate rowkey filter for each one foreach (UserBackendEntity userbackend in userbackendslist) { string rowkeyfilter = TableQuery.GenerateFilterCondition(CoreConstants.AzureTables.RowKey, QueryComparisons.Equal, userbackend.BackendID); //combine partitionkey filter with rowkey to get each entity string currentrowfilter = TableQuery.CombineFilters(partitionkeyfilter, TableOperators.And, rowkeyfilter); //if it is at first postion, no need to add OR condotion if ((userbackendslist.First().BackendID == userbackend.BackendID)) { finalfilter = currentrowfilter; } else { finalfilter = TableQuery.CombineFilters(finalfilter, TableOperators.Or, currentrowfilter); } } //generate query to get all user associated backends TableQuery <BackendEntity> query = new TableQuery <BackendEntity>().Where(finalfilter); List <BackendEntity> backends = DataProvider.GetEntitiesList <BackendEntity>(CoreConstants.AzureTables.ReferenceData, query); return(backends); } catch (Exception exception) { InsightLogger.Exception(exception.Message, exception, callerMethodName); //LoggerHelper.WriteToLog(exception + " - Error while retrieving backends to caliculate synchwaitingtime from referencedata azure table in DAL : " //+ exception.ToString(), CoreConstants.Priority.High, CoreConstants.Category.Error); throw new DataAccessException(); } }
/// <summary> /// Gets the searched blog previews. /// </summary> /// <param name="rowkeys">The rowkeys.</param> /// <returns>IEnumerable<TableBlogEntity>.</returns> private IEnumerable <TableBlogEntity> GetSearchedBlogPreviews(IEnumerable <string> rowkeys) { var rowKeyList = rowkeys as IList <string> ?? rowkeys.ToList(); if (!rowKeyList.Any()) { return(null); } var rowKeyFilterCondition = string.Empty; var isDraftCondition = TableQuery.GenerateFilterConditionForBool("IsDraft", QueryComparisons.Equal, false); var isDeletedCondition = TableQuery.GenerateFilterConditionForBool( "IsDeleted", QueryComparisons.Equal, false); foreach (var rowkey in rowKeyList) { var rowFilter = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, rowkey); var partitionFilter = TableQuery.GenerateFilterCondition( "PartitionKey", QueryComparisons.Equal, ApplicationConstants.BlogKey); var combinedFilter = TableQuery.CombineFilters(rowFilter, TableOperators.And, partitionFilter); rowKeyFilterCondition = string.IsNullOrWhiteSpace(rowKeyFilterCondition) ? combinedFilter : TableQuery.CombineFilters(rowKeyFilterCondition, TableOperators.Or, combinedFilter); } var activeTable = this.blogContext.CustomOperation(); var combinedQuery = new TableQuery <DynamicTableEntity>().Where( TableQuery.CombineFilters( TableQuery.CombineFilters(rowKeyFilterCondition, TableOperators.And, isDraftCondition), TableOperators.And, isDeletedCondition)).Take(this.searchRecordsSize); var result = activeTable.ExecuteQuerySegmented(combinedQuery, null, this.blogContext.TableRequestOptions); return(result.Select(element => element.ConvertDynamicEntityToEntity <TableBlogEntity>())); }
/// <summary> /// Demonstrate a cross partition query with order by against Cosmos Table API /// </summary> /// <param name="table">Sample table name</param> /// <param name="startRowKey"> The lowest bound of the row key range within which to search</param> /// <param name="endRowKey">The highest bound of the row key range within which to search</param> /// <returns>A Task object</returns> private static async Task ExecuteCrossPartitionQueryWithOrderBy(CloudTable table, string startRowKey, string endRowKey) { try { TableQuery <CustomerEntity> partitionScanQuery = new TableQuery <CustomerEntity>().Where( TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThanOrEqual, startRowKey), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThanOrEqual, endRowKey) ) ) .OrderBy("RowKey"); TableContinuationToken token = null; // Read entities from each query segment. do { TableQuerySegment <CustomerEntity> segment = await table.ExecuteQuerySegmentedAsync(partitionScanQuery, token); if (segment.RequestCharge.HasValue) { Console.WriteLine("Request Charge for Query Operation: " + segment.RequestCharge); } token = segment.ContinuationToken; foreach (CustomerEntity entity in segment) { Console.WriteLine("Customer: {0},{1}\t{2}\t{3}", entity.PartitionKey, entity.RowKey, entity.Email, entity.PhoneNumber); } }while (token != null); } catch (StorageException e) { Console.WriteLine(e.Message); Console.ReadLine(); throw; } }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req, [Table("gameconfig", "config", "bit")] GameConfig configItem, [Table("regourls")] CloudTable playerImgTable, [Table("playlogs")] CloudTable gameLogTable, ILogger log) { log.LogInformation($"Current Active Tier: {configItem.activetier}"); var winnerQuery = new TableQuery <PlayLog>().Where( TableQuery.CombineFilters( TableQuery.GenerateFilterConditionForInt("gamelevel", QueryComparisons.Equal, configItem.activetier), TableOperators.And, TableQuery.GenerateFilterCondition("status", QueryComparisons.Equal, "matched_bitly"))); var winnerQuerySegment = await gameLogTable.ExecuteQuerySegmentedAsync(winnerQuery, null); if (winnerQuerySegment != null && winnerQuerySegment.Count() > 0) { configItem.currentwinner = winnerQuerySegment.First().PartitionKey; configItem.winnersubmission = winnerQuerySegment.First().submittedimage; } log.LogInformation($"Looking up image for player: {configItem.currentwinner}"); var playerImageQuery = new TableQuery <PlayerImage>().Where( TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, configItem.currentwinner), TableOperators.And, TableQuery.GenerateFilterConditionForBool("selected", QueryComparisons.Equal, true))); var playerImageQueryResult = await playerImgTable.ExecuteQuerySegmentedAsync(playerImageQuery, null); if (playerImageQueryResult != null && playerImageQueryResult.Count() > 0) { configItem.winnerimgurl = playerImageQueryResult.First().imgurl; } return((ActionResult) new OkObjectResult(configItem)); }
private async Task <Dictionary <string, bool> > GetLegacy(IServiceProvider services, Dictionary <string, bool> result) { string filter = null; foreach (var name in result.Keys) { var f = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, name); if (filter == null) { filter = f; } else { filter = TableQuery.CombineFilters(filter, TableOperators.Or, f); } } var query = new TableQuery <LegacyFeatureEntry>() .Where( TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, GatePartitionKey), TableOperators.And, filter) ); await GatesTable.ProcessQueryAsync(query, async feature => { try { result[feature.RowKey] = feature != null && await feature.IsEnabled(services); } catch (Exception ex) { logger_.LogCritical(ex, $"FG query failed: {feature.RowKey}"); result[feature.RowKey] = false; } }); return(result); }
/// <summary> /// Get all DNS server statistics for a given server newer than a specific date /// </summary> /// <param name="server"></param> /// <param name="fromDate"></param> /// <returns></returns> public async Task <IOrderedEnumerable <DnsServerStatistics> > GetServerStatisticsFromDate(string server, DateTime fromDate) { if (fromDate > DateTime.UtcNow) { throw new ArgumentOutOfRangeException("From DateTime can not be greater than current DateTime. Can not query into the future"); } string partitionKeyFilter; // Partition key is server:year-month // If year or month is different from now, then we have to search in a range of partitions, for an example in partitions in range server:2020-01 - server:2020-03 // This have been manually tested and seems to work :) if (fromDate.Year != DateTime.UtcNow.Year || fromDate.Month != DateTime.UtcNow.Month) { partitionKeyFilter = TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.GreaterThanOrEqual, $"{server}:{fromDate:yyyy-MM}"), TableOperators.And, TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.LessThanOrEqual, $"{server}:{DateTime.UtcNow:yyyy-MM}")); } else { partitionKeyFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, $"{server}:{fromDate:yyyy-MM}"); } var createdDateFilter = TableQuery.GenerateFilterConditionForDate("CreatedDate", QueryComparisons.GreaterThanOrEqual, fromDate); string combinedFilter = TableQuery.CombineFilters(partitionKeyFilter, TableOperators.And, createdDateFilter); var entities = new List <DnsServerStatistics>(); TableContinuationToken continuationToken = null; do { var page = await GetTableData <DnsServerStatisticsEntity>(_cloudTable, combinedFilter, continuationToken); continuationToken = page.ContinuationToken; entities.AddRange(page.Results.Select(entity => entity.DnsServerStatistics)); }while (continuationToken != null); return(entities.OrderBy(entity => entity.CreatedDate)); }
/// <summary> /// Gets all of the Shift Mapping Entities in a Batch manner. /// </summary> /// <param name="userModel">The User Model.</param> /// <param name="monthPartitionKey">Month Partition Value.</param> /// <returns>A unit of execution that contains a list of shift mapping entities.</returns> private async Task <List <TeamsShiftMappingEntity> > GetAllShiftMappingEntitiesInBatchAsync( UserDetailsModel userModel, string monthPartitionKey) { if (userModel is null) { throw new ArgumentNullException(nameof(userModel)); } await this.EnsureInitializedAsync().ConfigureAwait(false); var getEntitiesProps = new Dictionary <string, string>() { { "CurrentCallingAssembly", Assembly.GetCallingAssembly().GetName().Name }, }; this.telemetryClient.TrackTrace(MethodBase.GetCurrentMethod().Name, getEntitiesProps); string userFilter = TableQuery.GenerateFilterCondition("KronosPersonNumber", QueryComparisons.Equal, userModel?.KronosPersonNumber); string monthPartitionFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, monthPartitionKey); // Table query TableQuery <TeamsShiftMappingEntity> query = new TableQuery <TeamsShiftMappingEntity>(); query.Where(TableQuery.CombineFilters(monthPartitionFilter, TableOperators.And, userFilter)); // Results list var results = new List <TeamsShiftMappingEntity>(); TableContinuationToken continuationToken = null; do { TableQuerySegment <TeamsShiftMappingEntity> queryResults = await this.shiftEntityMappingCloudTable.ExecuteQuerySegmentedAsync(query, continuationToken).ConfigureAwait(false); continuationToken = queryResults.ContinuationToken; results.AddRange(queryResults.Results); }while (continuationToken != null); return(results); }
/// <summary> /// method to get userbackends /// </summary> /// <param name="UserID">takes userid as input</param> /// <returns> returns list of user backends associated to user</returns> public List <UserBackendEntity> GetUserAllBackends(string UserID, List <string> userbackendidslist) { string callerMethodName = string.Empty; try { //Get Caller Method name from CallerInformation class callerMethodName = CallerInformation.TrackCallerMethodName(); string finalfilter = string.Empty; //partionkey filter string partitionkeyfilter = TableQuery.GenerateFilterCondition(CoreConstants.AzureTables.PartitionKey, QueryComparisons.Equal, string.Concat(CoreConstants.AzureTables.UserBackendPK, UserID)); //loop through each userbackend to generate rowkey filter for each one foreach (string userbackendid in userbackendidslist) { string rowkeyfilter = TableQuery.GenerateFilterCondition(CoreConstants.AzureTables.RowKey, QueryComparisons.Equal, userbackendid); //combine partitionkey filter with rowkey to get each entity string currentrowfilter = TableQuery.CombineFilters(partitionkeyfilter, TableOperators.And, rowkeyfilter); //if it is at first postion, no need to add OR condotion if ((userbackendidslist.First() == userbackendid)) { finalfilter = currentrowfilter; } else { finalfilter = TableQuery.CombineFilters(finalfilter, TableOperators.Or, currentrowfilter); } } //generate query to get all user associated backends TableQuery <UserBackendEntity> query = new TableQuery <UserBackendEntity>().Where(finalfilter); List <UserBackendEntity> alluserbackends = DataProvider.GetEntitiesList <UserBackendEntity>(CoreConstants.AzureTables.UserDeviceConfiguration, query); return(alluserbackends); } catch (Exception exception) { InsightLogger.Exception(exception.Message, exception, callerMethodName); //LoggerHelper.WriteToLog(exception + " - Error while retrieving userbackends from userdeviceconfig azure table in DAL : " //+ exception.ToString(), CoreConstants.Priority.High, CoreConstants.Category.Error); throw new DataAccessException(); } }
public async Task <IFeedCandle> GetCandleAsync(string asset, TimeInterval interval, bool isBuy, DateTime dateTime) { if (string.IsNullOrEmpty(asset)) { throw new ArgumentNullException(nameof(asset)); } // 1. Get candle table entity string partitionKey = CandleTableEntity.GeneratePartitionKey(asset); string rowKey = CandleTableEntity.GenerateRowKey(dateTime, isBuy, interval); //CandleTableEntity entity = await _tableStorage.GetDataAsync(partitionKey, rowKey); //--------------- TableQuery <CandleTableEntity> query = new TableQuery <CandleTableEntity>(); string pkeyFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey); string rowkeyFilter = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, rowKey); query.FilterString = TableQuery.CombineFilters(pkeyFilter, TableOperators.And, rowkeyFilter); query.SelectColumns = CandleTableEntity.GetStoreFields(interval, dateTime); List <CandleTableEntity> entities = new List <CandleTableEntity>(1); await _tableStorage.ScanDataAsync(query, list => { entities.AddRange(list); return(Task.FromResult(0)); }); //----------- // 2. Find required candle in candle list by tick if (entities.Count > 0) { var cell = dateTime.GetIntervalCell(interval); var tick = dateTime.GetIntervalTick(interval); var candleItem = entities[0].Candles.FirstOrDefault(ci => ci.Tick == tick && ci.Cell == cell); return(candleItem.ToCandle(isBuy, entities[0].DateTime, interval)); } return(null); }
/// <summary> /// Meant for a query for a two part partition key and row key, with the goal to filter on the first part /// of the partition key and the first part of the row key. This can also be used to filter on the entire /// partition key and the first part of a row key. /// </summary> /// <param name="partitionPrefix">A value the partition key must begin with, or the full partition key.</param> /// <param name="rowKeyStartRange">The first whole or partial row key to match.</param> /// <param name="rowKeyEndRange">The final whole or partial row key to match. All row keys that start with this will also be matched.</param> /// <param name="otherFilters">Any other filters, or null. Use <see cref="Microsoft.WindowsAzure.Storage.Table.TableQuery"/> to generate these filters.</param> /// <param name="take">The number of records to take, maximum.</param> /// <returns></returns> public List <TableEntityProxy <T> > QueryPartitionAndRowsByPrefex(String partitionPrefix, String rowKeyStartRange, String rowKeyEndRange, String otherFilters = null, Int32 take = 1000) { var table = GetTable(); if (!table.Exists()) { return(null); } var filter = TableQuery.CombineFilters( TableQuery.CombineFilters( TableQuery.GenerateFilterCondition(TableConstants.PartitionKey, QueryComparisons.GreaterThanOrEqual, partitionPrefix), TableOperators.And, TableQuery.GenerateFilterCondition(TableConstants.PartitionKey, QueryComparisons.LessThan, partitionPrefix.LexicalIncrement(LexicalCharacterSet.AsciiAlphaNumeric, true)) ), TableOperators.And, TableQuery.CombineFilters( TableQuery.GenerateFilterCondition(TableConstants.RowKey, QueryComparisons.GreaterThanOrEqual, rowKeyStartRange), TableOperators.And, TableQuery.GenerateFilterCondition(TableConstants.RowKey, QueryComparisons.LessThan, rowKeyEndRange.LexicalIncrement(LexicalCharacterSet.AsciiAlphaNumeric, true)) )); if (!String.IsNullOrEmpty(otherFilters)) { filter = TableQuery.CombineFilters(filter, TableOperators.And, otherFilters); } var query = new TableQuery <TableEntityProxy <T> >() .Where(filter) .Take(take); return(table.ExecuteQuery(query).ToList()); }
private static async Task <Investor> LoadInvestor(AssetPurchase bondPurchase, CloudTable cloudTable, ILogger log) { TableQuery <Investor> investorQuery = new TableQuery <Investor>().Where( TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, InvestorType.Individual), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, bondPurchase.InvestorId))); var queryExecution = await cloudTable.ExecuteQuerySegmentedAsync(investorQuery, null); var investor = queryExecution.Results.FirstOrDefault(); if (investor is null) { var message = $"The investor id '{bondPurchase.InvestorId}' was not found in table storage."; log.LogError(message); throw new ArgumentException(message, nameof(bondPurchase)); } return(investor); }
public override void ExecuteCommand() { string DeployId = new JavaScriptSerializer().Deserialize <string>(ReportHelpers.Load(StorageAccount, "DeploymentId_" + ServiceName + ".json", ContainerName)); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(PerfCounterTableStorageAccount); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); CloudTable table = tableClient.GetTableReference("WAD" + DeployId + "PT5MRTable"); int count = 0; double sum = 0; TableQuery <dataEntity> rangeQuery = new TableQuery <dataEntity>().Where(TableQuery.CombineFilters( TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.GreaterThan, DateTime.UtcNow.AddMinutes(-frequencyInMin)), TableOperators.And, TableQuery.GenerateFilterCondition("CounterName", QueryComparisons.Equal, PerfCounterName))); foreach (dataEntity entity in table.ExecuteQuery(rangeQuery)) { count++; sum += entity.Total / entity.Count; } ReportHelpers.AppendDatatoBlob(StorageAccount, ServiceName + PerfCounterName + string.Format("{0:MMdd}", DateTime.Now) + ".json", new Tuple <string, string>(String.Format("{0:HH:mm}", DateTime.Now), (sum / count).ToString("F")), 24 * 60 / frequencyInMin, ContainerName); }
/// <summary> /// Get post data. /// </summary> /// <param name="postCreatedByuserId">User id to fetch the post details.</param> /// <param name="postId">Post id to fetch the post details.</param> /// <returns>A task that represent a object to hold post data.</returns> public async Task <PostEntity> GetPostAsync(string postCreatedByuserId, string postId) { // When there is no post created by user and Messaging Extension is open, table initialization is required here before creating search index or data source or indexer. await this.EnsureInitializedAsync(); if (string.IsNullOrEmpty(postId) || string.IsNullOrEmpty(postCreatedByuserId)) { return(null); } string partitionKeyCondition = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, postCreatedByuserId); string postIdCondition = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, postId); var combinedPartitionFilter = TableQuery.CombineFilters(partitionKeyCondition, TableOperators.And, postIdCondition); string isRemovedCondition = TableQuery.GenerateFilterConditionForBool(IsRemovedColumnName, QueryComparisons.Equal, false); var combinedFilter = TableQuery.CombineFilters(combinedPartitionFilter, TableOperators.And, isRemovedCondition); TableQuery <PostEntity> query = new TableQuery <PostEntity>().Where(combinedFilter); var queryResult = await this.GoodReadsCloudTable.ExecuteQuerySegmentedAsync(query, null); return(queryResult?.FirstOrDefault()); }
public static async Task <IActionResult> Run(HttpRequestMessage req, CloudTable summaryTable, string network, int take, int skip, TraceWriter log) { if (!ValidNetwork(network)) { return(new NotFoundObjectResult(Resources.NetworkNotFound)); } var tip = GetTableHeight(summaryTable); if (tip == null) { return(new NotFoundResult()); } var fromOffset = Math.Max(tip.Height - skip, 0); var toOffset = Math.Max(fromOffset - (take - 1), 0); var from = RowKeyHelper.HeightToString(fromOffset); var to = RowKeyHelper.HeightToString(toOffset); var partitionFilter = TableQuery.GenerateFilterCondition(PartitionKey, QueryComparisons.Equal, network.ToLowerInvariant()); var pageFilter = TableQuery.CombineFilters( TableQuery.GenerateFilterCondition(RowKey, QueryComparisons.GreaterThanOrEqual, from), TableOperators.And, TableQuery.GenerateFilterCondition(RowKey, QueryComparisons.LessThanOrEqual, to)); var pageQuery = new TableQuery() { FilterString = TableQuery.CombineFilters(partitionFilter, TableOperators.And, pageFilter), TakeCount = take }; var pageResult = await summaryTable.ExecuteQueryAsync(pageQuery); var results = pageResult.Select(e => new BlockSummaryModel(e)) .ToList(); return(new JsonPrettyResult(results)); }
public PathFinderEvents(string PatientID, string StartDate, string EndDate, string Skill, string StorageConnectionString) { events = new List <PathfinderEvent>(); TableQuery <EventEntity> query = new TableQuery <EventEntity>() .Where( TableQuery.CombineFilters( (TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, PatientID), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThanOrEqual, StartDate) )), TableOperators.And, (TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThanOrEqual, EndDate), TableOperators.And, TableQuery.GenerateFilterCondition("Skill", QueryComparisons.GreaterThanOrEqual, Skill) )) ) ); ExecuteQuery(query, StorageConnectionString); }
public async Task <T> GetSingleAsync(string partitionKey, string rowKey) { string key = string.Format("{0}:{1}:{2}", typeof(T).Name, partitionKey, rowKey); T entity = null; TableQuery <T> query = new TableQuery <T>().Where( TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, rowKey))); var tableSet = await table.ExecuteQuerySegmentedAsync(query, null); if (tableSet.Count <T>() >= 1) { entity = tableSet.First(); } return(entity); }
/// <summary> /// Gets all alerts matching the supplied search query /// </summary> /// <param name="query">The query.</param> /// <returns></returns> public async Task <IEnumerable <JobAlert> > GetAlerts(JobAlertsQuery query) { var table = _tableClient.GetTableReference(_alertsTable); await table.CreateIfNotExistsAsync(); var filter = TableQuery.GenerateFilterCondition("JobsSet", QueryComparisons.Equal, query.JobsSet.ToString()); if (!String.IsNullOrEmpty(query.EmailAddress)) { filter = TableQuery.CombineFilters(filter, TableOperators.And, TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, query.EmailAddress)); } if (query.Frequency.HasValue) { filter = TableQuery.CombineFilters(filter, TableOperators.And, TableQuery.GenerateFilterConditionForInt("Frequency", QueryComparisons.Equal, query.Frequency.Value)); } var tableQuery = new TableQuery <JobAlertTableEntity>().Where(filter); var results = await ReadAllResults(table, tableQuery, entity => BuildAlertFromEntity(entity)); return(results); }
/// <summary> /// Method to delete user mapping. /// </summary> /// <param name="partitionKey">The partition key.</param> /// <param name="rowKey">The row key.</param> /// <returns>boolean value that indicates delete success.</returns> public async Task <bool> DeleteMappedUserDetailsAsync(string partitionKey, string rowKey) { await this.EnsureInitializedAsync().ConfigureAwait(false); // Table query TableQuery <AllUserMappingEntity> deleteQuery = new TableQuery <AllUserMappingEntity>(); deleteQuery .Where(TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, rowKey))); // Results list List <AllUserMappingEntity> results = new List <AllUserMappingEntity>(); TableContinuationToken continuationToken = null; if (await this.userMappingCloudTable.ExistsAsync().ConfigureAwait(false)) { TableQuerySegment <AllUserMappingEntity> queryResults = await this.userMappingCloudTable.ExecuteQuerySegmentedAsync( deleteQuery, continuationToken).ConfigureAwait(false); continuationToken = queryResults.ContinuationToken; results = queryResults.Results; } var row = results.FirstOrDefault(); TableOperation delete = TableOperation.Delete(row); var result = await this.userMappingCloudTable.ExecuteAsync(delete).ConfigureAwait(false); if (result.HttpStatusCode == (int)HttpStatusCode.NoContent) { return(true); } return(false); }
/// <summary> /// Get activity ids. /// </summary> /// <param name="activityReferenceId">Unique GUID referencing to activity id.</param> /// <returns>Activity entity object.</returns> public async Task <IList <ActivityEntity> > GetAsync(string activityReferenceId) { await this.EnsureInitializedAsync().ConfigureAwait(false); string partitionKeyCondition = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, ActivityParitionKey); string rowKeyCondition = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, activityReferenceId); string condition = TableQuery.CombineFilters(partitionKeyCondition, TableOperators.And, rowKeyCondition); TableQuery <ActivityEntity> query = new TableQuery <ActivityEntity>().Where(condition); TableContinuationToken continuationToken = null; List <ActivityEntity> activities = new List <ActivityEntity>(); do { var queryResult = await this.cloudTable.ExecuteQuerySegmentedAsync(query, continuationToken).ConfigureAwait(false); activities.AddRange(queryResult.Results); continuationToken = queryResult.ContinuationToken; }while (continuationToken != null); return(activities); }