Move from EventExporterRequest to engine/EventRequest

ees/eereq.go

@@ -1,386 +0,0 @@
-/*
-Real-time Online/Offline Charging System (OerS) for Telecom & ISP environments
-Copyright (C) ITsysCOM GmbH
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>
-*/
-
-package ees
-
-import (
-	"fmt"
-	"math"
-	"net"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/cgrates/cgrates/config"
-	"github.com/cgrates/cgrates/engine"
-	"github.com/cgrates/cgrates/utils"
-)
-
-// NewEventExporterRequest returns a new EventExporterRequest
-func NewEventExporterRequest(req utils.DataProvider, dc, opts utils.MapStorage,
-	tntTpl config.RSRParsers, dfltTenant, timezone string,
-	filterS *engine.FilterS) (eeR *EventExporterRequest) {
-	eeR = &EventExporterRequest{
-		req:     req,
-		tnt:     dfltTenant,
-		tmz:     timezone,
-		filterS: filterS,
-		cnt:     utils.NewOrderedNavigableMap(),
-		hdr:     utils.NewOrderedNavigableMap(),
-		trl:     utils.NewOrderedNavigableMap(),
-		dc:      dc,
-		opts:    opts,
-	}
-	if tntTpl != nil {
-		if tntIf, err := eeR.ParseField(
-			&config.FCTemplate{Type: utils.MetaComposed,
-				Value: tntTpl}); err == nil && tntIf.(string) != "" {
-			eeR.tnt = tntIf.(string)
-		}
-	}
-	return
-}
-
-// EventExporterRequest represents data related to one request towards agent
-// implements utils.DataProvider so we can pass it to filters
-type EventExporterRequest struct {
-	req  utils.DataProvider // request
-	eeDP utils.DataProvider // eventExporter DataProvider
-	tnt  string
-	tmz  string
-	cnt  *utils.OrderedNavigableMap // Used in reply to access the request that was send
-	hdr  *utils.OrderedNavigableMap // Used in reply to access the request that was send
-	trl  *utils.OrderedNavigableMap // Used in reply to access the request that was send
-	dc   utils.MapStorage
-	opts utils.MapStorage
-
-	filterS *engine.FilterS
-}
-
-// String implements utils.DataProvider
-func (eeR *EventExporterRequest) String() string {
-	return utils.ToIJSON(eeR)
-}
-
-// RemoteHost implements utils.DataProvider
-func (eeR *EventExporterRequest) RemoteHost() net.Addr {
-	return eeR.req.RemoteHost()
-}
-
-// FieldAsInterface implements utils.DataProvider
-func (eeR *EventExporterRequest) FieldAsInterface(fldPath []string) (val interface{}, err error) {
-	switch fldPath[0] {
-	default:
-		return nil, fmt.Errorf("unsupported field prefix: <%s>", fldPath[0])
-	case utils.MetaReq:
-		val, err = eeR.req.FieldAsInterface(fldPath[1:])
-	case utils.MetaUCH:
-		if cacheVal, ok := engine.Cache.Get(utils.CacheUCH, strings.Join(fldPath[1:], utils.NestingSep)); !ok {
-			err = utils.ErrNotFound
-		} else {
-			val = cacheVal
-		}
-	case utils.MetaDC:
-		val, err = eeR.dc.FieldAsInterface(fldPath[1:])
-	case utils.MetaOpts:
-		val, err = eeR.opts.FieldAsInterface(fldPath[1:])
-	}
-	if err != nil {
-		return
-	}
-	if nmItems, isNMItems := val.(*utils.NMSlice); isNMItems { // special handling of NMItems, take the last value out of it
-		val = (*nmItems)[len(*nmItems)-1].Interface()
-	}
-	return
-}
-
-// Field implements utils.NMInterface
-func (eeR *EventExporterRequest) Field(fldPath utils.PathItems) (val utils.NMInterface, err error) {
-	switch fldPath[0].Field {
-	default:
-		return nil, fmt.Errorf("unsupported field prefix: <%s>", fldPath[0])
-	case utils.MetaExp:
-		val, err = eeR.cnt.Field(fldPath[1:])
-	case utils.MetaHdr:
-		val, err = eeR.hdr.Field(fldPath[1:])
-	case utils.MetaTrl:
-		val, err = eeR.trl.Field(fldPath[1:])
-	}
-	return
-}
-
-// FieldAsString implements utils.DataProvider
-func (eeR *EventExporterRequest) FieldAsString(fldPath []string) (val string, err error) {
-	var iface interface{}
-	if iface, err = eeR.FieldAsInterface(fldPath); err != nil {
-		return
-	}
-	return utils.IfaceAsString(iface), nil
-}
-
-//SetFields will populate fields of AgentRequest out of templates
-func (eeR *EventExporterRequest) SetFields(tplFlds []*config.FCTemplate) (err error) {
-	for _, tplFld := range tplFlds {
-		if pass, err := eeR.filterS.Pass(eeR.tnt,
-			tplFld.Filters, eeR); err != nil {
-			return err
-		} else if !pass {
-			continue
-		}
-
-		var out interface{}
-		out, err = eeR.ParseField(tplFld)
-		if err != nil {
-			if err == utils.ErrNotFound {
-				if !tplFld.Mandatory {
-					err = nil
-					continue
-				}
-				err = utils.ErrPrefixNotFound(tplFld.Tag)
-			}
-			return
-		}
-		var fullPath *utils.FullPath
-		var itmPath []string
-		if fullPath, err = utils.GetFullFieldPath(tplFld.Path, eeR); err != nil {
-			return
-		} else if fullPath == nil { // no dynamic path
-			fullPath = &utils.FullPath{
-				PathItems: tplFld.GetPathItems().Clone(), // need to clone so me do not modify the template
-				Path:      tplFld.Path,
-			}
-			itmPath = tplFld.GetPathSlice()[1:]
-		} else {
-			itmPath = fullPath.PathItems.Slice()[1:]
-		}
-		nMItm := &config.NMItem{Data: out, Path: itmPath, Config: tplFld}
-		switch tplFld.Type {
-		case utils.MetaComposed:
-			err = utils.ComposeNavMapVal(eeR, fullPath, nMItm)
-		case utils.MetaGroup: // in case of *group type simply append to valSet
-			err = utils.AppendNavMapVal(eeR, fullPath, nMItm)
-		default:
-			_, err = eeR.Set(fullPath, &utils.NMSlice{nMItm})
-		}
-		if err != nil {
-			return
-		}
-
-		if tplFld.Blocker { // useful in case of processing errors first
-			break
-		}
-	}
-	return
-}
-
-// Set implements utils.NMInterface
-func (eeR *EventExporterRequest) Set(fullPath *utils.FullPath, nm utils.NMInterface) (added bool, err error) {
-
-	switch fullPath.PathItems[0].Field {
-	default:
-		return false, fmt.Errorf("unsupported field prefix: <%s> when set field", fullPath.PathItems[0].Field)
-	case utils.MetaExp:
-		return eeR.cnt.Set(&utils.FullPath{
-			PathItems: fullPath.PathItems[1:],
-			Path:      fullPath.Path[4:],
-		}, nm)
-	case utils.MetaHdr:
-		return eeR.hdr.Set(&utils.FullPath{
-			PathItems: fullPath.PathItems[1:],
-			Path:      fullPath.Path[4:],
-		}, nm)
-	case utils.MetaTrl:
-		return eeR.trl.Set(&utils.FullPath{
-			PathItems: fullPath.PathItems[1:],
-			Path:      fullPath.Path[4:],
-		}, nm)
-	case utils.MetaUCH:
-		err = engine.Cache.Set(utils.CacheUCH, fullPath.Path[5:], nm, nil, true, utils.NonTransactional)
-	}
-	return false, err
-}
-
-// ParseField outputs the value based on the template item
-func (eeR *EventExporterRequest) ParseField(
-	cfgFld *config.FCTemplate) (out interface{}, err error) {
-	var isString bool
-	switch cfgFld.Type {
-	default:
-		return utils.EmptyString, fmt.Errorf("unsupported type: <%s>", cfgFld.Type)
-	case utils.MetaNone:
-		return
-	case utils.MetaFiller:
-		out, err = cfgFld.Value.ParseValue(utils.EmptyString)
-		cfgFld.Padding = utils.MetaRight
-		isString = true
-	case utils.MetaConstant:
-		out, err = cfgFld.Value.ParseValue(utils.EmptyString)
-		isString = true
-	case utils.MetaRemoteHost:
-		out = eeR.RemoteHost().String()
-		isString = true
-	case utils.MetaVariable, utils.MetaComposed, utils.MetaGroup:
-		out, err = cfgFld.Value.ParseDataProvider(eeR)
-		isString = true
-	case utils.MetaUsageDifference:
-		if len(cfgFld.Value) != 2 {
-			return nil, fmt.Errorf("invalid arguments <%s> to %s",
-				utils.ToJSON(cfgFld.Value), utils.MetaUsageDifference)
-		}
-		var strVal1 string
-		if strVal1, err = cfgFld.Value[0].ParseDataProvider(eeR); err != nil {
-			return
-		}
-		var strVal2 string
-		if strVal2, err = cfgFld.Value[1].ParseDataProvider(eeR); err != nil {
-			return
-		}
-		var tEnd time.Time
-		if tEnd, err = utils.ParseTimeDetectLayout(strVal1, eeR.tmz); err != nil {
-			return
-		}
-		var tStart time.Time
-		if tStart, err = utils.ParseTimeDetectLayout(strVal2, eeR.tmz); err != nil {
-			return
-		}
-		out = tEnd.Sub(tStart).String()
-		isString = true
-	case utils.MetaCCUsage:
-		if len(cfgFld.Value) != 3 {
-			return nil, fmt.Errorf("invalid arguments <%s> to %s",
-				utils.ToJSON(cfgFld.Value), utils.MetaCCUsage)
-		}
-		var strVal1 string
-		if strVal1, err = cfgFld.Value[0].ParseDataProvider(eeR); err != nil {
-			return
-		}
-		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
-		}
-		var strVal2 string
-		if strVal2, err = cfgFld.Value[1].ParseDataProvider(eeR); err != nil {
-			return
-		}
-		var usedCCTime time.Duration
-		if usedCCTime, err = utils.ParseDurationWithNanosecs(strVal2); err != nil {
-			err = fmt.Errorf("invalid usedCCTime <%s> to %s",
-				strVal2, utils.MetaCCUsage)
-			return
-		}
-		var strVal3 string
-		if strVal3, err = cfgFld.Value[2].ParseDataProvider(eeR); err != nil {
-			return
-		}
-		var debitItvl time.Duration
-		if debitItvl, err = utils.ParseDurationWithNanosecs(strVal3); err != nil {
-			err = fmt.Errorf("invalid debitInterval <%s> to %s",
-				strVal3, utils.MetaCCUsage)
-			return
-		}
-
-		if reqNr--; reqNr < 0 { // terminate will be ignored (init request should always be 0)
-			reqNr = 0
-		}
-		return usedCCTime + time.Duration(debitItvl.Nanoseconds()*reqNr), nil
-	case utils.MetaSum:
-		var iFaceVals []interface{}
-		if iFaceVals, err = cfgFld.Value.GetIfaceFromValues(eeR); err != nil {
-			return
-		}
-		out, err = utils.Sum(iFaceVals...)
-	case utils.MetaDifference:
-		var iFaceVals []interface{}
-		if iFaceVals, err = cfgFld.Value.GetIfaceFromValues(eeR); err != nil {
-			return
-		}
-		out, err = utils.Difference(iFaceVals...)
-	case utils.MetaMultiply:
-		var iFaceVals []interface{}
-		if iFaceVals, err = cfgFld.Value.GetIfaceFromValues(eeR); err != nil {
-			return
-		}
-		out, err = utils.Multiply(iFaceVals...)
-	case utils.MetaDivide:
-		var iFaceVals []interface{}
-		if iFaceVals, err = cfgFld.Value.GetIfaceFromValues(eeR); err != nil {
-			return
-		}
-		out, err = utils.Divide(iFaceVals...)
-	case utils.MetaValueExponent:
-		if len(cfgFld.Value) != 2 {
-			return nil, fmt.Errorf("invalid arguments <%s> to %s",
-				utils.ToJSON(cfgFld.Value), utils.MetaValueExponent)
-		}
-		var strVal1 string
-		if strVal1, err = cfgFld.Value[0].ParseDataProvider(eeR); err != nil {
-			return
-		}
-		var val float64
-		if val, err = strconv.ParseFloat(strVal1, 64); err != nil {
-			err = fmt.Errorf("invalid value <%s> to %s",
-				strVal1, utils.MetaValueExponent)
-			return
-		}
-		var strVal2 string
-		if strVal2, err = cfgFld.Value[1].ParseDataProvider(eeR); err != nil {
-			return
-		}
-		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.MetaRoundingMiddle), 'f', -1, 64)
-	case utils.MetaUnixTimestamp:
-		var val string
-		if val, err = cfgFld.Value.ParseDataProvider(eeR); err != nil {
-			return
-		}
-		var t1 time.Time
-		if t1, err = utils.ParseTimeDetectLayout(val, cfgFld.Timezone); err != nil {
-			return
-		}
-		out = strconv.Itoa(int(t1.Unix()))
-	case utils.MetaMaskedDestination:
-		//check if we have destination in the event
-		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))
-			return
-		}
-		if cfgFld.MaskLen != -1 && len(cfgFld.MaskDestID) != 0 &&
-			engine.CachedDestHasPrefix(cfgFld.MaskDestID, dst) {
-			out = utils.MaskSuffix(dst, cfgFld.MaskLen)
-		}
-
-	}
-
-	if err != nil &&
-		!strings.HasPrefix(err.Error(), "Could not find") {
-		return
-	}
-	if isString { // format the string additionally with fmtFieldWidth
-		out, err = utils.FmtFieldWidth(cfgFld.Tag, out.(string), cfgFld.Width,
-			cfgFld.Strip, cfgFld.Padding, cfgFld.Mandatory)
-	}
-	return
-}

