Moved v3 code from NginxProxyManager/nginx-proxy-manager-3 to NginxProxyManager/nginx-proxy-manager

backend/internal/util/interfaces.go

@@ -0,0 +1,36 @@
+package util
+
+// FindItemInInterface Find key in interface (recursively) and return value as interface
+func FindItemInInterface(key string, obj interface{}) (interface{}, bool) {
+	// if the argument is not a map, ignore it
+	mobj, ok := obj.(map[string]interface{})
+	if !ok {
+		return nil, false
+	}
+
+	for k, v := range mobj {
+		// key match, return value
+		if k == key {
+			return v, true
+		}
+
+		// if the value is a map, search recursively
+		if m, ok := v.(map[string]interface{}); ok {
+			if res, ok := FindItemInInterface(key, m); ok {
+				return res, true
+			}
+		}
+		// if the value is an array, search recursively
+		// from each element
+		if va, ok := v.([]interface{}); ok {
+			for _, a := range va {
+				if res, ok := FindItemInInterface(key, a); ok {
+					return res, true
+				}
+			}
+		}
+	}
+
+	// element not found
+	return nil, false
+}

backend/internal/util/maps.go

@@ -0,0 +1,9 @@
+package util
+
+// MapContainsKey is fairly self explanatory
+func MapContainsKey(dict map[string]interface{}, key string) bool {
+	if _, ok := dict[key]; ok {
+		return true
+	}
+	return false
+}

backend/internal/util/maps_test.go

@@ -0,0 +1,45 @@
+package util
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type rect struct {
+	width  int
+	height int
+}
+
+func TestMapContainsKey(t *testing.T) {
+	var r rect
+	r.width = 5
+	r.height = 5
+	m := map[string]interface{}{
+		"rect_width":  r.width,
+		"rect_height": r.height,
+	}
+	tests := []struct {
+		name string
+		pass string
+		want bool
+	}{
+		{
+			name: "exists",
+			pass: "rect_width",
+			want: true,
+		},
+		{
+			name: "Does not exist",
+			pass: "rect_perimeter",
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := MapContainsKey(m, tt.pass)
+
+			assert.Equal(t, result, tt.want)
+		})
+	}
+}

backend/internal/util/slices.go

@@ -0,0 +1,44 @@
+package util
+
+import (
+	"strconv"
+	"strings"
+)
+
+// SliceContainsItem returns whether the slice given contains the item given
+func SliceContainsItem(slice []string, item string) bool {
+	for _, a := range slice {
+		if a == item {
+			return true
+		}
+	}
+	return false
+}
+
+// SliceContainsInt returns whether the slice given contains the item given
+func SliceContainsInt(slice []int, item int) bool {
+	for _, a := range slice {
+		if a == item {
+			return true
+		}
+	}
+	return false
+}
+
+// ConvertIntSliceToString returns a comma separated string of all items in the slice
+func ConvertIntSliceToString(slice []int) string {
+	strs := []string{}
+	for _, item := range slice {
+		strs = append(strs, strconv.Itoa(item))
+	}
+	return strings.Join(strs, ",")
+}
+
+// ConvertStringSliceToInterface is required in some special cases
+func ConvertStringSliceToInterface(slice []string) []interface{} {
+	res := make([]interface{}, len(slice))
+	for i := range slice {
+		res[i] = slice[i]
+	}
+	return res
+}

backend/internal/util/slices_test.go

@@ -0,0 +1,92 @@
+package util
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSliceContainsItem(t *testing.T) {
+	type want struct {
+		result bool
+	}
+	tests := []struct {
+		name        string
+		inputString string
+		inputArray  []string
+		want        want
+	}{
+		{
+			name:        "In array",
+			inputString: "test",
+			inputArray:  []string{"no", "more", "tests", "test"},
+			want: want{
+				result: true,
+			},
+		},
+		{
+			name:        "Not in array",
+			inputString: "test",
+			inputArray:  []string{"no", "more", "tests"},
+			want: want{
+				result: false,
+			},
+		},
+		{
+			name:        "Case sensitive",
+			inputString: "test",
+			inputArray:  []string{"no", "TEST", "more"},
+			want: want{
+				result: false,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := SliceContainsItem(tt.inputArray, tt.inputString)
+			assert.Equal(t, tt.want.result, got)
+		})
+	}
+}
+
+func TestSliceContainsInt(t *testing.T) {
+	type want struct {
+		result bool
+	}
+	tests := []struct {
+		name       string
+		inputInt   int
+		inputArray []int
+		want       want
+	}{
+		{
+			name:       "In array",
+			inputInt:   1,
+			inputArray: []int{1, 2, 3, 4},
+			want: want{
+				result: true,
+			},
+		},
+		{
+			name:       "Not in array",
+			inputInt:   1,
+			inputArray: []int{10, 2, 3, 4},
+			want: want{
+				result: false,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := SliceContainsInt(tt.inputArray, tt.inputInt)
+			assert.Equal(t, tt.want.result, got)
+		})
+	}
+}
+
+func TestConvertIntSliceToString(t *testing.T) {
+	items := []int{1, 2, 3, 4, 5, 6, 7}
+	expectedStr := "1,2,3,4,5,6,7"
+	str := ConvertIntSliceToString(items)
+	assert.Equal(t, expectedStr, str)
+}