public async Task <IEnumerable <TaskModel> > GetWithParameters(TasksParameters parameters)
        {
            var queryFilters = string.Empty;

            if (!string.IsNullOrWhiteSpace(parameters.Id))
            {
                queryFilters = TableQuery.GenerateFilterCondition(nameof(TaskEntity.RowKey), QueryComparisons.Equal, parameters.Id);
            }
            if (!string.IsNullOrWhiteSpace(parameters.ProjectId))
            {
                var projectCondition =
                    TableQuery.GenerateFilterCondition(nameof(TaskEntity.PartitionKey), QueryComparisons.Equal, parameters.ProjectId);
                queryFilters = string.IsNullOrEmpty(queryFilters) ? projectCondition : TableQuery.CombineFilters(queryFilters, TableOperators.And, projectCondition);
            }
            if (!string.IsNullOrWhiteSpace(parameters.Subject))
            {
                var subjectCondition =
                    TableQuery.GenerateFilterCondition(nameof(TaskEntity.Subject), QueryComparisons.Equal, parameters.Subject);
                queryFilters = string.IsNullOrEmpty(queryFilters) ? subjectCondition : TableQuery.CombineFilters(queryFilters, TableOperators.And, subjectCondition);
            }

            TableQuery <TaskEntity> tableQuery = new TableQuery <TaskEntity>().Where(queryFilters);

            if (parameters.Take.HasValue)
            {
                tableQuery = tableQuery.Take(parameters.Take.Value);
            }

            var tasks = await _context.QueryWithParametersAsync(TableName, tableQuery);

            return(_mapper.Map <List <TaskModel> >(tasks));
        }
Example #2
0
        public async Task QueryEntitiesWithTakeTest()
        {
            //arrange
            for (var i = 1; i <= 10; i++)
            {
                var operation = TableOperation.Insert(new TestEntity("part1", i.ToString(), $"Test {i}"));
                await _table.ExecuteAsync(operation);
            }
            var tableQuery = new TableQuery <TestEntity>();

            tableQuery.Take(5);
            //act
            var result = await _context.QueryWithParametersAsync <TestEntity>("Test", tableQuery);

            //assert
            Assert.Equal(5, result.Count());
        }
Example #3
0
        public async Task <IEnumerable <Project> > GetWithParameters(ProjectsParameters parameters)
        {
            var queryFilters = string.Empty;

            if (!string.IsNullOrWhiteSpace(parameters.Id))
            {
                queryFilters = TableQuery.GenerateFilterCondition(nameof(ProjectEntity.RowKey), QueryComparisons.Equal, parameters.Id);
            }
            if (!string.IsNullOrWhiteSpace(parameters.Code))
            {
                var codeCondition =
                    TableQuery.GenerateFilterCondition(nameof(ProjectEntity.PartitionKey), QueryComparisons.Equal, parameters.Code);
                queryFilters = string.IsNullOrEmpty(queryFilters) ? codeCondition : TableQuery.CombineFilters(queryFilters, TableOperators.And, codeCondition);
            }
            if (!string.IsNullOrWhiteSpace(parameters.Name))
            {
                var nameCondition =
                    TableQuery.GenerateFilterCondition(nameof(ProjectEntity.Name), QueryComparisons.Equal, parameters.Name);
                queryFilters = string.IsNullOrEmpty(queryFilters) ? nameCondition : TableQuery.CombineFilters(queryFilters, TableOperators.And, nameCondition);
            }

            TableQuery <ProjectEntity> tableQuery = new TableQuery <ProjectEntity>().Where(queryFilters);

            if (parameters.Take.HasValue)
            {
                tableQuery = tableQuery.Take(parameters.Take.Value);
            }
            //if (parameters.Offset.HasValue)
            //{
            //    //TODO: offset parameter
            //}

            var projects = await _context.QueryWithParametersAsync(TableName, tableQuery);

            return(_mapper.Map <List <Project> >(projects));
        }