ees/elastic.go

@@ -139,19 +139,22 @@ func (eEe *ElasticEe) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 	if len(eEe.cgrCfg.EEsCfg().Exporters[eEe.cfgIdx].ContentFields()) == 0 {
 		valMp = cgrEv.Event
 	} else {
+		oNm := map[string]*utils.OrderedNavigableMap{
+			utils.MetaExp: utils.NewOrderedNavigableMap(),
+		}
 		req := utils.MapStorage(cgrEv.Event)
-		eeReq := NewEventExporterRequest(req, eEe.dc, cgrEv.Opts,
+		eeReq := engine.NewEventRequest(req, eEe.dc, cgrEv.Opts,
 			eEe.cgrCfg.EEsCfg().Exporters[eEe.cfgIdx].Tenant,
 			eEe.cgrCfg.GeneralCfg().DefaultTenant,
 			utils.FirstNonEmpty(eEe.cgrCfg.EEsCfg().Exporters[eEe.cfgIdx].Timezone,
 				eEe.cgrCfg.GeneralCfg().DefaultTimezone),
-			eEe.filterS)
+			eEe.filterS, oNm)
 		if err = eeReq.SetFields(eEe.cgrCfg.EEsCfg().Exporters[eEe.cfgIdx].ContentFields()); err != nil {
 			return
 		}
-		for el := eeReq.cnt.GetFirstElement(); el != nil; el = el.Next() {
+		for el := eeReq.OrdNavMP[utils.MetaExp].GetFirstElement(); el != nil; el = el.Next() {
 			var nmIt utils.NMInterface
-			if nmIt, err = eeReq.cnt.Field(el.Value); err != nil {
+			if nmIt, err = eeReq.OrdNavMP[utils.MetaExp].Field(el.Value); err != nil {
 				return
 			}
 			itm, isNMItem := nmIt.(*config.NMItem)

ees/filecsv.go

@@ -109,20 +109,23 @@ func (fCsv *FileCSVee) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 			csvRecord = append(csvRecord, utils.IfaceAsString(val))
 		}
 	} else {
+		oNm := map[string]*utils.OrderedNavigableMap{
+			utils.MetaExp: utils.NewOrderedNavigableMap(),
+		}
 		req := utils.MapStorage(cgrEv.Event)
-		eeReq := NewEventExporterRequest(req, fCsv.dc, cgrEv.Opts,
+		eeReq := engine.NewEventRequest(req, fCsv.dc, cgrEv.Opts,
 			fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].Tenant,
 			fCsv.cgrCfg.GeneralCfg().DefaultTenant,
 			utils.FirstNonEmpty(fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].Timezone,
 				fCsv.cgrCfg.GeneralCfg().DefaultTimezone),
-			fCsv.filterS)
+			fCsv.filterS, oNm)
 
 		if err = eeReq.SetFields(fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].ContentFields()); err != nil {
 			return
 		}
