Add new converter *duration

apier/v1/stats_it_test.go

@@ -86,7 +86,7 @@ var sTestsStatSV1 = []func(t *testing.T){
 	testV1STSStatsPing,
 	// Need to make a decision about
 	// converter in filters
-	// testV1STSProcessMetricsWithFilter,
+	testV1STSProcessMetricsWithFilter,
 	testV1STSStopEngine,
 }
 
@@ -427,11 +427,11 @@ func testV1STSProcessMetricsWithFilter(t *testing.T) {
 		Metrics: []*engine.MetricWithFilters{
 			&engine.MetricWithFilters{
 				MetricID:  "*acd",
-				FilterIDs: []string{"*gte:~Usage{*duration_seconds}:10.0"},
+				FilterIDs: []string{"*rsr::~Usage{*duration}(>10s)"},
 			},
 			&engine.MetricWithFilters{
 				MetricID:  "*tcd",
-				FilterIDs: []string{"*gte:~Usage:5.0"},
+				FilterIDs: []string{"*rsr::~Usage{*duration}(>5s)"},
 			},
 			&engine.MetricWithFilters{
 				MetricID:  "*sum#CustomValue",
@@ -517,9 +517,9 @@ func testV1STSProcessMetricsWithFilter(t *testing.T) {
 	}
 
 	expectedMetrics = map[string]string{
-		utils.MetaACD: "18s",
+		utils.MetaACD: "12s",
 		utils.MetaTCD: "18s",
-		utils.StatsJoin(utils.MetaSum, "CustomValue"): "10.0",
+		utils.StatsJoin(utils.MetaSum, "CustomValue"): "10",
 	}
 	if err := stsV1Rpc.Call(utils.StatSv1GetQueueStringMetrics,
 		&utils.TenantID{Tenant: "cgrates.org", ID: expectedIDs[0]}, &metrics); err != nil {

utils/consts.go

@@ -550,6 +550,7 @@ const (
 	Version                      = "Version"
 	MetaTenant                   = "*tenant"
 	ResourceUsage                = "ResourceUsage"
+	MetaDuration                 = "*duration"
 )
 
 // Migrator Action

utils/dataconverter.go

@@ -72,6 +72,8 @@ func NewDataConverter(params string) (
 			return NewDivideConverter("")
 		}
 		return NewDivideConverter(params[len(MetaDivide)+1:])
+	case params == MetaDuration:
+		return NewDurationConverter("")
 	default:
 		return nil,
 			fmt.Errorf("unsupported converter definition: <%s>",
@@ -219,3 +221,16 @@ func (m *DivideConverter) Convert(in interface{}) (
 	out = inFloat64 / m.Value
 	return
 }
+
+func NewDurationConverter(params string) (
+	hdlr DataConverter, err error) {
+	return new(DurationConverter), nil
+}
+
+// DurationConverter converts duration into seconds encapsulated in float64
+type DurationConverter struct{}
+
+func (mS *DurationConverter) Convert(in interface{}) (
+	out interface{}, err error) {
+	return IfaceAsDuration(in)
+}

utils/dataconverter_test.go

@@ -198,3 +198,31 @@ func TestDivideConverter(t *testing.T) {
 		t.Errorf("expecting: %+v, received: %+v", expOut, out)
 	}
 }
+
+func TestDurationConverter(t *testing.T) {
+	d, err := NewDataConverter(MetaDuration)
+	if err != nil {
+		t.Error(err.Error())
+	}
+	expVal := time.Duration(10 * time.Second)
+	if i, err := d.Convert(10000000000.0); err != nil {
+		t.Error(err.Error())
+	} else if expVal != i {
+		t.Errorf("expecting: %d, received: %d", expVal, i)
+	}
+	if i, err := d.Convert(10000000000); err != nil {
+		t.Error(err.Error())
+	} else if expVal != i {
+		t.Errorf("expecting: %d, received: %d", expVal, i)
+	}
+	if i, err := d.Convert(time.Duration(10 * time.Second)); err != nil {
+		t.Error(err.Error())
+	} else if expVal != i {
+		t.Errorf("expecting: %d, received: %d", expVal, i)
+	}
+	if i, err := d.Convert("10s"); err != nil {
+		t.Error(err.Error())
+	} else if expVal != i {
+		t.Errorf("expecting: %d, received: %d", expVal, i)
+	}
+}