Centralize dispatcher ( authorizeMethod)

apier/v1/dispatcher.go

@@ -95,7 +95,7 @@ func (dRs *DispatcherResourceSv1) Ping(ign string, reply *string) error {
 }
 
 // GetResourcesForEvent implements ResourceSv1GetResourcesForEvent
-func (dRs *DispatcherResourceSv1) GetResourcesForEvent(args dispatcher.ArgsV1ResUsageWithApiKey,
+func (dRs *DispatcherResourceSv1) GetResourcesForEvent(args *dispatcher.ArgsV1ResUsageWithApiKey,
 	reply *engine.Resources) error {
 	return dRs.dRs.ResourceSv1GetResourcesForEvent(args, reply)
 }

dispatcher/attributes.go

@@ -25,7 +25,7 @@ import (
 
 func (dS *DispatcherService) AttributeSv1Ping(ign string, reply *string) error {
 	if dS.attrS == nil {
-		return utils.NewErrNotConnected(utils.ResourceS)
+		return utils.NewErrNotConnected(utils.AttributeS)
 	}
 	return dS.attrS.Call(utils.AttributeSv1Ping, ign, reply)
 }
@@ -33,28 +33,12 @@ func (dS *DispatcherService) AttributeSv1Ping(ign string, reply *string) error {
 func (dS *DispatcherService) AttributeSv1GetAttributeForEvent(args *CGREvWithApiKey,
 	reply *engine.AttributeProfile) (err error) {
 	if dS.attrS == nil {
-		return utils.NewErrNotConnected(utils.ResourceS)
+		return utils.NewErrNotConnected(utils.AttributeS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.CGREvent.Tenant,
+		utils.AttributeSv1GetAttributeForEvent, args.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.AttributeSv1GetAttributeForEvent) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.attrS.Call(utils.AttributeSv1GetAttributeForEvent, args.CGREvent, reply)
 
 }
@@ -62,28 +46,12 @@ func (dS *DispatcherService) AttributeSv1GetAttributeForEvent(args *CGREvWithApi
 func (dS *DispatcherService) AttributeSv1ProcessEvent(args *CGREvWithApiKey,
 	reply *engine.AttrSProcessEventReply) (err error) {
 	if dS.attrS == nil {
-		return utils.NewErrNotConnected(utils.ResourceS)
+		return utils.NewErrNotConnected(utils.AttributeS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.CGREvent.Tenant,
+		utils.AttributeSv1ProcessEvent, args.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.AttributeSv1ProcessEvent) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.attrS.Call(utils.AttributeSv1ProcessEvent, args.CGREvent, reply)
 
 }

dispatcher/attributes_it_test.go

@@ -51,6 +51,8 @@ var sTestsDspAttr = []func(t *testing.T){
 	testDspAttrPing,
 	testDspAttrLoadData,
 	testDspAttrAddAttributesWithPermision,
+	testDspAttrTestMissingApiKey,
+	testDspAttrTestUnknownApiKey,
 	testDspAttrTestAuthKey,
 	testDspAttrAddAttributesWithPermision2,
 	testDspAttrTestAuthKey2,
@@ -178,6 +180,43 @@ func testDspAttrAddAttributesWithPermision(t *testing.T) {
 	}
 }
 
+func testDspAttrTestMissingApiKey(t *testing.T) {
+	args := &CGREvWithApiKey{
+		CGREvent: utils.CGREvent{
+			Tenant:  "cgrates.org",
+			ID:      "testAttributeSGetAttributeForEvent",
+			Context: utils.StringPointer("simpleauth"),
+			Event: map[string]interface{}{
+				utils.Account: "1001",
+			},
+		},
+	}
+	var attrReply *engine.AttributeProfile
+	if err := dspAttrRPC.Call(utils.AttributeSv1GetAttributeForEvent,
+		args, &attrReply); err.Error() != utils.NewErrMandatoryIeMissing(utils.APIKey).Error() {
+		t.Error(err)
+	}
+}
+
+func testDspAttrTestUnknownApiKey(t *testing.T) {
+	args := &CGREvWithApiKey{
+		APIKey: "1234",
+		CGREvent: utils.CGREvent{
+			Tenant:  "cgrates.org",
+			ID:      "testAttributeSGetAttributeForEvent",
+			Context: utils.StringPointer("simpleauth"),
+			Event: map[string]interface{}{
+				utils.Account: "1001",
+			},
+		},
+	}
+	var attrReply *engine.AttributeProfile
+	if err := dspAttrRPC.Call(utils.AttributeSv1GetAttributeForEvent,
+		args, &attrReply); err.Error() != utils.ErrUnknownApiKey.Error() {
+		t.Error(err)
+	}
+}
+
 func testDspAttrTestAuthKey(t *testing.T) {
 	args := &CGREvWithApiKey{
 		APIKey: "12345",

dispatcher/dispatcher.go

@@ -21,6 +21,7 @@ package dispatcher
 import (
 	"fmt"
 	"reflect"
+	"time"
 
 	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
@@ -92,5 +93,38 @@ func (dS *DispatcherService) authorizeEvent(ev *utils.CGREvent,
 	if dS.attrS == nil {
 		return utils.NewErrNotConnected(utils.AttributeS)
 	}
-	return dS.attrS.Call(utils.AttributeSv1ProcessEvent, ev, reply)
+	if err = dS.attrS.Call(utils.AttributeSv1ProcessEvent, ev, reply); err != nil {
+		if err.Error() == utils.ErrNotFound.Error() {
+			err = utils.ErrUnknownApiKey
+		}
+		return
+	}
+	return
+}
+
+func (dS *DispatcherService) authorizeMethod(apiKey, tenant, method string, evTime *time.Time) (err error) {
+	if apiKey == "" {
+		return utils.NewErrMandatoryIeMissing(utils.APIKey)
+	}
+	ev := &utils.CGREvent{
+		Tenant:  tenant,
+		ID:      utils.UUIDSha1Prefix(),
+		Context: utils.StringPointer(utils.MetaAuth),
+		Time:    evTime,
+		Event: map[string]interface{}{
+			utils.APIKey: apiKey,
+		},
+	}
+	var rplyEv engine.AttrSProcessEventReply
+	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+		return
+	}
+	var apiMethods string
+	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
+		return
+	}
+	if !utils.ParseStringMap(apiMethods).HasKey(method) {
+		return utils.ErrUnauthorizedApi
+	}
+	return
 }

dispatcher/resources.go

@@ -30,30 +30,14 @@ func (dS *DispatcherService) ResourceSv1Ping(ign string, rpl *string) (err error
 	return dS.resS.Call(utils.ResourceSv1Ping, ign, rpl)
 }
 
-func (dS *DispatcherService) ResourceSv1GetResourcesForEvent(args ArgsV1ResUsageWithApiKey, reply *engine.Resources) (err error) {
+func (dS *DispatcherService) ResourceSv1GetResourcesForEvent(args *ArgsV1ResUsageWithApiKey, reply *engine.Resources) (err error) {
 	if dS.resS == nil {
 		return utils.NewErrNotConnected(utils.ResourceS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.ArgRSv1ResourceUsage.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.ArgRSv1ResourceUsage.CGREvent.Tenant,
+		utils.ResourceSv1GetResourcesForEvent, args.ArgRSv1ResourceUsage.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.ResourceSv1GetResourcesForEvent) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.resS.Call(utils.ResourceSv1GetResourcesForEvent, args.ArgRSv1ResourceUsage, reply)
 
 }

dispatcher/sessions.go

@@ -19,7 +19,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 package dispatcher
 
 import (
-	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/sessions"
 	"github.com/cgrates/cgrates/utils"
 )
@@ -36,26 +35,10 @@ func (dS *DispatcherService) SessionSv1AuthorizeEventWithDigest(args *AuthorizeA
 	if dS.sessionS == nil {
 		return utils.NewErrNotConnected(utils.SessionS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.V1AuthorizeArgs.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.V1AuthorizeArgs.CGREvent.Tenant,
+		utils.SessionSv1AuthorizeEventWithDigest, args.V1AuthorizeArgs.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.SessionSv1AuthorizeEventWithDigest) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.sessionS.Call(utils.SessionSv1AuthorizeEventWithDigest, args.V1AuthorizeArgs, reply)
 }
 
@@ -64,26 +47,10 @@ func (dS *DispatcherService) SessionSv1InitiateSessionWithDigest(args *InitArgsW
 	if dS.sessionS == nil {
 		return utils.NewErrNotConnected(utils.SessionS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.V1InitSessionArgs.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.V1InitSessionArgs.CGREvent.Tenant,
+		utils.SessionSv1InitiateSessionWithDigest, args.V1InitSessionArgs.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.SessionSv1InitiateSessionWithDigest) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.sessionS.Call(utils.SessionSv1InitiateSessionWithDigest, args.V1InitSessionArgs, reply)
 }
 
@@ -92,26 +59,10 @@ func (dS *DispatcherService) SessionSv1ProcessCDR(args *CGREvWithApiKey,
 	if dS.sessionS == nil {
 		return utils.NewErrNotConnected(utils.SessionS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.CGREvent.Tenant,
+		utils.SessionSv1ProcessCDR, args.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.SessionSv1ProcessCDR) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.sessionS.Call(utils.SessionSv1ProcessCDR, args.CGREvent, reply)
 }
 
@@ -120,26 +71,10 @@ func (dS *DispatcherService) SessionSv1ProcessEvent(args *ProcessEventWithApiKey
 	if dS.sessionS == nil {
 		return utils.NewErrNotConnected(utils.SessionS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.V1ProcessEventArgs.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.V1ProcessEventArgs.CGREvent.Tenant,
+		utils.SessionSv1ProcessEvent, args.V1ProcessEventArgs.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.SessionSv1ProcessEvent) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.sessionS.Call(utils.SessionSv1ProcessEvent, args.V1ProcessEventArgs, reply)
 }
 
@@ -148,26 +83,10 @@ func (dS *DispatcherService) SessionSv1TerminateSession(args *TerminateSessionWi
 	if dS.sessionS == nil {
 		return utils.NewErrNotConnected(utils.SessionS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.V1TerminateSessionArgs.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.V1TerminateSessionArgs.CGREvent.Tenant,
+		utils.SessionSv1TerminateSession, args.V1TerminateSessionArgs.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.SessionSv1TerminateSession) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.sessionS.Call(utils.SessionSv1TerminateSession, args.V1TerminateSessionArgs, reply)
 }
 
@@ -176,25 +95,9 @@ func (dS *DispatcherService) SessionSv1UpdateSession(args *UpdateSessionWithApiK
 	if dS.sessionS == nil {
 		return utils.NewErrNotConnected(utils.SessionS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.V1UpdateSessionArgs.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.V1UpdateSessionArgs.CGREvent.Tenant,
+		utils.SessionSv1UpdateSession, args.V1UpdateSessionArgs.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.SessionSv1UpdateSession) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.sessionS.Call(utils.SessionSv1UpdateSession, args.V1UpdateSessionArgs, reply)
 }

dispatcher/stats.go

@@ -21,7 +21,6 @@ package dispatcher
 import (
 	"time"
 
-	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
 )
 
@@ -37,26 +36,10 @@ func (dS *DispatcherService) StatSv1GetStatQueuesForEvent(args *CGREvWithApiKey,
 	if dS.statS == nil {
 		return utils.NewErrNotConnected(utils.StatS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.CGREvent.Tenant,
+		utils.StatSv1GetStatQueuesForEvent, args.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.StatSv1GetStatQueuesForEvent) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.statS.Call(utils.StatSv1GetStatQueuesForEvent, args.CGREvent, reply)
 }
 
@@ -65,26 +48,11 @@ func (dS *DispatcherService) StatSv1GetQueueStringMetrics(args *TntIDWithApiKey,
 	if dS.statS == nil {
 		return utils.NewErrNotConnected(utils.StatS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    utils.TimePointer(time.Now()),
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	nowTime := time.Now()
+	if err = dS.authorizeMethod(args.APIKey, args.TenantID.Tenant,
+		utils.StatSv1GetQueueStringMetrics, &nowTime); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.StatSv1GetQueueStringMetrics) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.statS.Call(utils.StatSv1GetQueueStringMetrics, args.TenantID, reply)
 }
 
@@ -93,25 +61,9 @@ func (dS *DispatcherService) StatSv1ProcessEvent(args *CGREvWithApiKey,
 	if dS.statS == nil {
 		return utils.NewErrNotConnected(utils.StatS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.CGREvent.Tenant,
+		utils.StatSv1ProcessEvent, args.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.StatSv1ProcessEvent) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.statS.Call(utils.StatSv1ProcessEvent, args.CGREvent, reply)
 }

dispatcher/suppliers.go

@@ -35,26 +35,10 @@ func (dS *DispatcherService) SupplierSv1GetSuppliers(args *ArgsGetSuppliersWithA
 	if dS.splS == nil {
 		return utils.NewErrNotConnected(utils.SupplierS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.ArgsGetSuppliers.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.ArgsGetSuppliers.CGREvent.Tenant,
+		utils.SupplierSv1GetSuppliers, args.ArgsGetSuppliers.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.SupplierSv1GetSuppliers) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.splS.Call(utils.SupplierSv1GetSuppliers, args.ArgsGetSuppliers, reply)
 
 }

dispatcher/thresholds.go

@@ -35,26 +35,10 @@ func (dS *DispatcherService) ThresholdSv1GetThresholdsForEvent(args *ArgsProcess
 	if dS.thdS == nil {
 		return utils.NewErrNotConnected(utils.ThresholdS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.ArgsProcessEvent.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.ArgsProcessEvent.CGREvent.Tenant,
+		utils.ThresholdSv1GetThresholdsForEvent, args.ArgsProcessEvent.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.ThresholdSv1GetThresholdsForEvent) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.thdS.Call(utils.ThresholdSv1GetThresholdsForEvent, args.ArgsProcessEvent, t)
 }
 
@@ -63,25 +47,9 @@ func (dS *DispatcherService) ThresholdSv1ProcessEvent(args *ArgsProcessEventWith
 	if dS.thdS == nil {
 		return utils.NewErrNotConnected(utils.ThresholdS)
 	}
-	ev := &utils.CGREvent{
-		Tenant:  args.Tenant,
-		ID:      utils.UUIDSha1Prefix(),
-		Context: utils.StringPointer(utils.MetaAuth),
-		Time:    args.ArgsProcessEvent.CGREvent.Time,
-		Event: map[string]interface{}{
-			utils.APIKey: args.APIKey,
-		},
-	}
-	var rplyEv engine.AttrSProcessEventReply
-	if err = dS.authorizeEvent(ev, &rplyEv); err != nil {
+	if err = dS.authorizeMethod(args.APIKey, args.ArgsProcessEvent.CGREvent.Tenant,
+		utils.ThresholdSv1ProcessEvent, args.ArgsProcessEvent.CGREvent.Time); err != nil {
 		return
 	}
-	var apiMethods string
-	if apiMethods, err = rplyEv.CGREvent.FieldAsString(utils.APIMethods); err != nil {
-		return
-	}
-	if !utils.ParseStringMap(apiMethods).HasKey(utils.ThresholdSv1ProcessEvent) {
-		return utils.ErrUnauthorizedApi
-	}
 	return dS.thdS.Call(utils.ThresholdSv1ProcessEvent, args.ArgsProcessEvent, tIDs)
 }

utils/errors.go

@@ -55,6 +55,7 @@ var (
 	ErrNotConvertibleNoCaps     = errors.New("not convertible")
 	ErrMandatoryIeMissingNoCaps = errors.New("mandatory information missing")
 	ErrUnauthorizedApi          = errors.New("UNAUTHORIZED_API")
+	ErrUnknownApiKey            = errors.New("UNKNOWN_API_KEY")
 	RalsErrorPrfx               = "RALS_ERROR"
 )