-		for el := eeReq.cnt.GetFirstElement(); el != nil; el = el.Next() {
+		for el := eeReq.OrdNavMP[utils.MetaExp].GetFirstElement(); el != nil; el = el.Next() {
 			var strVal string
-			if strVal, err = eeReq.cnt.FieldAsString(el.Value.Slice()); err != nil {
+			if strVal, err = eeReq.OrdNavMP[utils.MetaExp].FieldAsString(el.Value.Slice()); err != nil {
 				return
 			}
 			csvRecord = append(csvRecord, strVal)
@@ -140,18 +143,21 @@ func (fCsv *FileCSVee) composeHeader() (err error) {
 		return
 	}
 	var csvRecord []string
-	eeReq := NewEventExporterRequest(nil, fCsv.dc, nil,
+	oNm := map[string]*utils.OrderedNavigableMap{
+		utils.MetaHdr: utils.NewOrderedNavigableMap(),
+	}
+	eeReq := engine.NewEventRequest(nil, fCsv.dc, nil,
 		fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].Tenant,
 		fCsv.cgrCfg.GeneralCfg().DefaultTenant,
 		utils.FirstNonEmpty(fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].Timezone,
 			fCsv.cgrCfg.GeneralCfg().DefaultTimezone),
-		fCsv.filterS)
+		fCsv.filterS, oNm)
 	if err = eeReq.SetFields(fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].HeaderFields()); err != nil {
 		return
 	}
