Updated SessionsUpdate

agents/astagent.go

@@ -260,9 +260,9 @@ func (sma *AsteriskAgent) handleChannelStateChange(ev *SMAsteriskEvent) {
 	var initS bool
 	if cgrEvDisp.APIOpts == nil {
 		initS = true
-		cgrEvDisp.APIOpts = map[string]interface{}{utils.OptsSesInit: true}
+		cgrEvDisp.APIOpts = map[string]interface{}{utils.OptsSesInitiate: true}
 	} else {
-		initS = utils.OptAsBool(cgrEvDisp.APIOpts, utils.OptsSesInit)
+		initS = utils.OptAsBool(cgrEvDisp.APIOpts, utils.OptsSesInitiate)
 	}
 	//initit Session
 	var initReply sessions.V1InitSessionReply

agents/diamagent.go

@@ -382,18 +382,13 @@ func (da *DiameterAgent) processRequest(reqProcessor *config.RequestProcessor,
 		rply := new(sessions.V1InitSessionReply)
 		err = da.connMgr.Call(da.ctx, da.cgrCfg.DiameterAgentCfg().SessionSConns, utils.SessionSv1InitiateSession,
 			cgrEv, rply)
-		rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesInit))
+		rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesInitiate))
 		agReq.setCGRReply(rply, err)
 	case utils.MetaUpdate:
-		updateArgs := sessions.NewV1UpdateSessionArgs(
-			reqProcessor.Flags.GetBool(utils.MetaAttributes),
-			reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs),
-			reqProcessor.Flags.Has(utils.MetaAccounts),
-			cgrEv, reqProcessor.Flags.Has(utils.MetaFD))
 		rply := new(sessions.V1UpdateSessionReply)
