public async Task <IActionResult> Get(string firstName, string lastName, string secondLastName, string curp) { var credentials = new BasicAWSCredentials(AWSAccessKeyId, AWSSecretAccessKey); var client = new AmazonDynamoDBClient(credentials, RegionEndpoint.USWest2); ScanFilter scanFilter = new ScanFilter(); scanFilter.AddCondition("FirstName", ScanOperator.Equal, firstName); scanFilter.AddCondition("LastName", ScanOperator.Equal, lastName); scanFilter.AddCondition("SecondLastName", ScanOperator.Equal, secondLastName); scanFilter.AddCondition("CURP", ScanOperator.Equal, curp); ScanOperationConfig soc = new ScanOperationConfig() { // AttributesToGet = new List { "Id", "Title", "ISBN", "Price" }, Filter = scanFilter }; DynamoDBContext context = new DynamoDBContext(client); AsyncSearch <EmployeesPTU> search = context.FromScanAsync <EmployeesPTU>(soc, null); List <EmployeesPTU> documentList = new List <EmployeesPTU>(); do { documentList = await search.GetNextSetAsync(default(System.Threading.CancellationToken)); } while (!search.IsDone); return(Ok(documentList)); }
public async Task <List <Model.ObjectCode> > List(string parentObjectCodeId) { ListTablesResponse existingTables = await client.ListTablesAsync(); if (!existingTables.TableNames.Contains(TABLE_NAME)) { await SetupTable(client, TABLE_NAME, "CodeId"); } try { List <ScanCondition> filter = new List <ScanCondition>() { new ScanCondition("ParentId", ScanOperator.Equal, parentObjectCodeId.ToUpper()) }; AsyncSearch <Model.ObjectCode> scan = DDBContext.ScanAsync <Model.ObjectCode>(filter); List <Model.ObjectCode> documentList = new List <Model.ObjectCode>(); do { documentList.AddRange(await scan.GetNextSetAsync()); } while (!scan.IsDone); return(documentList); } catch (Exception ex) { Console.WriteLine("Error listing object codes: " + ex.Message); } return(null); }
public async Task <IActionResult> GetAsync() { try { // COGNITO SERVICE //AWSCredentials credentials = new CognitoAWSCredentials(cognitoID,RegionEndpoint.USEast1); //var client = new AmazonDynamoDBClient(credentials,RegionEndpoint.USEast1); // IAM SERVICE - Local //var credentials = new BasicAWSCredentials(AWSAccessKeyId, AWSSecretAccessKey); //var client = new AmazonDynamoDBClient(credentials, RegionEndpoint.USEast1); // This approach works when you are depending on a role var client = new AmazonDynamoDBClient(RegionEndpoint.USEast1); ScanFilter scanFilter = new ScanFilter(); ScanOperationConfig soc = new ScanOperationConfig() { Filter = scanFilter }; DynamoDBContext context = new DynamoDBContext(client); AsyncSearch <lreb> search = context.FromScanAsync <lreb>(soc, null); List <lreb> documentList = new List <lreb>(); do { documentList = await search.GetNextSetAsync(default(System.Threading.CancellationToken)); } while (!search.IsDone); return(Ok(documentList)); } catch (Exception e) { return(StatusCode(500, e)); } }
public async Task <List <T> > GetAsyncSearchResult <T>(AsyncSearch <T> asyncSearch, CancellationToken cancellationToken) { var results = await asyncSearch.GetNextSetAsync(cancellationToken); while (!asyncSearch.IsDone && !cancellationToken.IsCancellationRequested) { results.AddRange(await asyncSearch.GetRemainingAsync(cancellationToken)); } return(results); }
/// <summary> /// Configures an async Query operation against DynamoDB, finding items that match the specified hash primary key. /// </summary> /// <param name="hashKeyValue">Hash key of the items to query.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="take">The number of items to take.</param> /// <param name="queryFilter">Query filter for the Query operation operation.</param> /// <returns>The async task.</returns> private async Task <List <T> > QueryAsyncEx(object hashKeyValue, CancellationToken cancellationToken, int take = 100, List <ScanCondition> queryFilter = null) { List <T> items = new List <T>(); AsyncSearch <T> result = null; bool foundEnought = false; // Add the filter. if (queryFilter != null) { // Add the query filter. DynamoDBOperationConfig operationConfig = new DynamoDBOperationConfig(); operationConfig.QueryFilter = queryFilter; result = _context.QueryAsync <T>(hashKeyValue, operationConfig); } else { // Set the query. result = _context.QueryAsync <T>(hashKeyValue); } do { // Get the set of results. List <T> data = await result.GetNextSetAsync(cancellationToken); foreach (T entity in data) { // Add the item found. items.Add(entity); // If we have enought. if (items.Count >= take) { break; } } // No more data. foundEnought = result.IsDone; // If we have enought. if (items.Count >= take) { break; } }while (!foundEnought); // Return the list. return(items); }
public async Task <List <MediaItem> > LoadByUniqueNameAsync(Guid accountId, string uniqueName, bool decending) { var stopwatch = Stopwatch.StartNew(); try { var config = new DynamoDBContextConfig { TableNamePrefix = _tablePrefix }; var context = new DynamoDBContext(_client, config); var operationConfig = new DynamoDBOperationConfig { IndexName = "UniqueMediaKey-DateAdded-index", TableNamePrefix = _tablePrefix, ConditionalOperator = ConditionalOperatorValues.And, OverrideTableName = TableName, BackwardQuery = decending }; // Pagination doesn't work to well at present (or at-least not start/limit type for Dynamo). // Pagination needs to use datetime range. var hashKeyValue = string.Format("{0}-{1}", accountId, uniqueName.ToLower()); var operatorType = QueryOperator.Between; IEnumerable <object> values = new List <object> { DateTime.MinValue, DateTime.UtcNow, }; AsyncSearch <MediaItem> asyncSearch = context.QueryAsync <MediaItem>(hashKeyValue, operatorType, values, operationConfig); List <MediaItem> items = await asyncSearch.GetNextSetAsync(); // Assume one batch of query items is enough. // really needs to be paginated on date range. return(items.ToList()); } catch (Exception ex) { Logger.LogException(ex, "Exception loading media items"); throw; } finally { stopwatch.Stop(); Logger.LogMessage("LoadByUniqueNameAsync took: {0}ms", stopwatch.ElapsedMilliseconds); } }
public async Task <List <MediaItem> > LoadByUserAsync(Guid userId, DateTime startDate, DateTime endDate) { var stopwatch = Stopwatch.StartNew(); try { var config = new DynamoDBContextConfig { TableNamePrefix = _tablePrefix }; var context = new DynamoDBContext(_client, config); //QueryFilter filter = new QueryFilter(); //filter.AddCondition("UserId", QueryOperator.Equal, userId); var operationConfig = new DynamoDBOperationConfig { IndexName = "UserId-DateAdded-index", TableNamePrefix = _tablePrefix, ConditionalOperator = ConditionalOperatorValues.And, OverrideTableName = TableName, BackwardQuery = true, }; var hashKeyValue = userId; var operatorType = QueryOperator.Between; IEnumerable <object> values = new List <object> { startDate, endDate }; AsyncSearch <MediaItem> asyncSearch = context.QueryAsync <MediaItem>(hashKeyValue, operatorType, values, operationConfig); List <MediaItem> items = await asyncSearch.GetNextSetAsync(); Logger.LogMessage("LoadByUserAsync loaded {0} items", items.Count); return(items); } catch (Exception ex) { Logger.LogException(ex, "Exception loading media items (LoadByUserAsync)"); throw; } finally { stopwatch.Stop(); Logger.LogMessage("LoadByUserAsync took: {0} ms", stopwatch.ElapsedMilliseconds); } }
public async Task <IEnumerable <Expense> > GetExpenses() { ScanFilter scanFilter = new ScanFilter(); scanFilter.AddCondition("Id", ScanOperator.NotEqual, 0); ScanOperationConfig soc = new ScanOperationConfig() { Filter = scanFilter }; AsyncSearch <Expense> search = context.FromScanAsync <Expense>(soc, null); List <Expense> documentList = new List <Expense>(); do { documentList = await search.GetNextSetAsync(default(System.Threading.CancellationToken)); } while (!search.IsDone); return(documentList); }
public async Task <List <Coupon> > Get() { CreateTable(); ScanFilter scanFilter = new ScanFilter(); //scanFilter.AddCondition("StoreName", ScanOperator.Equal, storeName); ScanOperationConfig soc = new ScanOperationConfig() { Filter = scanFilter }; DynamoDBContext context = new DynamoDBContext(dynamoDBClient); AsyncSearch <Coupon> search = context.FromScanAsync <Coupon>(soc, null); List <Coupon> documentList = new List <Coupon>(); do { documentList = await search.GetNextSetAsync(default(System.Threading.CancellationToken)); } while (!search.IsDone); return(documentList); }
public List <TEntity> GetByList(List <FilterQuery> valuesAtributeScanOperator) { List <TEntity> listEntity; using (DynamoDBContext context = GetContext()) { List <ScanCondition> scanFilter = GetScanCondition(valuesAtributeScanOperator); AsyncSearch <TEntity> query = context.ScanAsync <TEntity>(scanFilter); List <TEntity> partialResultDynamo = new List <TEntity>(); List <TEntity> totalResultDynamo = new List <TEntity>(); do { partialResultDynamo.Clear(); partialResultDynamo = query.GetNextSetAsync().GetAwaiter().GetResult(); totalResultDynamo.AddRange(partialResultDynamo); } while (!query.IsDone); listEntity = totalResultDynamo; } return(listEntity); }
public List <TEntity> GetAll() { List <TEntity> partialResultDynamo = new List <TEntity>(); List <TEntity> totalResultDynamo = new List <TEntity>(); using DynamoDBContext context = GetContext(); //Teniendo en cuenta la restricción de Dynamo en cuanto al límite de 1MB de los registros devueltos por cada consulta: AsyncSearch <TEntity> query = context.ScanAsync <TEntity>(null); do { partialResultDynamo.Clear(); partialResultDynamo = query.GetNextSetAsync().Result.ToList(); if (partialResultDynamo.Count > 0) //Si en la porción consultada obtuvo registros que cumplen con los filtros { totalResultDynamo.AddRange(partialResultDynamo); //Añádalos. } } while (!query.IsDone); return(totalResultDynamo); }
public static List <Goal> GetByEmail(string email) { List <Goal> goals; AsyncSearch <Goal> query = context.QueryAsync <Goal>(email, QueryOperator.GreaterThan, new string[] { " " }); Task <List <Goal> > taskQuery = query.GetNextSetAsync(default(CancellationToken)); taskQuery.Wait(); goals = taskQuery.Result; foreach (var goal in goals) { ScanOperationConfig config = new ScanOperationConfig(); config.ConsistentRead = true; config.Filter = new ScanFilter(); config.Filter.AddCondition("GoalName", ScanOperator.Equal, goal.GoalName); var search = context.FromScanAsync <Goal>(config); Task <List <Goal> > taskScan = search.GetRemainingAsync(); taskScan.Wait(); goal.Members = taskScan.Result.Count; } return(goals); }
public async Task <List <UniqueName> > ListAsync(Guid accountId, int start, int limit) { var stopwatch = Stopwatch.StartNew(); try { var config = new DynamoDBContextConfig { TableNamePrefix = _tablePrefix }; var context = new DynamoDBContext(_client, config); var operationConfig = new DynamoDBOperationConfig { IndexName = "AccountId-index", TableNamePrefix = _tablePrefix, ConditionalOperator = ConditionalOperatorValues.And, OverrideTableName = TableName, BackwardQuery = true, }; // TODO: Figure out how to specify start and limit var hashKeyValue = accountId; AsyncSearch <UniqueName> asyncSearch = context.QueryAsync <UniqueName>(hashKeyValue, operationConfig); List <UniqueName> items = await asyncSearch.GetNextSetAsync(); return(items); } catch (Exception ex) { Logger.LogException(ex, "Exception loading unique names: "); throw; } finally { stopwatch.Stop(); Logger.LogMessage("Query unique names took: {0}ms", stopwatch.ElapsedMilliseconds); } }
public async Task <List <Book> > GetBooksAsync() { ScanFilter scanFilter = new ScanFilter(); scanFilter.AddCondition("Id", ScanOperator.NotEqual, 0); ScanOperationConfig soc = new ScanOperationConfig() { // AttributesToGet = new List { "Id", "Title", "ISBN", "Price" }, Filter = scanFilter }; DynamoDBContext context = new DynamoDBContext(dynamoDBClient); AsyncSearch <Book> search = context.FromScanAsync <Book>(soc, null); List <Book> documentList = new List <Book>(); do { documentList = await search.GetNextSetAsync(default(System.Threading.CancellationToken)); } while (!search.IsDone); return(documentList); }
/// <summary> /// Configures an async Scan operation against DynamoDB, finding items that match the specified conditions. /// </summary> /// <param name="conditions">The scan conditions.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="take">The number of items to take.</param> /// <returns>The async task.</returns> private async Task <List <T> > ScanAsyncEx(List <ScanCondition> conditions, CancellationToken cancellationToken, int take = 100) { List <T> items = new List <T>(); bool foundEnought = false; // Set the query. AsyncSearch <T> result = _context.ScanAsync <T>(conditions); do { // Get the set of results. List <T> data = await result.GetNextSetAsync(cancellationToken); foreach (T entity in data) { // Add the item found. items.Add(entity); // If we have enought. if (items.Count >= take) { break; } } // No more data. foundEnought = result.IsDone; // If we have enought. if (items.Count >= take) { break; } }while (!foundEnought); // Return the list. return(items); }