fix(go): add a fix for handling oneOf anyOf from and query parameters in the Core library.

https/arraySerialization.go

@@ -0,0 +1,68 @@
+package https
+
+import "fmt"
+
+// ArraySerializationOption represents the type for request array serialization options.
+type ArraySerializationOption int
+
+// Constants for different request retry options.
+const (
+	Indexed = iota
+	UnIndexed
+	Plain
+	Csv
+	Tsv
+	Psv
+)
+
+var ArraySerializationOptionStrings = [...]string{
+	"Indexed",
+	"UnIndexed",
+	"Plain",
+	"Csv",
+	"Tsv",
+	"Psv",
+}
+
+func (option ArraySerializationOption) getSeparator() rune {
+	switch option {
+	case Csv:
+		return ','
+	case Tsv:
+		return '\t'
+	case Psv:
+		return '|'
+	default:
+		return -1
+	}
+}
+
+func (option ArraySerializationOption) joinKey(keyPrefix string, index any) string {
+	if index == nil {
+		switch option {
+		case UnIndexed:
+			return fmt.Sprintf("%v[]", keyPrefix)
+		default:
+			return fmt.Sprintf("%v", keyPrefix)
+		}
+	}
+	indexedKey := fmt.Sprintf("%v", index)
+	return fmt.Sprintf("%v[%v]", keyPrefix, indexedKey)
+}
+
+func (option ArraySerializationOption) appendMap(result map[string][]string, param map[string][]string) {
+	for k, values := range param {
+		for _, value := range values {
+			option.append(result, k, value)
+		}
+	}
+}
+
+func (option ArraySerializationOption) append(result map[string][]string, key string, value string) {
+	separator := option.getSeparator()
+	if len(result[key]) > 0 && separator != -1 {
+		result[key][0] = fmt.Sprintf("%v%c%v", result[key][0], separator, value)
+	} else {
+		result[key] = append(result[key], value)
+	}
+}

https/arraySerialization_test.go