-		rply.SetMaxUsageNeeded(updateArgs.UpdateSession)
+		rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesUpdate))
 		err = da.connMgr.Call(da.ctx, da.cgrCfg.DiameterAgentCfg().SessionSConns, utils.SessionSv1UpdateSession,
-			updateArgs, rply)
+			cgrEv, rply)
 		agReq.setCGRReply(rply, err)
 	case utils.MetaTerminate:
 		terminateArgs := sessions.NewV1TerminateSessionArgs(

agents/diamagent_test.go

@@ -186,7 +186,7 @@ func TestProcessRequest(t *testing.T) {
 				},
 				APIOpts: map[string]interface{}{
 					utils.OptsSesAttributeS: "true",
-					utils.OptsSesInit:       "true",
+					utils.OptsSesInitiate:   "true",
 				},
 			}
 			if !reflect.DeepEqual(expargs, arg) {
@@ -228,27 +228,26 @@ func TestProcessRequest(t *testing.T) {
 			var id string
 			if arg == nil {
 				t.Errorf("args is nil")
-			} else if rargs, can := arg.(*sessions.V1UpdateSessionArgs); !can {
+			} else if rargs, can := arg.(*utils.CGREvent); !can {
 				t.Errorf("args is not of sessions.V1UpdateSessionArgs type")
 			} else {
 				id = rargs.ID
 			}
-			expargs := &sessions.V1UpdateSessionArgs{
-				GetAttributes: true,
-				UpdateSession: 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{}{
+					utils.OptsSesAttributeS: "true",
+					utils.OptsSesUpdate:     "true",
 				},
 			}
 			if !reflect.DeepEqual(expargs, arg) {
@@ -451,7 +450,7 @@ func TestProcessRequest(t *testing.T) {
 	reqProcessor.Flags = utils.FlagsWithParamsFromSlice([]string{utils.MetaInitiate, utils.MetaAccounts, utils.MetaAttributes})
 
 	tmpls := []*config.FCTemplate{
-		{Type: utils.MetaConstant, Path: utils.MetaOpts + utils.NestingSep + utils.OptsSesInit,
+		{Type: utils.MetaConstant, Path: utils.MetaOpts + utils.NestingSep + utils.OptsSesInitiate,
 			Value: config.NewRSRParsersMustCompile("true", utils.InfieldSep)},
 		{Type: utils.MetaConstant, Path: utils.MetaOpts + utils.NestingSep + utils.OptsSesAttributeS,
 			Value: config.NewRSRParsersMustCompile("true", utils.InfieldSep)},
@@ -478,6 +477,18 @@ func TestProcessRequest(t *testing.T) {
 	}
 
 	reqProcessor.Flags = utils.FlagsWithParamsFromSlice([]string{utils.MetaUpdate, utils.MetaAccounts, utils.MetaAttributes})
+
+	tmpls = []*config.FCTemplate{
+		{Type: utils.MetaConstant, Path: utils.MetaOpts + utils.NestingSep + utils.OptsSesUpdate,
+			Value: config.NewRSRParsersMustCompile("true", utils.InfieldSep)},
+		{Type: utils.MetaConstant, Path: utils.MetaOpts + utils.NestingSep + utils.OptsSesAttributeS,
+			Value: config.NewRSRParsersMustCompile("true", utils.InfieldSep)},
+	}
+	for _, v := range tmpls {
+		v.ComputePath()
+	}
+	clnReq = reqProcessor.Clone()
+	clnReq.RequestFields = append(clnReq.RequestFields, tmpls...)
 	cgrRplyNM = &utils.DataNode{Type: utils.NMMapType, Map: map[string]*utils.DataNode{}}
 	rply = utils.NewOrderedNavigableMap()
 
@@ -485,7 +496,7 @@ func TestProcessRequest(t *testing.T) {
 		reqProcessor.Tenant, config.CgrConfig().GeneralCfg().DefaultTenant,
 		config.CgrConfig().GeneralCfg().DefaultTimezone, filters, nil)
 
-	pr, err = da.processRequest(reqProcessor, agReq)
+	pr, err = da.processRequest(clnReq, agReq)
 	if err != nil {
 		t.Error(err)
 	} else if !pr {

agents/dnsagent.go

@@ -242,19 +242,14 @@ func (da *DNSAgent) processRequest(reqProcessor *config.RequestProcessor,
 		err = da.connMgr.Call(context.TODO(), da.cgrCfg.DNSAgentCfg().SessionSConns,
 			utils.SessionSv1InitiateSession,
 			cgrEv, rply)
-		rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesInit))
+		rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesInitiate))
 		agReq.setCGRReply(rply, err)
 	case utils.MetaUpdate:
-		updateArgs := sessions.NewV1UpdateSessionArgs(
-			reqProcessor.Flags.GetBool(utils.MetaAttributes),
-			reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs),
-			reqProcessor.Flags.Has(utils.MetaAccounts),
-			cgrEv, reqProcessor.Flags.Has(utils.MetaFD))
 		rply := new(sessions.V1UpdateSessionReply)
 		err = da.connMgr.Call(context.TODO(), da.cgrCfg.DNSAgentCfg().SessionSConns,
 			utils.SessionSv1UpdateSession,
-			updateArgs, rply)
-		rply.SetMaxUsageNeeded(updateArgs.UpdateSession)
+			cgrEv, rply)
+		rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesUpdate))
 		agReq.setCGRReply(rply, err)
 	case utils.MetaTerminate:
 		terminateArgs := sessions.NewV1TerminateSessionArgs(

agents/fsagent.go

@@ -242,7 +242,7 @@ func (fsa *FSsessions) onChannelAnswer(fsev FSEvent, connIdx int) {
 
 	cgrEv := fsev.AsCGREvent(config.CgrConfig().GeneralCfg().DefaultTimezone)
 	if cgrEv.APIOpts == nil {
-		cgrEv.APIOpts = map[string]interface{}{utils.OptsSesInit: true}
+		cgrEv.APIOpts = map[string]interface{}{utils.OptsSesInitiate: true}
 	}
 	cgrEv.Event[FsConnID] = connIdx // Attach the connection ID so we can properly disconnect later
 	var initReply sessions.V1InitSessionReply

agents/httpagent.go

@@ -173,18 +173,13 @@ func (ha *HTTPAgent) processRequest(reqProcessor *config.RequestProcessor,
 		rply := new(sessions.V1InitSessionReply)
 		err = ha.connMgr.Call(context.TODO(), ha.sessionConns, utils.SessionSv1InitiateSession,
 			cgrEv, rply)
-		rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesInit))
+		rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesInitiate))
 		agReq.setCGRReply(rply, err)
 	case utils.MetaUpdate:
