From 5d540bc17942ae5bdc8d83b8fa91f1dc99c514a1 Mon Sep 17 00:00:00 2001 From: Trial97 Date: Fri, 1 Oct 2021 16:03:08 +0300 Subject: [PATCH] Updated Sessions Auth API --- accounts/libaccounts.go | 9 +- agents/astagent.go | 6 +- agents/asterisk_event.go | 25 +---- agents/asterisk_event_test.go | 53 --------- agents/diamagent_test.go | 31 +++--- agents/fsagent.go | 6 +- agents/fsevent.go | 19 ---- agents/fsevent_test.go | 36 ------ agents/kamagent.go | 4 +- agents/kamevent.go | 32 ++---- agents/kamevent_test.go | 118 +++----------------- agents/libagents.go | 19 +--- agents/radagent.go | 19 +--- agents/sipagent.go | 19 +--- apis/sessions.go | 4 +- console/session_authorize_event.go | 8 +- dispatchers/sessions.go | 16 +-- dispatchers/sessions_test.go | 24 ++-- ers/ers.go | 17 +-- sessions/libsessions.go | 84 -------------- sessions/sessions.go | 91 ++++++--------- sessions/sessions_test.go | 171 ----------------------------- 22 files changed, 113 insertions(+), 698 deletions(-) diff --git a/accounts/libaccounts.go b/accounts/libaccounts.go index 56ce38059..56ef833a7 100644 --- a/accounts/libaccounts.go +++ b/accounts/libaccounts.go @@ -111,14 +111,17 @@ func processAttributeS(ctx *context.Context, connMgr *engine.ConnManager, cgrEv // rateSCostForEvent will process the event with RateS in order to get the cost func rateSCostForEvent(ctx *context.Context, connMgr *engine.ConnManager, cgrEv *utils.CGREvent, - rateSConns, rpIDs []string) (rplyCost *utils.RateProfileCost, err error) { + rateSConns, rpIDs []string) (_ *utils.RateProfileCost, err error) { if len(rateSConns) == 0 { return nil, utils.NewErrNotConnected(utils.RateS) } + tmp := cgrEv.APIOpts[utils.OptsRatesRateProfileIDs] cgrEv.APIOpts[utils.OptsRatesRateProfileIDs] = utils.CloneStringSlice(rpIDs) var tmpReply utils.RateProfileCost - if err = connMgr.Call(ctx, rateSConns, utils.RateSv1CostForEvent, - cgrEv, &tmpReply); err != nil { + err = connMgr.Call(ctx, rateSConns, utils.RateSv1CostForEvent, + cgrEv, &tmpReply) + cgrEv.APIOpts[utils.OptsRatesRateProfileIDs] = tmp + if err != nil { return } return &tmpReply, nil diff --git a/agents/astagent.go b/agents/astagent.go index 12da522e4..0e322b668 100644 --- a/agents/astagent.go +++ b/agents/astagent.go @@ -166,7 +166,7 @@ func (sma *AsteriskAgent) handleStasisStart(ev *SMAsteriskEvent) { return } //authorize Session - authArgs := ev.V1AuthorizeArgs() + authArgs := ev.AsCGREvent() if authArgs == nil { sma.hangupChannel(ev.ChannelID(), fmt.Sprintf("<%s> event: %s cannot generate auth session arguments", @@ -199,7 +199,7 @@ func (sma *AsteriskAgent) handleStasisStart(ev *SMAsteriskEvent) { } } } - if authArgs.GetMaxUsage { + if utils.OptAsBool(authArgs.APIOpts, utils.OptsAccountS) { if authReply.MaxUsage == nil || authReply.MaxUsage.Compare(utils.NewDecimal(0, 0)) == 0 { sma.hangupChannel(ev.ChannelID(), "") @@ -235,7 +235,7 @@ func (sma *AsteriskAgent) handleStasisStart(ev *SMAsteriskEvent) { } // Done with processing event, cache it for later use sma.evCacheMux.Lock() - sma.eventsCache[ev.ChannelID()] = authArgs.CGREvent + sma.eventsCache[ev.ChannelID()] = authArgs sma.evCacheMux.Unlock() } diff --git a/agents/asterisk_event.go b/agents/asterisk_event.go index f79ba3de5..07996dcef 100644 --- a/agents/asterisk_event.go +++ b/agents/asterisk_event.go @@ -19,11 +19,9 @@ along with this program. If not, see package agents import ( - "fmt" "strings" "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/sessions" "github.com/cgrates/cgrates/utils" ) @@ -269,31 +267,12 @@ func (smaEv *SMAsteriskEvent) AsMapStringInterface() (mp map[string]interface{}) } // AsCGREvent converts AsteriskEvent into CGREvent -func (smaEv *SMAsteriskEvent) AsCGREvent() (cgrEv *utils.CGREvent, err error) { - cgrEv = &utils.CGREvent{ +func (smaEv *SMAsteriskEvent) AsCGREvent() *utils.CGREvent { + return &utils.CGREvent{ Tenant: utils.FirstNonEmpty(smaEv.Tenant(), config.CgrConfig().GeneralCfg().DefaultTenant), ID: utils.UUIDSha1Prefix(), Event: smaEv.AsMapStringInterface(), APIOpts: smaEv.opts, } - return -} - -func (smaEv *SMAsteriskEvent) V1AuthorizeArgs() (args *sessions.V1AuthorizeArgs) { - cgrEv, err := smaEv.AsCGREvent() - if err != nil { - return - } - args = &sessions.V1AuthorizeArgs{ - CGREvent: cgrEv, - } - if smaEv.Subsystems() == utils.EmptyString { - utils.Logger.Warning(fmt.Sprintf("<%s> cgr_flags variable is not set, using defaults", - utils.AsteriskAgent)) - args.GetMaxUsage = true - return - } - args.ParseFlags(smaEv.Subsystems(), utils.PlusChar) - return } diff --git a/agents/asterisk_event_test.go b/agents/asterisk_event_test.go index 4ecb64574..25a4c5dbd 100644 --- a/agents/asterisk_event_test.go +++ b/agents/asterisk_event_test.go @@ -23,7 +23,6 @@ import ( "testing" "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/sessions" ) var ( @@ -340,58 +339,6 @@ func TestSMAEventExtraParameters(t *testing.T) { } } -func TestSMAEventV1AuthorizeArgs(t *testing.T) { - var ev map[string]interface{} - if err := json.Unmarshal([]byte(stasisStart), &ev); err != nil { - t.Error(err) - } - smaEv := NewSMAsteriskEvent(ev, "127.0.0.1", "") - cgrEv, err := smaEv.AsCGREvent() - if err != nil { - t.Error(err) - } - exp := &sessions.V1AuthorizeArgs{ - GetMaxUsage: true, - CGREvent: cgrEv, - } - if rcv := smaEv.V1AuthorizeArgs(); !reflect.DeepEqual(exp.GetMaxUsage, rcv.GetMaxUsage) { - t.Errorf("Expecting: %+v, received: %+v", exp.GetMaxUsage, rcv.GetMaxUsage) - } - - stasisStart2 := `{"type":"StasisStart","timestamp":"2018-11-25T05:03:26.464-0500","args":["cgr_reqtype=*prepaid","cgr_route=route1","cgr_flags=*accounts+*attributes+*resources+*stats+*routes+*thresholds"],"channel":{"id":"1543140206.0","dialplan":{"context":"internal","exten":"1002","priority":4},"caller":{"name":"","number":"1001"},"name":"PJSIP/1001-00000000","state":"Ring","connected":{"name":"","number":""},"language":"en","accountcode":"","creationtime":"2018-11-25T05:03:26.463-0500"},"asterisk_id":"08:00:27:b7:b8:1f","application":"cgrates_auth"}` - var ev2 map[string]interface{} - if err := json.Unmarshal([]byte(stasisStart2), &ev2); err != nil { - t.Error(err) - } - smaEv2 := NewSMAsteriskEvent(ev2, "127.0.0.1", "") - //smaEv2.parseStasisArgs() - cgrEv2, err := smaEv2.AsCGREvent() - if err != nil { - t.Error(err) - } - - exp2 := &sessions.V1AuthorizeArgs{ - GetAttributes: true, - AuthorizeResources: true, - GetMaxUsage: true, - ProcessThresholds: true, - ProcessStats: true, - GetRoutes: true, - CGREvent: cgrEv2, - } - if rcv := smaEv2.V1AuthorizeArgs(); !reflect.DeepEqual(exp2.GetAttributes, rcv.GetAttributes) { - t.Errorf("Expecting: %+v, received: %+v", exp2.GetAttributes, rcv.GetAttributes) - } else if !reflect.DeepEqual(exp2.AuthorizeResources, rcv.AuthorizeResources) { - t.Errorf("Expecting: %+v, received: %+v", exp2.AuthorizeResources, rcv.AuthorizeResources) - } else if !reflect.DeepEqual(exp2.GetMaxUsage, rcv.GetMaxUsage) { - t.Errorf("Expecting: %+v, received: %+v", exp2.GetMaxUsage, rcv.GetMaxUsage) - } else if !reflect.DeepEqual(exp2.ProcessThresholds, rcv.ProcessThresholds) { - t.Errorf("Expecting: %+v, received: %+v", exp2.ProcessThresholds, rcv.ProcessThresholds) - } else if !reflect.DeepEqual(exp2.ProcessStats, rcv.ProcessStats) { - t.Errorf("Expecting: %+v, received: %+v", exp2.ProcessStats, rcv.ProcessStats) - } -} - func TestRequestType(t *testing.T) { var ev map[string]interface{} if err := json.Unmarshal([]byte(stasisStart), &ev); err != nil { diff --git a/agents/diamagent_test.go b/agents/diamagent_test.go index 89d3a620d..011090a41 100644 --- a/agents/diamagent_test.go +++ b/agents/diamagent_test.go @@ -128,27 +128,24 @@ func TestProcessRequest(t *testing.T) { var id string if arg == nil { t.Errorf("args is nil") - } else if rargs, can := arg.(*sessions.V1AuthorizeArgs); !can { - t.Errorf("args is not of sessions.V1AuthorizeArgs type") + } else if rargs, can := arg.(*utils.CGREvent); !can { + t.Errorf("args is not of utils.CGREvent type") } else { id = rargs.ID } - expargs := &sessions.V1AuthorizeArgs{ - GetMaxUsage: true, - CGREvent: &utils.CGREvent{ - Tenant: "cgrates.org", - ID: id, - Event: map[string]interface{}{ - "Account": "1001", - "Category": "call", - "Destination": "1003", - "OriginHost": "local", - "OriginID": "123456", - "ToR": "*voice", - "Usage": "10s", - }, - APIOpts: map[string]interface{}{}, + expargs := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: id, + Event: map[string]interface{}{ + "Account": "1001", + "Category": "call", + "Destination": "1003", + "OriginHost": "local", + "OriginID": "123456", + "ToR": "*voice", + "Usage": "10s", }, + APIOpts: map[string]interface{}{}, } if !reflect.DeepEqual(expargs, arg) { t.Errorf("Expected:%s ,received: %s", utils.ToJSON(expargs), utils.ToJSON(arg)) diff --git a/agents/fsagent.go b/agents/fsagent.go index 791283c71..97f6eba2e 100644 --- a/agents/fsagent.go +++ b/agents/fsagent.go @@ -149,8 +149,8 @@ func (fsa *FSsessions) onChannelPark(fsev FSEvent, connIdx int) { return } fsev[VarCGROriginHost] = utils.FirstNonEmpty(fsev[VarCGROriginHost], fsa.cfg.EventSocketConns[connIdx].Alias) // rewrite the OriginHost variable if it is empty - authArgs := fsev.V1AuthorizeArgs() - authArgs.CGREvent.Event[FsConnID] = connIdx // Attach the connection ID + authArgs := fsev.AsCGREvent(fsa.timezone) + authArgs.Event[FsConnID] = connIdx // Attach the connection ID var authReply sessions.V1AuthorizeReply if err := fsa.connMgr.Call(fsa.ctx, fsa.cfg.SessionSConns, utils.SessionSv1AuthorizeEvent, authArgs, &authReply); err != nil { utils.Logger.Err( @@ -178,7 +178,7 @@ func (fsa *FSsessions) onChannelPark(fsev FSEvent, connIdx int) { } } } - if authArgs.GetMaxUsage { + if utils.OptAsBool(authArgs.APIOpts, utils.OptsAccountS) { if authReply.MaxUsage == nil || authReply.MaxUsage.Compare(utils.NewDecimal(0, 0)) == 0 { fsa.unparkCall(fsev.GetUUID(), connIdx, diff --git a/agents/fsevent.go b/agents/fsevent.go index 3d7eed577..1b6b2ffa1 100644 --- a/agents/fsevent.go +++ b/agents/fsevent.go @@ -25,7 +25,6 @@ import ( "time" "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/sessions" "github.com/cgrates/cgrates/utils" "github.com/cgrates/fsock" ) @@ -391,24 +390,6 @@ func (fsev FSEvent) AsMapStringInterface(timezone string) map[string]interface{} return mp } -// V1AuthorizeArgs returns the arguments used in SMGv1.Authorize -func (fsev FSEvent) V1AuthorizeArgs() (args *sessions.V1AuthorizeArgs) { - cgrEv := fsev.AsCGREvent(config.CgrConfig().GeneralCfg().DefaultTimezone) - cgrEv.Event[utils.Usage] = config.CgrConfig().SessionSCfg().GetDefaultUsage(utils.IfaceAsString(cgrEv.Event[utils.ToR])) // no billsec available in auth - args = &sessions.V1AuthorizeArgs{ // defaults - CGREvent: cgrEv, - } - subsystems, has := fsev[VarCGRFlags] - if !has { - utils.Logger.Warning(fmt.Sprintf("<%s> cgr_flags variable is not set, using defaults", - utils.FreeSWITCHAgent)) - args.GetMaxUsage = true - return - } - args.ParseFlags(subsystems, utils.InfieldSep) - return -} - // SliceAsFsArray Converts a slice of strings into a FS array string, contains len(array) at first index since FS does not support len(ARRAY::) for now func SliceAsFsArray(slc []string) (arry string) { if len(slc) == 0 { diff --git a/agents/fsevent_test.go b/agents/fsevent_test.go index c5e76cf9b..dd75afb93 100644 --- a/agents/fsevent_test.go +++ b/agents/fsevent_test.go @@ -1004,39 +1004,3 @@ variable_rtp_audio_rtcp_octet_count: 0` t.Errorf("Expecting: %s, received: %s", fsCDR.CGRID, smCDR.CGRID) } } - -func TestFsEvV1AuthorizeArgs(t *testing.T) { - timezone := config.CgrConfig().GeneralCfg().DefaultTimezone - ev := NewFSEvent(hangupEv) - expected := &sessions.V1AuthorizeArgs{ - GetMaxUsage: true, - CGREvent: &utils.CGREvent{ - Tenant: ev.GetTenant(utils.MetaDefault), - ID: utils.UUIDSha1Prefix(), - Event: ev.AsMapStringInterface(timezone), - }, - GetRoutes: true, - GetAttributes: true, - RoutesIgnoreErrors: true, - RoutesMaxCost: utils.MetaEventCost, - } - expected.Event[utils.Usage] = config.CgrConfig().SessionSCfg().GetDefaultUsage(utils.MetaVoice) - rcv := ev.V1AuthorizeArgs() - if !reflect.DeepEqual(expected.CGREvent.Tenant, rcv.CGREvent.Tenant) { - t.Errorf("Expecting: %+v, received: %+v", expected.CGREvent.Tenant, rcv.CGREvent.Tenant) - } else if !reflect.DeepEqual(expected.CGREvent.Event, rcv.CGREvent.Event) { - t.Errorf("Expecting: %+v, received: %+v", expected.CGREvent.Event, rcv.CGREvent.Event) - } else if !reflect.DeepEqual(expected.CGREvent.Event, rcv.CGREvent.Event) { - t.Errorf("Expecting: %+v, received: %+v", expected.CGREvent.Event, rcv.CGREvent.Event) - } else if !reflect.DeepEqual(expected.GetMaxUsage, rcv.GetMaxUsage) { - t.Errorf("Expecting: %+v, received: %+v", expected.GetMaxUsage, rcv.GetMaxUsage) - } else if !reflect.DeepEqual(expected.GetRoutes, rcv.GetRoutes) { - t.Errorf("Expecting: %+v, received: %+v", expected.GetRoutes, rcv.GetRoutes) - } else if !reflect.DeepEqual(expected.GetAttributes, rcv.GetAttributes) { - t.Errorf("Expecting: %+v, received: %+v", expected.GetAttributes, rcv.GetAttributes) - } else if !reflect.DeepEqual(expected.RoutesMaxCost, rcv.RoutesMaxCost) { - t.Errorf("Expecting: %+v, received: %+v", expected.RoutesMaxCost, rcv.RoutesMaxCost) - } else if !reflect.DeepEqual(expected.RoutesIgnoreErrors, rcv.RoutesIgnoreErrors) { - t.Errorf("Expecting: %+v, received: %+v", expected.RoutesIgnoreErrors, rcv.RoutesIgnoreErrors) - } -} diff --git a/agents/kamagent.go b/agents/kamagent.go index 480256439..c9c564aae 100644 --- a/agents/kamagent.go +++ b/agents/kamagent.go @@ -134,13 +134,13 @@ func (ka *KamailioAgent) onCgrAuth(evData []byte, connIdx int) { } return } - authArgs := kev.V1AuthorizeArgs() + authArgs := kev.AsCGREvent(ka.timezone) if authArgs == nil { utils.Logger.Err(fmt.Sprintf("<%s> event: %s cannot generate auth session arguments", utils.KamailioAgent, kev[utils.OriginID])) return } - authArgs.CGREvent.Event[EvapiConnID] = connIdx // Attach the connection ID + authArgs.Event[EvapiConnID] = connIdx // Attach the connection ID var authReply sessions.V1AuthorizeReply // take the error after calling SessionSv1.AuthorizeEvent // and send it as parameter to AsKamAuthReply diff --git a/agents/kamevent.go b/agents/kamevent.go index 91424dd83..cd4556c74 100644 --- a/agents/kamevent.go +++ b/agents/kamevent.go @@ -20,7 +20,6 @@ package agents import ( "encoding/json" - "fmt" "strings" "github.com/cgrates/cgrates/config" @@ -169,25 +168,8 @@ func (kev KamEvent) String() string { return utils.ToJSON(kev) } -// V1AuthorizeArgs returns the arguments used in SessionSv1.AuthorizeEvent -func (kev KamEvent) V1AuthorizeArgs() (args *sessions.V1AuthorizeArgs) { - cgrEv := kev.AsCGREvent(config.CgrConfig().GeneralCfg().DefaultTimezone) - args = &sessions.V1AuthorizeArgs{ - CGREvent: cgrEv, - } - subsystems, has := kev[utils.CGRFlags] - if !has { - utils.Logger.Warning(fmt.Sprintf("<%s> cgr_flags variable is not set, using defaults", - utils.KamailioAgent)) - args.GetMaxUsage = true - return - } - args.ParseFlags(subsystems, utils.InfieldSep) - return -} - // AsKamAuthReply builds up a Kamailio AuthReply based on arguments and reply from SessionS -func (kev KamEvent) AsKamAuthReply(authArgs *sessions.V1AuthorizeArgs, +func (kev KamEvent) AsKamAuthReply(authArgs *utils.CGREvent, authReply *sessions.V1AuthorizeReply, rplyErr error) (kar *KamReply, err error) { evName := CGR_AUTH_REPLY if kamRouReply, has := kev[KamReplyRoute]; has { @@ -201,13 +183,13 @@ func (kev KamEvent) AsKamAuthReply(authArgs *sessions.V1AuthorizeArgs, kar.Error = rplyErr.Error() return } - if authArgs.GetAttributes && authReply.Attributes != nil { + if authReply.Attributes != nil { kar.Attributes = authReply.Attributes.Digest() } - if authArgs.AuthorizeResources && authReply.ResourceAllocation != nil { + if authReply.ResourceAllocation != nil { kar.ResourceAllocation = *authReply.ResourceAllocation } - if authArgs.GetMaxUsage { + if utils.OptAsBool(authArgs.APIOpts, utils.OptsAccountS) { if authReply.MaxUsage != nil { maxDur, _ := authReply.MaxUsage.Duration() kar.MaxUsage = maxDur.Seconds() @@ -215,14 +197,14 @@ func (kev KamEvent) AsKamAuthReply(authArgs *sessions.V1AuthorizeArgs, kar.MaxUsage = 0 } } - if authArgs.GetRoutes && authReply.RouteProfiles != nil { + if authReply.RouteProfiles != nil { kar.Routes = authReply.RouteProfiles.Digest() } - if authArgs.ProcessThresholds && authReply.ThresholdIDs != nil { + if authReply.ThresholdIDs != nil { kar.Thresholds = strings.Join(*authReply.ThresholdIDs, utils.FieldsSep) } - if authArgs.ProcessStats && authReply.StatQueueIDs != nil { + if authReply.StatQueueIDs != nil { kar.StatQueues = strings.Join(*authReply.StatQueueIDs, utils.FieldsSep) } return diff --git a/agents/kamevent_test.go b/agents/kamevent_test.go index f4b68eab2..fcd87c4d2 100644 --- a/agents/kamevent_test.go +++ b/agents/kamevent_test.go @@ -133,90 +133,6 @@ func TestKamEvAsCGREvent(t *testing.T) { } } -func TestKamEvV1AuthorizeArgs(t *testing.T) { - kamEv := KamEvent{"event": "CGR_CALL_END", - "callid": "46c01a5c249b469e76333fc6bfa87f6a@0:0:0:0:0:0:0:0", - "from_tag": "bf71ad59", "to_tag": "7351fecf", - "cgr_reqtype": utils.MetaPostpaid, "cgr_account": "1001", - "cgr_destination": "1002", "cgr_answertime": "1419839310", - "cgr_duration": "3", "cgr_pdd": "4", - utils.CGRRoute: "supplier2", - utils.CGRDisconnectCause: "200", - utils.CGRFlags: "*accounts;*routes;*routesEventCost;*rouIgnoreErrors"} - expected := &sessions.V1AuthorizeArgs{ - GetMaxUsage: true, - CGREvent: &utils.CGREvent{ - Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant], - config.CgrConfig().GeneralCfg().DefaultTenant), - ID: utils.UUIDSha1Prefix(), - Event: kamEv.AsMapStringInterface(), - }, - GetRoutes: true, - RoutesIgnoreErrors: true, - RoutesMaxCost: utils.MetaEventCost, - } - rcv := kamEv.V1AuthorizeArgs() - if !reflect.DeepEqual(expected.CGREvent.Tenant, rcv.CGREvent.Tenant) { - t.Errorf("Expecting: %+v, received: %+v", expected.CGREvent.Tenant, rcv.CGREvent.Tenant) - } else if !reflect.DeepEqual(expected.CGREvent.Event, rcv.CGREvent.Event) { - t.Errorf("Expecting: %+v, received: %+v", expected.CGREvent.Event, rcv.CGREvent.Event) - } else if !reflect.DeepEqual(expected.CGREvent.Event, rcv.CGREvent.Event) { - t.Errorf("Expecting: %+v, received: %+v", expected.CGREvent.Event, rcv.CGREvent.Event) - } else if !reflect.DeepEqual(expected.GetMaxUsage, rcv.GetMaxUsage) { - t.Errorf("Expecting: %+v, received: %+v", expected.GetMaxUsage, rcv.GetMaxUsage) - } else if !reflect.DeepEqual(expected.GetRoutes, rcv.GetRoutes) { - t.Errorf("Expecting: %+v, received: %+v", expected.GetRoutes, rcv.GetRoutes) - } else if !reflect.DeepEqual(expected.GetAttributes, rcv.GetAttributes) { - t.Errorf("Expecting: %+v, received: %+v", expected.GetAttributes, rcv.GetAttributes) - } else if !reflect.DeepEqual(expected.RoutesMaxCost, rcv.RoutesMaxCost) { - t.Errorf("Expecting: %+v, received: %+v", expected.RoutesMaxCost, rcv.RoutesMaxCost) - } else if !reflect.DeepEqual(expected.RoutesIgnoreErrors, rcv.RoutesIgnoreErrors) { - t.Errorf("Expecting: %+v, received: %+v", expected.RoutesIgnoreErrors, rcv.RoutesIgnoreErrors) - } -} - -func TestKamEvV1AuthorizeArgs2(t *testing.T) { - kamEv := KamEvent{"event": "CGR_CALL_END", - "callid": "46c01a5c249b469e76333fc6bfa87f6a@0:0:0:0:0:0:0:0", - "from_tag": "bf71ad59", "to_tag": "7351fecf", - "cgr_reqtype": utils.MetaPostpaid, "cgr_account": "1001", - "cgr_destination": "1002", "cgr_answertime": "1419839310", - "cgr_duration": "3", "cgr_pdd": "4", - utils.CGRRoute: "supplier2", - utils.CGRDisconnectCause: "200", - utils.CGRFlags: "*accounts;*routes;*rouMaxCost:100;*rouIgnoreErrors"} - expected := &sessions.V1AuthorizeArgs{ - GetMaxUsage: true, - CGREvent: &utils.CGREvent{ - Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant], - config.CgrConfig().GeneralCfg().DefaultTenant), - ID: utils.UUIDSha1Prefix(), - Event: kamEv.AsMapStringInterface(), - }, - GetRoutes: true, - RoutesIgnoreErrors: true, - RoutesMaxCost: "100", - } - rcv := kamEv.V1AuthorizeArgs() - if !reflect.DeepEqual(expected.CGREvent.Tenant, rcv.CGREvent.Tenant) { - t.Errorf("Expecting: %+v, received: %+v", expected.CGREvent.Tenant, rcv.CGREvent.Tenant) - } else if !reflect.DeepEqual(expected.CGREvent.Event, rcv.CGREvent.Event) { - t.Errorf("Expecting: %+v, received: %+v", expected.CGREvent.Event, rcv.CGREvent.Event) - } else if !reflect.DeepEqual(expected.CGREvent.Event, rcv.CGREvent.Event) { - t.Errorf("Expecting: %+v, received: %+v", expected.CGREvent.Event, rcv.CGREvent.Event) - } else if !reflect.DeepEqual(expected.GetMaxUsage, rcv.GetMaxUsage) { - t.Errorf("Expecting: %+v, received: %+v", expected.GetMaxUsage, rcv.GetMaxUsage) - } else if !reflect.DeepEqual(expected.GetRoutes, rcv.GetRoutes) { - t.Errorf("Expecting: %+v, received: %+v", expected.GetRoutes, rcv.GetRoutes) - } else if !reflect.DeepEqual(expected.GetAttributes, rcv.GetAttributes) { - t.Errorf("Expecting: %+v, received: %+v", expected.GetAttributes, rcv.GetAttributes) - } else if !reflect.DeepEqual(expected.RoutesMaxCost, rcv.RoutesMaxCost) { - t.Errorf("Expecting: %+v, received: %+v", expected.RoutesMaxCost, rcv.RoutesMaxCost) - } else if !reflect.DeepEqual(expected.RoutesIgnoreErrors, rcv.RoutesIgnoreErrors) { - t.Errorf("Expecting: %+v, received: %+v", expected.RoutesIgnoreErrors, rcv.RoutesIgnoreErrors) - } -} - func TestKamEvAsKamAuthReply(t *testing.T) { kamEv := KamEvent{"event": "CGR_CALL_END", "callid": "46c01a5c249b469e76333fc6bfa87f6a@0:0:0:0:0:0:0:0", @@ -225,15 +141,14 @@ func TestKamEvAsKamAuthReply(t *testing.T) { "cgr_destination": "1002", "cgr_answertime": "1419839310", "cgr_duration": "3", "cgr_pdd": "4", utils.CGRRoute: "supplier2", - utils.CGRDisconnectCause: "200"} - authArgs := &sessions.V1AuthorizeArgs{ - GetMaxUsage: true, - CGREvent: &utils.CGREvent{ - Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant], - config.CgrConfig().GeneralCfg().DefaultTenant), - ID: utils.UUIDSha1Prefix(), - Event: kamEv.AsMapStringInterface(), - }, + utils.CGRDisconnectCause: "200", + utils.OptsAccountS: "true"} + authArgs := &utils.CGREvent{ + Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant], + config.CgrConfig().GeneralCfg().DefaultTenant), + ID: utils.UUIDSha1Prefix(), + Event: kamEv.AsMapStringInterface(), + APIOpts: kamEv.GetOptions(), } authRply := &sessions.V1AuthorizeReply{ MaxUsage: utils.NewDecimalFromFloat64(5 * float64(time.Second)), @@ -249,15 +164,14 @@ func TestKamEvAsKamAuthReply(t *testing.T) { } kamEv = KamEvent{"event": "CGR_PROFILE_REQUEST", "Tenant": "cgrates.org", "Account": "1001", - KamReplyRoute: "CGR_PROFILE_REPLY"} - authArgs = &sessions.V1AuthorizeArgs{ - GetAttributes: true, - CGREvent: &utils.CGREvent{ - Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant], - config.CgrConfig().GeneralCfg().DefaultTenant), - ID: utils.UUIDSha1Prefix(), - Event: kamEv.AsMapStringInterface(), - }, + KamReplyRoute: "CGR_PROFILE_REPLY", + utils.OptsAttributeS: "true"} + authArgs = &utils.CGREvent{ + Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant], + config.CgrConfig().GeneralCfg().DefaultTenant), + ID: utils.UUIDSha1Prefix(), + Event: kamEv.AsMapStringInterface(), + APIOpts: kamEv.GetOptions(), } authRply = &sessions.V1AuthorizeReply{ Attributes: &engine.AttrSProcessEventReply{ diff --git a/agents/libagents.go b/agents/libagents.go index 5c3f39098..5c60d227e 100644 --- a/agents/libagents.go +++ b/agents/libagents.go @@ -64,25 +64,10 @@ func processRequest(ctx *context.Context, reqProcessor *config.RequestProcessor, fmt.Sprintf("<%s> DRY_RUN, processorID: %s, DiameterMessage: %s", agentName, reqProcessor.ID, agReq.Request.String())) case utils.MetaAuthorize: - authArgs := sessions.NewV1AuthorizeArgs( - reqProcessor.Flags.GetBool(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), - reqProcessor.Flags.GetBool(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), - reqProcessor.Flags.GetBool(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), - reqProcessor.Flags.GetBool(utils.MetaResources), - reqProcessor.Flags.Has(utils.MetaAccounts), - reqProcessor.Flags.GetBool(utils.MetaRoutes), - reqProcessor.Flags.Has(utils.OptsRoutesIgnoreErrors), - reqProcessor.Flags.Has(utils.MetaRoutesEventCost), - cgrEv, reqProcessor.Flags.Has(utils.MetaFD), - reqProcessor.Flags.ParamValue(utils.OptsRoutesMaxCost), - ) rply := new(sessions.V1AuthorizeReply) err = connMgr.Call(ctx, sessionsConns, utils.SessionSv1AuthorizeEvent, - authArgs, rply) - rply.SetMaxUsageNeeded(authArgs.GetMaxUsage) + cgrEv, rply) + rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsAccountS)) agReq.setCGRReply(rply, err) case utils.MetaInitiate: rply := new(sessions.V1InitSessionReply) diff --git a/agents/radagent.go b/agents/radagent.go index 1625087eb..7983a03f2 100644 --- a/agents/radagent.go +++ b/agents/radagent.go @@ -198,25 +198,10 @@ func (ra *RadiusAgent) processRequest(req *radigo.Packet, reqProcessor *config.R fmt.Sprintf("<%s> DRY_RUN, processorID: %s, CGREvent: %s", utils.RadiusAgent, reqProcessor.ID, utils.ToJSON(cgrEv))) case utils.MetaAuthorize: - authArgs := sessions.NewV1AuthorizeArgs( - reqProcessor.Flags.GetBool(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), - reqProcessor.Flags.GetBool(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), - reqProcessor.Flags.GetBool(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), - reqProcessor.Flags.GetBool(utils.MetaResources), - reqProcessor.Flags.Has(utils.MetaAccounts), - reqProcessor.Flags.GetBool(utils.MetaRoutes), - reqProcessor.Flags.Has(utils.OptsRoutesIgnoreErrors), - reqProcessor.Flags.Has(utils.MetaRoutesEventCost), - cgrEv, reqProcessor.Flags.Has(utils.MetaFD), - reqProcessor.Flags.ParamValue(utils.OptsRoutesMaxCost), - ) rply := new(sessions.V1AuthorizeReply) err = ra.connMgr.Call(context.TODO(), ra.cgrCfg.RadiusAgentCfg().SessionSConns, utils.SessionSv1AuthorizeEvent, - authArgs, rply) - rply.SetMaxUsageNeeded(authArgs.GetMaxUsage) + cgrEv, rply) + rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsAccountS)) agReq.setCGRReply(rply, err) case utils.MetaInitiate: rply := new(sessions.V1InitSessionReply) diff --git a/agents/sipagent.go b/agents/sipagent.go index dcc3c3df5..06b4cd85d 100644 --- a/agents/sipagent.go +++ b/agents/sipagent.go @@ -411,25 +411,10 @@ func (sa *SIPAgent) processRequest(reqProcessor *config.RequestProcessor, fmt.Sprintf("<%s> DRY_RUN, processorID: %s, CGREvent: %s", utils.SIPAgent, reqProcessor.ID, utils.ToJSON(cgrEv))) case utils.MetaAuthorize: - authArgs := sessions.NewV1AuthorizeArgs( - reqProcessor.Flags.GetBool(utils.MetaAttributes), - reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs), - reqProcessor.Flags.GetBool(utils.MetaThresholds), - reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs), - reqProcessor.Flags.GetBool(utils.MetaStats), - reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs), - reqProcessor.Flags.GetBool(utils.MetaResources), - reqProcessor.Flags.Has(utils.MetaAccounts), - reqProcessor.Flags.GetBool(utils.MetaRoutes), - reqProcessor.Flags.Has(utils.OptsRoutesIgnoreErrors), - reqProcessor.Flags.Has(utils.MetaRoutesEventCost), - cgrEv, reqProcessor.Flags.Has(utils.MetaFD), - reqProcessor.Flags.ParamValue(utils.OptsRoutesMaxCost), - ) rply := new(sessions.V1AuthorizeReply) err = sa.connMgr.Call(context.TODO(), sa.cfg.SIPAgentCfg().SessionSConns, utils.SessionSv1AuthorizeEvent, - authArgs, rply) - rply.SetMaxUsageNeeded(authArgs.GetMaxUsage) + cgrEv, rply) + rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsAccountS)) agReq.setCGRReply(rply, err) case utils.MetaEvent: rply := new(sessions.V1ProcessEventReply) diff --git a/apis/sessions.go b/apis/sessions.go index 5ec953a17..b15a72ccc 100644 --- a/apis/sessions.go +++ b/apis/sessions.go @@ -37,12 +37,12 @@ type SessionSv1 struct { sS *sessions.SessionS } -func (ssv1 *SessionSv1) AuthorizeEvent(ctx *context.Context, args *sessions.V1AuthorizeArgs, +func (ssv1 *SessionSv1) AuthorizeEvent(ctx *context.Context, args *utils.CGREvent, rply *sessions.V1AuthorizeReply) error { return ssv1.sS.BiRPCv1AuthorizeEvent(ctx, args, rply) } -func (ssv1 *SessionSv1) AuthorizeEventWithDigest(ctx *context.Context, args *sessions.V1AuthorizeArgs, +func (ssv1 *SessionSv1) AuthorizeEventWithDigest(ctx *context.Context, args *utils.CGREvent, rply *sessions.V1AuthorizeReplyWithDigest) error { return ssv1.sS.BiRPCv1AuthorizeEventWithDigest(ctx, args, rply) } diff --git a/console/session_authorize_event.go b/console/session_authorize_event.go index 8ad0eb3f3..e1afd26cb 100644 --- a/console/session_authorize_event.go +++ b/console/session_authorize_event.go @@ -27,7 +27,7 @@ func init() { c := &CmdSessionsAuthorize{ name: "session_authorize_event", rpcMethod: utils.SessionSv1AuthorizeEventWithDigest, - rpcParams: &sessions.V1AuthorizeArgs{}, + rpcParams: &utils.CGREvent{}, } commands[c.Name()] = c c.CommandExecuter = &CommandExecuter{c} @@ -36,7 +36,7 @@ func init() { type CmdSessionsAuthorize struct { name string rpcMethod string - rpcParams *sessions.V1AuthorizeArgs + rpcParams *utils.CGREvent *CommandExecuter } @@ -50,9 +50,7 @@ func (self *CmdSessionsAuthorize) RpcMethod() string { func (self *CmdSessionsAuthorize) RpcParams(reset bool) interface{} { if reset || self.rpcParams == nil { - self.rpcParams = &sessions.V1AuthorizeArgs{ - CGREvent: new(utils.CGREvent), - } + self.rpcParams = new(utils.CGREvent) } return self.rpcParams } diff --git a/dispatchers/sessions.go b/dispatchers/sessions.go index cb0ec2c10..8591fbb1b 100644 --- a/dispatchers/sessions.go +++ b/dispatchers/sessions.go @@ -35,28 +35,28 @@ func (dS *DispatcherService) SessionSv1Ping(args *utils.CGREvent, reply *string) return dS.Dispatch(context.TODO(), args, utils.MetaSessionS, utils.SessionSv1Ping, args, reply) } -func (dS *DispatcherService) SessionSv1AuthorizeEvent(args *sessions.V1AuthorizeArgs, +func (dS *DispatcherService) SessionSv1AuthorizeEvent(args *utils.CGREvent, reply *sessions.V1AuthorizeReply) (err error) { - args.CGREvent.Tenant = utils.FirstNonEmpty(args.CGREvent.Tenant, dS.cfg.GeneralCfg().DefaultTenant) + args.Tenant = utils.FirstNonEmpty(args.Tenant, dS.cfg.GeneralCfg().DefaultTenant) if len(dS.cfg.DispatcherSCfg().AttributeSConns) != 0 { - if err = dS.authorize(utils.SessionSv1AuthorizeEvent, args.CGREvent.Tenant, + if err = dS.authorize(utils.SessionSv1AuthorizeEvent, args.Tenant, utils.IfaceAsString(args.APIOpts[utils.OptsAPIKey])); err != nil { return } } - return dS.Dispatch(context.TODO(), args.CGREvent, utils.MetaSessionS, utils.SessionSv1AuthorizeEvent, args, reply) + return dS.Dispatch(context.TODO(), args, utils.MetaSessionS, utils.SessionSv1AuthorizeEvent, args, reply) } -func (dS *DispatcherService) SessionSv1AuthorizeEventWithDigest(args *sessions.V1AuthorizeArgs, +func (dS *DispatcherService) SessionSv1AuthorizeEventWithDigest(args *utils.CGREvent, reply *sessions.V1AuthorizeReplyWithDigest) (err error) { - args.CGREvent.Tenant = utils.FirstNonEmpty(args.CGREvent.Tenant, dS.cfg.GeneralCfg().DefaultTenant) + args.Tenant = utils.FirstNonEmpty(args.Tenant, dS.cfg.GeneralCfg().DefaultTenant) if len(dS.cfg.DispatcherSCfg().AttributeSConns) != 0 { - if err = dS.authorize(utils.SessionSv1AuthorizeEventWithDigest, args.CGREvent.Tenant, + if err = dS.authorize(utils.SessionSv1AuthorizeEventWithDigest, args.Tenant, utils.IfaceAsString(args.APIOpts[utils.OptsAPIKey])); err != nil { return } } - return dS.Dispatch(context.TODO(), args.CGREvent, utils.MetaSessionS, utils.SessionSv1AuthorizeEventWithDigest, args, reply) + return dS.Dispatch(context.TODO(), args, utils.MetaSessionS, utils.SessionSv1AuthorizeEventWithDigest, args, reply) } func (dS *DispatcherService) SessionSv1InitiateSession(args *utils.CGREvent, diff --git a/dispatchers/sessions_test.go b/dispatchers/sessions_test.go index 96d4cf4cb..6f9b6e758 100644 --- a/dispatchers/sessions_test.go +++ b/dispatchers/sessions_test.go @@ -58,10 +58,8 @@ func TestDspSessionSv1PingErrorNil(t *testing.T) { func TestDspSessionSv1AuthorizeEventNil(t *testing.T) { cgrCfg := config.NewDefaultCGRConfig() dspSrv := NewDispatcherService(nil, cgrCfg, nil, nil) - CGREvent := &sessions.V1AuthorizeArgs{ - CGREvent: &utils.CGREvent{ - Tenant: "tenant", - }, + CGREvent := &utils.CGREvent{ + Tenant: "tenant", } var reply *sessions.V1AuthorizeReply result := dspSrv.SessionSv1AuthorizeEvent(CGREvent, reply) @@ -75,10 +73,8 @@ func TestDspSessionSv1AuthorizeEventErrorNil(t *testing.T) { cgrCfg := config.NewDefaultCGRConfig() dspSrv := NewDispatcherService(nil, cgrCfg, nil, nil) cgrCfg.DispatcherSCfg().AttributeSConns = []string{"test"} - CGREvent := &sessions.V1AuthorizeArgs{ - CGREvent: &utils.CGREvent{ - Tenant: "tenant", - }, + CGREvent := &utils.CGREvent{ + Tenant: "tenant", } var reply *sessions.V1AuthorizeReply result := dspSrv.SessionSv1AuthorizeEvent(CGREvent, reply) @@ -91,10 +87,8 @@ func TestDspSessionSv1AuthorizeEventErrorNil(t *testing.T) { func TestDspSessionSv1AuthorizeEventWithDigestNil(t *testing.T) { cgrCfg := config.NewDefaultCGRConfig() dspSrv := NewDispatcherService(nil, cgrCfg, nil, nil) - CGREvent := &sessions.V1AuthorizeArgs{ - CGREvent: &utils.CGREvent{ - Tenant: "tenant", - }, + CGREvent := &utils.CGREvent{ + Tenant: "tenant", } var reply *sessions.V1AuthorizeReplyWithDigest result := dspSrv.SessionSv1AuthorizeEventWithDigest(CGREvent, reply) @@ -108,10 +102,8 @@ func TestDspSessionSv1AuthorizeEventWithDigestErrorNil(t *testing.T) { cgrCfg := config.NewDefaultCGRConfig() dspSrv := NewDispatcherService(nil, cgrCfg, nil, nil) cgrCfg.DispatcherSCfg().AttributeSConns = []string{"test"} - CGREvent := &sessions.V1AuthorizeArgs{ - CGREvent: &utils.CGREvent{ - Tenant: "tenant", - }, + CGREvent := &utils.CGREvent{ + Tenant: "tenant", } var reply *sessions.V1AuthorizeReplyWithDigest result := dspSrv.SessionSv1AuthorizeEventWithDigest(CGREvent, reply) diff --git a/ers/ers.go b/ers/ers.go index dd4fb5f53..1292db2a5 100644 --- a/ers/ers.go +++ b/ers/ers.go @@ -199,24 +199,9 @@ func (erS *ERService) processEvent(cgrEv *utils.CGREvent, fmt.Sprintf("<%s> DRYRUN, reader: <%s>, CGREvent: <%s>", utils.ERs, rdrCfg.ID, utils.ToJSON(cgrEv))) case utils.MetaAuthorize: - authArgs := sessions.NewV1AuthorizeArgs( - 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.OptsRoutesIgnoreErrors), - rdrCfg.Flags.Has(utils.MetaRoutesEventCost), - cgrEv, rdrCfg.Flags.Has(utils.MetaFD), - rdrCfg.Flags.ParamValue(utils.OptsRoutesMaxCost), - ) rply := new(sessions.V1AuthorizeReply) err = erS.connMgr.Call(context.TODO(), erS.cfg.ERsCfg().SessionSConns, utils.SessionSv1AuthorizeEvent, - authArgs, rply) + cgrEv, rply) case utils.MetaInitiate: rply := new(sessions.V1InitSessionReply) err = erS.connMgr.Call(context.TODO(), erS.cfg.ERsCfg().SessionSConns, utils.SessionSv1InitiateSession, diff --git a/sessions/libsessions.go b/sessions/libsessions.go index 5c356bddc..0a332fb61 100644 --- a/sessions/libsessions.go +++ b/sessions/libsessions.go @@ -424,90 +424,6 @@ func (v1Rply *V1ProcessMessageReply) AsNavigableMap() map[string]*utils.DataNode return cgrReply } -// NewV1AuthorizeArgs is a constructor for V1AuthorizeArgs -func NewV1AuthorizeArgs(attrs bool, attributeIDs []string, - thrslds bool, thresholdIDs []string, statQueues bool, statIDs []string, - res, maxUsage, routes, routesIgnoreErrs, routesEventCost bool, - cgrEv *utils.CGREvent, forceDuration bool, routesMaxCost string) (args *V1AuthorizeArgs) { - args = &V1AuthorizeArgs{ - GetAttributes: attrs, - AuthorizeResources: res, - GetMaxUsage: maxUsage, - ProcessThresholds: thrslds, - ProcessStats: statQueues, - RoutesIgnoreErrors: routesIgnoreErrs, - GetRoutes: routes, - CGREvent: cgrEv, - ForceDuration: forceDuration, - } - if routesEventCost { - args.RoutesMaxCost = utils.MetaEventCost - } else { - args.RoutesMaxCost = routesMaxCost - } - if len(attributeIDs) != 0 { - args.AttributeIDs = attributeIDs - } - if len(thresholdIDs) != 0 { - args.ThresholdIDs = thresholdIDs - } - if len(statIDs) != 0 { - args.StatIDs = statIDs - } - - return -} - -// V1AuthorizeArgs are options available in auth request -type V1AuthorizeArgs struct { - GetAttributes bool - AuthorizeResources bool - GetMaxUsage bool - ForceDuration bool - ProcessThresholds bool - ProcessStats bool - GetRoutes bool - RoutesMaxCost string - RoutesIgnoreErrors bool - AttributeIDs []string - ThresholdIDs []string - StatIDs []string - *utils.CGREvent -} - -func (V1AuthorizeArgs) RPCClone() {} // disable rpcClonable from CGREvent - -// ParseFlags will populate the V1AuthorizeArgs flags -func (args *V1AuthorizeArgs) ParseFlags(flags, sep string) { - for _, subsystem := range strings.Split(flags, sep) { - switch { - case subsystem == utils.MetaAccounts: - args.GetMaxUsage = true - case subsystem == utils.MetaResources: - args.AuthorizeResources = true - case subsystem == utils.MetaRoutes: - args.GetRoutes = true - case subsystem == utils.OptsRoutesIgnoreErrors: - args.RoutesIgnoreErrors = true - case subsystem == utils.MetaRoutesEventCost: - args.RoutesMaxCost = utils.MetaEventCost - case strings.HasPrefix(subsystem, utils.OptsRoutesMaxCost): - args.RoutesMaxCost = strings.TrimPrefix(subsystem, utils.OptsRoutesMaxCost+utils.InInFieldSep) - case strings.HasPrefix(subsystem, utils.MetaAttributes): - args.GetAttributes = true - args.AttributeIDs = getFlagIDs(subsystem) - case strings.HasPrefix(subsystem, utils.MetaThresholds): - args.ProcessThresholds = true - args.ThresholdIDs = getFlagIDs(subsystem) - case strings.HasPrefix(subsystem, utils.MetaStats): - args.ProcessStats = true - args.StatIDs = getFlagIDs(subsystem) - case subsystem == utils.MetaFD: - args.ForceDuration = true - } - } -} - // V1AuthorizeReply are options available in auth reply type V1AuthorizeReply struct { Attributes *engine.AttrSProcessEventReply `json:",omitempty"` diff --git a/sessions/sessions.go b/sessions/sessions.go index 5a2935525..d38588090 100644 --- a/sessions/sessions.go +++ b/sessions/sessions.go @@ -1534,21 +1534,21 @@ func (sS *SessionS) BiRPCv1ReplicateSessions(ctx *context.Context, // BiRPCv1AuthorizeEvent performs authorization for CGREvent based on specific components func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context, - args *V1AuthorizeArgs, authReply *V1AuthorizeReply) (err error) { - if args.CGREvent == nil { + args *utils.CGREvent, authReply *V1AuthorizeReply) (err error) { + if args == nil { return utils.NewErrMandatoryIeMissing(utils.CGREventString) } var withErrors bool - if args.CGREvent.ID == "" { - args.CGREvent.ID = utils.GenUUID() + if args.ID == "" { + args.ID = utils.GenUUID() } - if args.CGREvent.Tenant == "" { - args.CGREvent.Tenant = sS.cgrCfg.GeneralCfg().DefaultTenant + if args.Tenant == "" { + args.Tenant = sS.cgrCfg.GeneralCfg().DefaultTenant } // RPC caching if sS.cgrCfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit != 0 { - cacheKey := utils.ConcatenatedKey(utils.SessionSv1AuthorizeEvent, args.CGREvent.ID) + cacheKey := utils.ConcatenatedKey(utils.SessionSv1AuthorizeEvent, args.ID) refID := guardian.Guardian.GuardIDs("", sS.cgrCfg.GeneralCfg().LockingTimeout, cacheKey) // RPC caching needs to be atomic defer guardian.Guardian.UnguardIDs(refID) @@ -1576,34 +1576,21 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context, } else if attrS, err = utils.IfaceAsBool(v); err != nil { return } - if !(args.GetAttributes || attrS || utils.OptAsBool(args.APIOpts, utils.OptsSesMaxUsage) || - args.AuthorizeResources || utils.OptAsBool(args.APIOpts, utils.OptsSesResourceSAuthorize) || - args.GetRoutes || utils.OptAsBool(args.APIOpts, utils.OptsRouteS)) { + if !(attrS || utils.OptAsBool(args.APIOpts, utils.OptsSesMaxUsage) || + utils.OptAsBool(args.APIOpts, utils.OptsSesResourceSAuthorize) || + utils.OptAsBool(args.APIOpts, utils.OptsRouteS)) { return // Nothing to do } if args.APIOpts == nil { args.APIOpts = make(map[string]interface{}) } - if v, has := args.APIOpts[utils.OptsAttributeS]; !has { - /* - if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS, - sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil { - return - } - */ - } else if attrS, err = utils.IfaceAsBool(v); err != nil { - return - } - if args.GetAttributes || attrS { + if attrS { if args.APIOpts == nil { args.APIOpts = make(map[string]interface{}) } - if args.AttributeIDs != nil { - args.APIOpts[utils.OptsAttributesAttributeIDs] = args.AttributeIDs - } - rplyAttr, err := sS.processAttributes(ctx, args.CGREvent) + rplyAttr, err := sS.processAttributes(ctx, args) if err == nil { - args.CGREvent = rplyAttr.CGREvent + args = rplyAttr.CGREvent authReply.Attributes = &rplyAttr } else if err.Error() != utils.ErrNotFound.Error() { return utils.NewErrAttributeS(err) @@ -1624,14 +1611,14 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context, } if chrgS { var chrgrs []*engine.ChrgSProcessEventReply - if chrgrs, err = sS.processChargerS(ctx, args.CGREvent); err != nil { + if chrgrs, err = sS.processChargerS(ctx, args); err != nil { return } for _, chrgr := range chrgrs { runEvents[chrgr.ChargerSProfile] = chrgr.CGREvent } } else { - runEvents[utils.MetaRaw] = args.CGREvent + runEvents[utils.MetaRaw] = args } var acntS bool if v, has := args.APIOpts[utils.OptsAccountS]; !has { @@ -1647,16 +1634,14 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context, if acntS { var maxAbstracts map[string]*utils.Decimal if maxAbstracts, err = sS.accounSMaxAbstracts(ctx, runEvents); err != nil { - return err + authReply.MaxUsage = getMaxUsageFromRuns(maxAbstracts) } - authReply.MaxUsage = getMaxUsageFromRuns(maxAbstracts) } - if args.AuthorizeResources || - utils.OptAsBool(args.APIOpts, utils.OptsSesResourceSAuthorize) { + if utils.OptAsBool(args.APIOpts, utils.OptsSesResourceSAuthorize) { if len(sS.cgrCfg.SessionSCfg().ResourceSConns) == 0 { return utils.NewErrNotConnected(utils.ResourceS) } - originID, _ := args.CGREvent.FieldAsString(utils.OriginID) + originID, _ := args.FieldAsString(utils.OriginID) if originID == "" { originID = utils.UUIDSha1Prefix() } @@ -1669,11 +1654,8 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context, } authReply.ResourceAllocation = &allocMsg } - if args.GetRoutes || - utils.OptAsBool(args.APIOpts, utils.OptsRouteS) { - args.APIOpts[utils.OptsRoutesMaxCost] = utils.FirstNonEmpty(args.RoutesMaxCost, utils.IfaceAsString(args.APIOpts[utils.OptsSesRouteSMaxCost])) - args.APIOpts[utils.OptsRoutesIgnoreErrors] = args.RoutesIgnoreErrors || utils.OptAsBool(args.APIOpts, utils.OptsSesRouteSIgnoreErrors) - routesReply, err := sS.getRoutes(ctx, args.CGREvent.Clone()) + if utils.OptAsBool(args.APIOpts, utils.OptsRouteS) { + routesReply, err := sS.getRoutes(ctx, args.Clone()) if err != nil { return err } @@ -1692,20 +1674,16 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context, } else if thdS, err = utils.IfaceAsBool(v); err != nil { return } - if args.ProcessThresholds || - thdS { + if thdS { var thIDs []string if thIDs, err = utils.OptAsStringSlice(args.APIOpts, utils.OptsSesThresholdIDs); err != nil { return } - if thIDs == nil { - thIDs = args.ThresholdIDs - } - tIDs, err := sS.processThreshold(ctx, args.CGREvent, thIDs, true) + tIDs, err := sS.processThreshold(ctx, args, thIDs, true) if err != nil && err.Error() != utils.ErrNotFound.Error() { utils.Logger.Warning( fmt.Sprintf("<%s> error: %s processing event %+v with ThresholdS.", - utils.SessionS, err.Error(), args.CGREvent)) + utils.SessionS, err.Error(), args)) withErrors = true } authReply.ThresholdIDs = &tIDs @@ -1721,20 +1699,17 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context, } else if stS, err = utils.IfaceAsBool(v); err != nil { return } - if args.ProcessStats || stS { + if stS { var statIDs []string if statIDs, err = utils.OptAsStringSlice(args.APIOpts, utils.OptsSesStatIDs); err != nil { return } - if statIDs == nil { - statIDs = args.StatIDs - } - sIDs, err := sS.processStats(ctx, args.CGREvent, statIDs, false) + sIDs, err := sS.processStats(ctx, args, statIDs, false) if err != nil && err.Error() != utils.ErrNotFound.Error() { utils.Logger.Warning( fmt.Sprintf("<%s> error: %s processing event %+v with StatS.", - utils.SessionS, err.Error(), args.CGREvent)) + utils.SessionS, err.Error(), args)) withErrors = true } authReply.StatQueueIDs = &sIDs @@ -1748,7 +1723,7 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context, // BiRPCv1AuthorizeEventWithDigest performs authorization for CGREvent based on specific components // returning one level fields instead of multiple ones returned by BiRPCv1AuthorizeEvent func (sS *SessionS) BiRPCv1AuthorizeEventWithDigest(ctx *context.Context, - args *V1AuthorizeArgs, authReply *V1AuthorizeReplyWithDigest) (err error) { + args *utils.CGREvent, authReply *V1AuthorizeReplyWithDigest) (err error) { var initAuthRply V1AuthorizeReply if err = sS.BiRPCv1AuthorizeEvent(ctx, args, &initAuthRply); err != nil { return @@ -1764,11 +1739,10 @@ func (sS *SessionS) BiRPCv1AuthorizeEventWithDigest(ctx *context.Context, } else if attrS, err = utils.IfaceAsBool(v); err != nil { return } - if (args.GetAttributes || attrS) && initAuthRply.Attributes != nil { + if attrS && initAuthRply.Attributes != nil { authReply.AttributesDigest = utils.StringPointer(initAuthRply.Attributes.Digest()) } - if args.AuthorizeResources || - utils.OptAsBool(args.APIOpts, utils.OptsSesResourceSAuthorize) { + if utils.OptAsBool(args.APIOpts, utils.OptsSesResourceSAuthorize) { authReply.ResourceAllocation = initAuthRply.ResourceAllocation } var acntS bool @@ -1786,8 +1760,7 @@ func (sS *SessionS) BiRPCv1AuthorizeEventWithDigest(ctx *context.Context, maxDur, _ := initAuthRply.MaxUsage.Duration() authReply.MaxUsage = maxDur.Seconds() } - if args.GetRoutes || - utils.OptAsBool(args.APIOpts, utils.OptsRouteS) { + if utils.OptAsBool(args.APIOpts, utils.OptsRouteS) { authReply.RoutesDigest = utils.StringPointer(initAuthRply.RouteProfiles.Digest()) } var thdS bool @@ -1801,7 +1774,7 @@ func (sS *SessionS) BiRPCv1AuthorizeEventWithDigest(ctx *context.Context, } else if thdS, err = utils.IfaceAsBool(v); err != nil { return } - if args.ProcessThresholds || thdS { + if thdS { authReply.Thresholds = utils.StringPointer( strings.Join(*initAuthRply.ThresholdIDs, utils.FieldsSep)) } @@ -1816,7 +1789,7 @@ func (sS *SessionS) BiRPCv1AuthorizeEventWithDigest(ctx *context.Context, } else if stS, err = utils.IfaceAsBool(v); err != nil { return } - if args.ProcessStats || stS { + if stS { authReply.StatQueues = utils.StringPointer( strings.Join(*initAuthRply.StatQueueIDs, utils.FieldsSep)) } diff --git a/sessions/sessions_test.go b/sessions/sessions_test.go index a2cc21f7d..b9cd924bf 100644 --- a/sessions/sessions_test.go +++ b/sessions/sessions_test.go @@ -942,90 +942,6 @@ func TestSessionSNewV1AuthorizeArgs(t *testing.T) { } */ -func TestV1AuthorizeArgsParseFlags1(t *testing.T) { - v1authArgs := new(V1AuthorizeArgs) - v1authArgs.CGREvent = new(utils.CGREvent) - eOut := new(V1AuthorizeArgs) - eOut.CGREvent = new(utils.CGREvent) - //empty check - strArg := "" - v1authArgs.ParseFlags(strArg, utils.InfieldSep) - if !reflect.DeepEqual(eOut, v1authArgs) { - t.Errorf("Expecting %+v,\n received: %+v", eOut, v1authArgs) - } - //normal check -> without *dispatchers - eOut = &V1AuthorizeArgs{ - GetMaxUsage: true, - AuthorizeResources: true, - GetRoutes: true, - RoutesIgnoreErrors: true, - RoutesMaxCost: utils.MetaEventCost, - GetAttributes: true, - AttributeIDs: []string{"Attr1", "Attr2"}, - ProcessThresholds: true, - ThresholdIDs: []string{"tr1", "tr2", "tr3"}, - ProcessStats: true, - StatIDs: []string{"st1", "st2", "st3"}, - CGREvent: eOut.CGREvent, - ForceDuration: true, - } - - strArg = "*accounts;*fd;*resources;*routes;*rouIgnoreErrors;*routesEventCost;*attributes:Attr1&Attr2;*thresholds:tr1&tr2&tr3;*stats:st1&st2&st3" - v1authArgs = new(V1AuthorizeArgs) - v1authArgs.CGREvent = new(utils.CGREvent) - v1authArgs.ParseFlags(strArg, utils.InfieldSep) - if !reflect.DeepEqual(eOut, v1authArgs) { - t.Errorf("Expecting %+v,\n received: %+v\n", utils.ToJSON(eOut), utils.ToJSON(v1authArgs)) - } - // //normal check -> with *dispatchers - eOut = &V1AuthorizeArgs{ - GetMaxUsage: true, - AuthorizeResources: true, - GetRoutes: true, - RoutesIgnoreErrors: true, - RoutesMaxCost: utils.MetaEventCost, - GetAttributes: true, - AttributeIDs: []string{"Attr1", "Attr2"}, - ProcessThresholds: true, - ThresholdIDs: []string{"tr1", "tr2", "tr3"}, - ProcessStats: true, - StatIDs: []string{"st1", "st2", "st3"}, - CGREvent: eOut.CGREvent, - ForceDuration: true, - } - - strArg = "*accounts;*fd;*resources;;*dispatchers;*routes;*rouIgnoreErrors;*routesEventCost;*attributes:Attr1&Attr2;*thresholds:tr1&tr2&tr3;*stats:st1&st2&st3" - v1authArgs = new(V1AuthorizeArgs) - v1authArgs.CGREvent = new(utils.CGREvent) - v1authArgs.ParseFlags(strArg, utils.InfieldSep) - if !reflect.DeepEqual(eOut, v1authArgs) { - t.Errorf("Expecting %+v,\n received: %+v\n", utils.ToJSON(eOut), utils.ToJSON(v1authArgs)) - } - eOut = &V1AuthorizeArgs{ - GetMaxUsage: true, - AuthorizeResources: true, - GetRoutes: true, - RoutesIgnoreErrors: true, - RoutesMaxCost: "100", - GetAttributes: true, - AttributeIDs: []string{"Attr1", "Attr2"}, - ProcessThresholds: true, - ThresholdIDs: []string{"tr1", "tr2", "tr3"}, - ProcessStats: true, - StatIDs: []string{"st1", "st2", "st3"}, - CGREvent: eOut.CGREvent, - ForceDuration: true, - } - - strArg = "*accounts;*fd;*resources;;*dispatchers;*routes;*rouIgnoreErrors;*rouMaxCost:100;*attributes:Attr1&Attr2;*thresholds:tr1&tr2&tr3;*stats:st1&st2&st3" - v1authArgs = new(V1AuthorizeArgs) - v1authArgs.CGREvent = new(utils.CGREvent) - v1authArgs.ParseFlags(strArg, utils.InfieldSep) - if !reflect.DeepEqual(eOut, v1authArgs) { - t.Errorf("Expecting %+v,\n received: %+v\n", utils.ToJSON(eOut), utils.ToJSON(v1authArgs)) - } -} - func TestSessionSV1AuthorizeReplyAsNavigableMap(t *testing.T) { splrs := engine.SortedRoutesList{ { @@ -1426,93 +1342,6 @@ func TestSessionSrelocateSessionS(t *testing.T) { } } -func TestSessionSNewV1AuthorizeArgsWithOpts(t *testing.T) { - - cgrEv := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "Event", - Event: map[string]interface{}{ - utils.AccountField: "1001", - utils.Destination: "1002", - }, - APIOpts: map[string]interface{}{ - utils.OptsAPIKey: "testkey", - utils.OptsRouteID: "testrouteid", - }, - } - expected := &V1AuthorizeArgs{ - AuthorizeResources: true, - GetAttributes: true, - CGREvent: cgrEv, - ForceDuration: true, - } - rply := NewV1AuthorizeArgs(true, nil, false, nil, false, nil, true, false, - false, false, false, cgrEv, true, "") - if !reflect.DeepEqual(expected, rply) { - t.Errorf("Expecting %+v, received: %+v", utils.ToJSON(expected), utils.ToJSON(rply)) - } - expected = &V1AuthorizeArgs{ - GetAttributes: true, - AuthorizeResources: false, - GetMaxUsage: true, - ProcessThresholds: false, - ProcessStats: true, - GetRoutes: false, - RoutesIgnoreErrors: true, - RoutesMaxCost: utils.MetaEventCost, - CGREvent: cgrEv, - ForceDuration: true, - } - rply = NewV1AuthorizeArgs(true, nil, false, nil, true, nil, false, true, - false, true, true, cgrEv, true, "") - if !reflect.DeepEqual(expected, rply) { - t.Errorf("Expecting %+v, received: %+v", utils.ToJSON(expected), utils.ToJSON(rply)) - } -} - -func TestSessionSNewV1AuthorizeArgsWithOpts2(t *testing.T) { - - cgrEv := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "Event", - Event: map[string]interface{}{ - utils.AccountField: "1001", - utils.Destination: "1002", - }, - APIOpts: map[string]interface{}{ - utils.OptsRouteID: "testrouteid", - }, - } - expected := &V1AuthorizeArgs{ - AuthorizeResources: true, - GetAttributes: true, - CGREvent: cgrEv, - ForceDuration: true, - } - rply := NewV1AuthorizeArgs(true, nil, false, nil, false, nil, true, false, false, - false, false, cgrEv, true, "") - if !reflect.DeepEqual(expected, rply) { - t.Errorf("Expecting %+v, received: %+v", utils.ToJSON(expected), utils.ToJSON(rply)) - } - expected = &V1AuthorizeArgs{ - GetAttributes: true, - AuthorizeResources: false, - GetMaxUsage: true, - ProcessThresholds: false, - ProcessStats: true, - GetRoutes: false, - RoutesIgnoreErrors: true, - RoutesMaxCost: utils.MetaEventCost, - CGREvent: cgrEv, - ForceDuration: true, - } - rply = NewV1AuthorizeArgs(true, nil, false, nil, true, nil, false, true, false, - true, true, cgrEv, true, "") - if !reflect.DeepEqual(expected, rply) { - t.Errorf("Expecting %+v, received: %+v", utils.ToJSON(expected), utils.ToJSON(rply)) - } -} - func TestSessionSGetIndexedFilters(t *testing.T) { sSCfg := config.NewDefaultCGRConfig() mpStr := engine.NewInternalDB(nil, nil, true)