-	for el := eeReq.hdr.GetFirstElement(); el != nil; el = el.Next() {
+	for el := eeReq.OrdNavMP[utils.MetaHdr].GetFirstElement(); el != nil; el = el.Next() {
 		var strVal string
-		if strVal, err = eeReq.hdr.FieldAsString(el.Value.Slice()); err != nil {
+		if strVal, err = eeReq.OrdNavMP[utils.MetaHdr].FieldAsString(el.Value.Slice()); err != nil {
 			return
 		}
 		csvRecord = append(csvRecord, strVal)
@@ -165,18 +171,21 @@ func (fCsv *FileCSVee) composeTrailer() (err error) {
 		return
 	}
 	var csvRecord []string
-	eeReq := NewEventExporterRequest(nil, fCsv.dc, nil,
+	oNm := map[string]*utils.OrderedNavigableMap{
+		utils.MetaTrl: utils.NewOrderedNavigableMap(),
+	}
+	eeReq := engine.NewEventRequest(nil, fCsv.dc, nil,
 		fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].Tenant,
 		fCsv.cgrCfg.GeneralCfg().DefaultTenant,
 		utils.FirstNonEmpty(fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].Timezone,
 			fCsv.cgrCfg.GeneralCfg().DefaultTimezone),
-		fCsv.filterS)
+		fCsv.filterS, oNm)
 	if err = eeReq.SetFields(fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].TrailerFields()); err != nil {
 		return
 	}