-		updateArgs := sessions.NewV1UpdateSessionArgs(
-			reqProcessor.Flags.GetBool(utils.MetaAttributes),
-			reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs),
-			reqProcessor.Flags.Has(utils.MetaAccounts),
-			cgrEv, reqProcessor.Flags.Has(utils.MetaFD))
 		rply := new(sessions.V1UpdateSessionReply)
 		err = ha.connMgr.Call(context.TODO(), ha.sessionConns, utils.SessionSv1UpdateSession,
-			updateArgs, rply)
-		rply.SetMaxUsageNeeded(updateArgs.UpdateSession)
+			cgrEv, rply)
+		rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesUpdate))
 		agReq.setCGRReply(rply, err)
 	case utils.MetaTerminate:
 		terminateArgs := sessions.NewV1TerminateSessionArgs(

agents/kamagent.go

@@ -177,7 +177,7 @@ func (ka *KamailioAgent) onCallStart(evData []byte, connIdx int) {
 	}
 	cgrEv := kev.AsCGREvent(config.CgrConfig().GeneralCfg().DefaultTimezone)
 	if cgrEv.APIOpts == nil {
-		cgrEv.APIOpts = map[string]interface{}{utils.OptsSesInit: true}
+		cgrEv.APIOpts = map[string]interface{}{utils.OptsSesInitiate: true}
 	}
 	cgrEv.Event[EvapiConnID] = connIdx // Attach the connection ID so we can properly disconnect later
 

agents/radagent.go

@@ -231,18 +231,13 @@ func (ra *RadiusAgent) processRequest(req *radigo.Packet, reqProcessor *config.R
 		rply := new(sessions.V1InitSessionReply)
 		err = ra.connMgr.Call(context.TODO(), ra.cgrCfg.RadiusAgentCfg().SessionSConns, utils.SessionSv1InitiateSession,
 			cgrEv, rply)
-		rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesInit))
+		rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesInitiate))
 		agReq.setCGRReply(rply, err)
 	case utils.MetaUpdate:
-		updateArgs := sessions.NewV1UpdateSessionArgs(
-			reqProcessor.Flags.GetBool(utils.MetaAttributes),
-			reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs),
-			reqProcessor.Flags.Has(utils.MetaAccounts),
-			cgrEv, reqProcessor.Flags.Has(utils.MetaFD))
 		rply := new(sessions.V1UpdateSessionReply)
 		err = ra.connMgr.Call(context.TODO(), ra.cgrCfg.RadiusAgentCfg().SessionSConns, utils.SessionSv1UpdateSession,
-			updateArgs, rply)
-		rply.SetMaxUsageNeeded(updateArgs.UpdateSession)
+			cgrEv, rply)
+		rply.SetMaxUsageNeeded(utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesUpdate))
 		agReq.setCGRReply(rply, err)
 	case utils.MetaTerminate:
 		terminateArgs := sessions.NewV1TerminateSessionArgs(

apis/sessions.go

@@ -57,7 +57,7 @@ func (ssv1 *SessionSv1) InitiateSessionWithDigest(ctx *context.Context, args *ut
 	return ssv1.sS.BiRPCv1InitiateSessionWithDigest(ctx, args, rply)
 }
 
-func (ssv1 *SessionSv1) UpdateSession(ctx *context.Context, args *sessions.V1UpdateSessionArgs,
+func (ssv1 *SessionSv1) UpdateSession(ctx *context.Context, args *utils.CGREvent,
 	rply *sessions.V1UpdateSessionReply) error {
 	return ssv1.sS.BiRPCv1UpdateSession(ctx, args, rply)
 }

console/session_update.go

@@ -27,7 +27,7 @@ func init() {
 	c := &CmdSessionsUpdate{
 		name:      "session_update",
 		rpcMethod: utils.SessionSv1UpdateSession,
-		rpcParams: &sessions.V1UpdateSessionArgs{},
+		rpcParams: &utils.CGREvent{},
 	}
 	commands[c.Name()] = c
 	c.CommandExecuter = &CommandExecuter{c}
@@ -36,7 +36,7 @@ func init() {
 type CmdSessionsUpdate struct {
 	name      string
 	rpcMethod string
-	rpcParams *sessions.V1UpdateSessionArgs
+	rpcParams *utils.CGREvent
 	*CommandExecuter
 }
 
@@ -50,9 +50,7 @@ func (self *CmdSessionsUpdate) RpcMethod() string {
 
 func (self *CmdSessionsUpdate) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
-		self.rpcParams = &sessions.V1UpdateSessionArgs{
-			CGREvent: new(utils.CGREvent),
-		}
+		self.rpcParams = new(utils.CGREvent)
 	}
 	return self.rpcParams
 }

dispatchers/sessions.go

@@ -83,16 +83,16 @@ func (dS *DispatcherService) SessionSv1InitiateSessionWithDigest(args *utils.CGR
 	return dS.Dispatch(context.TODO(), args, utils.MetaSessionS, utils.SessionSv1InitiateSessionWithDigest, args, reply)
 }
 
-func (dS *DispatcherService) SessionSv1UpdateSession(args *sessions.V1UpdateSessionArgs,
+func (dS *DispatcherService) SessionSv1UpdateSession(args *utils.CGREvent,
 	reply *sessions.V1UpdateSessionReply) (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.SessionSv1UpdateSession, args.CGREvent.Tenant,
+		if err = dS.authorize(utils.SessionSv1UpdateSession, args.Tenant,
 			utils.IfaceAsString(args.APIOpts[utils.OptsAPIKey])); err != nil {
 			return
 		}
 	}
-	return dS.Dispatch(context.TODO(), args.CGREvent, utils.MetaSessionS, utils.SessionSv1UpdateSession, args, reply)
+	return dS.Dispatch(context.TODO(), args, utils.MetaSessionS, utils.SessionSv1UpdateSession, args, reply)
 }
 
 func (dS *DispatcherService) SessionSv1SyncSessions(args *utils.TenantWithAPIOpts,

dispatchers/sessions_test.go

@@ -121,39 +121,6 @@ func TestDspSessionSv1AuthorizeEventWithDigestErrorNil(t *testing.T) {
 	}
 }
 
-func TestDspSessionSv1UpdateSessionNil(t *testing.T) {
-	cgrCfg := config.NewDefaultCGRConfig()
-	dspSrv := NewDispatcherService(nil, cgrCfg, nil, nil)
-	CGREvent := &sessions.V1UpdateSessionArgs{
-		CGREvent: &utils.CGREvent{
-			Tenant: "tenant",
-		},
-	}
-	var reply *sessions.V1UpdateSessionReply
-	result := dspSrv.SessionSv1UpdateSession(CGREvent, reply)
-	expected := "DISPATCHER_ERROR:NO_DATABASE_CONNECTION"
-	if result == nil || result.Error() != expected {
-		t.Errorf("\nExpected <%+v>, \nReceived <%+v>", expected, result)
-	}
-}
-
-func TestDspSessionSv1UpdateSessionErrorNil(t *testing.T) {
-	cgrCfg := config.NewDefaultCGRConfig()
-	dspSrv := NewDispatcherService(nil, cgrCfg, nil, nil)
-	cgrCfg.DispatcherSCfg().AttributeSConns = []string{"test"}
-	CGREvent := &sessions.V1UpdateSessionArgs{
-		CGREvent: &utils.CGREvent{
-			Tenant: "tenant",
-		},
-	}
-	var reply *sessions.V1UpdateSessionReply
-	result := dspSrv.SessionSv1UpdateSession(CGREvent, reply)
-	expected := "MANDATORY_IE_MISSING: [ApiKey]"
-	if result == nil || result.Error() != expected {
-		t.Errorf("\nExpected <%+v>, \nReceived <%+v>", expected, result)
-	}
-}
-
 func TestDspSessionSv1SyncSessionsNil(t *testing.T) {
 	cgrCfg := config.NewDefaultCGRConfig()
 	dspSrv := NewDispatcherService(nil, cgrCfg, nil, nil)

ers/ers.go

@@ -233,14 +233,9 @@ func (erS *ERService) processEvent(cgrEv *utils.CGREvent,
 		err = erS.connMgr.Call(context.TODO(), erS.cfg.ERsCfg().SessionSConns, utils.SessionSv1InitiateSession,
 			cgrEv, rply)
 	case utils.MetaUpdate:
-		updateArgs := sessions.NewV1UpdateSessionArgs(
-			rdrCfg.Flags.Has(utils.MetaAttributes),
-			rdrCfg.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs),
-			rdrCfg.Flags.Has(utils.MetaAccounts),
-			cgrEv, rdrCfg.Flags.Has(utils.MetaFD))
 		rply := new(sessions.V1UpdateSessionReply)
 		err = erS.connMgr.Call(context.TODO(), erS.cfg.ERsCfg().SessionSConns, utils.SessionSv1UpdateSession,
-			updateArgs, rply)
+			cgrEv, rply)
 	case utils.MetaTerminate:
 		terminateArgs := sessions.NewV1TerminateSessionArgs(
 			rdrCfg.Flags.Has(utils.MetaAccounts),

sessions/libsessions.go

@@ -742,30 +742,6 @@ type V1InitReplyWithDigest struct {
 	StatQueues         *string
 }
 
-// NewV1UpdateSessionArgs is a constructor for update session arguments
-func NewV1UpdateSessionArgs(attrs bool, attributeIDs []string,
-	acnts bool, cgrEv *utils.CGREvent, forceDuration bool) (args *V1UpdateSessionArgs) {
-	args = &V1UpdateSessionArgs{
-		GetAttributes: attrs,
-		UpdateSession: acnts,
-		CGREvent:      cgrEv,
-		ForceDuration: forceDuration,
-	}
-	if len(attributeIDs) != 0 {
-		args.AttributeIDs = attributeIDs
-	}
-	return
-}
-
-// V1UpdateSessionArgs contains options for session update
-type V1UpdateSessionArgs struct {
-	GetAttributes bool
-	UpdateSession bool
-	ForceDuration bool
-	AttributeIDs  []string
-	*utils.CGREvent
-}
-
 // V1UpdateSessionReply contains options for session update reply
 type V1UpdateSessionReply struct {
 	Attributes *engine.AttrSProcessEventReply `json:",omitempty"`

sessions/sessions.go

@@ -1742,7 +1742,7 @@ func (sS *SessionS) BiRPCv1InitiateSession(ctx *context.Context,
 	// end of RPC caching
 
 	attrS := utils.OptAsBool(args.APIOpts, utils.OptsSesAttributeS)
-	initS := utils.OptAsBool(args.APIOpts, utils.OptsSesInit)
+	initS := utils.OptAsBool(args.APIOpts, utils.OptsSesInitiate)
 	resS := utils.OptAsBool(args.APIOpts, utils.OptsSesResourceSAloc)
 	if !(attrS || initS || resS) {
 		return // nothing to do
@@ -1882,20 +1882,20 @@ func (sS *SessionS) BiRPCv1InitiateSessionWithDigest(ctx *context.Context,
 
 // BiRPCv1UpdateSession updates an existing session, returning the duration which the session can still last
 func (sS *SessionS) BiRPCv1UpdateSession(ctx *context.Context,
-	args *V1UpdateSessionArgs, rply *V1UpdateSessionReply) (err error) {
-	if args.CGREvent == nil {
+	args *utils.CGREvent, rply *V1UpdateSessionReply) (err error) {
+	if args == nil {
 		return utils.NewErrMandatoryIeMissing(utils.CGREventString)
 	}
-	if args.CGREvent.ID == utils.EmptyString {
-		args.CGREvent.ID = utils.GenUUID()
+	if args.ID == utils.EmptyString {
+		args.ID = utils.GenUUID()
 	}
-	if args.CGREvent.Tenant == utils.EmptyString {
-		args.CGREvent.Tenant = sS.cgrCfg.GeneralCfg().DefaultTenant
+	if args.Tenant == utils.EmptyString {
+		args.Tenant = sS.cgrCfg.GeneralCfg().DefaultTenant
 	}
 
 	// RPC caching
 	if sS.cgrCfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit != 0 {
-		cacheKey := utils.ConcatenatedKey(utils.SessionSv1UpdateSession, args.CGREvent.ID)
+		cacheKey := utils.ConcatenatedKey(utils.SessionSv1UpdateSession, args.ID)
 		refID := guardian.Guardian.GuardIDs("",
 			sS.cgrCfg.GeneralCfg().LockingTimeout, cacheKey) // RPC caching needs to be atomic
 		defer guardian.Guardian.UnguardIDs(refID)
@@ -1912,22 +1912,27 @@ func (sS *SessionS) BiRPCv1UpdateSession(ctx *context.Context,
 			nil, true, utils.NonTransactional)
 	}
 	// end of RPC caching
-
-	if !args.GetAttributes && !args.UpdateSession {
+	attrS := utils.OptAsBool(args.APIOpts, utils.OptsSesAttributeS)
+	updS := utils.OptAsBool(args.APIOpts, utils.OptsSesUpdate)
+	if !(attrS || updS) {
 		return // nothing to do
 	}
 
-	if args.GetAttributes {
-		rplyAttr, err := sS.processAttributes(ctx, args.CGREvent, args.AttributeIDs, false)
+	if attrS {
+		var atrsIDs []string
+		if atrsIDs, err = utils.OptAsStringSlice(args.APIOpts, utils.OptsSesAttributeIDs); err != nil {
+			return
+		}
+		rplyAttr, err := sS.processAttributes(ctx, args, atrsIDs, false)
 		if err == nil {
-			args.CGREvent = rplyAttr.CGREvent
+			args = rplyAttr.CGREvent
 			rply.Attributes = &rplyAttr
 		} else if err.Error() != utils.ErrNotFound.Error() {
 			return utils.NewErrAttributeS(err)
 		}
 	}
-	if args.UpdateSession {
-		ev := engine.MapEvent(args.CGREvent.Event)
+	if updS {
+		ev := engine.MapEvent(args.Event)
 		opts := engine.MapEvent(args.APIOpts)
 		dbtItvl := sS.cgrCfg.SessionSCfg().DebitInterval
 		if opts.HasField(utils.OptsSesDebitInterval) { // dynamic DebitInterval via CGRDebitInterval
@@ -1941,8 +1946,8 @@ func (sS *SessionS) BiRPCv1UpdateSession(ctx *context.Context,
 			ev.GetStringIgnoreErrors(utils.OriginID),
 			ev.GetStringIgnoreErrors(utils.OriginHost))
 		if s == nil {
-			if s, err = sS.initSession(ctx, args.CGREvent, sS.biJClntID(ctx.Client), ev.GetStringIgnoreErrors(utils.OriginID),
-				dbtItvl, false, args.ForceDuration); err != nil {
+			if s, err = sS.initSession(ctx, args, sS.biJClntID(ctx.Client), ev.GetStringIgnoreErrors(utils.OriginID),
+				dbtItvl, false, utils.OptAsBool(args.APIOpts, utils.OptsSesForceDuration)); err != nil {
 				return err
 			}
 		}

sessions/sessions_test.go

@@ -1031,44 +1031,6 @@ func TestV1AuthorizeArgsParseFlags1(t *testing.T) {
 	}
 }
 
-func TestSessionSNewV1UpdateSessionArgs(t *testing.T) {
-	cgrEv := &utils.CGREvent{
-		Tenant: "cgrates.org",
-		ID:     "Event",
-		Event: map[string]interface{}{
-			utils.AccountField: "1001",
-			utils.Destination:  "1002",
-		},
-	}
-	expected := &V1UpdateSessionArgs{
-		GetAttributes: true,
-		UpdateSession: true,
-		CGREvent:      cgrEv,
-		ForceDuration: true,
-	}
-	rply := NewV1UpdateSessionArgs(true, nil, true, cgrEv, true)
-	if !reflect.DeepEqual(expected, rply) {
-		t.Errorf("Expecting %+v, received: %+v", expected, rply)
-	}
-	expected = &V1UpdateSessionArgs{
-		GetAttributes: false,
-		UpdateSession: true,
-		CGREvent:      cgrEv,
-		ForceDuration: true,
-	}
-	rply = NewV1UpdateSessionArgs(false, nil, true, cgrEv, true)
-	if !reflect.DeepEqual(expected, rply) {
-		t.Errorf("Expecting %+v, received: %+v", expected, rply)
-	}
-	//test with len(AttributeIDs) != 0
-	attributeIDs := []string{"ATTR1", "ATTR2"}
-	rply = NewV1UpdateSessionArgs(false, attributeIDs, true, cgrEv, true)
-	expected.AttributeIDs = []string{"ATTR1", "ATTR2"}
-	if !reflect.DeepEqual(expected, rply) {
-		t.Errorf("Expecting %+v, received: %+v", expected, rply)
-	}
-}
-
 func TestSessionSNewV1TerminateSessionArgs(t *testing.T) {
 	cgrEv := &utils.CGREvent{
 		Tenant: "cgrates.org",

utils/consts.go

@@ -2126,7 +2126,8 @@ const (
 	OptsSesThresholdIDs           = "*sesThresholdIDs"
 	OptsSesMaxUsage               = "*sesMaxUsage"
 	OptsSesForceDuration          = "*sesForceDuration"
-	OptsSesInit                   = "*sesInit"
+	OptsSesInitiate               = "*sesInitiate"
+	OptsSesUpdate                 = "*sesUpdate"
 
 	OptsCDRsAttributeS = "*cdrsAttributeS"
 	OptsCDRsChargerS   = "*cdrsChargerS"