public async Task <bool> Actualizar(EmpleadosEntity actualizado) { var table = ObtenerTablaAzure(); // Create a retrieve operation that expects a customer entity. TableOperation retrieveOperation = TableOperation.Retrieve <EmpleadosAzureEntity>(actualizado.RFC.Substring(0, 2), actualizado.RFC); // Execute the operation. TableResult retrievedResult = await table.ExecuteAsync(retrieveOperation); // Assign the result to a CustomerEntity. var updateEntity = retrievedResult.Result as EmpleadosAzureEntity; // Create the Delete TableOperation. if (updateEntity != null) { updateEntity.nombre = actualizado.nombre; updateEntity.apellidoP = actualizado.apellidoP; updateEntity.apellidoM = actualizado.apellidoM; updateEntity.nacimiento = actualizado.nacimiento; updateEntity.tipo = actualizado.tipo; updateEntity.telefono = actualizado.telefono; updateEntity.sueldo = actualizado.sueldo; updateEntity.horario = actualizado.horario; TableOperation updateOperation = TableOperation.Replace(updateEntity); // Execute the operation. await table.ExecuteAsync(updateOperation); return(true); } else { return(false); } }
/// <summary> /// Updates a data entry in the Azure table: updates an already existing data in the table, by using eTag. /// Fails if the data does not already exist or of eTag does not match. /// </summary> /// <param name="data">Data to be updated into the table.</param> /// /// <param name="dataEtag">ETag to use.</param> /// <returns>Value promise with new Etag for this data entry after completing this storage operation.</returns> public async Task <string> UpdateTableEntryAsync(T data, string dataEtag) { const string operation = "UpdateTableEntryAsync"; var startTime = DateTime.UtcNow; if (Logger.IsVerbose2) { Logger.Verbose2("{0} table {1} entry {2}", operation, TableName, data); } try { try { data.ETag = dataEtag; var opResult = await Task <TableResult> .Factory.FromAsync( tableReference.BeginExecute, tableReference.EndExecute, TableOperation.Replace(data), null); //The ETag of data is needed in further operations. return(opResult.Etag); } catch (Exception exc) { CheckAlertWriteError(operation, data, null, exc); throw; } } finally { CheckAlertSlowAccess(startTime, operation); } }
private static async Task EditStudent() { System.Console.WriteLine("Adauga universitatea:"); string university = Console.ReadLine(); System.Console.WriteLine("Adauga CNP:"); string cnp = Console.ReadLine(); Studententity stud = await RetrieveRecordAsync(studentsTable, university, cnp); if (stud != null) { System.Console.WriteLine("S-a gasit!"); var student = new Studententity(university, cnp); 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(); student.Nume = nume; student.Prenume = prenume; student.Facultate = facultate; student.An = Convert.ToInt32(an); student.ETag = "*"; var updateOperation = TableOperation.Replace(student); await studentsTable.ExecuteAsync(updateOperation); System.Console.WriteLine("S-a modificat!"); } else { System.Console.WriteLine("Nu s-a gasit studentul!"); } }
private static async Task EditStudent() { System.Console.WriteLine("Insert university:"); string university = Console.ReadLine(); System.Console.WriteLine("Insert cnp:"); string cnp = Console.ReadLine(); StudentEntity stud = await RetrieveRecordAsync(studentsTable, university, cnp); if (stud != null) { System.Console.WriteLine("Record exists!"); var student = new StudentEntity(university, cnp); System.Console.WriteLine("Insert firstName:"); string firstName = Console.ReadLine(); System.Console.WriteLine("Insert lastName:"); string lastName = Console.ReadLine(); System.Console.WriteLine("Insert faculty:"); string faculty = Console.ReadLine(); System.Console.WriteLine("Insert year of study:"); string year = Console.ReadLine(); student.FirstName = firstName; student.LastName = lastName; student.Faculty = faculty; student.Year = Convert.ToInt32(year); student.ETag = "*"; var updateOperation = TableOperation.Replace(student); await studentsTable.ExecuteAsync(updateOperation); System.Console.WriteLine("Record updated!"); } else { System.Console.WriteLine("Record does not exists!"); } }
public async Task <Device> Update(Device device) { TableOperation retrieveOperation = TableOperation.Retrieve <DeviceEntity>(device.UserEmail, device.Id); TableResult retrievedResult = await cloudTable.ExecuteAsync(retrieveOperation); var dev = new DeviceEntity(); if (retrievedResult.Result != null) { dev = retrievedResult.Result as DeviceEntity; dev.Id = device.Id; dev.Name = device.Name; dev.IconName = device.IconName; dev.Description = device.Description; dev.Status = device.Status; dev.IsOn = device.IsOn; dev.UserEmail = device.UserEmail; var updateOperation = TableOperation.Replace(dev); await cloudTable.ExecuteAsync(updateOperation); return(device); } return(null); }
public async Task <Device> TurnOnOffDevice(Device device) { TableOperation retrieveOperation = TableOperation.Retrieve <DeviceEntity>(device.UserEmail, device.Id); TableResult retrievedResult = await cloudTable.ExecuteAsync(retrieveOperation); var dev = new DeviceEntity(); if (retrievedResult.Result != null) { dev = retrievedResult.Result as DeviceEntity; dev.IsOn = device.IsOn; var updateOperation = TableOperation.Replace(dev); var tblResult = await cloudTable.ExecuteAsync(updateOperation); // guardar datos aqui var blob = cloudBlobContainer.GetAppendBlobReference("usage.txt"); // Interesante solución // https://stackoverflow.com/questions/7653876/azure-updating-an-existing-xml-file-in-blob-storage await blob.AppendTextAsync("Super smash bros ultimate\n"); return(device); } return(null); }
private static CustomerEntity ReplaceAnEntity(CloudTable table) { 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. return((CustomerEntity)table.Execute(updateOperation).Result); } return(null); }
public User LogIn(User user) { //este user tem so email e password try { TableQuery <ModeloTableUser> query = new TableQuery <ModeloTableUser>().Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, user.Email)); List <ModeloTableUser> resultado = table.ExecuteQuery(query).ToList <ModeloTableUser>(); if (resultado.Count == 1) { foreach (var userDB in resultado) { if (userDB.RowKey == user.Email && userDB.PartitionKey == user.Password) { user.Nome = userDB.Nome; user.Apelido = userDB.Apelido; user.QuantLogins = userDB.QuantLogins + 1; user.Autenticado = true; //Atualiza quantidade de logins e se esta autenticado. TableOperation update = TableOperation.Replace(UserToModelTableUser(user)); table.Execute(update); } } } } catch (Exception ex) { Console.WriteLine(ex.Message); } if (user.Nome == null && user.Apelido == null) { user = null; } return(user); }
/// <summary> /// Updates the <see cref="T"/> in the Role store. /// </summary> /// <param name="role"><see cref="T"/></param> /// <returns><see cref="Task"/></returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="role"/> is <c>null</c>.</exception> /// <see cref="AzureTableRoleException">Thrown whenever a table operation results in a <see cref="StorageException"/> being thrown.</see> /// <see cref="AzureTableRoleException">Thrown whenever a table operation results in a <see cref="StorageException"/> being thrown.</see> public virtual async Task UpdateAsync(T role) { AssertNotDisposed(); if (role == null) { throw new ArgumentNullException("role"); } if (string.IsNullOrWhiteSpace(role.RowKey)) { throw new ArgumentException("Role Id not set", "role"); } var op = TableOperation.Replace(role.EnsureETagSet()); try { var result = await Run(RoleTableName, op); role.ETag = result.Etag; } catch (StorageException ex) { throw new AzureTableRoleException("An exception was thrown while attempting to update this role. See the inner exception for details.", ex); } }
private static string UpdateCostMasterLastProcessedDateWithTodaysDate(ILogger log) { TableOperation tableOperation; string storageConnectionString = SourceConnection; log.LogInformation("**** In Test Method ****"); CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(storageConnectionString); CloudTableClient tableClient = cloudStorageAccount.CreateCloudTableClient(); string tableName = "CostsMaster"; CloudTable cloudTable = tableClient.GetTableReference(tableName); CostMasterEntity costMasterEntity = new CostMasterEntity("2020", "1"); costMasterEntity.LastProcessedDate = DateTime.Now.ToString("dd'/'MM'/'yyyy"); // retrieve record var retrieverResult = RetrieveRecord(cloudTable, "2020", "1"); if (retrieverResult == null) { // if not found tableOperation = TableOperation.Insert(costMasterEntity); } else { // update costMasterEntity.ETag = "*"; tableOperation = TableOperation.Replace(costMasterEntity); } var result = cloudTable.ExecuteAsync(tableOperation); //CreateNewTable(cloudTable, log); return(result.Status.ToString()); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "put", Route = null)] HttpRequest req, // Invoce Microsoft.WindowsAzure.Storage.Table, which will connect to the employees table [Table("employees", Connection = "TableStorageConnection")] CloudTable cloudTable, ILogger log) { string requestBody = await new StreamReader(req.Body).ReadToEndAsync(); dynamic data = JsonConvert.DeserializeObject(requestBody); string employeeId = data.Id; string updatedEmployeeName = data.Name; string updatedEmployeeDepartment = data.Department; // TableEntity is required for TableOperation.Replace Employee updatedEmployeeData = new Employee(employeeId, updatedEmployeeName, updatedEmployeeDepartment); // Replace (PUT) the data entry. Trying to update RowKey or PartitionKey would result in error. // If that is needed the entity has to be deleted and recreated. TableOperation operation = TableOperation.Replace(updatedEmployeeData); await cloudTable.ExecuteAsync(operation); return(new OkObjectResult($"The employee data of {updatedEmployeeName} has been updated!")); }
public static async Task CancelOrphanPlans( [TimerTrigger("0 05 12 * * *")] TimerInfo timer, // 12:05AM daily [Table("plans")] CloudTable plansTable, [Table("proposals")] CloudTable proposalsTable, IBinder binder) { Utils.SetCulture(); var plans = await GetTodayPlansWithoutResponsible(plansTable); foreach (var plan in plans) { if (!string.IsNullOrWhiteSpace(plan.Video)) { var proposal = await proposalsTable.Retrieve <Proposal>(plan.PartitionKey, plan.Video); if (proposal != null) { proposal.PlannedIn = ""; await proposalsTable.ExecuteAsync(TableOperation.Replace(proposal)); } } var result = await plansTable.ExecuteAsync(TableOperation.Delete(plan)); if (result.IsError()) { continue; } await SlackHelper.PostMessage(binder, plan.Team, new PostMessageRequest { Channel = plan.Channel, Text = "Le Lunch & Watch de ce midi a été annulé car aucun responsable ne s'est manifesté." }); } }
private static async Task EditStudent() { System.Console.WriteLine("Introduceti universitatea:"); string university = Console.ReadLine(); System.Console.WriteLine("Introduceti cnp:"); string cnp = Console.ReadLine(); StudentEntity stud = await RetrieveRecordAsync(studentsTable, university, cnp); if (stud != null) { System.Console.WriteLine("Intregistrarea exista deja!"); var student = new StudentEntity(university, cnp); System.Console.WriteLine("Introduceti numele de familie:"); string firstName = Console.ReadLine(); System.Console.WriteLine("Introduceti prenumele:"); string lastName = Console.ReadLine(); System.Console.WriteLine("Introduceti facultatea: "); string faculty = Console.ReadLine(); System.Console.WriteLine("Introduceti anul de studiu: "); string year = Console.ReadLine(); student.FirstName = firstName; student.LastName = lastName; student.Faculty = faculty; student.Year = Convert.ToInt32(year); student.ETag = "*"; var updateOperation = TableOperation.Replace(student); await studentsTable.ExecuteAsync(updateOperation); System.Console.WriteLine("Modificarea s-a facut cu succes"); } else { System.Console.WriteLine("Inregistrarea nu exista"); } }
public void ReplaceBook(Book b) { operation = TableOperation.Replace(b); _table.Execute(operation); }
private static async Task UpdateInvestor(CloudTable cloudTable, Investor investor) { var operation = TableOperation.Replace(investor); await cloudTable.ExecuteAsync(operation); }
public static async Task Run([TimerTrigger("0 */5 * * * *")] TimerInfo myTimer, [Table("EventsTable")] CloudTable currentEvents, [SignalR(HubName = "broadcastConflicts")] IAsyncCollector <SignalRMessage> signalRMessages, ILogger log) { try { log.LogInformation($"Appointments Conflicts Detector Timer trigger function executed at: {DateTime.Now}"); DateTimeOffset dateTimeOffset = DateTimeOffset.Now.AddMinutes(-5); var partitionFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "BookingAppointmentEvent"); var IsConflictedFilter = TableQuery.GenerateFilterConditionForBool("IsConflicted", QueryComparisons.Equal, true); var IsConflictShownFilter = TableQuery.GenerateFilterConditionForBool("IsConflictShown", QueryComparisons.Equal, false); var dateFilter = TableQuery.GenerateFilterConditionForDate("EventCreationDate", QueryComparisons.LessThanOrEqual, dateTimeOffset); var filter = TableQuery.CombineFilters( dateFilter, TableOperators.And, TableQuery.CombineFilters( TableQuery.CombineFilters(partitionFilter, TableOperators.And, IsConflictedFilter), TableOperators.And, IsConflictShownFilter)); TableQuery <Event> rangeQuery = new TableQuery <Event>().Where(filter); List <AppointmentEvent> appointmentEventsWithConflicts = new List <AppointmentEvent>(); var conflictedEvents = await currentEvents.ExecuteQuerySegmentedAsync(rangeQuery, null); foreach (var conflictedEvent in conflictedEvents) { log.LogInformation($"{conflictedEvent.PartitionKey}\t{conflictedEvent.RowKey}\t{conflictedEvent.Timestamp}\t{conflictedEvent.EventId}"); var originalAppointmentEvent = appointmentEventsWithConflicts.Find(x => x.EventId == conflictedEvent.OriginalEventId); if (originalAppointmentEvent != null) { originalAppointmentEvent.ConflictedEvents.Add(conflictedEvent); } else { appointmentEventsWithConflicts.Add(new AppointmentEvent() { EventId = conflictedEvent.OriginalEventId, EventReferenceNo = conflictedEvent.OriginalEventId.ToString().Substring(0, conflictedEvent.OriginalEventId.ToString().IndexOf("-")), ConflictedEvents = new List <Event>() { conflictedEvent } }); } conflictedEvent.IsConflictShown = true; await currentEvents.ExecuteAsync(TableOperation.Replace(conflictedEvent)); } if (appointmentEventsWithConflicts.Any()) { await signalRMessages.AddAsync(new SignalRMessage { Target = "appointmentConflictDetected", Arguments = new[] { appointmentEventsWithConflicts } }); } } catch (Exception ex) { log.LogInformation($"AppointmentsConflictsDetector Timer trigger function executed at: {DateTime.Now} exception:{ex.Message}"); } }
public async Task <int> IncrementCountAsync(Repository repository) { string partitionKey = $"{repository.OrganizationId}_{repository.RepositoryId}"; string rowKey = string.Empty; TableOperation retrieveOperation = TableOperation.Retrieve <EventStatsTableEntity>(partitionKey, rowKey); try { TableResult retrieveResult = await this.table.ExecuteAsync(retrieveOperation).ConfigureAwait(false); int retrieveStatusCode = retrieveResult.HttpStatusCode; if (retrieveStatusCode == 404) // Not found { TableOperation insertOperation = TableOperation.Insert(new EventStatsTableEntity(repository, eventCount: 1)); try { await this.table.ExecuteAsync(insertOperation).ConfigureAwait(false); return(1); } catch (Exception insertException) when(insertException is StorageException) { StorageException insertStorageException = (StorageException)insertException; int insertStatusCode = insertStorageException.RequestInformation.HttpStatusCode; if (insertStatusCode == 409) // Conflict { // We were too late to insert, so someone else did it. Retry. await this.IncrementCountAsync(repository).ConfigureAwait(false); } else { Dictionary <string, string> properties = new Dictionary <string, string>() { { "OrganizationLogin", repository.OrganizationLogin }, { "RepositoryName", repository.RepositoryName }, { "ErrorMessage", insertStorageException.Message }, { "ErrorReturnCode", insertStatusCode.ToString() }, }; this.telemetryClient.TrackEvent("BookkeepingError", properties); } } } else if (retrieveStatusCode == 200) { EventStatsTableEntity retrieveStats = (EventStatsTableEntity)retrieveResult.Result; string retrieveETag = retrieveResult.Etag; int currentEventCount = retrieveStats.EventCount; TableOperation replaceOperation = TableOperation.Replace(new EventStatsTableEntity(repository, currentEventCount + 1, retrieveETag)); try { await this.table.ExecuteAsync(replaceOperation).ConfigureAwait(false); return(currentEventCount + 1); } catch (Exception replaceException) when(replaceException is StorageException) { StorageException replaceStorageException = (StorageException)replaceException; int replaceStatusCode = replaceStorageException.RequestInformation.HttpStatusCode; if (replaceStatusCode == 412) // Pre-condition failed { // We were too late to update, so someone else did it. Retry. return(await this.IncrementCountAsync(repository).ConfigureAwait(false)); } else { Dictionary <string, string> properties = new Dictionary <string, string>() { { "OrganizationLogin", repository.OrganizationLogin }, { "RepositoryName", repository.RepositoryName }, { "ErrorMessage", replaceException.Message }, { "ErrorReturnCode", replaceStatusCode.ToString() }, }; this.telemetryClient.TrackEvent("BookkeepingError", properties); } } } else { Dictionary <string, string> properties = new Dictionary <string, string>() { { "OrganizationLogin", repository.OrganizationLogin }, { "RepositoryName", repository.RepositoryName }, { "ErrorReturnCode", retrieveStatusCode.ToString() }, }; this.telemetryClient.TrackEvent("BookkeepingError", properties); } } catch (Exception exception) { Dictionary <string, string> properties = new Dictionary <string, string>() { { "OrganizationLogin", repository.OrganizationLogin }, { "RepositoryName", repository.RepositoryName }, { "ErrorReturnCode", exception.ToString() }, { "ErrorType", exception.GetType().ToString() }, }; this.telemetryClient.TrackEvent("BookkeepingError", properties); } return(0); }
public Task ResetCountAsync(Repository repository) { TableOperation replaceOperation = TableOperation.Replace(new EventStatsTableEntity(repository, 0, eTag: "*")); return(this.table.ExecuteAsync(replaceOperation)); }
protected override TableOperation AsTableOperation() { return(TableOperation.Replace(Entity)); }
private void UpdateCustomer(CloudTable cloudTable, CustomerUK customerToUpdate) { TableOperation update = TableOperation.Replace(customerToUpdate); cloudTable.Execute(update); }
public async Task UpdateBikeAsync(Bike bike) { var operation = TableOperation.Replace(bike); await _table.ExecuteAsync(operation); }
public void UpdateOCRJob(OCRJob job) { TableOperation insertOperation = TableOperation.Replace(job); table.Execute(insertOperation); }
public async Task UpdateOrder(Order order) { var entity = CreateOrderEntity(order); var op = TableOperation.Replace(entity); await ExecutionContext.TableStorage.ExecuteAsync(op); }
public static async Task <IActionResult> PostOrchestration( // Using /a/p/i route prefix, to let Functions Host distinguish api methods from statics [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "a/p/i/orchestrations('{instanceId}')/{action?}")] HttpRequest req, string instanceId, string action, [DurableClient(TaskHub = "%DFM_HUB_NAME%")] IDurableClient durableClient) { // Checking that the call is authenticated properly try { Globals.ValidateIdentity(req.HttpContext.User, req.Headers); } catch (UnauthorizedAccessException ex) { return(new OkObjectResult(ex.Message) { StatusCode = 401 }); } string bodyString = await req.ReadAsStringAsync(); switch (action) { case "purge": await durableClient.PurgeInstanceHistoryAsync(instanceId); break; case "rewind": await durableClient.RewindAsync(instanceId, bodyString); break; case "terminate": await durableClient.TerminateAsync(instanceId, bodyString); break; case "raise-event": dynamic bodyObject = JObject.Parse(bodyString); string eventName = bodyObject.name; JObject eventData = bodyObject.data; await durableClient.RaiseEventAsync(instanceId, eventName, eventData); break; case "set-custom-status": string connectionString = Environment.GetEnvironmentVariable(EnvVariableNames.AzureWebJobsStorage); string hubName = Environment.GetEnvironmentVariable(EnvVariableNames.DFM_HUB_NAME); // Updating the table directly, as there is no other known way var tableClient = CloudStorageAccount.Parse(connectionString).CreateCloudTableClient(); var table = tableClient.GetTableReference($"{hubName}Instances"); var orcEntity = (await table.ExecuteAsync(TableOperation.Retrieve(instanceId, string.Empty))).Result as DynamicTableEntity; if (string.IsNullOrEmpty(bodyString)) { orcEntity.Properties.Remove("CustomStatus"); } else { // Ensuring that it is at least a valid JSON string customStatus = JObject.Parse(bodyString).ToString(); orcEntity.Properties["CustomStatus"] = new EntityProperty(customStatus); } await table.ExecuteAsync(TableOperation.Replace(orcEntity)); break; default: return(new NotFoundResult()); } return(new OkResult()); }
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req, ILogger log) { log.LogTrace("C# HTTP trigger function processed a request."); dynamic body = await req.Content.ReadAsStringAsync(); var data = JsonConvert.DeserializeObject <LoginRepsonse>(body as string); // parse query parameter Guid? CompanyId = data?.CompanyId; string oldUserName = null, oldPassword = null, UserName = null, Password = null; string connectionstring2 = "DefaultEndpointsProtocol=https;AccountName=spassessservices20190227;AccountKey=KLx/VDJ279oOZ2Z2wELr90GauiVlEN4pr8r2ss2xAiokZJGAi4PF6eGz0nI0Vz0IieEwtKxqkgoM+ukeVoWxMw==;EndpointSuffix=core.windows.net"; if (data?.UserName == null && data?.Password == null) { return(req.CreateResponse(HttpStatusCode.BadRequest, "Please pass a username and password")); } if (data?.newUserName != null || data?.newPassword != null) { oldUserName = data?.UserName; oldPassword = data?.Password; UserName = data?.newUserName; Password = data?.newPassword; } else { UserName = data?.UserName; Password = data?.Password; oldUserName = UserName; oldPassword = Password; } Login login; try { //this code will do a insert and do a check for the id CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionstring2); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); //first call to get the login and verify CloudTable cloudTable = tableClient.GetTableReference("Login"); TableOperation tableOperation = TableOperation.Retrieve <Login>(oldUserName, oldPassword); TableResult tableResult = await cloudTable.ExecuteAsync(tableOperation); login = tableResult.Result as Login; if (login == null) { var newLogin = new Login() { PartitionKey = UserName, RowKey = Password, CompanyId = UpsertCompany.GenerateCompanyId(), UserName = UserName, Password = Password, oldUserName = oldUserName, oldPassword = oldPassword }; TableOperation insertOperation = TableOperation.Insert(newLogin); TableResult insertResult = await cloudTable.ExecuteAsync(insertOperation); return(req.CreateResponse(HttpStatusCode.Created, "successful")); } else { var updateLogin = new Login() { PartitionKey = UserName, RowKey = Password, CompanyId = login.CompanyId, UserName = UserName, Password = Password, oldUserName = oldUserName, oldPassword = oldPassword, ETag = "*" }; var operation = TableOperation.Replace(updateLogin); await cloudTable.ExecuteAsync(operation); return(req.CreateResponse(HttpStatusCode.Created, "successful")); } } catch (StorageException se) { log.LogTrace(se.Message); } catch (Exception ex) { log.LogTrace(ex.Message); } return(req.CreateResponse(HttpStatusCode.Created, "successful")); }
/// <summary> /// Updates the table entity into the Azure Table storage /// </summary> /// <param name="tableEntity">The entity to update to the Azure Table Storage</param> /// <returns>The table result from the Execute statement</returns> public TableResult Update(TableEntity tableEntity) { return(_cloudTable.Execute(TableOperation.Replace(tableEntity))); }
public async Task ReplaceAsync(T item) { item.PrepareForSave(); var operation = TableOperation.Replace(item); await _tableClient.ExecuteAsync(operation); }
public bool UpdateScore(CycleIdentifier cycle, int checkpoint, long timestampTicks, CpScore cpScore) { var scoreEntity = _cycleScoresCache[cycle.Id]; if (scoreEntity.Timestamp.Ticks != timestampTicks)//final check before we overwrite something we didn't mean to { return(false); } scoreEntity.SaveScores(checkpoint, cpScore); //this does update scoreEntity.TimeStamp _cloudTable.Execute(scoreEntity.Timestamp == DateTimeOffset.MinValue ? TableOperation.Insert(scoreEntity) : TableOperation.Replace(scoreEntity)); //should we check the _cloudTable.Execute().HttpStatusCode ?? return(true); //what is the new TimeStamp?? //else it's not the right timestamp }
public async Task UpdateAsync(LocalAuthoritySet item) => await Table.ExecuteAsync(TableOperation.Replace(item));
public async Task UpdateTask(DocumentTaskEntity document) { TableOperation taskTableOp = TableOperation.Replace(document); TableResult taskTableResult = await documentTaskTable.ExecuteAsync(taskTableOp); }