-	for el := eeReq.trl.GetFirstElement(); el != nil; el = el.Next() {
+	for el := eeReq.OrdNavMP[utils.MetaTrl].GetFirstElement(); el != nil; el = el.Next() {
 		var strVal string
-		if strVal, err = eeReq.trl.FieldAsString(el.Value.Slice()); err != nil {
+		if strVal, err = eeReq.OrdNavMP[utils.MetaTrl].FieldAsString(el.Value.Slice()); err != nil {
 			return
 		}
 		csvRecord = append(csvRecord, strVal)

ees/filefwv.go

@@ -99,20 +99,23 @@ func (fFwv *FileFWVee) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 			records = append(records, utils.IfaceAsString(val))
 		}
 	} else {
+		oNm := map[string]*utils.OrderedNavigableMap{
+			utils.MetaExp: utils.NewOrderedNavigableMap(),
+		}
 		req := utils.MapStorage(cgrEv.Event)
-		eeReq := NewEventExporterRequest(req, fFwv.dc, cgrEv.Opts,
+		eeReq := engine.NewEventRequest(req, fFwv.dc, cgrEv.Opts,
 			fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].Tenant,
 			fFwv.cgrCfg.GeneralCfg().DefaultTenant,
 			utils.FirstNonEmpty(fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].Timezone,
 				fFwv.cgrCfg.GeneralCfg().DefaultTimezone),
-			fFwv.filterS)
+			fFwv.filterS, oNm)
 
 		if err = eeReq.SetFields(fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].ContentFields()); err != nil {
 			return
 		}
-		for el := eeReq.cnt.GetFirstElement(); el != nil; el = el.Next() {
+		for el := eeReq.OrdNavMP[utils.MetaExp].GetFirstElement(); el != nil; el = el.Next() {
 			var strVal string
-			if strVal, err = eeReq.cnt.FieldAsString(el.Value.Slice()); err != nil {
+			if strVal, err = eeReq.OrdNavMP[utils.MetaExp].FieldAsString(el.Value.Slice()); err != nil {
 				return
 			}
 			records = append(records, strVal)
@@ -135,18 +138,21 @@ func (fFwv *FileFWVee) composeHeader() (err error) {
 		return
 	}
 	var records []string
-	eeReq := NewEventExporterRequest(nil, fFwv.dc, nil,
+	oNm := map[string]*utils.OrderedNavigableMap{
+		utils.MetaHdr: utils.NewOrderedNavigableMap(),
+	}
+	eeReq := engine.NewEventRequest(nil, fFwv.dc, nil,
 		fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].Tenant,
 		fFwv.cgrCfg.GeneralCfg().DefaultTenant,
 		utils.FirstNonEmpty(fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].Timezone,
 			fFwv.cgrCfg.GeneralCfg().DefaultTimezone),
-		fFwv.filterS)
+		fFwv.filterS, oNm)
 	if err = eeReq.SetFields(fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].HeaderFields()); err != nil {
 		return
 	}
