From b6b39b0e7dd8e6b273656f9bd7a6cb9c1fb9e748 Mon Sep 17 00:00:00 2001 From: porosnicuadrian Date: Tue, 12 Oct 2021 16:49:58 +0300 Subject: [PATCH] Removed external structs for event charges --- dispatchers/accounts.go | 8 +- utils/account.go | 344 ---------------------------------------- utils/eventcharges.go | 228 -------------------------- utils/librates.go | 259 +----------------------------- 4 files changed, 5 insertions(+), 834 deletions(-) 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)