public async Task <int> SaveSuggestClausesAsync(IEnumerable <Clause> clauses)
{
if (clauses == null || clauses.Count() == 0)
{
return(0);
}
var tasks = clauses.Select(async clause =>
{
var newClause = new ClauseTableEntity(clause)
{
ETag = "*"
};
TableQuery <ClauseTableEntity> query = new TableQuery <ClauseTableEntity>()
.Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, newClause.PartitionKey));
var clauseEntities = await _clauseTableStorageClient.ExecuteQueryAsync(query);
// There is limitation of scalability for this implementation to increase the hit count because
// storage table don't have good support for concurrent write for the same entity.
TableOperation operation;
if (clauseEntities.Any())
{
newClause.HitCounter = clauseEntities.First().HitCounter + 1;
operation = TableOperation.Replace(newClause);
}
else
{
operation = TableOperation.Insert(newClause);
}
return(await _clauseTableStorageClient.ExecuteAsync(operation));
});
return((await Task.WhenAll(tasks)).Count());
}
public async Task <int> DeleteSuggestClausesAsync(IEnumerable <Clause> clauses)
{
if (clauses == null || clauses.Count() == 0)
{
return(0);
}
var tasks = clauses.Select(async c =>
{
var entity = new ClauseTableEntity(c)
{
ETag = "*"
};
return(await _clauseTableStorageClient.DoDeleteAsync(entity, BuildClauseFromEntity));
});
var results = await Task.WhenAll(tasks);
return(results.Where(r => r.Status == TableStorageResponseStatus.Successful).Count());
}
private Clause BuildClauseFromEntity(ClauseTableEntity entity)
{
if (entity == null)
{
return(null);
}
ClauseType clauseType;
try
{
Enum.TryParse(entity.ClauseType, out clauseType);
}
catch
{
clauseType = ClauseType.EQ;
}
TwinDataType clauseDataType;
try
{
Enum.TryParse(entity.ClauseDataType, out clauseDataType);
}
catch
{
clauseDataType = TwinDataType.String;
}
return(new Clause
{
ColumnName = entity.ColumnName,
ClauseType = clauseType,
ClauseValue = entity.ClauseValue,
ClauseDataType = clauseDataType,
});
}