-	for el := eeReq.hdr.GetFirstElement(); el != nil; el = el.Next() {
+	for el := eeReq.OrdNavMP[utils.MetaHdr].GetFirstElement(); el != nil; el = el.Next() {
 		var strVal string
-		if strVal, err = eeReq.hdr.FieldAsString(el.Value.Slice()); err != nil {
+		if strVal, err = eeReq.OrdNavMP[utils.MetaHdr].FieldAsString(el.Value.Slice()); err != nil {
 			return
 		}
 		records = append(records, strVal)
@@ -165,18 +171,21 @@ func (fFwv *FileFWVee) composeTrailer() (err error) {
 		return
 	}
 	var records []string
-	eeReq := NewEventExporterRequest(nil, fFwv.dc, nil,
+	oNm := map[string]*utils.OrderedNavigableMap{
+		utils.MetaTrl: utils.NewOrderedNavigableMap(),
+	}
+	eeReq := engine.NewEventRequest(nil, fFwv.dc, nil,
 		fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].Tenant,
 		fFwv.cgrCfg.GeneralCfg().DefaultTenant,
 		utils.FirstNonEmpty(fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].Timezone,
 			fFwv.cgrCfg.GeneralCfg().DefaultTimezone),
-		fFwv.filterS)
+		fFwv.filterS, oNm)
 	if err = eeReq.SetFields(fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].TrailerFields()); err != nil {
 		return
 	}
