// GET: api/v1/namecache/list/1
public async Task <HttpResponseMessage> GetNameList(NameCacheEntityType type)
{
return(await GetServiceResponseAsync <IEnumerable <NameCacheEntity> >(async() =>
{
return await _nameCacheLogic.GetNameListAsync(type);
}));
}
/// <summary>
/// Delete an existing name from repository.
/// </summary>
/// <param name="entityType"></param>
/// <param name="name"></param>
/// <returns>true if succeeded, false if failed.</returns>
public async Task <bool> DeleteNameAsync(NameCacheEntityType entityType, string name)
{
CheckSingleEntityType(entityType);
NameCacheTableEntity tableEntity = new NameCacheTableEntity(entityType, name);
tableEntity.ETag = "*";
var result = await _azureTableStorageClient.DoDeleteAsync <NameCacheEntity, NameCacheTableEntity>(tableEntity, BuildNameCacheFromTableEntity);
return(result.Status == TableStorageResponseStatus.Successful);
}
/// <summary>
/// Save a new name into the repository. Update it if it already exists.
/// </summary>
/// <param name="name"></param>
/// <returns>true if succeeded, false if failed.</returns>
public async Task <bool> AddNameAsync(NameCacheEntityType entityType, NameCacheEntity entity)
{
CheckSingleEntityType(entityType);
NameCacheTableEntity tableEntity = new NameCacheTableEntity(entityType, entity.Name);
tableEntity.MethodParameters = JsonConvert.SerializeObject(entity.Parameters);
tableEntity.MethodDescription = entity.Description;
tableEntity.ETag = "*";
var result = await _azureTableStorageClient.DoTableInsertOrReplaceAsync <NameCacheEntity, NameCacheTableEntity>(tableEntity, BuildNameCacheFromTableEntity);
return(result.Status == TableStorageResponseStatus.Successful);
}
private void CheckSingleEntityType(NameCacheEntityType entityType)
{
if (entityType == NameCacheEntityType.DeviceInfo ||
entityType == NameCacheEntityType.Tag ||
entityType == NameCacheEntityType.DesiredProperty ||
entityType == NameCacheEntityType.ReportedProperty ||
entityType == NameCacheEntityType.Method)
{
return;
}
throw new ArgumentException("Can only pick up one of the flags: DeviceInfo, Tag, DesiredProperty, ReportedProperty, Method");
}
public async Task AddShortNamesAsync(NameCacheEntityType type, IEnumerable <string> shortNames)
{
var names = shortNames.Select(s =>
{
switch (type)
{
case NameCacheEntityType.Tag: return(PREFIX_TAGS + s);
case NameCacheEntityType.DesiredProperty: return(PREFIX_DESIRED + s);
case NameCacheEntityType.ReportedProperty: return(PREFIX_REPORTED + s);
default: throw new ArgumentOutOfRangeException();
}
}).ToList();
await _nameCacheRepository.AddNamesAsync(type, names);
}
/// <summary>
/// Add a set of names in batch
/// Reminder: Considering it will be called periodically to update the cache, it was
/// not designed as a realiable routine to reduce complexity
/// </summary>
/// <param name="entityType">Type of adding names</param>
/// <param name="names">Names to be added</param>
/// <returns>The asychornize task</returns>
public async Task AddNamesAsync(NameCacheEntityType entityType, IEnumerable <string> names)
{
CheckSingleEntityType(entityType);
var operations = names.Select(name => TableOperation.InsertOrReplace(new NameCacheTableEntity(entityType, name)
{
MethodParameters = "null", // [WORKAROUND] Existing code requires "null" rather than null for tag or properties
ETag = "*"
}));
while (operations.Any())
{
var batch = new TableBatchOperation();
operations.Take(MaxBatchSize).ToList().ForEach(op => batch.Add(op));
await _azureTableStorageClient.ExecuteBatchAsync(batch);
operations = operations.Skip(MaxBatchSize);
}
}
/// <summary>
/// Get name list for combined NameCacheEntityType flags
/// </summary>
/// <param name="entityType"></param>
/// <returns>a list of combined names</returns>
public async Task <IEnumerable <NameCacheEntity> > GetNameListAsync(NameCacheEntityType entityType)
{
List <string> filters = new List <string>();
var flags = Enum.GetValues(typeof(NameCacheEntityType));
foreach (NameCacheEntityType flag in flags)
{
if (entityType.HasFlag(flag) && flag != NameCacheEntityType.All && flag != NameCacheEntityType.Property)
{
var condition = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, flag.ToString());
filters.Add(condition);
}
}
TableQuery <NameCacheTableEntity> query = new TableQuery <NameCacheTableEntity>().Where(string.Join(" or ", filters));
var entities = await _azureTableStorageClient.ExecuteQueryAsync(query);
return(entities.OrderBy(e => e.PartitionKey).ThenBy(e => e.RowKey).
Select(e => new NameCacheEntity
{
Name = e.Name,
Parameters = JsonConvert.DeserializeObject <List <Parameter> >(e.MethodParameters),
Description = e.MethodDescription,
}));
}
public async Task <IEnumerable <NameCacheEntity> > GetNameListAsync(NameCacheEntityType type)
{
var namelist = await _nameCacheRepository.GetNameListAsync(type);
return(namelist.Where(n => !n.Name.IsReservedTwinName()));
}
public NameCacheTableEntity(NameCacheEntityType entityType, string name)
{
this.PartitionKey = entityType.ToString();
this.RowKey = name;
}
