Query language support for child iteration & area

controller/search_blackbox_test.go

@@ -1050,6 +1050,175 @@ func (s *searchControllerTestSuite) TestSearchByJoinedData() {
 	})
 }
 
+// TestSearchWorkItemsWithChildIterationsOption verifies the child work item search for iteration
+func (s *searchControllerTestSuite) TestSearchWorkItemsWithChildIterationsOption() {
+	s.T().Run("iterations", func(t *testing.T) {
+		fxt := tf.NewTestFixture(t, s.DB,
+			tf.Iterations(3, func(fxt *tf.TestFixture, idx int) error {
+				i := fxt.Iterations[idx]
+				switch idx {
+				case 0:
+					i.Name = "Top level iteration"
+				case 1:
+					i.Name = "Level 1 iteration"
+					i.MakeChildOf(*fxt.Iterations[idx-1])
+				case 2:
+					i.Name = "Level 2 iteration"
+					i.MakeChildOf(*fxt.Iterations[idx-1])
+				}
+				return nil
+			}),
+
+			tf.WorkItems(10, func(fxt *tf.TestFixture, idx int) error {
+				switch idx {
+				case 0, 1, 2:
+					fxt.WorkItems[idx].Fields[workitem.SystemIteration] = fxt.Iterations[0].ID.String()
+				case 3, 4:
+					fxt.WorkItems[idx].Fields[workitem.SystemIteration] = fxt.Iterations[1].ID.String()
+				case 5, 6, 7, 8:
+					fxt.WorkItems[idx].Fields[workitem.SystemIteration] = fxt.Iterations[2].ID.String()
+				}
+				return nil
+			}),
+		)
+
+		spaceIDStr := fxt.Spaces[0].ID.String()
+
+		t.Run("without child iteration", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s", "child": true}`, fxt.Iterations[2].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 4)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[5].ID,
+				fxt.WorkItems[6].ID,
+				fxt.WorkItems[7].ID,
+				fxt.WorkItems[8].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unknown work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to find all work items: %+s", toBeFound)
+		})
+		t.Run("with one child iteration", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s/**"}`, fxt.Iterations[1].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 6)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[3].ID,
+				fxt.WorkItems[4].ID,
+				fxt.WorkItems[5].ID,
+				fxt.WorkItems[6].ID,
+				fxt.WorkItems[7].ID,
+				fxt.WorkItems[8].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unknown work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to find all work items: %+s", toBeFound)
+		})
+		t.Run("with two child iteration", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s/**"}`, fxt.Iterations[0].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 9)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[0].ID,
+				fxt.WorkItems[1].ID,
+				fxt.WorkItems[2].ID,
+				fxt.WorkItems[3].ID,
+				fxt.WorkItems[4].ID,
+				fxt.WorkItems[5].ID,
+				fxt.WorkItems[6].ID,
+				fxt.WorkItems[7].ID,
+				fxt.WorkItems[8].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unknown work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to find all work items: %+s", toBeFound)
+		})
+
+		t.Run("without child iteration - implicit", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s"}`, fxt.Iterations[2].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 4)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[5].ID,
+				fxt.WorkItems[6].ID,
+				fxt.WorkItems[7].ID,
+				fxt.WorkItems[8].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unknown work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to find all work items: %+s", toBeFound)
+		})
+		t.Run("without child iteration - no /** suffix", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s"}`, fxt.Iterations[2].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 4)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[5].ID,
+				fxt.WorkItems[6].ID,
+				fxt.WorkItems[7].ID,
+				fxt.WorkItems[8].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unknown work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to find all work items: %+s", toBeFound)
+		})
+		t.Run("with one child iteration - no /** suffix", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s"}`, fxt.Iterations[1].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 2)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[3].ID,
+				fxt.WorkItems[4].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unknown work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to find all work items: %+s", toBeFound)
+		})
+		t.Run("with two child iteration - no /** suffix", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s"}`, fxt.Iterations[0].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 3)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[0].ID,
+				fxt.WorkItems[1].ID,
+				fxt.WorkItems[2].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unknown work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to found all work items: %+s", toBeFound)
+		})
+	})
+
+}
+
 // TestIncludedParents verifies the Included list of parents
 func (s *searchControllerTestSuite) TestIncludedParents() {
 

criteria/expression_child.go

@@ -0,0 +1,20 @@
+package criteria
+
+// ChildExpression represents the child operator
+type ChildExpression struct {
+	binaryExpression
+}
+
+// Ensure ChildExpression implements the Expression interface
+var _ Expression = &ChildExpression{}
+var _ Expression = (*ChildExpression)(nil)
+
+// Accept implements ExpressionVisitor
+func (t *ChildExpression) Accept(visitor ExpressionVisitor) interface{} {
+	return visitor.Child(t)
+}
+
+// Child constructs a ChildExpression
+func Child(left Expression, right Expression) Expression {
+	return reparent(&ChildExpression{binaryExpression{expression{}, left, right}})
+}

criteria/expression_visitor.go

@@ -10,5 +10,6 @@ type ExpressionVisitor interface {
 	Parameter(v *ParameterExpression) interface{}
 	Literal(c *LiteralExpression) interface{}
 	Not(e *NotExpression) interface{}
+	Child(e *ChildExpression) interface{}
 	IsNull(e *IsNullExpression) interface{}
 }

criteria/iterator.go

@@ -46,6 +46,10 @@ func (i *postOrderIterator) Not(exp *NotExpression) interface{} {
 	return i.binary(exp)
 }
 
+func (i *postOrderIterator) Child(exp *ChildExpression) interface{} {
+	return i.binary(exp)
+}
+
 func (i *postOrderIterator) IsNull(exp *IsNullExpression) interface{} {
 	return i.visit(exp)
 }

search/search_repository.go

@@ -275,9 +275,18 @@ func parseMap(queryMap map[string]interface{}, q *Query) {
 			q.Name = key
 			s := string(concreteVal)
 			q.Value = &s
+			if q.Name == "iteration" || q.Name == "area" {
+				if strings.HasSuffix(s, "/**") {
+					q.Child = true
+					ns := s[0 : len(s)-3]
+					q.Value = &ns
+				}
+			}
 		case bool:
 			s := concreteVal
-			q.Negate = s
+			if key == "negate" {
+				q.Negate = s
+			}
 		case nil:
 			q.Name = key
 			q.Value = nil
@@ -378,6 +387,8 @@ type Query struct {
 	Children []Query
 	// The Options represent the query options provided by the user.
 	Options *QueryOptions
+	// Consider child iteration/area
+	Child bool
 }
 
 func isOperator(str string) bool {
@@ -436,7 +447,11 @@ func (q Query) generateExpression() (criteria.Expression, error) {
 				if q.Substring {
 					myexpr = append(myexpr, criteria.Substring(left, right))
 				} else {
-					myexpr = append(myexpr, criteria.Equals(left, right))
+					if q.Child {
+						myexpr = append(myexpr, criteria.Child(left, right))
+					} else {
+						myexpr = append(myexpr, criteria.Equals(left, right))
+					}
 				}
 			}
 		} else {
@@ -477,7 +492,11 @@ func (q Query) generateExpression() (criteria.Expression, error) {
 					if child.Substring {
 						myexpr = append(myexpr, criteria.Substring(left, right))
 					} else {
-						myexpr = append(myexpr, criteria.Equals(left, right))
+						if child.Child {
+							myexpr = append(myexpr, criteria.Child(left, right))
+						} else {
+							myexpr = append(myexpr, criteria.Equals(left, right))
+						}
 					}
 				}
 			} else {

search/search_repository_blackbox_test.go

@@ -69,6 +69,82 @@ func (s *searchRepositoryBlackboxTest) getTestFixture() *tf.TestFixture {
 	)
 }
 
+func (s *searchRepositoryBlackboxTest) TestSearchWithChildIterationWorkItems() {
+	s.T().Run("iterations", func(t *testing.T) {
+		fxt := tf.NewTestFixture(t, s.DB,
+			tf.Iterations(3, func(fxt *tf.TestFixture, idx int) error {
+				i := fxt.Iterations[idx]
+				switch idx {
+				case 0:
+					i.Name = "Top level iteration"
+				case 1:
+					i.Name = "Level 1 iteration"
+					i.MakeChildOf(*fxt.Iterations[idx-1])
+				case 2:
+					i.Name = "Level 2 iteration"
+					i.MakeChildOf(*fxt.Iterations[idx-1])
+				}
+				return nil
+			}),
+
+			tf.WorkItems(10, func(fxt *tf.TestFixture, idx int) error {
+				switch idx {
+				case 0, 1, 2:
+					fxt.WorkItems[idx].Fields[workitem.SystemIteration] = fxt.Iterations[0].ID.String()
+				case 3, 4:
+					fxt.WorkItems[idx].Fields[workitem.SystemIteration] = fxt.Iterations[1].ID.String()
+				case 5, 6, 7, 8:
+					fxt.WorkItems[idx].Fields[workitem.SystemIteration] = fxt.Iterations[2].ID.String()
+				}
+				return nil
+			}),
+		)
+		t.Run("without child iteration", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"$AND": [{"iteration": "%s/**"}, {"space": "%s"}]}`, fxt.Iterations[2].ID, fxt.Spaces[0].ID)
+			_, count, _, _, err := s.searchRepo.Filter(context.Background(), filter, nil, nil, nil)
+			require.NoError(t, err)
+			assert.Equal(t, 4, count)
+		})
+
+		t.Run("with one child iteration", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s/**"}`, fxt.Iterations[1].ID)
+			_, count, _, _, err := s.searchRepo.Filter(context.Background(), filter, nil, nil, nil)
+			require.NoError(t, err)
+			assert.Equal(t, 6, count)
+		})
+		t.Run("with two child iteration", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s/**"}`, fxt.Iterations[0].ID)
+			_, count, _, _, err := s.searchRepo.Filter(context.Background(), filter, nil, nil, nil)
+			require.NoError(t, err)
+			assert.Equal(t, 9, count)
+		})
+		t.Run("without child iteration - no /** suffix", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s"}`, fxt.Iterations[2].ID)
+			_, count, _, _, err := s.searchRepo.Filter(context.Background(), filter, nil, nil, nil)
+			require.NoError(t, err)
+			assert.Equal(t, 4, count)
+		})
+		t.Run("with one child iteration - no /** suffix", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s"}`, fxt.Iterations[1].ID)
+			_, count, _, _, err := s.searchRepo.Filter(context.Background(), filter, nil, nil, nil)
+			require.NoError(t, err)
+			assert.Equal(t, 2, count)
+		})
+		t.Run("with two child iteration - no /** suffix", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s"}`, fxt.Iterations[0].ID)
+			_, count, _, _, err := s.searchRepo.Filter(context.Background(), filter, nil, nil, nil)
+			require.NoError(t, err)
+			assert.Equal(t, 3, count)
+		})
+		t.Run("with two child iteration and space", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"$AND": [{"iteration": "%s/**"},{"space": "%s"}]}`, fxt.Iterations[0].ID, fxt.Spaces[0].ID)
+			_, count, _, _, err := s.searchRepo.Filter(context.Background(), filter, nil, nil, nil)
+			require.NoError(t, err)
+			assert.Equal(t, 9, count)
+		})
+	})
+}
+
 func (s *searchRepositoryBlackboxTest) TestSearchWithJoin() {
 	s.T().Run("join iterations", func(t *testing.T) {
 		fxt := tf.NewTestFixture(t, s.DB,