internal static Tuple<HttpWebRequest, Stream> BuildRequestForTableOperation(Uri uri, UriQueryBuilder builder, IBufferManager bufferManager, int? timeout, TableOperation operation, OperationContext ctx) { HttpWebRequest msg = BuildRequestCore(uri, builder, operation.HttpMethod, timeout, ctx); if (operation.OperationType == TableOperationType.InsertOrMerge || operation.OperationType == TableOperationType.Merge) { // post tunnelling msg.Headers.Add("X-HTTP-Method", "MERGE"); } // etag if (operation.OperationType == TableOperationType.Delete || operation.OperationType == TableOperationType.Replace || operation.OperationType == TableOperationType.Merge) { if (operation.Entity.ETag != null) { msg.Headers.Add("If-Match", operation.Entity.ETag); } } if (operation.OperationType == TableOperationType.Insert || operation.OperationType == TableOperationType.Merge || operation.OperationType == TableOperationType.InsertOrMerge || operation.OperationType == TableOperationType.InsertOrReplace || operation.OperationType == TableOperationType.Replace) { // create the writer, indent for readability of the examples. ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings() { CheckCharacters = false, // sets this flag on the XmlWriter for ATOM Version = ODataVersion.V2 // set the Odata version to use when writing the entry }; HttpWebRequestAdapterMessage adapterMsg = new HttpWebRequestAdapterMessage(msg, bufferManager); ODataMessageWriter odataWriter = new ODataMessageWriter(adapterMsg, writerSettings); ODataWriter writer = odataWriter.CreateODataEntryWriter(); WriteOdataEntity(operation.Entity, operation.OperationType, ctx, writer); return new Tuple<HttpWebRequest, Stream>(adapterMsg.GetPopulatedMessage(), adapterMsg.GetStream()); } return new Tuple<HttpWebRequest, Stream>(msg, null); }
private async Task <List <TableOperation> > BuildTableOperationDelete(T entity) { var entityIdValues = EntityDefinition.GetIdValues(entity); var idString = string.Join(StorageQueryBuilder.PARTITION_FIELD_SEPARATOR, entityIdValues.Select(StorageQueryBuilder.NormalizeStringValue)); var record = GenerateRecordMainPartition(entity, null, null); List <TableOperation> operations = new List <TableOperation> { TableOperation.Delete(record) }; var old = await GetById(idString).ConfigureAwait(false); if (old != null) { var oldFields = GetEntityFilterableFields(old); operations.AddRange(GeneratePersistPartitionData(old, null, oldFields).Select(TableOperation.Delete)); } return(operations); }
public async Task Assert() { const int delayIncrement = 750; const int maximumDelay = delayIncrement * 120; CloudStorageAccount storageAccount = CloudStorageAccount.Parse(AbstractIntegrationTest.Settings.StorageConnectionString); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); CloudTable markerTable = tableClient.GetTableReference("markers"); int totalDelay = 0; MarkerTableEntity marker = null; do { await Task.Delay(delayIncrement); totalDelay += delayIncrement; marker = (MarkerTableEntity)(await markerTable.ExecuteAsync(TableOperation.Retrieve <MarkerTableEntity>(MarkerId.ToString(), string.Empty)))?.Result; } while (totalDelay < maximumDelay && marker == null); Xunit.Assert.NotNull(marker); Xunit.Assert.Equal(Value, marker.Value); }
private void SaveEditSurvey(IDialogContext context, dynamic resultValue, EventEntity oneEventEntity) { // Get card from result Dictionary <string, string> editedQuestionList = resultValue.ToObject <Dictionary <string, string> >(); for (int i = 0; i < questionList.Count; i++) { if (editedQuestionList.ContainsKey("q" + i)) { if (!(string.IsNullOrEmpty(editedQuestionList["q" + i]) || string.IsNullOrWhiteSpace(editedQuestionList["q" + i]))) { questionList[i] = editedQuestionList["q" + i]; } } } //Serialize the object back and save it var survey = new List <QuestionEntity>(); var question = new QuestionEntity(); for (int i = 0; i < questionList.Count; i++) { question = new QuestionEntity(); question.PartitionKey = oneEventEntity.SurveyCode; question.RowKey = (i + 1).ToString(); question.AnswerList = JsonConvert.SerializeObject(answerList[i]); question.QuestionText = questionList[i]; survey.Add(question); } oneEventEntity.Survey = JsonConvert.SerializeObject(survey); var storageAccount = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["AzureWebJobsStorage"]); var tableClient = storageAccount.CreateCloudTableClient(); CloudTable cloudTable = tableClient.GetTableReference("Event"); cloudTable.CreateIfNotExists(); cloudTable.Execute(TableOperation.InsertOrMerge(oneEventEntity)); }
public int GetConfigValueByKey(string key) { CloudStorageAccount storageAccount = CloudStorageAccount.Parse( ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString); // Create the table client. CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); // Create the CloudTable object that represents the "people" table. CloudTable table = tableClient.GetTableReference("config"); // Create a retrieve operation that takes a customer entity. TableOperation retrieveOperation = TableOperation.Retrieve <ConfigEntity>(PARTITION_KEY, key); // Execute the retrieve operation. TableResult retrievedResult = table.Execute(retrieveOperation); var config = (ConfigEntity)retrievedResult.Result; string value = config.Value; return(Convert.ToInt32(value)); }
/// <summary> /// Creates several Table Storage entities. /// </summary> /// <param name="count"></param> public void CreateEntities(int count) { // Create several entities. for (int i = 1; i <= count; i++) { // Create a new entity. Random rnd = new Random(); SampleEntity entity = new SampleEntity(Guid.NewGuid()) { CreatedAt = DateTime.UtcNow.ToString("o"), Number = rnd.Next(0, int.MaxValue) }; // Create the TableOperation that inserts the entity. Console.WriteLine(String.Format("Inserting entity {0}.", i)); TableOperation insertOperation = TableOperation.Insert(entity); // Execute the insert operation. table.Execute(insertOperation); Console.WriteLine(String.Format("Entity '{0}' inserted.", entity.RowKey)); } }
public static void WriteLine(string line) { Console.WriteLine( $"[{DateTime.Now.ToString("hh:mm:ss.fff", CultureInfo.InvariantCulture)}] - {line}"); #if DEBUG Debug.WriteLine($"{line}"); return; #endif var storageAccount = CloudStorageAccount.Parse( ConfigurationManager.AppSettings["Azure.Storage.ConnectionString"]); var tableClient = storageAccount.CreateCloudTableClient(); var table = tableClient.GetTableReference("CloudConsole"); table.CreateIfNotExists(); var operation = TableOperation.Insert( new TableEntity((long.MaxValue - DateTime.Now.Ticks).ToString(), line)); table.Execute(operation); }
public static async Task <IActionResult> DeleteTodoAsync( [HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "todo/{id}")] HttpRequest req, [Table("todos", Connection = "AzureWebJobsStorage")] CloudTable todoTable, ILogger log, string id) { log.LogInformation("Deleting todo list by Id"); var deleteOperation = TableOperation.Delete(new TableEntity() { PartitionKey = "TODO", RowKey = id, ETag = "*" }); try { var deleteResult = await todoTable.ExecuteAsync(deleteOperation); } catch (StorageException e) when(e.RequestInformation.HttpStatusCode == 404) { return(new NotFoundResult()); } return(new OkResult()); }
public async Task<T> ReplaceAsync(string partitionKey, string rowKey, Func<T, T> replaceAction) { object itm = "Not read"; try { while (true) { try { var entity = await GetDataAsync(partitionKey, rowKey); if (entity != null) { var result = replaceAction(entity); itm = result; if (result != null) await GetTable().ExecuteAsync(TableOperation.Replace(result)); return result; } return null; } catch (StorageException e) { // Если поймали precondition fall = 412, значит в другом потоке данную сущность успели поменять // - нужно повторить операцию, пока не исполнится без ошибок if (e.RequestInformation.HttpStatusCode != 412) throw; } } } catch (Exception ex) { _log?.WriteFatalError("Table storage: " + _tableName, "Replace item", TableStorageUtils.PrintItem(itm), ex).Wait(); throw; } }
/// <summary> /// Store the given LogMessage object an Azure Table Storage table called "SystemLogs" in the Azure Storage account pointed to by the "AzureStorageConnectionString" /// </summary> /// <param name="logMessage">Message object to log</param> public static void LogMessageToTableStorage(LogMessage logMessage) { try { // Convert message to Azure Table Entity var logAzureTableEntity = new LogAzureTableEntity(logMessage); var connectionString = CloudConfigurationManager.GetSetting(telemetryStorageConnectionStringSettingName); var table = AzureTablesHelper.GetAzureTablesTableObject(connectionString, AzureTableStorageTableName); table.CreateIfNotExists(); // Create the TableOperation object that inserts the entity. var insertOperation = TableOperation.Insert(logAzureTableEntity); // Execute the insert operation. table.Execute(insertOperation); } catch (Exception e) { // ignored } }
internal static async Task <bool> DeleteRow(CloudTable todoTable, string id, string partitionKey) { var entity = new TableEntity() { PartitionKey = partitionKey, RowKey = id, ETag = "*" }; var deleteOperation = TableOperation.Delete(entity); try { var deleteResult = await todoTable.ExecuteAsync(deleteOperation); } catch (StorageException e) when(e.RequestInformation.HttpStatusCode == 404) { return(false); } catch (System.Exception ex) { return(false); } return(true); }
private static async Task AddNewStudent() { System.Console.WriteLine("University:"); string university = Console.ReadLine(); System.Console.WriteLine("CNP:"); string cnp = Console.ReadLine(); System.Console.WriteLine("FirstName:"); string firstName = Console.ReadLine(); System.Console.WriteLine("LastName:"); string lastName = Console.ReadLine(); System.Console.WriteLine("Faculty:"); string faculty = Console.ReadLine(); System.Console.WriteLine("Year:"); string year = Console.ReadLine(); StudentEntity stud = await RetrieveRecordAsync(studentsTable, university, cnp); if (stud == null) { var student = new StudentEntity(university, cnp); student.FirstName = firstName; student.LastName = lastName; student.Faculty = faculty; student.Year = Convert.ToInt32(year); var insertOperation = TableOperation.Insert(student); await studentsTable.ExecuteAsync(insertOperation); System.Console.WriteLine("Inserted!"); } else { System.Console.WriteLine("Entries exists!"); } }
private Person CheckStorage(string email, string password) { string tableName = "Registrerade"; try { CloudStorageAccount account = CloudStorageAccount.Parse(tableConnectionString); CloudTableClient client = account.CreateCloudTableClient(); CloudTable table = client.GetTableReference(tableName); TableOperation retrieveOperation = TableOperation.Retrieve <Person>("signups", email); TableResult user = table.Execute(retrieveOperation); Person person = new Person(); person = (Person)user.Result; if (person.Email == email) { Trace.WriteLine(person.Email); Console.WriteLine(person.Email); return(person); } else { Trace.WriteLine("The f*g was not found."); Console.WriteLine("FAGGITY"); return(null); } } catch (Exception ex) { Trace.WriteLine(ex); Console.WriteLine(ex); } return(null); }
public async Task <bool> StoreAllAnalysedMailAsync(List <AnalysedMailMessageEntity> analysedMail) { if (analysedMail == null || analysedMail.Count == 0) { Dependencies.DiagnosticLogging.Verbose("MailProcessor: No analysed email to store, exiting."); return(true); } var numMsgs = analysedMail.Count; try { Dependencies.DiagnosticLogging.Verbose("MailProcessor: {numMsgs} mail messages to store.", numMsgs); var tblRef = CreateClientTableReference(DataStores.Tables.TableNameProcessedMail); foreach (var m in analysedMail) { var op = TableOperation.Insert(m); var result = await tblRef.ExecuteAsync(op); var resultCode = result.HttpStatusCode; if (resultCode >= 300) { Dependencies.DiagnosticLogging.Error("MailProcessor: Unable to write analysed messages to table storage status code: {resultCode}", resultCode); } } Dependencies.DiagnosticLogging.Info("MailProcessor: Analysed messages stored: #{numMsgs}", numMsgs); return(true); } catch (Exception ex) { Dependencies.DiagnosticLogging.Error(ex, "MailProcessor: Error storing analysed mail list"); var baseEx = ex.GetBaseException(); if (baseEx != null) { Dependencies.DiagnosticLogging.Error(baseEx, "MailProcessor: Error storing analysed mail list (Inner/base error)"); } } return(false); }
public static async Task InsertRecordToTableAsync(CloudTable table, string time, string nickname, string value) { MessageTable message = new MessageTable(); message.Time = time; message.AuthorNickName = nickname; message.Body = value; Message mess = await RetrieveRecordAsync(table, time, nickname); if (mess == null) { TableOperation tableOperation = TableOperation.Insert(message); await table.ExecuteAsync(tableOperation); //Console.WriteLine("Record inserted"); } else { //Console.WriteLine("Record exists"); } }
/// <summary> /// Demonstrate the most efficient storage query - the point query - where both partition key and row key are specified. /// </summary> /// <param name="table">Sample table name</param> /// <param name="partitionKey">Partition key - i.e., last name</param> /// <param name="rowKey">Row key - i.e., first name</param> /// <returns>A Task object</returns> private static async Task <CustomerEntity> RetrieveEntityUsingPointQueryAsync(CloudTable table, string partitionKey, string rowKey) { try { TableOperation retrieveOperation = TableOperation.Retrieve <CustomerEntity>(partitionKey, rowKey); TableResult result = await table.ExecuteAsync(retrieveOperation); CustomerEntity customer = result.Result as CustomerEntity; if (customer != null) { Console.WriteLine("\t{0}\t{1}\t{2}\t{3}", customer.PartitionKey, customer.RowKey, customer.Email, customer.PhoneNumber); } return(customer); } catch (StorageException e) { Console.WriteLine(e.Message); Console.ReadLine(); throw; } }
public async Task UpsertAsync(T t) { var tcw = t as IConcurrencyAware; OperationContext ctx = null; if (tcw != null) { ctx = new OperationContext() { UserHeaders = { { "If-Match", tcw.ETag } } } } ; var table = await GetTable(); await table.ExecuteAsync(TableOperation.InsertOrReplace(GetEntity(t, true)), null, ctx); }
private static async Task AddNewStudent() { System.Console.WriteLine("Adauga universitatea:"); string university = Console.ReadLine(); System.Console.WriteLine("Adauga CNP:"); string cnp = Console.ReadLine(); System.Console.WriteLine("Adauga nume:"); string nume = Console.ReadLine(); System.Console.WriteLine("Adauga prenume:"); string prenume = Console.ReadLine(); System.Console.WriteLine("Adauga facultate:"); string facultate = Console.ReadLine(); System.Console.WriteLine("Adauga an studiu:"); string an = Console.ReadLine(); Studententity stud = await RetrieveRecordAsync(studentsTable, university, cnp); if (stud == null) { var student = new Studententity(university, cnp); student.Nume = nume; student.Prenume = prenume; student.Facultate = facultate; student.An = Convert.ToInt32(an); var insertOperation = TableOperation.Insert(student); await studentsTable.ExecuteAsync(insertOperation); System.Console.WriteLine("S-a adaugat!"); } else { System.Console.WriteLine("S-a gasit!"); } }
/// <summary> /// Inserts a data entry in the Azure table: creates a new one if does not exists or overwrites (without eTag) an already existing version (the "update in place" semantincs). /// </summary> /// <param name="data">Data to be inserted or replaced in the table.</param> /// <returns>Value promise with new Etag for this data entry after completing this storage operation.</returns> public async Task <string> UpsertTableEntryAsync(T data) { const string operation = "UpsertTableEntry"; var startTime = DateTime.UtcNow; if (Logger.IsVerbose2) { Logger.Verbose2("{0} entry {1} into table {2}", operation, data, TableName); } try { try { // WAS: // svc.AttachTo(TableName, data, null); // svc.UpdateObject(data); // SaveChangesOptions.ReplaceOnUpdate, var opResult = await Task <TableResult> .Factory.FromAsync( tableReference.BeginExecute, tableReference.EndExecute, TableOperation.InsertOrReplace(data), null); return(opResult.Etag); } catch (Exception exc) { Logger.Warn(ErrorCode.AzureTable_06, String.Format("Intermediate error upserting entry {0} to the table {1}", (data == null ? "null" : data.ToString()), TableName), exc); throw; } } finally { CheckAlertSlowAccess(startTime, operation); } }
/// <summary> /// Method to delete user mapping. /// </summary> /// <param name="partitionKey">The partition key.</param> /// <param name="rowKey">The row key.</param> /// <returns>boolean value that indicates delete success.</returns> public async Task <bool> DeleteMappedUserDetailsAsync(string partitionKey, string rowKey) { await this.EnsureInitializedAsync().ConfigureAwait(false); // Table query TableQuery <AllUserMappingEntity> deleteQuery = new TableQuery <AllUserMappingEntity>(); deleteQuery .Where(TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, rowKey))); // Results list List <AllUserMappingEntity> results = new List <AllUserMappingEntity>(); TableContinuationToken continuationToken = null; if (await this.userMappingCloudTable.ExistsAsync().ConfigureAwait(false)) { TableQuerySegment <AllUserMappingEntity> queryResults = await this.userMappingCloudTable.ExecuteQuerySegmentedAsync( deleteQuery, continuationToken).ConfigureAwait(false); continuationToken = queryResults.ContinuationToken; results = queryResults.Results; } var row = results.FirstOrDefault(); TableOperation delete = TableOperation.Delete(row); var result = await this.userMappingCloudTable.ExecuteAsync(delete).ConfigureAwait(false); if (result.HttpStatusCode == (int)HttpStatusCode.NoContent) { return(true); } return(false); }
public async Task <TContext> LoadContextAsync <TContext>(long botId, long userOrChatId) where TContext : class, new() { var table = await GetTable(options.MainTableName); var key = BotUserOrChatContext.GetKey(botId, userOrChatId); var obj = await table.ExecuteAsync(TableOperation.Retrieve <BotUserOrChatContext>(key.PartitionKey, key.RowKey)); if (obj.Result == null) { return(null); } var context = (BotUserOrChatContext)obj.Result; if (string.IsNullOrEmpty(context.Value)) { return(null); } return(JsonConvert.DeserializeObject <TContext>(context.Value, EntityPropertyExtensions.JsonSettings)); }
private static void ReplaceEntity() { // Retrieve the storage account from the connection string. CloudStorageAccount storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); // Create the table client. CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); // Create the CloudTable object that represents the "people" table. CloudTable table = tableClient.GetTableReference("people"); // Create a retrieve operation that takes a customer entity. TableOperation retrieveOperation = TableOperation.Retrieve <CustomerEntity>("Smith", "Ben"); // Execute the operation. TableResult retrievedResult = table.Execute(retrieveOperation); // Assign the result to a CustomerEntity object. CustomerEntity updateEntity = (CustomerEntity)retrievedResult.Result; if (updateEntity != null) { // Change the phone number. updateEntity.PhoneNumber = "425-555-0105"; // Create the Replace TableOperation. TableOperation updateOperation = TableOperation.Replace(updateEntity); // Execute the operation. table.Execute(updateOperation); Console.WriteLine("Entity updated."); } else { Console.WriteLine("Entity could not be retrieved."); } }
static string deleteEntry(string tableName, string csvArg) { string returnString = "[done] Added entity. "; try { string[] argArray = csvArg.Split(','); string firstName = argArray[0]; string lastName = argArray[1]; // Create the CloudTable object that represents the "people" table. CloudTable table = tableClient.GetTableReference(tableName); // Create a retrieve operation that takes a customer entity. TableOperation retrieveOperation = TableOperation.Retrieve <CustomerEntity>(firstName, lastName); // Execute the retrieve operation. TableResult retrievedResult = table.Execute(retrieveOperation); // Assign the result to a CustomerEntity. CustomerEntity deleteEntity = (CustomerEntity)retrievedResult.Result; // Create the Delete TableOperation. if (deleteEntity != null) { TableOperation deleteOperation = TableOperation.Delete(deleteEntity); // Execute the operation. table.Execute(deleteOperation); } else { returnString = "Could not retrieve the entity."; } } catch (Exception Err) { returnString = Err.Message; } return(returnString); }
private static PictureEntity RunTableCode(CloudBlockBlob blob) { Console.WriteLine("\n\nStarting Table Demo..."); // Parse the connection string and return a reference to the storage account. CloudStorageAccount storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); // Create the table client. CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); // Get or create the table CloudTable table = tableClient.GetTableReference("pictures"); table.CreateIfNotExists(); PictureEntity picture = new PictureEntity(blob.Name); picture.FileSize = blob.Properties.Length; picture.BlobUri = blob.Uri.ToString(); TableOperation insert = TableOperation.Insert(picture); table.Execute(insert); Console.WriteLine("'Picture' TableEntity properties: "); foreach (var prop in picture.GetType().GetProperties()) { Console.WriteLine(" " + prop.Name + ": " + prop.GetValue(picture, null)); } Console.WriteLine("\nWrote metadata entity into " + table.Name + " table."); TableQuery <PictureEntity> query = new TableQuery <PictureEntity>() .Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, picture.PartitionKey)); Console.WriteLine("Entries for this picture: " + table.ExecuteQuery(query).Count()); return(picture); }
public static SnapmailRowData Update(string key, SnapmailRowData snapmail) { try { CloudTable tblSnapmails = GetAzureTable(SNAPMAIL_TABLE_NAME); SnapmailRowData old = Get(key); SnapmailRowData mail = new SnapmailRowData() { RowKey = key, PartitionKey = snapmail.PartitionKey, ETag = snapmail.ETag, Timestamp = snapmail.Timestamp, Cameras = snapmail.Cameras, CameraNames = snapmail.CameraNames, Message = old.Message, NotifyDays = snapmail.NotifyDays, NotifyTime = snapmail.NotifyTime, TimeZone = snapmail.TimeZone, Recipients = snapmail.Recipients, Subject = old.Subject, UserId = snapmail.UserId, UserName = snapmail.UserName, IsActive = old.IsActive, IsScheduled = old.IsScheduled, AccessToken = snapmail.AccessToken, RefreshToken = snapmail.RefreshToken, TokenExpires = snapmail.TokenExpires, TokenCreated = snapmail.TokenCreated }; TableOperation updateEmail = TableOperation.Replace(mail); var result = tblSnapmails.Execute(updateEmail); return(Get(key)); } catch (Exception x) { return(snapmail); } }
public void Write(string partitionKey, string rowKey, IDictionary <string, EntityProperty> values) { try { // Make sure the table exists. if (!_tableCreated) { Diagnostics.TableStorageEventSource.Log.Info("Ensuring table '{0}' exists.", _table.Name); // Create. _table.CreateIfNotExists(); _tableCreated = true; } // Write. _table.Execute(TableOperation.InsertOrMerge(new DynamicTableEntity(partitionKey, rowKey, "*", values))); } catch (Exception ex) { Diagnostics.TableStorageEventSource.Log.ErrorDetails(ex, "Error writing to table '{0}'.", _table.Name); } }
public async Task Upsert(string organisation, PullRequest pullRequest) { var entity = new PullRequestDao { PartitionKey = organisation.ToLowerInvariant(), RowKey = pullRequest.Id.ToString(), Number = pullRequest.Number, Title = pullRequest.Title, Timestamp = DateTimeOffset.Now, Url = pullRequest.Url.ToString(), CreatedAt = pullRequest.CreatedAt, UpdatedAt = pullRequest.UpdatedAt, ClosedAt = pullRequest.ClosedAt, Status = pullRequest.Status.ToString(), RepositoryName = pullRequest.RepositoryName, RepositoryUrl = pullRequest.RepositoryUrl.ToString() }; var table = await _azureStorage.GetTable(PullRequestsTable); await table.ExecuteAsync(TableOperation.InsertOrReplace(entity)); }
public SubmissionTableEntity IncrementVote(ItemNumber whichItem, string key) { var submission = GetSubmission(key); if (submission != null) { if (whichItem == ItemNumber.Item1) { submission.Item1Votes++; } else if (whichItem == ItemNumber.Item2) { submission.Item2Votes++; } var update = TableOperation.Replace(submission); _table.Execute(update); } return(submission); }
public static async Task <IActionResult> UpdateUser( [HttpTrigger(AuthorizationLevel.Anonymous, "put", Route = Route + "/{id}")] HttpRequest req, [Table(TableName, Connection = "AzureWebJobsStorage")] CloudTable userTable, ILogger log, string id) { string requestBody = await new StreamReader(req.Body).ReadToEndAsync(); var updated = JsonConvert.DeserializeObject <UserUpdateModel>(requestBody); var findOperation = TableOperation.Retrieve <UserTableEntity>("signup", id); var findResult = await userTable.ExecuteAsync(findOperation); if (findResult.Result == null) { return(new NotFoundResult()); } var existingRow = (UserTableEntity)findResult.Result; existingRow.IsActive = updated.IsActive; var replaceOperation = TableOperation.Replace(existingRow); await userTable.ExecuteAsync(replaceOperation); return(new OkObjectResult(existingRow.ToUser())); }
//AUTHENTIFICATION //ADD NEW USER IN DB public async Task <string> DBStoreUser(string login, string hash, string nickname, string level) { CloudTable cloudTable = tableClient.GetTableReference("users"); //await CreateNewTableAsync(cloudTable); UserTable userTable = new UserTable(); userTable.Login = login; userTable.Hash = hash; userTable.Nickname = nickname; userTable.Level = level; userTable.Photo = ""; userTable.AssignPartitionKey(); userTable.AssignRowKey(); TableOperation tableOperation = TableOperation.Insert(userTable); await cloudTable.ExecuteAsync(tableOperation); return("Record inserted"); }
public async Task <bool> SaveEntryAsync(GeoTaggerEntry entity) { try { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(AzureConnectionString); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); CloudTable table = tableClient.GetTableReference(enrtyTable); // Define the insert operation var operation = TableOperation.InsertOrReplace(entity); // Execute the insert against the table var result = await table.ExecuteAsync(operation); return(true); } catch (Exception ex) { return(false); } }
private RowCollection CompareTables(Output targetOutput, Table targetTable, Table updatedTable, out TableOperation operation) { RowCollection rows = new RowCollection(); operation = TableOperation.None; // dropped tables if (null == updatedTable ^ null == targetTable) { if (null == targetTable) { operation = TableOperation.Add; rows.AddRange(updatedTable.Rows); } else if (null == updatedTable) { operation = TableOperation.Drop; } } else // possibly modified tables { SortedList updatedPrimaryKeys = new SortedList(); SortedList targetPrimaryKeys = new SortedList(); // compare the table definitions if (0 != targetTable.Definition.CompareTo(updatedTable.Definition)) { // continue to the next table; may be more mismatches this.OnMessage(WixErrors.DatabaseSchemaMismatch(targetOutput.SourceLineNumbers, targetTable.Name)); } else { this.IndexPrimaryKeys(targetTable, targetPrimaryKeys, updatedTable, updatedPrimaryKeys); // diff the target and updated rows foreach (DictionaryEntry targetPrimaryKeyEntry in targetPrimaryKeys) { string targetPrimaryKey = (string)targetPrimaryKeyEntry.Key; bool keepRow = false; RowOperation rowOperation = RowOperation.None; Row compared = this.CompareRows(targetTable, targetPrimaryKeyEntry.Value as Row, updatedPrimaryKeys[targetPrimaryKey] as Row, out rowOperation, out keepRow); if (keepRow) { rows.Add(compared); } } // find the inserted rows foreach (DictionaryEntry updatedPrimaryKeyEntry in updatedPrimaryKeys) { string updatedPrimaryKey = (string)updatedPrimaryKeyEntry.Key; if (!targetPrimaryKeys.Contains(updatedPrimaryKey)) { Row updatedRow = (Row)updatedPrimaryKeyEntry.Value; updatedRow.Operation = RowOperation.Add; updatedRow.SectionId = sectionDelimiter + updatedRow.SectionId; rows.Add(updatedRow); } } } } return rows; }
internal static Tuple<HttpWebRequest, Stream> BuildRequestForTableOperation(Uri uri, UriQueryBuilder builder, IBufferManager bufferManager, int? timeout, TableOperation operation, bool useVersionHeader, OperationContext ctx, TableRequestOptions options, string accountName) { HttpWebRequest msg = BuildRequestCore(uri, builder, operation.HttpMethod, timeout, useVersionHeader, ctx); TablePayloadFormat payloadFormat = options.PayloadFormat.Value; // Set Accept and Content-Type based on the payload format. SetAcceptHeaderForHttpWebRequest(msg, payloadFormat); Logger.LogInformational(ctx, SR.PayloadFormat, payloadFormat); if (operation.HttpMethod != "HEAD" && operation.HttpMethod != "GET") { SetContentTypeForHttpWebRequest(msg, payloadFormat); } if (operation.OperationType == TableOperationType.InsertOrMerge || operation.OperationType == TableOperationType.Merge) { options.AssertNoEncryptionPolicyOrStrictMode(); // post tunnelling msg.Headers.Add("X-HTTP-Method", "MERGE"); } // etag if (operation.OperationType == TableOperationType.Delete || operation.OperationType == TableOperationType.Replace || operation.OperationType == TableOperationType.Merge) { if (operation.Entity.ETag != null) { msg.Headers.Add("If-Match", operation.Entity.ETag); } } // prefer header if (operation.OperationType == TableOperationType.Insert) { msg.Headers.Add("Prefer", operation.EchoContent ? "return-content" : "return-no-content"); } if (operation.OperationType == TableOperationType.Insert || operation.OperationType == TableOperationType.Merge || operation.OperationType == TableOperationType.InsertOrMerge || operation.OperationType == TableOperationType.InsertOrReplace || operation.OperationType == TableOperationType.Replace) { // create the writer, indent for readability of the examples. ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings() { CheckCharacters = false, // sets this flag on the XmlWriter for ATOM Version = TableConstants.ODataProtocolVersion // set the Odata version to use when writing the entry }; HttpWebRequestAdapterMessage adapterMsg = new HttpWebRequestAdapterMessage(msg, bufferManager); if (operation.HttpMethod != "HEAD" && operation.HttpMethod != "GET") { SetContentTypeForAdapterMessage(adapterMsg, payloadFormat); } ODataMessageWriter odataWriter = new ODataMessageWriter(adapterMsg, writerSettings, new TableStorageModel(accountName)); ODataWriter writer = odataWriter.CreateODataEntryWriter(); WriteOdataEntity(operation.Entity, operation.OperationType, ctx, writer, options); return new Tuple<HttpWebRequest, Stream>(adapterMsg.GetPopulatedMessage(), adapterMsg.GetStream()); } return new Tuple<HttpWebRequest, Stream>(msg, null); }
/// <summary> /// Parse a table from the xml. /// </summary> /// <param name="reader">XmlReader where the intermediate is persisted.</param> /// <param name="section">Section to populate with persisted data.</param> /// <param name="tableDefinitions">TableDefinitions to use in the intermediate.</param> /// <returns>The parsed table.</returns> internal static Table Parse(XmlReader reader, Section section, TableDefinitionCollection tableDefinitions) { Debug.Assert("table" == reader.LocalName); bool empty = reader.IsEmptyElement; TableOperation operation = TableOperation.None; string name = null; while (reader.MoveToNextAttribute()) { switch (reader.LocalName) { case "name": name = reader.Value; break; case "op": switch (reader.Value) { case "add": operation = TableOperation.Add; break; case "drop": operation = TableOperation.Drop; break; default: throw new WixException(WixErrors.IllegalAttributeValue(SourceLineNumberCollection.FromUri(reader.BaseURI), "table", reader.Name, reader.Value, "Add", "Drop")); } break; default: if (!reader.NamespaceURI.StartsWith("http://www.w3.org/", StringComparison.Ordinal)) { throw new WixException(WixErrors.UnexpectedAttribute(SourceLineNumberCollection.FromUri(reader.BaseURI), "table", reader.Name)); } break; } } if (null == name) { throw new WixException(WixErrors.ExpectedAttribute(SourceLineNumberCollection.FromUri(reader.BaseURI), "table", "name")); } TableDefinition tableDefinition = tableDefinitions[name]; Table table = new Table(section, tableDefinition); table.Operation = operation; if (!empty) { bool done = false; // loop through all the rows in a table while (!done && reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: switch (reader.LocalName) { case "row": Row.Parse(reader, table); break; default: throw new WixException(WixErrors.UnexpectedElement(SourceLineNumberCollection.FromUri(reader.BaseURI), "table", reader.Name)); } break; case XmlNodeType.EndElement: done = true; break; } } if (!done) { throw new WixException(WixErrors.ExpectedEndElement(SourceLineNumberCollection.FromUri(reader.BaseURI), "table")); } } return table; }