public async Task <IdentityResult> DeleteAsync(ApplicationUser user, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); var tableName = "ApplicationUser"; Dictionary <string, AttributeValue> deleteDict = new Dictionary <string, AttributeValue>(); deleteDict.Add("NormalizedUserName", new AttributeValue(user.NormalizedUserName.ToLower())); await _client.DeleteItemAsync(tableName, deleteDict, cancellationToken); return(IdentityResult.Success); }
/// <summary> /// Delete item from a DynamoDB table. /// </summary> /// <param name="client">An initialized DynamoDB client.</param> /// <param name="table">The table from which the item will be removed.</param> /// <param name="id">The Id of the item to remove.</param> /// <param name="area">A string representing the value of the Area attribute.</param> /// <returns>A DeleteItemResponse object representing the response from the /// DeleteItemAsync call.</returns> public static async Task <DeleteItemResponse> RemoveItemAsync( IAmazonDynamoDB client, string table, string id, string area) { var request = new DeleteItemRequest { TableName = table, Key = new Dictionary <string, AttributeValue>() { { "ID", new AttributeValue { S = id } }, { "Area", new AttributeValue { S = area } }, }, }; var response = await client.DeleteItemAsync(request); return(response); }
public async Task DeleteSession(string sessionId) { await dynamoDb.DeleteItemAsync(TableName, new Dictionary <string, AttributeValue> { { "SessionId", new AttributeValue(sessionId) } }); }
public async Task DeleteAllBuddies() { var request = new ScanRequest { TableName = _tableName }; var response = await _dynamoDbClient.ScanAsync(request); var items = response.Items.Select(Map); foreach (var item in items) { var deleteRequest = new DeleteItemRequest { TableName = _tableName, Key = new Dictionary <string, AttributeValue> { ["Id"] = new AttributeValue { S = item.Id } } }; await _dynamoDbClient.DeleteItemAsync(deleteRequest); } }
public async Task <APIGatewayProxyResponse> FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context) { LambdaLogger.Log(JObject.FromObject(request).ToString()); try { var connectionId = request.RequestContext.ConnectionId; LambdaLogger.Log("ConnectionId:" + connectionId); Dictionary <string, AttributeValue> attributes = new Dictionary <string, AttributeValue>(); attributes["ConnectionId"] = new AttributeValue { S = connectionId }; DeleteItemRequest ddbRequest = new DeleteItemRequest() { TableName = Environment.GetEnvironmentVariable("DynamoChatTable"), Key = attributes }; DeleteItemResponse ddbResponse = ddbClient.DeleteItemAsync(ddbRequest).Result; return(new APIGatewayProxyResponse { StatusCode = 200, Body = "Disconnected." }); } catch (Exception e) { context.Logger.LogLine("Error connecting: " + e.Message); context.Logger.LogLine(e.StackTrace); return(new APIGatewayProxyResponse { StatusCode = 500, Body = $"Failed to connect: {e.Message}" }); } }
public async Task ServiceClientExampleAsync() { try { var request = new DeleteItemRequest { TableName = "RetailDatabase", Key = new Dictionary <string, AttributeValue> { { "pk", new AttributeValue { S = "*****@*****.**" } }, { "sk", new AttributeValue { S = "metadata" } } } }; var response = await amazonDynamoDB.DeleteItemAsync(request); Console.WriteLine($"DeleteItem succeeded."); } catch (Exception e) { Console.Error.WriteLine(e.Message); throw; } }
public async Task ReleaseLock(string Id) { if (_mutex.WaitOne()) { try { _localLocks.Remove(Id); } finally { _mutex.Set(); } } try { var req = new DeleteItemRequest() { TableName = _tableName, Key = new Dictionary <string, AttributeValue> { { "id", new AttributeValue(Id) } }, ConditionExpression = "lock_owner = :nodeId", ExpressionAttributeValues = new Dictionary <string, AttributeValue> { { ":nodeId", new AttributeValue(_nodeId) } } }; await _client.DeleteItemAsync(req); } catch (ConditionalCheckFailedException) { } }
public async Task <DeleteItemResponse> DeleteItems <T>(T tabelaInterna, string nomeTabela) { try { table = Table.LoadTable(_dynamoClient, nomeTabela); // DynamoDBContext db = new DynamoDBContext(_dynamoClient); // Document documentRequest = db.ToDocument(tabelaInterna); //Mapeando os campos chave = table.ToAttributeMap(documentRequest); //Verificar quais campos são necessarios chave = Utils.VerificarChaves(chave, table); // var deleteRequest = new DeleteItemRequest(nomeTabela, chave); // var deleteResponse = await _dynamoClient.DeleteItemAsync(deleteRequest, cancellationToken); // db.Dispose(); // return(deleteResponse); } catch (Exception ex) { throw ex; } }
public async Task ReleaseLock(string Id) { _lockTracker.Remove(Id); try { var req = new DeleteItemRequest() { TableName = _tableName, Key = new Dictionary <string, AttributeValue> { { "id", new AttributeValue(Id) } }, ConditionExpression = "lock_owner = :node_id", ExpressionAttributeValues = new Dictionary <string, AttributeValue> { { ":node_id", new AttributeValue(_nodeId) } } }; await _client.DeleteItemAsync(req); } catch (ConditionalCheckFailedException) { } }
public static async Task Movies_Remove(this IAmazonDynamoDB ddb, Guid id) { await ddb.DeleteItemAsync(new DeleteItemRequest { TableName = TableNames.Movies, Key = Keys.Movies(id), }); }
public Task DeleteTask(string messgageId) { return(_dynamoClient.DeleteItemAsync(_tableName, new Dictionary <string, AttributeValue> { [TASK_ID] = new AttributeValue { S = messgageId } })); }
public Task DeleteRowAsync(string connectionId) => _dynamoDbClient.DeleteItemAsync(new DeleteItemRequest { TableName = _tableName, Key = new Dictionary <string, AttributeValue> { ["ConnectionId"] = new AttributeValue { S = connectionId } } });
public async Task DeleteItemAsync(string pkId, string skId) { var dbItemKey = DynamoDBKey(pkId, skId); var delItemRq = new DeleteItemRequest { TableName = TableName, Key = dbItemKey.ToDictionary() }; var result = await _dynamoDbClient.DeleteItemAsync(delItemRq); }
public static async Task <DeleteItemResponse> DeleteItem(this IAmazonDynamoDB ddb, IDynamoConfig cfg, string pk, string sk) { var request = new DeleteItemRequest { TableName = cfg.TableName }; request.Key.Add(cfg.PkName, new AttributeValue(pk)); request.Key.Add(cfg.SkName, new AttributeValue(sk)); return(await ddb.DeleteItemAsync(request)); }
public async Task Delete <T>(T entity) where T : Base, new() { var request = new DeleteItemRequest { TableName = entity.GetTableName(), Key = entity.GetKey() }; if (writeActions == null) { await amazonDynamoDB.DeleteItemAsync(request); } else { writeActions.Add(new TransactWriteItem { Delete = request.Map() }); } }
public async Task <int> DeleteItemAsync(Entity item) { var dbItem = new Dictionary <string, AttributeValue>(); dbItem.Add("user_id", new AttributeValue(item.UserId)); dbItem.Add("entity_id", new AttributeValue(item.Id)); var result = await _dynamoDbClient.DeleteItemAsync(_tableName, dbItem, ReturnValue.ALL_OLD); return(result.Attributes.Count); }
public async Task TerminateSubscription(string eventSubscriptionId, CancellationToken cancellationToken = default) { var request = new DeleteItemRequest { TableName = $"{_tablePrefix}-{SUBCRIPTION_TABLE}", Key = new Dictionary <string, AttributeValue> { { "id", new AttributeValue(eventSubscriptionId) } } }; await _client.DeleteItemAsync(request, cancellationToken); }
public async Task ClearTableItems(ICollection <TestEntity> entities) { foreach (var entity in entities) { await _dynamoDbClient.DeleteItemAsync(_configuration.TableName, new Dictionary <string, AttributeValue> { { _configuration.PartitionKey, new AttributeValue(entity.PartitionKey) }, { _configuration.SortKey, new AttributeValue(entity.SortKey) } }); } }
public void Delete(int tableNumber) { _client.DeleteItemAsync( tableName: _tableName, key: new Dictionary <string, AttributeValue> { { "tableNumber", new AttributeValue { N = tableNumber.ToString() } } } ).Wait(); }
public async Task <DeleteItemResponse> DeleteDetails(DeleteItemRequest request) { try { var response = await _amazonDynamoDb.DeleteItemAsync(request); return(response); } catch (Exception ex) { throw ex; } }
public async Task DeleteRecordByKey(string key) { var item = new ItemRecord(); var response = await _dynamoClient.DeleteItemAsync(_tableName, ConstructKeyDictionary(key)); if (response.HttpStatusCode == System.Net.HttpStatusCode.OK) { return; } throw new Exception($"Delete failed, server returned status {response.HttpStatusCode}"); }
public async Task <APIGatewayProxyResponse> OnDisconnect(APIGatewayProxyRequest request, ILambdaContext context) { try { // Using JObject instead of APIGatewayProxyRequest till APIGatewayProxyRequest gets updated with DomainName and ConnectionId var connectionId = request.RequestContext.ConnectionId; context.Logger.LogLine($"ConnectionId: {connectionId}"); var body = JObject.FromObject(request).ToString(); var ddbRequest = new DeleteItemRequest { TableName = Constants.WEBSOCKET_TABLE, Key = new Dictionary <string, AttributeValue> { { Constants.ConnectionIdField, new AttributeValue { S = connectionId } } } }; await _ddbClient.DeleteItemAsync(ddbRequest); return(new APIGatewayProxyResponse { StatusCode = 200, Body = "Disconnected." }); } catch (Exception e) { context.Logger.LogLine("Error disconnecting: " + e.Message); context.Logger.LogLine(e.StackTrace); return(new APIGatewayProxyResponse { StatusCode = 500, Body = $"Failed to disconnect: {e.Message}" }); } }
public async Task DeletePokemon(int pokemonNumber) { var request = new DeleteItemRequest { TableName = _tableName, Key = new Dictionary <string, AttributeValue> { { "Number", new AttributeValue { N = pokemonNumber.ToString() } } } }; await _amazonDynamoDb.DeleteItemAsync(request); }
/// <summary> /// Deletes a user by id. /// </summary> /// <param name="id">Id of the user to be deleted.</param> public async void Delete(int id) { await _dynamoDBClient.DeleteItemAsync(new DeleteItemRequest() { TableName = "dotnetcore-react-redux-users", Key = new Dictionary <string, AttributeValue>() { ["id"] = new AttributeValue() { N = id.ToString() } } }); }
public async Task <Item> DeleteItems(int id) { var deleteItem = _getItem.GetItems(id); var registerDateTime = deleteItem.Result.Items.Select(x => x.RegisterDateTime).FirstOrDefault(); var deleteItemRequest = DeleteItemRequest(id, registerDateTime); var response = await _amazonDynamoDB.DeleteItemAsync(deleteItemRequest); return(new Item { Id = Convert.ToInt32(response.Attributes["Id"].N), Price = Convert.ToDouble(response.Attributes["Price"].N), RegisterDateTime = response.Attributes["RegisterDateTime"].N }); }
public async Task DeleteImage(string id) { var attributes = new Dictionary <string, AttributeValue> { { "Id", new AttributeValue { S = id } } }; _log.LogInformation($"Begin delete row data"); await _dynamoDb.DeleteItemAsync( tableName : "azb.our-photos.images.test", key : attributes ); _log.LogInformation($"End delete row data"); _log.LogInformation($"Begin S3 delete thumbnail"); var thumbnail = new DeleteObjectRequest { BucketName = _options.FullImage, Key = id }; await _s3client.DeleteObjectAsync(thumbnail); _log.LogInformation($"End S3 S3 delete thumbnail"); _log.LogInformation($"Begin S3 delete image"); var fullImage = new DeleteObjectRequest { BucketName = _options.FullImage, Key = id }; await _s3client.DeleteObjectAsync(fullImage); _log.LogInformation($"End S3 S3 delete image"); }
public async Task <Result> DeleteItemsComplex(int iteration) { var request = new DeleteItemRequest { TableName = "Benchmarking", Key = new Dictionary <string, AttributeValue> { { "Id", new AttributeValue { N = "0" } } } }; var result = new Result(); var stopwatch = new Stopwatch(); stopwatch.Start(); for (int i = 0; i < iteration; ++i) { request.Key["Id"] = new AttributeValue { N = $"{i}" }; await amazonDynamoDB.DeleteItemAsync(request); } stopwatch.Stop(); result.Count = iteration; result.TimeTaken = stopwatch.Elapsed; result.Description = $"Delete {iteration} items in table (Complex)"; result.Service = repositoryName; result.Simple = false; result.Method = "Delete"; return(result); }
public async Task Delete(string id) { var request = new DeleteItemRequest { TableName = TableName, Key = new Dictionary <string, AttributeValue>() { { "id", new AttributeValue { S = id } } } }; await _amazonDynamoDb.DeleteItemAsync(request); }
public async Task <bool> RemoveAsync(int subscriptionId) { var deleteItemRequest = new DeleteItemRequest { TableName = _tableName, Key = new Dictionary <string, AttributeValue> { { "chatid", new AttributeValue { S = subscriptionId.ToString() } } } }; var response = await _amazonDynamoDB.DeleteItemAsync(deleteItemRequest); return(response.HttpStatusCode == System.Net.HttpStatusCode.OK); }
public void AddUpdateNginxConfigRepository(string pidUriString) { Uri pidUri = new Uri(pidUriString); Dictionary <string, AttributeValue> attributes = new Dictionary <string, AttributeValue>(); // PidUri is hash-key attributes["pid_uri"] = new AttributeValue { S = pidUri.ToString() }; //Try deleting if there is an existing entry in dynamoDB try { _amazonDynamoDbService.DeleteItemAsync(_nginxConfigDynamoDbTable, attributes); } catch (System.Exception ex) { _logger.LogInformation($"ProxyConfigService: could not delete Nginx Config before Added/Updated for : {pidUri} Error {ex.StackTrace}", pidUri, ex); } // Title is range-key attributes["configString"] = new AttributeValue { S = GetProxyConfigurationByPidUri(pidUri) }; //Add new Entry try { _amazonDynamoDbService.PutItemAsync(_nginxConfigDynamoDbTable, attributes); _logger.LogInformation($"ProxyConfigService: Nginx Config Added/Updated for : {pidUri}", pidUri); } catch (System.Exception ex) { _logger.LogError($"ProxyConfigService: Error occured while Add & Update DynamoDb: {ex.StackTrace}", ex); } }