GetLcrSuppliers in the SM-Generic

apier/v1/smgenericbirpcv1.go

@@ -37,11 +37,12 @@ type SMGenericBiRpcV1 struct {
 // Publishes methods exported by SMGenericBiRpcV1 as SMGenericV1 (so we can handle standard RPC methods via birpc socket)
 func (self *SMGenericBiRpcV1) Handlers() map[string]interface{} {
 	return map[string]interface{}{
-		"SMGenericV1.GetMaxUsage":   self.GetMaxUsage,
-		"SMGenericV1.SessionStart":  self.SessionStart,
-		"SMGenericV1.SessionUpdate": self.SessionUpdate,
-		"SMGenericV1.SessionEnd":    self.SessionEnd,
-		"SMGenericV1.ProcessCdr":    self.ProcessCdr,
+		"SMGenericV1.GetMaxUsage":     self.GetMaxUsage,
+		"SMGenericV1.GetLcrSuppliers": self.GetLcrSuppliers,
+		"SMGenericV1.SessionStart":    self.SessionStart,
+		"SMGenericV1.SessionUpdate":   self.SessionUpdate,
+		"SMGenericV1.SessionEnd":      self.SessionEnd,
+		"SMGenericV1.ProcessCdr":      self.ProcessCdr,
 	}
 }
 
@@ -59,6 +60,16 @@ func (self *SMGenericBiRpcV1) GetMaxUsage(clnt *rpc2.Client, ev sessionmanager.G
 	return nil
 }
 
+/// Returns list of suppliers which can be used for the request
+func (self *SMGenericBiRpcV1) GetLcrSuppliers(clnt *rpc2.Client, ev sessionmanager.GenericEvent, suppliers *[]string) error {
+	if supls, err := self.sm.GetLcrSuppliers(ev, clnt); err != nil {
+		return utils.NewErrServerError(err)
+	} else {
+		*suppliers = supls
+	}
+	return nil
+}
+
 // Called on session start, returns the maximum number of seconds the session can last
 func (self *SMGenericBiRpcV1) SessionStart(clnt *rpc2.Client, ev sessionmanager.GenericEvent, maxUsage *float64) error {
 	if err := self.sm.SessionStart(ev, clnt); err != nil {

apier/v1/smgenericv1.go

@@ -30,6 +30,16 @@ func (self *SMGenericV1) GetMaxUsage(ev sessionmanager.GenericEvent, maxUsage *f
 	return nil
 }
 
+/// Returns list of suppliers which can be used for the request
+func (self *SMGenericV1) GetLcrSuppliers(ev sessionmanager.GenericEvent, suppliers *[]string) error {
+	if supls, err := self.sm.GetLcrSuppliers(ev, nil); err != nil {
+		return utils.NewErrServerError(err)
+	} else {
+		*suppliers = supls
+	}
+	return nil
+}
+
 // Called on session start, returns the maximum number of seconds the session can last
 func (self *SMGenericV1) SessionStart(ev sessionmanager.GenericEvent, maxUsage *float64) error {
 	if err := self.sm.SessionStart(ev, nil); err != nil {

sessionmanager/genericsm.go

@@ -19,6 +19,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 package sessionmanager
 
 import (
+	"errors"
 	"sync"
 	"time"
 
@@ -86,6 +87,23 @@ func (self *GenericSessionManager) GetMaxUsage(gev GenericEvent, clnt *rpc2.Clie
 	return time.Duration(maxDur), nil
 }
 
+func (self *GenericSessionManager) GetLcrSuppliers(gev GenericEvent, clnt *rpc2.Client) ([]string, error) {
+	gev[utils.EVENT_NAME] = utils.CGR_LCR_REQUEST
+	cd, err := gev.AsLcrRequest(self.timezone).AsCallDescriptor(self.timezone)
+	if err != nil {
+		return nil, err
+	}
+	var lcr engine.LCRCost
+	if err = self.rater.GetLCR(&engine.AttrGetLcr{CallDescriptor: cd}, &lcr); err != nil {
+		return nil, err
+	}
+	if lcr.HasErrors() {
+		lcr.LogErrors()
+		return nil, errors.New("LCR_COMPUTE_ERROR")
+	}
+	return lcr.SuppliersSlice()
+}
+
 // Called on session start
 func (self *GenericSessionManager) SessionStart(gev GenericEvent, clnt *rpc2.Client) error {
 	return nil

sessionmanager/genericvent.go

@@ -202,8 +202,17 @@ func (self GenericEvent) MissingParameter(timezone string) bool {
 		}
 		return len(self.GetAccount(utils.META_DEFAULT)) == 0 ||
 			len(self.GetDestination(utils.META_DEFAULT)) == 0
+
+	case utils.CGR_SESSION_START:
+		return false
+	case utils.CGR_SESSION_UPDATE:
+		return false
+	case utils.CGR_SESSION_END:
+		return false
+	case utils.CGR_LCR_REQUEST:
+		return false
 	}
-	return false
+	return true // Unhandled event
 }
 
 func (self GenericEvent) ParseEventValue(rsrFld *utils.RSRField, timezone string) string {
@@ -281,3 +290,18 @@ func (self GenericEvent) ComputeLcr() bool {
 	computeLcr, _ := self[utils.COMPUTE_LCR].(bool)
 	return computeLcr
 }
+
+func (self GenericEvent) AsLcrRequest(timezone string) *engine.LcrRequest {
+	setupTimeStr, _ := utils.ConvertIfaceToString(self[utils.SETUP_TIME])
+	usageStr, _ := utils.ConvertIfaceToString(self[utils.USAGE])
+	return &engine.LcrRequest{
+		Direction:   self.GetDirection(utils.META_DEFAULT),
+		Tenant:      self.GetTenant(utils.META_DEFAULT),
+		Category:    self.GetCategory(utils.META_DEFAULT),
+		Account:     self.GetAccount(utils.META_DEFAULT),
+		Subject:     self.GetSubject(utils.META_DEFAULT),
+		Destination: self.GetDestination(utils.META_DEFAULT),
+		SetupTime:   utils.FirstNonEmpty(setupTimeStr),
+		Duration:    usageStr,
+	}
+}

utils/consts.go

@@ -240,8 +240,12 @@ const (
 	COUNTER_EVENT                = "*event"
 	COUNTER_BALANCE              = "*balance"
 	EVENT_NAME                   = "EventName"
-	CGR_AUTHORIZATION            = "CgrAuthorization"
 	COMPUTE_LCR                  = "ComputeLcr"
+	CGR_AUTHORIZATION            = "CgrAuthorization"
+	CGR_SESSION_START            = "CgrSessionStart"
+	CGR_SESSION_UPDATE           = "CgrSessionUpdate"
+	CGR_SESSION_END              = "CgrSessionEnd"
+	CGR_LCR_REQUEST              = "CgrLcrRequest"
 )
 
 var (