/// <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);
}
