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

Use the newly implemented functions to retrieve the opts from APIOpts/config

Browse Source
This commit is contained in:
ionutboangiu
2021-10-05 14:05:41 +03:00
committed by Dan Christian Bogos
parent 4863bd949f
commit b92e64ee86
9 changed files with 86 additions and 211 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
accounts/accounts.go
View File

@@ -132,12 +132,8 @@ func (aS *AccountS) matchingAccountsForEvent(ctx *context.Context, tnt string, c
func (aS *AccountS) accountsDebit(ctx *context.Context, acnts []*utils.AccountWithWeight,
cgrEv *utils.CGREvent, concretes, store bool) (ec *utils.EventCharges, err error) {
var usage *decimal.Big
if usage, err = engine.FilterDecimalBigCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), aS.fltrS,
aS.cfg.AccountSCfg().Opts.Usage); err != nil {
return
}
if usage, err = cgrEv.OptsAsDecimal(usage, utils.OptsAccountsUsage,
utils.MetaUsage); err != nil {
if usage, err = engine.GetDecimalBigOpts(ctx, cgrEv.Tenant, cgrEv, aS.fltrS, aS.cfg.AccountSCfg().Opts.Usage,
utils.OptsAccountsUsage, utils.MetaUsage); err != nil {
return
}
dbted := decimal.New(0, 0)
@@ -240,11 +236,8 @@ func (aS *AccountS) accountDebit(ctx *context.Context, acnt *utils.Account, usag
// V1AccountsForEvent returns the matching Accounts for Event
func (aS *AccountS) V1AccountsForEvent(ctx *context.Context, args *utils.CGREvent, aps *[]*utils.Account) (err error) {
var accIDs []string
if accIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
aS.cfg.AccountSCfg().Opts.AccountIDs); err != nil {
return
}
if accIDs, err = args.OptsAsStringSlice(accIDs, utils.OptsAccountsAccountIDs); err != nil {
if accIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.AccountSCfg().Opts.AccountIDs,
utils.OptsAccountsAccountIDs); err != nil {
return
}
var acnts utils.AccountsWithWeight
@@ -262,11 +255,8 @@ func (aS *AccountS) V1AccountsForEvent(ctx *context.Context, args *utils.CGREven
// V1MaxAbstracts returns the maximum abstract units for the event, based on matching Accounts
func (aS *AccountS) V1MaxAbstracts(ctx *context.Context, args *utils.CGREvent, eEc *utils.ExtEventCharges) (err error) {
var accIDs []string
if accIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
aS.cfg.AccountSCfg().Opts.AccountIDs); err != nil {
return
}
if accIDs, err = args.OptsAsStringSlice(accIDs, utils.OptsAccountsAccountIDs); err != nil {
if accIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.AccountSCfg().Opts.AccountIDs,
utils.OptsAccountsAccountIDs); err != nil {
return
}
var acnts utils.AccountsWithWeight
@@ -294,11 +284,8 @@ func (aS *AccountS) V1MaxAbstracts(ctx *context.Context, args *utils.CGREvent, e
// V1DebitAbstracts performs debit for the provided event
func (aS *AccountS) V1DebitAbstracts(ctx *context.Context, args *utils.CGREvent, eEc *utils.ExtEventCharges) (err error) {
var accIDs []string
if accIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
aS.cfg.AccountSCfg().Opts.AccountIDs); err != nil {
return
}
if accIDs, err = args.OptsAsStringSlice(accIDs, utils.OptsAccountsAccountIDs); err != nil {
if accIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.AccountSCfg().Opts.AccountIDs,
utils.OptsAccountsAccountIDs); err != nil {
return
}
var acnts utils.AccountsWithWeight
@@ -327,11 +314,8 @@ func (aS *AccountS) V1DebitAbstracts(ctx *context.Context, args *utils.CGREvent,
// V1MaxConcretes returns the maximum concrete units for the event, based on matching Accounts
func (aS *AccountS) V1MaxConcretes(ctx *context.Context, args *utils.CGREvent, eEc *utils.ExtEventCharges) (err error) {
var accIDs []string
if accIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
aS.cfg.AccountSCfg().Opts.AccountIDs); err != nil {
return
}
if accIDs, err = args.OptsAsStringSlice(accIDs, utils.OptsAccountsAccountIDs); err != nil {
if accIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.AccountSCfg().Opts.AccountIDs,
utils.OptsAccountsAccountIDs); err != nil {
return
}
var acnts utils.AccountsWithWeight
@@ -359,11 +343,8 @@ func (aS *AccountS) V1MaxConcretes(ctx *context.Context, args *utils.CGREvent, e
// V1DebitConcretes performs debit of concrete units for the provided event
func (aS *AccountS) V1DebitConcretes(ctx *context.Context, args *utils.CGREvent, eEc *utils.ExtEventCharges) (err error) {
var accIDs []string
if accIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
aS.cfg.AccountSCfg().Opts.AccountIDs); err != nil {
return
}
if accIDs, err = args.OptsAsStringSlice(accIDs, utils.OptsAccountsAccountIDs); err != nil {
if accIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.AccountSCfg().Opts.AccountIDs,
utils.OptsAccountsAccountIDs); err != nil {
return
}
var acnts utils.AccountsWithWeight

14
actions/actions.go
View File

@@ -261,11 +261,8 @@ func (aS *ActionS) asapExecuteActions(ctx *context.Context, sActs *scheduledActs
// V1ScheduleActions will be called to schedule actions matching the arguments
func (aS *ActionS) V1ScheduleActions(ctx *context.Context, args *utils.CGREvent, rpl *string) (err error) {
var actPrfIDs []string
if actPrfIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
aS.cfg.ActionSCfg().Opts.ActionProfileIDs); err != nil {
return
}
if actPrfIDs, err = args.OptsAsStringSlice(actPrfIDs, utils.OptsActionsActionProfileIDs); err != nil {
if actPrfIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.ActionSCfg().Opts.ActionProfileIDs,
utils.OptsActionsActionProfileIDs); err != nil {
return
}
if err = aS.scheduleActions(ctx, []*utils.CGREvent{args},
@@ -279,11 +276,8 @@ func (aS *ActionS) V1ScheduleActions(ctx *context.Context, args *utils.CGREvent,
// V1ExecuteActions will be called to execute ASAP action profiles, ignoring their Schedule field
func (aS *ActionS) V1ExecuteActions(ctx *context.Context, args *utils.CGREvent, rpl *string) (err error) {
var actPrfIDs []string
if actPrfIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
aS.cfg.ActionSCfg().Opts.ActionProfileIDs); err != nil {
return
}
if actPrfIDs, err = args.OptsAsStringSlice(actPrfIDs, utils.OptsActionsActionProfileIDs); err != nil {
if actPrfIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.ActionSCfg().Opts.ActionProfileIDs,
utils.OptsActionsActionProfileIDs); err != nil {
return
}
var schedActSet []*scheduledActs

20
engine/attributes.go
View File

@@ -133,7 +133,8 @@ func (attrReply *AttrSProcessEventReply) Digest() (rplyDigest string) {
func (alS *AttributeService) 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 = utils.OptAsStringSlice(args.APIOpts, utils.OptsAttributesAttributeIDs); err != nil {
if attrIDs, err = GetStringSliceOpts(ctx, args.Tenant, args, alS.filterS, alS.cgrcfg.AttributeSCfg().Opts.AttributeIDs,
utils.OptsAttributesAttributeIDs); err != nil {
return
}
var attrPrf *AttributeProfile
@@ -207,7 +208,8 @@ func (alS *AttributeService) V1GetAttributeForEvent(ctx *context.Context, args *
tnt = alS.cgrcfg.GeneralCfg().DefaultTenant
}
var attrIDs []string
if attrIDs, err = utils.OptAsStringSlice(args.APIOpts, utils.OptsAttributesAttributeIDs); err != nil {
if attrIDs, err = GetStringSliceOpts(ctx, args.Tenant, args, alS.filterS, alS.cgrcfg.AttributeSCfg().Opts.AttributeIDs,
utils.OptsAttributesAttributeIDs); err != nil {
return
}
attrPrf, err := alS.attributeProfileForEvent(ctx, tnt, attrIDs, utils.MapStorage{
@@ -236,20 +238,14 @@ func (alS *AttributeService) V1ProcessEvent(ctx *context.Context, args *utils.CG
}
var processRuns int
if processRuns, err = FilterIntCfgOpts(ctx, tnt, args.AsDataProvider(), alS.filterS,
alS.cgrcfg.AttributeSCfg().Opts.ProcessRuns); err != nil {
return
}
if processRuns, err = args.OptsAsInt(processRuns, utils.OptsAttributesProcessRuns); err != nil {
if processRuns, err = GetIntOpts(ctx, tnt, args, alS.filterS, alS.cgrcfg.AttributeSCfg().Opts.ProcessRuns,
utils.OptsAttributesProcessRuns); err != nil {
return
}
var profileRuns int
if profileRuns, err = FilterIntCfgOpts(ctx, tnt, args.AsDataProvider(), alS.filterS,
alS.cgrcfg.AttributeSCfg().Opts.ProfileRuns); err != nil {
return
}
if profileRuns, err = args.OptsAsInt(profileRuns, utils.OptsAttributesProfileRuns); err != nil {
if profileRuns, err = GetIntOpts(ctx, tnt, args, alS.filterS, alS.cgrcfg.AttributeSCfg().Opts.ProfileRuns,
utils.OptsAttributesProfileRuns); err != nil {
return
}
args = args.Clone()

55
engine/cdrs.go
View File

@@ -191,12 +191,8 @@ func (cdrS *CDRServer) eeSProcessEvent(ctx *context.Context, cgrEv *utils.CGREve
func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (evs []*utils.EventWithFlags, err error) {
// making the options
var attrS bool
if v, has := ev.APIOpts[utils.OptsAttributeS]; !has {
if attrS, err = FilterBoolCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), cdrS.filterS,
cdrS.cfg.CdrsCfg().Opts.Attributes); err != nil {
return
}
} else if attrS, err = utils.IfaceAsBool(v); err != nil {
if attrS, err = GetBoolOpts(ctx, ev.Tenant, ev, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Attributes,
utils.OptsAttributeS); err != nil {
return
}
if attrS {
@@ -211,11 +207,8 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (e
var cgrEvs []*utils.CGREvent
var chrgS bool
if v, has := ev.APIOpts[utils.OptsChargerS]; !has {
if chrgS, err = FilterBoolCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Chargers); err != nil {
return
}
} else if chrgS, err = utils.IfaceAsBool(v); err != nil {
if chrgS, err = GetBoolOpts(ctx, ev.Tenant, ev, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Chargers,
utils.OptsChargerS); err != nil {
return
}
if chrgS {
@@ -234,12 +227,8 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (e
var rateS bool
for _, cgrEv := range cgrEvs {
if v, has := cgrEv.APIOpts[utils.OptsRateS]; !has {
if rateS, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
cdrS.cfg.CdrsCfg().Opts.Rates); err != nil {
return
}
} else if rateS, err = utils.IfaceAsBool(v); err != nil {
if rateS, err = GetBoolOpts(ctx, cgrEv.Tenant, cgrEv, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Rates,
utils.OptsRateS); err != nil {
return
}
if rateS {
@@ -254,12 +243,8 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (e
var acntS bool
for _, cgrEv := range cgrEvs {
if v, has := cgrEv.APIOpts[utils.OptsAccountS]; !has {
if acntS, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
cdrS.cfg.CdrsCfg().Opts.Accounts); err != nil {
return
}
} else if acntS, err = utils.IfaceAsBool(v); err != nil {
if acntS, err = GetBoolOpts(ctx, cgrEv.Tenant, cgrEv, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Accounts,
utils.OptsAccountS); err != nil {
return
}
if acntS {
@@ -275,12 +260,8 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (e
var export bool
if len(cdrS.cfg.CdrsCfg().EEsConns) != 0 {
for _, cgrEv := range cgrEvs {
if v, has := cgrEv.APIOpts[utils.OptsCDRsExport]; !has {
if export, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
cdrS.cfg.CdrsCfg().Opts.Export); err != nil {
return
}
} else if export, err = utils.IfaceAsBool(v); err != nil {
if export, err = GetBoolOpts(ctx, cgrEv.Tenant, cgrEv, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Export,
utils.OptsCDRsExport); err != nil {
return
}
if export {
@@ -300,12 +281,8 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (e
var thdS bool
for _, cgrEv := range cgrEvs {
if v, has := cgrEv.APIOpts[utils.OptsThresholdS]; !has {
if thdS, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
cdrS.cfg.CdrsCfg().Opts.Thresholds); err != nil {
return
}
} else if thdS, err = utils.IfaceAsBool(v); err != nil {
if thdS, err = GetBoolOpts(ctx, cgrEv.Tenant, cgrEv, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Thresholds,
utils.OptsThresholdS); err != nil {
return
}
if thdS {
@@ -320,12 +297,8 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (e
var stS bool
for _, cgrEv := range cgrEvs {
if v, has := cgrEv.APIOpts[utils.OptsStatS]; !has {
if stS, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
cdrS.cfg.CdrsCfg().Opts.Stats); err != nil {
return
}
} else if stS, err = utils.IfaceAsBool(v); err != nil {
if stS, err = GetBoolOpts(ctx, cgrEv.Tenant, cgrEv, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Stats,
utils.OptsStatS); err != nil {
return
}
if stS {

62
engine/resources.go
View File

@@ -672,18 +672,14 @@ func (rS *ResourceService) V1ResourcesForEvent(ctx *context.Context, args *utils
}
var usageID string
if usageID, err = FilterStringCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
rS.cgrcfg.ResourceSCfg().Opts.UsageID); err != nil {
if usageID, err = GetStringOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageID,
utils.OptsResourcesUsageID); err != nil {
return
}
usageID = args.OptsAsString(usageID, utils.OptsResourcesUsageID)
var ttl time.Duration
if ttl, err = FilterDurationCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
rS.cgrcfg.ResourceSCfg().Opts.UsageTTL); err != nil {
return
}
if ttl, err = args.OptsAsDuration(ttl, utils.OptsResourcesUsageTTL); err != nil {
if ttl, err = GetDurationOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageTTL,
utils.OptsResourcesUsageTTL); err != nil {
return
}
usageTTL := utils.DurationPointer(ttl)
@@ -734,27 +730,20 @@ func (rS *ResourceService) V1AuthorizeResources(ctx *context.Context, args *util
}
var usageID string
if usageID, err = FilterStringCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
rS.cgrcfg.ResourceSCfg().Opts.UsageID); err != nil {
if usageID, err = GetStringOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageID,
utils.OptsResourcesUsageID); err != nil {
return
}
usageID = args.OptsAsString(usageID, utils.OptsResourcesUsageID)
var units float64
if units, err = FilterFloat64CfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
rS.cgrcfg.ResourceSCfg().Opts.Units); err != nil {
return
}
if units, err = args.OptsAsFloat64(units, utils.OptsResourcesUnits); err != nil {
if units, err = GetFloat64Opts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.Units,
utils.OptsResourcesUnits); err != nil {
return
}
var ttl time.Duration
if ttl, err = FilterDurationCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
rS.cgrcfg.ResourceSCfg().Opts.UsageTTL); err != nil {
return
}
if ttl, err = args.OptsAsDuration(ttl, utils.OptsResourcesUsageTTL); err != nil {
if ttl, err = GetDurationOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageTTL,
utils.OptsResourcesUsageTTL); err != nil {
return
}
usageTTL := utils.DurationPointer(ttl)
@@ -817,27 +806,20 @@ func (rS *ResourceService) V1AllocateResources(ctx *context.Context, args *utils
}
var usageID string
if usageID, err = FilterStringCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
rS.cgrcfg.ResourceSCfg().Opts.UsageID); err != nil {
if usageID, err = GetStringOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageID,
utils.OptsResourcesUsageID); err != nil {
return
}
usageID = args.OptsAsString(usageID, utils.OptsResourcesUsageID)
var units float64
if units, err = FilterFloat64CfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
rS.cgrcfg.ResourceSCfg().Opts.Units); err != nil {
return
}
if units, err = args.OptsAsFloat64(units, utils.OptsResourcesUnits); err != nil {
if units, err = GetFloat64Opts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.Units,
utils.OptsResourcesUnits); err != nil {
return
}
var ttl time.Duration
if ttl, err = FilterDurationCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
rS.cgrcfg.ResourceSCfg().Opts.UsageTTL); err != nil {
return
}
if ttl, err = args.OptsAsDuration(ttl, utils.OptsResourcesUsageTTL); err != nil {
if ttl, err = GetDurationOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageTTL,
utils.OptsResourcesUsageTTL); err != nil {
return
}
usageTTL := utils.DurationPointer(ttl)
@@ -904,18 +886,14 @@ func (rS *ResourceService) V1ReleaseResources(ctx *context.Context, args *utils.
}
var usageID string
if usageID, err = FilterStringCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
rS.cgrcfg.ResourceSCfg().Opts.UsageID); err != nil {
if usageID, err = GetStringOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageID,
utils.OptsResourcesUsageID); err != nil {
return
}
usageID = args.OptsAsString(usageID, utils.OptsResourcesUsageID)
var ttl time.Duration
if ttl, err = FilterDurationCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
rS.cgrcfg.ResourceSCfg().Opts.UsageTTL); err != nil {
return
}
if ttl, err = args.OptsAsDuration(ttl, utils.OptsResourcesUsageTTL); err != nil {
if ttl, err = GetDurationOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageTTL,
utils.OptsResourcesUsageTTL); err != nil {
return
}
usageTTL := utils.DurationPointer(ttl)

57
engine/routes.go
View File

@@ -185,45 +185,27 @@ func (rpS *RouteService) matchingRouteProfilesForEvent(ctx *context.Context, tnt
func newOptsGetRoutes(ctx *context.Context, ev *utils.CGREvent, fS *FilterS, def *config.RoutesOpts) (opts *optsGetRoutes, err error) {
var ignoreErrors bool
if ignoreErrors, err = FilterBoolCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), fS,
def.IgnoreErrors); err != nil {
if ignoreErrors, err = GetBoolOpts(ctx, ev.Tenant, ev, fS, def.IgnoreErrors,
utils.OptsRoutesIgnoreErrors); err != nil {
return
}
opts = &optsGetRoutes{
ignoreErrors: utils.OptAsBoolOrDef(ev.APIOpts, utils.OptsRoutesIgnoreErrors, ignoreErrors),
ignoreErrors: ignoreErrors,
paginator: &utils.Paginator{},
}
var limit int
if limit, err = FilterIntCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), fS,
def.Limit); err != nil {
if err == utils.ErrNotFound {
if limitOpt, has := ev.APIOpts[utils.OptsRoutesLimit]; has {
var limitValue int64
limitValue, err = utils.IfaceAsTInt64(limitOpt)
if err != nil {
return
}
opts.paginator.Limit = utils.IntPointer(int(limitValue))
}
} else {
if limit, err = GetIntOpts(ctx, ev.Tenant, ev, fS, def.Limit,
utils.OptsRoutesLimit); err != nil {
if err != utils.ErrNotFound {
return
}
} else {
opts.paginator.Limit = utils.IntPointer(limit)
}
var offset int
if offset, err = FilterIntCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), fS,
def.Offset); err != nil {
if err == utils.ErrNotFound {
if offsetOpt, has := ev.APIOpts[utils.OptsRoutesOffset]; has {
var offsetValue int64
offsetValue, err = utils.IfaceAsTInt64(offsetOpt)
if err != nil {
return
}
opts.paginator.Offset = utils.IntPointer(int(offsetValue))
}
} else {
if offset, err = GetIntOpts(ctx, ev.Tenant, ev, fS, def.Offset,
utils.OptsRoutesOffset); err != nil {
if err != utils.ErrNotFound {
return
}
} else {
@@ -231,11 +213,10 @@ func newOptsGetRoutes(ctx *context.Context, ev *utils.CGREvent, fS *FilterS, def
}
var maxCost interface{}
if maxCost, err = FilterInterfaceCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), fS,
def.MaxCost); err != nil {
if maxCost, err = GetInterfaceOpts(ctx, ev.Tenant, ev, fS, def.MaxCost,
utils.OptsRoutesMaxCost); err != nil {
return
}
maxCost = ev.OptsAsInterface(maxCost, utils.OptsRoutesMaxCost)
switch maxCost {
case utils.EmptyString, nil:
@@ -289,14 +270,11 @@ func (rpS *RouteService) V1GetRoutes(ctx *context.Context, args *utils.CGREvent,
}
args.APIOpts[utils.Subsys] = utils.MetaRoutes
var context string
if context, err = FilterStringCfgOpts(ctx, tnt, args.AsDataProvider(), rpS.filterS,
rpS.cfg.RouteSCfg().Opts.Context); err != nil {
if context, err = GetStringOpts(ctx, tnt, args, rpS.filterS, rpS.cfg.RouteSCfg().Opts.Context,
utils.OptsContext); err != nil {
return
}
args.APIOpts[utils.OptsContext] = utils.FirstNonEmpty(
utils.IfaceAsString(args.APIOpts[utils.OptsContext]),
context,
utils.MetaRoutes)
args.APIOpts[utils.OptsContext] = context
var rplyEv AttrSProcessEventReply
if err := rpS.connMgr.Call(ctx, rpS.cfg.RouteSCfg().AttributeSConns,
utils.AttributeSv1ProcessEvent, args, &rplyEv); err == nil && len(rplyEv.AlteredFields) != 0 {
@@ -409,11 +387,8 @@ func (rpS *RouteService) sortedRoutesForEvent(ctx *context.Context, tnt string,
}
prfCount := len(rPrfs) // if the option is not present return for all profiles
var prfCountOpt int
if prfCountOpt, err = FilterIntCfgOpts(ctx, tnt, args.AsDataProvider(), rpS.filterS,
rpS.cfg.RouteSCfg().Opts.ProfileCount); err != nil {
return
}
if prfCountOpt, err = args.OptsAsInt(prfCountOpt, utils.OptsRoutesProfileCount); err != nil {
if prfCountOpt, err = GetIntOpts(ctx, tnt, args, rpS.filterS, rpS.cfg.RouteSCfg().Opts.ProfileCount,
utils.OptsRoutesProfileCount); err != nil {
return
}
if prfCount > prfCountOpt { // it has the option and is smaller that the current number of profiles

13
engine/stats.go
View File

@@ -337,11 +337,8 @@ func (sS *StatService) processEvent(ctx *context.Context, tnt string, args *Stat
utils.MetaOpts: args.APIOpts,
}
var sqIDs []string
if sqIDs, err = FilterStringSliceCfgOpts(ctx, tnt, args.AsDataProvider(), sS.filterS,
sS.cgrcfg.StatSCfg().Opts.StatIDs); err != nil {
return
}
if sqIDs, err = args.OptsAsStringSlice(sqIDs, utils.OptsStatsStatIDs); err != nil {
if sqIDs, err = GetStringSliceOpts(ctx, tnt, args.CGREvent, sS.filterS, sS.cgrcfg.StatSCfg().Opts.StatIDs,
utils.OptsStatsStatIDs); err != nil {
return
}
matchSQs, err := sS.matchingStatQueuesForEvent(ctx, tnt, sqIDs, evNm)
@@ -406,10 +403,8 @@ func (sS *StatService) V1GetStatQueuesForEvent(ctx *context.Context, args *Stats
tnt = sS.cgrcfg.GeneralCfg().DefaultTenant
}
var sqIDs []string
if sqIDs, err = FilterStringSliceCfgOpts(ctx, tnt, args.AsDataProvider(), sS.filterS,
sS.cgrcfg.StatSCfg().Opts.StatIDs); err != nil {
}
if sqIDs, err = args.OptsAsStringSlice(sqIDs, utils.OptsStatsStatIDs); err != nil {
if sqIDs, err = GetStringSliceOpts(ctx, tnt, args.CGREvent, sS.filterS, sS.cgrcfg.StatSCfg().Opts.StatIDs,
utils.OptsStatsStatIDs); err != nil {
return
}
var sQs StatQueues

12
engine/thresholds.go
View File

@@ -330,19 +330,11 @@ func (tS *ThresholdService) matchingThresholdsForEvent(ctx *context.Context, tnt
utils.MetaOpts: args.APIOpts,
}
var thIDs []string
if thIDs, err = FilterStringSliceCfgOpts(ctx, tnt, args.AsDataProvider(), tS.filterS,
tS.cgrcfg.ThresholdSCfg().Opts.ThresholdIDs); err != nil {
return
}
if thIDs, err = args.OptsAsStringSlice(thIDs, utils.OptsThresholdsThresholdIDs); err != nil {
if thIDs, err = GetStringSliceOpts(ctx, tnt, args, tS.filterS, tS.cgrcfg.ThresholdSCfg().Opts.ThresholdIDs,
utils.OptsThresholdsThresholdIDs); err != nil {
return
}
if args.APIOpts[utils.OptsThresholdsThresholdIDs] != nil {
if thIDs, err = utils.IfaceAsStringSlice(args.APIOpts[utils.OptsThresholdsThresholdIDs]); err != nil {
return
}
}
tIDs := utils.NewStringSet(thIDs)
if len(tIDs) == 0 {
tIDs, err = MatchingItemIDsForEvent(ctx, evNm,

21
rates/rates.go
View File

@@ -178,11 +178,8 @@ func (rS *RateS) rateProfileCostForEvent(ctx *context.Context, rtPfl *utils.Rate
return
}
var usage *decimal.Big
if usage, err = engine.FilterDecimalBigCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
rS.cfg.RateSCfg().Opts.Usage); err != nil {
return
}
if usage, err = args.OptsAsDecimal(usage, utils.OptsRatesUsage, utils.MetaUsage); err != nil {
if usage, err = engine.GetDecimalBigOpts(ctx, args.Tenant, args, rS.filterS, rS.cfg.RateSCfg().Opts.Usage,
utils.OptsRatesUsage, utils.MetaUsage); err != nil {
return
}
var ordRts []*orderedRate
@@ -200,11 +197,8 @@ func (rS *RateS) rateProfileCostForEvent(ctx *context.Context, rtPfl *utils.Rate
rpCost.MaxCost = rtPfl.MaxCost
}
var ivalStart *decimal.Big
if ivalStart, err = engine.FilterDecimalBigCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
rS.cfg.RateSCfg().Opts.IntervalStart); err != nil {
return
}
if ivalStart, err = args.OptsAsDecimal(ivalStart, utils.OptsRatesIntervalStart); err != nil {
if ivalStart, err = engine.GetDecimalBigOpts(ctx, args.Tenant, args, rS.filterS, rS.cfg.RateSCfg().Opts.IntervalStart,
utils.OptsRatesIntervalStart); err != nil {
return
}
var costIntervals []*utils.RateSInterval
@@ -224,11 +218,8 @@ func (rS *RateS) rateProfileCostForEvent(ctx *context.Context, rtPfl *utils.Rate
// V1CostForEvent will be called to calculate the cost for an event
func (rS *RateS) V1CostForEvent(ctx *context.Context, args *utils.CGREvent, rpCost *utils.RateProfileCost) (err error) {
var rPfIDs []string
if rPfIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
rS.cfg.RateSCfg().Opts.RateProfileIDs); err != nil {
return
}
if rPfIDs, err = args.OptsAsStringSlice(rPfIDs, utils.OptsRatesRateProfileIDs); err != nil {
if rPfIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, rS.filterS, rS.cfg.RateSCfg().Opts.RateProfileIDs,
utils.OptsRatesRateProfileIDs); err != nil {
return
}
var rtPrl *utils.RateProfile