public async Task Delete()
{
var table = 'a' + Guid.NewGuid().ToString().ToLowerInvariant().Replace('-', 'a');
var localStorage = new TableStorage(table, TestHelpers.DevConnectionString);
var created = await localStorage.Create();
Assert.IsTrue(created);
await localStorage.Delete();
created = await localStorage.Create();
Assert.IsTrue(created);
await localStorage.Delete();
}
public void DeleteEntitiesNull()
{
var name = Guid.NewGuid().ToString();
var t = new TableStorage(name, ConnectionString);
Assert.That(() => t.Delete((IEnumerable <ITableEntity>)null), Throws.TypeOf <ArgumentNullException>());
}
public async Task ConstructorTableToSql()
{
var c = new ConfigValues()
{
StorageAccountConnection = "UseDevelopmentStorage=true;",
SqlConnection = "Server=localhost;Database=King.BTrak.Data;Trusted_Connection=True;",
SqlTableName = "TableData",
StorageTableName = "sqlserverdata",
Direction = Direction.TableToSql,
};
var tableName = "testsynctabletosql";
var table = new TableStorage(tableName, c.StorageAccountConnection);
await table.CreateIfNotExists();
var entity = new TableEntity
{
PartitionKey = Guid.NewGuid().ToString(),
RowKey = Guid.NewGuid().ToString(),
};
await table.InsertOrReplace(entity);
var s = new Synchronizer(c);
await s.Run();
await table.Delete();
var statement = string.Format("SELECT 1 AS [Exists] FROM [dbo].[TableData] WHERE TableName='{0}' AND PartitionKey = '{1}' AND RowKey = '{2}';", tableName, entity.PartitionKey, entity.RowKey);
var executor = new Executor(new SqlConnection(c.SqlConnection));
var ds = await executor.Query(statement);
var r = ds.Model<DataRow>();
Assert.IsNotNull(r);
Assert.IsTrue(r.Exists);
}
public async Task refreshCopyJobAsync()
{
TableStorage <CopyJob> copyJobTableStorage = new TableStorage <CopyJob>(masterStorageAccount, "jobs");
TableStorage <CopyJob> copyCompleteJobTableStorage = new TableStorage <CopyJob>(masterStorageAccount, "completejobs");
TableStorage <ReplicationStorageAccount> accountTableStorage = new TableStorage <ReplicationStorageAccount>(masterStorageAccount, "accounts");
List <ReplicationStorageAccount> accounts = await accountTableStorage.GetAllAsync();
List <Task> tasks = new List <Task>();
Parallel.ForEach <ReplicationStorageAccount>(accounts, async(account) =>
{
TableContinuationToken continuationToken = null;
TableQuery <CopyJob> query = new TableQuery <CopyJob>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, account.RowKey));
CloudStorageAccount targetStorageAccount = CloudStorageAccount.Parse(account.connectionString);
CloudBlobClient blobClient = targetStorageAccount.CreateCloudBlobClient();
do
{
var response = await copyJobTableStorage.table.ExecuteQuerySegmentedAsync(query, continuationToken);
continuationToken = response.ContinuationToken;
tasks.Add(Task.Run(async() =>
{
foreach (var job in response.Results)
{
CloudBlobContainer container = blobClient.GetContainerReference(job.targetContainer);
CloudBlockBlob blob = container.GetBlockBlobReference(job.targetBlobName);
await blob.FetchAttributesAsync();
CopyState state = blob.CopyState;
job.Update(state);
//log.Info($"Updated {job.copyId} - status {job.copyStatus}");
if (job.copyStatus == "Success")
{
try
{
await copyCompleteJobTableStorage.InsertOrReplaceAsync(job);
await copyJobTableStorage.Delete(job);
//log.Info($"Deleted completed job {job.copyId}");
}
catch (StorageException ex)
{
// log.Info($"Exception deleting CopyJob {job.copyId}: {ex.Message}");
}
}
else
{
await copyJobTableStorage.InsertOrReplaceAsync(job);
}
}
}));
}while (continuationToken != null);
});
Task.WaitAll(tasks.ToArray());
}
public async Task CreateIfNotExists()
{
var table = 'a' + Guid.NewGuid().ToString().ToLowerInvariant().Replace('-', 'a');
var storage = new TableStorage(table, ConnectionString);
var created = await storage.CreateIfNotExists();
Assert.IsTrue(created);
await storage.Delete();
}
public async Task <ActionResult> Delete(string row, MapEntity model)
{
MapEntity entity = await TableStorage.Get(MapEntity.MainKey, row);
try
{
await TableStorage.Delete(entity);
}
catch (StorageException error)
{
Task.Run(() => RavenClient.CaptureException(error));
return(this.AzureStorageErrorResponse(row, MapEntity.MainKey, error));
}
this.TempData["Alerts"] = AlertModel.CreateSingle(AlertType.Info, string.Format("{0} by {1} was deleted.", entity.Title, entity.Author));
return(this.RedirectToAction("Index"));
}
public async Task ConstructorTableToSql()
{
var c = new ConfigValues()
{
StorageAccountConnection = "UseDevelopmentStorage=true;",
SqlConnection = "Server=localhost;Database=King.BTrak.Data;Trusted_Connection=True;",
SqlTableName = "TableData",
StorageTableName = "sqlserverdata",
Direction = Direction.TableToSql,
};
var tableName = "testsynctabletosql";
var table = new TableStorage(tableName, c.StorageAccountConnection);
await table.CreateIfNotExists();
var entity = new TableEntity
{
PartitionKey = Guid.NewGuid().ToString(),
RowKey = Guid.NewGuid().ToString(),
};
await table.InsertOrReplace(entity);
var s = new Synchronizer(c);
await s.Run();
await table.Delete();
var statement = string.Format("SELECT 1 AS [Exists] FROM [dbo].[TableData] WHERE TableName='{0}' AND PartitionKey = '{1}' AND RowKey = '{2}';", tableName, entity.PartitionKey, entity.RowKey);
var executor = new Executor(new SqlConnection(c.SqlConnection));
var ds = await executor.Query(statement);
var r = ds.Model <DataRow>();
Assert.IsNotNull(r);
Assert.IsTrue(r.Exists);
}
public async Task <IActionResult> DeleteByEntry(BD_Product product)
{
return(Ok(await tableStorage.Delete(product, tableName)));
}
public void InsertUpdateAndDeleteSingleThread()
{
const string tableName = "myTable";
const string newTableName = "myNewTable";
TableStorage.CreateTable(tableName);
const int partitionCount = 10;
var entities =
Enumerable.Range(0, 100).Select(
i =>
new CloudEntity <object>
{
PartitionKey = "Pkey-" + (i % partitionCount).ToString("0"),
RowKey = "RowKey-" + i.ToString("00"),
Value = new object()
});
TableStorage.Insert(tableName, entities);
var isSucces = false;
try
{
TableStorage.Insert(
tableName, new[] { new CloudEntity <object> {
PartitionKey = "Pkey-6", RowKey = "RowKey-56"
} });
}
catch (Exception exception)
{
isSucces = (exception as InvalidOperationException) == null ? false : true;
}
Assert.IsTrue(isSucces);
TableStorage.CreateTable(newTableName);
TableStorage.Insert(
newTableName,
new[]
{ new CloudEntity <object> {
PartitionKey = "Pkey-6", RowKey = "RowKey-56", Value = new object()
} });
Assert.AreEqual(2, TableStorage.GetTables().Count());
TableStorage.Update(
newTableName,
new[] { new CloudEntity <object> {
PartitionKey = "Pkey-6", RowKey = "RowKey-56", Value = 2000
} },
true);
Assert.AreEqual(
2000, (int)TableStorage.Get <object>(newTableName, "Pkey-6", new[] { "RowKey-56" }).First().Value);
TableStorage.Delete <object>(newTableName, "Pkey-6", new[] { "RowKey-56" });
var retrieved = TableStorage.Get <object>(newTableName);
Assert.AreEqual(0, retrieved.Count());
}
public void Delete(object key)
{
storage.Delete(key);
}
