replaced CGREvent parameter to DataProvider for GetOpts functions

engine/attributes.go

@@ -153,7 +153,7 @@ func (attrReply *AttrSProcessEventReply) Digest() (rplyDigest string) {
 func (alS *AttributeS) processEvent(ctx *context.Context, tnt string, args *utils.CGREvent, evNm utils.MapStorage, dynDP utils.DataProvider,
 	lastID string, processedPrfNo map[string]int, profileRuns int) (rply *AttrSProcessEventReply, err error) {
 	var attrIDs []string
-	if attrIDs, err = GetStringSliceOpts(ctx, args.Tenant, args, alS.fltrS, alS.cfg.AttributeSCfg().Opts.ProfileIDs,
+	if attrIDs, err = GetStringSliceOpts(ctx, args.Tenant, args.AsDataProvider(), alS.fltrS, alS.cfg.AttributeSCfg().Opts.ProfileIDs,
 		config.AttributesProfileIDsDftOpt, utils.OptsAttributesProfileIDs); err != nil {
 		return
 	}
@@ -247,11 +247,6 @@ func (alS *AttributeS) V1GetAttributeForEvent(ctx *context.Context, args *utils.
 	if tnt == utils.EmptyString {
 		tnt = alS.cfg.GeneralCfg().DefaultTenant
 	}
-	var attrIDs []string
-	if attrIDs, err = GetStringSliceOpts(ctx, args.Tenant, args, alS.fltrS, alS.cfg.AttributeSCfg().Opts.ProfileIDs,
-		config.AttributesProfileIDsDftOpt, utils.OptsAttributesProfileIDs); err != nil {
-		return
-	}
 	evNM := utils.MapStorage{
 		utils.MetaReq:  args.Event,
 		utils.MetaOpts: args.APIOpts,
@@ -259,6 +254,11 @@ func (alS *AttributeS) V1GetAttributeForEvent(ctx *context.Context, args *utils.
 			utils.OptsAttributesProcessRuns: 0,
 		},
 	}
+	var attrIDs []string
+	if attrIDs, err = GetStringSliceOpts(ctx, args.Tenant, evNM, alS.fltrS, alS.cfg.AttributeSCfg().Opts.ProfileIDs,
+		config.AttributesProfileIDsDftOpt, utils.OptsAttributesProfileIDs); err != nil {
+		return
+	}
 	var ignFilters bool
 	if ignFilters, err = GetBoolOpts(ctx, tnt, evNM, alS.fltrS, alS.cfg.AttributeSCfg().Opts.ProfileIgnoreFilters,
 		utils.MetaProfileIgnoreFilters); err != nil {
@@ -285,13 +285,13 @@ func (alS *AttributeS) V1ProcessEvent(ctx *context.Context, args *utils.CGREvent
 	}
 
 	var processRuns int
-	if processRuns, err = GetIntOpts(ctx, tnt, args, alS.fltrS, alS.cfg.AttributeSCfg().Opts.ProcessRuns,
+	if processRuns, err = GetIntOpts(ctx, tnt, args.AsDataProvider(), alS.fltrS, alS.cfg.AttributeSCfg().Opts.ProcessRuns,
 		utils.OptsAttributesProcessRuns); err != nil {
 		return
 	}
 
 	var profileRuns int
-	if profileRuns, err = GetIntOpts(ctx, tnt, args, alS.fltrS, alS.cfg.AttributeSCfg().Opts.ProfileRuns,
+	if profileRuns, err = GetIntOpts(ctx, tnt, args.AsDataProvider(), alS.fltrS, alS.cfg.AttributeSCfg().Opts.ProfileRuns,
 		utils.OptsAttributesProfileRuns); err != nil {
 		return
 	}

engine/libdynopts.go

@@ -31,22 +31,29 @@ import (
 
 // GetFloat64Opts checks the specified option names in order among the keys in APIOpts returning the first value it finds as float64, otherwise it
 // returns the config option if at least one filter passes or the default value if none of them do
-func GetFloat64Opts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*config.DynamicFloat64Opt,
+func GetFloat64Opts(ctx *context.Context, tnt string, dP utils.DataProvider, fS *FilterS, dynOpts []*config.DynamicFloat64Opt,
 	optNames ...string) (cfgOpt float64, err error) {
+	values, err := dP.FieldAsInterface([]string{utils.MetaOpts})
+	if err != nil {
+		return 0, err
+	}
+	opts, err := ConvertOptsToMapStringAny(values)
+	if err != nil {
+		return
+	}
 	for _, optName := range optNames {
-		if opt, has := ev.APIOpts[optName]; has {
+		if opt, has := opts[optName]; has {
 			return utils.IfaceAsFloat64(opt)
 		}
 	}
-	evDP := ev.AsDataProvider()
 	for _, opt := range dynOpts { // iterate through the options
 		if !slices.Contains([]string{utils.EmptyString, utils.MetaAny, tnt}, opt.Tenant) {
 			continue
 		}
-		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, evDP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
+		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, dP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
 			return 0, err
 		} else if pass {
-			return opt.Value(evDP)
+			return opt.Value(dP)
 		}
 	}
 	return
@@ -54,22 +61,29 @@ func GetFloat64Opts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *Fi
 
 // GetDurationOpts checks the specified option names in order among the keys in APIOpts returning the first value it finds as time.Duration, otherwise it
 // returns the config option if at least one filter passes or the default value if none of them do
-func GetDurationOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*config.DynamicDurationOpt,
+func GetDurationOpts(ctx *context.Context, tnt string, dP utils.DataProvider, fS *FilterS, dynOpts []*config.DynamicDurationOpt,
 	optNames ...string) (cfgOpt time.Duration, err error) {
+	values, err := dP.FieldAsInterface([]string{utils.MetaOpts})
+	if err != nil {
+		return 0, err
+	}
+	opts, err := ConvertOptsToMapStringAny(values)
+	if err != nil {
+		return
+	}
 	for _, optName := range optNames {
-		if opt, has := ev.APIOpts[optName]; has {
+		if opt, has := opts[optName]; has {
 			return utils.IfaceAsDuration(opt)
 		}
 	}
-	evDP := ev.AsDataProvider()
 	for _, opt := range dynOpts { // iterate through the options
 		if !slices.Contains([]string{utils.EmptyString, utils.MetaAny, tnt}, opt.Tenant) {
 			continue
 		}
-		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, evDP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
+		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, dP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
 			return 0, err
 		} else if pass {
-			return opt.Value(evDP)
+			return opt.Value(dP)
 		}
 	}
 	return
@@ -77,22 +91,29 @@ func GetDurationOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *F
 
 // GetStringOpts checks the specified option names in order among the keys in APIOpts returning the first value it finds as string, otherwise it
 // returns the config option if at least one filter passes or the default value if none of them do
-func GetStringOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*config.DynamicStringOpt,
+func GetStringOpts(ctx *context.Context, tnt string, dP utils.DataProvider, fS *FilterS, dynOpts []*config.DynamicStringOpt,
 	optNames ...string) (cfgOpt string, err error) {
+	values, err := dP.FieldAsInterface([]string{utils.MetaOpts})
+	if err != nil {
+		return "", err
+	}
+	opts, err := ConvertOptsToMapStringAny(values)
+	if err != nil {
+		return
+	}
 	for _, optName := range optNames {
-		if opt, has := ev.APIOpts[optName]; has {
+		if opt, has := opts[optName]; has {
 			return utils.IfaceAsString(opt), nil
 		}
 	}
-	evDP := ev.AsDataProvider()
 	for _, opt := range dynOpts { // iterate through the options
 		if !slices.Contains([]string{utils.EmptyString, utils.MetaAny, tnt}, opt.Tenant) {
 			continue
 		}
-		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, evDP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
+		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, dP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
 			return utils.EmptyString, err
 		} else if pass {
-			return opt.Value(evDP)
+			return opt.Value(dP)
 		}
 	}
 	return
@@ -100,24 +121,31 @@ func GetStringOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *Fil
 
 // GetTimeOpts checks the specified option names in order among the keys in APIOpts returning the first value it finds as time.Time, otherwise it
 // returns the config option if at least one filter passes or the default value if none of them do
-func GetTimeOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*config.DynamicStringOpt,
+func GetTimeOpts(ctx *context.Context, tnt string, dP utils.DataProvider, fS *FilterS, dynOpts []*config.DynamicStringOpt,
 	tmz string, optNames ...string) (_ time.Time, err error) {
+	values, err := dP.FieldAsInterface([]string{utils.MetaOpts})
+	if err != nil {
+		return
+	}
+	opts, err := ConvertOptsToMapStringAny(values)
+	if err != nil {
+		return
+	}
 	for _, optName := range optNames {
-		if opt, has := ev.APIOpts[optName]; has {
+		if opt, has := opts[optName]; has {
 			return utils.IfaceAsTime(opt, tmz)
 		}
 	}
-	evDP := ev.AsDataProvider()
 	for _, opt := range dynOpts { // iterate through the options
 		if !slices.Contains([]string{utils.EmptyString, utils.MetaAny, tnt}, opt.Tenant) {
 			continue
 		}
 		var pass bool
-		if pass, err = fS.Pass(ctx, tnt, opt.FilterIDs, evDP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
+		if pass, err = fS.Pass(ctx, tnt, opt.FilterIDs, dP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
 			return
 		} else if pass {
 			var dur string
-			dur, err = opt.Value(evDP)
+			dur, err = opt.Value(dP)
 			if err != nil {
 				return
 			}
@@ -129,19 +157,26 @@ func GetTimeOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *Filte
 
 // GetStringSliceOpts checks the specified option names in order among the keys in APIOpts returning the first value it finds as []string, otherwise it
 // returns the config option if at least one filter passes or the default value if none of them do
-func GetStringSliceOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*config.DynamicStringSliceOpt,
+func GetStringSliceOpts(ctx *context.Context, tnt string, dP utils.DataProvider, fS *FilterS, dynOpts []*config.DynamicStringSliceOpt,
 	dftOpt []string, optNames ...string) (cfgOpt []string, err error) {
+	values, err := dP.FieldAsInterface([]string{utils.MetaOpts})
+	if err != nil {
+		return nil, err
+	}
+	opts, err := ConvertOptsToMapStringAny(values)
+	if err != nil {
+		return
+	}
 	for _, optName := range optNames {
-		if opt, has := ev.APIOpts[optName]; has {
+		if opt, has := opts[optName]; has {
 			return utils.IfaceAsStringSlice(opt)
 		}
 	}
-	evDP := ev.AsDataProvider()
 	for _, opt := range dynOpts { // iterate through the options
 		if !slices.Contains([]string{utils.EmptyString, utils.MetaAny, tnt}, opt.Tenant) {
 			continue
 		}
-		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, evDP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
+		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, dP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
 			return nil, err
 		} else if pass {
 			return opt.Values, nil
@@ -152,26 +187,29 @@ func GetStringSliceOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS
 
 // GetIntOpts checks the specified option names in order among the keys in APIOpts returning the first value it finds as int, otherwise it
 // returns the config option if at least one filter passes or the default value if none of them do
-func GetIntOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*config.DynamicIntOpt,
+func GetIntOpts(ctx *context.Context, tnt string, dP utils.DataProvider, fS *FilterS, dynOpts []*config.DynamicIntOpt,
 	optNames ...string) (cfgOpt int, err error) {
+	values, err := dP.FieldAsInterface([]string{utils.MetaOpts})
+	if err != nil {
+		return 0, err
+	}
+	opts, err := ConvertOptsToMapStringAny(values)
+	if err != nil {
+		return
+	}
 	for _, optName := range optNames {
-		if opt, has := ev.APIOpts[optName]; has {
-			var value int64
-			if value, err = utils.IfaceAsTInt64(opt); err != nil {
-				return 0, err
-			}
-			return int(value), nil
+		if opt, has := opts[optName]; has {
+			return utils.IfaceAsInt(opt)
 		}
 	}
-	evDP := ev.AsDataProvider()
 	for _, opt := range dynOpts { // iterate through the options
 		if !slices.Contains([]string{utils.EmptyString, utils.MetaAny, tnt}, opt.Tenant) {
 			continue
 		}
-		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, evDP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
+		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, dP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
 			return 0, err
 		} else if pass {
-			return opt.Value(evDP)
+			return opt.Value(dP)
 		}
 	}
 	return
@@ -209,22 +247,29 @@ func GetBoolOpts(ctx *context.Context, tnt string, dP utils.DataProvider, fS *Fi
 
 // GetDecimalBigOpts checks the specified option names in order among the keys in APIOpts returning the first value it finds as *decimal.Big, otherwise it
 // returns the config option if at least one filter passes or the default value if none of them do
-func GetDecimalBigOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*config.DynamicDecimalOpt,
+func GetDecimalBigOpts(ctx *context.Context, tnt string, dP utils.DataProvider, fS *FilterS, dynOpts []*config.DynamicDecimalOpt,
 	optNames ...string) (cfgOpt *decimal.Big, err error) {
+	values, err := dP.FieldAsInterface([]string{utils.MetaOpts})
+	if err != nil {
+		return nil, err
+	}
+	opts, err := ConvertOptsToMapStringAny(values)
+	if err != nil {
+		return
+	}
 	for _, optName := range optNames {
-		if opt, has := ev.APIOpts[optName]; has {
+		if opt, has := opts[optName]; has {
 			return utils.IfaceAsBig(opt)
 		}
 	}
-	evDP := ev.AsDataProvider()
 	for _, opt := range dynOpts { // iterate through the options
 		if !slices.Contains([]string{utils.EmptyString, utils.MetaAny, tnt}, opt.Tenant) {
 			continue
 		}
-		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, evDP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
+		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, dP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
 			return nil, err
 		} else if pass {
-			return opt.Value(evDP)
+			return opt.Value(dP)
 		}
 	}
 	return
@@ -232,19 +277,26 @@ func GetDecimalBigOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS
 
 // GetInterfaceOpts checks the specified option names in order among the keys in APIOpts returning the first value it finds as any, otherwise it
 // returns the config option if at least one filter passes or the default value if none of them do
-func GetInterfaceOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*config.DynamicInterfaceOpt,
+func GetInterfaceOpts(ctx *context.Context, tnt string, dP utils.DataProvider, fS *FilterS, dynOpts []*config.DynamicInterfaceOpt,
 	optNames ...string) (cfgOpt any, err error) {
+	values, err := dP.FieldAsInterface([]string{utils.MetaOpts})
+	if err != nil {
+		return nil, err
+	}
+	opts, err := ConvertOptsToMapStringAny(values)
+	if err != nil {
+		return
+	}
 	for _, optName := range optNames {
-		if opt, has := ev.APIOpts[optName]; has {
+		if opt, has := opts[optName]; has {
 			return opt, nil
 		}
 	}
-	evDP := ev.AsDataProvider()
 	for _, opt := range dynOpts { // iterate through the options
 		if !slices.Contains([]string{utils.EmptyString, utils.MetaAny, tnt}, opt.Tenant) {
 			continue
 		}
-		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, evDP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
+		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, dP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
 			return false, err
 		} else if pass {
 			return opt.Value, nil
@@ -255,10 +307,18 @@ func GetInterfaceOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *
 
 // GetIntPointerOpts checks the specified option names in order among the keys in APIOpts returning the first value it finds as *int, otherwise it
 // returns the config option if at least one filter passes or NOT_FOUND if none of them do
-func GetIntPointerOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*config.DynamicIntPointerOpt,
+func GetIntPointerOpts(ctx *context.Context, tnt string, dP utils.DataProvider, fS *FilterS, dynOpts []*config.DynamicIntPointerOpt,
 	optNames ...string) (cfgOpt *int, err error) {
+	values, err := dP.FieldAsInterface([]string{utils.MetaOpts})
+	if err != nil {
+		return nil, err
+	}
+	opts, err := ConvertOptsToMapStringAny(values)
+	if err != nil {
+		return
+	}
 	for _, optName := range optNames {
-		if opt, has := ev.APIOpts[optName]; has {
+		if opt, has := opts[optName]; has {
 			var value int64
 			if value, err = utils.IfaceAsTInt64(opt); err != nil {
 				return nil, err
@@ -266,15 +326,14 @@ func GetIntPointerOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS
 			return utils.IntPointer(int(value)), nil
 		}
 	}
-	evDP := ev.AsDataProvider()
 	for _, opt := range dynOpts { // iterate through the options
 		if !slices.Contains([]string{utils.EmptyString, utils.MetaAny, tnt}, opt.Tenant) {
 			continue
 		}
-		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, evDP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
+		if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, dP); err != nil { // check if the filter is passing for the DataProvider and return the option if it does
 			return nil, err
 		} else if pass {
-			return opt.Value(evDP)
+			return opt.Value(dP)
 		}
 	}
 	return nil, nil

engine/libdynopts_test.go

@@ -52,7 +52,7 @@ func TestLibFiltersGetFloat64OptsReturnConfigOpt(t *testing.T) {
 	}
 
 	expected := 5.
-	if rcv, err := GetFloat64Opts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetFloat64Opts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsResourcesUnits); err != nil {
 		t.Error(err)
 	} else if rcv != expected {
@@ -80,7 +80,7 @@ func TestLibFiltersGetFloat64OptsFilterCheckErr(t *testing.T) {
 	}
 
 	experr := `inline parse error for string: <*string.invalid:filter>`
-	if _, err := GetFloat64Opts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if _, err := GetFloat64Opts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsResourcesUnits); err == nil ||
 		err.Error() != experr {
 		t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
@@ -106,7 +106,7 @@ func TestLibFiltersGetFloat64OptsReturnDefaultOpt(t *testing.T) {
 		config.NewDynamicFloat64Opt(nil, utils.EmptyString, config.ResourcesUnitsDftOpt, nil),
 	}
 
-	if rcv, err := GetFloat64Opts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetFloat64Opts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsResourcesUnits); err != nil {
 		t.Error(err)
 	} else if rcv != config.ResourcesUnitsDftOpt {
@@ -136,7 +136,7 @@ func TestLibFiltersGetFloat64OptsReturnOptFromAPIOpts(t *testing.T) {
 	}
 
 	expected := 6.
-	if rcv, err := GetFloat64Opts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetFloat64Opts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		"nonExistingAPIOpt", utils.OptsResourcesUnits); err != nil {
 		t.Error(err)
 	} else if rcv != expected {
@@ -167,7 +167,7 @@ func TestLibFiltersGetStringOptsReturnConfigOpt(t *testing.T) {
 	}
 
 	expected := "value3"
-	if rcv, err := GetStringOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetStringOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		config.ResourcesUsageIDDftOpt, utils.OptsResourcesUsageID); err != nil {
 		t.Error(err)
 	} else if rcv != expected {
@@ -194,7 +194,7 @@ func TestLibFiltersGetStringOptsFilterCheckErr(t *testing.T) {
 	}
 
 	experr := `inline parse error for string: <*string.invalid:filter>`
-	if _, err := GetStringOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if _, err := GetStringOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		config.ResourcesUsageIDDftOpt, utils.OptsResourcesUsageID); err == nil ||
 		err.Error() != experr {
 		t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
@@ -219,7 +219,7 @@ func TestLibFiltersGetStringOptsReturnDefaultOpt(t *testing.T) {
 		config.NewDynamicStringOpt([]string{"*string:~*req.Account:1002"}, "cgrates.org", "value2", nil),
 	}
 
-	if rcv, err := GetStringOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetStringOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		config.ResourcesUsageIDDftOpt, utils.OptsResourcesUsageID); err != nil {
 		t.Error(err)
 	} else if rcv != config.ResourcesUsageIDDftOpt {
@@ -249,7 +249,7 @@ func TestLibFiltersGetStringOptsReturnOptFromAPIOpts(t *testing.T) {
 	}
 
 	expected := "value4"
-	if rcv, err := GetStringOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetStringOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		config.ResourcesUsageIDDftOpt, "nonExistingAPIOpt", utils.OptsResourcesUsageID); err != nil {
 		t.Error(err)
 	} else if rcv != expected {
@@ -279,7 +279,7 @@ func TestLibFiltersGetDurationOptsReturnConfigOpt(t *testing.T) {
 	}
 
 	expected := time.Minute
-	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsResourcesUsageTTL); err != nil {
 		t.Error(err)
 	} else if rcv != expected {
@@ -306,7 +306,7 @@ func TestLibFiltersGetDurationOptsFilterCheckErr(t *testing.T) {
 	}
 
 	experr := `inline parse error for string: <*string.invalid:filter>`
-	if _, err := GetDurationOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if _, err := GetDurationOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsResourcesUsageTTL); err == nil ||
 		err.Error() != experr {
 		t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
@@ -332,7 +332,7 @@ func TestLibFiltersGetDurationOptsReturnDefaultOpt(t *testing.T) {
 		config.NewDynamicDurationOpt(nil, "", config.ResourcesUsageTTLDftOpt, nil),
 	}
 
-	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsResourcesUsageTTL); err != nil {
 		t.Error(err)
 	} else if rcv != config.ResourcesUsageTTLDftOpt {
@@ -362,7 +362,7 @@ func TestLibFiltersGetDurationOptsReturnOptFromAPIOpts(t *testing.T) {
 	}
 
 	expected := time.Hour
-	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		"nonExistingAPIOpt", utils.OptsResourcesUsageTTL); err != nil {
 		t.Error(err)
 	} else if rcv != expected {
@@ -392,7 +392,7 @@ func TestLibFiltersGetIntOptsReturnConfigOpt(t *testing.T) {
 	}
 
 	expected := 5
-	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsAttributesProcessRuns); err != nil {
 		t.Error(err)
 	} else if rcv != expected {
@@ -419,7 +419,7 @@ func TestLibFiltersGetIntOptsFilterCheckErr(t *testing.T) {
 	}
 
 	experr := `inline parse error for string: <*string.invalid:filter>`
-	if _, err := GetIntOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if _, err := GetIntOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsAttributesProcessRuns); err == nil ||
 		err.Error() != experr {
 		t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
@@ -445,7 +445,7 @@ func TestLibFiltersGetIntOptsReturnDefaultOpt(t *testing.T) {
 		config.NewDynamicIntOpt(nil, utils.EmptyString, config.AttributesProcessRunsDftOpt, nil),
 	}
 
-	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsAttributesProcessRuns); err != nil {
 		t.Error(err)
 	} else if rcv != config.AttributesProcessRunsDftOpt {
@@ -475,7 +475,7 @@ func TestLibFiltersGetIntOptsReturnOptFromAPIOptsOK(t *testing.T) {
 	}
 
 	expected := 6
-	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		"nonExistingAPIOpt", utils.OptsAttributesProcessRuns); err != nil {
 		t.Error(err)
 	} else if rcv != expected {
@@ -505,7 +505,7 @@ func TestLibFiltersGetIntOptsReturnOptFromAPIOptsErr(t *testing.T) {
 	}
 
 	experr := `cannot convert field<bool>: true to int`
-	if _, err := GetIntOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if _, err := GetIntOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		"nonExistingAPIOpt", utils.OptsAttributesProcessRuns); err == nil || err.Error() != experr {
 		t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
 	}
@@ -533,7 +533,7 @@ func TestLibFiltersGetTimeOptsReturnConfigOpt(t *testing.T) {
 	}
 
 	expected := time.Now().AddDate(0, 1, 0)
-	if rcv, err := GetTimeOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetTimeOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		cfg.GeneralCfg().DefaultTimezone, config.RatesStartTimeDftOpt, utils.OptsRatesStartTime); err != nil {
 		t.Error(err)
 	} else if !dateEqual(rcv, expected) {
@@ -560,7 +560,7 @@ func TestLibFiltersGetTimeOptsFilterCheckErr(t *testing.T) {
 	}
 
 	experr := `inline parse error for string: <*string.invalid:filter>`
-	if _, err := GetTimeOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if _, err := GetTimeOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		cfg.GeneralCfg().DefaultTimezone, config.RatesStartTimeDftOpt, utils.OptsRatesStartTime); err == nil ||
 		err.Error() != experr {
 		t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
@@ -590,7 +590,7 @@ func TestLibFiltersGetTimeOptsReturnDefaultOpt(t *testing.T) {
 		config.NewDynamicStringOpt(nil, "", config.RatesStartTimeDftOpt, nil),
 	}
 
-	if rcv, err := GetTimeOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetTimeOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		cfg.GeneralCfg().DefaultTimezone, config.RatesStartTimeDftOpt, utils.OptsRatesStartTime); err != nil {
 		t.Error(err)
 	} else if !dateEqual(rcv, expected) {
@@ -620,7 +620,7 @@ func TestLibFiltersGetTimeOptsReturnOptFromAPIOpts(t *testing.T) {
 	}
 
 	expected := time.Now().AddDate(1, 0, 0)
-	if rcv, err := GetTimeOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetTimeOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		cfg.GeneralCfg().DefaultTimezone, config.RatesStartTimeDftOpt, "nonExistingAPIOpt", utils.OptsRatesStartTime); err != nil {
 		t.Error(err)
 	} else if !dateEqual(rcv, expected) {
@@ -780,7 +780,7 @@ func TestLibFiltersGetInterfaceOptsReturnConfigOpt(t *testing.T) {
 	}
 
 	expected := "value3"
-	if rcv, err := GetInterfaceOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetInterfaceOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		config.RoutesMaxCostDftOpt, utils.OptsRoutesMaxCost); err != nil {
 		t.Error(err)
 	} else if rcv != expected {
@@ -811,7 +811,7 @@ func TestLibFiltersGetInterfaceOptsFilterCheckErr(t *testing.T) {
 	}
 
 	experr := `inline parse error for string: <*string.invalid:filter>`
-	if _, err := GetInterfaceOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if _, err := GetInterfaceOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		config.RoutesMaxCostDftOpt, utils.OptsRoutesMaxCost); err == nil ||
 		err.Error() != experr {
 		t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
@@ -843,7 +843,7 @@ func TestLibFiltersGetInterfaceOptsReturnDefaultOpt(t *testing.T) {
 		},
 	}
 
-	if rcv, err := GetInterfaceOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetInterfaceOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsRoutesMaxCost); err != nil {
 		t.Error(err)
 	} else if rcv != config.RoutesMaxCostDftOpt {
@@ -877,7 +877,7 @@ func TestLibFiltersGetInterfaceOptsReturnOptFromAPIOpts(t *testing.T) {
 	}
 
 	expected := 4
-	if rcv, err := GetInterfaceOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetInterfaceOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		config.RoutesMaxCostDftOpt, "nonExistingAPIOpt", utils.OptsRoutesMaxCost); err != nil {
 		t.Error(err)
 	} else if rcv != expected {
@@ -919,7 +919,7 @@ func TestLibFiltersGetStringSliceOptsReturnConfigOpt(t *testing.T) {
 	}
 
 	expected := []string{"value3"}
-	if rcv, err := GetStringSliceOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetStringSliceOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		config.AttributesProfileIDsDftOpt, utils.OptsAttributesProfileIDs); err != nil {
 		t.Error(err)
 	} else if !reflect.DeepEqual(rcv, expected) {
@@ -950,7 +950,7 @@ func TestLibFiltersGetStringSliceOptsFilterCheckErr(t *testing.T) {
 	}
 
 	experr := `inline parse error for string: <*string.invalid:filter>`
-	if _, err := GetStringSliceOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if _, err := GetStringSliceOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		config.AttributesProfileIDsDftOpt, utils.OptsAttributesProfileIDs); err == nil ||
 		err.Error() != experr {
 		t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
@@ -979,7 +979,7 @@ func TestLibFiltersGetStringSliceOptsReturnDefaultOpt(t *testing.T) {
 		},
 	}
 
-	if rcv, err := GetStringSliceOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetStringSliceOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		config.AttributesProfileIDsDftOpt, utils.OptsAttributesProfileIDs); err != nil {
 		t.Error(err)
 	} else if !reflect.DeepEqual(rcv, config.AttributesProfileIDsDftOpt) {
@@ -1013,7 +1013,7 @@ func TestLibFiltersGetStringSliceOptsReturnOptFromAPIOpts(t *testing.T) {
 	}
 
 	expected := []string{"value4"}
-	if rcv, err := GetStringSliceOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetStringSliceOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		config.AttributesProfileIDsDftOpt, "nonExistingAPIOpt", utils.OptsAttributesProfileIDs); err != nil {
 		t.Error(err)
 	} else if !reflect.DeepEqual(rcv, expected) {
@@ -1055,7 +1055,7 @@ func TestLibFiltersGetDecimalBigOptsReturnConfigOpt(t *testing.T) {
 	dynOpts, _ := config.IfaceToDecimalBigDynamicOpts(strOpts)
 
 	expected := decimal.New(1234, 0)
-	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsRatesUsage); err != nil {
 		t.Error(err)
 	} else if rcv.Cmp(expected) != 0 {
@@ -1143,7 +1143,7 @@ func TestDynamicDecimalBigOptsDynVal(t *testing.T) {
 				t.Error(err)
 				return
 			}
-			out, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev, fs, dynOpts, utils.OptsRatesUsage)
+			out, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fs, dynOpts, utils.OptsRatesUsage)
 			if tt.expErr != nil {
 				if err == nil {
 					t.Error("expected err,received nil")
@@ -1243,7 +1243,7 @@ func TestDynamicIntOptsDynVal(t *testing.T) {
 				t.Error(err)
 				return
 			}
-			out, err := GetIntOpts(context.Background(), "cgrates.org", ev, fs, dynOpts, utils.OptsRatesUsage)
+			out, err := GetIntOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fs, dynOpts, utils.OptsRatesUsage)
 			if tt.expErr != nil {
 				if err == nil {
 					t.Error("expected err,received nil")
@@ -1343,7 +1343,7 @@ func TestDynamicFloat64OptsDynVal(t *testing.T) {
 				t.Error(err)
 				return
 			}
-			out, err := GetFloat64Opts(context.Background(), "cgrates.org", ev, fs, dynOpts, utils.OptsRatesUsage)
+			out, err := GetFloat64Opts(context.Background(), "cgrates.org", ev.AsDataProvider(), fs, dynOpts, utils.OptsRatesUsage)
 			if tt.expErr != nil {
 				if err == nil {
 					t.Error("expected err,received nil")
@@ -1543,7 +1543,7 @@ func TestDynamicDurationOptsDynVal(t *testing.T) {
 				t.Error(err)
 				return
 			}
-			out, err := GetDurationOpts(context.Background(), "cgrates.org", ev, fs, dynOpts, utils.OptsRatesUsage)
+			out, err := GetDurationOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fs, dynOpts, utils.OptsRatesUsage)
 			if tt.expErr != nil {
 				if err == nil {
 					t.Error("expected err,received nil")
@@ -1622,7 +1622,7 @@ func TestDynamicStringOptsDynVal(t *testing.T) {
 				t.Error(err)
 				return
 			}
-			out, err := GetStringOpts(context.Background(), "cgrates.org", ev, fs, dynOpts)
+			out, err := GetStringOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fs, dynOpts)
 			if tt.expErr != nil {
 				if err == nil {
 					t.Error("expected err,received nil")
@@ -1717,28 +1717,28 @@ func TestAttrDynamicOptsFromJson(t *testing.T) {
 		APIOpts: map[string]any{},
 	}
 	fltrs := NewFilterS(cgrCfg, nil, nil)
-	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev, fltrs, cgrCfg.AttributeSCfg().Opts.ProcessRuns); err != nil {
+	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fltrs, cgrCfg.AttributeSCfg().Opts.ProcessRuns); err != nil {
 		t.Error(err)
 	} else if rcv != 4 {
 		t.Errorf("expected %d,received %d", 4, rcv)
 	}
-	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev3, fltrs, cgrCfg.AttributeSCfg().Opts.ProcessRuns); err != nil {
+	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev3.AsDataProvider(), fltrs, cgrCfg.AttributeSCfg().Opts.ProcessRuns); err != nil {
 		t.Error(err)
 	} else if rcv != 11 {
 		t.Errorf("expected %d,received %d", 11, rcv)
 	}
-	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev2, fltrs, cgrCfg.AttributeSCfg().Opts.ProcessRuns); err != nil {
+	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev2.AsDataProvider(), fltrs, cgrCfg.AttributeSCfg().Opts.ProcessRuns); err != nil {
 		t.Error(err)
 	} else if rcv != config.AttributesProcessRunsDftOpt {
 		t.Errorf("expected %d,received %d", config.AttributesProcessRunsDftOpt, rcv)
 	}
 
-	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev, fltrs, cgrCfg.AttributeSCfg().Opts.ProfileRuns); err != nil {
+	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fltrs, cgrCfg.AttributeSCfg().Opts.ProfileRuns); err != nil {
 		t.Error(err)
 	} else if rcv != 5 {
 		t.Errorf("expected %d,received %d", 5, rcv)
 	}
-	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev2, fltrs, cgrCfg.AttributeSCfg().Opts.ProfileRuns); err != nil {
+	if rcv, err := GetIntOpts(context.Background(), "cgrates.org", ev2.AsDataProvider(), fltrs, cgrCfg.AttributeSCfg().Opts.ProfileRuns); err != nil {
 		t.Error(err)
 	} else if rcv != config.AttributesProfileRunsDftOpt {
 		t.Errorf("expected %d,received %d", config.AttributesProcessRunsDftOpt, rcv)
@@ -1848,23 +1848,23 @@ func TestSessionDynamicOptsFromJson(t *testing.T) {
 		t.Errorf("expected %v,received %v", config.SessionsAttributesDftOpt, rcv)
 	}
 
-	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev, fltrs, cgrCfg.SessionSCfg().Opts.TTL); err != nil {
+	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fltrs, cgrCfg.SessionSCfg().Opts.TTL); err != nil {
 		t.Error(err)
 	} else if rcv != time.Second {
 		t.Errorf("expected %v,received %v", time.Second, rcv)
 	}
-	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev2, fltrs, cgrCfg.SessionSCfg().Opts.TTL); err != nil {
+	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev2.AsDataProvider(), fltrs, cgrCfg.SessionSCfg().Opts.TTL); err != nil {
 		t.Error(err)
 	} else if rcv != config.SessionsTTLDftOpt {
 		t.Errorf("expected %v,received %v", config.SessionsTTLDftOpt, rcv)
 	}
 
-	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev, fltrs, cgrCfg.SessionSCfg().Opts.DebitInterval); err != nil {
+	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fltrs, cgrCfg.SessionSCfg().Opts.DebitInterval); err != nil {
 		t.Error(err)
 	} else if rcv != (8 * time.Second) {
 		t.Errorf("expected %v,received %v", 8*time.Second, rcv)
 	}
-	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev2, fltrs, cgrCfg.SessionSCfg().Opts.DebitInterval); err != nil {
+	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev2.AsDataProvider(), fltrs, cgrCfg.SessionSCfg().Opts.DebitInterval); err != nil {
 		t.Error(err)
 	} else if rcv != config.SessionsDebitIntervalDftOpt {
 		t.Errorf("expected %v,received %v", config.SessionsDebitIntervalDftOpt, rcv)
@@ -1931,34 +1931,34 @@ func TestResDynamicOptsFromJson(t *testing.T) {
 		},
 	}
 	fltrs := NewFilterS(cgrCfg, nil, nil)
-	if rcv, err := GetStringOpts(context.Background(), "cgrates.org", ev, fltrs, cgrCfg.ResourceSCfg().Opts.UsageID); err != nil {
+	if rcv, err := GetStringOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fltrs, cgrCfg.ResourceSCfg().Opts.UsageID); err != nil {
 		t.Error(err)
 	} else if rcv != "UsgID3232" {
 		t.Errorf("expected %s,received %s", "UsgID3232", rcv)
 	}
-	if rcv, err := GetStringOpts(context.Background(), "cgrates.org", ev2, fltrs, cgrCfg.ResourceSCfg().Opts.UsageID); err != nil {
+	if rcv, err := GetStringOpts(context.Background(), "cgrates.org", ev2.AsDataProvider(), fltrs, cgrCfg.ResourceSCfg().Opts.UsageID); err != nil {
 		t.Error(err)
 	} else if rcv != config.ResourcesUsageIDDftOpt {
 		t.Errorf("expected %s,received %s", config.ResourcesUsageTTLDftOpt, rcv)
 	}
 
-	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev, fltrs, cgrCfg.ResourceSCfg().Opts.UsageTTL); err != nil {
+	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fltrs, cgrCfg.ResourceSCfg().Opts.UsageTTL); err != nil {
 		t.Error(err)
 	} else if rcv != 3*time.Second {
 		t.Errorf("expected %v,received %d", 3*time.Second, rcv)
 	}
-	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev2, fltrs, cgrCfg.ResourceSCfg().Opts.UsageTTL); err != nil {
+	if rcv, err := GetDurationOpts(context.Background(), "cgrates.org", ev2.AsDataProvider(), fltrs, cgrCfg.ResourceSCfg().Opts.UsageTTL); err != nil {
 		t.Error(err)
 	} else if rcv != config.ResourcesUsageTTLDftOpt {
 		t.Errorf("expected %d,received %d", config.ResourcesUsageTTLDftOpt, rcv)
 	}
 
-	if rcv, err := GetFloat64Opts(context.Background(), "cgrates.org", ev, fltrs, cgrCfg.ResourceSCfg().Opts.Units); err != nil {
+	if rcv, err := GetFloat64Opts(context.Background(), "cgrates.org", ev.AsDataProvider(), fltrs, cgrCfg.ResourceSCfg().Opts.Units); err != nil {
 		t.Error(err)
 	} else if rcv != 23.22 {
 		t.Errorf("expected %f,received %f", 23.22, rcv)
 	}
-	if rcv, err := GetFloat64Opts(context.Background(), "cgrates.org", ev2, fltrs, cgrCfg.ResourceSCfg().Opts.Units); err != nil {
+	if rcv, err := GetFloat64Opts(context.Background(), "cgrates.org", ev2.AsDataProvider(), fltrs, cgrCfg.ResourceSCfg().Opts.Units); err != nil {
 		t.Error(err)
 	} else if rcv != config.ResourcesUnitsDftOpt {
 		t.Errorf("expected %v,received %v", config.ResourcesUnitsDftOpt, rcv)
@@ -2012,34 +2012,34 @@ func TestRoutesDynamicOptsFromJson(t *testing.T) {
 	dec.SetFloat64(43364.4)
 
 	fltrs := NewFilterS(cgrCfg, nil, nil)
-	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev, fltrs, cgrCfg.RouteSCfg().Opts.Usage); err != nil {
+	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fltrs, cgrCfg.RouteSCfg().Opts.Usage); err != nil {
 		t.Error(err)
 	} else if rcv.Cmp(&dec) != 0 {
 		t.Errorf("expected %v,received %v", dec.String(), rcv.String())
 	}
 	ev.Event[utils.AccountField] = 1002
 	dec.SetUint64(15555)
-	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev, fltrs, cgrCfg.RouteSCfg().Opts.Usage); err != nil {
+	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fltrs, cgrCfg.RouteSCfg().Opts.Usage); err != nil {
 		t.Error(err)
 	} else if rcv.Cmp(&dec) != 0 {
 		t.Errorf("expected %v,received %v", dec.String(), rcv.String())
 	}
 	ev.Event[utils.AccountField] = 1003
 	dec = *decimal.New(int64(5*time.Minute), 0)
-	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev, fltrs, cgrCfg.RouteSCfg().Opts.Usage); err != nil {
+	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fltrs, cgrCfg.RouteSCfg().Opts.Usage); err != nil {
 		t.Error(err)
 	} else if rcv.Cmp(&dec) != 0 {
 		t.Errorf("expected %v,received %v", dec.String(), rcv.String())
 	}
 	ev.Event[utils.AccountField] = 1004
 	dec = *decimal.New(int64(12*time.Minute), 0)
-	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev, fltrs, cgrCfg.RouteSCfg().Opts.Usage); err != nil {
+	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fltrs, cgrCfg.RouteSCfg().Opts.Usage); err != nil {
 		t.Error(err)
 	} else if rcv.Cmp(&dec) != 0 {
 		t.Errorf("expected %v,received %v", dec.String(), rcv.String())
 	}
 	ev.Event[utils.AccountField] = 1005
-	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev, fltrs, cgrCfg.RouteSCfg().Opts.Usage); err != nil {
+	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fltrs, cgrCfg.RouteSCfg().Opts.Usage); err != nil {
 		t.Error(err)
 	} else if rcv.Cmp(config.RatesUsageDftOpt) != 0 {
 		t.Errorf("expected %v,received %v", config.RatesUsageDftOpt.String(), rcv.String())
@@ -2069,7 +2069,7 @@ func TestLibFiltersGetDecimalBigOptsFilterCheckErr(t *testing.T) {
 	}
 	dynOpts, _ := config.IfaceToDecimalBigDynamicOpts(strOpts)
 	experr := `inline parse error for string: <*string.invalid:filter>`
-	if _, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if _, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsRatesUsage); err == nil ||
 		err.Error() != experr {
 		t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
@@ -2101,7 +2101,7 @@ func TestLibFiltersGetDecimalBigOptsReturnDefaultOpt(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsRatesUsage); err != nil {
 		t.Error(err)
 	} else if rcv.Cmp(config.RatesUsageDftOpt) != 0 {
@@ -2137,7 +2137,7 @@ func TestLibFiltersGetDecimalBigOptsReturnOptFromAPIOpts(t *testing.T) {
 	dynOpts, _ := config.IfaceToDecimalBigDynamicOpts(strOpts)
 
 	expected := decimal.New(4321, 5)
-	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetDecimalBigOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		"nonExistingAPIOpt", utils.OptsRatesUsage); err != nil {
 		t.Error(err)
 	} else if rcv.Cmp(expected) != 0 {
@@ -2167,7 +2167,7 @@ func TestLibFiltersGetIntPointerOptsReturnConfigOpt(t *testing.T) {
 	}
 
 	expected := 5
-	if rcv, err := GetIntPointerOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetIntPointerOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsRoutesProfilesCount); err != nil {
 		t.Error(err)
 	} else if *rcv != expected {
@@ -2194,7 +2194,7 @@ func TestLibFiltersGetIntPointerOptsFilterCheckErr(t *testing.T) {
 	}
 
 	experr := `inline parse error for string: <*string.invalid:filter>`
-	if _, err := GetIntPointerOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if _, err := GetIntPointerOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsRoutesProfilesCount); err == nil ||
 		err.Error() != experr {
 		t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
@@ -2219,7 +2219,7 @@ func TestLibFiltersGetIntPointerOptsReturnDft(t *testing.T) {
 		config.NewDynamicIntPointerOpt([]string{"*string:~*req.Account:1002"}, "cgrates.org", utils.IntPointer(4), nil),
 	}
 
-	if rcv, err := GetIntPointerOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetIntPointerOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		utils.OptsRoutesProfilesCount); err != nil {
 		t.Error(err)
 	} else if rcv != nil {
@@ -2249,7 +2249,7 @@ func TestLibFiltersGetIntPointerOptsReturnOptFromAPIOptsOK(t *testing.T) {
 	}
 
 	expected := 6
-	if rcv, err := GetIntPointerOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if rcv, err := GetIntPointerOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		"nonExistingAPIOpt", utils.OptsRoutesProfilesCount); err != nil {
 		t.Error(err)
 	} else if *rcv != expected {
@@ -2279,7 +2279,7 @@ func TestLibFiltersGetIntPointerOptsReturnOptFromAPIOptsErr(t *testing.T) {
 	}
 
 	experr := `cannot convert field<bool>: true to int`
-	if _, err := GetIntPointerOpts(context.Background(), "cgrates.org", ev, fS, dynOpts,
+	if _, err := GetIntPointerOpts(context.Background(), "cgrates.org", ev.AsDataProvider(), fS, dynOpts,
 		"nonExistingAPIOpt", utils.OptsRoutesProfilesCount); err == nil || err.Error() != experr {
 		t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
 	}

engine/resources.go

@@ -673,13 +673,13 @@ func (rS *ResourceS) V1GetResourcesForEvent(ctx *context.Context, args *utils.CG
 	}
 
 	var usageID string
-	if usageID, err = GetStringOpts(ctx, args.Tenant, args, rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageID,
+	if usageID, err = GetStringOpts(ctx, args.Tenant, args.AsDataProvider(), rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageID,
 		utils.OptsResourcesUsageID); err != nil {
 		return
 	}
 
 	var ttl time.Duration
-	if ttl, err = GetDurationOpts(ctx, args.Tenant, args, rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageTTL,
+	if ttl, err = GetDurationOpts(ctx, args.Tenant, args.AsDataProvider(), rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageTTL,
 		utils.OptsResourcesUsageTTL); err != nil {
 		return
 	}
@@ -731,19 +731,19 @@ func (rS *ResourceS) V1AuthorizeResources(ctx *context.Context, args *utils.CGRE
 	}
 
 	var usageID string
-	if usageID, err = GetStringOpts(ctx, args.Tenant, args, rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageID,
+	if usageID, err = GetStringOpts(ctx, args.Tenant, args.AsDataProvider(), rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageID,
 		utils.OptsResourcesUsageID); err != nil {
 		return
 	}
 
 	var units float64
-	if units, err = GetFloat64Opts(ctx, args.Tenant, args, rS.fltrS, rS.cfg.ResourceSCfg().Opts.Units,
+	if units, err = GetFloat64Opts(ctx, args.Tenant, args.AsDataProvider(), rS.fltrS, rS.cfg.ResourceSCfg().Opts.Units,
 		utils.OptsResourcesUnits); err != nil {
 		return
 	}
 
 	var ttl time.Duration
-	if ttl, err = GetDurationOpts(ctx, args.Tenant, args, rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageTTL,
+	if ttl, err = GetDurationOpts(ctx, args.Tenant, args.AsDataProvider(), rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageTTL,
 		utils.OptsResourcesUsageTTL); err != nil {
 		return
 	}
@@ -807,19 +807,19 @@ func (rS *ResourceS) V1AllocateResources(ctx *context.Context, args *utils.CGREv
 	}
 
 	var usageID string
-	if usageID, err = GetStringOpts(ctx, args.Tenant, args, rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageID,
+	if usageID, err = GetStringOpts(ctx, args.Tenant, args.AsDataProvider(), rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageID,
 		utils.OptsResourcesUsageID); err != nil {
 		return
 	}
 
 	var units float64
-	if units, err = GetFloat64Opts(ctx, args.Tenant, args, rS.fltrS, rS.cfg.ResourceSCfg().Opts.Units,
+	if units, err = GetFloat64Opts(ctx, args.Tenant, args.AsDataProvider(), rS.fltrS, rS.cfg.ResourceSCfg().Opts.Units,
 		utils.OptsResourcesUnits); err != nil {
 		return
 	}
 
 	var ttl time.Duration
-	if ttl, err = GetDurationOpts(ctx, args.Tenant, args, rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageTTL,
+	if ttl, err = GetDurationOpts(ctx, args.Tenant, args.AsDataProvider(), rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageTTL,
 		utils.OptsResourcesUsageTTL); err != nil {
 		return
 	}
@@ -887,13 +887,13 @@ func (rS *ResourceS) V1ReleaseResources(ctx *context.Context, args *utils.CGREve
 	}
 
 	var usageID string
-	if usageID, err = GetStringOpts(ctx, args.Tenant, args, rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageID,
+	if usageID, err = GetStringOpts(ctx, args.Tenant, args.AsDataProvider(), rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageID,
 		utils.OptsResourcesUsageID); err != nil {
 		return
 	}
 
 	var ttl time.Duration
-	if ttl, err = GetDurationOpts(ctx, args.Tenant, args, rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageTTL,
+	if ttl, err = GetDurationOpts(ctx, args.Tenant, args.AsDataProvider(), rS.fltrS, rS.cfg.ResourceSCfg().Opts.UsageTTL,
 		utils.OptsResourcesUsageTTL); err != nil {
 		return
 	}

engine/route_cost_sort.go

@@ -36,7 +36,7 @@ func populateCostForRoutes(ctx *context.Context, cfg *config.CGRConfig, connMgr
 		return nil, utils.NewErrMandatoryIeMissing("connIDs")
 	}
 	var usage *decimal.Big
-	if usage, err = GetDecimalBigOpts(ctx, ev.Tenant, ev, fltrS, cfg.RouteSCfg().Opts.Usage,
+	if usage, err = GetDecimalBigOpts(ctx, ev.Tenant, ev.AsDataProvider(), fltrS, cfg.RouteSCfg().Opts.Usage,
 		utils.OptsRoutesUsage, utils.MetaUsage); err != nil {
 		return
 	}

engine/routes.go

@@ -192,7 +192,8 @@ func (rpS *RouteS) matchingRouteProfilesForEvent(ctx *context.Context, tnt strin
 
 func newOptsGetRoutes(ctx *context.Context, ev *utils.CGREvent, fS *FilterS, cfgOpts *config.RoutesOpts) (opts *optsGetRoutes, err error) {
 	var ignoreErrors bool
-	if ignoreErrors, err = GetBoolOpts(ctx, ev.Tenant, ev.AsDataProvider(), fS, cfgOpts.IgnoreErrors,
+	evNM := ev.AsDataProvider()
+	if ignoreErrors, err = GetBoolOpts(ctx, ev.Tenant, evNM, fS, cfgOpts.IgnoreErrors,
 		utils.OptsRoutesIgnoreErrors); err != nil {
 		return
 	}
@@ -201,21 +202,21 @@ func newOptsGetRoutes(ctx *context.Context, ev *utils.CGREvent, fS *FilterS, cfg
 		paginator:    &utils.Paginator{},
 	}
 	var limit *int
-	if limit, err = GetIntPointerOpts(ctx, ev.Tenant, ev, fS, cfgOpts.Limit,
+	if limit, err = GetIntPointerOpts(ctx, ev.Tenant, evNM, fS, cfgOpts.Limit,
 		utils.OptsRoutesLimit); err != nil {
 		return
 	} else {
 		opts.paginator.Limit = limit
 	}
 	var offset *int
-	if offset, err = GetIntPointerOpts(ctx, ev.Tenant, ev, fS, cfgOpts.Offset,
+	if offset, err = GetIntPointerOpts(ctx, ev.Tenant, evNM, fS, cfgOpts.Offset,
 		utils.OptsRoutesOffset); err != nil {
 		return
 	} else {
 		opts.paginator.Offset = offset
 	}
 	var maxItems *int
-	if maxItems, err = GetIntPointerOpts(ctx, ev.Tenant, ev, fS, cfgOpts.MaxItems,
+	if maxItems, err = GetIntPointerOpts(ctx, ev.Tenant, evNM, fS, cfgOpts.MaxItems,
 		utils.OptsRoutesMaxItems); err != nil {
 		return
 	} else {
@@ -223,7 +224,7 @@ func newOptsGetRoutes(ctx *context.Context, ev *utils.CGREvent, fS *FilterS, cfg
 	}
 
 	var maxCost any
-	if maxCost, err = GetInterfaceOpts(ctx, ev.Tenant, ev, fS, cfgOpts.MaxCost, config.RoutesMaxCostDftOpt,
+	if maxCost, err = GetInterfaceOpts(ctx, ev.Tenant, evNM, fS, cfgOpts.MaxCost, config.RoutesMaxCostDftOpt,
 		utils.OptsRoutesMaxCost); err != nil {
 		return
 	}
@@ -280,7 +281,7 @@ func (rpS *RouteS) V1GetRoutes(ctx *context.Context, args *utils.CGREvent, reply
 	if len(rpS.cfg.RouteSCfg().AttributeSConns) != 0 {
 		args.APIOpts[utils.MetaSubsys] = utils.MetaRoutes
 		var context string
-		if context, err = GetStringOpts(ctx, tnt, args, rpS.fltrS, rpS.cfg.RouteSCfg().Opts.Context,
+		if context, err = GetStringOpts(ctx, tnt, args.AsDataProvider(), rpS.fltrS, rpS.cfg.RouteSCfg().Opts.Context,
 			utils.OptsContext); err != nil {
 			return
 		}
@@ -408,7 +409,7 @@ func (rpS *RouteS) sortedRoutesForEvent(ctx *context.Context, tnt string, args *
 	}
 	prfCount := len(rPrfs) // if the option is not present return for all profiles
 	var prfCountOpt *int
-	if prfCountOpt, err = GetIntPointerOpts(ctx, tnt, args, rpS.fltrS, rpS.cfg.RouteSCfg().Opts.ProfileCount,
+	if prfCountOpt, err = GetIntPointerOpts(ctx, tnt, args.AsDataProvider(), rpS.fltrS, rpS.cfg.RouteSCfg().Opts.ProfileCount,
 		utils.OptsRoutesProfilesCount); err != nil && err != utils.ErrNotFound {
 		// if the error is NOT_FOUND, it means that in opts or config, countProfiles field is not defined
 		return

engine/stats.go

@@ -373,7 +373,7 @@ func (sS *StatS) processEEs(ctx *context.Context, sQs StatQueues, opts map[strin
 func (sS *StatS) processEvent(ctx *context.Context, tnt string, args *utils.CGREvent) (statQueueIDs []string, err error) {
 	evNm := args.AsDataProvider()
 	var sqIDs []string
-	if sqIDs, err = GetStringSliceOpts(ctx, tnt, args, sS.fltrS, sS.cfg.StatSCfg().Opts.ProfileIDs,
+	if sqIDs, err = GetStringSliceOpts(ctx, tnt, evNm, sS.fltrS, sS.cfg.StatSCfg().Opts.ProfileIDs,
 		config.StatsProfileIDsDftOpt, utils.OptsStatsProfileIDs); err != nil {
 		return
 	}
@@ -415,7 +415,7 @@ func (sS *StatS) processEvent(ctx *context.Context, tnt string, args *utils.CGRE
 	}
 
 	var promIDs []string
-	if promIDs, err = GetStringSliceOpts(ctx, tnt, args, sS.fltrS, sS.cfg.StatSCfg().Opts.PrometheusStatIDs,
+	if promIDs, err = GetStringSliceOpts(ctx, tnt, evNm, sS.fltrS, sS.cfg.StatSCfg().Opts.PrometheusStatIDs,
 		[]string{}, utils.OptsPrometheusStatIDs); err != nil {
 		return
 	}
@@ -467,7 +467,8 @@ func (sS *StatS) V1GetStatQueuesForEvent(ctx *context.Context, args *utils.CGREv
 		tnt = sS.cfg.GeneralCfg().DefaultTenant
 	}
 	var sqIDs []string
-	if sqIDs, err = GetStringSliceOpts(ctx, tnt, args, sS.fltrS, sS.cfg.StatSCfg().Opts.ProfileIDs,
+	dP := args.AsDataProvider()
+	if sqIDs, err = GetStringSliceOpts(ctx, tnt, dP, sS.fltrS, sS.cfg.StatSCfg().Opts.ProfileIDs,
 		config.StatsProfileIDsDftOpt, utils.OptsStatsProfileIDs); err != nil {
 		return
 	}
@@ -531,7 +532,7 @@ func (sS *StatS) V1GetQueueStringMetrics(ctx *context.Context, args *utils.Tenan
 		return err
 	}
 	var rnd int
-	if rnd, err = GetIntOpts(ctx, tnt, &utils.CGREvent{Tenant: tnt}, sS.fltrS,
+	if rnd, err = GetIntOpts(ctx, tnt, MapEvent{utils.Tenant: tnt, "*opts": map[string]any{}}, sS.fltrS,
 		sS.cfg.StatSCfg().Opts.RoundingDecimals,
 		utils.OptsRoundingDecimals); err != nil {
 		return

engine/thresholds.go

@@ -333,7 +333,7 @@ func (tS *ThresholdS) matchingThresholdsForEvent(ctx *context.Context, tnt strin
 		utils.MetaOpts: args.APIOpts,
 	}
 	var thIDs []string
-	if thIDs, err = GetStringSliceOpts(ctx, tnt, args, tS.fltrS, tS.cfg.ThresholdSCfg().Opts.ProfileIDs,
+	if thIDs, err = GetStringSliceOpts(ctx, tnt, evNm, tS.fltrS, tS.cfg.ThresholdSCfg().Opts.ProfileIDs,
 		config.ThresholdsProfileIDsDftOpt, utils.OptsThresholdsProfileIDs); err != nil {
 		return
 	}

engine/z_attributes_test.go

@@ -5301,7 +5301,7 @@ func TestAttributesAttributeServiceV1PrcssEvPrcssRunsGetIntOptsErr(t *testing.T)
 	}
 
 	reply := &AttrSProcessEventReply{}
-	exrErr := `strconv.ParseInt: parsing "errVal": invalid syntax`
+	exrErr := `strconv.Atoi: parsing "errVal": invalid syntax`
 	if err := alS.V1ProcessEvent(context.Background(), ev, reply); err == nil || err.Error() != exrErr {
 		t.Errorf("\nExpected <%+v>, \nReceived <%+v>", exrErr, err)
 	}
@@ -5353,7 +5353,7 @@ func TestAttributesAttributeServiceV1PrcssEvProfRunsGetIntOptsErr(t *testing.T)
 	}
 
 	reply := &AttrSProcessEventReply{}
-	exrErr := `strconv.ParseInt: parsing "errVal": invalid syntax`
+	exrErr := `strconv.Atoi: parsing "errVal": invalid syntax`
 	if err := alS.V1ProcessEvent(context.Background(), ev, reply); err == nil || err.Error() != exrErr {
 		t.Errorf("\nExpected <%+v>, \nReceived <%+v>", exrErr, err)
 	}