public static void LogInfo(string msg) { TableClient client = new TableClient(_TableName); Models.LogEntry l = new Models.LogEntry("0", Convert.ToString(Guid.NewGuid())); l.Level = "Info"; l.Message = msg; l.Source = "System"; client.InsertRow(l); }
public static MessageEntity GetMessage(string orgId, string messageId) { TableClient client = new TableClient(_TableName); TableOperation operation = TableOperation.Retrieve<MessageEntity>(orgId, messageId); // Execute the retrieve operation. TableResult tresult = client.Table.Execute(operation); Models.MessageEntity entity = (MessageEntity)tresult.Result; return entity; }
public static void CreateMessage(Models.MessageEntity entity) { Contracts.MessageContract contract = new Contracts.MessageContract(entity.RowKey, entity.PartitionKey); TableClient client = new TableClient(_TableName); QueueClient qclient = new QueueClient(); Console.WriteLine("Inserting Entity"); entity.ModifiedOn = System.DateTime.Now.ToString(); client.InsertRow(entity); Console.WriteLine("Inserting Queue Msg"); qclient.Send(contract); }
/// <summary> /// Deletes all the underlying Service Bus entities. /// </summary> /// <param name="deleteInstanceStore">True if Azure Storage entities should also deleted, False otherwise.</param> public void DeleteHub(bool deleteInstanceStore) { NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString); SafeDeleteQueue(namespaceManager, orchestratorEntityName); SafeDeleteQueue(namespaceManager, workerEntityName); SafeDeleteQueue(namespaceManager, trackingEntityName); if (deleteInstanceStore) { if (!string.IsNullOrEmpty(tableStoreConnectionString)) { var client = new TableClient(hubName, tableStoreConnectionString); client.DeleteTableIfExists(); } } }
public async Task TableEntity_IfBoundToJObject_CanCall() { // Arrange await TableClient.AddEntityAsync(CreateTableEntity(PartitionKey, RowKey, "Value", "Foo")); await CallAsync <BindTableEntityToJObjectProgram>(arguments : new { table = TableName, // Test resolution pk1 = PartitionKey, rk1 = RowKey }); // Assert SdkTableEntity entity = await TableClient.GetEntityAsync <SdkTableEntity>(PartitionKey, RowKey); Assert.NotNull(entity); }
public void CreateDeleteTable() { string storageUri = StorageUri; string accountName = StorageAccountName; string storageAccountKey = PrimaryStorageAccountKey; string tableName = "OfficeSupplies1p1"; #region Snippet:TablesSample1CreateClient // Construct a new <see cref="TableServiceClient" /> using a <see cref="TableSharedKeyCredential" />. var serviceClient = new TableServiceClient( new Uri(storageUri), new TableSharedKeyCredential(accountName, storageAccountKey)); #endregion #region Snippet:TablesSample1CreateTable // Create a new table. The <see cref="TableItem" /> class stores properties of the created table. TableItem table = serviceClient.CreateTable(tableName); Console.WriteLine($"The created table's name is {table.TableName}."); #endregion #region Snippet:TablesSample1DeleteTable // Deletes the table made previously. serviceClient.DeleteTable(tableName); #endregion #region Snippet:TablesSample1GetTableClient tableName = "OfficeSupplies1p2"; var tableClient = serviceClient.GetTableClient(tableName); #endregion #region Snippet:TablesSample1CreateTableClient tableClient = new TableClient( tableName, new Uri(storageUri), new TableSharedKeyCredential(accountName, storageAccountKey)); #endregion #region Snippet:TablesSample1TableClientCreateTable tableClient.Create(); #endregion #region Snippet:TablesSample1TableClientDeleteTable tableClient.Delete(); #endregion }
// Used as an alternative to binding to IQueryable. private async Task <JArray> CreateJArray(TableAttribute attribute, CancellationToken cancellation) { var table = GetTable(attribute); string filter = attribute.Filter; if (!string.IsNullOrEmpty(attribute.PartitionKey)) { var partitionKeyPredicate = TableClient.CreateQueryFilter($"PartitionKey eq {attribute.PartitionKey}"); if (!string.IsNullOrEmpty(filter)) { filter = $"{partitionKeyPredicate} and {filter}"; } else { filter = partitionKeyPredicate; } } int?maxPerPage = null; if (attribute.Take > 0) { maxPerPage = attribute.Take; } int countRemaining = attribute.Take; JArray entityArray = new JArray(); var entities = table.QueryAsync <TableEntity>( filter: filter, maxPerPage: maxPerPage, cancellationToken: cancellation).ConfigureAwait(false); await foreach (var entity in entities) { countRemaining--; entityArray.Add(ConvertEntityToJObject(entity)); if (countRemaining == 0) { break; } } return(entityArray); }
public async Task <T> GetTableRow <T>(string tableName, string rowKey, string partitionKey = "default") where T : ValueWithEtag { TableClient tableClient = await this.GetTableClient(tableName); try { var res = await tableClient.GetEntityAsync <ContentDataEntity>(partitionKey, rowKey); T value = JsonConvert.DeserializeObject <T>(res.Value.Content); value.etag = res.Value.ETag; return(value); } catch (RequestFailedException e) { return(null); } }
public async Task ConnStringAuth() { string tableName = "OfficeSupplies"; string connectionString = $"DefaultEndpointsProtocol=https;AccountName={StorageAccountName};AccountKey={PrimaryStorageAccountKey};EndpointSuffix={StorageEndpointSuffix ?? DefaultStorageSuffix}"; #region Snippet:TablesAuthConnString // Construct a new TableClient using a connection string. var client = new TableClient( connectionString, tableName); // Create the table if it doesn't already exist to verify we've successfully authenticated. await client.CreateIfNotExistsAsync(); #endregion }
public async Task TableQueryableComplexFilterWithCreateFilter() { var entitiesToCreate = CreateComplexTableEntities(PartitionKeyValue, 4); // Create the new entities. await CreateTestEntities(entitiesToCreate).ConfigureAwait(false); var filter = TableClient.CreateQueryFilter <ComplexEntity>(ent => (ent.RowKey == "0004" && ent.Int32 == 4) || ((ent.Int32 == 2) && (ent.String == "wrong string" || ent.Bool == true)) || (ent.LongPrimitiveN == (long)int.MaxValue + 50)); var results = await client.QueryAsync <ComplexEntity>(filter).ToEnumerableAsync().ConfigureAwait(false); foreach (ComplexEntity ent in results) { Assert.IsTrue(ent.Int32 == 4 || ent.Int32 == 2); } Assert.That(results.Count, Is.EqualTo(2)); }
private TableClient GetTableClient() { if (tableClient == null) { lock (tableClientLock) { if (tableClient == null) { KeyVaultSecret secret = secretClient.GetSecret(ConnectionStringSecretName); var connectionString = secret.Value; tableClient = new TableClient(connectionString, PullRequestStateTableName); } } } return(tableClient); }
public static HelpMetaData CalculateMetaData(TableClient client, ILogger log) { log.LogInformation("Calculating meta data on HelpTable"); string filter = TableServiceClient.CreateQueryFilter($"PartitionKey eq {CommandHelpPartitionKey}"); var select = new string[] { "CommandName", "ModuleName" }; var entities = client.Query <HelpEntity>(filter: filter, select: select); var numAbout = entities .Where(r => r .CommandName .StartsWith("about_", StringComparison.OrdinalIgnoreCase)) .Count(); var moduleNames = entities .Select(r => r.ModuleName) .Where(moduleName => !string.IsNullOrEmpty(moduleName)) .Distinct(); var helpMetaData = new HelpMetaData() { PartitionKey = MetaDataPartitionKey, RowKey = MetaDataRowKey, NumberOfAboutArticles = numAbout, NumberOfCommands = entities.Count() - numAbout, NumberOfModules = moduleNames.Count(), ModuleNames = string.Join(',', moduleNames), LastPublished = Helpers.GetBuildDate(Assembly.GetExecutingAssembly()).ToLongDateString() }; var metaDataEntity = new HelpMetaData(); try { metaDataEntity = client.GetEntity <HelpMetaData>(MetaDataPartitionKey, MetaDataRowKey); _ = client.UpsertEntity(helpMetaData); } catch (RequestFailedException) { _ = client.AddEntity(helpMetaData); } return(helpMetaData); }
public async Task <ActionResult> AddToCart(Guid id, int quantity) { var shoppingCart = TableClient.GetTableReference("shoppingcart"); shoppingCart.CreateIfNotExists(); var retrieve = TableOperation.Retrieve <ProductCartEntity>(UserSession(), id.ToString()); var result = shoppingCart.Execute(retrieve); var item = (ProductCartEntity)result.Result; if (item != null) { item.Quantity = quantity; item.TotalPrice = quantity * item.UnitPrice; } else { var product = DocumentDbProducts().Where(xx => xx.id == id).ToList().First(); item = new ProductCartEntity { PartitionKey = UserSession() , RowKey = id.ToString() , CreateDate = DateTime.Now , ProductDescription = product.Name , Currency = "EUR" , UnitPrice = (double)product.ListPrice , TotalPrice = quantity * (double)product.ListPrice , Quantity = quantity }; } var upsert = TableOperation.InsertOrReplace(item); shoppingCart.Execute(upsert); return(RedirectToAction("ShoppingCart")); }
public async Task TableEntity_IfUpdatesRowKey_Throws() { // Arrange await TableClient.AddEntityAsync(new TableEntity(PartitionKey, RowKey)); // Act var functionException = Assert.CatchAsync <FunctionInvocationException>(async() => await CallAsync <UpdatePocoRowKeyProgram>()); Exception exception = functionException.InnerException; // Assert Assert.NotNull(exception); Assert.IsInstanceOf <InvalidOperationException>(exception); Assert.AreEqual("Error while handling parameter entity after function returned:", exception.Message); Exception innerException = exception.InnerException; Assert.NotNull(innerException); Assert.IsInstanceOf <InvalidOperationException>(innerException); Assert.AreEqual("When binding to a table entity, the row key must not be changed.", innerException.Message); }
internal HttpStatusCode insertTableEntity(CloudStorageAccount pCloudStorageAccount, string pTable, TableEntity pTableEntity, out string pInsertETag) { //TableClient table = new TableClient(pCloudStorageAccount, caCerts, _timeZoneOffset, _debug, _debug_level); TableClient table = new TableClient(pCloudStorageAccount, caCerts, _debug, _debug_level); // To use Fiddler as WebProxy include the following line. Use the local IP-Address of the PC where Fiddler is running // see: -http://blog.devmobile.co.nz/2013/01/09/netmf-http-debugging-with-fiddler if (attachFiddler) { table.attachFiddler(true, fiddlerIPAddress, fiddlerPort); } var resultCode = table.InsertTableEntity(pTable, pTableEntity, TableClient.ContType.applicationIatomIxml, TableClient.AcceptType.applicationIjson, TableClient.ResponseType.dont_returnContent, useSharedKeyLite: false); pInsertETag = table.OperationResponseETag; //var body = table.OperationResponseBody; //Debug.Print("Entity inserted"); return(resultCode); }
/// <summary> /// Creates all the underlying entities in Service bus and Azure Storage (if specified) for /// the TaskHubWorker and TaskHubClient's operations. If TaskHub already existed then /// it would be deleted and recreated. Instance store creation can be controlled via parameter. /// </summary> public void CreateHub(TaskHubDescription description, bool createInstanceStore) { NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString); SafeDeleteQueue(namespaceManager, orchestratorEntityName); SafeDeleteQueue(namespaceManager, workerEntityName); SafeDeleteQueue(namespaceManager, trackingEntityName); CreateQueue(namespaceManager, orchestratorEntityName, true, description.MaxTaskOrchestrationDeliveryCount); CreateQueue(namespaceManager, workerEntityName, false, description.MaxTaskActivityDeliveryCount); CreateQueue(namespaceManager, trackingEntityName, true, description.MaxTrackingDeliveryCount); if (!string.IsNullOrEmpty(tableStoreConnectionString) && createInstanceStore) { var client = new TableClient(hubName, tableStoreConnectionString); client.DeleteTableIfExists(); client.CreateTableIfNotExists(); } }
public async Task <IActionResult> GetFileAsync(string fileId) { // TODO: Verify that user is allowed to get files for this chat/call // Prepare Table Storage clients TableServiceClient tableServiceClient = new TableServiceClient(_storageAccountConnectionString); TableClient tableClient = tableServiceClient.GetTableClient(_tableName); tableClient.CreateIfNotExists(); // Get file info from Table Storage Azure.Response <TableEntity> getTableEntityResponse; try { getTableEntityResponse = await tableClient.GetEntityAsync <TableEntity>(fileId, fileId); } catch (Azure.RequestFailedException e) { if (e.Status == 404) { return(NotFound()); } return(BadRequest("Couldn't get file from storage")); } var fileName = getTableEntityResponse.Value.GetString("FileName"); // Prepare Blob Storage clients and container BlobContainerClient containerClient = new BlobContainerClient(_storageAccountConnectionString, _blobContainerName); containerClient.CreateIfNotExists(); BlobClient blob = containerClient.GetBlobClient(fileId); // MemoryStream blobStream = new MemoryStream(); // var downloadResult = await blob.DownloadToAsync(blobStream); var blobStream = await blob.OpenReadAsync(); return(new FileStreamResult(blobStream, "application/octet-stream") { FileDownloadName = fileName }); }
private static async Task <TableClient> InitTableAsync(ILogger logger) { try { var tableCreationClient = GetCloudTableCreationClient(logger); TableClient tableRef = tableCreationClient.GetTableClient(tableName); var tableItem = await tableRef.CreateIfNotExistsAsync(); var didCreate = tableItem is not null; logger.LogInformation("{Verb} Azure storage table {TableName}", didCreate ? "Created" : "Attached to", tableName); return(tableRef); } catch (Exception exc) { logger.LogError(exc, "Could not initialize connection to storage table {TableName}", tableName); throw; } }
public async Task <IActionResult> GetAsync() { // TODO: Verify that user is allowed to get files for this chat/call // Get file info from Table Storage TableServiceClient tableServiceClient = new TableServiceClient(_storageAccountConnectionString); TableClient tableClient = tableServiceClient.GetTableClient(_tableName); tableClient.CreateIfNotExists(); var tableEntities = tableClient.Query <TableEntity>(); var files = tableEntities.Select(tableEntity => new FileMetadata { Id = tableEntity.GetString("FileId"), Name = tableEntity.GetString("FileName"), UploadDateTime = tableEntity.GetDateTimeOffset("UploadDateTime").Value, }); return(Ok(files)); }
public async Task TableEntity_IfBoundToExistingPoco_BindsUsingNativeTableTypes() { // Arrange byte[] expectedValue = new byte[] { 0x12, 0x34 }; await TableClient.AddEntityAsync(new TableEntity(PartitionKey, RowKey) { { "Value", (expectedValue) } }); // Act var function = await CallAsync <BindToPocoWithByteArrayValueProgram>(); var result = function.Entity; // Assert Assert.NotNull(result); Assert.AreEqual(expectedValue, result.Value); }
public async Task <ActionResult> AddToCart(string productId, decimal unitPrice, int quantity) { var shoppingCart = TableClient.GetTableReference("shoppingcart"); shoppingCart.CreateIfNotExists(); var userSession = Membership.GetUser().UserName; var retrieve = TableOperation.Retrieve <ProductCartEntity>(userSession, productId); var result = shoppingCart.Execute(retrieve); var item = (ProductCartEntity)result.Result; if (item != null) { item.UnitPrice = unitPrice; item.Quantity = quantity; } else { item = new ProductCartEntity { PartitionKey = userSession , RowKey = productId , CreateDate = DateTime.Now , Currency = "EUR" , UnitPrice = unitPrice , Quantity = quantity }; } item.TotalPrice = item.UnitPrice * item.Quantity; var upsert = TableOperation.InsertOrReplace(item); shoppingCart.Execute(upsert); return(RedirectToAction("Index")); }
internal AzureTableRepositoryBase(string connectionString, string tableName, bool createIfNotExists, ICompoundKeyCachingStrategy <T, string, string> cachingStrategy = null) : base(cachingStrategy) { var storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(connectionString); TableName = TypeName; if (!String.IsNullOrEmpty(tableName)) { TableName = tableName; } TableClient = storageAccount.CreateCloudTableClient(); Table = TableClient.GetTableReference(TableName); if (createIfNotExists) { Table.CreateIfNotExists(); } }
/// <summary> /// AddEntity Wrapper. /// </summary> /// <param name="tableName">TableName.</param> /// <param name="entity">Entity.</param> /// <param name="cancellationToken">CancellationToken.</param> /// <returns>Response</returns> public async Task <Azure.Response> AddEntityAsync(string tableName, TableEntity entity, CancellationToken cancellationToken = default) { TableClient tableClient; // Look for cache key. if (!this.memoryCache.TryGetValue(tableName, out tableClient)) { await this.CreateTableIfNotExistsAsync(tableName).ConfigureAwait(false); tableClient = new TableClient( this.tableStorageConfig.ConnectionString, tableName); // Save data in cache. this.memoryCache.Set(tableName, tableClient); } Azure.Response res = tableClient.AddEntity(entity, cancellationToken); return(res); }
public async Task <List <T> > GetAllRowsAsync <T>(string tableName, string partitionKey) where T : ValueWithEtag { TableClient tableClient = await this.GetTableClient(tableName); try { var res = await tableClient.QueryAsync <ContentDataEntity>((item) => string.Equals(item.PartitionKey, partitionKey)).ToListAsync(); return(res.ConvertAll(item => { T value = JsonConvert.DeserializeObject <T>(item.Content); value.etag = item.ETag; return value; })); } catch (RequestFailedException e) { return(null); } }
public async Task SharedKeyAuth() { string storageUri = StorageUri; string accountName = StorageAccountName; string accountKey = PrimaryStorageAccountKey; string tableName = "OfficeSuppliesSharedKeyAuth" + _random.Next(); #region Snippet:TablesAuthSharedKey // Construct a new TableClient using a TableSharedKeyCredential. var client = new TableClient( new Uri(storageUri), tableName, new TableSharedKeyCredential(accountName, accountKey)); // Create the table if it doesn't already exist to verify we've successfully authenticated. await client.CreateIfNotExistsAsync(); #endregion }
public static async Task <HttpResponseMessage> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req, [Table(HelpTableName)] TableClient tableClient, ILogger log) { AnalysisResult analysisResult; string requestBody = await new StreamReader(req.Body).ReadToEndAsync(); if (string.IsNullOrEmpty(requestBody)) { return(ResponseHelper(HttpStatusCode.BadRequest, "Empty request. Pass powershell code in the request body for an AST analysis.")); } var code = JsonConvert .DeserializeObject <Code>(requestBody) ?.PowershellCode; log.LogInformation("PowerShell code sent: " + code); // LogAnalytics does not log the body of requests, so we have to log this ourselves. ScriptBlockAst ast = Parser.ParseInput(code, out Token[] tokens, out ParseError[] parseErrors);
/// <inheritdoc /> public async Task <IDictionary <DateTime, IList <string> > > RetrieveSiteNewsEntriesAsync() { TableClient tableClient = GetTableClient(); // Group entities by date and sort by order in each group int currentOrder = 0; SortedDictionary <DateTime, SortedList <int, string> > entitiesByDate = new(); AsyncPageable <TableEntity> results = tableClient.QueryAsync <TableEntity>(); await foreach (TableEntity entity in results) { if (!DateTime.TryParse(entity.PartitionKey, out DateTime date)) { _telemetryClient.TrackInvalidTableEntry(entity); continue; } if (!int.TryParse(entity.RowKey, out int order)) { order = currentOrder++; } if (!entitiesByDate.TryGetValue(date, out SortedList <int, string> entities)) { entities = new SortedList <int, string>(); entitiesByDate.Add(date, entities); } entities.Add(order, entity.GetString("Message")); } // Select only the messages SortedDictionary <DateTime, IList <string> > entries = new(); foreach (KeyValuePair <DateTime, SortedList <int, string> > entities in entitiesByDate) { entries.Add(entities.Key, entities.Value.Values); } return(entries); }
private static HttpStatusCode queryTableEntities(CloudStorageAccount pCloudStorageAccount, X509Certificate[] pCaCerts, string tableName, string query, out ArrayList queryResult) { //table = new TableClient(pCloudStorageAccount, pCaCerts, _debug, _debug_level, wifi); table = new TableClient(pCloudStorageAccount, pCaCerts, _debug, _debug_level); // To use Fiddler as WebProxy include the following line. Use the local IP-Address of the PC where Fiddler is running // see: -http://blog.devmobile.co.nz/2013/01/09/netmf-http-debugging-with-fiddler //if (attachFiddler) //{ table.attachFiddler(true, fiddlerIPAddress, fiddlerPort); } HttpStatusCode resultCode = table.QueryTableEntities(tableName, query, TableClient.ContType.applicationIatomIxml, TableClient.AcceptType.applicationIatomIxml, useSharedKeyLite: false); // now we can get the results by reading the properties: table.OperationResponse...... queryResult = table.OperationResponseQueryList; // var body = table.OperationResponseBody; // this shows how to get a special value (here the RowKey)of the first entity // var entityHashtable = queryResult[0] as Hashtable; // var theRowKey = entityHashtable["RowKey"]; return(resultCode); }
protected virtual void Initialize(PersistedGrantStorageConfig config) { TableClient = Microsoft.Azure.Cosmos.Table.CloudStorageAccount.Parse(config.StorageConnectionString).CreateCloudTableClient(); TableClient.DefaultRequestOptions.PayloadFormat = TablePayloadFormat.Json; PersistedGrantTableName = config.PersistedGrantTableName; if (string.IsNullOrWhiteSpace(PersistedGrantTableName)) { throw new ArgumentException($"PersistedGrantTableName cannot be null or empty, check your configuration.", nameof(config.PersistedGrantTableName)); } PersistedGrantTable = TableClient.GetTableReference(PersistedGrantTableName); BlobClient = new BlobServiceClient(config.StorageConnectionString); BlobContainerName = config.BlobContainerName; if (string.IsNullOrWhiteSpace(BlobContainerName)) { throw new ArgumentException($"BlobContainerName cannot be null or empty, check your configuration.", nameof(config.BlobContainerName)); } PersistedGrantBlobContainer = BlobClient.GetBlobContainerClient(BlobContainerName); }
public async Task SaveTableRow <T>(string tableName, string rowKey, string partitionKey, T entity) where T : ValueWithEtag { TableClient tableClient = await this.GetTableClient(tableName); ContentDataEntity entry = new ContentDataEntity { RowKey = rowKey, PartitionKey = partitionKey, Content = JsonConvert.SerializeObject(entity) }; if (entity.etag == default) { await tableClient.UpsertEntityAsync(entry); } else { var res = await tableClient.UpdateEntityAsync(entry, entity.etag); } }
public async Task CreateIfNotExists() { // Call CreateIfNotExists when the table already exists. Assert.That(async() => await CosmosThrottleWrapper(async() => await client.CreateIfNotExistsAsync().ConfigureAwait(false)), Throws.Nothing); // Call CreateIfNotExists when the table does not already exist. var newTableName = Recording.GenerateAlphaNumericId("testtable", useOnlyLowercase: true); TableItem table; TableClient tableClient = null; try { tableClient = service.GetTableClient(newTableName); table = await CosmosThrottleWrapper(async() => await tableClient.CreateIfNotExistsAsync().ConfigureAwait(false)); } finally { await tableClient.DeleteAsync().ConfigureAwait(false); } Assert.That(table.TableName, Is.EqualTo(newTableName)); }
public async Task TableEntity_IfBoundToExistingPoco_Binds() { // Arrange const string expectedValue = "abc"; await TableClient.AddEntityAsync(new TableEntity(PartitionKey, RowKey) { { "Value", (expectedValue) } }); // Act var function = await CallAsync <BindToPocoProgram>(arguments : new { newValue = expectedValue }); var result = function.Entity; // Assert Assert.NotNull(result); Assert.AreEqual(expectedValue, result.Value); }
public async Task InsertRowsAsync( TableName tableName, IEnumerable <BigtableByteString> rowKeys, string familyName = null, BigtableByteString?qualifierName = null, BigtableByteString?valuePrefix = null, BigtableVersion?version = null) { BigtableByteString rowKey = Guid.NewGuid().ToString(); familyName = familyName ?? ColumnFamily1; qualifierName = qualifierName ?? "row_index"; valuePrefix = valuePrefix ?? ""; // TODO: Use cleaner API when available. int counter = 0; var request = new MutateRowsRequest { TableNameAsTableName = tableName, Entries = { rowKeys.Select(k => new MutateRowsRequest.Types.Entry { RowKey = k.Value, Mutations = { Mutations.SetCell( familyName, qualifierName.Value, valuePrefix.Value.Value.Concat(new BigtableByteString(counter++).Value), version) } }) } }; var response = TableClient.MutateRows(request); while (await response.ResponseStream.MoveNext(default))
public static void UpdateMessage(Models.MessageEntity entity) { TableClient client = new TableClient(_TableName); entity.ModifiedOn = System.DateTime.Now.ToString(); client.UpdateRow(entity); }
/// <summary> /// Create a new TaskHubClient with given name, Service Bus and Azure Storage connection strings with specified /// settings. /// </summary> /// <param name="hubName">Name of the Task Hub</param> /// <param name="connectionString">Service Bus connection string</param> /// <param name="tableStoreConnectionString">Azure Storage connection string</param> /// <param name="settings">Client settings</param> public TaskHubClient(string hubName, string connectionString, string tableStoreConnectionString, TaskHubClientSettings settings) { this.hubName = hubName; this.connectionString = connectionString; messagingFactory = Utils.CreateMessagingFactory(connectionString); workerEntityName = string.Format(FrameworkConstants.WorkerEndpointFormat, this.hubName); orchestratorEntityName = string.Format(FrameworkConstants.OrchestratorEndpointFormat, this.hubName); defaultConverter = new JsonDataConverter(); this.settings = settings; this.tableStoreConnectionString = tableStoreConnectionString; if (!string.IsNullOrEmpty(this.tableStoreConnectionString)) { tableClient = new TableClient(this.hubName, this.tableStoreConnectionString); } }