-	for el := eeReq.trl.GetFirstElement(); el != nil; el = el.Next() {
+	for el := eeReq.OrdNavMP[utils.MetaTrl].GetFirstElement(); el != nil; el = el.Next() {
 		var strVal string
-		if strVal, err = eeReq.trl.FieldAsString(el.Value.Slice()); err != nil {
+		if strVal, err = eeReq.OrdNavMP[utils.MetaTrl].FieldAsString(el.Value.Slice()); err != nil {
 			return
 		}
 		records = append(records, strVal)

ees/httpjsonmap.go

@@ -87,18 +87,21 @@ func (httpEE *HTTPjsonMapEE) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 	if len(httpEE.cgrCfg.EEsCfg().Exporters[httpEE.cfgIdx].ContentFields()) == 0 {
 		valMp = cgrEv.Event
 	} else {
-		eeReq := NewEventExporterRequest(utils.MapStorage(cgrEv.Event), httpEE.dc, cgrEv.Opts,
+		oNm := map[string]*utils.OrderedNavigableMap{
+			utils.MetaExp: utils.NewOrderedNavigableMap(),
+		}
+		eeReq := engine.NewEventRequest(utils.MapStorage(cgrEv.Event), httpEE.dc, cgrEv.Opts,
 			httpEE.cgrCfg.EEsCfg().Exporters[httpEE.cfgIdx].Tenant,
 			httpEE.cgrCfg.GeneralCfg().DefaultTenant,
 			utils.FirstNonEmpty(httpEE.cgrCfg.EEsCfg().Exporters[httpEE.cfgIdx].Timezone,
-				httpEE.cgrCfg.GeneralCfg().DefaultTimezone), httpEE.filterS)
+				httpEE.cgrCfg.GeneralCfg().DefaultTimezone), httpEE.filterS, oNm)
 
 		if err = eeReq.SetFields(httpEE.cgrCfg.EEsCfg().Exporters[httpEE.cfgIdx].ContentFields()); err != nil {
 			return
 		}
-		for el := eeReq.cnt.GetFirstElement(); el != nil; el = el.Next() {
+		for el := eeReq.OrdNavMP[utils.MetaExp].GetFirstElement(); el != nil; el = el.Next() {
 			var nmIt utils.NMInterface
-			if nmIt, err = eeReq.cnt.Field(el.Value); err != nil {
+			if nmIt, err = eeReq.OrdNavMP[utils.MetaExp].Field(el.Value); err != nil {
 				return
 			}
 			itm, isNMItem := nmIt.(*config.NMItem)
@@ -141,18 +144,21 @@ func (httpEE *HTTPjsonMapEE) composeHeader() (hdr http.Header, err error) {
 	if len(httpEE.cgrCfg.EEsCfg().Exporters[httpEE.cfgIdx].HeaderFields()) == 0 {
 		return
 	}
-	eeReq := NewEventExporterRequest(nil, httpEE.dc, nil,
+	oNm := map[string]*utils.OrderedNavigableMap{
+		utils.MetaHdr: utils.NewOrderedNavigableMap(),
+	}
+	eeReq := engine.NewEventRequest(nil, httpEE.dc, nil,
 		httpEE.cgrCfg.EEsCfg().Exporters[httpEE.cfgIdx].Tenant,
 		httpEE.cgrCfg.GeneralCfg().DefaultTenant,
 		utils.FirstNonEmpty(httpEE.cgrCfg.EEsCfg().Exporters[httpEE.cfgIdx].Timezone,
 			httpEE.cgrCfg.GeneralCfg().DefaultTimezone),
-		httpEE.filterS)
+		httpEE.filterS, oNm)
 	if err = eeReq.SetFields(httpEE.cgrCfg.EEsCfg().Exporters[httpEE.cfgIdx].HeaderFields()); err != nil {
 		return
 	}
-	for el := eeReq.hdr.GetFirstElement(); el != nil; el = el.Next() {
+	for el := eeReq.OrdNavMP[utils.MetaHdr].GetFirstElement(); el != nil; el = el.Next() {
 		var nmIt utils.NMInterface
-		if nmIt, err = eeReq.hdr.Field(el.Value); err != nil {
+		if nmIt, err = eeReq.OrdNavMP[utils.MetaHdr].Field(el.Value); err != nil {
 			return
 		}
 		itm, isNMItem := nmIt.(*config.NMItem)

ees/httppost.go

@@ -82,19 +82,22 @@ func (httpPost *HTTPPost) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 			urlVals.Set(k, utils.IfaceAsString(v))
 		}
 	} else {
+		oNm := map[string]*utils.OrderedNavigableMap{
+			utils.MetaExp: utils.NewOrderedNavigableMap(),
+		}
 		req := utils.MapStorage(cgrEv.Event)
-		eeReq := NewEventExporterRequest(req, httpPost.dc, cgrEv.Opts,
+		eeReq := engine.NewEventRequest(req, httpPost.dc, cgrEv.Opts,
 			httpPost.cgrCfg.EEsCfg().Exporters[httpPost.cfgIdx].Tenant,
 			httpPost.cgrCfg.GeneralCfg().DefaultTenant,
 			utils.FirstNonEmpty(httpPost.cgrCfg.EEsCfg().Exporters[httpPost.cfgIdx].Timezone,
 				httpPost.cgrCfg.GeneralCfg().DefaultTimezone),
-			httpPost.filterS)
+			httpPost.filterS, oNm)
 		if err = eeReq.SetFields(httpPost.cgrCfg.EEsCfg().Exporters[httpPost.cfgIdx].ContentFields()); err != nil {
 			return
 		}
-		for el := eeReq.cnt.GetFirstElement(); el != nil; el = el.Next() {
+		for el := eeReq.OrdNavMP[utils.MetaExp].GetFirstElement(); el != nil; el = el.Next() {
 			var nmIt utils.NMInterface
-			if nmIt, err = eeReq.cnt.Field(el.Value); err != nil {
+			if nmIt, err = eeReq.OrdNavMP[utils.MetaExp].Field(el.Value); err != nil {
 				return
 			}
 			itm, isNMItem := nmIt.(*config.NMItem)
@@ -134,18 +137,21 @@ func (httpPost *HTTPPost) composeHeader() (hdr http.Header, err error) {
 	if len(httpPost.cgrCfg.EEsCfg().Exporters[httpPost.cfgIdx].HeaderFields()) == 0 {
 		return
 	}
-	eeReq := NewEventExporterRequest(nil, httpPost.dc, nil,
+	oNm := map[string]*utils.OrderedNavigableMap{
+		utils.MetaHdr: utils.NewOrderedNavigableMap(),
+	}
+	eeReq := engine.NewEventRequest(nil, httpPost.dc, nil,
 		httpPost.cgrCfg.EEsCfg().Exporters[httpPost.cfgIdx].Tenant,
 		httpPost.cgrCfg.GeneralCfg().DefaultTenant,
 		utils.FirstNonEmpty(httpPost.cgrCfg.EEsCfg().Exporters[httpPost.cfgIdx].Timezone,
 			httpPost.cgrCfg.GeneralCfg().DefaultTimezone),
-		httpPost.filterS)
+		httpPost.filterS, oNm)
 	if err = eeReq.SetFields(httpPost.cgrCfg.EEsCfg().Exporters[httpPost.cfgIdx].HeaderFields()); err != nil {
 		return
 	}
-	for el := eeReq.hdr.GetFirstElement(); el != nil; el = el.Next() {
+	for el := eeReq.OrdNavMP[utils.MetaHdr].GetFirstElement(); el != nil; el = el.Next() {
 		var nmIt utils.NMInterface
-		if nmIt, err = eeReq.hdr.Field(el.Value); err != nil {
+		if nmIt, err = eeReq.OrdNavMP[utils.MetaHdr].Field(el.Value); err != nil {
 			return
 		}
 		itm, isNMItem := nmIt.(*config.NMItem)

ees/posterjsonmap.go

@@ -98,18 +98,21 @@ func (pstrEE *PosterJSONMapEE) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 	if len(pstrEE.cgrCfg.EEsCfg().Exporters[pstrEE.cfgIdx].ContentFields()) == 0 {
 		valMp = cgrEv.Event
 	} else {
-		eeReq := NewEventExporterRequest(utils.MapStorage(cgrEv.Event), pstrEE.dc, cgrEv.Opts,
+		oNm := map[string]*utils.OrderedNavigableMap{
+			utils.MetaExp: utils.NewOrderedNavigableMap(),
+		}
+		eeReq := engine.NewEventRequest(utils.MapStorage(cgrEv.Event), pstrEE.dc, cgrEv.Opts,
 			pstrEE.cgrCfg.EEsCfg().Exporters[pstrEE.cfgIdx].Tenant,
 			pstrEE.cgrCfg.GeneralCfg().DefaultTenant,
 			utils.FirstNonEmpty(pstrEE.cgrCfg.EEsCfg().Exporters[pstrEE.cfgIdx].Timezone,
-				pstrEE.cgrCfg.GeneralCfg().DefaultTimezone), pstrEE.filterS)
+				pstrEE.cgrCfg.GeneralCfg().DefaultTimezone), pstrEE.filterS, oNm)
 
 		if err = eeReq.SetFields(pstrEE.cgrCfg.EEsCfg().Exporters[pstrEE.cfgIdx].ContentFields()); err != nil {
 			return
 		}
-		for el := eeReq.cnt.GetFirstElement(); el != nil; el = el.Next() {
+		for el := eeReq.OrdNavMP[utils.MetaExp].GetFirstElement(); el != nil; el = el.Next() {
 			var nmIt utils.NMInterface
-			if nmIt, err = eeReq.cnt.Field(el.Value); err != nil {
+			if nmIt, err = eeReq.OrdNavMP[utils.MetaExp].Field(el.Value); err != nil {
 				return
 			}
 			itm, isNMItem := nmIt.(*config.NMItem)

ees/sql.go

@@ -150,20 +150,23 @@ func (sqlEe *SQLEe) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 
 	var vals []interface{}
 	var colNames []string
+	oNm := map[string]*utils.OrderedNavigableMap{
+		utils.MetaExp: utils.NewOrderedNavigableMap(),
+	}
 	req := utils.MapStorage(cgrEv.Event)
-	eeReq := NewEventExporterRequest(req, sqlEe.dc, cgrEv.Opts,
+	eeReq := engine.NewEventRequest(req, sqlEe.dc, cgrEv.Opts,
 		sqlEe.cgrCfg.EEsCfg().Exporters[sqlEe.cfgIdx].Tenant,
 		sqlEe.cgrCfg.GeneralCfg().DefaultTenant,
 		utils.FirstNonEmpty(sqlEe.cgrCfg.EEsCfg().Exporters[sqlEe.cfgIdx].Timezone,
 			sqlEe.cgrCfg.GeneralCfg().DefaultTimezone),
-		sqlEe.filterS)
+		sqlEe.filterS, oNm)
 	if err = eeReq.SetFields(sqlEe.cgrCfg.EEsCfg().Exporters[sqlEe.cfgIdx].ContentFields()); err != nil {
 		return
 	}
 
-	for el := eeReq.cnt.GetFirstElement(); el != nil; el = el.Next() {
+	for el := eeReq.OrdNavMP[utils.MetaExp].GetFirstElement(); el != nil; el = el.Next() {
 		var iface interface{}
-		if iface, err = eeReq.cnt.FieldAsInterface(el.Value.Slice()); err != nil {
+		if iface, err = eeReq.OrdNavMP[utils.MetaExp].FieldAsInterface(el.Value.Slice()); err != nil {
 			return
 		}
 		pathWithoutIndex := utils.GetPathWithoutIndex(el.Value.String())

ees/virtualee.go

@@ -73,12 +73,15 @@ func (vEe *VirtualEe) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 	vEe.dc[utils.NumberOfEvents] = vEe.dc[utils.NumberOfEvents].(int64) + 1
 
 	req := utils.MapStorage(cgrEv.Event)
-	eeReq := NewEventExporterRequest(req, vEe.dc, cgrEv.Opts,
+	oNm := map[string]*utils.OrderedNavigableMap{
+		utils.MetaExp: utils.NewOrderedNavigableMap(),
+	}
+	eeReq := engine.NewEventRequest(req, vEe.dc, cgrEv.Opts,
 		vEe.cgrCfg.EEsCfg().Exporters[vEe.cfgIdx].Tenant,
 		vEe.cgrCfg.GeneralCfg().DefaultTenant,
 		utils.FirstNonEmpty(vEe.cgrCfg.EEsCfg().Exporters[vEe.cfgIdx].Timezone,
 			vEe.cgrCfg.GeneralCfg().DefaultTimezone),
-		vEe.filterS)
+		vEe.filterS, oNm)
 	if err = eeReq.SetFields(vEe.cgrCfg.EEsCfg().Exporters[vEe.cfgIdx].ContentFields()); err != nil {
 		return
 	}