From a08b190a4e6ba853aee44e5249e471c50eb9b7f3 Mon Sep 17 00:00:00 2001 From: Trial97 Date: Wed, 7 Aug 2019 21:15:10 +0300 Subject: [PATCH] Replaced IsSliceMember with SliceHasMember for constant slices --- agents/asterisk_event.go | 7 ++-- agents/fsevent.go | 4 +-- agents/fsevent_test.go | 2 +- agents/kamevent.go | 6 ++-- apier/v1/cdre.go | 4 +-- apier/v2/cdre.go | 2 +- cdrc/cdrc.go | 5 ++- cdrc/csv.go | 4 +-- config/config.go | 14 ++++---- engine/account.go | 2 +- engine/action.go | 3 +- engine/cdre.go | 6 ++-- engine/cdrs.go | 12 ++++--- engine/cgrcdr.go | 2 +- engine/eventcost.go | 2 +- engine/filterindexer.go | 4 +-- engine/filters.go | 34 ++++++++++-------- engine/libengine.go | 2 +- engine/libtest.go | 2 +- engine/mapevent.go | 14 ++++---- engine/mapevent_test.go | 45 +++-------------------- engine/pstr_http.go | 6 ++-- engine/safevent.go | 13 ++----- engine/safevent_test.go | 41 ++------------------- engine/storage_mongo_datadb.go | 4 +-- engine/storage_redis.go | 4 +-- engine/tpexporter.go | 8 ++--- migrator/filters.go | 13 +++---- sessions/session.go | 66 +++++++++++++++++----------------- sessions/sessions.go | 4 +-- utils/consts.go | 23 ++++-------- utils/set.go | 48 +++++++++++++++++++++++++ 32 files changed, 183 insertions(+), 223 deletions(-) create mode 100644 utils/set.go diff --git a/agents/asterisk_event.go b/agents/asterisk_event.go index 1e574becc..10f79e101 100644 --- a/agents/asterisk_event.go +++ b/agents/asterisk_event.go @@ -173,12 +173,13 @@ func (smaEv *SMAsteriskEvent) DisconnectCause() string { return cachedVal } +var primaryFields = utils.NewStringSet([]string{eventType, channelID, timestamp, utils.SetupTime, utils.CGR_ACCOUNT, utils.CGR_DESTINATION, utils.CGR_REQTYPE, + utils.CGR_TENANT, utils.CGR_CATEGORY, utils.CGR_SUBJECT, utils.CGR_PDD, utils.CGR_SUPPLIER, utils.CGR_DISCONNECT_CAUSE}) + func (smaEv *SMAsteriskEvent) ExtraParameters() (extraParams map[string]string) { extraParams = make(map[string]string) - primaryFields := []string{eventType, channelID, timestamp, utils.SetupTime, utils.CGR_ACCOUNT, utils.CGR_DESTINATION, utils.CGR_REQTYPE, - utils.CGR_TENANT, utils.CGR_CATEGORY, utils.CGR_SUBJECT, utils.CGR_PDD, utils.CGR_SUPPLIER, utils.CGR_DISCONNECT_CAUSE} for cachedKey, cachedVal := range smaEv.cachedFields { - if !utils.IsSliceMember(primaryFields, cachedKey) { + if !primaryFields.Has(cachedKey) { extraParams[cachedKey] = cachedVal } } diff --git a/agents/fsevent.go b/agents/fsevent.go index 9d996521c..0bea355f7 100644 --- a/agents/fsevent.go +++ b/agents/fsevent.go @@ -241,7 +241,7 @@ func (fsev FSEvent) GetDuration(fieldName string) (time.Duration, error) { func (fsev FSEvent) GetPdd(fieldName string) (time.Duration, error) { var PDDStr string - if utils.IsSliceMember([]string{utils.PDD, utils.META_DEFAULT}, fieldName) { + if utils.SliceHasMember([]string{utils.META_DEFAULT, utils.PDD}, fieldName) { PDDStr = utils.FirstNonEmpty(fsev[PDD_MEDIA_MS], fsev[PDD_NOMEDIA_MS]) if len(PDDStr) != 0 { PDDStr = PDDStr + "ms" // PDD is in milliseconds and CGR expects it in seconds @@ -256,7 +256,7 @@ func (fsev FSEvent) GetPdd(fieldName string) (time.Duration, error) { func (fsev FSEvent) GetADC(fieldName string) (time.Duration, error) { var ACDStr string - if utils.IsSliceMember([]string{utils.ACD, utils.META_DEFAULT}, fieldName) { + if utils.SliceHasMember([]string{utils.META_DEFAULT, utils.ACD}, fieldName) { ACDStr = utils.FirstNonEmpty(fsev[VarCGRACD]) if len(ACDStr) != 0 { ACDStr = ACDStr + "s" // ACD is in seconds and CGR expects it in seconds diff --git a/agents/fsevent_test.go b/agents/fsevent_test.go index ed999f274..1e3c9ef2c 100644 --- a/agents/fsevent_test.go +++ b/agents/fsevent_test.go @@ -976,7 +976,7 @@ variable_rtp_audio_rtcp_octet_count: 0` sessions.GetSetCGRID(smGev) smCDR, err := smGev.AsCDR(fsCdrCfg, utils.EmptyString, timezone) if err != nil { - t.Error(err) + t.Fatal(err) } fsCDR := fsCdr.AsCDR(timezone) if fsCDR.CGRID != smCDR.CGRID { diff --git a/agents/kamevent.go b/agents/kamevent.go index 8749b3072..e663b69c7 100644 --- a/agents/kamevent.go +++ b/agents/kamevent.go @@ -47,8 +47,8 @@ const ( ) var ( - kamReservedEventFields = []string{EVENT, KamTRIndex, KamTRLabel, utils.CGRFlags, KamReplyRoute} - kamReservedCDRFields = append(kamReservedEventFields, KamHashEntry, KamHashID) // HashEntry and id are needed in events for disconnects + kamReservedEventFields = utils.NewStringSet([]string{EVENT, KamTRIndex, KamTRLabel, utils.CGRFlags, KamReplyRoute}) + // kamReservedCDRFields = append(kamReservedEventFields, KamHashEntry, KamHashID) // HashEntry and id are needed in events for disconnects ) func NewKamSessionDisconnect(hEntry, hID, reason string) *KamSessionDisconnect { @@ -140,7 +140,7 @@ func (kev KamEvent) AsMapStringInterface() (mp map[string]interface{}) { if k == utils.Usage { v += "s" // mark the Usage as seconds } - if !utils.IsSliceMember(kamReservedEventFields, k) { // reserved attributes not getting into event + if !kamReservedEventFields.Has(k) { // reserved attributes not getting into event mp[k] = v } } diff --git a/apier/v1/cdre.go b/apier/v1/cdre.go index 9d2f9851c..5fc2f3f45 100644 --- a/apier/v1/cdre.go +++ b/apier/v1/cdre.go @@ -107,7 +107,7 @@ func (self *ApierV1) ExportCdrsToFile(attr utils.AttrExpFileCdrs, reply *utils.E if attr.CdrFormat != nil && len(*attr.CdrFormat) != 0 { exportFormat = strings.ToLower(*attr.CdrFormat) } - if !utils.IsSliceMember(utils.CDRExportFormats, exportFormat) { + if !utils.CDRExportFormats.Has(exportFormat) { return fmt.Errorf("%s:%s", utils.ErrMandatoryIeMissing.Error(), "CdrFormat") } fieldSep := exportTemplate.FieldSeparator @@ -225,7 +225,7 @@ func (self *ApierV1) ExportCDRs(arg ArgExportCDRs, reply *RplExportedCDRs) (err if arg.ExportFormat != nil && len(*arg.ExportFormat) != 0 { exportFormat = strings.ToLower(*arg.ExportFormat) } - if !utils.IsSliceMember(utils.CDRExportFormats, exportFormat) { + if !utils.CDRExportFormats.Has(exportFormat) { return utils.NewErrMandatoryIeMissing("CdrFormat") } synchronous := exportTemplate.Synchronous diff --git a/apier/v2/cdre.go b/apier/v2/cdre.go index b4e990146..cc695e4df 100644 --- a/apier/v2/cdre.go +++ b/apier/v2/cdre.go @@ -65,7 +65,7 @@ func (self *ApierV2) ExportCdrsToFile(attr AttrExportCdrsToFile, reply *Exported if attr.CdrFormat != nil && len(*attr.CdrFormat) != 0 { exportFormat = strings.ToLower(*attr.CdrFormat) } - if !utils.IsSliceMember(utils.CDRExportFormats, exportFormat) { + if !utils.CDRExportFormats.Has(exportFormat) { return utils.NewErrMandatoryIeMissing("CdrFormat") } fieldSep := exportTemplate.FieldSeparator diff --git a/cdrc/cdrc.go b/cdrc/cdrc.go index b42731f87..4edf99354 100644 --- a/cdrc/cdrc.go +++ b/cdrc/cdrc.go @@ -65,14 +65,13 @@ func NewCdrc(cdrcCfgs []*config.CdrcCfg, httpSkipTlsCheck bool, cdrs rpcclient.R maxOpenFiles: make(chan struct{}, cdrcCfg.MaxOpenFiles), } // Before processing, make sure in and out folders exist - if utils.IsSliceMember(utils.CDRCFileFormats, cdrcCfg.CdrFormat) { + if utils.CDRCFileFormats.Has(cdrcCfg.CdrFormat) { for _, dir := range []string{cdrcCfg.CDRInPath, cdrcCfg.CDROutPath} { if _, err := os.Stat(dir); err != nil && os.IsNotExist(err) { return nil, fmt.Errorf(" nonexistent folder: %s", dir) } } - } - if utils.IsSliceMember(utils.CDRCFileFormats, cdrcCfg.CdrFormat) { + var processFile struct{} for i := 0; i < cdrcCfg.MaxOpenFiles; i++ { cdrc.maxOpenFiles <- processFile // Empty initiate so we do not need to wait later when we pop diff --git a/cdrc/csv.go b/cdrc/csv.go index bc030f742..b9259ae42 100644 --- a/cdrc/csv.go +++ b/cdrc/csv.go @@ -71,7 +71,7 @@ func (self *CsvRecordsProcessor) ProcessNextRecord() ([]*engine.CDR, error) { return nil, err } self.processedRecordsNr += 1 - if utils.IsSliceMember([]string{utils.MetaKamFlatstore, utils.MetaOsipsFlatstore}, self.dfltCdrcCfg.CdrFormat) { + if utils.SliceHasMember([]string{utils.MetaKamFlatstore, utils.MetaOsipsFlatstore}, self.dfltCdrcCfg.CdrFormat) { if record, err = self.processFlatstoreRecord(record); err != nil { return nil, err } else if record == nil { @@ -159,7 +159,7 @@ func (self *CsvRecordsProcessor) recordToStoredCdr(record []string, cdrcCfg *con continue } } - if utils.IsSliceMember([]string{utils.MetaKamFlatstore, utils.MetaOsipsFlatstore}, self.dfltCdrcCfg.CdrFormat) { // Hardcode some values in case of flatstore + if utils.SliceHasMember([]string{utils.MetaKamFlatstore, utils.MetaOsipsFlatstore}, self.dfltCdrcCfg.CdrFormat) { // Hardcode some values in case of flatstore switch cdrFldCfg.FieldId { case utils.OriginID: cdrFldCfg.Value = config.NewRSRParsersMustCompile("~3;~1;~2", true, utils.INFIELD_SEP) // in case of flatstore, accounting id is made up out of callid, from_tag and to_tag diff --git a/config/config.go b/config/config.go index 73fde9845..d3108eef1 100755 --- a/config/config.go +++ b/config/config.go @@ -353,6 +353,11 @@ type CGRConfig struct { apier *ApierCfg } +var posibleLoaderTypes = utils.NewStringSet([]string{utils.MetaAttributes, + utils.MetaResources, utils.MetaFilters, utils.MetaStats, + utils.MetaSuppliers, utils.MetaThresholds, utils.MetaChargers, + utils.MetaDispatchers, utils.MetaDispatcherHosts}) + func (self *CGRConfig) checkConfigSanity() error { // Rater checks if self.ralsCfg.RALsEnabled && !self.dispatcherSCfg.Enabled { @@ -457,10 +462,7 @@ func (self *CGRConfig) checkConfigSanity() error { } } for _, data := range ldrSCfg.Data { - if !utils.IsSliceMember([]string{utils.MetaAttributes, - utils.MetaResources, utils.MetaFilters, utils.MetaStats, - utils.MetaSuppliers, utils.MetaThresholds, utils.MetaChargers, - utils.MetaDispatchers, utils.MetaDispatcherHosts}, data.Type) { + if !posibleLoaderTypes.Has(data.Type) { return fmt.Errorf("<%s> unsupported data type %s", utils.LoaderS, data.Type) } @@ -636,11 +638,11 @@ func (self *CGRConfig) checkConfigSanity() error { } } } - if !utils.IsSliceMember([]string{utils.MetaUrl, utils.MetaXml}, httpAgentCfg.RequestPayload) { + if !utils.SliceHasMember([]string{utils.MetaUrl, utils.MetaXml}, httpAgentCfg.RequestPayload) { return fmt.Errorf("<%s> unsupported request payload %s", utils.HTTPAgent, httpAgentCfg.RequestPayload) } - if !utils.IsSliceMember([]string{utils.MetaXml, utils.MetaTextPlain}, httpAgentCfg.ReplyPayload) { + if !utils.SliceHasMember([]string{utils.MetaTextPlain, utils.MetaXml}, httpAgentCfg.ReplyPayload) { return fmt.Errorf("<%s> unsupported reply payload %s", utils.HTTPAgent, httpAgentCfg.ReplyPayload) } diff --git a/engine/account.go b/engine/account.go index f577e1ce5..1d0740dd4 100644 --- a/engine/account.go +++ b/engine/account.go @@ -1136,7 +1136,7 @@ func (acnt *Account) AsNavigableMap(_ []*config.FCTemplate) (*config.NavigableMa } func NewAccountSummaryFromJSON(jsn string) (acntSummary *AccountSummary, err error) { - if !utils.IsSliceMember([]string{"", "null"}, jsn) { // Unmarshal only when content + if !utils.SliceHasMember([]string{"", "null"}, jsn) { // Unmarshal only when content json.Unmarshal([]byte(jsn), &acntSummary) } return diff --git a/engine/action.go b/engine/action.go index 569416e7d..7bbcbd63a 100644 --- a/engine/action.go +++ b/engine/action.go @@ -156,8 +156,7 @@ func cdrLogAction(acc *Account, a *Action, acs Actions, extraData interface{}) ( // set stored cdr values var cdrs []*CDR for _, action := range acs { - if !utils.IsSliceMember([]string{utils.DEBIT, utils.DEBIT_RESET, - utils.TOPUP, utils.TOPUP_RESET, utils.SET_BALANCE}, action.ActionType) || + if !utils.SliceHasMember([]string{utils.DEBIT, utils.DEBIT_RESET, utils.SET_BALANCE, utils.TOPUP, utils.TOPUP_RESET}, action.ActionType) || action.Balance == nil { continue // Only log specific actions } diff --git a/engine/cdre.go b/engine/cdre.go index 11c782fa7..2a6ce38e3 100644 --- a/engine/cdre.go +++ b/engine/cdre.go @@ -394,7 +394,7 @@ func (cdre *CDRExporter) processCDRs() (err error) { } } if cdre.synchronous || - utils.IsSliceMember([]string{utils.MetaFileCSV, utils.MetaFileFWV}, cdre.exportFormat) { + utils.SliceHasMember([]string{utils.MetaFileCSV, utils.MetaFileFWV}, cdre.exportFormat) { wg.Add(1) // wait for synchronous or file ones since these need to be done before continuing } go func(cdre *CDRExporter, cdr *CDR) { @@ -408,7 +408,7 @@ func (cdre *CDRExporter) processCDRs() (err error) { cdre.Unlock() } if cdre.synchronous || - utils.IsSliceMember([]string{utils.MetaFileCSV, utils.MetaFileFWV}, cdre.exportFormat) { + utils.SliceHasMember([]string{utils.MetaFileCSV, utils.MetaFileFWV}, cdre.exportFormat) { wg.Done() } }(cdre, cdr) @@ -484,7 +484,7 @@ func (cdre *CDRExporter) ExportCDRs() (err error) { if err = cdre.processCDRs(); err != nil { return } - if utils.IsSliceMember([]string{utils.MetaFileCSV, utils.MetaFileFWV}, cdre.exportFormat) { // files are written after processing all CDRs + if utils.SliceHasMember([]string{utils.MetaFileCSV, utils.MetaFileFWV}, cdre.exportFormat) { // files are written after processing all CDRs cdre.RLock() contLen := len(cdre.content) cdre.RUnlock() diff --git a/engine/cdrs.go b/engine/cdrs.go index 85b59e61c..89f208ea0 100644 --- a/engine/cdrs.go +++ b/engine/cdrs.go @@ -149,7 +149,7 @@ func (cdrS *CDRServer) rateCDR(cdr *CDRWithArgDispatcher) ([]*CDR, error) { cdr.ExtraInfo = "" // Clean previous ExtraInfo, useful when re-rating var cdrsRated []*CDR _, hasLastUsed := cdr.ExtraFields[utils.LastUsed] - if utils.IsSliceMember([]string{utils.META_PREPAID, utils.PREPAID}, cdr.RequestType) && + if utils.SliceHasMember([]string{utils.META_PREPAID, utils.PREPAID}, cdr.RequestType) && (cdr.Usage != 0 || hasLastUsed) { // ToDo: Get rid of PREPAID as soon as we don't want to support it backwards // Should be previously calculated and stored in DB fib := utils.Fib() @@ -200,6 +200,9 @@ func (cdrS *CDRServer) rateCDR(cdr *CDRWithArgDispatcher) ([]*CDR, error) { return []*CDR{cdr.CDR}, nil } +var reqTypes = utils.NewStringSet([]string{utils.META_PSEUDOPREPAID, utils.META_POSTPAID, utils.META_PREPAID, + utils.PSEUDOPREPAID, utils.POSTPAID, utils.PREPAID}) + // getCostFromRater will retrieve the cost from RALs func (cdrS *CDRServer) getCostFromRater(cdr *CDRWithArgDispatcher) (*CallCost, error) { cc := new(CallCost) @@ -220,8 +223,7 @@ func (cdrS *CDRServer) getCostFromRater(cdr *CDRWithArgDispatcher) (*CallCost, e DurationIndex: cdr.Usage, PerformRounding: true, } - if utils.IsSliceMember([]string{utils.META_PSEUDOPREPAID, utils.META_POSTPAID, utils.META_PREPAID, - utils.PSEUDOPREPAID, utils.POSTPAID, utils.PREPAID}, cdr.RequestType) { // Prepaid - Cost can be recalculated in case of missing records from SM + if reqTypes.Has(cdr.RequestType) { // Prepaid - Cost can be recalculated in case of missing records from SM err = cdrS.rals.Call(utils.ResponderDebit, &CallDescriptorWithArgDispatcher{CallDescriptor: cd, ArgDispatcher: cdr.ArgDispatcher}, cc) @@ -468,7 +470,7 @@ func (cdrS *CDRServer) V1ProcessCDR(cdr *CDRWithArgDispatcher, reply *string) (e if !cdr.PreRated { // Enforce the RunID if CDR is not rated cdr.RunID = utils.MetaRaw } - if utils.IsSliceMember([]string{"", utils.MetaRaw}, cdr.RunID) { + if utils.SliceHasMember([]string{"", utils.MetaRaw}, cdr.RunID) { cdr.Cost = -1.0 } cgrEv := &utils.CGREventWithArgDispatcher{ @@ -505,7 +507,7 @@ func (cdrS *CDRServer) V1ProcessCDR(cdr *CDRWithArgDispatcher, reply *string) (e go cdrS.statSProcessEvent(cgrEv) } if cdrS.chargerS != nil && - utils.IsSliceMember([]string{"", utils.MetaRaw}, cdr.RunID) { + utils.SliceHasMember([]string{"", utils.MetaRaw}, cdr.RunID) { go cdrS.chrgProcessEvent(cgrEv, cdrS.attrS != nil, cdrS.cgrCfg.CdrsCfg().CDRSStoreCdrs, false, len(cdrS.cgrCfg.CdrsCfg().CDRSOnlineCDRExports) != 0, cdrS.thdS != nil, cdrS.statS != nil) } diff --git a/engine/cgrcdr.go b/engine/cgrcdr.go index 6b6ec90e7..84d89943f 100644 --- a/engine/cgrcdr.go +++ b/engine/cgrcdr.go @@ -51,7 +51,7 @@ func (cgrCdr CgrCdr) getCGRID(timezone string) string { func (cgrCdr CgrCdr) getExtraFields() map[string]string { extraFields := make(map[string]string) for k, v := range cgrCdr { - if _, has := utils.MainCDRFieldsMap[k]; !has { + if !utils.MainCDRFields.Has(k) { extraFields[k] = v } } diff --git a/engine/eventcost.go b/engine/eventcost.go index ff5e8ffa0..a702f0dc5 100644 --- a/engine/eventcost.go +++ b/engine/eventcost.go @@ -297,7 +297,7 @@ func (ec *EventCost) AsCallCost() *CallCost { } } } - if utils.IsSliceMember([]string{utils.VOICE, utils.DATA}, balanceType) && cBC.ExtraChargeID == "" { + if utils.SliceHasMember([]string{utils.DATA, utils.VOICE}, balanceType) && cBC.ExtraChargeID == "" { cBC.ExtraChargeID = utils.META_NONE // mark the balance to be exported as Unit type } if cBC.ExtraChargeID != "" { // have both monetary and data diff --git a/engine/filterindexer.go b/engine/filterindexer.go index f6473a66f..7330304ea 100644 --- a/engine/filterindexer.go +++ b/engine/filterindexer.go @@ -249,7 +249,7 @@ func (rfi *FilterIndexer) RemoveItemFromIndex(tenant, itemID string, oldFilters for _, flt := range fltr.Rules { var fldType, fldName string var fldVals []string - if utils.IsSliceMember([]string{utils.MetaString, utils.MetaPrefix, utils.META_NONE}, flt.Type) { + if utils.SliceHasMember([]string{utils.META_NONE, utils.MetaPrefix, utils.MetaString}, flt.Type) { fldType, fldName = flt.Type, flt.FieldName fldVals = flt.Values } @@ -310,7 +310,7 @@ func createAndIndex(itemPrefix, tenant, context, itemID string, filterIDs []stri for _, flt := range fltr.Rules { var fldType, fldName string var fldVals []string - if utils.IsSliceMember([]string{utils.MetaString, utils.MetaPrefix, utils.META_NONE}, flt.Type) { + if utils.SliceHasMember([]string{utils.META_NONE, utils.MetaPrefix, utils.MetaString}, flt.Type) { fldType, fldName = flt.Type, flt.FieldName fldVals = flt.Values } diff --git a/engine/filters.go b/engine/filters.go index e4083e10c..0b06e5c90 100644 --- a/engine/filters.go +++ b/engine/filters.go @@ -187,6 +187,20 @@ func (f *Filter) Compile() (err error) { return } +var supportedFiltersType *utils.StringSet = utils.NewStringSet([]string{utils.MetaString, utils.MetaPrefix, utils.MetaSuffix, + utils.MetaTimings, utils.MetaRSR, utils.MetaStatS, utils.MetaDestinations, + utils.MetaEmpty, utils.MetaExists, utils.MetaLessThan, utils.MetaLessOrEqual, + utils.MetaGreaterThan, utils.MetaGreaterOrEqual, utils.MetaResources, utils.MetaEqual, + utils.MetaAccount, utils.MetaNotEqual}) +var needsFieldName *utils.StringSet = utils.NewStringSet([]string{utils.MetaString, utils.MetaPrefix, + utils.MetaSuffix, utils.MetaTimings, utils.MetaDestinations, utils.MetaLessThan, + utils.MetaEmpty, utils.MetaExists, utils.MetaLessOrEqual, utils.MetaGreaterThan, + utils.MetaGreaterOrEqual, utils.MetaEqual, utils.MetaNotEqual}) +var needsValues *utils.StringSet = utils.NewStringSet([]string{utils.MetaString, utils.MetaPrefix, + utils.MetaSuffix, utils.MetaTimings, utils.MetaRSR, utils.MetaDestinations, + utils.MetaLessThan, utils.MetaLessOrEqual, utils.MetaGreaterThan, utils.MetaGreaterOrEqual, + utils.MetaEqual, utils.MetaNotEqual}) + func NewFilterRule(rfType, fieldName string, vals []string) (*FilterRule, error) { var negative bool rType := rfType @@ -194,23 +208,13 @@ func NewFilterRule(rfType, fieldName string, vals []string) (*FilterRule, error) rType = "*" + strings.TrimPrefix(rfType, utils.MetaNot) negative = true } - if !utils.IsSliceMember([]string{utils.MetaString, utils.MetaPrefix, utils.MetaSuffix, - utils.MetaTimings, utils.MetaRSR, utils.MetaStatS, utils.MetaDestinations, - utils.MetaEmpty, utils.MetaExists, utils.MetaLessThan, utils.MetaLessOrEqual, - utils.MetaGreaterThan, utils.MetaGreaterOrEqual, utils.MetaResources, utils.MetaEqual, - utils.MetaAccount, utils.MetaNotEqual}, rType) { + if !supportedFiltersType.Has(rType) { return nil, fmt.Errorf("Unsupported filter Type: %s", rfType) } - if fieldName == "" && utils.IsSliceMember([]string{utils.MetaString, utils.MetaPrefix, - utils.MetaSuffix, utils.MetaTimings, utils.MetaDestinations, utils.MetaLessThan, - utils.MetaEmpty, utils.MetaExists, utils.MetaLessOrEqual, utils.MetaGreaterThan, - utils.MetaGreaterOrEqual, utils.MetaEqual, utils.MetaNotEqual}, rType) { + if fieldName == "" && needsFieldName.Has(rType) { return nil, fmt.Errorf("FieldName is mandatory for Type: %s", rfType) } - if len(vals) == 0 && utils.IsSliceMember([]string{utils.MetaString, utils.MetaPrefix, - utils.MetaSuffix, utils.MetaTimings, utils.MetaRSR, utils.MetaDestinations, - utils.MetaLessThan, utils.MetaLessOrEqual, utils.MetaGreaterThan, utils.MetaGreaterOrEqual, - utils.MetaEqual, utils.MetaNotEqual}, rType) { + if len(vals) == 0 && needsValues.Has(rType) { return nil, fmt.Errorf("Values is mandatory for Type: %s", rfType) } rf := &FilterRule{ @@ -559,9 +563,9 @@ func (fltr *FilterRule) passGreaterThan(dP config.DataProvider) (bool, error) { } if gte, err := utils.GreaterThan(fldIf, sval, orEqual); err != nil { return false, err - } else if utils.IsSliceMember([]string{utils.MetaGreaterThan, utils.MetaGreaterOrEqual}, fltr.Type) && gte { + } else if utils.SliceHasMember([]string{utils.MetaGreaterThan, utils.MetaGreaterOrEqual}, fltr.Type) && gte { return true, nil - } else if utils.IsSliceMember([]string{utils.MetaLessThan, utils.MetaLessOrEqual}, fltr.Type) && !gte { + } else if utils.SliceHasMember([]string{utils.MetaLessThan, utils.MetaLessOrEqual}, fltr.Type) && !gte { return true, nil } } diff --git a/engine/libengine.go b/engine/libengine.go index 8c0bb85d2..600e01cc3 100644 --- a/engine/libengine.go +++ b/engine/libengine.go @@ -39,7 +39,7 @@ func NewRPCPool(dispatchStrategy string, keyPath, certPath, caPath string, connA if rpcConnCfg.Address == utils.MetaInternal { rpcClient, err = rpcclient.NewRpcClient("", "", rpcConnCfg.TLS, keyPath, certPath, caPath, connAttempts, reconnects, connectTimeout, replyTimeout, rpcclient.INTERNAL_RPC, internalConnChan, lazyConnect) - } else if utils.IsSliceMember([]string{utils.MetaJSONrpc, utils.MetaGOBrpc, ""}, rpcConnCfg.Transport) { + } else if utils.SliceHasMember([]string{utils.EmptyString, utils.MetaGOBrpc, utils.MetaJSONrpc}, rpcConnCfg.Transport) { codec := utils.GOB if rpcConnCfg.Transport != "" { codec = rpcConnCfg.Transport[1:] // Transport contains always * before codec understood by rpcclient diff --git a/engine/libtest.go b/engine/libtest.go index 5160b173e..3feb3e20c 100644 --- a/engine/libtest.go +++ b/engine/libtest.go @@ -317,7 +317,7 @@ func InitStorDb(cfg *config.CGRConfig) error { cfg.StorDbCfg().StorDBType)); err != nil { return err } - if utils.IsSliceMember([]string{utils.MYSQL, utils.POSTGRES, utils.MONGO}, + if utils.IsSliceMember([]string{utils.MONGO, utils.MYSQL, utils.POSTGRES}, cfg.StorDbCfg().StorDBType) { if err := SetDBVersions(storDb); err != nil { return err diff --git a/engine/mapevent.go b/engine/mapevent.go index 424fcb60d..09990a306 100644 --- a/engine/mapevent.go +++ b/engine/mapevent.go @@ -154,10 +154,13 @@ func (me MapEvent) Clone() (mp MapEvent) { // AsMapString returns a map[string]string out of mp, ignoring specific fields if needed // most used when needing to export extraFields -func (me MapEvent) AsMapString(ignoredFlds utils.StringMap) (mp map[string]string, err error) { +func (me MapEvent) AsMapString(ignoredFlds *utils.StringSet) (mp map[string]string) { mp = make(map[string]string) + if ignoredFlds == nil { + ignoredFlds = utils.NewStringSet(nil) + } for k, v := range me { - if ignoredFlds.HasKey(k) { + if ignoredFlds.Has(k) { continue } mp[k] = utils.IfaceAsString(v) @@ -165,16 +168,11 @@ func (me MapEvent) AsMapString(ignoredFlds utils.StringMap) (mp map[string]strin return } -func (me MapEvent) AsMapStringIgnoreErrors(ignoredFlds utils.StringMap) (mp map[string]string) { - mp, _ = me.AsMapString(ignoredFlds) - return -} - // AsCDR exports the SafEvent as CDR func (me MapEvent) AsCDR(cfg *config.CGRConfig, tnt, tmz string) (cdr *CDR, err error) { cdr = &CDR{Tenant: tnt, Cost: -1.0, ExtraFields: make(map[string]string)} for k, v := range me { - if _, has := utils.MainCDRFieldsMap[k]; !has { // not primary field, populate extra ones + if !utils.MainCDRFields.Has(k) { // not primary field, populate extra ones cdr.ExtraFields[k] = utils.IfaceAsString(v) continue } diff --git a/engine/mapevent_test.go b/engine/mapevent_test.go index 557a88144..3ff6f8fac 100644 --- a/engine/mapevent_test.go +++ b/engine/mapevent_test.go @@ -259,54 +259,17 @@ func TestMapEventAsMapString(t *testing.T) { "test4": "true", "test5": "test", } - mpIgnore := utils.StringMap{ - "test6": true, - "test7": false, - "test8": true, - "test9": false, - } - if rply, err := mapEv.AsMapString(mpIgnore); err != nil { - t.Error(err) - } else if !reflect.DeepEqual(expected, rply) { - t.Errorf("Expecting %+v, received: %+v", expected, rply) - } - var mp MapEvent - mp = nil - if rply, err := mp.AsMapString(nil); err != nil { - t.Error(err) - } else if !reflect.DeepEqual(map[string]string{}, rply) { - t.Errorf("Expecting %+v, received: %+v", map[string]string{}, rply) - } - if rply, err := mp.AsMapString(mpIgnore); err != nil { - t.Error(err) - } else if !reflect.DeepEqual(map[string]string{}, rply) { - t.Errorf("Expecting %+v, received: %+v", map[string]string{}, rply) - } -} + mpIgnore := utils.NewStringSet([]string{"test6", "test7", "test8", "test9"}) -func TestMapEventAsMapStringIgnoreErrors(t *testing.T) { - expected := map[string]string{ - "test1": utils.EmptyString, - "test2": "42", - "test3": "42.3", - "test4": "true", - "test5": "test", - } - mpIgnore := utils.StringMap{ - "test6": true, - "test7": true, - "test8": true, - "test9": true, - } - if rply := mapEv.AsMapStringIgnoreErrors(mpIgnore); !reflect.DeepEqual(expected, rply) { + if rply := mapEv.AsMapString(mpIgnore); !reflect.DeepEqual(expected, rply) { t.Errorf("Expecting %+v, received: %+v", expected, rply) } var mp MapEvent mp = nil - if rply := mp.AsMapStringIgnoreErrors(nil); !reflect.DeepEqual(map[string]string{}, rply) { + if rply := mp.AsMapString(nil); !reflect.DeepEqual(map[string]string{}, rply) { t.Errorf("Expecting %+v, received: %+v", map[string]string{}, rply) } - if rply := mp.AsMapStringIgnoreErrors(mpIgnore); !reflect.DeepEqual(map[string]string{}, rply) { + if rply := mp.AsMapString(mpIgnore); !reflect.DeepEqual(map[string]string{}, rply) { t.Errorf("Expecting %+v, received: %+v", map[string]string{}, rply) } } diff --git a/engine/pstr_http.go b/engine/pstr_http.go index d1fc4f787..9de52d1af 100644 --- a/engine/pstr_http.go +++ b/engine/pstr_http.go @@ -68,12 +68,12 @@ type HTTPPoster struct { // Post with built-in failover // Returns also reference towards client so we can close it's connections when done func (poster *HTTPPoster) Post(addr string, contentType string, content interface{}, attempts int, fallbackFilePath string) (respBody []byte, err error) { - if !utils.IsSliceMember([]string{utils.CONTENT_JSON, utils.CONTENT_FORM, utils.CONTENT_TEXT}, contentType) { + if !utils.SliceHasMember([]string{utils.CONTENT_FORM, utils.CONTENT_JSON, utils.CONTENT_TEXT}, contentType) { return nil, fmt.Errorf("unsupported ContentType: %s", contentType) } var body []byte // Used to write in file and send over http var urlVals url.Values // Used when posting form - if utils.IsSliceMember([]string{utils.CONTENT_JSON, utils.CONTENT_TEXT}, contentType) { + if utils.SliceHasMember([]string{utils.CONTENT_JSON, utils.CONTENT_TEXT}, contentType) { body = content.([]byte) } else if contentType == utils.CONTENT_FORM { urlVals = content.(url.Values) @@ -86,7 +86,7 @@ func (poster *HTTPPoster) Post(addr string, contentType string, content interfac } for i := 0; i < attempts; i++ { var resp *http.Response - if utils.IsSliceMember([]string{utils.CONTENT_JSON, utils.CONTENT_TEXT}, contentType) { + if utils.SliceHasMember([]string{utils.CONTENT_JSON, utils.CONTENT_TEXT}, contentType) { resp, err = poster.httpClient.Post(addr, bodyType, bytes.NewBuffer(body)) } else if contentType == utils.CONTENT_FORM { resp, err = poster.httpClient.PostForm(addr, urlVals) diff --git a/engine/safevent.go b/engine/safevent.go index 6b1544cbc..162f9bd7a 100644 --- a/engine/safevent.go +++ b/engine/safevent.go @@ -240,18 +240,9 @@ func (se *SafEvent) AsMapInterface() (mp map[string]interface{}) { // AsMapString returns a map[string]string out of mp, ignoring specific fields if needed // most used when needing to export extraFields -func (se *SafEvent) AsMapString(ignoredFlds utils.StringMap) (mp map[string]string, err error) { +func (se *SafEvent) AsMapString(ignoredFlds *utils.StringSet) (mp map[string]string) { se.RLock() - mp, err = se.Me.AsMapString(ignoredFlds) - se.RUnlock() - return -} - -// AsMapString returns a map[string]string out of mp, ignoring specific fields if needed -// most used when needing to export extraFields -func (se *SafEvent) AsMapStringIgnoreErrors(ignoredFlds utils.StringMap) (mp map[string]string) { - se.RLock() - mp = se.Me.AsMapStringIgnoreErrors(ignoredFlds) + mp = se.Me.AsMapString(ignoredFlds) se.RUnlock() return } diff --git a/engine/safevent_test.go b/engine/safevent_test.go index b43126dbc..00dd03b6e 100644 --- a/engine/safevent_test.go +++ b/engine/safevent_test.go @@ -622,47 +622,12 @@ func TestSafEventAsMapString(t *testing.T) { safEv.Remove("test9") }) } - var expected map[string]string - if expected, err = safEv.Me.AsMapString(nil); err != nil { - t.Error(err) - } - if rply, err := safEv.AsMapString(nil); err != nil { - t.Error(err) - } else if !reflect.DeepEqual(expected, rply) { + expected := safEv.Me.AsMapString(nil) + if rply := safEv.AsMapString(nil); !reflect.DeepEqual(expected, rply) { t.Errorf("Expecting %+v, received: %+v", expected, rply) } delete(expected, "test1") - if rply, err := safEv.AsMapString(utils.StringMap{"test1": true}); err != nil { - t.Error(err) - } else if !reflect.DeepEqual(expected, rply) { - t.Errorf("Expecting %+v, received: %+v", expected, rply) - } -} - -func TestSafEventAsMapStringIgnoreErrors(t *testing.T) { - for i := 0; i < 10; i++ { - t.Run("asMapStr", func(t *testing.T) { - t.Parallel() - safEv.AsMapStringIgnoreErrors(nil) - }) - t.Run("set", func(t *testing.T) { - t.Parallel() - safEv.Set("test9", true) - }) - t.Run("remove", func(t *testing.T) { - t.Parallel() - safEv.Remove("test9") - }) - } - var expected map[string]string - if expected, err = safEv.Me.AsMapString(nil); err != nil { - t.Error(err) - } - if rply := safEv.AsMapStringIgnoreErrors(nil); !reflect.DeepEqual(expected, rply) { - t.Errorf("Expecting %+v, received: %+v", expected["test8"], rply["test8"]) - } - delete(expected, "test1") - if rply := safEv.AsMapStringIgnoreErrors(utils.StringMap{"test1": true}); !reflect.DeepEqual(expected, rply) { + if rply := safEv.AsMapString(utils.NewStringSet([]string{"test1"})); !reflect.DeepEqual(expected, rply) { t.Errorf("Expecting %+v, received: %+v", expected, rply) } } diff --git a/engine/storage_mongo_datadb.go b/engine/storage_mongo_datadb.go index 7d9818bc9..e3943b00e 100644 --- a/engine/storage_mongo_datadb.go +++ b/engine/storage_mongo_datadb.go @@ -424,7 +424,7 @@ func (ms *MongoStorage) SelectDatabase(dbName string) (err error) { // RebuildReverseForPrefix implementation func (ms *MongoStorage) RebuildReverseForPrefix(prefix string) (err error) { - if !utils.IsSliceMember([]string{utils.REVERSE_DESTINATION_PREFIX, utils.AccountActionPlansPrefix}, prefix) { + if !utils.SliceHasMember([]string{utils.AccountActionPlansPrefix, utils.REVERSE_DESTINATION_PREFIX}, prefix) { return utils.ErrInvalidKey } colName, ok := ms.getColNameForPrefix(prefix) @@ -473,7 +473,7 @@ func (ms *MongoStorage) RebuildReverseForPrefix(prefix string) (err error) { // RemoveReverseForPrefix implementation func (ms *MongoStorage) RemoveReverseForPrefix(prefix string) (err error) { - if !utils.IsSliceMember([]string{utils.REVERSE_DESTINATION_PREFIX, utils.AccountActionPlansPrefix}, prefix) { + if !utils.SliceHasMember([]string{utils.AccountActionPlansPrefix, utils.REVERSE_DESTINATION_PREFIX}, prefix) { return utils.ErrInvalidKey } colName, ok := ms.getColNameForPrefix(prefix) diff --git a/engine/storage_redis.go b/engine/storage_redis.go index 8bd3795ae..e9b5bb699 100644 --- a/engine/storage_redis.go +++ b/engine/storage_redis.go @@ -233,7 +233,7 @@ func (rs *RedisStorage) IsDBEmpty() (resp bool, err error) { } func (rs *RedisStorage) RebuildReverseForPrefix(prefix string) (err error) { - if !utils.IsSliceMember([]string{utils.REVERSE_DESTINATION_PREFIX, utils.AccountActionPlansPrefix}, prefix) { + if !utils.SliceHasMember([]string{utils.AccountActionPlansPrefix, utils.REVERSE_DESTINATION_PREFIX}, prefix) { return utils.ErrInvalidKey } var keys []string @@ -280,7 +280,7 @@ func (rs *RedisStorage) RebuildReverseForPrefix(prefix string) (err error) { } func (rs *RedisStorage) RemoveReverseForPrefix(prefix string) (err error) { - if !utils.IsSliceMember([]string{utils.REVERSE_DESTINATION_PREFIX, utils.AccountActionPlansPrefix}, prefix) { + if !utils.SliceHasMember([]string{utils.AccountActionPlansPrefix, utils.REVERSE_DESTINATION_PREFIX}, prefix) { return utils.ErrInvalidKey } var keys []string diff --git a/engine/tpexporter.go b/engine/tpexporter.go index 02206ca5f..199309aa5 100644 --- a/engine/tpexporter.go +++ b/engine/tpexporter.go @@ -32,15 +32,15 @@ import ( "github.com/cgrates/cgrates/utils" ) -var ( - TPExportFormats = []string{utils.CSV} -) +// var ( +// TPExportFormats = []string{utils.CSV} +// ) func NewTPExporter(storDb LoadStorage, tpID, expPath, fileFormat, sep string, compress bool) (*TPExporter, error) { if len(tpID) == 0 { return nil, errors.New("Missing TPid") } - if !utils.IsSliceMember(TPExportFormats, fileFormat) { + if utils.CSV != fileFormat { return nil, errors.New("Unsupported file format") } tpExp := &TPExporter{ diff --git a/migrator/filters.go b/migrator/filters.go index 6191c3063..b7588df88 100644 --- a/migrator/filters.go +++ b/migrator/filters.go @@ -54,12 +54,14 @@ func (m *Migrator) migrateCurrentRequestFilter() (err error) { return } +var filterTypes = utils.NewStringSet([]string{utils.MetaRSR, utils.MetaStatS, utils.MetaResources, + utils.MetaNotRSR, utils.MetaNotStatS, utils.MetaNotResources}) + func migrateFilterV1(fl *engine.Filter) *engine.Filter { for i, rule := range fl.Rules { if rule.FieldName == "" || - utils.IsSliceMember([]string{utils.MetaRSR, utils.MetaStatS, utils.MetaResources, - utils.MetaNotRSR, utils.MetaNotStatS, utils.MetaNotResources}, rule.Type) || - strings.HasPrefix(rule.FieldName, utils.DynamicDataPrefix) { + strings.HasPrefix(rule.FieldName, utils.DynamicDataPrefix) || + filterTypes.Has(rule.Type) { continue } fl.Rules[i].FieldName = utils.DynamicDataPrefix + rule.FieldName @@ -76,9 +78,8 @@ func migrateInlineFilter(fl string) string { return fl } - if utils.IsSliceMember([]string{utils.MetaRSR, utils.MetaStatS, utils.MetaResources, - utils.MetaNotRSR, utils.MetaNotStatS, utils.MetaNotResources}, ruleSplt[0]) || - strings.HasPrefix(ruleSplt[1], utils.DynamicDataPrefix) { + if strings.HasPrefix(ruleSplt[1], utils.DynamicDataPrefix) || + filterTypes.Has(ruleSplt[0]) { return fl } return fmt.Sprintf("%s:~%s:%s", ruleSplt[0], ruleSplt[1], strings.Join(ruleSplt[2:], utils.InInFieldSep)) diff --git a/sessions/session.go b/sessions/session.go index 3b55c3b44..c36c11105 100644 --- a/sessions/session.go +++ b/sessions/session.go @@ -119,23 +119,22 @@ func (s *Session) AsExternalSessions(tmz, nodeID string) (aSs []*ExternalSession aSs = make([]*ExternalSession, len(s.SRuns)) for i, sr := range s.SRuns { aSs[i] = &ExternalSession{ - CGRID: s.CGRID, - RunID: sr.Event.GetStringIgnoreErrors(utils.RunID), - ToR: sr.Event.GetStringIgnoreErrors(utils.ToR), - OriginID: s.EventStart.GetStringIgnoreErrors(utils.OriginID), - OriginHost: s.EventStart.GetStringIgnoreErrors(utils.OriginHost), - Source: utils.SessionS + "_" + s.EventStart.GetStringIgnoreErrors(utils.EVENT_NAME), - RequestType: sr.Event.GetStringIgnoreErrors(utils.RequestType), - Tenant: s.Tenant, - Category: sr.Event.GetStringIgnoreErrors(utils.Category), - Account: sr.Event.GetStringIgnoreErrors(utils.Account), - Subject: sr.Event.GetStringIgnoreErrors(utils.Subject), - Destination: sr.Event.GetStringIgnoreErrors(utils.Destination), - SetupTime: sr.Event.GetTimeIgnoreErrors(utils.SetupTime, tmz), - AnswerTime: sr.Event.GetTimeIgnoreErrors(utils.AnswerTime, tmz), - Usage: sr.TotalUsage, - ExtraFields: sr.Event.AsMapStringIgnoreErrors( - utils.NewStringMap(utils.MainCDRFields...)), + CGRID: s.CGRID, + RunID: sr.Event.GetStringIgnoreErrors(utils.RunID), + ToR: sr.Event.GetStringIgnoreErrors(utils.ToR), + OriginID: s.EventStart.GetStringIgnoreErrors(utils.OriginID), + OriginHost: s.EventStart.GetStringIgnoreErrors(utils.OriginHost), + Source: utils.SessionS + "_" + s.EventStart.GetStringIgnoreErrors(utils.EVENT_NAME), + RequestType: sr.Event.GetStringIgnoreErrors(utils.RequestType), + Tenant: s.Tenant, + Category: sr.Event.GetStringIgnoreErrors(utils.Category), + Account: sr.Event.GetStringIgnoreErrors(utils.Account), + Subject: sr.Event.GetStringIgnoreErrors(utils.Subject), + Destination: sr.Event.GetStringIgnoreErrors(utils.Destination), + SetupTime: sr.Event.GetTimeIgnoreErrors(utils.SetupTime, tmz), + AnswerTime: sr.Event.GetTimeIgnoreErrors(utils.AnswerTime, tmz), + Usage: sr.TotalUsage, + ExtraFields: sr.Event.AsMapString(utils.MainCDRFields), NodeID: nodeID, DebitInterval: s.DebitInterval, } @@ -153,23 +152,22 @@ func (s *Session) AsExternalSessions(tmz, nodeID string) (aSs []*ExternalSession func (s *Session) AsExternalSession(sr *SRun, tmz, nodeID string) (aS *ExternalSession) { s.RLock() aS = &ExternalSession{ - CGRID: s.CGRID, - RunID: sr.Event.GetStringIgnoreErrors(utils.RunID), - ToR: sr.Event.GetStringIgnoreErrors(utils.ToR), - OriginID: s.EventStart.GetStringIgnoreErrors(utils.OriginID), - OriginHost: s.EventStart.GetStringIgnoreErrors(utils.OriginHost), - Source: utils.SessionS + "_" + s.EventStart.GetStringIgnoreErrors(utils.EVENT_NAME), - RequestType: sr.Event.GetStringIgnoreErrors(utils.RequestType), - Tenant: s.Tenant, - Category: sr.Event.GetStringIgnoreErrors(utils.Category), - Account: sr.Event.GetStringIgnoreErrors(utils.Account), - Subject: sr.Event.GetStringIgnoreErrors(utils.Subject), - Destination: sr.Event.GetStringIgnoreErrors(utils.Destination), - SetupTime: sr.Event.GetTimeIgnoreErrors(utils.SetupTime, tmz), - AnswerTime: sr.Event.GetTimeIgnoreErrors(utils.AnswerTime, tmz), - Usage: sr.TotalUsage, - ExtraFields: sr.Event.AsMapStringIgnoreErrors( - utils.NewStringMap(utils.MainCDRFields...)), + CGRID: s.CGRID, + RunID: sr.Event.GetStringIgnoreErrors(utils.RunID), + ToR: sr.Event.GetStringIgnoreErrors(utils.ToR), + OriginID: s.EventStart.GetStringIgnoreErrors(utils.OriginID), + OriginHost: s.EventStart.GetStringIgnoreErrors(utils.OriginHost), + Source: utils.SessionS + "_" + s.EventStart.GetStringIgnoreErrors(utils.EVENT_NAME), + RequestType: sr.Event.GetStringIgnoreErrors(utils.RequestType), + Tenant: s.Tenant, + Category: sr.Event.GetStringIgnoreErrors(utils.Category), + Account: sr.Event.GetStringIgnoreErrors(utils.Account), + Subject: sr.Event.GetStringIgnoreErrors(utils.Subject), + Destination: sr.Event.GetStringIgnoreErrors(utils.Destination), + SetupTime: sr.Event.GetTimeIgnoreErrors(utils.SetupTime, tmz), + AnswerTime: sr.Event.GetTimeIgnoreErrors(utils.AnswerTime, tmz), + Usage: sr.TotalUsage, + ExtraFields: sr.Event.AsMapString(utils.MainCDRFields), NodeID: nodeID, DebitInterval: s.DebitInterval, } diff --git a/sessions/sessions.go b/sessions/sessions.go index 429f7c5c7..3d3e7fd15 100644 --- a/sessions/sessions.go +++ b/sessions/sessions.go @@ -1117,7 +1117,7 @@ func (sS *SessionS) forkSession(s *Session) (err error) { Destination: me.GetStringIgnoreErrors(utils.Destination), TimeStart: startTime, TimeEnd: startTime.Add(s.EventStart.GetDurationIgnoreErrors(utils.Usage)), - ExtraFields: me.AsMapStringIgnoreErrors(utils.NewStringMap(utils.MainCDRFields...)), + ExtraFields: me.AsMapString(utils.MainCDRFields), }, } } @@ -1517,7 +1517,7 @@ func (sS *SessionS) chargeEvent(tnt string, ev *engine.SafEvent, argDisp *utils. return } usage := maxUsage - if utils.IsSliceMember(utils.PostPaidRatedSlice, ev.GetStringIgnoreErrors(utils.RequestType)) { + if utils.SliceHasMember(utils.PostPaidRatedSlice, ev.GetStringIgnoreErrors(utils.RequestType)) { usage = ev.GetDurationIgnoreErrors(utils.Usage) } //in case of postpaid and rated maxUsage = usage from event diff --git a/utils/consts.go b/utils/consts.go index f686db281..0733d7692 100755 --- a/utils/consts.go +++ b/utils/consts.go @@ -18,19 +18,16 @@ along with this program. If not, see package utils -import "sort" - var ( - CDRExportFormats = []string{DRYRUN, MetaFileCSV, MetaFileFWV, MetaHTTPjsonCDR, MetaHTTPjsonMap, + CDRExportFormats = NewStringSet([]string{DRYRUN, MetaFileCSV, MetaFileFWV, MetaHTTPjsonCDR, MetaHTTPjsonMap, MetaHTTPjson, META_HTTP_POST, MetaAMQPjsonCDR, MetaAMQPjsonMap, MetaAMQPV1jsonMap, MetaSQSjsonMap, - MetaKafkajsonMap, MetaS3jsonMap} - MainCDRFields = []string{CGRID, Source, OriginHost, OriginID, ToR, RequestType, Tenant, Category, + MetaKafkajsonMap, MetaS3jsonMap}) + MainCDRFields = NewStringSet([]string{CGRID, Source, OriginHost, OriginID, ToR, RequestType, Tenant, Category, Account, Subject, Destination, SetupTime, AnswerTime, Usage, COST, RATED, Partial, RunID, - PreRated, CostSource, CostDetails, ExtraInfo, OrderID} - CDRCFileFormats = []string{MetaFileCSV, MetaFScsv, - MetaKamFlatstore, MetaOsipsFlatstore, MetaPartialCSV, MetaFileFWV, MetaFileXML} + PreRated, CostSource, CostDetails, ExtraInfo, OrderID}) + CDRCFileFormats = NewStringSet([]string{MetaFileCSV, MetaFScsv, + MetaKamFlatstore, MetaOsipsFlatstore, MetaPartialCSV, MetaFileFWV, MetaFileXML}) PostPaidRatedSlice = []string{META_POSTPAID, META_RATED} - MainCDRFieldsMap StringMap GitLastLog string // If set, it will be processed as part of versioning PosterTransportContentTypes = map[string]string{ @@ -1194,15 +1191,7 @@ func buildCacheIndexesToPrefix() { } } -// sortStringSlices makes sure the slices are string sorted -// so we can search inside using SliceHasMember -func sortStringSlices() { - sort.Strings(CDRExportFormats) -} - func init() { - sortStringSlices() buildCacheInstRevPrefixes() buildCacheIndexesToPrefix() - MainCDRFieldsMap = NewStringMap(MainCDRFields...) } diff --git a/utils/set.go b/utils/set.go new file mode 100644 index 000000000..10549aade --- /dev/null +++ b/utils/set.go @@ -0,0 +1,48 @@ +/* +Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments +Copyright (C) ITsysCOM GmbH + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see +*/ + +package utils + +func NewStringSet(dataSlice []string) (s *StringSet) { + s = &StringSet{data: make(map[string]struct{})} + s.AddSlice(dataSlice) + return s +} + +type StringSet struct { + data map[string]struct{} +} + +func (s *StringSet) Add(val string) { + s.data[val] = struct{}{} +} + +func (s *StringSet) Remove(val string) { + delete(s.data, val) +} + +func (s *StringSet) Has(val string) bool { + _, has := s.data[val] + return has +} + +func (s *StringSet) AddSlice(dataSlice []string) { + for _, val := range dataSlice { + s.Add(val) + } +}