public static async Task InsertInTable(Microsoft.WindowsAzure.Storage.Table.TableEntity newEntity, string tableName)
{
var table = await GetTable(tableName);
var insertOperation = Microsoft.WindowsAzure.Storage.Table.TableOperation.Insert(newEntity);
await table.ExecuteAsync(insertOperation);
}
public static async Task DeleteFromTable(Microsoft.WindowsAzure.Storage.Table.TableEntity newEntity, string tableName)
{
var table = await GetTable(tableName);
var deleteOperation = Microsoft.WindowsAzure.Storage.Table.TableOperation.Delete(newEntity);
await table.ExecuteAsync(deleteOperation);
}
public ActionResult Index()
{
var tableClient = _storageAccount.CreateCloudTableClient();
var indicesTable = tableClient.GetTableReference(StorageNames.BenchmarksTable);
IEnumerable<TableEntity> benchmarks;
if (indicesTable.Exists())
{
var query = new TableQuery<TableEntity>()
.Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "index"));
benchmarks = indicesTable.ExecuteQuery(query);
}
else
{
benchmarks = new TableEntity[0];
}
ViewerModel model = new ViewerModel()
{
Benchmarks = benchmarks.Select(r => r.RowKey)
};
return View(model);
}
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);
}
/// <summary>
/// creates and save the azure table to azure table storage.
/// </summary>
/// <typeparam name="T">Table Type name</typeparam>
/// <param name="tableName">azure table name</param>
/// <param name="AzureTable">Azure Table object</param>
public void SaveToTable(string tableName, TableEntity AzureTable)
{
if (storageAccount == null)
throw new NullReferenceException("Storage Account is null please check constructor.");
CloudTable table = getTable(tableName);
TableOperation insertOperation = TableOperation.Insert(AzureTable);
table.Execute(insertOperation);
}
public static void AddToQueue(ToDoTask task)
{
var taskEntity = new TableEntity()
{
PartitionKey = task.Id.ToString(CultureInfo.InvariantCulture),
RowKey = string.Format("{0:D19}",task.Due.Ticks)
};
TodoTaskTable.Execute(TableOperation.Insert(taskEntity));
}
public TableResult AddItemToTable(TableEntity item)
{
// Create the table client.
CloudTableClient tableClient = _storageAccount.CreateCloudTableClient();
// Create the CloudTable object that represents the "people" table.
CloudTable table = tableClient.GetTableReference(_tableName);
// Create the TableOperation that inserts the customer entity.
TableOperation insertOperation = TableOperation.Insert(item);
// Execute the insert operation.
return table.Execute(insertOperation);
}
/// <summary>
/// Insert or Replaces the azure table to azure table storage.
/// </summary>
/// <param name="tableName">azure table name</param>
/// <param name="AzureTable">table object</param>
public void UpdateToTable(string tableName, TableEntity AzureTable)
{
if (storageAccount == null)
throw new NullReferenceException("Storage Account is null please check constructor.");
try
{
CloudTable table = getTable(tableName);
TableOperation updateOperation = TableOperation.InsertOrReplace(AzureTable);
table.Execute(updateOperation);
}
catch (Exception ex)
{
throw new StorageOperationException("Table Updation Excetion. please see inner exception for more details.", ex);
}
}
public void savetable(string partitionKey, string rowKey)
{
var connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString);
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
CloudTable table = tableClient.GetTableReference("Login");
//Create the batch operation
TableBatchOperation batchOperation = new TableBatchOperation();
TableEntity table1 = new TableEntity("PartitionKey", "RowKey");
table1.PartitionKey = "*****@*****.**";
table1.RowKey = "prateekTest12345";
// Create the TableOperation object that inserts the customer entity.
TableOperation insertOperation = TableOperation.Insert(table1);
// Add both customer entities to the batch insert operation
batchOperation.Insert(table1);
//table.ExecuteBatch(batchOperation);
// Execute the insert operation.
table.Execute(insertOperation);
}
public void Delete(string rowKey, string tableName)
{
TableAccess tableAccess = new TableAccess(tableName);
ITableEntity tableEntity = new TableEntity();
if (tableName == "photoinformation")
{
tableEntity = tableAccess.GetPhotoEntity(rowKey);
// Ta bort från container
var rawContainer = new BlobContainer("rawimages");
rawContainer.DeleteBlob(rowKey);
var thuContainer = new BlobContainer("thumbimages");
thuContainer.DeleteBlob(rowKey);
}
if (tableName == "documentinformation")
{
tableEntity = tableAccess.GetDocumentEntity(rowKey);
var container = new BlobContainer("documents");
container.DeleteBlob(rowKey);
}
if (tableName == "videoinformation")
{
tableEntity = tableAccess.GetVideoEntity(rowKey);
var container = new BlobContainer("videos");
container.DeleteBlob(rowKey);
}
if (tableName == "audioinformation")
{
tableEntity = tableAccess.GetAudioEntity(rowKey);
var container = new BlobContainer("audios");
container.DeleteBlob(rowKey);
}
// Ta bort från tabellen
tableEntity.ETag = "*";
TableOperation opp = TableOperation.Delete(tableEntity);
_table.Execute(opp);
}
/// <inheritdoc />
public override async Task<StoreResult> DeleteWebHookAsync(string user, string id)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
if (id == null)
{
throw new ArgumentNullException("id");
}
user = NormalizeKey(user);
id = NormalizeKey(id);
CloudTable table = _manager.GetCloudTable(_connectionString, WebHookTable);
TableEntity tableEntity = new TableEntity(user, id);
tableEntity.ETag = "*";
TableOperation operation = TableOperation.Delete(tableEntity);
TableResult tableResult = await _manager.ExecuteAsync(table, operation);
StoreResult result = GetStoreResult(tableResult);
if (result != StoreResult.Success)
{
string msg = string.Format(CultureInfo.CurrentCulture, AzureStorageResources.StorageManager_OperationFailed, table.Name, tableResult.HttpStatusCode);
_logger.Error(msg);
}
return result;
}
public void Execute(TableBatchOperation batchOperation, TableEntity entity)
{
batchOperation.InsertOrReplace(entity);
}
public EncryptionException(TableEntity entity, string propertyName, Exception inner)
: base("Error encrypting property \"" + propertyName + "\" on entity of type " + entity.GetType().Name, inner)
{
this.Entity = entity;
}
public void CloudTableClientNullPartitionKeyRowKeyCheck()
{
CloudTableClient client = GenerateCloudTableClient();
var table = client.GetTableReference("newtable");
table.CreateIfNotExists();
try
{
TableBatchOperation batch = new TableBatchOperation();
TableEntity entity = new TableEntity(null, "foo");
batch.InsertOrMerge(entity);
table.ExecuteBatch(batch);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(ArgumentNullException));
}
try
{
TableBatchOperation batch = new TableBatchOperation();
TableEntity entity = new TableEntity("foo", null);
batch.InsertOrMerge(entity);
table.ExecuteBatch(batch);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(ArgumentNullException));
}
}
public async Task Commit(string eventStreamId, string transactionId)
{
var table = this.client.GetTableReference(this.tableName);
await EnsureTableExists(table);
var uncommittedLogEntity = new TableEntity(eventStreamId, string.Format("{0}:{1}", UncommittedPrefix, transactionId));
uncommittedLogEntity.ETag = "*";
var deleteOperation = TableOperation.Delete(uncommittedLogEntity);
await table.ExecuteAsync(deleteOperation);
}
public void SimpleTableEntitySerilization()
{
TableEntity testEnt = new TableEntity(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
currentTable.Execute(TableOperation.Insert(testEnt));
TableEntity retrievedEnt = currentTable.Execute(TableOperation.Retrieve<TableEntity>(testEnt.PartitionKey, testEnt.RowKey)).Result as TableEntity;
Assert.IsNotNull(retrievedEnt);
TableEntity.DisableCompiledSerializers = true;
TableEntity testEnt2 = new TableEntity(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
currentTable.Execute(TableOperation.Insert(testEnt2));
TableEntity retrievedEnt2 = currentTable.Execute(TableOperation.Retrieve<TableEntity>(testEnt2.PartitionKey, testEnt2.RowKey)).Result as TableEntity;
Assert.IsNotNull(retrievedEnt2);
}
public void AddEntity(TableEntity entity)
{
if (! BatchBuffer.ContainsKey(entity.PartitionKey))
BatchBuffer.Add(entity.PartitionKey, new List<TableEntity>() { entity });
else
{
var part = BatchBuffer[entity.PartitionKey];
part.Add(entity);
// send batch if at limit
if (part.Count == 100)
{
TableBatchManager.LogInfo("partition has 100");
LoadBatch(part);
BatchBuffer.Remove(entity.PartitionKey);
}
}
if (BatchBuffer.Keys.Count == MaxPartitions)
ClearBuffer();
}
public void Add(TableEntity entity)
{
TableOperation opp = TableOperation.Insert(entity);
_table.Execute(opp);
}
private void DoSimpleTableEntitySerilization(TablePayloadFormat format)
{
tableClient.DefaultRequestOptions.PayloadFormat = format;
TableEntity testEnt = new TableEntity(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
currentTable.Execute(TableOperation.Insert(testEnt));
TableEntity retrievedEnt = currentTable.Execute(TableOperation.Retrieve<TableEntity>(testEnt.PartitionKey, testEnt.RowKey)).Result as TableEntity;
Assert.IsNotNull(retrievedEnt);
TableEntity.DisableCompiledSerializers = true;
TableEntity testEnt2 = new TableEntity(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
currentTable.Execute(TableOperation.Insert(testEnt2));
TableEntity retrievedEnt2 = currentTable.Execute(TableOperation.Retrieve<TableEntity>(testEnt2.PartitionKey, testEnt2.RowKey)).Result as TableEntity;
Assert.IsNotNull(retrievedEnt2);
}
public void Execute(TableBatchOperation batchOperation, TableEntity entity)
{
entity.ETag = "*"; // Always overwrite (ignore concurrency).
batchOperation.Replace(entity);
}
public TableResult InsertEntity(CloudTable table, TableEntity entity)
{
TableOperation insertOperation = TableOperation.Insert(entity);
return table.Execute(insertOperation);
}
