internal IEnumerable <object> ListItems(string path)
{
var result = AzureTablePathResolver.ResolvePath(this.Client, path);
switch (result.PathType)
{
case PathType.AzureTableRoot:
return(ListTables());
case PathType.AzureTableQuery:
return(ListEntities(result.Table, result.Query));
default:
return(null);
}
}
public override void RemoveItem(string path, bool recurse)
{
var r = AzureTablePathResolver.ResolvePath(this.Client, path);
if (r.Parts.Count == 1) //removing table
{
var table = this.Client.GetTableReference(r.Parts.Last());
table.Delete();
return;
}
else if (r.PathType != PathType.Invalid && r.Parts.Count > 1)
{
var entities = ListEntities(r.Table, r.Query);
foreach (var e in entities)
{
var o = TableOperation.Delete(e);
r.Table.Execute(o);
this.RootProvider.WriteWarning(string.Format("Entity {0} # {1} is removed.", e.PartitionKey, e.RowKey));
}
return;
}
if (r.PathType == PathType.Invalid)
{
var propertyName = Path.GetFileName(path);
var entityPath = PathResolver.GetParentPath(path);
r = AzureTablePathResolver.ResolvePath(this.Client, entityPath); //override path
var entities = ListEntities(r.Table, r.Query);
foreach (var e in entities)
{
if (e.Properties.ContainsKey(propertyName))
{
e.Properties.Remove(propertyName);
var o = TableOperation.Replace(e);
r.Table.Execute(o);
this.RootProvider.WriteWarning(string.Format("Entity {0} # {1} is updated.", e.PartitionKey, e.RowKey));
}
}
return;
}
this.RootProvider.WriteWarning("Nothing to do");
}
public override void GetChildNames(string path, ReturnContainers returnContainers)
{
var r = AzureTablePathResolver.ResolvePath(this.Client, path);
switch (r.PathType)
{
case PathType.AzureTableRoot:
var tables = ListTables();
foreach (var table in tables)
{
this.RootProvider.WriteItemObject(table.Name, path, true);
}
break;
default:
break;
}
}
public override bool IsItemContainer(string path)
{
var parts = PathResolver.SplitPath(path);
if (parts.Count == 0)
{
return(true);
}
try
{
var r = AzureTablePathResolver.ResolvePath(this.Client, path);
return(r.Exists());
}
catch (Exception)
{
return(false);
}
}
internal void CopyTo(string path, AzureTableServiceDriveInfo target, string copyPath, bool deleteOriginal = false)
{
var parts = PathResolver.SplitPath(path);
if (parts.Count == 0)
{
this.RootProvider.WriteWarning("Not supported to copy multiple tables.");
return;
}
var targetRef = AzureTablePathResolver.ResolvePath(target.Client, copyPath);
if (targetRef.PathType == PathType.AzureTableRoot)
{
this.RootProvider.WriteWarning("Must specify the target table.");
return;
}
var items = this.ListItems(path);
foreach (ITableEntity i in items)
{
var o = TableOperation.InsertOrReplace(i);
targetRef.Table.Execute(o);
this.RootProvider.WriteWarning(string.Format("Entity {0} # {1} is inserted", i.PartitionKey, i.RowKey));
}
if (deleteOriginal)
{
var sourceRef = AzureTablePathResolver.ResolvePath(this.Client, path);
foreach (ITableEntity i in items)
{
var o = TableOperation.Delete(i);
sourceRef.Table.Execute(o);
this.RootProvider.WriteWarning(string.Format("Source Entity {0} # {1} is deleted", i.PartitionKey, i.RowKey));
}
}
}
public override bool HasChildItems(string path)
{
var r = AzureTablePathResolver.ResolvePath(this.Client, path);
return(r.Exists());
}
/// <summary>
/// It creates a table or a table entity, or update table entities
/// </summary>
public override void NewItem(
string path,
string type,
object newItemValue)
{
var r = AzureTablePathResolver.ResolvePath(this.Client, path);
if (r.Parts.Count == 0)
{
this.RootProvider.WriteWarning("Nothing to create.");
return;
}
if (type == null)
{
type = string.Empty;
}
switch (type.ToLowerInvariant())
{
case "entity":
{
var keys = newItemValue as string;
if (keys == null || !keys.Contains("#"))
{
this.RootProvider.WriteWarning("It requires value formatted as <PartitionKey>#<RowKey>");
return;
}
var parts = keys.Split('#');
var pk = parts[0];
var rk = parts[1];
var e = new TableEntity(pk, rk);
var o = TableOperation.Insert(e);
r.Table.Execute(o);
break;
}
case "insertentity":
CreateEntity(r, newItemValue, TableOperation.Insert);
break;
case "replaceentity":
CreateEntity(r, newItemValue, TableOperation.Replace);
break;
case "mergeentity":
CreateEntity(r, newItemValue, TableOperation.Merge);
break;
case "insertorreplaceentity":
CreateEntity(r, newItemValue, TableOperation.InsertOrReplace);
break;
case "insertormergeentity":
CreateEntity(r, newItemValue, TableOperation.InsertOrMerge);
break;
case "sastoken":
{
var parts = PathResolver.SplitPath(path);
if (parts.Count > 0)
{
var tableName = parts[0];
var table = this.Client.GetTableReference(tableName);
var policyName = string.Empty;
var policy = CreateTablePermission(newItemValue as string, ref policyName);
if (policyName != string.Empty) //policy-based SAStoken
{
var token = table.GetSharedAccessSignature(policy, policyName);
this.RootProvider.WriteItemObject(token, path, false);
}
else
{
var token = table.GetSharedAccessSignature(policy);
this.RootProvider.WriteItemObject(token, path, false);
}
}
}
break;
case "policy":
{
var parts = PathResolver.SplitPath(path);
if (parts.Count > 0)
{
var tableName = parts[0];
var table = this.Client.GetTableReference(tableName);
var policyName = parts.Last();
var policyPlaceHolder = string.Empty;
var policy = CreateTablePermission(newItemValue as string, ref policyPlaceHolder);
var permissions = table.GetPermissions();
if (permissions.SharedAccessPolicies.ContainsKey(policyName))
{
if (!this.RootProvider.ShouldContinue(string.Format("Should continue to update existing policy {0}?", policyName), "Policy existed"))
{
this.RootProvider.WriteWarning("Cancelled");
return;
}
else
{
permissions.SharedAccessPolicies[policyName] = policy;
}
}
else
{
permissions.SharedAccessPolicies.Add(policyName, policy);
}
table.SetPermissions(permissions);
this.RootProvider.WriteWarning(string.Format("Policy {0} updated or added.", policyName));
}
}
break;
default:
if (r.Parts.Count == 1) //create a table
{
r.Table.Create();
this.RootProvider.WriteWarning("Table is created.");
}
else
{
UpdateEntities(path, type, newItemValue);
}
break;
}
}
private void UpdateEntities(string path, string type, object newItemValue)
{
//update existing entities
this.RootProvider.WriteWarning("update existing entities");
var propertyName = Path.GetFileName(path);
var entityPath = PathResolver.GetParentPath(path);
var r = AzureTablePathResolver.ResolvePath(this.Client, entityPath); //override path
var isNull = newItemValue == null;
var entities = this.ListEntities(r.Table, r.Query);
foreach (DynamicTableEntity e in entities)
{
if (isNull)
{
//removing the property and save
if (e.Properties.ContainsKey(propertyName))
{
e.Properties.Remove(propertyName);
var op = TableOperation.InsertOrReplace(e);
r.Table.Execute(op);
this.RootProvider.WriteWarning(string.Format("Property {2} is removed from entity {0} # {1}.", e.PartitionKey, e.RowKey, propertyName));
}
else
{
this.RootProvider.WriteWarning(string.Format("Skipping entity {0} # {1} is .", e.PartitionKey, e.RowKey));
}
continue;
}
//Type choice:
//0. if specified explicitly in type
//1. if there is existing property
//2. default to string
var targetType = EdmType.String;
if (!string.IsNullOrEmpty(type))
{
if (!Enum.TryParse <EdmType>(type, true, out targetType))
{
throw new Exception("Failed to parse type " + type + ", valid values are:" + string.Join(",", Enum.GetNames(typeof(EdmType))));
}
}
else if (e.Properties.ContainsKey(propertyName))
{
targetType = e.Properties[propertyName].PropertyType;
}
//Check property existence:
var existing = e.Properties.ContainsKey(propertyName);
//set value
switch (targetType)
{
case EdmType.String:
if (existing)
{
e.Properties[propertyName].StringValue = newItemValue.ToString();
}
else
{
var value = new EntityProperty(newItemValue.ToString());
e.Properties.Add(propertyName, value);
}
break;
case EdmType.Binary:
var bytes = newItemValue as byte[];
if (existing)
{
if (bytes != null)
{
e.Properties[propertyName].BinaryValue = bytes;
}
else
{
e.Properties[propertyName].BinaryValue = Utils.FromBase64(newItemValue.ToString());
}
}
else
{
if (bytes != null)
{
var value = new EntityProperty(bytes);
e.Properties.Add(propertyName, value);
}
else
{
var value = new EntityProperty(newItemValue.ToString());
e.Properties.Add(propertyName, value);
}
}
break;
case EdmType.Boolean:
var boolValue = true as bool?;
// Check target value:
// 1. the input value is a bool
// 2. the input value is a string, can be parsed to be a bool
if (newItemValue is bool)
{
boolValue = (bool)newItemValue;
}
else if (newItemValue is string)
{
var boolString = newItemValue as string;
var tempValue = true;
if (Boolean.TryParse(boolString, out tempValue))
{
boolValue = tempValue;
}
else
{
throw new Exception("Failed to parse boolean value " + boolString);
}
}
//set value
if (existing)
{
e.Properties[propertyName].BooleanValue = boolValue;
}
else
{
var value = new EntityProperty(boolValue);
e.Properties.Add(propertyName, value);
}
break;
case EdmType.DateTime:
var dateTime = null as DateTime?;
// Check target value:
// 1. the input value is a DateTime
// 2. the input value is a string, can be parsed to be a DateTime
if (newItemValue is DateTime)
{
dateTime = (DateTime)newItemValue;
}
else if (newItemValue is string)
{
var dateTimeString = newItemValue as string;
var tempDateTime = DateTime.Now;
if (DateTime.TryParse(dateTimeString, out tempDateTime))
{
dateTime = tempDateTime;
}
else
{
throw new Exception("Failed to parse DateTime value " + dateTimeString);
}
}
//set value
if (existing)
{
e.Properties[propertyName].DateTime = dateTime;
}
else
{
var value = new EntityProperty(dateTime);
e.Properties.Add(propertyName, value);
}
break;
case EdmType.Double:
var doubleValue = null as double?;
if (newItemValue is double)
{
doubleValue = (double)newItemValue;
}
else if (newItemValue is string)
{
var doubleString = newItemValue as string;
var tempValue = 0.0;
if (Double.TryParse(doubleString, out tempValue))
{
doubleValue = tempValue;
}
else
{
throw new Exception("Failed to parse double value " + doubleString);
}
}
//set value
if (existing)
{
e.Properties[propertyName].DoubleValue = doubleValue;
}
else
{
var value = new EntityProperty(doubleValue);
e.Properties.Add(propertyName, value);
}
break;
case EdmType.Guid:
var guidValue = null as Guid?;
if (newItemValue is Guid)
{
guidValue = (Guid)newItemValue;
}
else
{
var guidString = newItemValue as string;
var tempValue = Guid.NewGuid();
if (Guid.TryParse(guidString, out tempValue))
{
guidValue = tempValue;
}
else
{
throw new Exception("Failed to parse Guid value " + guidString);
}
}
//set value
if (existing)
{
e.Properties[propertyName].GuidValue = guidValue;
}
else
{
var value = new EntityProperty(guidValue);
e.Properties.Add(propertyName, value);
}
break;
case EdmType.Int32:
var int32Value = null as int?;
if (newItemValue is int)
{
int32Value = (int)newItemValue;
}
else
{
var int32String = newItemValue as string;
var tempValue = 0;
if (int.TryParse(int32String, out tempValue))
{
int32Value = tempValue;
}
else
{
throw new Exception("Failed to parse int32 value " + int32String);
}
}
//set value
if (existing)
{
e.Properties[propertyName].Int32Value = int32Value;
}
else
{
var value = new EntityProperty(int32Value);
e.Properties.Add(propertyName, value);
}
break;
case EdmType.Int64:
var int64Value = null as Int64?;
if (newItemValue is Int64)
{
int64Value = (Int64)newItemValue;
}
else
{
var int64String = newItemValue as string;
var tempValue = (Int64)0;
if (Int64.TryParse(int64String, out tempValue))
{
int64Value = tempValue;
}
else
{
throw new Exception("Failed to parse int64 value " + int64String);
}
}
//set value
if (existing)
{
e.Properties[propertyName].Int64Value = int64Value;
}
else
{
var value = new EntityProperty(int64Value);
e.Properties.Add(propertyName, value);
}
break;
} //end of switch
var o = TableOperation.Merge(e);
r.Table.Execute(o);
this.RootProvider.WriteWarning(string.Format("Entity {0} # {1} is merged.", e.PartitionKey, e.RowKey));
}
}