Updated ParseField processing

agents/agentreq.go

@@ -373,21 +373,21 @@ func (ar *AgentRequest) ParseField(
 			return nil, fmt.Errorf("invalid arguments <%s> to %s",
 				utils.ToJSON(cfgFld.Value), utils.META_USAGE_DIFFERENCE)
 		}
-		strVal1, err := cfgFld.Value[0].ParseDataProvider(ar)
-		if err != nil {
-			return "", err
+		var strVal1 string
+		if strVal1, err = cfgFld.Value[0].ParseDataProvider(ar); err != nil {
+			return
 		}
-		strVal2, err := cfgFld.Value[1].ParseDataProvider(ar)
-		if err != nil {
-			return "", err
+		var strVal2 string
+		if strVal2, err = cfgFld.Value[1].ParseDataProvider(ar); err != nil {
+			return
 		}
-		tEnd, err := utils.ParseTimeDetectLayout(strVal1, ar.Timezone)
-		if err != nil {
-			return "", err
+		var tEnd time.Time
+		if tEnd, err = utils.ParseTimeDetectLayout(strVal1, ar.Timezone); err != nil {
+			return
 		}
-		tStart, err := utils.ParseTimeDetectLayout(strVal2, ar.Timezone)
-		if err != nil {
-			return "", err
+		var tStart time.Time
+		if tStart, err = utils.ParseTimeDetectLayout(strVal2, ar.Timezone); err != nil {
+			return
 		}
 		out = tEnd.Sub(tStart).String()
 		isString = true
@@ -396,76 +396,62 @@ func (ar *AgentRequest) ParseField(
 			return nil, fmt.Errorf("invalid arguments <%s> to %s",
 				utils.ToJSON(cfgFld.Value), utils.MetaCCUsage)
 		}
-		strVal1, err := cfgFld.Value[0].ParseDataProvider(ar) // ReqNr
-		if err != nil {
-			return "", err
+		var strVal1 string
+		if strVal1, err = cfgFld.Value[0].ParseDataProvider(ar); err != nil {
+			return
 		}
-		reqNr, err := strconv.ParseInt(strVal1, 10, 64)
-		if err != nil {
-			return "", fmt.Errorf("invalid requestNumber <%s> to %s",
+		var reqNr int64
+		if reqNr, err = strconv.ParseInt(strVal1, 10, 64); err != nil {
+			err = fmt.Errorf("invalid requestNumber <%s> to %s",
 				strVal1, utils.MetaCCUsage)
+			return
 		}
-		strVal2, err := cfgFld.Value[1].ParseDataProvider(ar) // TotalUsage
-		if err != nil {
-			return "", err
+		var strVal2 string
+		if strVal2, err = cfgFld.Value[1].ParseDataProvider(ar); err != nil {
+			return
 		}
-		usedCCTime, err := utils.ParseDurationWithNanosecs(strVal2)
-		if err != nil {
-			return "", fmt.Errorf("invalid usedCCTime <%s> to %s",
+		var usedCCTime time.Duration
+		if usedCCTime, err = utils.ParseDurationWithNanosecs(strVal2); err != nil {
+			err = fmt.Errorf("invalid usedCCTime <%s> to %s",
 				strVal2, utils.MetaCCUsage)
+			return
 		}
-		strVal3, err := cfgFld.Value[2].ParseDataProvider(ar) // DebitInterval
-		if err != nil {
-			return "", err
+		var strVal3 string
+		if strVal3, err = cfgFld.Value[2].ParseDataProvider(ar); err != nil {
+			return
 		}
-		debitItvl, err := utils.ParseDurationWithNanosecs(strVal3)
-		if err != nil {
-			return "", fmt.Errorf("invalid debitInterval <%s> to %s",
+		var debitItvl time.Duration
+		if debitItvl, err = utils.ParseDurationWithNanosecs(strVal3); err != nil {
+			err = fmt.Errorf("invalid debitInterval <%s> to %s",
 				strVal3, utils.MetaCCUsage)
+			return
 		}
-		mltpl := reqNr - 1 // terminate will be ignored (init request should always be 0)
-		if mltpl < 0 {
-			mltpl = 0
+		if reqNr--; reqNr < 0 { // terminate will be ignored (init request should always be 0)
+			reqNr = 0
 		}
-		return usedCCTime + time.Duration(debitItvl.Nanoseconds()*mltpl), nil
+		return usedCCTime + time.Duration(debitItvl.Nanoseconds()*reqNr), nil
 	case utils.MetaSum:
-		iFaceVals := make([]interface{}, len(cfgFld.Value))
-		for i, val := range cfgFld.Value {
-			strVal, err := val.ParseDataProvider(ar)
-			if err != nil {
-				return "", err
-			}
-			iFaceVals[i] = utils.StringToInterface(strVal)
+		var iFaceVals []interface{}
+		if iFaceVals, err = cfgFld.Value.GetIfaceFromValues(ar); err != nil {
+			return
 		}
 		out, err = utils.Sum(iFaceVals...)
 	case utils.MetaDifference:
-		iFaceVals := make([]interface{}, len(cfgFld.Value))
-		for i, val := range cfgFld.Value {
-			strVal, err := val.ParseDataProvider(ar)
-			if err != nil {
-				return "", err
-			}
-			iFaceVals[i] = utils.StringToInterface(strVal)
+		var iFaceVals []interface{}
+		if iFaceVals, err = cfgFld.Value.GetIfaceFromValues(ar); err != nil {
+			return
 		}
 		out, err = utils.Difference(iFaceVals...)
 	case utils.MetaMultiply:
-		iFaceVals := make([]interface{}, len(cfgFld.Value))
-		for i, val := range cfgFld.Value {
-			strVal, err := val.ParseDataProvider(ar)
-			if err != nil {
-				return "", err
-			}
-			iFaceVals[i] = utils.StringToInterface(strVal)
+		var iFaceVals []interface{}
+		if iFaceVals, err = cfgFld.Value.GetIfaceFromValues(ar); err != nil {
+			return
 		}
 		out, err = utils.Multiply(iFaceVals...)
 	case utils.MetaDivide:
-		iFaceVals := make([]interface{}, len(cfgFld.Value))
-		for i, val := range cfgFld.Value {
-			strVal, err := val.ParseDataProvider(ar)
-			if err != nil {
-				return "", err
-			}
-			iFaceVals[i] = utils.StringToInterface(strVal)
+		var iFaceVals []interface{}
+		if iFaceVals, err = cfgFld.Value.GetIfaceFromValues(ar); err != nil {
+			return
 		}
 		out, err = utils.Divide(iFaceVals...)
 	case utils.MetaValueExponent:
@@ -473,35 +459,36 @@ func (ar *AgentRequest) ParseField(
 			return nil, fmt.Errorf("invalid arguments <%s> to %s",
 				utils.ToJSON(cfgFld.Value), utils.MetaValueExponent)
 		}
-		strVal1, err := cfgFld.Value[0].ParseDataProvider(ar) // String Value
-		if err != nil {
-			return "", err
+		var strVal1 string
+		if strVal1, err = cfgFld.Value[0].ParseDataProvider(ar); err != nil {
+			return
 		}
-		val, err := strconv.ParseFloat(strVal1, 64)
-		if err != nil {
-			return "", fmt.Errorf("invalid value <%s> to %s",
+		var val float64
+		if val, err = strconv.ParseFloat(strVal1, 64); err != nil {
+			err = fmt.Errorf("invalid value <%s> to %s",
 				strVal1, utils.MetaValueExponent)
+			return
 		}
-		strVal2, err := cfgFld.Value[1].ParseDataProvider(ar) // String Exponent
-		if err != nil {
-			return "", err
+		var strVal2 string
+		if strVal2, err = cfgFld.Value[1].ParseDataProvider(ar); err != nil {
+			return
 		}
-		exp, err := strconv.Atoi(strVal2)
-		if err != nil {
-			return "", err
+		var exp int
+		if exp, err = strconv.Atoi(strVal2); err != nil {
+			return
 		}
 		out = strconv.FormatFloat(utils.Round(val*math.Pow10(exp),
 			config.CgrConfig().GeneralCfg().RoundingDecimals, utils.ROUNDING_MIDDLE), 'f', -1, 64)
 	case utils.MetaUnixTimestamp:
-		val, err := cfgFld.Value.ParseDataProvider(ar)
-		if err != nil {
-			return nil, err
+		var val string
+		if val, err = cfgFld.Value.ParseDataProvider(ar); err != nil {
+			return
 		}
-		t, err := utils.ParseTimeDetectLayout(val, cfgFld.Timezone)
-		if err != nil {
-			return nil, err
+		var t1 time.Time
+		if t1, err = utils.ParseTimeDetectLayout(val, cfgFld.Timezone); err != nil {
+			return
 		}
-		out = strconv.Itoa(int(t.Unix()))
+		out = strconv.Itoa(int(t1.Unix()))
 	}
 
 	if err != nil &&

agents/libdiam.go

@@ -442,9 +442,9 @@ func updateDiamMsgFromNavMap(m *diam.Message, navMp *utils.OrderedNavigableMap,
 		if itm == nil {
 			continue // all attributes, not writable to diameter packet
 		}
-		newBranch := itm.Config != nil && itm.Config.NewBranch
-		if err = messageSetAVPsWithPath(m, itm.Path,
-			utils.IfaceAsString(itm.Data), newBranch, tmz); err != nil {
+		if err = messageSetAVPsWithPath(m,
+			itm.Path, utils.IfaceAsString(itm.Data),
+			itm.Config != nil && itm.Config.NewBranch, tmz); err != nil {
 			return fmt.Errorf("setting item with path: %+v got err: %s", itm.Path, err.Error())
 		}
 	}

config/config_it_test.go

@@ -571,7 +571,6 @@ func testCgrCfgV1ReloadConfigSection(t *testing.T) {
 		map[string]interface{}{
 			"AttributeID":      "",
 			"Blocker":          false,
-			"BreakOnSuccess":   false,
 			"CostShiftDigits":  0,
 			"Path":             "*cgreq.ToR",
 			"Filters":          nil,
@@ -595,7 +594,6 @@ func testCgrCfgV1ReloadConfigSection(t *testing.T) {
 		map[string]interface{}{
 			"AttributeID":      "",
 			"Blocker":          false,
-			"BreakOnSuccess":   false,
 			"CostShiftDigits":  0,
 			"Path":             "*cgreq.OriginID",
 			"Filters":          nil,
@@ -619,7 +617,6 @@ func testCgrCfgV1ReloadConfigSection(t *testing.T) {
 		map[string]interface{}{
 			"AttributeID":      "",
 			"Blocker":          false,
-			"BreakOnSuccess":   false,
 			"CostShiftDigits":  0,
 			"Path":             "*cgreq.RequestType",
 			"Filters":          nil,
@@ -643,7 +640,6 @@ func testCgrCfgV1ReloadConfigSection(t *testing.T) {
 		map[string]interface{}{
 			"AttributeID":      "",
 			"Blocker":          false,
-			"BreakOnSuccess":   false,
 			"CostShiftDigits":  0,
 			"Path":             "*cgreq.Tenant",
 			"Filters":          nil,
@@ -667,7 +663,6 @@ func testCgrCfgV1ReloadConfigSection(t *testing.T) {
 		map[string]interface{}{
 			"AttributeID":      "",
 			"Blocker":          false,
-			"BreakOnSuccess":   false,
 			"CostShiftDigits":  0,
 			"Path":             "*cgreq.Category",
 			"Filters":          nil,
@@ -691,7 +686,6 @@ func testCgrCfgV1ReloadConfigSection(t *testing.T) {
 		map[string]interface{}{
 			"AttributeID":      "",
 			"Blocker":          false,
-			"BreakOnSuccess":   false,
 			"CostShiftDigits":  0,
 			"Path":             "*cgreq.Account",
 			"Filters":          nil,
@@ -715,7 +709,6 @@ func testCgrCfgV1ReloadConfigSection(t *testing.T) {
 		map[string]interface{}{
 			"AttributeID":      "",
 			"Blocker":          false,
-			"BreakOnSuccess":   false,
 			"CostShiftDigits":  0,
 			"Path":             "*cgreq.Subject",
 			"Filters":          nil,
@@ -739,7 +732,6 @@ func testCgrCfgV1ReloadConfigSection(t *testing.T) {
 		map[string]interface{}{
 			"AttributeID":      "",
 			"Blocker":          false,
-			"BreakOnSuccess":   false,
 			"CostShiftDigits":  0,
 			"Path":             "*cgreq.Destination",
 			"Filters":          nil,
@@ -763,7 +755,6 @@ func testCgrCfgV1ReloadConfigSection(t *testing.T) {
 		map[string]interface{}{
 			"AttributeID":      "",
 			"Blocker":          false,
-			"BreakOnSuccess":   false,
 			"CostShiftDigits":  0,
 			"Path":             "*cgreq.SetupTime",
 			"Filters":          nil,
@@ -787,7 +778,6 @@ func testCgrCfgV1ReloadConfigSection(t *testing.T) {
 		map[string]interface{}{
 			"AttributeID":      "",
 			"Blocker":          false,
-			"BreakOnSuccess":   false,
 			"CostShiftDigits":  0,
 			"Path":             "*cgreq.AnswerTime",
 			"Filters":          nil,
@@ -811,7 +801,6 @@ func testCgrCfgV1ReloadConfigSection(t *testing.T) {
 		map[string]interface{}{
 			"AttributeID":      "",
 			"Blocker":          false,
-			"BreakOnSuccess":   false,
 			"CostShiftDigits":  0,
 			"Path":             "*cgreq.Usage",
 			"Filters":          nil,

config/fctemplate.go

@@ -77,9 +77,6 @@ func NewFCTemplateFromFCTemplateJsonCfg(jsnCfg *FcTemplateJsonCfg, separator str
 	if jsnCfg.Blocker != nil {
 		fcTmp.Blocker = *jsnCfg.Blocker
 	}
-	if jsnCfg.Break_on_success != nil {
-		fcTmp.BreakOnSuccess = *jsnCfg.Break_on_success
-	}
 	fcTmp.Layout = time.RFC3339
 	if jsnCfg.Layout != nil {
 		fcTmp.Layout = *jsnCfg.Layout
@@ -114,7 +111,6 @@ type FCTemplate struct {
 	NewBranch        bool   // Used by NavigableMap when creating XMLElements
 	Timezone         string
 	Blocker          bool
-	BreakOnSuccess   bool
 	Layout           string // time format
 	CostShiftDigits  int    // Used for CDR
 	RoundingDecimals *int
@@ -196,7 +192,6 @@ func (fc *FCTemplate) Clone() *FCTemplate {
 	cln.NewBranch = fc.NewBranch
 	cln.Timezone = fc.Timezone
 	cln.Blocker = fc.Blocker
-	cln.BreakOnSuccess = fc.BreakOnSuccess
 	cln.Layout = fc.Layout
 	cln.CostShiftDigits = fc.CostShiftDigits
 	cln.RoundingDecimals = fc.RoundingDecimals
@@ -255,9 +250,6 @@ func (fc *FCTemplate) AsMapInterface(separator string) (mp map[string]interface{
 	if fc.Blocker != false {
 		mp[utils.BlockerCfg] = fc.Blocker
 	}
-	if fc.BreakOnSuccess != false {
-		mp[utils.BreakOnSuccessCfg] = fc.BreakOnSuccess
-	}
 	if fc.Layout != time.RFC3339 {
 		mp[utils.LayoutCfg] = fc.Layout
 	}

config/libconfig_json.go

@@ -587,7 +587,6 @@ type FcTemplateJsonCfg struct {
 	New_branch           *bool
 	Timezone             *string
 	Blocker              *bool
-	Break_on_success     *bool
 	Layout               *string
 	Cost_shift_digits    *int
 	Rounding_decimals    *int

config/rsrparser.go

@@ -161,6 +161,19 @@ func (prsrs RSRParsers) ParseDataProviderWithInterfaces(dP utils.DataProvider) (
 	return
 }
 
+// GetIfaceFromValues returns an interface for each RSRParser
+func (prsrs RSRParsers) GetIfaceFromValues(evNm utils.DataProvider) (iFaceVals []interface{}, err error) {
+	iFaceVals = make([]interface{}, len(prsrs))
+	for i, val := range prsrs {
+		var strVal string
+		if strVal, err = val.ParseDataProvider(evNm); err != nil {
+			return
+		}
+		iFaceVals[i] = utils.StringToInterface(strVal)
+	}
+	return
+}
+
 func NewRSRParser(parserRules string) (rsrParser *RSRParser, err error) {
 	if len(parserRules) == 0 {
 		return

config/rsrparser_test.go

@@ -570,3 +570,20 @@ func TestRSRParserCompileDynRule(t *testing.T) {
 		t.Errorf("Expected ~*req.CGRID received: %q", out)
 	}
 }
+
+func TestRSRParsersGetIfaceFromValues(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			utils.Category: "call",
+		},
+	}
+	exp := []interface{}{"*rated", "call"}
+	if rply, err := NewRSRParsersMustCompile("*rated;~*req.Category", utils.INFIELD_SEP).GetIfaceFromValues(dp); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rply) {
+		t.Errorf("Expecting %q, received: %q", exp, rply)
+	}
+	if _, err := NewRSRParsersMustCompile("*rated;~req.Category", utils.INFIELD_SEP).GetIfaceFromValues(utils.MapStorage{}); err != utils.ErrNotFound {
+		t.Error(err)
+	}
+}

ees/eereq.go

@@ -219,7 +219,7 @@ func (eeR *EventExporterRequest) ParseField(
 	case utils.MetaRemoteHost:
 		out = eeR.RemoteHost().String()
 		isString = true
-	case utils.MetaVariable, utils.META_COMPOSED, utils.MetaGroup:
+	case utils.MetaVariable, utils.META_COMPOSED:
 		out, err = cfgFld.Value.ParseDataProvider(eeR)
 		isString = true
 	case utils.META_USAGE_DIFFERENCE:
@@ -227,21 +227,21 @@ func (eeR *EventExporterRequest) ParseField(
 			return nil, fmt.Errorf("invalid arguments <%s> to %s",
 				utils.ToJSON(cfgFld.Value), utils.META_USAGE_DIFFERENCE)
 		}
-		strVal1, err := cfgFld.Value[0].ParseDataProvider(eeR)
-		if err != nil {
-			return "", err
+		var strVal1 string
+		if strVal1, err = cfgFld.Value[0].ParseDataProvider(eeR); err != nil {
+			return
 		}
-		strVal2, err := cfgFld.Value[1].ParseDataProvider(eeR)
-		if err != nil {
-			return "", err
+		var strVal2 string
+		if strVal2, err = cfgFld.Value[1].ParseDataProvider(eeR); err != nil {
+			return
 		}
-		tEnd, err := utils.ParseTimeDetectLayout(strVal1, eeR.tmz)
-		if err != nil {
-			return "", err
+		var tEnd time.Time
+		if tEnd, err = utils.ParseTimeDetectLayout(strVal1, eeR.tmz); err != nil {
+			return
 		}
-		tStart, err := utils.ParseTimeDetectLayout(strVal2, eeR.tmz)
-		if err != nil {
-			return "", err
+		var tStart time.Time
+		if tStart, err = utils.ParseTimeDetectLayout(strVal2, eeR.tmz); err != nil {
+			return
 		}
 		out = tEnd.Sub(tStart).String()
 		isString = true
@@ -250,76 +250,63 @@ func (eeR *EventExporterRequest) ParseField(
 			return nil, fmt.Errorf("invalid arguments <%s> to %s",
 				utils.ToJSON(cfgFld.Value), utils.MetaCCUsage)
 		}
-		strVal1, err := cfgFld.Value[0].ParseDataProvider(eeR) // ReqNr
-		if err != nil {
-			return "", err
+		var strVal1 string
+		if strVal1, err = cfgFld.Value[0].ParseDataProvider(eeR); err != nil {
+			return
 		}
-		reqNr, err := strconv.ParseInt(strVal1, 10, 64)
-		if err != nil {
-			return "", fmt.Errorf("invalid requestNumber <%s> to %s",
+		var reqNr int64
+		if reqNr, err = strconv.ParseInt(strVal1, 10, 64); err != nil {
+			err = fmt.Errorf("invalid requestNumber <%s> to %s",
 				strVal1, utils.MetaCCUsage)
+			return
 		}
-		strVal2, err := cfgFld.Value[1].ParseDataProvider(eeR) // TotalUsage
-		if err != nil {
-			return "", err
+		var strVal2 string
+		if strVal2, err = cfgFld.Value[1].ParseDataProvider(eeR); err != nil {
+			return
 		}
-		usedCCTime, err := utils.ParseDurationWithNanosecs(strVal2)
-		if err != nil {
-			return "", fmt.Errorf("invalid usedCCTime <%s> to %s",
+		var usedCCTime time.Duration
+		if usedCCTime, err = utils.ParseDurationWithNanosecs(strVal2); err != nil {
+			err = fmt.Errorf("invalid usedCCTime <%s> to %s",
 				strVal2, utils.MetaCCUsage)
+			return
 		}
-		strVal3, err := cfgFld.Value[2].ParseDataProvider(eeR) // DebitInterval
-		if err != nil {
-			return "", err
+		var strVal3 string
+		if strVal3, err = cfgFld.Value[2].ParseDataProvider(eeR); err != nil {
+			return
 		}
-		debitItvl, err := utils.ParseDurationWithNanosecs(strVal3)
-		if err != nil {
-			return "", fmt.Errorf("invalid debitInterval <%s> to %s",
+		var debitItvl time.Duration
+		if debitItvl, err = utils.ParseDurationWithNanosecs(strVal3); err != nil {
+			err = fmt.Errorf("invalid debitInterval <%s> to %s",
 				strVal3, utils.MetaCCUsage)
+			return
 		}
-		mltpl := reqNr - 1 // terminate will be ignored (init request should always be 0)
-		if mltpl < 0 {
-			mltpl = 0
+
+		if reqNr--; reqNr < 0 { // terminate will be ignored (init request should always be 0)
+			reqNr = 0
 		}
-		return usedCCTime + time.Duration(debitItvl.Nanoseconds()*mltpl), nil
+		return usedCCTime + time.Duration(debitItvl.Nanoseconds()*reqNr), nil
 	case utils.MetaSum:
-		iFaceVals := make([]interface{}, len(cfgFld.Value))
-		for i, val := range cfgFld.Value {
-			strVal, err := val.ParseDataProvider(eeR)
-			if err != nil {
-				return "", err
-			}
-			iFaceVals[i] = utils.StringToInterface(strVal)
+		var iFaceVals []interface{}
+		if iFaceVals, err = cfgFld.Value.GetIfaceFromValues(eeR); err != nil {
+			return
 		}
 		out, err = utils.Sum(iFaceVals...)
 	case utils.MetaDifference:
-		iFaceVals := make([]interface{}, len(cfgFld.Value))
-		for i, val := range cfgFld.Value {
-			strVal, err := val.ParseDataProvider(eeR)
-			if err != nil {
-				return "", err
-			}
-			iFaceVals[i] = utils.StringToInterface(strVal)
+		var iFaceVals []interface{}
+		if iFaceVals, err = cfgFld.Value.GetIfaceFromValues(eeR); err != nil {
+			return
 		}
 		out, err = utils.Difference(iFaceVals...)
 	case utils.MetaMultiply:
-		iFaceVals := make([]interface{}, len(cfgFld.Value))
-		for i, val := range cfgFld.Value {
-			strVal, err := val.ParseDataProvider(eeR)
-			if err != nil {
-				return "", err
-			}
-			iFaceVals[i] = utils.StringToInterface(strVal)
+		var iFaceVals []interface{}
+		if iFaceVals, err = cfgFld.Value.GetIfaceFromValues(eeR); err != nil {
+			return
 		}
 		out, err = utils.Multiply(iFaceVals...)
 	case utils.MetaDivide:
-		iFaceVals := make([]interface{}, len(cfgFld.Value))
-		for i, val := range cfgFld.Value {
-			strVal, err := val.ParseDataProvider(eeR)
-			if err != nil {
-				return "", err
-			}
-			iFaceVals[i] = utils.StringToInterface(strVal)
+		var iFaceVals []interface{}
+		if iFaceVals, err = cfgFld.Value.GetIfaceFromValues(eeR); err != nil {
+			return
 		}
 		out, err = utils.Divide(iFaceVals...)
 	case utils.MetaValueExponent:
@@ -327,41 +314,45 @@ func (eeR *EventExporterRequest) ParseField(
 			return nil, fmt.Errorf("invalid arguments <%s> to %s",
 				utils.ToJSON(cfgFld.Value), utils.MetaValueExponent)
 		}
-		strVal1, err := cfgFld.Value[0].ParseDataProvider(eeR) // String Value
-		if err != nil {
-			return "", err
+		var strVal1 string
+		if strVal1, err = cfgFld.Value[0].ParseDataProvider(eeR); err != nil {
+			return
 		}
-		val, err := strconv.ParseFloat(strVal1, 64)
-		if err != nil {
-			return "", fmt.Errorf("invalid value <%s> to %s",
+		var val float64
+		if val, err = strconv.ParseFloat(strVal1, 64); err != nil {
+			err = fmt.Errorf("invalid value <%s> to %s",
 				strVal1, utils.MetaValueExponent)
+			return
 		}
-		strVal2, err := cfgFld.Value[1].ParseDataProvider(eeR) // String Exponent
-		if err != nil {
-			return "", err
+		var strVal2 string
+		if strVal2, err = cfgFld.Value[1].ParseDataProvider(eeR); err != nil {
+			return
 		}
-		exp, err := strconv.Atoi(strVal2)
-		if err != nil {
-			return "", err
+		var exp int
+		if exp, err = strconv.Atoi(strVal2); err != nil {
+			return
 		}
 		out = strconv.FormatFloat(utils.Round(val*math.Pow10(exp),
 			config.CgrConfig().GeneralCfg().RoundingDecimals, utils.ROUNDING_MIDDLE), 'f', -1, 64)
 	case utils.MetaUnixTimestamp:
-		val, err := cfgFld.Value.ParseDataProvider(eeR)
-		if err != nil {
-			return nil, err
+		var val string
+		if val, err = cfgFld.Value.ParseDataProvider(eeR); err != nil {
+			return
 		}
-		t, err := utils.ParseTimeDetectLayout(val, cfgFld.Timezone)
-		if err != nil {
-			return nil, err
+		var t1 time.Time
+		if t1, err = utils.ParseTimeDetectLayout(val, cfgFld.Timezone); err != nil {
+			return
 		}
-		out = strconv.Itoa(int(t.Unix()))
+		out = strconv.Itoa(int(t1.Unix()))
 	case utils.MetaMaskedDestination:
 		//check if we have destination in the event
-		if dst, err := eeR.req.FieldAsString([]string{utils.Destination}); err != nil {
-			return nil, fmt.Errorf("error <%s> getting destination for %s",
+		var dst string
+		if dst, err = eeR.req.FieldAsString([]string{utils.Destination}); err != nil {
+			err = fmt.Errorf("error <%s> getting destination for %s",
 				err, utils.ToJSON(cfgFld))
-		} else if cfgFld.MaskLen != -1 && len(cfgFld.MaskDestID) != 0 &&
+			return
+		}
+		if cfgFld.MaskLen != -1 && len(cfgFld.MaskDestID) != 0 &&
 			engine.CachedDestHasPrefix(cfgFld.MaskDestID, dst) {
 			out = utils.MaskSuffix(dst, cfgFld.MaskLen)
 		}

engine/attributes.go

@@ -224,7 +224,7 @@ func (alS *AttributeService) processEvent(args *AttrArgsProcessEvent, evNm utils
 			substitute = tEnd.Sub(tStart).String()
 		case utils.MetaSum:
 			var ifaceVals []interface{}
-			if ifaceVals, err = getIfaceFromValues(attribute.Value, evNm); err != nil {
+			if ifaceVals, err = attribute.Value.GetIfaceFromValues(evNm); err != nil {
 				rply = nil
 				return
 			}
@@ -236,7 +236,7 @@ func (alS *AttributeService) processEvent(args *AttrArgsProcessEvent, evNm utils
 			substitute = utils.IfaceAsString(ifaceSum)
 		case utils.MetaDifference:
 			var ifaceVals []interface{}
-			if ifaceVals, err = getIfaceFromValues(attribute.Value, evNm); err != nil {
+			if ifaceVals, err = attribute.Value.GetIfaceFromValues(evNm); err != nil {
 				rply = nil
 				return
 			}
@@ -248,7 +248,7 @@ func (alS *AttributeService) processEvent(args *AttrArgsProcessEvent, evNm utils
 			substitute = utils.IfaceAsString(ifaceSum)
 		case utils.MetaMultiply:
 			var ifaceVals []interface{}
-			if ifaceVals, err = getIfaceFromValues(attribute.Value, evNm); err != nil {
+			if ifaceVals, err = attribute.Value.GetIfaceFromValues(evNm); err != nil {
 				rply = nil
 				return
 			}
@@ -260,7 +260,7 @@ func (alS *AttributeService) processEvent(args *AttrArgsProcessEvent, evNm utils
 			substitute = utils.IfaceAsString(ifaceSum)
 		case utils.MetaDivide:
 			var ifaceVals []interface{}
-			if ifaceVals, err = getIfaceFromValues(attribute.Value, evNm); err != nil {
+			if ifaceVals, err = attribute.Value.GetIfaceFromValues(evNm); err != nil {
 				rply = nil
 				return
 			}

engine/libattributes.go

@@ -153,15 +153,3 @@ func NewAttributeFromInline(tenant, inlnRule string) (attr *AttributeProfile, er
 	}
 	return
 }
-
-func getIfaceFromValues(values config.RSRParsers, evNm utils.DataProvider) (iFaceVals []interface{}, err error) {
-	iFaceVals = make([]interface{}, len(values))
-	for i, val := range values {
-		var strVal string
-		if strVal, err = val.ParseDataProvider(evNm); err != nil {
-			return
-		}
-		iFaceVals[i] = utils.StringToInterface(strVal)
-	}
-	return
-}

engine/libattributes_test.go

@@ -167,24 +167,6 @@ func TestNewAttributeFromInlineWithMultipleRuns(t *testing.T) {
 		t.Errorf("Expecting %+v, received: %+v", utils.ToJSON(expAttrPrf1), utils.ToJSON(attr))
 	}
 }
-
-func TestGetIfaceFromValues(t *testing.T) {
-	dp := utils.MapStorage{
-		utils.MetaReq: utils.MapStorage{
-			utils.Category: "call",
-		},
-	}
-	exp := []interface{}{"*rated", "call"}
-	if rply, err := getIfaceFromValues(config.NewRSRParsersMustCompile("*rated;~*req.Category", utils.INFIELD_SEP), dp); err != nil {
-		t.Error(err)
-	} else if !reflect.DeepEqual(exp, rply) {
-		t.Errorf("Expecting %q, received: %q", exp, rply)
-	}
-	if _, err := getIfaceFromValues(config.NewRSRParsersMustCompile("*rated;~req.Category", utils.INFIELD_SEP), utils.MapStorage{}); err != utils.ErrNotFound {
-		t.Error(err)
-	}
-}
-
 func TestNewAttributeFromInlineWithMultipleRuns2(t *testing.T) {
 	attrID := "*constant:*req.RequestType*rated;*constant:*req.Category:call"
 

utils/consts.go

@@ -2207,11 +2207,11 @@ var (
 )
 
 // CGROptionsSet the possible cgr options
-var CGROptionsSet = NewStringSet([]string{OptsStirATest, OptsStirPayloadMaxDuration,
-	OptsStirIdentity, OptsStirOriginatorTn, OptsStirOriginatorURI, OptsStirDestinationTn,
-	OptsStirDestinationURI, OptsStirPublicKeyPath, OptsStirPrivateKeyPath,
-	OptsDebitInterval, OptsContext, OptsSessionTTL, OptsSessionTTLMaxDelay,
-	OptsSessionTTLLastUsed, OptsSessionTTLLastUsage, OptsSessionTTLUsage, OptsAPIKey, OptsRouteID})
+var CGROptionsSet = NewStringSet([]string{OptsRatesStartTime, OptsSessionTTL, OptsSessionTTLMaxDelay,
+	OptsSessionTTLLastUsed, OptsSessionTTLLastUsage, OptsSessionTTLUsage, OptsDebitInterval, OptsStirATest,
+	OptsStirPayloadMaxDuration, OptsStirIdentity, OptsStirOriginatorTn, OptsStirOriginatorURI,
+	OptsStirDestinationTn, OptsStirDestinationURI, OptsStirPublicKeyPath, OptsStirPrivateKeyPath,
+	OptsAPIKey, OptsRouteID, OptsContext, OptsAttributesProcessRuns})
 
 // SessionS ProccessEvent posible options
 const (