diff --git a/dispatchers/accounts.go b/dispatchers/accounts.go
index 69606a260..8b0825cc3 100644
--- a/dispatchers/accounts.go
+++ b/dispatchers/accounts.go
@@ -51,7 +51,7 @@ func (dS *DispatcherService) AccountsForEvent(args *utils.CGREvent, reply *[]*ut
return dS.Dispatch(context.TODO(), args, utils.MetaAccounts, utils.AccountSv1AccountsForEvent, args, reply)
}
-func (dS *DispatcherService) MaxAbstracts(args *utils.CGREvent, reply *utils.ExtEventCharges) (err error) {
+func (dS *DispatcherService) MaxAbstracts(args *utils.CGREvent, reply *utils.EventCharges) (err error) {
tnt := dS.cfg.GeneralCfg().DefaultTenant
if args != nil && args.Tenant != utils.EmptyString {
tnt = args.Tenant
@@ -65,7 +65,7 @@ func (dS *DispatcherService) MaxAbstracts(args *utils.CGREvent, reply *utils.Ext
return dS.Dispatch(context.TODO(), args, utils.MetaAccounts, utils.AccountSv1MaxAbstracts, args, reply)
}
-func (dS *DispatcherService) DebitAbstracts(args *utils.CGREvent, reply *utils.ExtEventCharges) (err error) {
+func (dS *DispatcherService) DebitAbstracts(args *utils.CGREvent, reply *utils.EventCharges) (err error) {
tnt := dS.cfg.GeneralCfg().DefaultTenant
if args != nil && args.Tenant != utils.EmptyString {
tnt = args.Tenant
@@ -79,7 +79,7 @@ func (dS *DispatcherService) DebitAbstracts(args *utils.CGREvent, reply *utils.E
return dS.Dispatch(context.TODO(), args, utils.MetaAccounts, utils.AccountSv1DebitAbstracts, args, reply)
}
-func (dS *DispatcherService) MaxConcretes(args *utils.CGREvent, reply *utils.ExtEventCharges) (err error) {
+func (dS *DispatcherService) MaxConcretes(args *utils.CGREvent, reply *utils.EventCharges) (err error) {
tnt := dS.cfg.GeneralCfg().DefaultTenant
if args != nil && args.Tenant != utils.EmptyString {
tnt = args.Tenant
@@ -93,7 +93,7 @@ func (dS *DispatcherService) MaxConcretes(args *utils.CGREvent, reply *utils.Ext
return dS.Dispatch(context.TODO(), args, utils.MetaAccounts, utils.AccountSv1MaxConcretes, args, reply)
}
-func (dS *DispatcherService) DebitConcretes(args *utils.CGREvent, reply *utils.ExtEventCharges) (err error) {
+func (dS *DispatcherService) DebitConcretes(args *utils.CGREvent, reply *utils.EventCharges) (err error) {
tnt := dS.cfg.GeneralCfg().DefaultTenant
if args != nil && args.Tenant != utils.EmptyString {
tnt = args.Tenant
diff --git a/utils/account.go b/utils/account.go
index ca7eb79b6..b4adb1b5c 100644
--- a/utils/account.go
+++ b/utils/account.go
@@ -19,8 +19,6 @@ along with this program. If not, see
package utils
import (
- "errors"
- "fmt"
"sort"
"time"
@@ -99,104 +97,6 @@ func NewDefaultBalance(id string) *Balance {
}
}
-type ExtAccount struct {
- Tenant string
- ID string // Account identificator, unique within the tenant
- FilterIDs []string
- Weights DynamicWeights
- Opts map[string]interface{}
- Balances map[string]*ExtBalance
- ThresholdIDs []string
-}
-
-// AsExtAccount converts Account to ExtAccount
-func (aC *Account) AsExtAccount() (eAc *ExtAccount, err error) {
- eAc = &ExtAccount{
- Tenant: aC.Tenant,
- ID: aC.ID,
- }
- if aC.FilterIDs != nil {
- eAc.FilterIDs = make([]string, len(aC.FilterIDs))
- for idx, val := range aC.FilterIDs {
- eAc.FilterIDs[idx] = val
- }
- }
- if aC.Weights != nil {
- eAc.Weights = aC.Weights
- }
- if aC.Opts != nil {
- eAc.Opts = make(map[string]interface{}, len(aC.Opts))
- for key, val := range aC.Opts {
- eAc.Opts[key] = val
- }
- }
- if aC.Balances != nil {
- eAc.Balances = make(map[string]*ExtBalance, len(aC.Balances))
- for key, val := range aC.Balances {
- if bal, err := val.AsExtBalance(); err != nil {
- return nil, err
- } else {
- eAc.Balances[key] = bal
- }
- }
- }
- if aC.ThresholdIDs != nil {
- eAc.ThresholdIDs = make([]string, len(aC.ThresholdIDs))
- for idx, val := range aC.ThresholdIDs {
- eAc.ThresholdIDs[idx] = val
- }
- }
- return
-}
-
-// Equals returns the equality between two ExtAccount
-func (eAc *ExtAccount) Equals(extAc *ExtAccount) (eq bool) {
- if (eAc.ID != extAc.ID || eAc.Tenant != extAc.Tenant) ||
- (eAc.FilterIDs == nil && extAc.FilterIDs != nil ||
- eAc.FilterIDs != nil && extAc.FilterIDs == nil ||
- len(eAc.FilterIDs) != len(extAc.FilterIDs)) ||
- (eAc.Weights == nil && extAc.Weights != nil ||
- eAc.Weights != nil && extAc.Weights == nil ||
- len(eAc.Weights) != len(extAc.Weights)) ||
- (eAc.Opts == nil && extAc.Opts != nil ||
- eAc.Opts != nil && extAc.Opts == nil ||
- len(eAc.Opts) != len(extAc.Opts)) ||
- (eAc.Balances == nil && extAc.Balances != nil ||
- eAc.Balances != nil && extAc.Balances == nil ||
- len(eAc.Balances) != len(extAc.Balances)) ||
- (eAc.ThresholdIDs == nil && extAc.ThresholdIDs != nil ||
- eAc.ThresholdIDs != nil && extAc.ThresholdIDs == nil ||
- len(eAc.ThresholdIDs) != len(extAc.ThresholdIDs)) {
- return
- }
- for idx, val := range eAc.FilterIDs {
- if val != extAc.FilterIDs[idx] {
- return
- }
- }
- for idx, val := range eAc.Weights {
- if ok := val.Equals(extAc.Weights[idx]); !ok {
- return
- }
- }
- for key, val := range eAc.Opts {
- if val != extAc.Opts[key] {
- return
- }
- }
- for key, val := range eAc.Balances {
- if ok := val.Equals(extAc.Balances[key]); !ok {
- return
- }
- }
- for idx, val := range eAc.ThresholdIDs {
- if val != extAc.ThresholdIDs[idx] {
- return
- }
- }
- return true
-}
-
// Balance represents one Balance inside an Account
type Balance struct {
ID string // Balance identificator, unique within an Account
@@ -211,148 +111,6 @@ type Balance struct {
RateProfileIDs []string
}
-type ExtBalance struct {
- ID string // Balance identificator, unique within an Account
- FilterIDs []string
- Weights DynamicWeights
- Type string
- Units *float64
- UnitFactors []*ExtUnitFactor
- Opts map[string]interface{}
- CostIncrements []*ExtCostIncrement
- AttributeIDs []string
- RateProfileIDs []string
-}
-
-// AsExtBalance converts Balance to ExtBalance
-func (bL *Balance) AsExtBalance() (eBl *ExtBalance, err error) {
- eBl = &ExtBalance{
- ID: bL.ID,
- Type: bL.Type,
- }
- if bL.FilterIDs != nil {
- eBl.FilterIDs = make([]string, len(bL.FilterIDs))
- for idx, val := range bL.FilterIDs {
- eBl.FilterIDs[idx] = val
- }
- }
- if bL.Weights != nil {
- eBl.Weights = bL.Weights
- }
- if bL.Units != nil {
- fltUnits, ok := bL.Units.Big.Float64()
- if !ok {
- Logger.Warning(fmt.Sprintf("Units Balance: %v from ID: %v cannot fit into a float64 without truncation, overflow, or underflow", bL.Units, bL.ID))
- }
- eBl.Units = &fltUnits
- }
- if bL.UnitFactors != nil {
- eBl.UnitFactors = make([]*ExtUnitFactor, len(bL.UnitFactors))
- for idx, val := range bL.UnitFactors {
- if uFctr, err := val.AsExtUnitFactor(); err != nil {
- return nil, err
- } else {
- eBl.UnitFactors[idx] = uFctr
- }
- }
- }
- if bL.Opts != nil {
- eBl.Opts = make(map[string]interface{}, len(bL.Opts))
- for key, val := range bL.Opts {
- eBl.Opts[key] = val
- }
- }
- if bL.CostIncrements != nil {
- eBl.CostIncrements = make([]*ExtCostIncrement, len(bL.CostIncrements))
- for idx, val := range bL.CostIncrements {
- if extCstIncr, err := val.AsExtCostIncrement(); err != nil {
- return nil, err
- } else {
- eBl.CostIncrements[idx] = extCstIncr
- }
- }
- }
- if bL.AttributeIDs != nil {
- eBl.AttributeIDs = make([]string, len(bL.AttributeIDs))
- for idx, val := range bL.AttributeIDs {
- eBl.AttributeIDs[idx] = val
- }
- }
- if bL.RateProfileIDs != nil {
- eBl.RateProfileIDs = make([]string, len(bL.RateProfileIDs))
- for idx, val := range bL.RateProfileIDs {
- eBl.RateProfileIDs[idx] = val
- }
- }
- return
-}
-
-// Equals returns the equality between two ExtBalance
-func (eBL *ExtBalance) Equals(extBl *ExtBalance) (eq bool) {
- if (eBL.ID != extBl.ID || eBL.Type != extBl.Type) ||
- (eBL.FilterIDs == nil && extBl.FilterIDs != nil ||
- eBL.FilterIDs != nil && extBl.FilterIDs == nil ||
- len(eBL.FilterIDs) != len(extBl.FilterIDs)) ||
- (eBL.Weights == nil && extBl.Weights != nil ||
- eBL.Weights != nil && extBl.Weights == nil ||
- len(eBL.Weights) != len(extBl.Weights)) ||
- !((eBL.Units == nil && extBl.Units == nil) ||
- (eBL.Units != nil && extBl.Units != nil && *eBL.Units == *extBl.Units)) ||
- (eBL.UnitFactors == nil && extBl.UnitFactors != nil ||
- eBL.UnitFactors != nil && extBl.UnitFactors == nil ||
- len(eBL.UnitFactors) != len(extBl.UnitFactors)) ||
- (eBL.Opts == nil && extBl.Opts != nil ||
- eBL.Opts != nil && extBl.Opts == nil ||
- len(eBL.Opts) != len(extBl.Opts)) ||
- (eBL.CostIncrements == nil && extBl.CostIncrements != nil ||
- eBL.CostIncrements != nil && extBl.CostIncrements == nil ||
- len(eBL.CostIncrements) != len(extBl.CostIncrements)) ||
- (eBL.AttributeIDs == nil && extBl.AttributeIDs != nil ||
- eBL.AttributeIDs != nil && extBl.AttributeIDs == nil ||
- len(eBL.AttributeIDs) != len(extBl.AttributeIDs)) ||
- (eBL.RateProfileIDs == nil && extBl.RateProfileIDs != nil ||
- eBL.RateProfileIDs != nil && extBl.RateProfileIDs == nil ||
- len(eBL.RateProfileIDs) != len(extBl.RateProfileIDs)) {
- return
- }
- for i, val := range eBL.FilterIDs {
- if val != extBl.FilterIDs[i] {
- return
- }
- }
- for idx, val := range eBL.Weights {
- if ok := val.Equals(extBl.Weights[idx]); !ok {
- return
- }
- }
- for idx, val := range eBL.UnitFactors {
- if ok := val.Equals(extBl.UnitFactors[idx]); !ok {
- return
- }
- }
- for key, val := range eBL.Opts {
- if val != extBl.Opts[key] {
- return
- }
- }
- for idx, val := range eBL.CostIncrements {
- if ok := val.Equals(extBl.CostIncrements[idx]); !ok {
- return
- }
- }
- for i, val := range eBL.AttributeIDs {
- if val != extBl.AttributeIDs[i] {
- return
- }
- }
- for i, val := range eBL.RateProfileIDs {
- if val != extBl.RateProfileIDs[i] {
- return
- }
- }
- return true
-}
-
// Equals returns the equality between two Balance
func (bL *Balance) Equals(bal *Balance) (eq bool) {
if (bL.ID != bal.ID || bL.Type != bal.Type) ||
@@ -428,67 +186,6 @@ type CostIncrement struct {
RecurrentFee *Decimal
}
-type ExtCostIncrement struct {
- FilterIDs []string
- Increment *float64
- FixedFee *float64
- RecurrentFee *float64
-}
-
-// Equals returns the equality between two ExtCostIncrement
-func (eCi *ExtCostIncrement) Equals(extCi *ExtCostIncrement) (eq bool) {
- if (eCi.FilterIDs == nil && extCi.FilterIDs != nil ||
- eCi.FilterIDs != nil && extCi.FilterIDs == nil ||
- len(eCi.FilterIDs) != len(extCi.FilterIDs)) ||
- !((eCi.Increment == nil && extCi.Increment == nil) ||
- (eCi.Increment != nil && extCi.Increment != nil && *eCi.Increment == *extCi.Increment)) ||
- !((eCi.FixedFee == nil && extCi.FixedFee == nil) ||
- (eCi.FixedFee != nil && extCi.FixedFee != nil && *eCi.FixedFee == *extCi.FixedFee)) ||
- !((eCi.RecurrentFee == nil && extCi.RecurrentFee == nil) ||
- (eCi.RecurrentFee != nil && extCi.RecurrentFee != nil && *eCi.RecurrentFee == *extCi.RecurrentFee)) {
- return
- }
- for idx, val := range eCi.FilterIDs {
- if val != extCi.FilterIDs[idx] {
- return
- }
- }
- return true
-}
-
-// AsExtCostIncrement converts CostIncrement to ExtCostIncrement
-func (cI *CostIncrement) AsExtCostIncrement() (eCi *ExtCostIncrement, err error) {
- eCi = new(ExtCostIncrement)
- if cI.FilterIDs != nil {
- eCi.FilterIDs = make([]string, len(cI.FilterIDs))
- for idx, val := range cI.FilterIDs {
- eCi.FilterIDs[idx] = val
- }
- }
- if cI.Increment != nil {
- if fltIncr, ok := cI.Increment.Big.Float64(); !ok {
- return nil, errors.New("cannot convert decimal Increment to float64 ")
- } else {
- eCi.Increment = &fltIncr
- }
- }
- if cI.FixedFee != nil {
- if fltFxdFee, ok := cI.FixedFee.Big.Float64(); !ok {
- return nil, errors.New("cannot convert decimal FixedFee to float64 ")
- } else {
- eCi.FixedFee = &fltFxdFee
- }
- }
- if cI.RecurrentFee != nil {
- if fltRecFee, ok := cI.RecurrentFee.Big.Float64(); !ok {
- return nil, errors.New("cannot convert decimal RecurrentFee to float64 ")
- } else {
- eCi.RecurrentFee = &fltRecFee
- }
- }
- return
-}
-
// Equals returns the equality between two CostIncrement
func (cI *CostIncrement) Equals(ctIn *CostIncrement) (eq bool) {
if (cI.FilterIDs == nil && ctIn.FilterIDs != nil ||
@@ -537,47 +234,6 @@ func (cI *CostIncrement) Clone() (cIcln *CostIncrement) {
return
}
-type ExtUnitFactor struct {
- FilterIDs []string
- Factor *float64
-}
-
-// AsExtUnitFactor converts UnitFactor to ExtUnitFactor
-func (uF *UnitFactor) AsExtUnitFactor() (eUf *ExtUnitFactor, err error) {
- eUf = new(ExtUnitFactor)
- if uF.FilterIDs != nil {
- eUf.FilterIDs = make([]string, len(uF.FilterIDs))
- for idx, val := range uF.FilterIDs {
- eUf.FilterIDs[idx] = val
- }
- }
- if uF.Factor != nil {
- if fltFct, ok := uF.Factor.Big.Float64(); !ok {
- return nil, errors.New("cannot convert decimal Factor to float64 ")
- } else {
- eUf.Factor = &fltFct
- }
- }
- return
-}
-
-// Equals compares two ExtUnitFactor
-func (eUf *ExtUnitFactor) Equals(extUf *ExtUnitFactor) (eq bool) {
- if (eUf.FilterIDs == nil && extUf.FilterIDs != nil ||
- eUf.FilterIDs != nil && extUf.FilterIDs == nil ||
- len(eUf.FilterIDs) != len(extUf.FilterIDs)) ||
- !((eUf.Factor == nil && extUf.Factor == nil) ||
- (eUf.Factor != nil && extUf.Factor != nil && *eUf.Factor == *extUf.Factor)) {
- return
- }
- for idx, val := range eUf.FilterIDs {
- if val != extUf.FilterIDs[idx] {
- return
- }
- }
- return true
-}
-
// Clone return a copy of the UnitFactor
func (uF *UnitFactor) Clone() (untFct *UnitFactor) {
untFct = new(UnitFactor)
diff --git a/utils/eventcharges.go b/utils/eventcharges.go
index 445e15e0d..70c4dc788 100644
--- a/utils/eventcharges.go
+++ b/utils/eventcharges.go
@@ -18,10 +18,6 @@ along with this program. If not, see
package utils
-import (
- "errors"
-)
-
// NewEventChargers instantiates the EventChargers in a central place
func NewEventCharges() (ec *EventCharges) {
ec = &EventCharges{
@@ -148,131 +144,6 @@ func (ec *EventCharges) SyncIDs(eCs ...*EventCharges) {
}
}
-// AsExtEventCharges converts EventCharges to ExtEventCharges
-func (ec *EventCharges) AsExtEventCharges() (eEc *ExtEventCharges, err error) {
- eEc = new(ExtEventCharges)
- if ec.Abstracts != nil {
- if flt, ok := ec.Abstracts.Big.Float64(); !ok {
- return nil, errors.New("cannot convert decimal Abstracts to float64")
- } else {
- eEc.Abstracts = &flt
- }
- }
- if ec.Concretes != nil {
- if flt, ok := ec.Concretes.Big.Float64(); !ok {
- return nil, errors.New("cannot convert decimal Concretes to float64")
- } else {
- eEc.Concretes = &flt
- }
- }
- if ec.Charges != nil {
- eEc.Charges = make([]*ChargeEntry, len(ec.Charges))
- for idx, val := range ec.Charges {
- eEc.Charges[idx] = val
- }
- }
- if ec.Accounting != nil {
- eEc.Accounting = make(map[string]*ExtAccountCharge, len(eEc.Accounting))
- for key, val := range ec.Accounting {
- if eEc.Accounting[key], err = val.AsExtAccountCharge(); err != nil {
- return nil, err
- }
- }
- }
- if ec.UnitFactors != nil {
- eEc.UnitFactors = make(map[string]*ExtUnitFactor, len(ec.UnitFactors))
- for key, val := range ec.UnitFactors {
- if eEc.UnitFactors[key], err = val.AsExtUnitFactor(); err != nil {
- return nil, err
- }
- }
- }
- if ec.Rating != nil {
- eEc.Rating = make(map[string]*ExtRateSInterval, len(ec.Rating))
- for key, val := range ec.Rating {
- if eEc.Rating[key], err = val.AsExtRateSInterval(); err != nil {
- return nil, err
- }
- }
- }
- if ec.Rates != nil {
- eEc.Rates = make(map[string]*ExtIntervalRate, len(ec.Rates))
- for key, val := range ec.Rates {
- if eEc.Rates[key], err = val.AsExtIntervalRate(); err != nil {
- return nil, err
- }
- }
- }
- if ec.Accounts != nil {
- eEc.Accounts = make(map[string]*ExtAccount, len(ec.Accounts))
- for acntID, acnt := range ec.Accounts {
- if eEc.Accounts[acntID], err = acnt.AsExtAccount(); err != nil {
- return nil, err
- }
- }
- }
- return
-}
-
-// Equals returns the equality between two ExtEventCharges
-func (eEc *ExtEventCharges) Equals(exCh *ExtEventCharges) (eq bool) {
- if !((eEc.Abstracts == nil && exCh.Abstracts == nil) ||
- (eEc.Abstracts != nil && exCh.Abstracts != nil &&
- *eEc.Abstracts == *exCh.Abstracts)) ||
- !((eEc.Concretes == nil && exCh.Concretes == nil) ||
- (eEc.Concretes != nil && exCh.Concretes != nil &&
- *eEc.Concretes == *exCh.Concretes)) ||
- (eEc.Charges == nil && exCh.Charges != nil ||
- eEc.Charges != nil && exCh.Charges == nil ||
- len(eEc.Charges) != len(exCh.Charges)) ||
- (eEc.Accounting == nil && exCh.Accounting != nil ||
- eEc.Accounting != nil && exCh.Accounting == nil ||
- len(eEc.Accounting) != len(exCh.Accounting)) ||
- (eEc.UnitFactors == nil && exCh.UnitFactors != nil ||
- eEc.UnitFactors != nil && exCh.UnitFactors == nil ||
- len(eEc.UnitFactors) != len(exCh.UnitFactors)) ||
- (eEc.Rating == nil && exCh.Rating != nil ||
- eEc.Rating != nil && exCh.Rating == nil ||
- len(eEc.Rating) != len(exCh.Rating)) ||
- (eEc.Rates == nil && exCh.Rates != nil ||
- eEc.Rates != nil && exCh.Rates == nil ||
- len(eEc.Rates) != len(exCh.Rates)) ||
- (eEc.Accounts == nil && exCh.Accounts != nil ||
- eEc.Accounts != nil && exCh.Accounts == nil ||
- len(eEc.Accounts) != len(exCh.Accounts)) {
- return
- }
- /*
- for idx, val := range exCh.Charges {
- if ok := val.Equals(exCh.Charges[idx], eEc.Accounting, exCh.Accounting); !ok {
- return
- }
- }
- for key, val := range eEc.Accounting {
- if ok := val.Equals(exCh.Accounting[key]); !ok {
- return
- }
- }
-
- */
- for key, val := range eEc.UnitFactors {
- if ok := val.Equals(exCh.UnitFactors[key]); !ok {
- return
- }
- }
- for key, val := range eEc.Rating {
- if ok := val.Equals(exCh.Rating[key], eEc.Rates, exCh.Rates); !ok {
- return
- }
- }
- for key, val := range eEc.Accounts {
- if ok := val.Equals(exCh.Accounts[key]); !ok {
- return
- }
- }
- return true
-}
-
// Equals returns the equality between two EventCharges
func (eC *EventCharges) Equals(evCh *EventCharges) (eq bool) {
if eC == nil && evCh == nil {
@@ -376,26 +247,6 @@ func (ec *EventCharges) accountChargeID(ac *AccountCharge) (acID string) {
return
}
-// ExtEventCharges is a generic EventCharges used in APIs
-type ExtEventCharges struct {
- Abstracts *float64
- Concretes *float64
-
- Charges []*ChargeEntry
-
- Accounting map[string]*ExtAccountCharge
- UnitFactors map[string]*ExtUnitFactor
- Rating map[string]*ExtRateSInterval
- Rates map[string]*ExtIntervalRate
- Accounts map[string]*ExtAccount
-}
-
-type ExtChargingIncrement struct {
- Units *float64
- AccountChargeID string
- CompressFactor int
-}
-
// AccountCharge represents one Account charge
type AccountCharge struct {
AccountID string
@@ -408,85 +259,6 @@ type AccountCharge struct {
JoinedChargeIDs []string // identificator of extra account charges
}
-type ExtAccountCharge struct {
- AccountID string
- BalanceID string
- Units *float64
- BalanceLimit *float64 // the minimum balance value accepted(float64 type)
- UnitFactorID string // identificator in ChargingUnitFactors
- AttributeIDs []string // list of attribute profiles matched
- RatingID string // identificator in cost increments
- JoinedChargeIDs []string // identificator of extra account charges
-}
-
-// AsExtAccountCharge converts AccountCharge to ExtAccountCharge
-func (aC *AccountCharge) AsExtAccountCharge() (eAc *ExtAccountCharge, err error) {
- eAc = &ExtAccountCharge{
- AccountID: aC.AccountID,
- BalanceID: aC.BalanceID,
- UnitFactorID: aC.UnitFactorID,
- RatingID: aC.RatingID,
- }
- if aC.Units != nil {
- if fltUnit, ok := aC.Units.Big.Float64(); !ok {
- return nil, errors.New("cannot convert decimal Units to float64 ")
- } else {
- eAc.Units = &fltUnit
- }
- }
- if aC.BalanceLimit != nil {
- if fltBlUnit, ok := aC.BalanceLimit.Big.Float64(); !ok {
- return nil, errors.New("cannot convert decimal BalanceLimit to float64 ")
- } else {
- eAc.BalanceLimit = &fltBlUnit
- }
- }
- if aC.AttributeIDs != nil {
- eAc.AttributeIDs = make([]string, len(aC.AttributeIDs))
- for idx, val := range aC.AttributeIDs {
- eAc.AttributeIDs[idx] = val
- }
- }
- if aC.JoinedChargeIDs != nil {
- eAc.JoinedChargeIDs = make([]string, len(aC.JoinedChargeIDs))
- for idx, val := range aC.JoinedChargeIDs {
- eAc.JoinedChargeIDs[idx] = val
- }
- }
- return
-}
-
-// Equals compares two ExtAccountCharge
-func (eAc *ExtAccountCharge) Equals(extAc *ExtAccountCharge) (eq bool) {
- if (eAc.AttributeIDs == nil && extAc.AttributeIDs != nil ||
- eAc.AttributeIDs != nil && extAc.AttributeIDs == nil ||
- len(eAc.AttributeIDs) != len(extAc.AttributeIDs)) ||
- (eAc.JoinedChargeIDs == nil && extAc.JoinedChargeIDs != nil ||
- eAc.JoinedChargeIDs != nil && extAc.JoinedChargeIDs == nil ||
- len(eAc.JoinedChargeIDs) != len(extAc.JoinedChargeIDs)) ||
- (eAc.AccountID != extAc.AccountID ||
- eAc.BalanceID != extAc.BalanceID ||
- eAc.UnitFactorID != extAc.UnitFactorID ||
- eAc.RatingID != extAc.RatingID) ||
- !((eAc.Units == nil && extAc.Units == nil) ||
- (eAc.Units != nil && extAc.Units != nil && *eAc.Units == *extAc.Units)) ||
- !((eAc.BalanceLimit == nil && extAc.BalanceLimit == nil) ||
- (eAc.BalanceLimit != nil && extAc.BalanceLimit != nil && *eAc.BalanceLimit == *extAc.BalanceLimit)) {
- return
- }
- for idx, val := range eAc.AttributeIDs {
- if val != extAc.AttributeIDs[idx] {
- return
- }
- }
- for idx, val := range eAc.JoinedChargeIDs {
- if val != extAc.JoinedChargeIDs[idx] {
- return
- }
- }
- return true
-}
-
// Equals compares two AccountCharges
func (ac *AccountCharge) equals(nAc *AccountCharge) (eq bool) {
if ac == nil && nAc == nil {
diff --git a/utils/librates.go b/utils/librates.go
index feb0d9b8c..e8e88df72 100644
--- a/utils/librates.go
+++ b/utils/librates.go
@@ -19,7 +19,6 @@ along with this program. If not, see
package utils
import (
- "errors"
"fmt"
"sort"
"time"
@@ -67,86 +66,6 @@ type Rate struct {
uID string
}
-type ExtRate struct {
- ID string // RateID
- FilterIDs []string // RateFilterIDs
- ActivationTimes string // ActivationTimes is a cron formatted time interval
- Weights DynamicWeights // RateWeight will decide the winner per interval start
- Blocker bool // RateBlocker will make this rate recurrent, deactivating further intervals
- IntervalRates []*ExtIntervalRate
-
- sched cron.Schedule // compiled version of activation times as cron.Schedule interface
- uID string
-}
-
-// Equals returns the equality between two ExtRate
-func (eRt *ExtRate) Equals(extRT *ExtRate) (eq bool) {
- if (eRt.ID != extRT.ID ||
- eRt.ActivationTimes != extRT.ActivationTimes ||
- eRt.Blocker != extRT.Blocker) ||
- (eRt.FilterIDs == nil && extRT.FilterIDs != nil ||
- eRt.FilterIDs != nil && extRT.FilterIDs == nil) ||
- (eRt.Weights == nil && extRT.Weights != nil ||
- eRt.Weights != nil && extRT.Weights == nil ||
- len(eRt.Weights) != len(extRT.Weights)) ||
- (eRt.IntervalRates == nil && extRT.IntervalRates != nil ||
- eRt.IntervalRates != nil && extRT.IntervalRates == nil ||
- len(eRt.IntervalRates) != len(extRT.IntervalRates)) {
- return
- }
- for idx, val := range eRt.FilterIDs {
- if val != extRT.FilterIDs[idx] {
- return
- }
- }
- if eRt.Weights != nil && extRT.Weights != nil {
- for idx, val := range eRt.Weights {
- if ok := val.Equals(extRT.Weights[idx]); !ok {
- return
- }
- }
- }
- if eRt.IntervalRates != nil && extRT.IntervalRates != nil {
- for idx, val := range eRt.IntervalRates {
- if ok := val.Equals(extRT.IntervalRates[idx]); !ok {
- return
- }
- }
- }
- return true
-}
-
-// AsExtRate converts Rate to ExtRate
-func (rT *Rate) AsExtRate() (eRt *ExtRate, err error) {
- eRt = &ExtRate{
- ID: rT.ID,
- ActivationTimes: rT.ActivationTimes,
- sched: rT.sched,
- uID: rT.uID,
- Blocker: rT.Blocker,
- }
- if rT.FilterIDs != nil {
- eRt.FilterIDs = make([]string, len(rT.FilterIDs))
- for idx, val := range rT.FilterIDs {
- eRt.FilterIDs[idx] = val
- }
- }
- if rT.Weights != nil {
- eRt.Weights = rT.Weights
- }
- if rT.IntervalRates != nil {
- eRt.IntervalRates = make([]*ExtIntervalRate, len(rT.IntervalRates))
- for idx, val := range rT.IntervalRates {
- if rcvIntv, err := val.AsExtIntervalRate(); err != nil {
- return nil, err
- } else {
- eRt.IntervalRates[idx] = rcvIntv
- }
- }
- }
- return
-}
-
// UID returns system wide unique identifier
func (rt *Rate) UID() string {
return rt.uID
@@ -160,72 +79,6 @@ type IntervalRate struct {
Increment *Decimal // RateIncrement
}
-type ExtIntervalRate struct {
- IntervalStart *float64 // Starting point when the Rate kicks in
- FixedFee *float64
- RecurrentFee *float64
- Unit *float64 // RateUnit
- Increment *float64 // RateIncrement
-}
-
-// AsExtIntervalRate converts IntervalRate to ExtIntervalRate
-func (iR *IntervalRate) AsExtIntervalRate() (eIr *ExtIntervalRate, err error) {
- eIr = new(ExtIntervalRate)
- if iR.IntervalStart != nil {
- if fltIntSt, ok := iR.IntervalStart.Big.Float64(); !ok {
- return nil, errors.New("cannot convert decimal IntervalStart to float64")
- } else {
- eIr.IntervalStart = &fltIntSt
- }
- }
- if iR.FixedFee != nil {
- if fltFxdFee, ok := iR.FixedFee.Big.Float64(); !ok {
- return nil, errors.New("cannot convert decimal FixedFee to float64")
- } else {
- eIr.FixedFee = &fltFxdFee
- }
- }
- if iR.RecurrentFee != nil {
- if fltRecFee, ok := iR.RecurrentFee.Big.Float64(); !ok {
- return nil, errors.New("cannot convert decimal RecurrentFee to float64")
- } else {
- eIr.RecurrentFee = &fltRecFee
- }
- }
- if iR.Unit != nil {
- if fltUnit, ok := iR.Unit.Big.Float64(); !ok {
- return nil, errors.New("cannot convert decimal Unit to float64")
- } else {
- eIr.Unit = &fltUnit
- }
- }
- if iR.Increment != nil {
- if fltIncr, ok := iR.Increment.Big.Float64(); !ok {
- return nil, errors.New("cannot convert decimal Increment to float64")
- } else {
- eIr.Increment = &fltIncr
- }
- }
- return
-}
-
-// Equals returns the equality between two ExtIntervalRate
-func (eIr *ExtIntervalRate) Equals(extIr *ExtIntervalRate) (eq bool) {
- if !((eIr.IntervalStart == nil && extIr.IntervalStart == nil) ||
- (eIr.IntervalStart != nil && extIr.IntervalStart != nil && *eIr.IntervalStart == *extIr.IntervalStart)) ||
- !((eIr.FixedFee == nil && extIr.FixedFee == nil) ||
- (eIr.FixedFee != nil && extIr.FixedFee != nil && *eIr.FixedFee == *extIr.FixedFee)) ||
- !((eIr.RecurrentFee == nil && extIr.RecurrentFee == nil) ||
- (eIr.RecurrentFee != nil && extIr.RecurrentFee != nil && *eIr.RecurrentFee == *extIr.RecurrentFee)) ||
- !((eIr.Unit == nil && extIr.Unit == nil) ||
- (eIr.Unit != nil && extIr.Unit != nil && *eIr.Unit == *extIr.Unit)) ||
- !((eIr.Increment == nil && extIr.Increment == nil) ||
- (eIr.Increment != nil && extIr.Increment != nil && *eIr.Increment == *extIr.Increment)) {
- return
- }
- return true
-}
-
// Equals returns the equality between two IntervalRate
func (iR *IntervalRate) Equals(inRt *IntervalRate) (eq bool) {
if iR == nil && inRt == nil {
@@ -310,14 +163,6 @@ type RateSInterval struct {
cost *decimal.Big // unexported total interval cost
}
-type ExtRateSInterval struct {
- IntervalStart *float64
- Increments []*ExtRateSIncrement
- CompressFactor int64
-
- cost *float64 // unexported total interval cost
-}
-
// AsRatesIntervalsCost converts RateSInterval to RateSIntervalCost
// The difference between this 2 is that RateSIntervalCost don't need IntervalStart
func (rI *RateSInterval) AsRatesIntervalsCost() (rIc *RateSIntervalCost) {
@@ -333,56 +178,6 @@ func (rI *RateSInterval) AsRatesIntervalsCost() (rIc *RateSIntervalCost) {
return
}
-// AsExtRateSInterval converts RateSInterval to ExtRateSInterval
-func (rI *RateSInterval) AsExtRateSInterval() (eRi *ExtRateSInterval, err error) {
- eRi = &ExtRateSInterval{
- CompressFactor: rI.CompressFactor,
- }
- if rI.Increments != nil {
- eRi.Increments = make([]*ExtRateSIncrement, len(rI.Increments))
- for idx, val := range rI.Increments {
- if rcv, err := val.AsExtRateSIncrement(); err != nil {
- return nil, err
- } else {
- eRi.Increments[idx] = rcv
- }
- }
- }
- if rI.IntervalStart != nil {
- if fltIntStart, ok := rI.IntervalStart.Big.Float64(); !ok {
- return nil, errors.New("Cannot convert decimal IntervalStart into float64 ")
- } else {
- eRi.IntervalStart = &fltIntStart
- }
- }
- if rI.cost != nil {
- if fltCost, ok := rI.cost.Float64(); !ok {
- return nil, errors.New("Cannot convert decimal cost into float64 ")
- } else {
- eRi.cost = &fltCost
- }
- }
- return
-}
-
-// Equals compares two ExtRateSInterval
-func (rIl *ExtRateSInterval) Equals(nRil *ExtRateSInterval, exInRt, exInRtRef map[string]*ExtIntervalRate) (eq bool) {
- if !((rIl.IntervalStart == nil && nRil.IntervalStart == nil) ||
- (rIl.IntervalStart != nil && nRil.IntervalStart != nil && *rIl.IntervalStart == *nRil.IntervalStart)) ||
- (rIl.Increments == nil && nRil.Increments != nil ||
- rIl.Increments != nil && nRil.Increments == nil ||
- len(rIl.Increments) != len(nRil.Increments)) ||
- (rIl.CompressFactor != nRil.CompressFactor) {
- return
- }
- for i, rtIn := range rIl.Increments {
- if !rtIn.Equals(nRil.Increments[i], exInRt, exInRtRef) {
- return
- }
- }
- return true
-}
-
type RateSIncrement struct {
IncrementStart *Decimal
RateIntervalIndex int
@@ -393,58 +188,6 @@ type RateSIncrement struct {
cost *decimal.Big // unexported total increment cost
}
-type ExtRateSIncrement struct {
- IncrementStart *float64
- IntervalRateIndex int
- RateID string
- CompressFactor int64
- Usage *float64
-
- cost *float64 // unexported total increment cost
-}
-
-//AsExtRateSIncrement converts RateSIncrement to ExtRateSIncrement
-func (rI *RateSIncrement) AsExtRateSIncrement() (eRi *ExtRateSIncrement, err error) {
- eRi = &ExtRateSIncrement{
- IntervalRateIndex: rI.RateIntervalIndex,
- CompressFactor: rI.CompressFactor,
- RateID: rI.RateID,
- }
- if rI.IncrementStart != nil {
- if fltIncrStart, ok := rI.IncrementStart.Big.Float64(); !ok {
- return nil, errors.New("Cannot convert decimal IncrementStart into float64 ")
- } else {
- eRi.IncrementStart = &fltIncrStart
- }
- }
- if rI.Usage != nil {
- if fltUsage, ok := rI.Usage.Big.Float64(); !ok {
- return nil, errors.New("Cannot convert decimal Usage into float64 ")
- } else {
- eRi.Usage = &fltUsage
- }
- }
- if rI.cost != nil {
- if fltCost, ok := rI.cost.Float64(); !ok {
- return nil, errors.New("Cannot convert decimal cost into float64 ")
- } else {
- eRi.cost = &fltCost
- }
- }
- return
-}
-
-// Equals returns the equality between twoExt RateSIncrement
-func (eRI *ExtRateSIncrement) Equals(extRI *ExtRateSIncrement, exInRt, exInRtRef map[string]*ExtIntervalRate) (eq bool) {
- return ((eRI.Usage == nil && extRI.Usage == nil) ||
- (eRI.Usage != nil && extRI.Usage != nil && *eRI.Usage == *extRI.Usage)) &&
- ((eRI.IncrementStart == nil && extRI.IncrementStart == nil) ||
- (eRI.IncrementStart != nil && extRI.IncrementStart != nil && *eRI.IncrementStart == *extRI.IncrementStart)) &&
- (eRI.CompressFactor == extRI.CompressFactor) &&
- (eRI.IntervalRateIndex == extRI.IntervalRateIndex) &&
- exInRt[eRI.RateID].Equals(exInRtRef[extRI.RateID])
-}
-
// Equals compares two RateSIntervals
func (rIl *RateSInterval) Equals(nRil *RateSInterval, rIlRef, nRilRef map[string]*IntervalRate) (eq bool) {
if rIl == nil && nRil == nil {
@@ -559,7 +302,7 @@ func (rIncrC *RateSIncrementCost) Equals(nRi *RateSIncrementCost, rIRef, rtInRef
!rIRef[rIncrC.RateID].Equals(rtInRef[nRi.RateID])))
}
-/*rIncrC
+/*
func (rpC *RateProfileCost) SynchronizeRateKeys(nRpCt *RateProfileCost) {
rts := make(map[string]*IntervalRate)
reverse := make(map[string]string)