uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-12 02:26:26 +05:00
Code Issues Packages Projects Releases Wiki Activity

Delete unused opt retrieval functions

Browse Source
This commit is contained in:
ionutboangiu
2021-10-06 12:59:13 +03:00
committed by Dan Christian Bogos
parent 1e7ff42468
commit 37e8f358b7
4 changed files with 0 additions and 451 deletions
Download Patch File Download Diff File Expand all files Collapse all files

168
engine/libfilters.go
View File

@@ -26,27 +26,6 @@ import (
"github.com/ericlagergren/decimal"
)
// FilterFloat64CfgOpts returns the option as float64 if the filters match
func FilterFloat64CfgOpts(ctx *context.Context, tnt string, ev utils.DataProvider, fS *FilterS, dynOpts []*utils.DynamicFloat64Opt) (dft float64, err error) {
var hasDefault bool
for _, opt := range dynOpts { // iterate through the options
if len(opt.FilterIDs) == 1 && opt.FilterIDs[0] == utils.MetaDefault {
hasDefault = true
dft = opt.Value
continue
}
if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, ev); 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, nil
}
}
if !hasDefault {
err = utils.ErrNotFound
}
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// 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 NOT_FOUND if none of them do
func GetFloat64Opts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*utils.DynamicFloat64Opt,
@@ -76,27 +55,6 @@ func GetFloat64Opts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *Fi
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// FilterDurationCfgOpts returns the option as time.Duration if the filters match
func FilterDurationCfgOpts(ctx *context.Context, tnt string, ev utils.DataProvider, fS *FilterS, dynOpts []*utils.DynamicDurationOpt) (dft time.Duration, err error) {
var hasDefault bool
for _, opt := range dynOpts { // iterate through the options
if len(opt.FilterIDs) == 1 && opt.FilterIDs[0] == utils.MetaDefault {
hasDefault = true
dft = opt.Value
continue
}
if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, ev); 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, nil
}
}
if !hasDefault {
err = utils.ErrNotFound
}
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// 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 NOT_FOUND if none of them do
func GetDurationOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*utils.DynamicDurationOpt,
@@ -126,27 +84,6 @@ func GetDurationOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *F
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// FilterStringCfgOpts returns the option as string if the filters match
func FilterStringCfgOpts(ctx *context.Context, tnt string, ev utils.DataProvider, fS *FilterS, dynOpts []*utils.DynamicStringOpt) (dft string, err error) {
var hasDefault bool
for _, opt := range dynOpts { // iterate through the options
if len(opt.FilterIDs) == 1 && opt.FilterIDs[0] == utils.MetaDefault {
hasDefault = true
dft = opt.Value
continue
}
if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, ev); 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, nil
}
}
if !hasDefault {
err = utils.ErrNotFound
}
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// 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 NOT_FOUND if none of them do
func GetStringOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*utils.DynamicStringOpt,
@@ -208,27 +145,6 @@ func GetTimeOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *Filte
return utils.ParseTimeDetectLayout(cfgOptStr, tmz) // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// FilterStringSliceCfgOpts returns the option as []string if the filters match
func FilterStringSliceCfgOpts(ctx *context.Context, tnt string, ev utils.DataProvider, fS *FilterS, dynOpts []*utils.DynamicStringSliceOpt) (dft []string, err error) {
var hasDefault bool
for _, opt := range dynOpts { // iterate through the options
if len(opt.FilterIDs) == 1 && opt.FilterIDs[0] == utils.MetaDefault {
hasDefault = true
dft = opt.Value
continue
}
if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, ev); 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, nil
}
}
if !hasDefault {
err = utils.ErrNotFound
}
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// 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 NOT_FOUND if none of them do
func GetStringSliceOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*utils.DynamicStringSliceOpt,
@@ -258,27 +174,6 @@ func GetStringSliceOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// FilterIntCfgOpts returns the option as int if the filters match
func FilterIntCfgOpts(ctx *context.Context, tnt string, ev utils.DataProvider, fS *FilterS, dynOpts []*utils.DynamicIntOpt) (dft int, err error) {
var hasDefault bool
for _, opt := range dynOpts { // iterate through the options
if len(opt.FilterIDs) == 1 && opt.FilterIDs[0] == utils.MetaDefault {
hasDefault = true
dft = opt.Value
continue
}
if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, ev); 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, nil
}
}
if !hasDefault {
err = utils.ErrNotFound
}
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// 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 NOT_FOUND if none of them do
func GetIntOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*utils.DynamicIntOpt,
@@ -312,27 +207,6 @@ func GetIntOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *Filter
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// FilterBoolCfgOpts returns the option as bool if the filters match
func FilterBoolCfgOpts(ctx *context.Context, tnt string, ev utils.DataProvider, fS *FilterS, dynOpts []*utils.DynamicBoolOpt) (dft bool, err error) {
var hasDefault bool
for _, opt := range dynOpts { // iterate through the options
if len(opt.FilterIDs) == 1 && opt.FilterIDs[0] == utils.MetaDefault {
hasDefault = true
dft = opt.Value
continue
}
if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, ev); 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
}
}
if !hasDefault {
err = utils.ErrNotFound
}
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// GetBoolOpts checks the specified option names in order among the keys in APIOpts returning the first value it finds as bool, otherwise it
// returns the config option if at least one filter passes or NOT_FOUND if none of them do
func GetBoolOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*utils.DynamicBoolOpt,
@@ -362,27 +236,6 @@ func GetBoolOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *Filte
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// FilterDurationCfgOpts returns the option as time.Duration if the filters match
func FilterDecimalBigCfgOpts(ctx *context.Context, tnt string, ev utils.DataProvider, fS *FilterS, dynOpts []*utils.DynamicDecimalBigOpt) (dft *decimal.Big, err error) {
var hasDefault bool
for _, opt := range dynOpts { // iterate through the options
if len(opt.FilterIDs) == 1 && opt.FilterIDs[0] == utils.MetaDefault {
hasDefault = true
dft = opt.Value
continue
}
if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, ev); 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, nil
}
}
if !hasDefault {
err = utils.ErrNotFound
}
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// 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 NOT_FOUND if none of them do
func GetDecimalBigOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*utils.DynamicDecimalBigOpt,
@@ -412,27 +265,6 @@ func GetDecimalBigOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// FilterInterfaceCfgOpts returns the option as interface{} if the filters match
func FilterInterfaceCfgOpts(ctx *context.Context, tnt string, ev utils.DataProvider, fS *FilterS, dynOpts []*utils.DynamicInterfaceOpt) (dft interface{}, err error) {
var hasDefault bool
for _, opt := range dynOpts { // iterate through the options
if len(opt.FilterIDs) == 1 && opt.FilterIDs[0] == utils.MetaDefault {
hasDefault = true
dft = opt.Value
continue
}
if pass, err := fS.Pass(ctx, tnt, opt.FilterIDs, ev); 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
}
}
if !hasDefault {
err = utils.ErrNotFound
}
return // return the option or NOT_FOUND if there are no options or none of the filters pass
}
// GetInterfaceOpts checks the specified option names in order among the keys in APIOpts returning the first value it finds as interface{}, otherwise it
// returns the config option if at least one filter passes or NOT_FOUND if none of them do
func GetInterfaceOpts(ctx *context.Context, tnt string, ev *utils.CGREvent, fS *FilterS, dynOpts []*utils.DynamicInterfaceOpt,

164
utils/apitpdata_test.go
View File

@@ -21,8 +21,6 @@ import (
"reflect"
"testing"
"time"
"github.com/ericlagergren/decimal"
)
func TestPaginatorPaginateStringSlice(t *testing.T) {
@@ -506,123 +504,6 @@ func TestNewAttrReloadCacheWithOpts(t *testing.T) {
}
}
func TestStartTimeNow(t *testing.T) {
ev := &CGREvent{
Tenant: "*req.CGRID",
ID: "",
Event: map[string]interface{}{},
APIOpts: map[string]interface{}{
OptsRatesRateProfileIDs: []string{"123", "456", "789"},
},
}
timpulet1 := time.Now()
result, err := ev.StartTime(MetaNow, "", OptsRatesStartTime, MetaStartTime)
timpulet2 := time.Now()
if err != nil {
t.Errorf("Expected <nil> , received <%+v>", err)
}
if result.Before(timpulet1) && result.After(timpulet2) {
t.Errorf("Expected between <%+v> and <%+v>, received <%+v>", timpulet1, timpulet2, result)
}
}
func TestStartTime(t *testing.T) {
ev := &CGREvent{
Tenant: "*req.CGRID",
ID: "",
Event: map[string]interface{}{},
APIOpts: map[string]interface{}{
"*ratesStartTime": "2018-01-07T17:00:10Z",
OptsRatesRateProfileIDs: []string{"123", "456", "789"},
},
}
if result, err := ev.StartTime(MetaNow, "", OptsRatesStartTime, MetaStartTime); err != nil {
t.Errorf("Expected <nil> , received <%+v>", err)
} else if !reflect.DeepEqual(result.String(), "2018-01-07 17:00:10 +0000 UTC") {
t.Errorf("Expected <2018-01-07 17:00:10 +0000 UTC> , received <%+v>", result)
}
}
func TestStartTime2(t *testing.T) {
ev := &CGREvent{
Tenant: "cgrates.org",
ID: "TestEvent",
Event: map[string]interface{}{},
APIOpts: map[string]interface{}{},
}
if result, err := ev.StartTime("2018-01-07T17:00:10Z", "", OptsRatesStartTime, MetaStartTime); err != nil {
t.Errorf("Expected <nil> , received <%+v>", err)
} else if !reflect.DeepEqual(result.String(), "2018-01-07 17:00:10 +0000 UTC") {
t.Errorf("Expected <2018-01-07 17:00:10 +0000 UTC> , received <%+v>", result)
}
}
func TestStartTimeError(t *testing.T) {
ev := &CGREvent{
Tenant: "*req.CGRID",
ID: "",
Event: map[string]interface{}{},
APIOpts: map[string]interface{}{
"*ratesStartTime": "start",
OptsRatesRateProfileIDs: []string{"123", "456", "789"},
},
}
_, err := ev.StartTime(MetaNow, "", OptsRatesStartTime, MetaStartTime)
if err == nil && err.Error() != "received <Unsupported time format" {
t.Errorf("Expected <nil> , received <%+v>", err)
}
}
func TestUsageMinute(t *testing.T) {
ev := &CGREvent{
Tenant: "*req.CGRID",
ID: "",
Event: map[string]interface{}{},
APIOpts: map[string]interface{}{
OptsRatesRateProfileIDs: []string{"123", "456", "789"},
},
}
if rcv, err := ev.OptsAsDecimal(decimal.New(int64(60*time.Second), 0), OptsRatesUsage, MetaUsage); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(decimal.New(int64(time.Minute), 0), rcv) {
t.Errorf("Expected %+v, received %+v", decimal.New(int64(time.Minute), 0), rcv)
}
}
func TestUsageError(t *testing.T) {
ev := &CGREvent{
Tenant: "*req.CGRID",
ID: "",
Event: map[string]interface{}{},
APIOpts: map[string]interface{}{
"*ratesUsage": "start",
OptsRatesRateProfileIDs: []string{"123", "456", "789"},
},
}
_, err := ev.OptsAsDecimal(decimal.New(int64(time.Minute), 0), OptsRatesUsage, MetaUsage)
if err == nil && err.Error() != "received <Unsupported time format" {
t.Errorf("Expected <nil> , received <%+v>", err)
}
}
func TestUsage(t *testing.T) {
ev := &CGREvent{
Tenant: "*req.CGRID",
ID: "",
Event: map[string]interface{}{},
APIOpts: map[string]interface{}{
"*ratesUsage": "2m10s",
OptsRatesRateProfileIDs: []string{"123", "456", "789"},
},
}
if result, err := ev.OptsAsDecimal(decimal.New(int64(time.Minute), 0), OptsRatesUsage, MetaUsage); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(result.String(), "130000000000") {
t.Errorf("Expected <130000000000> , received <%+v>", result.String())
}
}
func TestNewTPBalanceCostIncrement(t *testing.T) {
incrementStr := "20"
fixedFeeStr := "10"
@@ -701,21 +582,6 @@ func TestBalanceUnitFactor(t *testing.T) {
}
}
func TestATDUsage(t *testing.T) {
ev := &CGREvent{
ID: "testID",
APIOpts: map[string]interface{}{
OptsRatesUsage: true,
},
}
_, err := ev.OptsAsDecimal(decimal.New(int64(time.Minute), 0), OptsRatesUsage, MetaUsage)
expected := "cannot convert field: bool to decimal.Big"
if err == nil || err.Error() != expected {
t.Errorf("\nExpected: <%+v>, \nReceived: <%+v>", expected, err.Error())
}
}
func TestActivationIntervalEquals(t *testing.T) {
aI := &ActivationInterval{
ActivationTime: time.Time{},
@@ -732,36 +598,6 @@ func TestActivationIntervalEquals(t *testing.T) {
}
}
func TestIntervalStart(t *testing.T) {
args := &CGREvent{
APIOpts: map[string]interface{}{
OptsRatesIntervalStart: "1ns",
OptsRatesRateProfileIDs: []string{"RP_1001"},
},
}
rcv, err := args.OptsAsDecimal(decimal.New(0, 0), OptsRatesIntervalStart)
exp := new(decimal.Big).SetUint64(1)
if err != nil {
t.Error(err)
} else if !reflect.DeepEqual(rcv, exp) {
t.Errorf("Expected %v but received %v", rcv, exp)
}
}
func TestIntervalStartDefault(t *testing.T) {
args := &CGREvent{
APIOpts: map[string]interface{}{
OptsRatesRateProfileIDs: []string{"RP_1001"},
},
}
rcv, err := args.OptsAsDecimal(decimal.New(0, 0), OptsRatesIntervalStart)
exp := new(decimal.Big).SetUint64(0)
if err != nil {
t.Error(err)
} else if !reflect.DeepEqual(rcv, exp) {
t.Errorf("Expected %v but received %v", rcv, exp)
}
}
func TestNewAttrReloadCacheWithOptsFromMap(t *testing.T) {
excluded := NewStringSet([]string{MetaAPIBan, MetaLoadIDs})
mp := make(map[string][]string)

86
utils/cgrevent.go
View File

@@ -21,8 +21,6 @@ package utils
import (
"strings"
"time"
"github.com/ericlagergren/decimal"
)
// CGREvent is a generic event processed by CGR services
@@ -86,80 +84,6 @@ func (ev *CGREvent) FieldAsDuration(fldName string) (d time.Duration, err error)
return IfaceAsDuration(iface)
}
// OptsAsDecimal returns an option as decimal.Big instance
func (ev *CGREvent) OptsAsDecimal(defaultValue *decimal.Big, optNames ...string) (*decimal.Big, error) {
for _, optName := range optNames {
if iface, has := ev.APIOpts[optName]; has {
return IfaceAsBig(iface)
}
}
return defaultValue, nil
}
// OptsAsString returns an option as string
func (ev *CGREvent) OptsAsString(defaultValue string, optNames ...string) string {
for _, optName := range optNames {
if iface, has := ev.APIOpts[optName]; has {
return IfaceAsString(iface)
}
}
return defaultValue
}
// OptsAsInt returns an option as int
func (ev *CGREvent) OptsAsInt(defaultValue int, optNames ...string) (opt int, err error) {
for _, optName := range optNames {
if iface, has := ev.APIOpts[optName]; has {
var value int64
if value, err = IfaceAsTInt64(iface); err != nil {
return 0, err
}
return int(value), nil
}
}
return defaultValue, nil
}
// OptsAsDuration returns an option as time.Duration
func (ev *CGREvent) OptsAsDuration(defaultValue time.Duration, optNames ...string) (time.Duration, error) {
for _, optName := range optNames {
if iface, has := ev.APIOpts[optName]; has {
return IfaceAsDuration(iface)
}
}
return defaultValue, nil
}
// OptsAsFloat64 returns an option as float64
func (ev *CGREvent) OptsAsFloat64(defaultValue float64, optNames ...string) (float64, error) {
for _, optName := range optNames {
if iface, has := ev.APIOpts[optName]; has {
return IfaceAsFloat64(iface)
}
}
return defaultValue, nil
}
// OptsAsStringSlice returns an option as []string
func (ev *CGREvent) OptsAsStringSlice(defaultValue []string, optNames ...string) ([]string, error) {
for _, optName := range optNames {
if iface, has := ev.APIOpts[optName]; has {
return IfaceAsStringSlice(iface)
}
}
return defaultValue, nil
}
// OptsAsInterface returns an option as float64
func (ev *CGREvent) OptsAsInterface(defaultValue interface{}, optNames ...string) interface{} {
for _, optName := range optNames {
if iface, has := ev.APIOpts[optName]; has {
return iface
}
}
return defaultValue
}
func (ev *CGREvent) Clone() (clned *CGREvent) {
clned = &CGREvent{
Tenant: ev.Tenant,
@@ -269,16 +193,6 @@ func NMAsCGREvent(nM *OrderedNavigableMap, tnt string, pathSep string, opts MapS
return
}
// StartTime returns the event time used to check active rate profiles
func (args *CGREvent) StartTime(configSTime, tmz string, optNames ...string) (time.Time, error) {
for _, optName := range optNames {
if iface, has := args.APIOpts[optName]; has {
return IfaceAsTime(iface, tmz)
}
}
return ParseTimeDetectLayout(configSTime, tmz)
}
// SetCloneable sets if the args should be clonned on internal connections
func (attr *CGREvent) SetCloneable(rpcCloneable bool) {
attr.clnb = rpcCloneable

33
utils/cgrevent_test.go
View File

@@ -22,8 +22,6 @@ import (
"strings"
"testing"
"time"
"github.com/ericlagergren/decimal"
)
func TestCGREventHasField(t *testing.T) {
@@ -335,37 +333,6 @@ func TestCGREventOptAsInt64(t *testing.T) {
}
}
func TestCGREventOptAsDurationNoOpts(t *testing.T) {
ev := &CGREvent{}
expdur := decimal.New(int64(time.Minute), 0)
received, err := ev.OptsAsDecimal(decimal.New(int64(time.Minute), 0), "testString")
if err != nil {
t.Error(err)
} else if !reflect.DeepEqual(expdur, received) {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", expdur, received)
}
}
func TestCGREventOptAsDuration(t *testing.T) {
ev := &CGREvent{
APIOpts: map[string]interface{}{
"*usage": 30,
},
}
received, err := ev.OptsAsDecimal(decimal.New(int64(72*time.Hour), 0), "*usage")
if err != nil {
t.Errorf("\nExpected: <%+v>, \nReceived: <%+v>", nil, err)
}
expected := decimal.New(int64(30*time.Nanosecond), 0)
if !reflect.DeepEqual(received, expected) {
t.Errorf("\nExpected: <%+v>, \nReceived: <%+v>", expected, received)
}
}
func TestCGREventAsDataProvider(t *testing.T) {
ev := &CGREvent{
APIOpts: map[string]interface{}{