public string Get(string name, Guid sessionId) { var table = GetTableReference("users"); var container = GetBlobContainer("container"); TableQuery <User> query = new TableQuery <User>() .Where(TableQuery.GenerateFilterConditionForGuid("SessionId", QueryComparisons.Equal, sessionId)); var result = table.ExecuteQuery(query); var user = result.SingleOrDefault(); if (user == null) { return("Niepoprawne ID sesji."); } var blob = container.GetBlockBlobReference(name); if (blob == null) { return("Nie ma pliku o takiej nazwie."); } var s = new System.IO.MemoryStream(); blob.DownloadToStream(s); string content = System.Text.Encoding.UTF8.GetString(s.ToArray()); return(content); }
public static string Column(string columnName, Guid value, ColumnOperator op = ColumnOperator.Equal) { return(TableQuery.GenerateFilterConditionForGuid( columnName, ToQueryComparison(op), value)); }
/// <summary> /// Get the skip query. /// </summary> /// <returns>The skip query string.</returns> public string GetSkipQuery() { // Select the skip type. switch (typeof(T).Name.ToLower()) { case "system.boolean": case "boolean": case "bool": return(TableQuery.GenerateFilterConditionForBool( _skipPropertyName, QueryComparisons.GreaterThanOrEqual, (Boolean)Convert.ChangeType(_skipValue, typeof(Boolean)))); case "system.byte[]": case "byte[]": return(TableQuery.GenerateFilterConditionForBinary( _skipPropertyName, QueryComparisons.GreaterThanOrEqual, (Byte[])Convert.ChangeType(_skipValue, typeof(Byte[])))); case "system.datetimeoffset": case "datetimeoffset": return(TableQuery.GenerateFilterConditionForDate( _skipPropertyName, QueryComparisons.GreaterThanOrEqual, (DateTimeOffset)Convert.ChangeType(_skipValue, typeof(DateTimeOffset)))); case "system.double": case "double": return(TableQuery.GenerateFilterConditionForDouble( _skipPropertyName, QueryComparisons.GreaterThanOrEqual, (Double)Convert.ChangeType(_skipValue, typeof(Double)))); case "system.guid": case "guid": return(TableQuery.GenerateFilterConditionForGuid( _skipPropertyName, QueryComparisons.GreaterThanOrEqual, (Guid)Convert.ChangeType(_skipValue, typeof(Guid)))); case "system.int32": case "int32": case "int": return(TableQuery.GenerateFilterConditionForInt( _skipPropertyName, QueryComparisons.GreaterThanOrEqual, (Int32)Convert.ChangeType(_skipValue, typeof(Int32)))); case "system.int64": case "int64": case "long": return(TableQuery.GenerateFilterConditionForLong( _skipPropertyName, QueryComparisons.GreaterThanOrEqual, (Int64)Convert.ChangeType(_skipValue, typeof(Int64)))); case "system.string": case "string": return(TableQuery.GenerateFilterCondition( _skipPropertyName, QueryComparisons.GreaterThanOrEqual, (String)Convert.ChangeType(_skipValue, typeof(String)))); default: throw new Exception("The skip value type is not supported."); } }
/// <summary> /// Get async. /// </summary> /// <typeparam name="ST">The skip type.</typeparam> /// <param name="value">The value.</param> /// <param name="propertyName">The property name.</param> /// <param name="operation">The operation.</param> /// <param name="take">The number of items to return.</param> /// <param name="skip">The number of items to skip.</param> /// <returns>The array or items.</returns> public async Task <T[]> GetAsync <ST>(Guid value, string propertyName = "PartitionKey", string operation = QueryComparisons.Equal, int take = 100, SkipCount <ST> skip = null) { TableQuery <T> scanQuery = null; if (skip == null) { // Create the query. scanQuery = new TableQuery <T>().Where (TableQuery.GenerateFilterConditionForGuid(propertyName, operation, value)); } else { // Create the query. scanQuery = new TableQuery <T>().Where (TableQuery.CombineFilters( TableQuery.GenerateFilterConditionForGuid(propertyName, operation, value), TableOperators.And, skip.GetSkipQuery() )); } // Return the array return(await ScanAsyncEx(scanQuery, take)); }
public static string CreateAzureTableQueryPropertyFilter(string propertyName, object value, string queryComparison) { Assert.IsNotNull(value, "value != null"); // When DCA pushes data into Azure, if any property has a '.' in it, it is replaced by '_'. We are taking care of it // below while creating filter for query to Azure table. propertyName = propertyName.Replace('.', '_'); if (value.GetType() == typeof(Guid)) { if ((Guid)value != Guid.Empty) { return(TableQuery.GenerateFilterConditionForGuid(propertyName, queryComparison, (Guid)value)); } } if (value.GetType() == typeof(string)) { if ((string)value != null) { return(TableQuery.GenerateFilterCondition(propertyName, queryComparison, (string)value)); } } if (value.GetType() == typeof(int)) { return(TableQuery.GenerateFilterConditionForInt(propertyName, queryComparison, (int)value)); } if (value.GetType() == typeof(Int64)) { return(TableQuery.GenerateFilterConditionForLong(propertyName, queryComparison, (long)value)); } throw new ArgumentException(string.Format("Type {0} Not supported in Filter Creation", value.GetType())); }
/// <summary> /// Shortcut method that queries the table based on a given PartitionKey and given property with /// the same property name. Handles the continuation token scenario as well. Overloaded to accept /// all appropriate table entity types. /// </summary> /// <param name="partitionKey"></param> /// <param name="propertyName"></param> /// <param name="property"></param> /// <returns></returns> public async Task <List <TAzureTableEntity> > WherePropertyEqualsAsync(string partitionKey, string propertyName, Guid property) { var propertyFilter = TableQuery.GenerateFilterConditionForGuid(propertyName, QueryComparisons.Equal, property); var query = PartitionKeyAndPropertyFilterQuery(partitionKey, propertyFilter); return(await RunQuerySegmentAsync(query).ConfigureAwait(false)); }
/// <summary> /// Shortcut method that queries the table based on a given PartitionKey and given property with /// the same property name. Handles the continuation token scenario as well. Overloaded to accept /// all appropriate table entity types. /// </summary> /// <param name="partitionKey"></param> /// <param name="propertyName"></param> /// <param name="property"></param> /// <returns></returns> public IEnumerable <TAzureTableEntity> WherePropertyEquals(string partitionKey, string propertyName, Guid property) { var propertyFilter = TableQuery.GenerateFilterConditionForGuid(propertyName, QueryComparisons.Equal, property); var query = PartitionKeyAndPropertyFilterQuery(partitionKey, propertyFilter); return(RunQuerySegment(query)); }
/// <summary> /// Converts the filters to table query. /// </summary> /// <param name="filters">The filters.</param> /// <returns>returns filter string.</returns> public string ConvertFiltersToTableQuery(object filters) { var finalQuery = string.Empty; if (filters == null) { return(finalQuery); } PropertyDescriptorCollection props = TypeDescriptor.GetProperties(filters); foreach (PropertyDescriptor prop in props) { var filterQuery = string.Empty; if (prop.PropertyType == typeof(bool)) { filterQuery = TableQuery.GenerateFilterConditionForBool(prop.Name, QueryComparisons.Equal, (bool)prop.GetValue(filters)); } else if (prop.PropertyType == typeof(DateTime)) { filterQuery = TableQuery.GenerateFilterConditionForDate(prop.Name, QueryComparisons.Equal, (DateTime)prop.GetValue(filters)); } else if (prop.PropertyType == typeof(double)) { filterQuery = TableQuery.GenerateFilterConditionForDouble(prop.Name, QueryComparisons.Equal, (double)prop.GetValue(filters)); } else if (prop.PropertyType == typeof(int)) { filterQuery = TableQuery.GenerateFilterConditionForInt(prop.Name, QueryComparisons.Equal, (int)prop.GetValue(filters)); } else if (prop.PropertyType == typeof(long)) { filterQuery = TableQuery.GenerateFilterConditionForLong(prop.Name, QueryComparisons.Equal, (long)prop.GetValue(filters)); } else if (prop.PropertyType == typeof(Guid)) { filterQuery = TableQuery.GenerateFilterConditionForGuid(prop.Name, QueryComparisons.Equal, (Guid)prop.GetValue(filters)); } else { filterQuery = TableQuery.GenerateFilterCondition(prop.Name, QueryComparisons.Equal, (string)prop.GetValue(filters)); } if (string.IsNullOrEmpty(finalQuery)) { finalQuery = filterQuery; } else { finalQuery = TableQuery.CombineFilters(finalQuery, TableOperators.And, filterQuery); } } return(finalQuery); }
protected override string GenerateFilterConditionFor(Comparisons comparison, Guid value) { if (QueryParameter.ContextValue.Comparison == Comparisons.Equal) { // ReSharper disable once PossibleInvalidOperationException return(TableQuery.GenerateFilterConditionForGuid(QueryParameter.MemberModel.Member.Name, QueryComparisons.Equal, value)); } return(null); }
/// <summary> /// Get async. /// </summary> /// <param name="value">The value.</param> /// <param name="propertyName">The property name.</param> /// <param name="operation">The operation.</param> /// <param name="take">The number of items to return.</param> /// <returns>The array or items.</returns> public async Task <T[]> GetAsync(Guid value, string propertyName = "PartitionKey", string operation = QueryComparisons.Equal, int take = 100) { // Create the query. TableQuery <T> scanQuery = new TableQuery <T>().Where (TableQuery.GenerateFilterConditionForGuid(propertyName, operation, value)); // Return the array return(await ScanAsyncEx(scanQuery, take)); }
private async Task <IEnumerable <QuestionEntity> > GetPlayerQuestionEntities(Guid playerId) { var table = _tableClient.GetTableReference(TableNames.Player); TableQuery <QuestionEntity> questionsForPlayerQuery = new TableQuery <QuestionEntity>().Where( TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, PartitionKeys.Question), TableOperators.And, TableQuery.GenerateFilterConditionForGuid("PlayerId", QueryComparisons.Equal, playerId))); return(await table.ExecuteQueryAsync(questionsForPlayerQuery)); }
public async Task <IEnumerable <SourcedEvent> > ReadEvents(string aggregateId, Guid cmdId) { var tableQuery = new TableQuery <TableEventModel>().Where( TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, aggregateId), TableOperators.And, TableQuery.GenerateFilterConditionForGuid("CommandId", QueryComparisons.GreaterThanOrEqual, cmdId) )); return(await PullEvents(tableQuery)); }
private async Task <RefreshTokenEntity> GetRefreshTokenEntity(Guid refreshToken) { var workTimeTable = await _tableHelper.GetTable(); var tableQuery = new TableQuery <RefreshTokenEntity>() .Where(TableQuery.GenerateFilterConditionForGuid(nameof(RefreshTokenEntity.RefreshToken), QueryComparisons.Equal, refreshToken)); var entities = await workTimeTable.ExecuteQueryFull(tableQuery); return(entities.Single()); }
public async Task <bool> DeletePlayerQuestions(Guid playerGuidId) { var table = _tableClient.GetTableReference(TableNames.Player); TableQuery <DynamicTableEntity> questionsForPlayerQuery = new TableQuery <DynamicTableEntity>() .Where(TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, PartitionKeys.Question), TableOperators.And, TableQuery.GenerateFilterConditionForGuid("PlayerId", QueryComparisons.Equal, playerGuidId))) .Select(new string[] { "PartitionKey", "RowKey" }); return(await DeleteEntities(await table.ExecuteQueryAsync(questionsForPlayerQuery))); }
public async Task <Cat> GetBySecondaryId(Guid id) { var query = new TableQuery <Cat>().Where( TableQuery.GenerateFilterConditionForGuid( nameof(Cat.SecondaryId), QueryComparisons.Equal, id)); var entities = await ExecuteQuery <Cat>(query); return(entities.FirstOrDefault()); }
public static Task <IList <TEntity> > QueryByField <TEntity>(this CloudTable table, string field, Guid value) where TEntity : ITableEntity, new() { if (string.IsNullOrWhiteSpace(field)) { throw new ArgumentNullException(nameof(field)); } var filter = TableQuery.GenerateFilterConditionForGuid(field, QueryComparisons.Equal, value); return(Query(table, new TableQuery <TEntity>().Where(filter))); }
public async Task <IEnumerable <ScorecardInfo> > GetScorecardsAsync(ScorecardsQueryOptions options) { // If there's no options get all the player's scorecards. if (options == null || (options.CourseId == null && options.From == null && options.To == null)) { return(await GetPlayersEntitiesAsync <ScorecardInfo>(options.PlayerId)); } var filterConditions = new List <string>(); filterConditions.Add(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, options.PlayerId)); // Add CourseId filter if applicable. if (options.CourseId != null && options.CourseId != Guid.Empty) { filterConditions.Add(TableQuery.GenerateFilterConditionForGuid("CourseId", QueryComparisons.Equal, options.CourseId.Value)); } // Add From filter if applicable. if (options.From != null) { filterConditions.Add(TableQuery.GenerateFilterConditionForDate("Date", QueryComparisons.GreaterThanOrEqual, options.From.Value)); } // Add To filter if applicable. if (options.To != null) { filterConditions.Add(TableQuery.GenerateFilterConditionForDate("Date", QueryComparisons.LessThanOrEqual, options.To.Value)); } // Build the query. var query = new TableQuery <ScorecardInfoTableEntity>(); string filter = null; if (filterConditions.Count == 1) { filter = filterConditions.First(); } else { filter = TableQuery.CombineFilters(filterConditions[0], TableOperators.And, filterConditions[1]); for (int i = 2; i < filterConditions.Count; i++) { filter = TableQuery.CombineFilters(filter, TableOperators.And, filterConditions[i]); } } query = query.Where(filter); // Execute the query and return ScorecardInfo data. var entities = await Options.GetCloudTable(nameof(ScorecardInfo)).ExecuteTableQueryAsync(query); return(entities.Select(e => JsonConvert.DeserializeObject <ScorecardInfo>(e.Data)).OrderBy(s => s.Date)); }
DictionaryTableEntity GetDictionaryTableEntity(Type type, string property, object value) { var tableName = type.Name; var table = client.GetTableReference(tableName); TableQuery <DictionaryTableEntity> query; var propertyInfo = type.GetProperty(property); if (propertyInfo.PropertyType == typeof(byte[])) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForBinary(property, QueryComparisons.Equal, (byte[])value)); } else if (propertyInfo.PropertyType == typeof(bool)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForBool(property, QueryComparisons.Equal, (bool)value)); } else if (propertyInfo.PropertyType == typeof(DateTime)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForDate(property, QueryComparisons.Equal, (DateTime)value)); } else if (propertyInfo.PropertyType == typeof(Guid)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForGuid(property, QueryComparisons.Equal, (Guid)value)); } else if (propertyInfo.PropertyType == typeof(Int32)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForInt(property, QueryComparisons.Equal, (int)value)); } else if (propertyInfo.PropertyType == typeof(Int64)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForLong(property, QueryComparisons.Equal, (long)value)); } else if (propertyInfo.PropertyType == typeof(Double)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForDouble(property, QueryComparisons.Equal, (double)value)); } else if (propertyInfo.PropertyType == typeof(string)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterCondition(property, QueryComparisons.Equal, (string)value)); } else { throw new NotSupportedException( string.Format("The property type '{0}' is not supported in windows azure table storage", propertyInfo.PropertyType.Name)); } var tableEntity = table.ExecuteQuery(query).SafeFirstOrDefault(); return(tableEntity); }
private async Task DeleteQuestionsByExamId(Guid id) { var questions = await _context.GetListAsync(new TableQuery <AtsQuestion>() .Where(TableQuery.GenerateFilterCondition(nameof(AtsQuestion.PartitionKey), QueryComparisons.Equal, AtsExamsContext.QuestionsPartitionKey)) .Where(TableQuery.GenerateFilterConditionForGuid(nameof(AtsQuestion.ExamId), QueryComparisons.Equal, id)) ); if (questions.Count > 0) { var batch = new TableBatchOperation(); questions.ForEach(x => batch.Delete(x)); await _context.Table.ExecuteBatchAsync(batch); } }
public static TableQuery <DictionaryTableEntity> BuildWherePropertyQuery(Type type, string property, object value) { TableQuery <DictionaryTableEntity> query; var propertyInfo = type.GetProperty(property); if (propertyInfo == null) { return(null); } if (propertyInfo.PropertyType == typeof(byte[])) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForBinary(property, QueryComparisons.Equal, (byte[])value)); } else if (propertyInfo.PropertyType == typeof(bool)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForBool(property, QueryComparisons.Equal, (bool)value)); } else if (propertyInfo.PropertyType == typeof(DateTime)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForDate(property, QueryComparisons.Equal, (DateTime)value)); } else if (propertyInfo.PropertyType == typeof(Guid)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForGuid(property, QueryComparisons.Equal, (Guid)value)); } else if (propertyInfo.PropertyType == typeof(int)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForInt(property, QueryComparisons.Equal, (int)value)); } else if (propertyInfo.PropertyType == typeof(long)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForLong(property, QueryComparisons.Equal, (long)value)); } else if (propertyInfo.PropertyType == typeof(double)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForDouble(property, QueryComparisons.Equal, (double)value)); } else if (propertyInfo.PropertyType == typeof(string)) { query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterCondition(property, QueryComparisons.Equal, (string)value)); } else { throw new NotSupportedException($"The property type '{propertyInfo.PropertyType.Name}' is not supported in Azure Table Storage"); } return(query); }
public async Task <ITable> Retrieve(DbTableSchema dbTableSchema, Guid id) { var client = _clientFactory.CreateCloudTableClient(); var table = client.GetTableReference(dbTableSchema.TableName); await CreateTableIfNotExistsAsync(dbTableSchema, table); var condition = TableQuery.GenerateFilterConditionForGuid("RowKey", QueryComparisons.Equal, id); var allColumns = dbTableSchema.Columns.Select(x => x.ColumnName).ToList(); TableQuery <DynamicTableEntity> projectionQuery = new TableQuery <DynamicTableEntity>().Select(allColumns).Where(condition); var tableResult = await FetchResults(dbTableSchema, table, projectionQuery); return(tableResult); }
private string GenerateFilterCondition(string key, object value) { if (value is string) { return(TableQuery.GenerateFilterCondition(key, QueryComparisons.Equal, (string)value)); } if (value is Guid) { return(TableQuery.GenerateFilterConditionForGuid(key, QueryComparisons.Equal, (Guid)value)); } if (value is byte || value is short || value is int) { return(TableQuery.GenerateFilterConditionForInt(key, QueryComparisons.Equal, (int)value)); } if (value is long) { return(TableQuery.GenerateFilterConditionForLong(key, QueryComparisons.Equal, (long)value)); } if (value is bool) { return(TableQuery.GenerateFilterConditionForBool(key, QueryComparisons.Equal, (bool)value)); } if (value is DateTimeOffset) { return(TableQuery.GenerateFilterConditionForDate(key, QueryComparisons.Equal, (DateTimeOffset)value)); } if (value is DateTime) { return(TableQuery.GenerateFilterConditionForDate(key, QueryComparisons.Equal, new DateTimeOffset((DateTime)value))); } if (value is float || value is double) { return(TableQuery.GenerateFilterConditionForDouble(key, QueryComparisons.Equal, (double)value)); } throw new NotSupportedException(); }
protected override string ExpressionFilterConverter(IFilterExpression <T> expression) { if (expression.PropertyType == typeof(byte[])) { return(TableQuery.GenerateFilterConditionForBinary(expression.PropertyName, GetInstruction(expression.Comparator), (byte[])expression.PropertyValue)); } if (expression.PropertyType == typeof(bool) || expression.PropertyType == typeof(bool?)) { return(TableQuery.GenerateFilterConditionForBool(expression.PropertyName, GetInstruction(expression.Comparator), (bool)expression.PropertyValue)); } if (expression.PropertyType == typeof(DateTime) || expression.PropertyType == typeof(DateTime?)) { return(TableQuery.GenerateFilterConditionForDate(expression.PropertyName, GetInstruction(expression.Comparator), (DateTime)expression.PropertyValue)); } if (expression.PropertyType == typeof(DateTimeOffset) || expression.PropertyType == typeof(DateTimeOffset?)) { return(TableQuery.GenerateFilterConditionForDate(expression.PropertyName, GetInstruction(expression.Comparator), (DateTimeOffset)expression.PropertyValue)); } if (expression.PropertyType == typeof(double) || expression.PropertyType == typeof(double?)) { return(TableQuery.GenerateFilterConditionForDouble(expression.PropertyName, GetInstruction(expression.Comparator), (double)expression.PropertyValue)); } if (expression.PropertyType == typeof(Guid) || expression.PropertyType == typeof(Guid?)) { return(TableQuery.GenerateFilterConditionForGuid(expression.PropertyName, GetInstruction(expression.Comparator), (Guid)expression.PropertyValue)); } if (expression.PropertyType == typeof(int) || expression.PropertyType == typeof(int?)) { return(TableQuery.GenerateFilterConditionForInt(expression.PropertyName, GetInstruction(expression.Comparator), (int)expression.PropertyValue)); } if (expression.PropertyType == typeof(long) || expression.PropertyType == typeof(long?)) { return(TableQuery.GenerateFilterConditionForLong(expression.PropertyName, GetInstruction(expression.Comparator), (long)expression.PropertyValue)); } return(TableQuery.GenerateFilterCondition(expression.PropertyName, GetInstruction(expression.Comparator), expression.PropertyValue?.ToString() ?? string.Empty)); }
public string GenerateFilter(string propertyName, object propertyValue, string operatorString) { var propertyType = propertyValue.GetType(); if (propertyType == typeof(string)) { return(TableQuery.GenerateFilterCondition(propertyName, operatorString, propertyValue as string)); } if (propertyType == typeof(DateTime)) { return(TableQuery.GenerateFilterConditionForDate(propertyName, operatorString, (DateTime)propertyValue)); } if (propertyType == typeof(bool)) { return(TableQuery.GenerateFilterConditionForBool(propertyName, operatorString, (bool)propertyValue)); } if (propertyType == typeof(double)) { return(TableQuery.GenerateFilterConditionForDouble(propertyName, operatorString, (double)propertyValue)); } if (propertyType == typeof(int)) { return(TableQuery.GenerateFilterConditionForInt(propertyName, operatorString, (int)propertyValue)); } if (propertyType == typeof(long)) { return(TableQuery.GenerateFilterConditionForLong(propertyName, operatorString, (long)propertyValue)); } if (propertyType == typeof(Guid)) { return(TableQuery.GenerateFilterConditionForGuid(propertyName, operatorString, (Guid)propertyValue)); } return(propertyType == typeof(byte[]) ? TableQuery.GenerateFilterConditionForBinary(propertyName, operatorString, (byte[])propertyValue) : TableQuery.GenerateFilterCondition(propertyName, operatorString, propertyValue.ToString())); }
public static IEnumerableAsync <Adapter> FindAll(Guid integrationId, string resourceType) { if (resourceType.IsNullOrWhiteSpace()) { return(EnumerableAsync.Empty <Adapter>()); } return(AzureStorageRepository.Connection( azureStorageRepository => { var whereIntegrationQuery = TableQuery.GenerateFilterConditionForGuid("IntegrationId", QueryComparisons.Equal, integrationId); var whereResourceTypeQuery = TableQuery.GenerateFilterCondition("ResourceType", QueryComparisons.Equal, resourceType); var whereQuery = TableQuery.CombineFilters(whereIntegrationQuery, TableOperators.And, whereResourceTypeQuery); var adapterQuery = new TableQuery <AdapterDocument>().Where(whereQuery); return azureStorageRepository .FindAllAsync(adapterQuery) .Select(Convert); })); }
public static string WhereExpression(this ExpressionType comparision, string assignmentName, object assignmentValue) { var queryComparison = comparision.ExpressionTypeToQueryComparison(); if (typeof(Guid?).IsInstanceOfType(assignmentValue)) { TableQuery.GenerateFilterConditionForGuid(assignmentName, queryComparison, (assignmentValue as Guid?).Value); } if (typeof(Guid).IsInstanceOfType(assignmentValue)) { return(TableQuery.GenerateFilterConditionForGuid(assignmentName, queryComparison, (Guid)assignmentValue)); } if (typeof(IReferenceable).IsInstanceOfType(assignmentValue)) { return(TableQuery.GenerateFilterConditionForGuid(assignmentName, queryComparison, ((IReferenceable)assignmentValue).id)); } if (typeof(bool).IsInstanceOfType(assignmentValue)) { return(TableQuery.GenerateFilterConditionForBool(assignmentName, queryComparison, (bool)assignmentValue)); } if (typeof(DateTime).IsInstanceOfType(assignmentValue)) { return(TableQuery.GenerateFilterConditionForDate(assignmentName, queryComparison, (DateTime)assignmentValue)); } if (typeof(int).IsInstanceOfType(assignmentValue)) { return(TableQuery.GenerateFilterConditionForInt(assignmentName, queryComparison, (int)assignmentValue)); } if (typeof(string).IsInstanceOfType(assignmentValue)) { return(TableQuery.GenerateFilterCondition(assignmentName, queryComparison, (string)assignmentValue)); } throw new NotImplementedException($"No filter condition created for type {assignmentValue.GetType().FullName}"); }
public IEnumerable <ITableEntity> RetrieveByDisplayIds(string type, List <Guid> displayIds) { var table = _tableClient.GetTableReference(type); string whereTotal = ""; foreach (var displayId in displayIds) { var where = TableQuery.GenerateFilterConditionForGuid("DisplayId", QueryComparisons.Equal, displayId); if (whereTotal.Length > 0) { whereTotal = TableQuery.CombineFilters(whereTotal, TableOperators.Or, where); } else { whereTotal = where; } } return(ExecuteTableQuery(type, table, whereTotal)); }
public bool Put(string name, string content, Guid sessionId) { var table = GetTableReference("users"); var container = GetBlobContainer("container"); TableQuery <User> query = new TableQuery <User>() .Where(TableQuery.GenerateFilterConditionForGuid("SessionId", QueryComparisons.Equal, sessionId)); var result = table.ExecuteQuery(query); var user = result.SingleOrDefault(); if (user == null) { return(false); } var blob = container.GetBlockBlobReference(name); var bytes = new System.Text.ASCIIEncoding().GetBytes(content); var s = new System.IO.MemoryStream(bytes); blob.UploadFromStream(s); return(true); }
public async Task <int> DeleteByDisplayId(string type, Guid displayId) { var table = _tableClient.GetTableReference(type); await table.CreateIfNotExistsAsync(); var ret = 0; IEnumerable <ITableEntity> found = null; found = ExecuteTableQuery(type, table, TableQuery.GenerateFilterConditionForGuid("DisplayId", QueryComparisons.Equal, displayId)); if (found != null) { foreach (var item in found) { TableOperation op = TableOperation.Delete(item); var result = await table.ExecuteAsync(op); ret = result.HttpStatusCode; } } return(ret); }
static string GenerateFilterCondition(BinaryExpression binary) { var left = binary.Left as MemberExpression; if (left == null) { throw new InvalidOperationException(); } var op = ToComparisonOperator(binary.NodeType); var rightValue = binary.Right.Invoke(); return (left.Type == typeof(byte[]) ? TableQuery.GenerateFilterConditionForBinary(left.Member.Name, op, (byte[])rightValue) : left.Type == typeof(bool) ? TableQuery.GenerateFilterConditionForBool(left.Member.Name, op, (bool)rightValue) : left.Type == typeof(DateTime) ? TableQuery.GenerateFilterConditionForDate(left.Member.Name, op, (DateTime)rightValue) : left.Type == typeof(DateTimeOffset) ? TableQuery.GenerateFilterConditionForDate(left.Member.Name, op, (DateTimeOffset)rightValue) : left.Type == typeof(double) ? TableQuery.GenerateFilterConditionForDouble(left.Member.Name, op, (double)rightValue) : left.Type == typeof(Guid) ? TableQuery.GenerateFilterConditionForGuid(left.Member.Name, op, (Guid)rightValue) : left.Type == typeof(int) ? TableQuery.GenerateFilterConditionForInt(left.Member.Name, op, (int)rightValue) : left.Type == typeof(long) ? TableQuery.GenerateFilterConditionForLong(left.Member.Name, op, (long)rightValue) : TableQuery.GenerateFilterCondition(left.Member.Name, op, rightValue.To <string>())); }