Allow multiple OR filters (#14)

 makie it possible to have multiple and filters


* AB#9044

Author: wp0pw

Taskfile.yml

@@ -72,7 +72,7 @@ tasks:
     cmds:
       - task: builder-start
       - defer: {task: builder-cleanup}
-      - task: local-all
+      - docker exec -t {{.BUILD_CONTAINER}} task local-all
 
   local-all:
     desc: |

datatrails-common-api/marshalers/query/attributeparser.go

@@ -225,31 +225,36 @@ func handleFilters(msg protoreflect.ProtoMessage, p runtime.QueryParameterParser
 
 	// did user specify any filters in the query string
 	if values.Has(string(prop.Name())) {
-		// get the filters from query
-		filterSpec := values.Get(string(prop.Name()))
-
-		// split the filter terms
-		filters, err := getFilterParts(filterSpec)
-		if err != nil {
-			return err
-		}
 
 		// create mutable 'filters' property
 		filtersMutable := msg.ProtoReflect().Mutable(prop)
-		// append new filter to the list
-		newFilter := filtersMutable.List().NewElement()
-		// get the descriptor for the 'or' element of a filter
-		orDesc := newFilter.Message().Descriptor().Fields().ByJSONName("or")
-		// create mutable 'or' proprty of a filter
-		or := newFilter.Message().Mutable(orDesc)
-
-		// append our terms eg. attributes.foo=5 to the 'or'
-		for _, term := range filters {
-			v := protoreflect.ValueOf(term)
-			or.List().Append(v)
+
+		// get the filters from query
+		//filterSpec := values.Get(string(prop.Name()))
+		filterSpecs := values[string(prop.Name())]
+		for _, filterSpec := range filterSpecs {
+
+			// split the filter terms
+			filters, err := getFilterParts(filterSpec)
+			if err != nil {
+				return err
+			}
+
+			// append new filter to the list
+			newFilter := filtersMutable.List().NewElement()
+			// get the descriptor for the 'or' element of a filter
+			orDesc := newFilter.Message().Descriptor().Fields().ByJSONName("or")
+			// create mutable 'or' proprty of a filter
+			or := newFilter.Message().Mutable(orDesc)
+
+			// append our terms eg. attributes.foo=5 to the 'or'
+			for _, term := range filters {
+				v := protoreflect.ValueOf(term)
+				or.List().Append(v)
+			}
+			// append our new filter to 'filters'
+			filtersMutable.List().Append(newFilter)
 		}
-		// append our new filter to 'filters'
-		filtersMutable.List().Append(newFilter)
 	}
 
 	return nil

datatrails-common-api/marshalers/query/attributeparser_test.go

@@ -20,36 +20,59 @@ func TestFilterParsing(t *testing.T) {
 		values         url.Values
 		parser         runtime.QueryParameterParser
 		isError        bool
-		expectedResult []string
+		expectedResult [][]string
 	}{
 		{
 			name:           "test simple or",
 			message:        &assets.ListAssetsRequest{},
 			values:         map[string][]string{"filters": {"attributes.foo=2 OR attributes.bar=2"}},
 			parser:         &runtime.DefaultQueryParser{},
-			expectedResult: []string{"attributes.foo=2", "attributes.bar=2"},
+			expectedResult: [][]string{{"attributes.foo=2", "attributes.bar=2"}},
+		},
+		{
+			name:           "test multiple or",
+			message:        &assets.ListAssetsRequest{},
+			values:         map[string][]string{"filters": {"attributes.foo=2 OR attributes.bar=2", "attributes.foo=dd OR attributes.bar=77"}},
+			parser:         &runtime.DefaultQueryParser{},
+			expectedResult: [][]string{{"attributes.foo=2", "attributes.bar=2"}, {"attributes.foo=dd", "attributes.bar=77"}},
 		},
 		{
 			name:           "test or *",
 			message:        &assets.ListAssetsRequest{},
 			values:         map[string][]string{"filters": {"attributes.foo=* oR attributes.bar=2"}},
 			parser:         &runtime.DefaultQueryParser{},
-			expectedResult: []string{"attributes.foo=*", "attributes.bar=2"},
+			expectedResult: [][]string{{"attributes.foo=*", "attributes.bar=2"}},
 		},
 		{
 			name:           "test or 5 terms",
 			message:        &assets.ListAssetsRequest{},
 			values:         map[string][]string{"filters": {"attributes.foo=2 or attributes.bar=2 OR attributes.lop=2 oR attributes.foo=22 Or attributes.bar=77"}},
 			parser:         &runtime.DefaultQueryParser{},
-			expectedResult: []string{"attributes.foo=2", "attributes.bar=2", "attributes.lop=2", "attributes.foo=22", "attributes.bar=77"},
+			expectedResult: [][]string{{"attributes.foo=2", "attributes.bar=2", "attributes.lop=2", "attributes.foo=22", "attributes.bar=77"}},
+		},
+		{
+			name:    "test 4 filter terms",
+			message: &assets.ListAssetsRequest{},
+			values: map[string][]string{"filters": {
+				"attributes.foo=2 or attributes.bar=2 OR attributes.lop=2",
+				"attribtues.basss=e88 oR attributes.foxo=22",
+				"attribtues.ba=e oR attributes.foo=22 Or attributes.bar=77",
+				"something=xx oR attributes.gg=22 Or attributes.bar=87",
+			}},
+			parser: &runtime.DefaultQueryParser{},
+			expectedResult: [][]string{
+				{"attributes.foo=2", "attributes.bar=2", "attributes.lop=2"},
+				{"attribtues.basss=e88", "attributes.foxo=22"},
+				{"attribtues.ba=e", "attributes.foo=22", "attributes.bar=77"},
+				{"something=xx", "attributes.gg=22", "attributes.bar=87"}},
 		},
 		{
 			name:           "test bad filter",
 			message:        &assets.ListAssetsRequest{},
 			values:         map[string][]string{"filters": {"attributes.foo=2 OF attributes.bar=2"}},
 			parser:         &runtime.DefaultQueryParser{},
 			isError:        true,
-			expectedResult: []string{},
+			expectedResult: [][]string{},
 		},
 		{
 			name:    "test nil message",
@@ -68,7 +91,12 @@ func TestFilterParsing(t *testing.T) {
 				assert.Nil(t, result)
 			}
 			if result == nil && test.message != nil {
-				assert.Equal(t, test.message.Filters[0].Or, test.expectedResult)
+
+				assert.Equal(t, len(test.message.Filters), len(test.expectedResult))
+				for idx, expected := range test.expectedResult {
+					assert.Equal(t, test.message.Filters[idx].Or, expected)
+				}
+
 			}
 		})
 	}