@@ -0,0 +1,152 @@
+package https
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestGetSeparator(t *testing.T) {
+	testCases := make(map[ArraySerializationOption]rune)
+	testCases[Indexed] = -1
+	testCases[UnIndexed] = -1
+	testCases[Plain] = -1
+	testCases[Tsv] = '\t'
+	testCases[Csv] = ','
+	testCases[Psv] = '|'
+	testCases[100] = -1
+	testCases[-1] = -1
+
+	for testCase, expectedValue := range testCases {
+		actual := testCase.getSeparator()
+		if actual != expectedValue {
+			t.Errorf("For option %v, expected separator %c but got %c", ArraySerializationOptionStrings[testCase], testCase, actual)
+		}
+	}
+}
+
+func TestJoinKey(t *testing.T) {
+	testCases := []struct {
+		option    ArraySerializationOption
+		keyPrefix string
+		index     any
+		expected  string
+	}{
+		{UnIndexed, "prefix", nil, "prefix[]"},
+		{UnIndexed, "prefix", "index", "prefix[index]"},
+		{Indexed, "prefix", nil, "prefix"},
+		{Indexed, "prefix", "index", "prefix[index]"},
+		{Plain, "prefix", nil, "prefix"},
+		{Plain, "prefix", "index", "prefix[index]"},
+		{Tsv, "prefix", nil, "prefix"},
+		{Tsv, "prefix", "index", "prefix[index]"},
+		{Csv, "prefix", nil, "prefix"},
+		{Csv, "prefix", "index", "prefix[index]"},
+		{Psv, "prefix", nil, "prefix"},
+		{Psv, "prefix", "index", "prefix[index]"},
+	}
+
+	for _, tc := range testCases {
+		actual := tc.option.joinKey(tc.keyPrefix, tc.index)
+		if actual != tc.expected {
+			t.Errorf("For option %s, keyPrefix %s, and index %v, expected %q but got %q",
+				ArraySerializationOptionStrings[tc.option], tc.keyPrefix, tc.index, tc.expected, actual)
+		}
+	}
+}
+
+func TestAppendMap(t *testing.T) {
+	testCases := []struct {
+		option   ArraySerializationOption
+		result   map[string][]string
+		param    map[string][]string
+		expected map[string][]string
+	}{
+		// Test case where result map is empty
+		{
+			option: Csv,
+			result: map[string][]string{},
+			param: map[string][]string{
+				"key1": {"value1"},
+			},
+			expected: map[string][]string{
+				"key1": {"value1"},
+			},
+		},
+		// Test case where result map is non-empty and separator is set
+		{
+			option: Tsv,
+			result: map[string][]string{
+				"key1": {"value1"},
+			},
+			param: map[string][]string{
+				"key1": {"value2"},
+			},
+			expected: map[string][]string{
+				"key1": {"value1\tvalue2"},
+			},
+		},
+		// Test case where result map is non-empty and separator is not set
+		{
+			option: Indexed,
+			result: map[string][]string{
+				"key1": {"value1"},
+			},
+			param: map[string][]string{
+				"key1": {"value2"},
+			},
+			expected: map[string][]string{
+				"key1": {"value1", "value2"},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc.option.appendMap(tc.result, tc.param)
+
+		// Check if the result map matches the expected result
+		if !reflect.DeepEqual(tc.result, tc.expected) {
+			t.Errorf("For option %d, expected %v but got %v", tc.option, tc.expected, tc.result)
+		}
+	}
+}
+
+func TestAppend(t *testing.T) {
+	testCases := []struct {
+		option   ArraySerializationOption
+		result   map[string][]string
+		key      string
+		value    string
+		expected map[string][]string
+	}{
+		// Test case where result map is empty
+		{option: Csv, result: map[string][]string{"key1": {"value1"}}, key: "key1", value: "value2", expected: map[string][]string{"key1": {"value1,value2"}}},
+		// Test case where result map is non-empty and separator is set
+		{Tsv, map[string][]string{"key1": {"value1"}}, "key1", "value2", map[string][]string{"key1": {"value1\tvalue2"}}},
+		{Psv, map[string][]string{"key1": {"value1"}}, "key1", "value2", map[string][]string{"key1": {"value1|value2"}}},
+		// Test case where result map is non-empty and separator is not set
+		{Indexed, map[string][]string{"key1": {"value1"}}, "key1", "value2", map[string][]string{"key1": {"value1", "value2"}}},
+	}
+
+	for _, tc := range testCases {
+		tc.option.append(tc.result, tc.key, tc.value)
+
+		// Check if the result map matches the expected result
+		for k, v := range tc.expected {
+			if !equalSlices(tc.result[k], v) {
+				t.Errorf("For key %q, expected %v but got %v", k, v, tc.result[k])
+			}
+		}
+	}
+}
+
+func equalSlices(slice1, slice2 []string) bool {
+	if len(slice1) != len(slice2) {
+		return false
+	}
+	for i, v := range slice1 {
+		if v != slice2[i] {
+			return false
+		}
+	}
+	return true
+}

https/callBuilder.go

@@ -66,6 +66,7 @@ type CallBuilder interface {
 	CallAsStream() ([]byte, *http.Response, error)
 	Authenticate(authGroup AuthGroup)
 	RequestRetryOption(option RequestRetryOption)
+	ArraySerializationOption(option ArraySerializationOption)
 }
 
 // defaultCallBuilder is a struct that implements the CallBuilder interface for making API calls.
@@ -94,6 +95,7 @@ type defaultCallBuilder struct {
 	formParams             FormParams
 	queryParams            FormParams
 	errors                 map[string]ErrorBuilder[error]
+	arraySerializationOption ArraySerializationOption
 }
 
 // newDefaultCallBuilder creates a new instance of defaultCallBuilder, which implements the CallBuilder interface.
@@ -105,17 +107,19 @@ func newDefaultCallBuilder(
 	baseUrlProvider baseUrlProvider,
 	authProvider map[string]AuthInterface,
 	retryConfig RetryConfiguration,
+	option ArraySerializationOption,
 ) *defaultCallBuilder {
 	cb := defaultCallBuilder{
-		httpClient:      httpClient,
-		path:            path,
-		httpMethod:      httpMethod,
-		authProvider:    authProvider,
-		baseUrlProvider: baseUrlProvider,
-		retryOption:     RequestRetryOption(Default),
-		clientError:     nil,
-		retryConfig:     retryConfig,
-		ctx:             ctx,
+		httpClient:               httpClient,
+		path:                     path,
+		httpMethod:               httpMethod,
+		authProvider:             authProvider,
+		baseUrlProvider:          baseUrlProvider,
+		retryOption:              RequestRetryOption(Default),
+		clientError:              nil,
+		retryConfig:              retryConfig,
+		ctx:                      ctx,
+		arraySerializationOption: option,
 	}
 	cb.addRetryInterceptor()
 	return &cb
@@ -148,6 +152,10 @@ func (cb *defaultCallBuilder) RequestRetryOption(option RequestRetryOption) {
 	cb.retryOption = option
 }
 
+func (cb *defaultCallBuilder) ArraySerializationOption(option ArraySerializationOption) {
+	cb.arraySerializationOption = option
+}
+
 // AppendPath appends the provided path to the existing path in the CallBuilder.
 func (cb *defaultCallBuilder) AppendPath(path string) {
 	if cb.path != "" {
@@ -268,7 +276,7 @@ func (cb *defaultCallBuilder) validateQueryParams() error {
 		if cb.query == nil {
 			cb.query = url.Values{}
 		}
-		err := cb.queryParams.prepareFormFields(cb.query)
+		err := cb.queryParams.prepareFormFields(cb.query, cb.arraySerializationOption)
 		if err != nil {
 			return internalError{Body: err.Error(), FileInfo: "CallBuilder.go/validateQueryParams"}
 		}
@@ -298,7 +306,7 @@ func (cb *defaultCallBuilder) validateFormParams() error {
 		if cb.form == nil {
 			cb.form = url.Values{}
 		}
-		err := cb.formParams.prepareFormFields(cb.form)
+		err := cb.formParams.prepareFormFields(cb.form, cb.arraySerializationOption)
 		if err != nil {
 			return internalError{Body: err.Error(), FileInfo: "CallBuilder.go/validateFormParams"}
 		}
@@ -321,7 +329,7 @@ func (cb *defaultCallBuilder) validateFormData() error {
 	var headerVal string
 	var err error = nil
 	if len(cb.formFields) != 0 {
-		cb.formData, headerVal, err = cb.formFields.prepareMultipartFields()
+		cb.formData, headerVal, err = cb.formFields.prepareMultipartFields(cb.arraySerializationOption)
 		if err != nil {
 			return internalError{Body: err.Error(), FileInfo: "CallBuilder.go/validateFormData"}
 		}
@@ -362,7 +370,13 @@ func (cb *defaultCallBuilder) validateJson() error {
 			return internalError{Body: fmt.Sprintf("Unable to marshal the given data: %v", err.Error()), FileInfo: "CallBuilder.go/validateJson"}
 		}
 		cb.body = string(bytes)
-		cb.setContentTypeIfNotSet(JSON_CONTENT_TYPE)
+		contentType := JSON_CONTENT_TYPE
+		var testMap map[string]any
+		errTest := json.Unmarshal(bytes, &testMap)
+		if errTest != nil {
+			contentType = TEXT_CONTENT_TYPE
+		}
+		cb.setContentTypeIfNotSet(contentType)
 	}
 	return nil
 }
@@ -594,7 +608,7 @@ func (cb *defaultCallBuilder) CallAsText() (string, *http.Response, error) {
 
 		body, err := io.ReadAll(result.Response.Body)
 		if err != nil {
-			return "", result.Response, fmt.Errorf("Error reading Response body: %v", err.Error())
+			return "", result.Response, fmt.Errorf("error reading Response body: %v", err.Error())
 		}
 
 		return string(body), result.Response, err
@@ -617,7 +631,7 @@ func (cb *defaultCallBuilder) CallAsStream() ([]byte, *http.Response, error) {
 
 		bytes, err := io.ReadAll(result.Response.Body)
 		if err != nil {
-			return nil, result.Response, fmt.Errorf("Error reading Response body: %v", err.Error())
+			return nil, result.Response, fmt.Errorf("error reading Response body: %v", err.Error())
 		}
 
 		return bytes, result.Response, err
@@ -704,11 +718,13 @@ func CreateCallBuilderFactory(
 	auth map[string]AuthInterface,
 	httpClient HttpClient,
 	retryConfig RetryConfiguration,
+	option ArraySerializationOption,
 ) CallBuilderFactory {
 	return func(
 		ctx context.Context,
 		httpMethod,
 		path string,
+
 	) CallBuilder {
 		return newDefaultCallBuilder(
 			ctx,
@@ -718,6 +734,7 @@ func CreateCallBuilderFactory(
 			baseUrlProvider,
 			auth,
 			retryConfig,
+			option,
 		)
 	}
 }

https/callBuilder_test.go

@@ -23,6 +23,7 @@ func GetCallBuilder(ctx context.Context, method, path string, auth map[string]Au
 		auth,
 		client,
 		NewRetryConfiguration(),
+		Indexed,
 	)
 
 	return callBuilder(ctx, method, path)

https/fileWrapper.go

@@ -44,7 +44,7 @@ func GetFile(fileUrl string) (FileWrapper, error) {
 func ReadBytes(input io.Reader) ([]byte, error) {
 	bytes, err := io.ReadAll(input)
 	if err != nil {
-		err = fmt.Errorf("Error reading file: %v", err)
+		err = fmt.Errorf("error reading file: %v", err)
 	}
 	return bytes, err
 }