diff --git a/agents/agentreq.go b/agents/agentreq.go index 9ad7e5789..96928f84d 100644 --- a/agents/agentreq.go +++ b/agents/agentreq.go @@ -532,10 +532,12 @@ func (ar *AgentRequest) setCGRReply(rply utils.NavigableMapper, errRply error) ( return } -func needsMaxUsage(ralsFlags []string) bool { - for _, flag := range ralsFlags { - if utils.IsSliceMember([]string{utils.MetaAuthorize, utils.MetaInitiate, utils.MetaUpdate}, - flag) { +func needsMaxUsage(ralsFlags utils.FlagParams) bool { + if len(ralsFlags) == 0 { + return false + } + for _, flag := range []string{utils.MetaAuthorize, utils.MetaInitiate, utils.MetaUpdate} { + if ralsFlags.Has(flag) { return true } } diff --git a/agents/agentreq_test.go b/agents/agentreq_test.go index 8c7fbd42b..7f1a9c03d 100644 --- a/agents/agentreq_test.go +++ b/agents/agentreq_test.go @@ -2171,3 +2171,20 @@ func BenchmarkAgReqSetField(b *testing.B) { } } } + +func TestNeedsMaxUsage(t *testing.T) { + if needsMaxUsage(nil) { + t.Error("Expected empty flag to not need maxUsage") + } + + if needsMaxUsage(utils.FlagParams{}) { + t.Error("Expected empty flag to not need maxUsage") + } + + if needsMaxUsage(utils.FlagParams{utils.MetaIDs: {"ID1", "ID2"}}) { + t.Error("Expected flag to not need maxUsage") + } + if !needsMaxUsage(utils.FlagParams{utils.MetaIDs: {"ID1", "ID2"}, utils.MetaInitiate: {}}) { + t.Error("Expected flag to need maxUsage") + } +} diff --git a/agents/diamagent.go b/agents/diamagent.go index cf5038d5d..9017892d5 100644 --- a/agents/diamagent.go +++ b/agents/diamagent.go @@ -298,20 +298,20 @@ func (da *DiameterAgent) processRequest(reqProcessor *config.RequestProcessor, utils.MetaInitiate, utils.MetaUpdate, utils.MetaTerminate, utils.MetaMessage, utils.MetaCDRs, utils.MetaEvent, utils.META_NONE} { - if reqProcessor.Flags.HasKey(typ) { // request type is identified through flags + if reqProcessor.Flags.Has(typ) { // request type is identified through flags reqType = typ break } } var cgrArgs utils.ExtractedArgs - if cgrArgs, err = utils.ExtractArgsFromOpts(opts, reqProcessor.Flags.HasKey(utils.MetaDispatchers), + if cgrArgs, err = utils.ExtractArgsFromOpts(opts, reqProcessor.Flags.Has(utils.MetaDispatchers), reqType == utils.MetaAuthorize || reqType == utils.MetaMessage || reqType == utils.MetaEvent); err != nil { utils.Logger.Warning(fmt.Sprintf("<%s> args extraction failed because <%s>", utils.DiameterAgent, err.Error())) err = nil // reset the error and continue the processing } - if reqProcessor.Flags.HasKey(utils.MetaLog) { + if reqProcessor.Flags.Has(utils.MetaLog) { utils.Logger.Info( fmt.Sprintf("<%s> LOG, processorID: %s, diameter message: %s", utils.DiameterAgent, reqProcessor.ID, agReq.Request.String())) @@ -326,19 +326,19 @@ func (da *DiameterAgent) processRequest(reqProcessor *config.RequestProcessor, utils.DiameterAgent, reqProcessor.ID, agReq.Request.String())) case utils.MetaAuthorize: authArgs := sessions.NewV1AuthorizeArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaAccounts), - reqProcessor.Flags.HasKey(utils.MetaRoutes), - reqProcessor.Flags.HasKey(utils.MetaRoutesIgnoreErrors), - reqProcessor.Flags.HasKey(utils.MetaRoutesEventCost), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaRoutes), + reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors), + reqProcessor.Flags.Has(utils.MetaRoutesEventCost), cgrEv, cgrArgs.ArgDispatcher, *cgrArgs.RoutePaginator, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts, ) rply := new(sessions.V1AuthorizeReply) @@ -349,16 +349,16 @@ func (da *DiameterAgent) processRequest(reqProcessor *config.RequestProcessor, } case utils.MetaInitiate: initArgs := sessions.NewV1InitSessionArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaAccounts), cgrEv, cgrArgs.ArgDispatcher, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1InitSessionReply) err = da.connMgr.Call(da.cgrCfg.DiameterAgentCfg().SessionSConns, da, utils.SessionSv1InitiateSession, @@ -368,11 +368,11 @@ func (da *DiameterAgent) processRequest(reqProcessor *config.RequestProcessor, } case utils.MetaUpdate: updateArgs := sessions.NewV1UpdateSessionArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaAccounts), cgrEv, cgrArgs.ArgDispatcher, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1UpdateSessionReply) err = da.connMgr.Call(da.cgrCfg.DiameterAgentCfg().SessionSConns, da, utils.SessionSv1UpdateSession, @@ -382,14 +382,14 @@ func (da *DiameterAgent) processRequest(reqProcessor *config.RequestProcessor, } case utils.MetaTerminate: terminateArgs := sessions.NewV1TerminateSessionArgs( - reqProcessor.Flags.HasKey(utils.MetaAccounts), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), + reqProcessor.Flags.Has(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), cgrEv, cgrArgs.ArgDispatcher, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := utils.StringPointer("") err = da.connMgr.Call(da.cgrCfg.DiameterAgentCfg().SessionSConns, da, utils.SessionSv1TerminateSession, @@ -399,19 +399,19 @@ func (da *DiameterAgent) processRequest(reqProcessor *config.RequestProcessor, } case utils.MetaMessage: msgArgs := sessions.NewV1ProcessMessageArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaAccounts), - reqProcessor.Flags.HasKey(utils.MetaRoutes), - reqProcessor.Flags.HasKey(utils.MetaRoutesIgnoreErrors), - reqProcessor.Flags.HasKey(utils.MetaRoutesEventCost), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaRoutes), + reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors), + reqProcessor.Flags.Has(utils.MetaRoutesEventCost), cgrEv, cgrArgs.ArgDispatcher, *cgrArgs.RoutePaginator, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1ProcessMessageReply) err = da.connMgr.Call(da.cgrCfg.DiameterAgentCfg().SessionSConns, da, utils.SessionSv1ProcessMessage, @@ -437,7 +437,7 @@ func (da *DiameterAgent) processRequest(reqProcessor *config.RequestProcessor, evArgs, rply) if utils.ErrHasPrefix(err, utils.RalsErrorPrfx) { cgrEv.Event[utils.Usage] = 0 // avoid further debits - } else if needsMaxUsage(reqProcessor.Flags.ParamsSlice(utils.MetaRALs)) { + } else if needsMaxUsage(reqProcessor.Flags[utils.MetaRALs]) { cgrEv.Event[utils.Usage] = rply.MaxUsage // make sure the CDR reflects the debit } if err = agReq.setCGRReply(rply, err); err != nil { @@ -446,8 +446,8 @@ func (da *DiameterAgent) processRequest(reqProcessor *config.RequestProcessor, case utils.MetaCDRs: // allow CDR processing } // separate request so we can capture the Terminate/Event also here - if reqProcessor.Flags.HasKey(utils.MetaCDRs) && - !reqProcessor.Flags.HasKey(utils.MetaDryRun) { + if reqProcessor.Flags.Has(utils.MetaCDRs) && + !reqProcessor.Flags.Has(utils.MetaDryRun) { rplyCDRs := utils.StringPointer("") if err = da.connMgr.Call(da.cgrCfg.DiameterAgentCfg().SessionSConns, da, utils.SessionSv1ProcessCDR, &utils.CGREventWithArgDispatcher{CGREvent: cgrEv, @@ -458,7 +458,7 @@ func (da *DiameterAgent) processRequest(reqProcessor *config.RequestProcessor, if err = agReq.SetFields(reqProcessor.ReplyFields); err != nil { return } - if reqProcessor.Flags.HasKey(utils.MetaLog) { + if reqProcessor.Flags.Has(utils.MetaLog) { utils.Logger.Info( fmt.Sprintf("<%s> LOG, Diameter reply: %s", utils.DiameterAgent, agReq.Reply)) diff --git a/agents/diamagent_test.go b/agents/diamagent_test.go index 1adab643b..923150420 100644 --- a/agents/diamagent_test.go +++ b/agents/diamagent_test.go @@ -439,7 +439,7 @@ func TestProcessRequest(t *testing.T) { return nil }, }} - reqProcessor.Flags, _ = utils.FlagsWithParamsFromSlice([]string{utils.MetaAuthorize, utils.MetaAccounts}) + reqProcessor.Flags = utils.FlagsWithParamsFromSlice([]string{utils.MetaAuthorize, utils.MetaAccounts}) agReq := NewAgentRequest(diamDP, reqVars, &cgrRplyNM, rply, nil, reqProcessor.Tenant, config.CgrConfig().GeneralCfg().DefaultTenant, config.CgrConfig().GeneralCfg().DefaultTimezone, filters, nil, nil) @@ -463,7 +463,7 @@ func TestProcessRequest(t *testing.T) { t.Errorf("Expected the reply to have 2 values received: %s", rply.String()) } - reqProcessor.Flags, _ = utils.FlagsWithParamsFromSlice([]string{utils.MetaInitiate, utils.MetaAccounts, utils.MetaAttributes}) + reqProcessor.Flags = utils.FlagsWithParamsFromSlice([]string{utils.MetaInitiate, utils.MetaAccounts, utils.MetaAttributes}) cgrRplyNM = utils.NavigableMap2{} rply = utils.NewOrderedNavigableMap() @@ -480,7 +480,7 @@ func TestProcessRequest(t *testing.T) { t.Errorf("Expected the reply to have 2 values received: %s", rply.String()) } - reqProcessor.Flags, _ = utils.FlagsWithParamsFromSlice([]string{utils.MetaUpdate, utils.MetaAccounts, utils.MetaAttributes}) + reqProcessor.Flags = utils.FlagsWithParamsFromSlice([]string{utils.MetaUpdate, utils.MetaAccounts, utils.MetaAttributes}) cgrRplyNM = utils.NavigableMap2{} rply = utils.NewOrderedNavigableMap() @@ -497,7 +497,7 @@ func TestProcessRequest(t *testing.T) { t.Errorf("Expected the reply to have 2 values received: %s", rply.String()) } - reqProcessor.Flags, _ = utils.FlagsWithParamsFromSlice([]string{utils.MetaTerminate, utils.MetaAccounts, utils.MetaAttributes, utils.MetaCDRs}) + reqProcessor.Flags = utils.FlagsWithParamsFromSlice([]string{utils.MetaTerminate, utils.MetaAccounts, utils.MetaAttributes, utils.MetaCDRs}) reqProcessor.ReplyFields = []*config.FCTemplate{{Tag: "ResultCode", Type: utils.META_CONSTANT, Path: utils.MetaRep + utils.NestingSep + "ResultCode", Value: config.NewRSRParsersMustCompile("2001", utils.INFIELD_SEP)}} @@ -520,7 +520,7 @@ func TestProcessRequest(t *testing.T) { t.Errorf("Expected the reply to have one value received: %s", rply.String()) } - reqProcessor.Flags, _ = utils.FlagsWithParamsFromSlice([]string{utils.MetaMessage, utils.MetaAccounts, utils.MetaAttributes}) + reqProcessor.Flags = utils.FlagsWithParamsFromSlice([]string{utils.MetaMessage, utils.MetaAccounts, utils.MetaAttributes}) cgrRplyNM = utils.NavigableMap2{} rply = utils.NewOrderedNavigableMap() diff --git a/agents/dnsagent.go b/agents/dnsagent.go index d06c3ec52..413bf398d 100644 --- a/agents/dnsagent.go +++ b/agents/dnsagent.go @@ -185,19 +185,19 @@ func (da *DNSAgent) processRequest(reqProcessor *config.RequestProcessor, utils.MetaInitiate, utils.MetaUpdate, utils.MetaTerminate, utils.MetaMessage, utils.MetaCDRs, utils.MetaEvent, utils.META_NONE} { - if reqProcessor.Flags.HasKey(typ) { // request type is identified through flags + if reqProcessor.Flags.Has(typ) { // request type is identified through flags reqType = typ break } } var cgrArgs utils.ExtractedArgs - if cgrArgs, err = utils.ExtractArgsFromOpts(opts, reqProcessor.Flags.HasKey(utils.MetaDispatchers), + if cgrArgs, err = utils.ExtractArgsFromOpts(opts, reqProcessor.Flags.Has(utils.MetaDispatchers), reqType == utils.MetaAuthorize || reqType == utils.MetaMessage || reqType == utils.MetaEvent); err != nil { utils.Logger.Warning(fmt.Sprintf("<%s> args extraction failed because <%s>", utils.DNSAgent, err.Error())) err = nil // reset the error and continue the processing } - if reqProcessor.Flags.HasKey(utils.MetaLog) { + if reqProcessor.Flags.Has(utils.MetaLog) { utils.Logger.Info( fmt.Sprintf("<%s> LOG, processorID: <%s>, message: %s", utils.DNSAgent, reqProcessor.ID, agReq.Request.String())) @@ -212,19 +212,19 @@ func (da *DNSAgent) processRequest(reqProcessor *config.RequestProcessor, utils.DNSAgent, reqProcessor.ID, utils.ToJSON(cgrEv))) case utils.MetaAuthorize: authArgs := sessions.NewV1AuthorizeArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaAccounts), - reqProcessor.Flags.HasKey(utils.MetaRoutes), - reqProcessor.Flags.HasKey(utils.MetaRoutesIgnoreErrors), - reqProcessor.Flags.HasKey(utils.MetaRoutesEventCost), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaRoutes), + reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors), + reqProcessor.Flags.Has(utils.MetaRoutesEventCost), cgrEv, cgrArgs.ArgDispatcher, *cgrArgs.RoutePaginator, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts, ) rply := new(sessions.V1AuthorizeReply) @@ -236,16 +236,16 @@ func (da *DNSAgent) processRequest(reqProcessor *config.RequestProcessor, } case utils.MetaInitiate: initArgs := sessions.NewV1InitSessionArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaAccounts), cgrEv, cgrArgs.ArgDispatcher, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1InitSessionReply) err = da.connMgr.Call(da.cgrCfg.DNSAgentCfg().SessionSConns, nil, @@ -256,11 +256,11 @@ func (da *DNSAgent) processRequest(reqProcessor *config.RequestProcessor, } case utils.MetaUpdate: updateArgs := sessions.NewV1UpdateSessionArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaAccounts), cgrEv, cgrArgs.ArgDispatcher, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1UpdateSessionReply) err = da.connMgr.Call(da.cgrCfg.DNSAgentCfg().SessionSConns, nil, @@ -271,14 +271,14 @@ func (da *DNSAgent) processRequest(reqProcessor *config.RequestProcessor, } case utils.MetaTerminate: terminateArgs := sessions.NewV1TerminateSessionArgs( - reqProcessor.Flags.HasKey(utils.MetaAccounts), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), + reqProcessor.Flags.Has(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), cgrEv, cgrArgs.ArgDispatcher, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := utils.StringPointer("") err = da.connMgr.Call(da.cgrCfg.DNSAgentCfg().SessionSConns, nil, @@ -289,19 +289,19 @@ func (da *DNSAgent) processRequest(reqProcessor *config.RequestProcessor, } case utils.MetaMessage: evArgs := sessions.NewV1ProcessMessageArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaAccounts), - reqProcessor.Flags.HasKey(utils.MetaRoutes), - reqProcessor.Flags.HasKey(utils.MetaRoutesIgnoreErrors), - reqProcessor.Flags.HasKey(utils.MetaRoutesEventCost), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaRoutes), + reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors), + reqProcessor.Flags.Has(utils.MetaRoutesEventCost), cgrEv, cgrArgs.ArgDispatcher, *cgrArgs.RoutePaginator, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1ProcessMessageReply) // need it so rpcclient can clone err = da.connMgr.Call(da.cgrCfg.DNSAgentCfg().SessionSConns, nil, @@ -329,7 +329,7 @@ func (da *DNSAgent) processRequest(reqProcessor *config.RequestProcessor, evArgs, rply) if utils.ErrHasPrefix(err, utils.RalsErrorPrfx) { cgrEv.Event[utils.Usage] = 0 // avoid further debits - } else if needsMaxUsage(reqProcessor.Flags.ParamsSlice(utils.MetaRALs)) { + } else if needsMaxUsage(reqProcessor.Flags[utils.MetaRALs]) { cgrEv.Event[utils.Usage] = rply.MaxUsage // make sure the CDR reflects the debit } if err = agReq.setCGRReply(rply, err); err != nil { @@ -338,8 +338,8 @@ func (da *DNSAgent) processRequest(reqProcessor *config.RequestProcessor, case utils.MetaCDRs: // allow CDR processing } // separate request so we can capture the Terminate/Event also here - if reqProcessor.Flags.HasKey(utils.MetaCDRs) && - !reqProcessor.Flags.HasKey(utils.MetaDryRun) { + if reqProcessor.Flags.Has(utils.MetaCDRs) && + !reqProcessor.Flags.Has(utils.MetaDryRun) { rplyCDRs := utils.StringPointer("") if err = da.connMgr.Call(da.cgrCfg.DNSAgentCfg().SessionSConns, nil, utils.SessionSv1ProcessCDR, @@ -351,7 +351,7 @@ func (da *DNSAgent) processRequest(reqProcessor *config.RequestProcessor, if err := agReq.SetFields(reqProcessor.ReplyFields); err != nil { return false, err } - if reqProcessor.Flags.HasKey(utils.MetaLog) { + if reqProcessor.Flags.Has(utils.MetaLog) { utils.Logger.Info( fmt.Sprintf("<%s> LOG, reply: %s", utils.DNSAgent, agReq.Reply)) diff --git a/agents/httpagent.go b/agents/httpagent.go index 608f13fbb..202d10502 100644 --- a/agents/httpagent.go +++ b/agents/httpagent.go @@ -120,19 +120,19 @@ func (ha *HTTPAgent) processRequest(reqProcessor *config.RequestProcessor, utils.MetaInitiate, utils.MetaUpdate, utils.MetaTerminate, utils.MetaMessage, utils.MetaCDRs, utils.MetaEvent, utils.MetaEmpty} { - if reqProcessor.Flags.HasKey(typ) { // request type is identified through flags + if reqProcessor.Flags.Has(typ) { // request type is identified through flags reqType = typ break } } var cgrArgs utils.ExtractedArgs - if cgrArgs, err = utils.ExtractArgsFromOpts(opts, reqProcessor.Flags.HasKey(utils.MetaDispatchers), + if cgrArgs, err = utils.ExtractArgsFromOpts(opts, reqProcessor.Flags.Has(utils.MetaDispatchers), reqType == utils.MetaAuthorize || reqType == utils.MetaMessage || reqType == utils.MetaEvent); err != nil { utils.Logger.Warning(fmt.Sprintf("<%s> args extraction failed because <%s>", utils.HTTPAgent, err.Error())) err = nil // reset the error and continue the processing } - if reqProcessor.Flags.HasKey(utils.MetaLog) { + if reqProcessor.Flags.Has(utils.MetaLog) { utils.Logger.Info( fmt.Sprintf("<%s> LOG, processorID: %s, http message: %s", utils.HTTPAgent, reqProcessor.ID, agReq.Request.String())) @@ -147,19 +147,19 @@ func (ha *HTTPAgent) processRequest(reqProcessor *config.RequestProcessor, utils.HTTPAgent, reqProcessor.ID, utils.ToJSON(cgrEv))) case utils.MetaAuthorize: authArgs := sessions.NewV1AuthorizeArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaAccounts), - reqProcessor.Flags.HasKey(utils.MetaRoutes), - reqProcessor.Flags.HasKey(utils.MetaRoutesIgnoreErrors), - reqProcessor.Flags.HasKey(utils.MetaRoutesEventCost), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaRoutes), + reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors), + reqProcessor.Flags.Has(utils.MetaRoutesEventCost), cgrEv, cgrArgs.ArgDispatcher, *cgrArgs.RoutePaginator, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts, ) rply := new(sessions.V1AuthorizeReply) @@ -170,16 +170,16 @@ func (ha *HTTPAgent) processRequest(reqProcessor *config.RequestProcessor, } case utils.MetaInitiate: initArgs := sessions.NewV1InitSessionArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaAccounts), cgrEv, cgrArgs.ArgDispatcher, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1InitSessionReply) err = ha.connMgr.Call(ha.sessionConns, nil, utils.SessionSv1InitiateSession, @@ -189,11 +189,11 @@ func (ha *HTTPAgent) processRequest(reqProcessor *config.RequestProcessor, } case utils.MetaUpdate: updateArgs := sessions.NewV1UpdateSessionArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaAccounts), cgrEv, cgrArgs.ArgDispatcher, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1UpdateSessionReply) err = ha.connMgr.Call(ha.sessionConns, nil, utils.SessionSv1UpdateSession, @@ -203,14 +203,14 @@ func (ha *HTTPAgent) processRequest(reqProcessor *config.RequestProcessor, } case utils.MetaTerminate: terminateArgs := sessions.NewV1TerminateSessionArgs( - reqProcessor.Flags.HasKey(utils.MetaAccounts), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), + reqProcessor.Flags.Has(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), cgrEv, cgrArgs.ArgDispatcher, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := utils.StringPointer("") err = ha.connMgr.Call(ha.sessionConns, nil, utils.SessionSv1TerminateSession, @@ -220,19 +220,19 @@ func (ha *HTTPAgent) processRequest(reqProcessor *config.RequestProcessor, } case utils.MetaMessage: evArgs := sessions.NewV1ProcessMessageArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaAccounts), - reqProcessor.Flags.HasKey(utils.MetaRoutes), - reqProcessor.Flags.HasKey(utils.MetaRoutesIgnoreErrors), - reqProcessor.Flags.HasKey(utils.MetaRoutesEventCost), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaRoutes), + reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors), + reqProcessor.Flags.Has(utils.MetaRoutesEventCost), cgrEv, cgrArgs.ArgDispatcher, *cgrArgs.RoutePaginator, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1ProcessMessageReply) err = ha.connMgr.Call(ha.sessionConns, nil, utils.SessionSv1ProcessMessage, @@ -258,7 +258,7 @@ func (ha *HTTPAgent) processRequest(reqProcessor *config.RequestProcessor, evArgs, rply) if utils.ErrHasPrefix(err, utils.RalsErrorPrfx) { cgrEv.Event[utils.Usage] = 0 // avoid further debits - } else if needsMaxUsage(reqProcessor.Flags.ParamsSlice(utils.MetaRALs)) { + } else if needsMaxUsage(reqProcessor.Flags[utils.MetaRALs]) { cgrEv.Event[utils.Usage] = rply.MaxUsage // make sure the CDR reflects the debit } if err = agReq.setCGRReply(rply, err); err != nil { @@ -267,8 +267,8 @@ func (ha *HTTPAgent) processRequest(reqProcessor *config.RequestProcessor, case utils.MetaCDRs: // allow CDR processing } // separate request so we can capture the Terminate/Event also here - if reqProcessor.Flags.HasKey(utils.MetaCDRs) && - !reqProcessor.Flags.HasKey(utils.MetaDryRun) { + if reqProcessor.Flags.Has(utils.MetaCDRs) && + !reqProcessor.Flags.Has(utils.MetaDryRun) { rplyCDRs := utils.StringPointer("") if err = ha.connMgr.Call(ha.sessionConns, nil, utils.SessionSv1ProcessCDR, &utils.CGREventWithArgDispatcher{CGREvent: cgrEv, @@ -280,7 +280,7 @@ func (ha *HTTPAgent) processRequest(reqProcessor *config.RequestProcessor, if err := agReq.SetFields(reqProcessor.ReplyFields); err != nil { return false, err } - if reqProcessor.Flags.HasKey(utils.MetaLog) { + if reqProcessor.Flags.Has(utils.MetaLog) { utils.Logger.Info( fmt.Sprintf("<%s> LOG, HTTP reply: %s", utils.HTTPAgent, agReq.Reply)) diff --git a/agents/librad.go b/agents/librad.go index bb740f850..2111026cf 100644 --- a/agents/librad.go +++ b/agents/librad.go @@ -122,7 +122,7 @@ func radauthReq(flags utils.FlagsWithParams, req *radigo.Packet, aReq *AgentRequ return false, err } switch { - case flags.HasKey(utils.MetaPAP): + case flags.Has(utils.MetaPAP): userPassAvps := req.AttributesWithName(UserPasswordAVP, utils.EmptyString) if len(userPassAvps) == 0 { return false, utils.NewErrMandatoryIeMissing(UserPasswordAVP) @@ -130,14 +130,14 @@ func radauthReq(flags utils.FlagsWithParams, req *radigo.Packet, aReq *AgentRequ if userPassAvps[0].StringValue != (*nmItems.(*utils.NMSlice))[0].Interface() { return false, nil } - case flags.HasKey(utils.MetaCHAP): + case flags.Has(utils.MetaCHAP): chapAVPs := req.AttributesWithName(CHAPPasswordAVP, utils.EmptyString) if len(chapAVPs) == 0 { return false, utils.NewErrMandatoryIeMissing(CHAPPasswordAVP) } return radigo.AuthenticateCHAP([]byte(utils.IfaceAsString((*nmItems.(*utils.NMSlice))[0].Interface())), req.Authenticator[:], chapAVPs[0].RawValue), nil - case flags.HasKey(utils.MetaMSCHAPV2): + case flags.Has(utils.MetaMSCHAPV2): msChallenge := req.AttributesWithName(MSCHAPChallengeAVP, MicrosoftVendor) if len(msChallenge) == 0 { return false, utils.NewErrMandatoryIeMissing(MSCHAPChallengeAVP) diff --git a/agents/radagent.go b/agents/radagent.go index 1bd40e844..f111962b1 100644 --- a/agents/radagent.go +++ b/agents/radagent.go @@ -178,19 +178,19 @@ func (ra *RadiusAgent) processRequest(req *radigo.Packet, reqProcessor *config.R utils.MetaInitiate, utils.MetaUpdate, utils.MetaTerminate, utils.MetaMessage, utils.MetaCDRs, utils.MetaEvent, utils.META_NONE, utils.MetaRadauth} { - if reqProcessor.Flags.HasKey(typ) { // request type is identified through flags + if reqProcessor.Flags.Has(typ) { // request type is identified through flags reqType = typ break } } var cgrArgs utils.ExtractedArgs - if cgrArgs, err = utils.ExtractArgsFromOpts(opts, reqProcessor.Flags.HasKey(utils.MetaDispatchers), + if cgrArgs, err = utils.ExtractArgsFromOpts(opts, reqProcessor.Flags.Has(utils.MetaDispatchers), reqType == utils.MetaAuthorize || reqType == utils.MetaMessage || reqType == utils.MetaEvent); err != nil { utils.Logger.Warning(fmt.Sprintf("<%s> args extraction failed because <%s>", utils.RadiusAgent, err.Error())) err = nil // reset the error and continue the processing } - if reqProcessor.Flags.HasKey(utils.MetaLog) { + if reqProcessor.Flags.Has(utils.MetaLog) { utils.Logger.Info( fmt.Sprintf("<%s> LOG, processorID: %s, radius message: %s", utils.RadiusAgent, reqProcessor.ID, agReq.Request.String())) @@ -205,19 +205,19 @@ func (ra *RadiusAgent) processRequest(req *radigo.Packet, reqProcessor *config.R utils.RadiusAgent, reqProcessor.ID, utils.ToJSON(cgrEv))) case utils.MetaAuthorize: authArgs := sessions.NewV1AuthorizeArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaAccounts), - reqProcessor.Flags.HasKey(utils.MetaRoutes), - reqProcessor.Flags.HasKey(utils.MetaRoutesIgnoreErrors), - reqProcessor.Flags.HasKey(utils.MetaRoutesEventCost), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaRoutes), + reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors), + reqProcessor.Flags.Has(utils.MetaRoutesEventCost), cgrEv, cgrArgs.ArgDispatcher, *cgrArgs.RoutePaginator, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts, ) rply := new(sessions.V1AuthorizeReply) @@ -228,16 +228,16 @@ func (ra *RadiusAgent) processRequest(req *radigo.Packet, reqProcessor *config.R } case utils.MetaInitiate: initArgs := sessions.NewV1InitSessionArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaAccounts), cgrEv, cgrArgs.ArgDispatcher, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1InitSessionReply) err = ra.connMgr.Call(ra.cgrCfg.RadiusAgentCfg().SessionSConns, nil, utils.SessionSv1InitiateSession, @@ -247,11 +247,11 @@ func (ra *RadiusAgent) processRequest(req *radigo.Packet, reqProcessor *config.R } case utils.MetaUpdate: updateArgs := sessions.NewV1UpdateSessionArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaAccounts), cgrEv, cgrArgs.ArgDispatcher, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1UpdateSessionReply) err = ra.connMgr.Call(ra.cgrCfg.RadiusAgentCfg().SessionSConns, nil, utils.SessionSv1UpdateSession, @@ -261,14 +261,14 @@ func (ra *RadiusAgent) processRequest(req *radigo.Packet, reqProcessor *config.R } case utils.MetaTerminate: terminateArgs := sessions.NewV1TerminateSessionArgs( - reqProcessor.Flags.HasKey(utils.MetaAccounts), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), + reqProcessor.Flags.Has(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), cgrEv, cgrArgs.ArgDispatcher, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := utils.StringPointer("") err = ra.connMgr.Call(ra.cgrCfg.RadiusAgentCfg().SessionSConns, nil, utils.SessionSv1TerminateSession, @@ -278,19 +278,19 @@ func (ra *RadiusAgent) processRequest(req *radigo.Packet, reqProcessor *config.R } case utils.MetaMessage: evArgs := sessions.NewV1ProcessMessageArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaAccounts), - reqProcessor.Flags.HasKey(utils.MetaRoutes), - reqProcessor.Flags.HasKey(utils.MetaRoutesIgnoreErrors), - reqProcessor.Flags.HasKey(utils.MetaRoutesEventCost), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaRoutes), + reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors), + reqProcessor.Flags.Has(utils.MetaRoutesEventCost), cgrEv, cgrArgs.ArgDispatcher, *cgrArgs.RoutePaginator, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1ProcessMessageReply) err = ra.connMgr.Call(ra.cgrCfg.RadiusAgentCfg().SessionSConns, nil, utils.SessionSv1ProcessMessage, evArgs, rply) @@ -313,7 +313,7 @@ func (ra *RadiusAgent) processRequest(req *radigo.Packet, reqProcessor *config.R evArgs, rply) if utils.ErrHasPrefix(err, utils.RalsErrorPrfx) { cgrEv.Event[utils.Usage] = 0 // avoid further debits - } else if needsMaxUsage(reqProcessor.Flags.ParamsSlice(utils.MetaRALs)) { + } else if needsMaxUsage(reqProcessor.Flags[utils.MetaRALs]) { cgrEv.Event[utils.Usage] = rply.MaxUsage // make sure the CDR reflects the debit } if err = agReq.setCGRReply(rply, err); err != nil { @@ -328,7 +328,7 @@ func (ra *RadiusAgent) processRequest(req *radigo.Packet, reqProcessor *config.R } } // separate request so we can capture the Terminate/Event also here - if reqProcessor.Flags.HasKey(utils.MetaCDRs) { + if reqProcessor.Flags.Has(utils.MetaCDRs) { rplyCDRs := utils.StringPointer("") if err = ra.connMgr.Call(ra.cgrCfg.RadiusAgentCfg().SessionSConns, nil, utils.SessionSv1ProcessCDR, &utils.CGREventWithArgDispatcher{CGREvent: cgrEv, @@ -342,7 +342,7 @@ func (ra *RadiusAgent) processRequest(req *radigo.Packet, reqProcessor *config.R return false, err } - if reqProcessor.Flags.HasKey(utils.MetaLog) { + if reqProcessor.Flags.Has(utils.MetaLog) { utils.Logger.Info( fmt.Sprintf("<%s> LOG, Radius reply: %s", utils.RadiusAgent, utils.ToIJSON(agReq.Reply))) diff --git a/agents/sipagent.go b/agents/sipagent.go index 341bf57ab..449819958 100644 --- a/agents/sipagent.go +++ b/agents/sipagent.go @@ -385,19 +385,19 @@ func (sa *SIPAgent) processRequest(reqProcessor *config.RequestProcessor, utils.MetaInitiate, utils.MetaUpdate, utils.MetaTerminate, utils.MetaMessage, utils.MetaCDRs, */utils.MetaEvent, utils.META_NONE} { - if reqProcessor.Flags.HasKey(typ) { // request type is identified through flags + if reqProcessor.Flags.Has(typ) { // request type is identified through flags reqType = typ break } } var cgrArgs utils.ExtractedArgs - if cgrArgs, err = utils.ExtractArgsFromOpts(opts, reqProcessor.Flags.HasKey(utils.MetaDispatchers), + if cgrArgs, err = utils.ExtractArgsFromOpts(opts, reqProcessor.Flags.Has(utils.MetaDispatchers), reqType == utils.MetaAuthorize || reqType == utils.MetaMessage || reqType == utils.MetaEvent); err != nil { utils.Logger.Warning(fmt.Sprintf("<%s> args extraction failed because <%s>", utils.SIPAgent, err.Error())) err = nil // reset the error and continue the processing } - if reqProcessor.Flags.HasKey(utils.MetaLog) { + if reqProcessor.Flags.Has(utils.MetaLog) { utils.Logger.Info( fmt.Sprintf("<%s> LOG, processorID: %s, SIP message: %s", utils.SIPAgent, reqProcessor.ID, agReq.Request.String())) @@ -412,19 +412,19 @@ func (sa *SIPAgent) processRequest(reqProcessor *config.RequestProcessor, utils.SIPAgent, reqProcessor.ID, utils.ToJSON(cgrEv))) case utils.MetaAuthorize: authArgs := sessions.NewV1AuthorizeArgs( - reqProcessor.Flags.HasKey(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - reqProcessor.Flags.HasKey(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - reqProcessor.Flags.HasKey(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats), - reqProcessor.Flags.HasKey(utils.MetaResources), - reqProcessor.Flags.HasKey(utils.MetaAccounts), - reqProcessor.Flags.HasKey(utils.MetaRoutes), - reqProcessor.Flags.HasKey(utils.MetaRoutesIgnoreErrors), - reqProcessor.Flags.HasKey(utils.MetaRoutesEventCost), + reqProcessor.Flags.Has(utils.MetaAttributes), + reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaThresholds), + reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaStats), + reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + reqProcessor.Flags.Has(utils.MetaResources), + reqProcessor.Flags.Has(utils.MetaAccounts), + reqProcessor.Flags.Has(utils.MetaRoutes), + reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors), + reqProcessor.Flags.Has(utils.MetaRoutesEventCost), cgrEv, cgrArgs.ArgDispatcher, *cgrArgs.RoutePaginator, - reqProcessor.Flags.HasKey(utils.MetaFD), + reqProcessor.Flags.Has(utils.MetaFD), opts, ) rply := new(sessions.V1AuthorizeReply) @@ -435,16 +435,16 @@ func (sa *SIPAgent) processRequest(reqProcessor *config.RequestProcessor, } // case utils.MetaInitiate: // initArgs := sessions.NewV1InitSessionArgs( - // reqProcessor.Flags.HasKey(utils.MetaAttributes), - // reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - // reqProcessor.Flags.HasKey(utils.MetaThresholds), - // reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - // reqProcessor.Flags.HasKey(utils.MetaStats), - // reqProcessor.Flags.ParamsSlice(utils.MetaStats), - // reqProcessor.Flags.HasKey(utils.MetaResources), - // reqProcessor.Flags.HasKey(utils.MetaAccounts), + // reqProcessor.Flags.Has(utils.MetaAttributes), + // reqProcessor.Flags.ParamsSlice(utils.MetaAttributes,utils.MetaIDs), + // reqProcessor.Flags.Has(utils.MetaThresholds), + // reqProcessor.Flags.ParamsSlice(utils.MetaThresholds,utils.MetaIDs), + // reqProcessor.Flags.Has(utils.MetaStats), + // reqProcessor.Flags.ParamsSlice(utils.MetaStats,utils.MetaIDs), + // reqProcessor.Flags.Has(utils.MetaResources), + // reqProcessor.Flags.Has(utils.MetaAccounts), // cgrEv, cgrArgs.ArgDispatcher, - // reqProcessor.Flags.HasKey(utils.MetaFD), + // reqProcessor.Flags.Has(utils.MetaFD), // opts) // rply := new(sessions.V1InitSessionReply) // err = sa.connMgr.Call(sa.cfg.SIPAgentCfg().SessionSConns, nil, utils.SessionSv1InitiateSession, @@ -454,11 +454,11 @@ func (sa *SIPAgent) processRequest(reqProcessor *config.RequestProcessor, // } // case utils.MetaUpdate: // updateArgs := sessions.NewV1UpdateSessionArgs( - // reqProcessor.Flags.HasKey(utils.MetaAttributes), - // reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - // reqProcessor.Flags.HasKey(utils.MetaAccounts), + // reqProcessor.Flags.Has(utils.MetaAttributes), + // reqProcessor.Flags.ParamsSlice(utils.MetaAttributes,utils.MetaIDs), + // reqProcessor.Flags.Has(utils.MetaAccounts), // cgrEv, cgrArgs.ArgDispatcher, - // reqProcessor.Flags.HasKey(utils.MetaFD), + // reqProcessor.Flags.Has(utils.MetaFD), // opts) // rply := new(sessions.V1UpdateSessionReply) // err = sa.connMgr.Call(sa.cfg.SIPAgentCfg().SessionSConns, nil, utils.SessionSv1UpdateSession, @@ -468,14 +468,14 @@ func (sa *SIPAgent) processRequest(reqProcessor *config.RequestProcessor, // } // case utils.MetaTerminate: // terminateArgs := sessions.NewV1TerminateSessionArgs( - // reqProcessor.Flags.HasKey(utils.MetaAccounts), - // reqProcessor.Flags.HasKey(utils.MetaResources), - // reqProcessor.Flags.HasKey(utils.MetaThresholds), - // reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - // reqProcessor.Flags.HasKey(utils.MetaStats), - // reqProcessor.Flags.ParamsSlice(utils.MetaStats), + // reqProcessor.Flags.Has(utils.MetaAccounts), + // reqProcessor.Flags.Has(utils.MetaResources), + // reqProcessor.Flags.Has(utils.MetaThresholds), + // reqProcessor.Flags.ParamsSlice(utils.MetaThresholds,utils.MetaIDs), + // reqProcessor.Flags.Has(utils.MetaStats), + // reqProcessor.Flags.ParamsSlice(utils.MetaStats,utils.MetaIDs), // cgrEv, cgrArgs.ArgDispatcher, - // reqProcessor.Flags.HasKey(utils.MetaFD), + // reqProcessor.Flags.Has(utils.MetaFD), // opts) // rply := utils.StringPointer("") // err = sa.connMgr.Call(sa.cfg.SIPAgentCfg().SessionSConns, nil, utils.SessionSv1TerminateSession, @@ -485,19 +485,19 @@ func (sa *SIPAgent) processRequest(reqProcessor *config.RequestProcessor, // } // case utils.MetaMessage: // evArgs := sessions.NewV1ProcessMessageArgs( - // reqProcessor.Flags.HasKey(utils.MetaAttributes), - // reqProcessor.Flags.ParamsSlice(utils.MetaAttributes), - // reqProcessor.Flags.HasKey(utils.MetaThresholds), - // reqProcessor.Flags.ParamsSlice(utils.MetaThresholds), - // reqProcessor.Flags.HasKey(utils.MetaStats), - // reqProcessor.Flags.ParamsSlice(utils.MetaStats), - // reqProcessor.Flags.HasKey(utils.MetaResources), - // reqProcessor.Flags.HasKey(utils.MetaAccounts), - // reqProcessor.Flags.HasKey(utils.MetaRoutes), - // reqProcessor.Flags.HasKey(utils.MetaRoutesIgnoreErrors), - // reqProcessor.Flags.HasKey(utils.MetaRoutesEventCost), + // reqProcessor.Flags.Has(utils.MetaAttributes), + // reqProcessor.Flags.ParamsSlice(utils.MetaAttributes,utils.MetaIDs), + // reqProcessor.Flags.Has(utils.MetaThresholds), + // reqProcessor.Flags.ParamsSlice(utils.MetaThresholds,utils.MetaIDs), + // reqProcessor.Flags.Has(utils.MetaStats), + // reqProcessor.Flags.ParamsSlice(utils.MetaStats,utils.MetaIDs), + // reqProcessor.Flags.Has(utils.MetaResources), + // reqProcessor.Flags.Has(utils.MetaAccounts), + // reqProcessor.Flags.Has(utils.MetaRoutes), + // reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors), + // reqProcessor.Flags.Has(utils.MetaRoutesEventCost), // cgrEv, cgrArgs.ArgDispatcher, *cgrArgs.RoutePaginator, - // reqProcessor.Flags.HasKey(utils.MetaFD), + // reqProcessor.Flags.Has(utils.MetaFD), // opts) // rply := new(sessions.V1ProcessMessageReply) // err = sa.connMgr.Call(sa.cfg.SIPAgentCfg().SessionSConns, nil, utils.SessionSv1ProcessMessage, @@ -524,7 +524,7 @@ func (sa *SIPAgent) processRequest(reqProcessor *config.RequestProcessor, evArgs, rply) if utils.ErrHasPrefix(err, utils.RalsErrorPrfx) { cgrEv.Event[utils.Usage] = 0 // avoid further debits - } else if needsMaxUsage(reqProcessor.Flags.ParamsSlice(utils.MetaRALs)) { + } else if needsMaxUsage(reqProcessor.Flags[utils.MetaRALs]) { cgrEv.Event[utils.Usage] = rply.MaxUsage // make sure the CDR reflects the debit } if err = agReq.setCGRReply(rply, err); err != nil { @@ -533,8 +533,8 @@ func (sa *SIPAgent) processRequest(reqProcessor *config.RequestProcessor, // case utils.MetaCDRs: // allow CDR processing } // separate request so we can capture the Terminate/Event also here - // if reqProcessor.Flags.HasKey(utils.MetaCDRs) && - // !reqProcessor.Flags.HasKey(utils.MetaDryRun) { + // if reqProcessor.Flags.Has(utils.MetaCDRs) && + // !reqProcessor.Flags.Has(utils.MetaDryRun) { // rplyCDRs := utils.StringPointer("") // if err = sa.connMgr.Call(sa.cfg.SIPAgentCfg().SessionSConns, nil, utils.SessionSv1ProcessCDR, // &utils.CGREventWithArgDispatcher{CGREvent: cgrEv, @@ -546,7 +546,7 @@ func (sa *SIPAgent) processRequest(reqProcessor *config.RequestProcessor, if err := agReq.SetFields(reqProcessor.ReplyFields); err != nil { return false, err } - if reqProcessor.Flags.HasKey(utils.MetaLog) { + if reqProcessor.Flags.Has(utils.MetaLog) { utils.Logger.Info( fmt.Sprintf("<%s> LOG, SIP reply: %s", utils.SIPAgent, agReq.Reply)) diff --git a/config/config_it_test.go b/config/config_it_test.go index eeca17c1a..4767fc58f 100644 --- a/config/config_it_test.go +++ b/config/config_it_test.go @@ -436,8 +436,8 @@ func testCGRConfigReloadERs(t *testing.T) { } else if reply != utils.OK { t.Errorf("Expected OK received: %s", reply) } - flags, _ := utils.FlagsWithParamsFromSlice([]string{"*dryrun"}) - flagsDefault, _ := utils.FlagsWithParamsFromSlice([]string{}) + flags := utils.FlagsWithParamsFromSlice([]string{"*dryrun"}) + flagsDefault := utils.FlagsWithParamsFromSlice([]string{}) content := []*FCTemplate{ {Tag: utils.ToR, Path: utils.MetaCgreq + utils.NestingSep + utils.ToR, Type: utils.MetaVariable, Value: NewRSRParsersMustCompile("~*req.2", utils.INFIELD_SEP), Mandatory: true, Layout: time.RFC3339}, {Tag: utils.OriginID, Path: utils.MetaCgreq + utils.NestingSep + utils.OriginID, Type: utils.MetaVariable, Value: NewRSRParsersMustCompile("~*req.3", utils.INFIELD_SEP), Mandatory: true, Layout: time.RFC3339}, @@ -864,7 +864,7 @@ func testCgrCfgV1ReloadConfigSection(t *testing.T) { "HeaderDefineChar": ":", "Filters": nil, "Flags": map[string]interface{}{ - "*dryrun": []interface{}{}, + "*dryrun": map[string][]interface{}{}, }, "FailedCallsPrefix": "", "PartialCacheExpiryAction": "", diff --git a/config/dnsagentcfg_test.go b/config/dnsagentcfg_test.go index 787bcbfa9..06c5f6c90 100644 --- a/config/dnsagentcfg_test.go +++ b/config/dnsagentcfg_test.go @@ -86,7 +86,7 @@ func TestRequestProcessorloadFromJsonCfg(t *testing.T) { ID: "cgrates", Tenant: NewRSRParsersMustCompile("tenant", utils.INFIELD_SEP), Filters: []string{"filter1", "filter2"}, - Flags: utils.FlagsWithParams{"flag1": []string{}, "flag2": []string{}}, + Flags: utils.FlagsWithParams{"flag1": {}, "flag2": {}}, } if err = dareq.loadFromJsonCfg(json, utils.INFIELD_SEP); err != nil { t.Error(err) @@ -168,7 +168,7 @@ func TestDNSAgentCfgAsMapInterface(t *testing.T) { "id": "OutboundAUTHDryRun", "filters": []string{"*string:~*req.request_type:OutboundAUTH", "*string:~*req.Msisdn:497700056231"}, "tenant": "cgrates.org", - "flags": map[string][]string{"*dryrun": {}}, + "flags": []string{"*dryrun"}, "Timezone": "", "request_fields": []map[string]interface{}{}, "reply_fields": []map[string]interface{}{ diff --git a/config/dnsagntcfg.go b/config/dnsagntcfg.go index 4b9ed7606..00a2eed85 100644 --- a/config/dnsagntcfg.go +++ b/config/dnsagntcfg.go @@ -133,9 +133,7 @@ func (rp *RequestProcessor) loadFromJsonCfg(jsnCfg *ReqProcessorJsnCfg, sep stri } } if jsnCfg.Flags != nil { - if rp.Flags, err = utils.FlagsWithParamsFromSlice(*jsnCfg.Flags); err != nil { - return - } + rp.Flags = utils.FlagsWithParamsFromSlice(*jsnCfg.Flags) } if jsnCfg.Timezone != nil { rp.Timezone = *jsnCfg.Timezone @@ -177,16 +175,11 @@ func (rp *RequestProcessor) AsMapInterface(separator string) map[string]interfac tenant = strings.Join(values, separator) } - flags := make(map[string][]string, len(rp.Flags)) - for key, item := range rp.Flags { - flags[key] = item - } - return map[string]interface{}{ utils.IDCfg: rp.ID, utils.TenantCfg: tenant, utils.FiltersCfg: rp.Filters, - utils.FlagsCfg: flags, + utils.FlagsCfg: rp.Flags.SliceFlags(), utils.TimezoneCfgC: rp.Timezone, utils.RequestFieldsCfg: requestFields, utils.ReplyFieldsCfg: replyFields, diff --git a/config/eescfg.go b/config/eescfg.go index 83608661c..438ee86a2 100644 --- a/config/eescfg.go +++ b/config/eescfg.go @@ -166,9 +166,7 @@ func (eeC *EventExporterCfg) loadFromJsonCfg(jsnEec *EventExporterJsonCfg, separ } } if jsnEec.Flags != nil { - if eeC.Flags, err = utils.FlagsWithParamsFromSlice(*jsnEec.Flags); err != nil { - return - } + eeC.Flags = utils.FlagsWithParamsFromSlice(*jsnEec.Flags) } if jsnEec.Attribute_context != nil { eeC.AttributeSCtx = *jsnEec.Attribute_context @@ -285,14 +283,6 @@ func (eeC *EventExporterCfg) AsMapInterface(separator string) map[string]interfa tenant = strings.Join(values, separator) } - flags := make(map[string][]interface{}, len(eeC.Flags)) - for key, val := range eeC.Flags { - buf := make([]interface{}, len(val)) - for i, item := range val { - buf[i] = item - } - flags[key] = buf - } fields := make([]map[string]interface{}, 0, len(eeC.Fields)) for _, fld := range eeC.Fields { fields = append(fields, fld.AsMapInterface(separator)) @@ -306,7 +296,7 @@ func (eeC *EventExporterCfg) AsMapInterface(separator string) map[string]interfa utils.TenantCfg: tenant, utils.TimezoneCfg: eeC.Timezone, utils.FiltersCfg: eeC.Filters, - utils.FlagsCfg: flags, + utils.FlagsCfg: eeC.Flags.SliceFlags(), utils.AttributeContextCfg: eeC.AttributeSCtx, utils.AttributeIDsCfg: eeC.AttributeSIDs, utils.SynchronousCfg: eeC.Synchronous, diff --git a/config/erscfg.go b/config/erscfg.go index 3c13f3808..7ce6f0690 100644 --- a/config/erscfg.go +++ b/config/erscfg.go @@ -184,9 +184,7 @@ func (er *EventReaderCfg) loadFromJsonCfg(jsnCfg *EventReaderJsonCfg, sep string } } if jsnCfg.Flags != nil { - if er.Flags, err = utils.FlagsWithParamsFromSlice(*jsnCfg.Flags); err != nil { - return - } + er.Flags = utils.FlagsWithParamsFromSlice(*jsnCfg.Flags) } if jsnCfg.Failed_calls_prefix != nil { er.FailedCallsPrefix = *jsnCfg.Failed_calls_prefix @@ -265,14 +263,6 @@ func (er *EventReaderCfg) AsMapInterface(separator string) map[string]interface{ tenant = strings.Join(values, separator) } - flags := make(map[string][]interface{}, len(er.Flags)) - for key, val := range er.Flags { - buf := make([]interface{}, len(val)) - for i, item := range val { - buf[i] = item - } - flags[key] = buf - } fields := make([]map[string]interface{}, len(er.Fields)) for i, item := range er.Fields { fields[i] = item.AsMapInterface(separator) @@ -309,7 +299,7 @@ func (er *EventReaderCfg) AsMapInterface(separator string) map[string]interface{ utils.TenantCfg: tenant, utils.TimezoneCfg: er.Timezone, utils.FiltersCfg: er.Filters, - utils.FlagsCfg: flags, + utils.FlagsCfg: er.Flags.SliceFlags(), utils.FailedCallsPrefixCfg: er.FailedCallsPrefix, utils.PartialRecordCacheCfg: partialRecordCache, utils.PartialCacheExpiryActionCfg: er.PartialCacheExpiryAction, diff --git a/config/erscfg_test.go b/config/erscfg_test.go index c621750e6..4292464b8 100644 --- a/config/erscfg_test.go +++ b/config/erscfg_test.go @@ -374,7 +374,7 @@ func TestERsCfgAsMapInterface(t *testing.T) { "readers": []map[string]interface{}{ { "filters": []string{}, - "flags": map[string][]interface{}{}, + "flags": filters, "id": "*default", "partial_record_cache": "0", "processed_path": "/var/spool/cgrates/ers/out", @@ -426,7 +426,7 @@ func TestERsCfgAsMapInterface(t *testing.T) { {"mandatory": true, "path": "*cgreq.Usage", "tag": "Usage", "type": "*variable", "value": "~*req.13"}, }, "filters": filters, - "flags": map[string][]interface{}{}, + "flags": filters, "id": "file_reader1", "partial_record_cache": "0", "processed_path": "/tmp/ers/out", diff --git a/config/httpagntcfg_test.go b/config/httpagntcfg_test.go index 735ca9dff..fb070167f 100644 --- a/config/httpagntcfg_test.go +++ b/config/httpagntcfg_test.go @@ -72,7 +72,7 @@ func TestHttpAgentCfgsloadFromJsonCfg(t *testing.T) { ID: "OutboundAUTHDryRun", Filters: []string{"*string:*req.request_type:OutboundAUTH", "*string:*req.Msisdn:497700056231"}, Tenant: NewRSRParsersMustCompile("cgrates.org", utils.INFIELD_SEP), - Flags: utils.FlagsWithParams{"*dryrun": []string{}}, + Flags: utils.FlagsWithParams{"*dryrun": {}}, RequestFields: []*FCTemplate{}, ReplyFields: []*FCTemplate{{ Tag: "Allow", @@ -150,7 +150,7 @@ func TestHttpAgentCfgsloadFromJsonCfg(t *testing.T) { ID: "OutboundAUTHDryRun", Filters: []string{"*string:*req.request_type:OutboundAUTH", "*string:*req.Msisdn:497700056231"}, Tenant: NewRSRParsersMustCompile("cgrates.org", utils.INFIELD_SEP), - Flags: utils.FlagsWithParams{"*dryrun": []string{}}, + Flags: utils.FlagsWithParams{"*dryrun": {}}, RequestFields: []*FCTemplate{}, ReplyFields: []*FCTemplate{{ Tag: "Allow", @@ -165,7 +165,7 @@ func TestHttpAgentCfgsloadFromJsonCfg(t *testing.T) { ID: "mtcall_cdr", Filters: []string{"*string:*req.request_type:MTCALL_CDR"}, Tenant: NewRSRParsersMustCompile("cgrates.org", utils.INFIELD_SEP), - Flags: utils.FlagsWithParams{"*cdrs": []string{}}, + Flags: utils.FlagsWithParams{"*cdrs": {}}, RequestFields: []*FCTemplate{{ Tag: "RequestType", Path: "RequestType", @@ -192,7 +192,7 @@ func TestHttpAgentCfgsloadFromJsonCfg(t *testing.T) { RequestProcessors: []*RequestProcessor{{ ID: "cdr_from_xml", Tenant: NewRSRParsersMustCompile("cgrates.org", utils.INFIELD_SEP), - Flags: utils.FlagsWithParams{"*cdrs": []string{}}, + Flags: utils.FlagsWithParams{"*cdrs": {}}, RequestFields: []*FCTemplate{}, ReplyFields: []*FCTemplate{}, }}, @@ -251,7 +251,7 @@ func TestHttpAgentCfgloadFromJsonCfg(t *testing.T) { ID: "OutboundAUTHDryRun", Filters: []string{"*string:*req.request_type:OutboundAUTH", "*string:*req.Msisdn:497700056231"}, Tenant: NewRSRParsersMustCompile("cgrates.org", utils.INFIELD_SEP), - Flags: utils.FlagsWithParams{"*dryrun": []string{}}, + Flags: utils.FlagsWithParams{"*dryrun": {}}, RequestFields: []*FCTemplate{}, ReplyFields: []*FCTemplate{}, }}, @@ -275,7 +275,7 @@ func TestHttpAgentCfgappendHttpAgntProcCfgs(t *testing.T) { ID: "OutboundAUTHDryRun", Filters: []string{"*string:*req.request_type:OutboundAUTH", "*string:*req.Msisdn:497700056231"}, Tenant: NewRSRParsersMustCompile("cgrates.org", utils.INFIELD_SEP), - Flags: utils.FlagsWithParams{"*dryrun": []string{}}, + Flags: utils.FlagsWithParams{"*dryrun": {}}, RequestFields: []*FCTemplate{}, ReplyFields: []*FCTemplate{{ Tag: "Allow", @@ -325,7 +325,7 @@ func TestHttpAgentCfgappendHttpAgntProcCfgs(t *testing.T) { ID: "OutboundAUTHDryRun", Filters: []string{"*string:*req.request_type:OutboundAUTH", "*string:*req.Msisdn:497700056231"}, Tenant: NewRSRParsersMustCompile("cgrates.org", utils.INFIELD_SEP), - Flags: utils.FlagsWithParams{"*dryrun": []string{}}, + Flags: utils.FlagsWithParams{"*dryrun": {}}, RequestFields: []*FCTemplate{}, ReplyFields: []*FCTemplate{{ Tag: "Allow", @@ -339,7 +339,7 @@ func TestHttpAgentCfgappendHttpAgntProcCfgs(t *testing.T) { ID: "OutboundAUTHDryRun1", Filters: []string{"*string:*req.request_type:OutboundAUTH", "*string:*req.Msisdn:497700056231"}, Tenant: NewRSRParsersMustCompile("cgrates.org", utils.INFIELD_SEP), - Flags: utils.FlagsWithParams{"*dryrun": []string{}}, + Flags: utils.FlagsWithParams{"*dryrun": {}}, RequestFields: []*FCTemplate{}, ReplyFields: []*FCTemplate{{ Tag: "Allow", @@ -408,7 +408,7 @@ func TestHttpAgentCfgAsMapInterface(t *testing.T) { "id": "OutboundAUTHDryRun", "filters": []string{"*string:~*req.request_type:OutboundAUTH", "*string:~*req.Msisdn:497700056231"}, "tenant": "cgrates.org", - "flags": map[string][]string{"*dryrun": {}}, + "flags": []string{"*dryrun"}, "Timezone": "", "request_fields": []map[string]interface{}{}, "reply_fields": []map[string]interface{}{ diff --git a/config/loaderscfg.go b/config/loaderscfg.go index cf912e86c..26f7696b6 100644 --- a/config/loaderscfg.go +++ b/config/loaderscfg.go @@ -86,9 +86,7 @@ func (self *LoaderDataType) loadFromJsonCfg(jsnCfg *LoaderJsonDataType, separato self.Filename = *jsnCfg.File_name } if jsnCfg.Flags != nil { - if self.Flags, err = utils.FlagsWithParamsFromSlice(*jsnCfg.Flags); err != nil { - return - } + self.Flags = utils.FlagsWithParamsFromSlice(*jsnCfg.Flags) } if jsnCfg.Fields != nil { if self.Fields, err = FCTemplatesFromFCTemplatesJsonCfg(*jsnCfg.Fields, separator); err != nil { diff --git a/config/multifiles_it_test.go b/config/multifiles_it_test.go index 1a84e2fbc..a94131655 100644 --- a/config/multifiles_it_test.go +++ b/config/multifiles_it_test.go @@ -99,7 +99,7 @@ func TestMfHttpAgentMultipleFields(t *testing.T) { ID: "OutboundAUTHDryRun", Filters: []string{}, Tenant: NewRSRParsersMustCompile("cgrates.org", utils.INFIELD_SEP), - Flags: utils.FlagsWithParams{"*dryrun": []string{}}, + Flags: utils.FlagsWithParams{"*dryrun": {}}, RequestFields: []*FCTemplate{}, ReplyFields: []*FCTemplate{{ Tag: "Allow", @@ -114,8 +114,8 @@ func TestMfHttpAgentMultipleFields(t *testing.T) { ID: "OutboundAUTH", Filters: []string{"*string:~*req.request_type:OutboundAUTH"}, Tenant: NewRSRParsersMustCompile("cgrates.org", utils.INFIELD_SEP), - Flags: utils.FlagsWithParams{"*accounts": []string{}, - "*attributes": []string{}, "*authorize": []string{}}, + Flags: utils.FlagsWithParams{"*accounts": {}, + "*attributes": {}, "*authorize": {}}, RequestFields: []*FCTemplate{ { Tag: "RequestType", @@ -141,7 +141,7 @@ func TestMfHttpAgentMultipleFields(t *testing.T) { ID: "mtcall_cdr", Filters: []string{"*string:~*req.request_type:MTCALL_CDR"}, Tenant: NewRSRParsersMustCompile("cgrates.org", utils.INFIELD_SEP), - Flags: utils.FlagsWithParams{"*cdrs": []string{}}, + Flags: utils.FlagsWithParams{"*cdrs": {}}, RequestFields: []*FCTemplate{{ Tag: "RequestType", Path: "RequestType", @@ -170,7 +170,7 @@ func TestMfHttpAgentMultipleFields(t *testing.T) { RequestProcessors: []*RequestProcessor{{ ID: "cdr_from_xml", Tenant: NewRSRParsersMustCompile("cgrates.org", utils.INFIELD_SEP), - Flags: utils.FlagsWithParams{"*cdrs": []string{}}, + Flags: utils.FlagsWithParams{"*cdrs": {}}, RequestFields: []*FCTemplate{ { Tag: "ToR", diff --git a/config/sipagentcfg_test.go b/config/sipagentcfg_test.go index 9647085d6..ca3c41ee7 100644 --- a/config/sipagentcfg_test.go +++ b/config/sipagentcfg_test.go @@ -137,7 +137,7 @@ func TestSIPAgentCfgAsMapInterface(t *testing.T) { "id": "OutboundAUTHDryRun", "filters": []string{"*string:~*req.request_type:OutboundAUTH", "*string:~*req.Msisdn:497700056231"}, "tenant": "cgrates.org", - "flags": map[string][]string{"*dryrun": {}}, + "flags": []string{"*dryrun"}, "Timezone": "", "request_fields": []map[string]interface{}{}, "reply_fields": []map[string]interface{}{ diff --git a/engine/cdrs.go b/engine/cdrs.go index 3e6b017b1..9efb0bed1 100644 --- a/engine/cdrs.go +++ b/engine/cdrs.go @@ -737,47 +737,44 @@ func (cdrS *CDRServer) V1ProcessEvent(arg *ArgV1ProcessEvent, reply *string) (er // end of RPC caching // processing options - var flgs utils.FlagsWithParams - if flgs, err = utils.FlagsWithParamsFromSlice(arg.Flags); err != nil { - return - } + flgs := utils.FlagsWithParamsFromSlice(arg.Flags) attrS := len(cdrS.cgrCfg.CdrsCfg().AttributeSConns) != 0 - if flgs.HasKey(utils.MetaAttributes) { + if flgs.Has(utils.MetaAttributes) { attrS = flgs.GetBool(utils.MetaAttributes) } store := cdrS.cgrCfg.CdrsCfg().StoreCdrs - if flgs.HasKey(utils.MetaStore) { + if flgs.Has(utils.MetaStore) { store = flgs.GetBool(utils.MetaStore) } export := len(cdrS.cgrCfg.CdrsCfg().OnlineCDRExports) != 0 || len(cdrS.cgrCfg.CdrsCfg().EEsConns) != 0 - if flgs.HasKey(utils.MetaExport) { + if flgs.Has(utils.MetaExport) { export = flgs.GetBool(utils.MetaExport) } thdS := len(cdrS.cgrCfg.CdrsCfg().ThresholdSConns) != 0 - if flgs.HasKey(utils.MetaThresholds) { + if flgs.Has(utils.MetaThresholds) { thdS = flgs.GetBool(utils.MetaThresholds) } stS := len(cdrS.cgrCfg.CdrsCfg().StatSConns) != 0 - if flgs.HasKey(utils.MetaStats) { + if flgs.Has(utils.MetaStats) { stS = flgs.GetBool(utils.MetaStats) } chrgS := len(cdrS.cgrCfg.CdrsCfg().ChargerSConns) != 0 // activate charging for the Event - if flgs.HasKey(utils.MetaChargers) { + if flgs.Has(utils.MetaChargers) { chrgS = flgs.GetBool(utils.MetaChargers) } var ralS bool // activate single rating for the CDR - if flgs.HasKey(utils.MetaRALs) { + if flgs.Has(utils.MetaRALs) { ralS = flgs.GetBool(utils.MetaRALs) } var reRate bool - if flgs.HasKey(utils.MetaRerate) { + if flgs.Has(utils.MetaRerate) { reRate = flgs.GetBool(utils.MetaRerate) if reRate { ralS = true } } var refund bool - if flgs.HasKey(utils.MetaRefund) { + if flgs.Has(utils.MetaRefund) { refund = flgs.GetBool(utils.MetaRefund) } // end of processing options @@ -821,47 +818,44 @@ func (cdrS *CDRServer) V2ProcessEvent(arg *ArgV1ProcessEvent, evs *[]*utils.Even // end of RPC caching // processing options - var flgs utils.FlagsWithParams - if flgs, err = utils.FlagsWithParamsFromSlice(arg.Flags); err != nil { - return - } + flgs := utils.FlagsWithParamsFromSlice(arg.Flags) attrS := len(cdrS.cgrCfg.CdrsCfg().AttributeSConns) != 0 - if flgs.HasKey(utils.MetaAttributes) { + if flgs.Has(utils.MetaAttributes) { attrS = flgs.GetBool(utils.MetaAttributes) } store := cdrS.cgrCfg.CdrsCfg().StoreCdrs - if flgs.HasKey(utils.MetaStore) { + if flgs.Has(utils.MetaStore) { store = flgs.GetBool(utils.MetaStore) } export := len(cdrS.cgrCfg.CdrsCfg().OnlineCDRExports) != 0 || len(cdrS.cgrCfg.CdrsCfg().EEsConns) != 0 - if flgs.HasKey(utils.MetaExport) { + if flgs.Has(utils.MetaExport) { export = flgs.GetBool(utils.MetaExport) } thdS := len(cdrS.cgrCfg.CdrsCfg().ThresholdSConns) != 0 - if flgs.HasKey(utils.MetaThresholds) { + if flgs.Has(utils.MetaThresholds) { thdS = flgs.GetBool(utils.MetaThresholds) } stS := len(cdrS.cgrCfg.CdrsCfg().StatSConns) != 0 - if flgs.HasKey(utils.MetaStats) { + if flgs.Has(utils.MetaStats) { stS = flgs.GetBool(utils.MetaStats) } chrgS := len(cdrS.cgrCfg.CdrsCfg().ChargerSConns) != 0 // activate charging for the Event - if flgs.HasKey(utils.MetaChargers) { + if flgs.Has(utils.MetaChargers) { chrgS = flgs.GetBool(utils.MetaChargers) } var ralS bool // activate single rating for the CDR - if flgs.HasKey(utils.MetaRALs) { + if flgs.Has(utils.MetaRALs) { ralS = flgs.GetBool(utils.MetaRALs) } var reRate bool - if flgs.HasKey(utils.MetaRerate) { + if flgs.Has(utils.MetaRerate) { reRate = flgs.GetBool(utils.MetaRerate) if reRate { ralS = true } } var refund bool - if flgs.HasKey(utils.MetaRefund) { + if flgs.Has(utils.MetaRefund) { refund = flgs.GetBool(utils.MetaRefund) } // end of processing options @@ -875,9 +869,8 @@ func (cdrS *CDRServer) V2ProcessEvent(arg *ArgV1ProcessEvent, evs *[]*utils.Even if procEvs, err = cdrS.processEvent(cgrEv, chrgS, attrS, refund, ralS, store, reRate, export, thdS, stS); err != nil { return - } else { - *evs = procEvs } + *evs = procEvs return nil } @@ -996,32 +989,29 @@ func (cdrS *CDRServer) V1RateCDRs(arg *ArgRateCDRs, reply *string) (err error) { if err != nil { return } - var flgs utils.FlagsWithParams - if flgs, err = utils.FlagsWithParamsFromSlice(arg.Flags); err != nil { - return - } + flgs := utils.FlagsWithParamsFromSlice(arg.Flags) store := cdrS.cgrCfg.CdrsCfg().StoreCdrs - if flgs.HasKey(utils.MetaStore) { + if flgs.Has(utils.MetaStore) { store = flgs.GetBool(utils.MetaStore) } export := len(cdrS.cgrCfg.CdrsCfg().OnlineCDRExports) != 0 || len(cdrS.cgrCfg.CdrsCfg().EEsConns) != 0 - if flgs.HasKey(utils.MetaExport) { + if flgs.Has(utils.MetaExport) { export = flgs.GetBool(utils.MetaExport) } thdS := len(cdrS.cgrCfg.CdrsCfg().ThresholdSConns) != 0 - if flgs.HasKey(utils.MetaThresholds) { + if flgs.Has(utils.MetaThresholds) { thdS = flgs.GetBool(utils.MetaThresholds) } statS := len(cdrS.cgrCfg.CdrsCfg().StatSConns) != 0 - if flgs.HasKey(utils.MetaStatS) { + if flgs.Has(utils.MetaStatS) { statS = flgs.GetBool(utils.MetaStatS) } chrgS := len(cdrS.cgrCfg.CdrsCfg().ChargerSConns) != 0 - if flgs.HasKey(utils.MetaChargers) { + if flgs.Has(utils.MetaChargers) { chrgS = flgs.GetBool(utils.MetaChargers) } attrS := len(cdrS.cgrCfg.CdrsCfg().AttributeSConns) != 0 - if flgs.HasKey(utils.MetaAttributes) { + if flgs.Has(utils.MetaAttributes) { attrS = flgs.GetBool(utils.MetaAttributes) } diff --git a/ers/ers.go b/ers/ers.go index 407db1b50..c216e2073 100644 --- a/ers/ers.go +++ b/ers/ers.go @@ -154,7 +154,7 @@ func (erS *ERService) addReader(rdrID string, cfgIdx int) (err error) { func (erS *ERService) processEvent(cgrEv *utils.CGREvent, rdrCfg *config.EventReaderCfg, opts map[string]interface{}) (err error) { // log the event created if requested by flags - if rdrCfg.Flags.HasKey(utils.MetaLog) { + if rdrCfg.Flags.Has(utils.MetaLog) { utils.Logger.Info( fmt.Sprintf("<%s> LOG, reader: <%s>, message: %s", utils.ERs, rdrCfg.ID, utils.ToIJSON(cgrEv))) @@ -166,14 +166,14 @@ func (erS *ERService) processEvent(cgrEv *utils.CGREvent, utils.MetaInitiate, utils.MetaUpdate, utils.MetaTerminate, utils.MetaMessage, utils.MetaCDRs, utils.MetaEvent, utils.META_NONE} { - if rdrCfg.Flags.HasKey(typ) { // request type is identified through flags + if rdrCfg.Flags.Has(typ) { // request type is identified through flags reqType = typ break } } var cgrArgs utils.ExtractedArgs if cgrArgs, err = utils.ExtractArgsFromOpts(opts, - rdrCfg.Flags.HasKey(utils.MetaDispatchers), + rdrCfg.Flags.Has(utils.MetaDispatchers), reqType == utils.MetaAuthorize || reqType == utils.MetaMessage || reqType == utils.MetaEvent); err != nil { @@ -192,19 +192,19 @@ func (erS *ERService) processEvent(cgrEv *utils.CGREvent, utils.ERs, rdrCfg.ID, utils.ToJSON(cgrEv))) case utils.MetaAuthorize: authArgs := sessions.NewV1AuthorizeArgs( - rdrCfg.Flags.HasKey(utils.MetaAttributes), - rdrCfg.Flags.ParamsSlice(utils.MetaAttributes), - rdrCfg.Flags.HasKey(utils.MetaThresholds), - rdrCfg.Flags.ParamsSlice(utils.MetaThresholds), - rdrCfg.Flags.HasKey(utils.MetaStats), - rdrCfg.Flags.ParamsSlice(utils.MetaStats), - rdrCfg.Flags.HasKey(utils.MetaResources), - rdrCfg.Flags.HasKey(utils.MetaAccounts), - rdrCfg.Flags.HasKey(utils.MetaRoutes), - rdrCfg.Flags.HasKey(utils.MetaRoutesIgnoreErrors), - rdrCfg.Flags.HasKey(utils.MetaRoutesEventCost), + rdrCfg.Flags.Has(utils.MetaAttributes), + rdrCfg.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + rdrCfg.Flags.Has(utils.MetaThresholds), + rdrCfg.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + rdrCfg.Flags.Has(utils.MetaStats), + rdrCfg.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + rdrCfg.Flags.Has(utils.MetaResources), + rdrCfg.Flags.Has(utils.MetaAccounts), + rdrCfg.Flags.Has(utils.MetaRoutes), + rdrCfg.Flags.Has(utils.MetaRoutesIgnoreErrors), + rdrCfg.Flags.Has(utils.MetaRoutesEventCost), cgrEv, cgrArgs.ArgDispatcher, *cgrArgs.RoutePaginator, - rdrCfg.Flags.HasKey(utils.MetaFD), + rdrCfg.Flags.Has(utils.MetaFD), opts, ) rply := new(sessions.V1AuthorizeReply) @@ -212,60 +212,60 @@ func (erS *ERService) processEvent(cgrEv *utils.CGREvent, authArgs, rply) case utils.MetaInitiate: initArgs := sessions.NewV1InitSessionArgs( - rdrCfg.Flags.HasKey(utils.MetaAttributes), - rdrCfg.Flags.ParamsSlice(utils.MetaAttributes), - rdrCfg.Flags.HasKey(utils.MetaThresholds), - rdrCfg.Flags.ParamsSlice(utils.MetaThresholds), - rdrCfg.Flags.HasKey(utils.MetaStats), - rdrCfg.Flags.ParamsSlice(utils.MetaStats), - rdrCfg.Flags.HasKey(utils.MetaResources), - rdrCfg.Flags.HasKey(utils.MetaAccounts), + rdrCfg.Flags.Has(utils.MetaAttributes), + rdrCfg.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + rdrCfg.Flags.Has(utils.MetaThresholds), + rdrCfg.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + rdrCfg.Flags.Has(utils.MetaStats), + rdrCfg.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + rdrCfg.Flags.Has(utils.MetaResources), + rdrCfg.Flags.Has(utils.MetaAccounts), cgrEv, cgrArgs.ArgDispatcher, - rdrCfg.Flags.HasKey(utils.MetaFD), + rdrCfg.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1InitSessionReply) err = erS.connMgr.Call(erS.cfg.ERsCfg().SessionSConns, nil, utils.SessionSv1InitiateSession, initArgs, rply) case utils.MetaUpdate: updateArgs := sessions.NewV1UpdateSessionArgs( - rdrCfg.Flags.HasKey(utils.MetaAttributes), - rdrCfg.Flags.ParamsSlice(utils.MetaAttributes), - rdrCfg.Flags.HasKey(utils.MetaAccounts), + rdrCfg.Flags.Has(utils.MetaAttributes), + rdrCfg.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + rdrCfg.Flags.Has(utils.MetaAccounts), cgrEv, cgrArgs.ArgDispatcher, - rdrCfg.Flags.HasKey(utils.MetaFD), + rdrCfg.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1UpdateSessionReply) err = erS.connMgr.Call(erS.cfg.ERsCfg().SessionSConns, nil, utils.SessionSv1UpdateSession, updateArgs, rply) case utils.MetaTerminate: terminateArgs := sessions.NewV1TerminateSessionArgs( - rdrCfg.Flags.HasKey(utils.MetaAccounts), - rdrCfg.Flags.HasKey(utils.MetaResources), - rdrCfg.Flags.HasKey(utils.MetaThresholds), - rdrCfg.Flags.ParamsSlice(utils.MetaThresholds), - rdrCfg.Flags.HasKey(utils.MetaStats), - rdrCfg.Flags.ParamsSlice(utils.MetaStats), + rdrCfg.Flags.Has(utils.MetaAccounts), + rdrCfg.Flags.Has(utils.MetaResources), + rdrCfg.Flags.Has(utils.MetaThresholds), + rdrCfg.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + rdrCfg.Flags.Has(utils.MetaStats), + rdrCfg.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), cgrEv, cgrArgs.ArgDispatcher, - rdrCfg.Flags.HasKey(utils.MetaFD), + rdrCfg.Flags.Has(utils.MetaFD), opts) rply := utils.StringPointer("") err = erS.connMgr.Call(erS.cfg.ERsCfg().SessionSConns, nil, utils.SessionSv1TerminateSession, terminateArgs, rply) case utils.MetaMessage: evArgs := sessions.NewV1ProcessMessageArgs( - rdrCfg.Flags.HasKey(utils.MetaAttributes), - rdrCfg.Flags.ParamsSlice(utils.MetaAttributes), - rdrCfg.Flags.HasKey(utils.MetaThresholds), - rdrCfg.Flags.ParamsSlice(utils.MetaThresholds), - rdrCfg.Flags.HasKey(utils.MetaStats), - rdrCfg.Flags.ParamsSlice(utils.MetaStats), - rdrCfg.Flags.HasKey(utils.MetaResources), - rdrCfg.Flags.HasKey(utils.MetaAccounts), - rdrCfg.Flags.HasKey(utils.MetaRoutes), - rdrCfg.Flags.HasKey(utils.MetaRoutesIgnoreErrors), - rdrCfg.Flags.HasKey(utils.MetaRoutesEventCost), + rdrCfg.Flags.Has(utils.MetaAttributes), + rdrCfg.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), + rdrCfg.Flags.Has(utils.MetaThresholds), + rdrCfg.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), + rdrCfg.Flags.Has(utils.MetaStats), + rdrCfg.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), + rdrCfg.Flags.Has(utils.MetaResources), + rdrCfg.Flags.Has(utils.MetaAccounts), + rdrCfg.Flags.Has(utils.MetaRoutes), + rdrCfg.Flags.Has(utils.MetaRoutesIgnoreErrors), + rdrCfg.Flags.Has(utils.MetaRoutesEventCost), cgrEv, cgrArgs.ArgDispatcher, *cgrArgs.RoutePaginator, - rdrCfg.Flags.HasKey(utils.MetaFD), + rdrCfg.Flags.Has(utils.MetaFD), opts) rply := new(sessions.V1ProcessMessageReply) // need it so rpcclient can clone err = erS.connMgr.Call(erS.cfg.ERsCfg().SessionSConns, nil, utils.SessionSv1ProcessMessage, @@ -292,8 +292,8 @@ func (erS *ERService) processEvent(cgrEv *utils.CGREvent, return } // separate request so we can capture the Terminate/Event also here - if rdrCfg.Flags.HasKey(utils.MetaCDRs) && - !rdrCfg.Flags.HasKey(utils.MetaDryRun) { + if rdrCfg.Flags.Has(utils.MetaCDRs) && + !rdrCfg.Flags.Has(utils.MetaDryRun) { rplyCDRs := utils.StringPointer("") err = erS.connMgr.Call(erS.cfg.ERsCfg().SessionSConns, nil, utils.SessionSv1ProcessCDR, &utils.CGREventWithArgDispatcher{CGREvent: cgrEv, diff --git a/loaders/loader_test.go b/loaders/loader_test.go index 9caa97e62..154bb5377 100644 --- a/loaders/loader_test.go +++ b/loaders/loader_test.go @@ -1581,11 +1581,7 @@ cgrates.org,RP1,,,,,,,,,,RT_CHRISTMAS,,* * 24 12 *,30,false,0s,0.06,1m,1s utils.RateProfilesCsv: &openedCSVFile{fileName: utils.RateProfilesCsv, rdr: rdr2, csvRdr: csvRdr2}}, } - if flag, err := utils.FlagsWithParamsFromSlice([]string{utils.MetaPartial}); err != nil { - t.Error(err) - } else { - ldr.flagsTpls[utils.MetaRateProfiles] = flag - } + ldr.flagsTpls[utils.MetaRateProfiles] = utils.FlagsWithParamsFromSlice([]string{utils.MetaPartial}) if err := ldr.processContent(utils.MetaRateProfiles, utils.EmptyString); err != nil { t.Error(err) } @@ -1830,11 +1826,7 @@ cgrates.org,RP1, utils.RateProfilesCsv: &openedCSVFile{fileName: utils.RateProfilesCsv, rdr: rdr1, csvRdr: csvRdr1}}, } - if flag, err := utils.FlagsWithParamsFromSlice([]string{utils.MetaPartial}); err != nil { - t.Error(err) - } else { - ldr.flagsTpls[utils.MetaRateProfiles] = flag - } + ldr.flagsTpls[utils.MetaRateProfiles] = utils.FlagsWithParamsFromSlice([]string{utils.MetaPartial}) if err := ldr.removeContent(utils.MetaRateProfiles, utils.EmptyString); err != nil { t.Error(err) } @@ -1903,11 +1895,7 @@ cgrates.org,RP1, utils.RateProfilesCsv: &openedCSVFile{fileName: utils.RateProfilesCsv, rdr: rdr2, csvRdr: csvRdr2}}, } - if flag, err := utils.FlagsWithParamsFromSlice([]string{utils.MetaPartial}); err != nil { - t.Error(err) - } else { - ldr.flagsTpls[utils.MetaRateProfiles] = flag - } + ldr.flagsTpls[utils.MetaRateProfiles] = utils.FlagsWithParamsFromSlice([]string{utils.MetaPartial}) if err := ldr.removeContent(utils.MetaRateProfiles, utils.EmptyString); err != nil { t.Error(err) } diff --git a/packages/debian/changelog b/packages/debian/changelog index 3aeb9c881..d6bf33d4c 100644 --- a/packages/debian/changelog +++ b/packages/debian/changelog @@ -80,6 +80,7 @@ cgrates (0.11.0~dev) UNRELEASED; urgency=medium * [SessionS] Rename from ResourceMessage to ResourceAllocation * [LoaderS] Updated file selector from *req to *file(FileName) * [SessionS] Added *chargers flag to ProcessEvent to proccess the events from ChargerS with other subsystems + * [SessionS] Updated the ids handling in flags by ading *ids as a new flag -- DanB Wed, 19 Feb 2020 13:25:52 +0200 diff --git a/sessions/sessions.go b/sessions/sessions.go index ee32f0e15..9b25fff20 100644 --- a/sessions/sessions.go +++ b/sessions/sessions.go @@ -3148,10 +3148,7 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, } //convert from Flags []string to utils.FlagsWithParams - var argsFlagsWithParams utils.FlagsWithParams - if argsFlagsWithParams, err = utils.FlagsWithParamsFromSlice(args.Flags); err != nil { - return - } + argsFlagsWithParams := utils.FlagsWithParamsFromSlice(args.Flags) events := map[string]*utils.CGREventWithOpts{ utils.MetaRaw: { @@ -3179,8 +3176,8 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, } // check for *attribute - if argsFlagsWithParams.HasKey(utils.MetaAttributes) { - attrIDs := argsFlagsWithParams.ParamsSlice(utils.MetaAttributes) + if argsFlagsWithParams.GetBool(utils.MetaAttributes) { + attrIDs := argsFlagsWithParams.ParamsSlice(utils.MetaAttributes, utils.MetaIDs) rply.Attributes = make(map[string]*engine.AttrSProcessEventReply) for runID, cgrEv := range events { rplyAttr, err := sS.processAttributes(cgrEv.CGREvent, cgrEv.ArgDispatcher, @@ -3201,21 +3198,14 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, } // get routes if required - if argsFlagsWithParams.HasKey(utils.MetaRoutes) { + if argsFlagsWithParams.GetBool(utils.MetaRoutes) { rply.Routes = make(map[string]*engine.SortedRoutes) - var ignoreErrors bool - var maxCost string // check in case we have options for suppliers - if splOpts := argsFlagsWithParams.ParamsSlice(utils.MetaRoutes); len(splOpts) != 0 { - //check for subflags and convert them into utils.FlagsWithParams - splsFlagsWithParams, err := utils.FlagsWithParamsFromSlice(splOpts) - if err != nil { - return err - } - ignoreErrors = splsFlagsWithParams.HasKey(utils.MetaIgnoreErrors) - if splsFlagsWithParams.HasKey(utils.MetaEventCost) { - maxCost = utils.MetaRoutesEventCost - } + flags := argsFlagsWithParams[utils.MetaRoutes] + ignoreErrors := flags.Has(utils.MetaIgnoreErrors) + var maxCost string + if flags.Has(utils.MetaEventCost) { + maxCost = utils.MetaRoutesEventCost } for runID, cgrEv := range events { routesReply, err := sS.getRoutes(cgrEv.CGREvent.Clone(), cgrEv.ArgDispatcher, @@ -3230,9 +3220,9 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, } // process thresholds if required - if argsFlagsWithParams.HasKey(utils.MetaThresholds) { + if argsFlagsWithParams.GetBool(utils.MetaThresholds) { rply.ThresholdIDs = make(map[string][]string) - thIDs := argsFlagsWithParams.ParamsSlice(utils.MetaThresholds) + thIDs := argsFlagsWithParams.ParamsSlice(utils.MetaThresholds, utils.MetaIDs) for runID, cgrEv := range events { tIDs, err := sS.processThreshold(cgrEv.CGREvent, cgrEv.ArgDispatcher, thIDs) if err != nil && err.Error() != utils.ErrNotFound.Error() { @@ -3246,9 +3236,9 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, } // process stats if required - if argsFlagsWithParams.HasKey(utils.MetaStats) { + if argsFlagsWithParams.GetBool(utils.MetaStats) { rply.StatQueueIDs = make(map[string][]string) - stIDs := argsFlagsWithParams.ParamsSlice(utils.MetaStats) + stIDs := argsFlagsWithParams.ParamsSlice(utils.MetaStats, utils.MetaIDs) for runID, cgrEv := range events { sIDs, err := sS.processStats(cgrEv.CGREvent, cgrEv.ArgDispatcher, stIDs) if err != nil && @@ -3262,7 +3252,7 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, } } - if argsFlagsWithParams.HasKey(utils.MetaSTIRAuthenticate) { + if argsFlagsWithParams.GetBool(utils.MetaSTIRAuthenticate) { for _, cgrEv := range events { ev := engine.MapEvent(cgrEv.CGREvent.Event) opts := engine.MapEvent(cgrEv.Opts) @@ -3283,7 +3273,7 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, return utils.NewSTIRError(err.Error()) } } - } else if argsFlagsWithParams.HasKey(utils.MetaSTIRInitiate) { + } else if argsFlagsWithParams.GetBool(utils.MetaSTIRInitiate) { rply.STIRIdentity = make(map[string]string) for runID, cgrEv := range events { ev := engine.MapEvent(cgrEv.CGREvent.Event) @@ -3319,12 +3309,12 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, } // check for *resources - if argsFlagsWithParams.HasKey(utils.MetaResources) { + if argsFlagsWithParams.GetBool(utils.MetaResources) { if len(sS.cgrCfg.SessionSCfg().ResSConns) == 0 { return utils.NewErrNotConnected(utils.ResourceS) } rply.ResourceAllocation = make(map[string]string) - if resOpt := argsFlagsWithParams.ParamsSlice(utils.MetaResources); len(resOpt) != 0 { + if resOpt := argsFlagsWithParams[utils.MetaResources]; len(resOpt) != 0 { for runID, cgrEv := range events { originID := engine.MapEvent(cgrEv.CGREvent.Event).GetStringIgnoreErrors(utils.OriginID) if originID == "" { @@ -3340,24 +3330,20 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, var resMessage string // check what we need to do for resources (*authorization/*allocation) //check for subflags and convert them into utils.FlagsWithParams - resourceFlagsWithParams, err := utils.FlagsWithParamsFromSlice(resOpt) - if err != nil { - return err - } switch { - case resourceFlagsWithParams.HasKey(utils.MetaAuthorize): + case resOpt.Has(utils.MetaAuthorize): if err = sS.connMgr.Call(sS.cgrCfg.SessionSCfg().ResSConns, nil, utils.ResourceSv1AuthorizeResources, attrRU, &resMessage); err != nil { return utils.NewErrResourceS(err) } rply.ResourceAllocation[runID] = resMessage - case resourceFlagsWithParams.HasKey(utils.MetaAllocate): + case resOpt.Has(utils.MetaAllocate): if err = sS.connMgr.Call(sS.cgrCfg.SessionSCfg().ResSConns, nil, utils.ResourceSv1AllocateResources, attrRU, &resMessage); err != nil { return utils.NewErrResourceS(err) } rply.ResourceAllocation[runID] = resMessage - case resourceFlagsWithParams.HasKey(utils.MetaRelease): + case resOpt.Has(utils.MetaRelease): if err = sS.connMgr.Call(sS.cgrCfg.SessionSCfg().ResSConns, nil, utils.ResourceSv1ReleaseResources, attrRU, &resMessage); err != nil { return utils.NewErrResourceS(err) @@ -3370,12 +3356,11 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, // check what we need to do for RALs (*authorize/*initiate/*update/*terminate) dbtItvl := sS.cgrCfg.SessionSCfg().DebitInterval - if argsFlagsWithParams.HasKey(utils.MetaRALs) { - if ralsOpts := argsFlagsWithParams.ParamsSlice(utils.MetaRALs); len(ralsOpts) != 0 { + if argsFlagsWithParams.GetBool(utils.MetaRALs) { + if ralsOpts := argsFlagsWithParams[utils.MetaRALs]; len(ralsOpts) != 0 { //check for subflags and convert them into utils.FlagsWithParams - ralsFlagsWithParams, err := utils.FlagsWithParamsFromSlice(ralsOpts) // check for *cost - if ralsFlagsWithParams.HasKey(utils.MetaCost) { + if ralsOpts.Has(utils.MetaCost) { rply.Cost = make(map[string]float64) for runID, cgrEv := range events { ev := engine.MapEvent(cgrEv.CGREvent.Event) @@ -3406,7 +3391,7 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, Destination: ev.GetStringIgnoreErrors(utils.Destination), TimeStart: startTime, TimeEnd: startTime.Add(ev.GetDurationIgnoreErrors(utils.Usage)), - ForceDuration: ralsFlagsWithParams.HasKey(utils.MetaFD), + ForceDuration: ralsOpts.Has(utils.MetaFD), } var cc engine.CallCost if err = sS.connMgr.Call(sS.cgrCfg.SessionSCfg().RALsConns, nil, @@ -3423,16 +3408,16 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, originID := ev.GetStringIgnoreErrors(utils.OriginID) switch { //check for auth session - case ralsFlagsWithParams.HasKey(utils.MetaAuthorize): + case ralsOpts.Has(utils.MetaAuthorize): if rply.MaxUsage, err = sS.authEvent(&utils.CGREventWithOpts{ CGREvent: args.CGREvent, Opts: args.Opts, ArgDispatcher: args.ArgDispatcher, - }, ralsFlagsWithParams.HasKey(utils.MetaFD)); err != nil { + }, ralsOpts.Has(utils.MetaFD)); err != nil { return err } // check for init session - case ralsFlagsWithParams.HasKey(utils.MetaInitiate): + case ralsOpts.Has(utils.MetaInitiate): if opts.HasField(utils.OptsDebitInterval) { // dynamic DebitInterval via CGRDebitInterval if dbtItvl, err = opts.GetDuration(utils.OptsDebitInterval); err != nil { return utils.NewErrRALs(err) @@ -3443,7 +3428,7 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, Opts: args.Opts, ArgDispatcher: args.ArgDispatcher, }, sS.biJClntID(clnt), originID, dbtItvl, false, - ralsFlagsWithParams.HasKey(utils.MetaFD)) + ralsOpts.Has(utils.MetaFD)) if err != nil { return err } @@ -3455,7 +3440,7 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, return utils.NewErrRALs(err) } //check for update session - case ralsFlagsWithParams.HasKey(utils.MetaUpdate): + case ralsOpts.Has(utils.MetaUpdate): if opts.HasField(utils.OptsDebitInterval) { // dynamic DebitInterval via CGRDebitInterval if dbtItvl, err = opts.GetDuration(utils.OptsDebitInterval); err != nil { return utils.NewErrRALs(err) @@ -3471,7 +3456,7 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, Opts: args.Opts, ArgDispatcher: args.ArgDispatcher, }, sS.biJClntID(clnt), ev.GetStringIgnoreErrors(utils.OriginID), - dbtItvl, false, ralsFlagsWithParams.HasKey(utils.MetaFD)); err != nil { + dbtItvl, false, ralsOpts.Has(utils.MetaFD)); err != nil { return err } } @@ -3479,7 +3464,7 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, return utils.NewErrRALs(err) } // check for terminate session - case ralsFlagsWithParams.HasKey(utils.MetaTerminate): + case ralsOpts.Has(utils.MetaTerminate): if opts.HasField(utils.OptsDebitInterval) { // dynamic DebitInterval via CGRDebitInterval if dbtItvl, err = opts.GetDuration(utils.OptsDebitInterval); err != nil { return utils.NewErrRALs(err) @@ -3495,7 +3480,7 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, Opts: args.Opts, ArgDispatcher: args.ArgDispatcher, }, sS.biJClntID(clnt), ev.GetStringIgnoreErrors(utils.OriginID), - dbtItvl, false, ralsFlagsWithParams.HasKey(utils.MetaFD)); err != nil { + dbtItvl, false, ralsOpts.Has(utils.MetaFD)); err != nil { return err } } @@ -3510,12 +3495,12 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector, } } - if argsFlagsWithParams.HasKey(utils.MetaCDRs) { + if argsFlagsWithParams.GetBool(utils.MetaCDRs) { var cdrRply string for _, cgrEv := range events { if err := sS.connMgr.Call(sS.cgrCfg.SessionSCfg().CDRsConns, nil, utils.CDRsV1ProcessEvent, &engine.ArgV1ProcessEvent{ - Flags: argsFlagsWithParams[utils.MetaCDRs], + Flags: argsFlagsWithParams[utils.MetaCDRs].SliceFlags(), CGREvent: *cgrEv.CGREvent, ArgDispatcher: cgrEv.ArgDispatcher, }, &cdrRply); err != nil { @@ -3571,14 +3556,11 @@ func (sS *SessionS) BiRPCv1GetCost(clnt rpcclient.ClientConnector, } //convert from Flags []string to utils.FlagsWithParams - var argsFlagsWithParams utils.FlagsWithParams - if argsFlagsWithParams, err = utils.FlagsWithParamsFromSlice(args.Flags); err != nil { - return - } + argsFlagsWithParams := utils.FlagsWithParamsFromSlice(args.Flags) // check for *attribute - if argsFlagsWithParams.HasKey(utils.MetaAttributes) { + if argsFlagsWithParams.Has(utils.MetaAttributes) { rplyAttr, err := sS.processAttributes(args.CGREvent, args.ArgDispatcher, - argsFlagsWithParams.ParamsSlice(utils.MetaAttributes), args.Opts) + argsFlagsWithParams.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), args.Opts) if err == nil { args.CGREvent = rplyAttr.CGREvent.Clone() args.Opts = rplyAttr.Opts diff --git a/utils/consts.go b/utils/consts.go index 6626ef69a..bc5e035bf 100755 --- a/utils/consts.go +++ b/utils/consts.go @@ -2259,8 +2259,17 @@ const ( OptsAPIKey = "*dispatcherApiKey" OptsRouteID = "*dispatcherRouteID" // Others - OptsContext = "*context" + OptsContext = "*context" +) + +// Event Flags +const ( MetaDerivedReply = "*derivedreply" + + MetaIDs = "*ids" + + TrueStr = "true" + FalseStr = "false" ) func buildCacheInstRevPrefixes() { diff --git a/utils/map.go b/utils/map.go index f6fb95b54..b7763d213 100644 --- a/utils/map.go +++ b/utils/map.go @@ -261,6 +261,18 @@ func (fWp FlagParams) ParamsSlice(opt string) (ps []string) { return fWp[opt] // if it doesn't have the option it will return an empty slice } +// SliceFlags converts from FlagsParams to []string +func (fWp FlagParams) SliceFlags() (sls []string) { + for key, sub := range fWp { + if len(sub) == 0 { // no option for these subsystem + sls = append(sls, key) + continue + } + sls = append(sls, ConcatenatedKey(key, strings.Join(sub, INFIELD_SEP))) + } + return +} + // FlagsWithParams should store a list of flags for each subsystem type FlagsWithParams map[string]FlagParams @@ -305,5 +317,5 @@ func (fWp FlagsWithParams) GetBool(key string) (b bool) { if v == nil || len(v) == 0 { return true // empty map } - return !v.Has("*disabled") // check if has *disable param + return v.Has(TrueStr) || !v.Has(FalseStr) } diff --git a/utils/map_test.go b/utils/map_test.go index 9d4e288ca..e58d82359 100644 --- a/utils/map_test.go +++ b/utils/map_test.go @@ -200,9 +200,9 @@ func TestMapSubsystemIDsFromSlice(t *testing.T) { sls := []string{"*event", "*thresholds:*ids:ID1;ID2;ID3", "*thresholds:*derivedreply", "*attributes:*disabled", "*stats:*ids:ID"} eMp := FlagsWithParams{ "*event": map[string][]string{}, - "*thresholds": map[string][]string{"*ids": {"ID1", "ID2", "ID3"}, MetaDerivedReply: {}}, + "*thresholds": map[string][]string{MetaIDs: {"ID1", "ID2", "ID3"}, MetaDerivedReply: {}}, "*attributes": map[string][]string{"*disabled": {}}, - "*stats": map[string][]string{"*ids": {"ID"}}, + "*stats": map[string][]string{MetaIDs: {"ID"}}, } if mp := FlagsWithParamsFromSlice(sls); !reflect.DeepEqual(mp, eMp) { t.Errorf("Expecting: %+v, received: %+v", eMp, mp) @@ -213,9 +213,9 @@ func TestMapSubsystemIDsHasKey(t *testing.T) { sls := []string{"*event", "*thresholds:*ids:ID1;ID2;ID3", "*attributes", "*stats:*ids:ID"} eMp := FlagsWithParams{ "*event": map[string][]string{}, - "*thresholds": map[string][]string{"*ids": {"ID1", "ID2", "ID3"}}, + "*thresholds": map[string][]string{MetaIDs: {"ID1", "ID2", "ID3"}}, "*attributes": map[string][]string{}, - "*stats": map[string][]string{"*ids": {"ID"}}, + "*stats": map[string][]string{MetaIDs: {"ID"}}, } mp := FlagsWithParamsFromSlice(sls) if !reflect.DeepEqual(mp, eMp) { @@ -236,23 +236,23 @@ func TestMapSubsystemIDsGetIDs(t *testing.T) { sls := []string{"*event", "*thresholds:*ids:ID1;ID2;ID3", "*attributes", "*stats:*ids:ID"} eMp := FlagsWithParams{ "*event": map[string][]string{}, - "*thresholds": map[string][]string{"*ids": {"ID1", "ID2", "ID3"}}, + "*thresholds": map[string][]string{MetaIDs: {"ID1", "ID2", "ID3"}}, "*attributes": map[string][]string{}, - "*stats": map[string][]string{"*ids": {"ID"}}, + "*stats": map[string][]string{MetaIDs: {"ID"}}, } mp := FlagsWithParamsFromSlice(sls) if !reflect.DeepEqual(mp, eMp) { t.Errorf("Expecting: %+v, received: %+v", eMp, mp) } eIDs := []string{"ID1", "ID2", "ID3"} - if ids := mp.ParamsSlice("*thresholds", "*ids"); !reflect.DeepEqual(ids, eIDs) { + if ids := mp.ParamsSlice("*thresholds", MetaIDs); !reflect.DeepEqual(ids, eIDs) { t.Errorf("Expecting: %+v, received: %+v", eIDs, ids) } eIDs = nil - if ids := mp.ParamsSlice("*event", "*ids"); !reflect.DeepEqual(ids, eIDs) { + if ids := mp.ParamsSlice("*event", MetaIDs); !reflect.DeepEqual(ids, eIDs) { t.Errorf("Expecting: %+v, received: %+v", eIDs, ids) } - if ids := mp.ParamsSlice("*test", "*ids"); !reflect.DeepEqual(ids, eIDs) { + if ids := mp.ParamsSlice("*test", MetaIDs); !reflect.DeepEqual(ids, eIDs) { t.Errorf("Expecting: %+v, received: %+v", eIDs, ids) } } @@ -261,9 +261,9 @@ func TestFlagsToSlice(t *testing.T) { sls := []string{"*event", "*thresholds:*ids:ID1;ID2;ID3", "*attributes", "*stats:*ids:ID", "*routes:*derivedreply"} eMp := FlagsWithParams{ "*event": map[string][]string{}, - "*thresholds": map[string][]string{"*ids": {"ID1", "ID2", "ID3"}}, + "*thresholds": map[string][]string{MetaIDs: {"ID1", "ID2", "ID3"}}, "*attributes": map[string][]string{}, - "*stats": map[string][]string{"*ids": {"ID"}}, + "*stats": map[string][]string{MetaIDs: {"ID"}}, "*routes": map[string][]string{MetaDerivedReply: {}}, } mp := FlagsWithParamsFromSlice(sls) @@ -280,8 +280,9 @@ func TestFlagsToSlice(t *testing.T) { func TestFlagsWithParamsGetBool(t *testing.T) { flagsWithParams := &FlagsWithParams{ - "test": map[string][]string{"*disabled": {}, "string2": {}}, + "test": map[string][]string{"false": {}, "string2": {}}, "test2": map[string][]string{"string2": {}}, + "test3": map[string][]string{"true": {}}, "empty": map[string][]string{}, } key := "notpresent" @@ -300,15 +301,48 @@ func TestFlagsWithParamsGetBool(t *testing.T) { if rcv := flagsWithParams.GetBool(key); rcv != true { t.Errorf("Expecting: true, received: %+v", ToJSON(rcv)) } + key = "test3" + if rcv := flagsWithParams.GetBool(key); rcv != true { + t.Errorf("Expecting: true, received: %+v", ToJSON(rcv)) + } } func TestFlagParamsAdd(t *testing.T) { flgs := make(FlagParams) exp := FlagParams{ - "*ids": []string{"id1", "id2"}, + MetaIDs: []string{"id1", "id2"}, } - flgs.Add([]string{"*ids", "id1;id2", "ignored"}) + flgs.Add([]string{MetaIDs, "id1;id2", "ignored"}) if !reflect.DeepEqual(flgs, exp) { t.Errorf("Expecting: %+v, received: %+v", exp, flgs) } } + +func TestFlagsToSlice2(t *testing.T) { + sls := []string{"*event", "*thresholds:*ids:ID1;ID2;ID3", "*attributes", "*stats:*ids:ID", "*routes:*derivedreply", "*cdrs:*attributes", "*cdrs:*stats:ID"} + eMp := FlagsWithParams{ + "*event": map[string][]string{}, + "*thresholds": map[string][]string{MetaIDs: {"ID1", "ID2", "ID3"}}, + "*attributes": map[string][]string{}, + "*stats": map[string][]string{MetaIDs: {"ID"}}, + "*routes": map[string][]string{MetaDerivedReply: {}}, + "*cdrs": map[string][]string{MetaAttributes: {}, MetaStats: {"ID"}}, + } + mp := FlagsWithParamsFromSlice(sls) + if !reflect.DeepEqual(mp, eMp) { + t.Errorf("Expecting: %+v, received: %+v", ToJSON(eMp), ToJSON(mp)) + } + sort.Strings(sls) + flgSls := mp.SliceFlags() + sort.Strings(flgSls) + if !reflect.DeepEqual(flgSls, sls) { + t.Errorf("Expecting: %+v, received: %+v", sls, flgSls) + } + + sls = []string{"*attributes", "*stats:ID"} + flgSls = mp["*cdrs"].SliceFlags() + sort.Strings(flgSls) + if !reflect.DeepEqual(flgSls, sls) { + t.Errorf("Expecting: %+v, received: %+v", sls, flgSls) + } +}