filter_sort: add time.Time comparison support for gt, gte, lt, lte operators

Signed-off-by: Jeeva Kandasamy <jkandasa@gmail.com>

Author: jkandasa

pkg/utils/filter_sort/utils_filter.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"reflect"
 	"regexp"
+	"time"
 
 	"github.com/mycontroller-org/server/v2/pkg/types/cmap"
 	sfTY "github.com/mycontroller-org/server/v2/pkg/types/service_filter"
@@ -61,6 +62,14 @@ func IsMatching(entity interface{}, filters []storageTY.Filter) bool {
 		case reflect.Bool:
 			match = CompareBool(value, filter.Operator, filter.Value)
 
+		case reflect.Struct:
+			timeValue, ok := value.(time.Time)
+			if !ok {
+				match = false
+				break
+			}
+			match = CompareTime(timeValue, filter.Operator, filter.Value)
+
 		default:
 			match = false
 		}
@@ -251,6 +260,30 @@ func VerifyFloatSlice(value float64, operator string, expectedValue interface{})
 	return false
 }
 
+// CompareTime compares time.Time values
+func CompareTime(value time.Time, operator string, expectedValue interface{}) bool {
+	expectedStr := converterUtils.ToString(expectedValue)
+	expected, err := time.Parse(time.RFC3339, expectedStr)
+	if err != nil {
+		return false
+	}
+	switch operator {
+	case storageTY.OperatorEqual, storageTY.OperatorNone:
+		return value.Equal(expected)
+	case storageTY.OperatorNotEqual:
+		return !value.Equal(expected)
+	case storageTY.OperatorGreaterThan:
+		return value.After(expected)
+	case storageTY.OperatorGreaterThanEqual:
+		return value.After(expected) || value.Equal(expected)
+	case storageTY.OperatorLessThan:
+		return value.Before(expected)
+	case storageTY.OperatorLessThanEqual:
+		return value.Before(expected) || value.Equal(expected)
+	}
+	return false
+}
+
 // IsMine verifies the supplied id and labels with valid list
 func IsMine(svcFilter *sfTY.ServiceFilter, targetType, targetID string, targetLabels cmap.CustomStringMap) bool {
 	if !svcFilter.HasFilter() {

pkg/utils/filter_sort/utils_filter_test.go

@@ -2,9 +2,12 @@ package helper
 
 import (
 	"testing"
+	"time"
 
 	"github.com/mycontroller-org/server/v2/pkg/types/cmap"
 	sfTY "github.com/mycontroller-org/server/v2/pkg/types/service_filter"
+	storageTY "github.com/mycontroller-org/server/v2/plugin/database/storage/types"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -170,3 +173,112 @@ func TestIsMine(t *testing.T) {
 	}
 
 }
+
+func TestCompareTime(t *testing.T) {
+	base := time.Date(2024, time.June, 15, 12, 0, 0, 0, time.UTC)
+	earlier := time.Date(2024, time.June, 10, 12, 0, 0, 0, time.UTC)
+	later := time.Date(2024, time.June, 20, 12, 0, 0, 0, time.UTC)
+
+	baseStr := base.Format(time.RFC3339)
+	earlierStr := earlier.Format(time.RFC3339)
+
+	tests := []struct {
+		name     string
+		value    time.Time
+		operator string
+		filter   string
+		expected bool
+	}{
+		{name: "eq match", value: base, operator: storageTY.OperatorEqual, filter: baseStr, expected: true},
+		{name: "eq no match", value: base, operator: storageTY.OperatorEqual, filter: earlierStr, expected: false},
+		{name: "ne match", value: base, operator: storageTY.OperatorNotEqual, filter: earlierStr, expected: true},
+		{name: "ne no match", value: base, operator: storageTY.OperatorNotEqual, filter: baseStr, expected: false},
+		{name: "gt match", value: later, operator: storageTY.OperatorGreaterThan, filter: baseStr, expected: true},
+		{name: "gt equal no match", value: base, operator: storageTY.OperatorGreaterThan, filter: baseStr, expected: false},
+		{name: "gt earlier no match", value: earlier, operator: storageTY.OperatorGreaterThan, filter: baseStr, expected: false},
+		{name: "gte match equal", value: base, operator: storageTY.OperatorGreaterThanEqual, filter: baseStr, expected: true},
+		{name: "gte match greater", value: later, operator: storageTY.OperatorGreaterThanEqual, filter: baseStr, expected: true},
+		{name: "gte no match", value: earlier, operator: storageTY.OperatorGreaterThanEqual, filter: baseStr, expected: false},
+		{name: "lt match", value: earlier, operator: storageTY.OperatorLessThan, filter: baseStr, expected: true},
+		{name: "lt equal no match", value: base, operator: storageTY.OperatorLessThan, filter: baseStr, expected: false},
+		{name: "lt later no match", value: later, operator: storageTY.OperatorLessThan, filter: baseStr, expected: false},
+		{name: "lte match equal", value: base, operator: storageTY.OperatorLessThanEqual, filter: baseStr, expected: true},
+		{name: "lte match less", value: earlier, operator: storageTY.OperatorLessThanEqual, filter: baseStr, expected: true},
+		{name: "lte no match", value: later, operator: storageTY.OperatorLessThanEqual, filter: baseStr, expected: false},
+		{name: "invalid filter value", value: base, operator: storageTY.OperatorEqual, filter: "not-a-time", expected: false},
+		{name: "unknown operator", value: base, operator: "unknown", filter: baseStr, expected: false},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result := CompareTime(tc.value, tc.operator, tc.filter)
+			assert.Equal(t, tc.expected, result)
+		})
+	}
+}
+
+func TestIsMatchingTimeField(t *testing.T) {
+	type event struct {
+		ID        string
+		CreatedAt time.Time
+	}
+
+	base := time.Date(2024, time.June, 15, 12, 0, 0, 0, time.UTC)
+	earlier := time.Date(2024, time.June, 10, 12, 0, 0, 0, time.UTC)
+	later := time.Date(2024, time.June, 20, 12, 0, 0, 0, time.UTC)
+
+	tests := []struct {
+		name     string
+		entity   interface{}
+		filters  []storageTY.Filter
+		expected bool
+	}{
+		{
+			name:   "gt match",
+			entity: &event{ID: "1", CreatedAt: later},
+			filters: []storageTY.Filter{
+				{Key: "createdAt", Operator: storageTY.OperatorGreaterThan, Value: base.Format(time.RFC3339)},
+			},
+			expected: true,
+		},
+		{
+			name:   "gt no match",
+			entity: &event{ID: "2", CreatedAt: earlier},
+			filters: []storageTY.Filter{
+				{Key: "createdAt", Operator: storageTY.OperatorGreaterThan, Value: base.Format(time.RFC3339)},
+			},
+			expected: false,
+		},
+		{
+			name:   "lt match",
+			entity: &event{ID: "3", CreatedAt: earlier},
+			filters: []storageTY.Filter{
+				{Key: "createdAt", Operator: storageTY.OperatorLessThan, Value: base.Format(time.RFC3339)},
+			},
+			expected: true,
+		},
+		{
+			name:   "lte match equal",
+			entity: &event{ID: "4", CreatedAt: base},
+			filters: []storageTY.Filter{
+				{Key: "createdAt", Operator: storageTY.OperatorLessThanEqual, Value: base.Format(time.RFC3339)},
+			},
+			expected: true,
+		},
+		{
+			name:   "gte no match",
+			entity: &event{ID: "5", CreatedAt: earlier},
+			filters: []storageTY.Filter{
+				{Key: "createdAt", Operator: storageTY.OperatorGreaterThanEqual, Value: base.Format(time.RFC3339)},
+			},
+			expected: false,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result := IsMatching(tc.entity, tc.filters)
+			assert.Equal(t, tc.expected, result)
+		})
+	}
+}