Added support for *tmp in loaders

engine/dynamicdp.go

@@ -67,7 +67,7 @@ var initialDPPrefixes = utils.NewStringSet([]string{
 	utils.MetaCgrep, utils.MetaRep, utils.MetaAct,
 	utils.MetaEC, utils.MetaUCH, utils.MetaOpts,
 	utils.MetaHdr, utils.MetaTrl, utils.MetaCfg,
-	utils.MetaTenant})
+	utils.MetaTenant, utils.MetaTmp})
 
 func (dDP *dynamicDP) FieldAsInterface(fldPath []string) (val interface{}, err error) {
 	if len(fldPath) == 0 {

engine/libengine.go

@@ -163,11 +163,6 @@ func NewServiceWithName(val interface{}, name string, useName bool) (_ IntServic
 		}
 		srv2.Methods[m[2:]] = v
 	}
-	for _, s := range s {
-		for m := range s.Methods {
-			utils.Logger.Crit(fmt.Sprintf("===>%s.%s", s.Name, m))
-		}
-	}
 	return s, nil
 }
 

loaders/libloader.go

@@ -35,6 +35,7 @@ func newRecord(ctx *context.Context, req utils.DataProvider, tmpls []*config.FCT
 	cfg *config.CGRConfig, cache *ltcache.Cache) (_ utils.MapStorage, err error) {
 	r := &record{
 		data:  make(utils.MapStorage),
+		tmp:   make(utils.MapStorage),
 		req:   req,
 		cfg:   cfg.GetDataProvider(),
 		cache: cache,
@@ -47,6 +48,7 @@ func newRecord(ctx *context.Context, req utils.DataProvider, tmpls []*config.FCT
 
 type record struct {
 	data  utils.MapStorage
+	tmp   utils.MapStorage
 	req   utils.DataProvider
 	cfg   utils.DataProvider
 	cache *ltcache.Cache
@@ -100,6 +102,8 @@ func (r *record) FieldAsInterface(path []string) (val interface{}, err error) {
 		return r.cfg.FieldAsInterface(path[1:])
 	case utils.MetaReq:
 		return r.req.FieldAsInterface(path[1:])
+	case utils.MetaTmp:
+		return r.tmp.FieldAsInterface(path[1:])
 	default:
 		return r.data.FieldAsInterface(path)
 	}
@@ -122,6 +126,8 @@ func (r *record) Set(path []string, val interface{}) (err error) {
 		}
 		r.cache.Set(cp, val, nil)
 		return
+	case utils.MetaTmp:
+		return r.tmp.Set(path[1:], val)
 	default:
 		return r.data.Set(path, val)
 	}

loaders/libloader_test.go

@@ -136,3 +136,24 @@ func TestNewRecordWithCahe(t *testing.T) {
 		t.Errorf("Expected %+v, received %+q", exp, r)
 	}
 }
+
+func TestNewRecordWithTmp(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	fs := engine.NewFilterS(cfg, nil, nil)
+	fc := []*config.FCTemplate{
+		{Type: utils.MetaVariable, Path: "Tenant", Value: config.NewRSRParsersMustCompile("~*req.0", ";")},
+		{Type: utils.MetaVariable, Path: "ID", Value: config.NewRSRParsersMustCompile("~*req.1", ";")},
+		{Type: utils.MetaComposed, Path: "*tmp.*tntID.Value", Value: config.NewRSRParsersMustCompile("0", ";")},
+		{Type: utils.MetaVariable, Path: "Value", Value: config.NewRSRParsersMustCompile("~*tmp.*tntID.Value", ";")},
+	}
+	for _, f := range fc {
+		f.ComputePath()
+	}
+	exp := utils.MapStorage{"ID": "Attr1", "Tenant": "cgrates.org", "Value": "0"}
+	if r, err := newRecord(context.Background(), config.NewSliceDP([]string{"cgrates.org", "Attr1"}, nil),
+		fc, "cgrates.org", fs, cfg, ltcache.NewCache(-1, 0, false, nil)); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(r, exp) {
+		t.Errorf("Expected %+v, received %+q", exp, r)
+	}
+}

utils/dataconverter.go

@@ -25,6 +25,7 @@ import (
 	"fmt"
 	"math/rand"
 	"net"
+	"reflect"
 	"strconv"
 	"strings"
 	"time"
@@ -510,8 +511,50 @@ func (LengthConverter) Convert(in interface{}) (out interface{}, err error) {
 		return len(val), nil
 	case []complex128:
 		return len(val), nil
+	case map[string]string:
+		return len(val), nil
+	case map[string]interface{}:
+		return len(val), nil
+	case map[string]bool:
+		return len(val), nil
+	case map[string]int:
+		return len(val), nil
+	case map[string]int8:
+		return len(val), nil
+	case map[string]int16:
+		return len(val), nil
+	case map[string]int32:
+		return len(val), nil
+	case map[string]int64:
+		return len(val), nil
+	case map[string]uint:
+		return len(val), nil
+	case map[string]uint8:
+		return len(val), nil
+	case map[string]uint16:
+		return len(val), nil
+	case map[string]uint32:
+		return len(val), nil
+	case map[string]uint64:
+		return len(val), nil
+	case map[string]uintptr:
+		return len(val), nil
+	case map[string]float32:
+		return len(val), nil
+	case map[string]float64:
+		return len(val), nil
+	case map[string]complex64:
+		return len(val), nil
+	case map[string]complex128:
+		return len(val), nil
 	default:
-		return len(IfaceAsString(val)), nil
+		vl := reflect.ValueOf(val)
+		switch vl.Kind() {
+		case reflect.Array, reflect.Map, reflect.Slice:
+			return vl.Len(), nil
+		default:
+			return len(IfaceAsString(val)), nil
+		}
 	}
 }