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