public async Task DeactivatePollAsync(string id) { var poll = await this._dbContext.LoadAsync <PollDefinition>(id); var activeRecord = new ActivePoll { Id = id, ActivatedTime = DateTime.Now }; await _dbContext.DeleteAsync <ActivePoll>(id); await UpdatePollStateAsync(id, PollDefinition.POLL_STATE_EXPIRED); }
public async Task <IActionResult> Delete(string petId) { _logger.LogInformation("Iniciando Delete"); Pets item = await _context.LoadAsync <Pets>(petId); if (item == null) { return(NotFound()); } await _context.DeleteAsync <Pets>(petId); return(NoContent()); }
public async Task <IActionResult> Delete(string id, string projectName) { var context = new DynamoDBContext(_dynamoDbClient); // load project var projectModel = new ProjectModel { SolutionName = id, ProjectName = projectName }; var project = await context.LoadAsync(projectModel); // delete project await context.DeleteAsync(project); return(RedirectToAction("Index")); }
public IActionResult DeleteByIdBaseMaterials(int id) { DynamoDBContext aws_Context = new DynamoDBContext(client); try { aws_Context.DeleteAsync <BaseMaterials>(id); return(helpController.jsonResponseMessage(id, "Data is Deleted!", 0)); } catch (AmazonDynamoDBException e) { Console.WriteLine(e.Message); } catch (AmazonServiceException e) { Console.WriteLine(e.Message); } catch (Exception e) { Console.WriteLine(e.Message); } return(null); }
public async Task Delete(Guid id) { // Delete the book. await context.DeleteAsync <Book>(id); // Try to retrieve deleted book. It should return null. Book deletedBook = await context.LoadAsync <Book>(id, new DynamoDBContextConfig { ConsistentRead = true }); if (deletedBook == null) { LambdaLogger.Log($"Book {id} is deleted"); } }
public virtual async Task RemoveAsync(string key) { try { using (var dBContext = new DynamoDBContext(dynamoDBClient, dynamoDBOptions.DynamoDBContextConfig)) { logger.LogInformation("removing {key} persisted grant from DynamoDB database", key); await dBContext.DeleteAsync <Models.PersistedGrant>(key); } } catch (Exception ex) { logger.LogError(ex, "exception removing {key} persisted grant from database", key); throw; } }
public async Task <bool> DeletePlayersAsync(Player player) { try { DynamoDBContext context = new DynamoDBContext(_dynamoDbClient); await context.DeleteAsync <Player>(player); return(true); } catch (Exception ex) { Console.WriteLine(ex.Message); Console.WriteLine(ex); return(false); } }
public async void DeleteContact() { var client = new AmazonDynamoDBClient(); DynamoDBContext dbcontext = new DynamoDBContext(client); try { await dbcontext.DeleteAsync <Contact>(this.Email); Console.WriteLine($"Deleted {this.Email} successfully."); } catch (System.Exception) { Console.WriteLine($"Exception thrown while attempting to delete {this.Email}"); } }
private void DeleteObjectFromDB(DynamoDBContext context) { context.DeleteAsync <PlacedObject>(1, (res) => { if (res.Exception == null) { context.LoadAsync <PlacedObject>(1, (result) => { PlacedObject deletedBook = result.Result; if (deletedBook == null) { Debug.Log("Object Deleted"); } }); } }); }
public async Task <HttpResponse> FunctionHandler(MessageKeys key, ILambdaContext context) { var message = new MessageDbDto { Id = key.Id, Time = key.Time }; await dbContext.DeleteAsync(message, new DynamoDBOperationConfig { OverrideTableName = Environment.GetEnvironmentVariable("MESSAGES_TABLE") }); return(new HttpResponse { statusCode = HttpStatusCode.OK }); }
public async Task <bool> DeleteUser(string key) { //get user from key User deleteUser = await _context.LoadAsync <User>(key, new DynamoDBContextConfig { ConsistentRead = true }); if (deleteUser != null) { await _context.DeleteAsync <User>(deleteUser); return(true); } return(false); }
public async Task Confirm(ConfirmAdvertModel model) { using var client = new AmazonDynamoDBClient(); using var context = new DynamoDBContext(client); var record = await context.LoadAsync <AdvertDbModel>(model.Id) ?? throw new KeyNotFoundException($"A record with ID = {model.Id} was not found"); if (model.Status == AdvertStatus.Active) { record.Status = AdvertStatus.Active; await context.SaveAsync(record); } else { await context.DeleteAsync(record); } }
private static async Task TestCRUDOperations(DynamoDBContext context) { int bookID = 1001; // Some unique value. Book myBook = new Book { Id = bookID, Title = "object persistence-AWS SDK for.NET SDK-Book 1001", ISBN = "111-1111111001", BookAuthors = new List <string> { "Author 1", "Author 2" }, }; // Save the book. await context.SaveAsync(myBook); // Retrieve the book. Book bookRetrieved = await context.LoadAsync <Book>(bookID); // Update few properties. bookRetrieved.ISBN = "222-2222221001"; bookRetrieved.BookAuthors = new List <string> { " Author 1", "Author x" }; // Replace existing authors list with this. await context.SaveAsync(bookRetrieved); // Retrieve the updated book. This time add the optional ConsistentRead parameter using DynamoDBContextConfig object. Book updatedBook = await context.LoadAsync <Book>(bookID, new DynamoDBContextConfig { ConsistentRead = true }); // Delete the book. await context.DeleteAsync <Book>(bookID); // Try to retrieve deleted book. It should return null. Book deletedBook = await context.LoadAsync <Book>(bookID, new DynamoDBContextConfig { ConsistentRead = true }); if (deletedBook == null) { Console.WriteLine("Book is deleted"); } }
public async Task <IActionResult> DeleteConfirmed(int id) { var dynamoContext = new DynamoDBContext(dynamoDb); var movie = await _context.Movie.FindAsync(id); var userM = await _context.UserMovie .FirstOrDefaultAsync(m => m.MovieId == id); // Delete comments for that movie await dynamoContext.DeleteAsync <Comments>(movie.Id); _context.Movie.Remove(movie); _context.UserMovie.Remove(userM); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); }
public async Task ConfirmAsync(ConfirmAdvertModel model) { DynamoDBContext context = new DynamoDBContext(_client); var record = await context.LoadAsync <AdvertDbModel>(model.Id); if (record == null) { throw new KeyNotFoundException($"A record with ID={model.Id} was not found."); } if (model.Status == AdvertStatus.Active) { record.Status = AdvertStatus.Active; await context.SaveAsync(record); } else { await context.DeleteAsync(record); } }
public async Task DeleteAsync(User userProperties) { try { var config = new DynamoDBContextConfig { TableNamePrefix = TablePrefix, SkipVersionCheck = true, }; var context = new DynamoDBContext(Client, config); await context.DeleteAsync(userProperties); } catch (Exception ex) { _logger.LogError(ex, "Exception deleting user properties." + ex.Message); throw; } }
public async Task DeactivatePoll(string id) { await _dbContext.DeleteAsync <ActivePoll>(id); await UpdatePollStateAsync(id, PollDefinition.POLL_STATE_EXPIRED); var poll = await this._dbContext.LoadAsync <PollDefinition>(id); var message = new StringBuilder(); message.AppendFormat("Poll {0} has expired, final results are:\n", poll.Title); foreach (var option in poll.Options.Values.OrderByDescending(x => x.Votes)) { message.AppendFormat("\t{0}: {1} Votes\n", option.Text, option.Votes); } await this._snsClient.PublishAsync(poll.TopicArn, message.ToString(), string.Format("Poll {0} has expired", poll.Title)); }
/// <summary> /// Removes all async. /// /// subjectId && clientId && type /// /// see https://github.com/IdentityServer/IdentityServer4/blob/325ea0e67b1de2c836f26eb38436ff07177028d4/src/IdentityServer4/Stores/InMemory/InMemoryPersistedGrantStore.cs#L110 /// /// </summary> /// <returns>The all async.</returns> /// <param name="subjectId">Subject identifier.</param> /// <param name="clientId">Client identifier.</param> /// <param name="type">Type.</param> public async Task RemoveAllAsync(string subjectId, string clientId, string type) { if (string.IsNullOrEmpty(subjectId) || string.IsNullOrEmpty(clientId) || string.IsNullOrEmpty(type)) { await Task.FromException(new ArgumentNullException($"PersistedGrantRepository.RemoveAllAsync subjectId:{subjectId} And/Or clientId:{clientId} And/Or type:{type} is null")); return; } List <ScanCondition> conditions = new List <ScanCondition>(); conditions.Add(new ScanCondition(nameof(subjectId), ScanOperator.Equal, subjectId)); conditions.Add(new ScanCondition(nameof(clientId), ScanOperator.Equal, clientId)); conditions.Add(new ScanCondition(nameof(type), ScanOperator.Equal, type)); try { using (var context = new DynamoDBContext(client, ddbConfig)) { var batch = context.ScanAsync <PersistedGrantDynamoDB>(conditions); while (!batch.IsDone) { var dataset = await batch.GetNextSetAsync(); if (dataset.Any()) { dataset.ForEach(async item => await context.DeleteAsync(item)); } } } } catch (Exception ex) { logger.LogError(default(EventId), ex, "PersistedGrantRepository.RemoveAllAsync failed with subjectId: {subjectId}, clientId: {clientId}", subjectId, clientId); await Task.FromException(ex); return; } await Task.CompletedTask; return; }
public async Task <bool> DeletePackageAsync(AnnotationPackage package) { try { var successful = true; // Delete images on S3 foreach (var image in package.Images) { if (!await this.DeleteImageAsync(image).ConfigureAwait(false)) { successful = false; } } // Delete package from DynamoDB using (var context = new DynamoDBContext(this._dynamoDbClient)) { var dbConfig = new DynamoDBOperationConfig { OverrideTableName = this._dbTableName }; await context.DeleteAsync(new AnnotationPackageDto { Id = package.ExternalId }, dbConfig).ConfigureAwait(false); } // Delete local folder var path = Path.Combine(this._extractionFolder, package.PackageName); if (Directory.Exists(path)) { Directory.Delete(path, true); } return(successful); } catch (Exception e) { return(false); } }
public static async Task ExecuteAsync() { var credentials = new BasicAWSCredentials("AKIAZEFCLWDDRHQZKD7U", "0D4KlTb4COgrY8hupdQPnbBANTRwQP448I8nTxGw"); AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials, RegionEndpoint.SAEast1); using (DynamoDBContext context = new DynamoDBContext(client)) { User user = new User() { Active = true, Address = "Rua Vicente Savi , n12", Email = "*****@*****.**", FirstName = "wesley", LastName = "azevedo bezerra", Interests = new List <string> { "Futebol", "Video Game", "Gastronomia", "Viajens" }, NumberOfChildren = 0 }; await context.SaveAsync(user); Console.WriteLine("User Saved"); User loadUser = await context.LoadAsync <User>(user.Email); Console.WriteLine("Reading User"); PrintUser(loadUser); await context.DeleteAsync <User>(user.Email); Console.WriteLine("User Delete"); } }
public async Task Confirm(ConfirmAdvertModel model) { using (var context = new DynamoDBContext(_amazonDynamoDB)) { var record = await context.LoadAsync <AdvertDTO>(model.ID); if (record == null) { throw new Exception("record not found"); } if (record.Status == AdvertStatus.Success) { await context.SaveAsync(record); } else { await context.DeleteAsync(model.ID); } } }
/// <summary> /// Deletes a recipe from the database. Returns false if something went wrong, or /// true if it was deleted successfully. /// </summary> public async Task <bool> DeleteRecipe(Recipe recipe) { if (recipe == null) { return(false); } var context = new DynamoDBContext(_client); try { await context.DeleteAsync(recipe); return(true); } catch (AmazonDynamoDBException) { return(false); } }
//we can't update sort key //https://stackoverflow.com/questions/55474664/dynamoddb-how-to-update-sort-key/55474827 public async Task UpdateName(string countryId, string oldName, string newName) { Profile profile = await _context.LoadAsync <Profile>(countryId, oldName); if (profile != null) { await _context.DeleteAsync <Profile>(countryId, oldName); profile.Name = newName; await _context.SaveAsync <Profile>(profile); Console.WriteLine("Item updated"); Console.WriteLine(); await ScanAll(); } else { Console.WriteLine("Item not found!"); } }
public async Task <bool> DeleteUser(object key, ILambdaContext context) { context.Logger.Log("DELETE USER: " + key); InitializeDB(); //get user from key User deleteUser = await _context.LoadAsync <User>(key, new DynamoDBContextConfig { ConsistentRead = true }); if (deleteUser != null) { await _context.DeleteAsync <User>(deleteUser); return(true); } return(false); }
public async Task <bool> DeleteChannelsFromUserIdAsync(string userId) { // context DynamoDBContext context = new DynamoDBContext(_dynamoDBClient); // creating an UserChannels object just for its UserId // DynamoDb will delete the record matching has this UserId UserChannels userChannels = new UserChannels { UserId = userId }; // delete await context.DeleteAsync(userChannels); // dispose context context.Dispose(); return(true); }
public async Task Confirm(ConfirmAdvertisement confirm) { using var context = new DynamoDBContext(_client); var dbModel = await context.LoadAsync <AdvertisementDb>(confirm.Id); if (dbModel is null) { throw new KeyNotFoundException($"A record with ID={confirm.Id} has not been found"); } if (confirm.Status == AdvertisementStatus.Active) { dbModel.FilePath = confirm.FilePath; dbModel.Status = AdvertisementStatus.Active; await context.SaveAsync(dbModel); } else { await context.DeleteAsync(dbModel); } }
private void DeleteBook() { this.displayMessage += "\n*** Delete book**\n"; if (retrievedBook == null) { this.displayMessage += "\nCan't perform DeleteBook() before RetrieveBook()"; return; } // Update the book. context.DeleteAsync <Book>(retrievedBook, (AmazonDynamoResult <VoidResponse> result) => { if (result.Exception != null) { this.displayMessage += ("Delete error" + result.Exception.Message); Debug.LogException(result.Exception); return; } this.displayMessage += ("Delete Book{" + retrievedBook.Id + "} from DynamoDB Complete ! \n"); }, null); }
public virtual async Task RemoveAllAsync(PersistedGrantFilter filter) { try { var conditions = new List <ScanCondition>(); if (!string.IsNullOrEmpty(filter.SubjectId)) { conditions.Add(new ScanCondition(nameof(filter.SubjectId), ScanOperator.Equal, filter.SubjectId)); } if (!string.IsNullOrEmpty(filter.ClientId)) { conditions.Add(new ScanCondition(nameof(filter.ClientId), ScanOperator.Equal, filter.ClientId)); } if (!string.IsNullOrEmpty(filter.SessionId)) { conditions.Add(new ScanCondition(nameof(filter.SessionId), ScanOperator.Equal, filter.SessionId)); } if (!string.IsNullOrEmpty(filter.Type)) { conditions.Add(new ScanCondition(nameof(filter.Type), ScanOperator.Equal, filter.Type)); } var data = new List <PersistedGrant>(); using (var dBContext = new DynamoDBContext(dynamoDBClient, dynamoDBOptions.DynamoDBContextConfig)) { var result = await dBContext.ScanAsync <Models.PersistedGrant>(conditions).GetRemainingAsync(); logger.LogInformation("removing {grantKeysCount} persisted grants from DynamoDB database for subject {subjectId}, clientId {clientId}, grantType {type} and session {session}", result.Count(), filter.SubjectId, filter.ClientId, filter.Type, filter.SessionId); foreach (var grant in result) { await dBContext.DeleteAsync <Models.PersistedGrant>(grant); } } } catch (Exception ex) { logger.LogError(ex, "exception removing persisted grants from database for subject {subjectId}, clientId {clientId}, grantType {type} and session {session}", filter.SubjectId, filter.ClientId, filter.Type, filter.SessionId); throw; } }
public async Task ConfirmAsync(ConfirmAdvertModel confirmAdvert) { using (var client = new AmazonDynamoDBClient()) { using (var context = new DynamoDBContext(client)) { var record = await context.LoadAsync<AdvertForCreationDto>(confirmAdvert.Id); if (record == null) throw new KeyNotFoundException($"A record with ID={confirmAdvert.Id} was not found."); if (confirmAdvert.Status == AdvertStatus.Active) { record.FilePath = confirmAdvert.FilePath; record.Status = AdvertStatus.Active; await context.SaveAsync(record); } else { await context.DeleteAsync(record); } } } }
public async Task Confirm(ConfirmAdvertModel model) { using (var client = new AmazonDynamoDBClient()){ using (var context = new DynamoDBContext(client)){ var record = await context.LoadAsync <AdvertDBModel>(model.Id); if (record == null) { throw new KeyNotFoundException("Record With" + model.Id + "Not found"); } if (model.Status == AdvertStatus.Active) { record.Status = AdvertStatus.Active; await context.SaveAsync(record); } else { await context.DeleteAsync(record); } } } }
public async Task DeleteAsync(Guid instanceId, CancellationToken cancellationToken = default(CancellationToken)) { var context = new DynamoDBContext(Settings.AmazonDynamoDBClient); await context.DeleteAsync<TenTwentyAgency>(instanceId.ToString(), Settings.AgenciesRangeKeyValue, cancellationToken); }