func (um *UserMap) deleteIndex(up *UserProfile) { key := up.GetId() for _, index := range um.indexKeys { if index == "Tenant" { if up.Tenant != "" { indexKey := utils.ConcatenatedKey(index, up.Tenant) delete(um.index[indexKey], key) if len(um.index[indexKey]) == 0 { delete(um.index, indexKey) } } continue } if index == "UserName" { if up.UserName != "" { indexKey := utils.ConcatenatedKey(index, up.UserName) delete(um.index[indexKey], key) if len(um.index[indexKey]) == 0 { delete(um.index, indexKey) } } continue } for k, v := range up.Profile { if k == index && v != "" { indexKey := utils.ConcatenatedKey(k, v) delete(um.index[indexKey], key) if len(um.index[indexKey]) == 0 { delete(um.index, indexKey) } } } } }
func (um *UserMap) addIndex(up *UserProfile, indexes []string) { key := up.GetId() for _, index := range indexes { if index == "Tenant" { if up.Tenant != "" { indexKey := utils.ConcatenatedKey(index, up.Tenant) if um.index[indexKey] == nil { um.index[indexKey] = make(map[string]bool) } um.index[indexKey][key] = true } continue } if index == "UserName" { if up.UserName != "" { indexKey := utils.ConcatenatedKey(index, up.UserName) if um.index[indexKey] == nil { um.index[indexKey] = make(map[string]bool) } um.index[indexKey][key] = true } continue } for k, v := range up.Profile { if k == index && v != "" { indexKey := utils.ConcatenatedKey(k, v) if um.index[indexKey] == nil { um.index[indexKey] = make(map[string]bool) } um.index[indexKey][key] = true } } } }
// GetAccountKey returns the key used to retrive the user balance involved in this call func (cd *CallDescriptor) GetAccountKey() string { subj := cd.Subject if cd.Account != "" { // check if subject is alias if aliasService != nil { var alias string err := aliasService.GetMatchingAlias( AttrMatchingAlias{ Destination: cd.Destination, Direction: cd.Direction, Tenant: cd.Tenant, Category: cd.Category, Account: cd.Account, Subject: cd.Subject, Context: utils.ALIAS_GROUP_ACC, Target: "Account", Original: cd.Account, }, &alias) if err == nil && alias != "" { cd.Account = alias } } subj = cd.Account } return utils.ConcatenatedKey(cd.Direction, cd.Tenant, subj) }
func (ms *MapStorage) RemoveAlias(key string, transactionID string) error { // get alias for values list al, err := ms.GetAlias(key, false, transactionID) if err != nil { return err } ms.mu.Lock() defer ms.mu.Unlock() key = utils.ALIASES_PREFIX + key aliasValues := make(AliasValues, 0) if values, ok := ms.dict[key]; ok { ms.ms.Unmarshal(values, &aliasValues) } delete(ms.dict, key) cCommit := cacheCommit(transactionID) cache.RemKey(key, cCommit, transactionID) for _, value := range al.Values { tmpKey := utils.ConcatenatedKey(al.GetId(), value.DestinationId) for target, pairs := range value.Pairs { for _, alias := range pairs { rKey := utils.REVERSE_ALIASES_PREFIX + alias + target + al.Context ms.dict.srem(rKey, tmpKey, ms.ms) cache.RemKey(rKey, cCommit, transactionID) /*_, err = ms.GetReverseAlias(rKey, true) // recache if err != nil { return err }*/ } } } return nil }
func TestRDSitSetGetDerivedCharges(t *testing.T) { if !*testIntegration { return } keyCharger1 := utils.ConcatenatedKey("*out", "cgrates.org", "call", "dan", "dan") charger1 := &utils.DerivedChargers{Chargers: []*utils.DerivedCharger{ &utils.DerivedCharger{RunID: "extra1", RequestTypeField: "^prepaid", DirectionField: "*default", TenantField: "*default", CategoryField: "*default", AccountField: "rif", SubjectField: "rif", DestinationField: "*default", SetupTimeField: "*default", AnswerTimeField: "*default", UsageField: "*default"}, &utils.DerivedCharger{RunID: "extra2", RequestTypeField: "*default", DirectionField: "*default", TenantField: "*default", CategoryField: "*default", AccountField: "ivo", SubjectField: "ivo", DestinationField: "*default", SetupTimeField: "*default", AnswerTimeField: "*default", UsageField: "*default"}, }} if err := rds.SetDerivedChargers(keyCharger1, charger1, utils.NonTransactional); err != nil { t.Error("Error on setting DerivedChargers", err.Error()) } // Retrieve from db if rcvCharger, err := rds.GetDerivedChargers(keyCharger1, true, utils.NonTransactional); err != nil { t.Error("Error when retrieving DerivedCHarger", err.Error()) } else if !reflect.DeepEqual(rcvCharger, charger1) { t.Errorf("Expecting %v, received: %v", charger1, rcvCharger) } // Retrieve from cache if rcvCharger, err := rds.GetDerivedChargers(keyCharger1, false, utils.NonTransactional); err != nil { t.Error("Error when retrieving DerivedCHarger", err.Error()) } else if !reflect.DeepEqual(rcvCharger, charger1) { t.Errorf("Expecting %v, received: %v", charger1, rcvCharger) } }
func testOnStorITCacheDerivedChargers(t *testing.T) { dcs := &utils.DerivedChargers{ DestinationIDs: make(utils.StringMap), Chargers: []*utils.DerivedCharger{ &utils.DerivedCharger{RunID: "extra1", RunFilters: "^filteredHeader1/filterValue1/", RequestTypeField: "^prepaid", DirectionField: utils.META_DEFAULT, TenantField: utils.META_DEFAULT, CategoryField: utils.META_DEFAULT, AccountField: "rif", SubjectField: "rif", DestinationField: utils.META_DEFAULT, SetupTimeField: utils.META_DEFAULT, PDDField: utils.META_DEFAULT, AnswerTimeField: utils.META_DEFAULT, UsageField: utils.META_DEFAULT, SupplierField: utils.META_DEFAULT, DisconnectCauseField: utils.META_DEFAULT, CostField: utils.META_DEFAULT, RatedField: utils.META_DEFAULT}, &utils.DerivedCharger{RunID: "extra2", RequestTypeField: utils.META_DEFAULT, DirectionField: utils.META_DEFAULT, TenantField: utils.META_DEFAULT, CategoryField: utils.META_DEFAULT, AccountField: "ivo", SubjectField: "ivo", DestinationField: utils.META_DEFAULT, SetupTimeField: utils.META_DEFAULT, PDDField: utils.META_DEFAULT, AnswerTimeField: utils.META_DEFAULT, UsageField: utils.META_DEFAULT, SupplierField: utils.META_DEFAULT, DisconnectCauseField: utils.META_DEFAULT, CostField: utils.META_DEFAULT, RatedField: utils.META_DEFAULT}, }} keyDCS := utils.ConcatenatedKey("*out", "itsyscom.com", "call", "dan", "dan") if err := onStor.SetDerivedChargers(keyDCS, dcs, utils.NonTransactional); err != nil { t.Error(err) } if _, hasIt := cache.Get(utils.DERIVEDCHARGERS_PREFIX + keyDCS); hasIt { t.Error("Already in cache") } if err := onStor.CacheDataFromDB(utils.DERIVEDCHARGERS_PREFIX, []string{keyDCS}, false); err != nil { t.Error(err) } if itm, hasIt := cache.Get(utils.DERIVEDCHARGERS_PREFIX + keyDCS); !hasIt { t.Error("Did not cache") } else if rcv := itm.(*utils.DerivedChargers); !reflect.DeepEqual(dcs, rcv) { t.Errorf("Expecting: %+v, received: %+v", dcs, rcv) } }
func testOnStorITSetGetDerivedCharges(t *testing.T) { keyCharger1 := utils.ConcatenatedKey("*out", "cgrates.org", "call", "dan", "dan") if _, err := onStor.GetDerivedChargers(keyCharger1, true, utils.NonTransactional); err == nil { t.Error("DC exists") } charger1 := &utils.DerivedChargers{DestinationIDs: make(utils.StringMap), Chargers: []*utils.DerivedCharger{ &utils.DerivedCharger{RunID: "extra1", RequestTypeField: "^prepaid", DirectionField: "*default", TenantField: "*default", CategoryField: "*default", AccountField: "rif", SubjectField: "rif", DestinationField: "*default", SetupTimeField: "*default", AnswerTimeField: "*default", UsageField: "*default"}, &utils.DerivedCharger{RunID: "extra2", RequestTypeField: "*default", DirectionField: "*default", TenantField: "*default", CategoryField: "*default", AccountField: "ivo", SubjectField: "ivo", DestinationField: "*default", SetupTimeField: "*default", AnswerTimeField: "*default", UsageField: "*default"}, }} if err := onStor.SetDerivedChargers(keyCharger1, charger1, utils.NonTransactional); err != nil { t.Error("Error on setting DerivedChargers", err.Error()) } // Retrieve from db if rcvCharger, err := onStor.GetDerivedChargers(keyCharger1, true, utils.NonTransactional); err != nil { t.Error("Error when retrieving DerivedCHarger", err.Error()) } else if !reflect.DeepEqual(rcvCharger, charger1) { for i, eChrg := range charger1.Chargers { if !reflect.DeepEqual(eChrg, rcvCharger.Chargers[i]) { t.Logf("Expecting: %+v, received: %+v", eChrg, rcvCharger.Chargers[i]) } } t.Errorf("Expecting %v, received: %v", charger1, rcvCharger) } // Retrieve from cache if rcvCharger, err := onStor.GetDerivedChargers(keyCharger1, false, utils.NonTransactional); err != nil { t.Error("Error when retrieving DerivedCHarger", err.Error()) } else if !reflect.DeepEqual(rcvCharger, charger1) { t.Errorf("Expecting %v, received: %v", charger1, rcvCharger) } }
func testOnStorITMatchReqFilterIndex(t *testing.T) { eMp := utils.StringMap{ "RL1": true, "RL2": true, } if rcvMp, err := onStor.MatchReqFilterIndex(utils.ResourceLimitsIndex, utils.ConcatenatedKey("Account", "1002")); err != nil { t.Error(err) } else if !reflect.DeepEqual(eMp, rcvMp) { t.Errorf("Expecting: %+v, received: %+v", eMp, rcvMp) } if _, err := onStor.MatchReqFilterIndex(utils.ResourceLimitsIndex, utils.ConcatenatedKey("NonexistentField", "1002")); err == nil || err != utils.ErrNotFound { t.Error(err) } }
func (rs *RedisStorage) RemoveAlias(id string, transactionID string) (err error) { key := utils.ALIASES_PREFIX + id // get alias for values list al, err := rs.GetAlias(id, false, transactionID) if err != nil { return } err = rs.db.Cmd("DEL", key).Err if err != nil { return err } cCommit := cacheCommit(transactionID) cache2go.RemKey(key, cCommit, transactionID) for _, value := range al.Values { tmpKey := utils.ConcatenatedKey(al.GetId(), value.DestinationId) for target, pairs := range value.Pairs { for _, alias := range pairs { rKey := utils.REVERSE_ALIASES_PREFIX + alias + target + al.Context err = rs.db.Cmd("SREM", rKey, tmpKey).Err if err != nil { return err } cache2go.RemKey(rKey, cCommit, transactionID) /*_, err = rs.GetReverseAlias(rKey, true) // recache if err != nil { return err }*/ } } } return }
// IndexFilters parses reqFltrs, adding itemID in the indexes and marks the changed keys in chngdIndxKeys func (rfi *ReqFilterIndexer) IndexFilters(itemID string, reqFltrs []*RequestFilter) { var hasMetaString bool for _, fltr := range reqFltrs { if fltr.Type != MetaString { continue } hasMetaString = true // Mark that we found at least one metatring so we don't index globally if _, hastIt := rfi.indexes[fltr.FieldName]; !hastIt { rfi.indexes[fltr.FieldName] = make(map[string]utils.StringMap) } for _, fldVal := range fltr.Values { if _, hasIt := rfi.indexes[fltr.FieldName][fldVal]; !hasIt { rfi.indexes[fltr.FieldName][fldVal] = make(utils.StringMap) } rfi.indexes[fltr.FieldName][fldVal][itemID] = true rfi.chngdIndxKeys[utils.ConcatenatedKey(fltr.FieldName, fldVal)] = true } } if !hasMetaString { if _, hasIt := rfi.indexes[utils.NOT_AVAILABLE]; !hasIt { rfi.indexes[utils.NOT_AVAILABLE] = make(map[string]utils.StringMap) } if _, hasIt := rfi.indexes[utils.NOT_AVAILABLE][utils.NOT_AVAILABLE]; !hasIt { rfi.indexes[utils.NOT_AVAILABLE][utils.NOT_AVAILABLE] = make(utils.StringMap) } rfi.indexes[utils.NOT_AVAILABLE][utils.NOT_AVAILABLE][itemID] = true // Fields without real field index will be located in map[NOT_AVAILABLE][NOT_AVAILABLE][rl.ID] } return }
// GetAccountKey returns the key used to retrive the user balance involved in this call func (cd *CallDescriptor) GetAccountKey() string { subj := cd.Subject if cd.Account != "" { subj = cd.Account } return utils.ConcatenatedKey(cd.Tenant, subj) }
func TestSetGetDerivedCharges(t *testing.T) { if !*testLocal { return } keyCharger1 := utils.ConcatenatedKey("cgrates.org", "call", "*out", "dan", "dan") charger1 := utils.DerivedChargers{ &utils.DerivedCharger{RunId: "extra1", ReqTypeField: "^prepaid", DirectionField: "*default", TenantField: "*default", CategoryField: "*default", AccountField: "rif", SubjectField: "rif", DestinationField: "*default", SetupTimeField: "*default", AnswerTimeField: "*default", UsageField: "*default"}, &utils.DerivedCharger{RunId: "extra2", ReqTypeField: "*default", DirectionField: "*default", TenantField: "*default", CategoryField: "*default", AccountField: "ivo", SubjectField: "ivo", DestinationField: "*default", SetupTimeField: "*default", AnswerTimeField: "*default", UsageField: "*default"}, } if err := rds.SetDerivedChargers(keyCharger1, charger1); err != nil { t.Error("Error on setting DerivedChargers", err.Error()) } // Try retrieving from cache, should not be in yet if _, err := rds.GetDerivedChargers(keyCharger1, false); err == nil { t.Error("DerivedCharger should not be in the cache") } // Retrieve from db if rcvCharger, err := rds.GetDerivedChargers(keyCharger1, true); err != nil { t.Error("Error when retrieving DerivedCHarger", err.Error()) } else if !reflect.DeepEqual(rcvCharger, charger1) { t.Errorf("Expecting %v, received: %v", charger1, rcvCharger) } // Retrieve from cache if rcvCharger, err := rds.GetDerivedChargers(keyCharger1, false); err != nil { t.Error("Error when retrieving DerivedCHarger", err.Error()) } else if !reflect.DeepEqual(rcvCharger, charger1) { t.Errorf("Expecting %v, received: %v", charger1, rcvCharger) } }
func TestUsersAddIndex(t *testing.T) { var r string testMap.AddIndex([]string{"t"}, &r) if r != utils.OK || len(testMap.index) != 1 || len(testMap.index[utils.ConcatenatedKey("t", "v")]) != 5 { t.Error("error adding index: ", testMap.index) } }
func (al *Alias) SetReverseCache() { for _, value := range al.Values { for target, pairs := range value.Pairs { for _, alias := range pairs { rKey := strings.Join([]string{utils.REVERSE_ALIASES_PREFIX, alias, target, al.Context}, "") CachePush(rKey, utils.ConcatenatedKey(al.GetId(), value.DestinationId)) } } } }
func TestUsersAddIndexFull(t *testing.T) { var r string testMap.index = make(map[string]map[string]bool) // reset index testMap.AddIndex([]string{"t", "x", "UserName", "Tenant"}, &r) if r != utils.OK || len(testMap.index) != 7 || len(testMap.index[utils.ConcatenatedKey("t", "v")]) != 5 { t.Error("error adding index: ", testMap.index) } }
func (self *ApierV1) AddBalance(attr *AttrAddBalance, reply *string) error { expTime, err := utils.ParseDate(attr.ExpiryTime) if err != nil { *reply = err.Error() return err } tag := utils.ConcatenatedKey(attr.Direction, attr.Tenant, attr.Account) if _, err := self.AccountDb.GetAccount(tag); err != nil { // create user balance if not exists account := &engine.Account{ Id: tag, } if err := self.AccountDb.SetAccount(account); err != nil { *reply = err.Error() return err } } at := &engine.ActionPlan{ AccountIds: []string{tag}, } if attr.Direction == "" { attr.Direction = engine.OUTBOUND } aType := engine.DEBIT // reverse the sign as it is a debit attr.Value = -attr.Value if attr.Overwrite { aType = engine.DEBIT_RESET } at.SetActions(engine.Actions{ &engine.Action{ ActionType: aType, BalanceType: attr.BalanceType, Direction: attr.Direction, Balance: &engine.Balance{ Uuid: attr.BalanceUuid, Id: attr.BalanceId, Value: attr.Value, ExpirationDate: expTime, RatingSubject: attr.RatingSubject, DestinationIds: attr.DestinationId, Weight: attr.Weight, SharedGroup: attr.SharedGroup, Disabled: attr.Disabled, }, }, }) if err := at.Execute(); err != nil { *reply = err.Error() return err } *reply = OK return nil }
func (self *ApierV1) GetAccounts(attr utils.AttrGetAccounts, reply *[]*engine.Account) error { if len(attr.Tenant) == 0 { return utils.NewErrMandatoryIeMissing("Tenanat") } if len(attr.Direction) == 0 { attr.Direction = utils.OUT } var accountKeys []string var err error if len(attr.AccountIds) == 0 { if accountKeys, err = self.AccountDb.GetKeysForPrefix(utils.ACCOUNT_PREFIX + utils.ConcatenatedKey(attr.Direction, attr.Tenant)); err != nil { return err } } else { for _, acntId := range attr.AccountIds { if len(acntId) == 0 { // Source of error returned from redis (key not found) continue } accountKeys = append(accountKeys, utils.ACCOUNT_PREFIX+utils.ConcatenatedKey(attr.Direction, attr.Tenant, acntId)) } } if len(accountKeys) == 0 { return nil } var limitedAccounts []string if attr.Limit != 0 { max := math.Min(float64(attr.Offset+attr.Limit), float64(len(accountKeys))) limitedAccounts = accountKeys[attr.Offset:int(max)] } else { limitedAccounts = accountKeys[attr.Offset:] } retAccounts := make([]*engine.Account, 0) for _, acntKey := range limitedAccounts { if acnt, err := self.AccountDb.GetAccount(acntKey[len(utils.ACCOUNT_PREFIX):]); err != nil && err != utils.ErrNotFound { // Not found is not an error here return err } else if acnt != nil { retAccounts = append(retAccounts, acnt) } } *reply = retAccounts return nil }
func (al *Alias) RemoveReverseCache() { for _, value := range al.Values { tmpKey := utils.ConcatenatedKey(al.GetId(), value.DestinationId) for target, pairs := range value.Pairs { for _, alias := range pairs { rKey := utils.REVERSE_ALIASES_PREFIX + alias + target + al.Context CachePop(rKey, tmpKey) } } } }
func TestSetAccounts(t *testing.T) { cgrTenant := "cgrates.org" iscTenant := "itsyscom.com" b10 := &engine.Balance{Value: 10, Weight: 10} cgrAcnt1 := &engine.Account{Id: utils.ConcatenatedKey(cgrTenant, "account1"), BalanceMap: map[string]engine.BalanceChain{utils.MONETARY + utils.OUT: engine.BalanceChain{b10}}} cgrAcnt2 := &engine.Account{Id: utils.ConcatenatedKey(cgrTenant, "account2"), BalanceMap: map[string]engine.BalanceChain{utils.MONETARY + utils.OUT: engine.BalanceChain{b10}}} cgrAcnt3 := &engine.Account{Id: utils.ConcatenatedKey(cgrTenant, "account3"), BalanceMap: map[string]engine.BalanceChain{utils.MONETARY + utils.OUT: engine.BalanceChain{b10}}} iscAcnt1 := &engine.Account{Id: utils.ConcatenatedKey(iscTenant, "account1"), BalanceMap: map[string]engine.BalanceChain{utils.MONETARY + utils.OUT: engine.BalanceChain{b10}}} iscAcnt2 := &engine.Account{Id: utils.ConcatenatedKey(iscTenant, "account2"), BalanceMap: map[string]engine.BalanceChain{utils.MONETARY + utils.OUT: engine.BalanceChain{b10}}} for _, account := range []*engine.Account{cgrAcnt1, cgrAcnt2, cgrAcnt3, iscAcnt1, iscAcnt2} { if err := apierAcntsAcntStorage.SetAccount(account); err != nil { t.Error(err) } } apierAcntsAcntStorage.CacheRatingPrefixes(utils.ACTION_PREFIX) }
func (rs *RedisStorage) SetReverseAlias(al *Alias, transactionID string) (err error) { for _, value := range al.Values { for target, pairs := range value.Pairs { for _, alias := range pairs { rKey := strings.Join([]string{utils.REVERSE_ALIASES_PREFIX, alias, target, al.Context}, "") id := utils.ConcatenatedKey(al.GetId(), value.DestinationId) if err = rs.Cmd("SADD", rKey, id).Err; err != nil { break } } } } return }
func TestStorageCacheGetReverseAliases(t *testing.T) { ala := &Alias{ Direction: "*out", Tenant: "vdf", Category: "0", Account: "b1", Subject: "b1", Context: utils.ALIAS_CONTEXT_RATING, } alb := &Alias{ Direction: "*out", Tenant: "vdf", Category: "0", Account: "b1", Subject: "b1", Context: "*other", } if x, err := cache2go.Get(utils.REVERSE_ALIASES_PREFIX + "aaa" + "Subject" + utils.ALIAS_CONTEXT_RATING); err == nil { aliasKeys := x.(map[string]bool) _, found := aliasKeys[utils.ConcatenatedKey(ala.GetId(), utils.ANY)] if !found { t.Error("Error getting reverse alias: ", aliasKeys, ala.GetId()+utils.ANY) } } else { t.Error("Error getting reverse alias: ", err) } if x, err := cache2go.Get(utils.REVERSE_ALIASES_PREFIX + "aaa" + "Account" + "*other"); err == nil { aliasKeys := x.(map[string]bool) _, found := aliasKeys[utils.ConcatenatedKey(alb.GetId(), utils.ANY)] if !found { t.Error("Error getting reverse alias: ", aliasKeys) } } else { t.Error("Error getting reverse alias: ", err) } }
func TestResponderGetSessionRuns(t *testing.T) { testTenant := "vdf" cdr := &CDR{CGRID: utils.Sha1("dsafdsaf", time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC).String()), OrderID: 123, ToR: utils.VOICE, OriginID: "dsafdsaf", OriginHost: "192.168.1.1", Source: "test", RequestType: utils.META_PREPAID, Direction: "*out", Tenant: testTenant, Category: "call", Account: "dan2", Subject: "dan2", Destination: "1002", SetupTime: time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC), PDD: 3 * time.Second, AnswerTime: time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC), Supplier: "suppl1", RunID: utils.DEFAULT_RUNID, Usage: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}, Cost: 1.01} keyCharger1 := utils.ConcatenatedKey("*out", testTenant, "call", "dan2", "dan2") dfDC := &utils.DerivedCharger{RunID: utils.DEFAULT_RUNID, RequestTypeField: utils.META_DEFAULT, DirectionField: utils.META_DEFAULT, TenantField: utils.META_DEFAULT, CategoryField: utils.META_DEFAULT, AccountField: utils.META_DEFAULT, SubjectField: utils.META_DEFAULT, DestinationField: utils.META_DEFAULT, SetupTimeField: utils.META_DEFAULT, PDDField: utils.META_DEFAULT, AnswerTimeField: utils.META_DEFAULT, UsageField: utils.META_DEFAULT, SupplierField: utils.META_DEFAULT, DisconnectCauseField: utils.META_DEFAULT, CostField: utils.META_DEFAULT, RatedField: utils.META_DEFAULT} extra1DC := &utils.DerivedCharger{RunID: "extra1", RequestTypeField: "^" + utils.META_PREPAID, DirectionField: utils.META_DEFAULT, TenantField: utils.META_DEFAULT, CategoryField: "^0", AccountField: "^minitsboy", SubjectField: "^rif", DestinationField: "^0256", SetupTimeField: utils.META_DEFAULT, PDDField: utils.META_DEFAULT, AnswerTimeField: utils.META_DEFAULT, UsageField: utils.META_DEFAULT, SupplierField: utils.META_DEFAULT} extra2DC := &utils.DerivedCharger{RunID: "extra2", RequestTypeField: utils.META_DEFAULT, DirectionField: utils.META_DEFAULT, TenantField: utils.META_DEFAULT, CategoryField: utils.META_DEFAULT, AccountField: "^ivo", SubjectField: "^ivo", DestinationField: utils.META_DEFAULT, SetupTimeField: utils.META_DEFAULT, AnswerTimeField: utils.META_DEFAULT, UsageField: utils.META_DEFAULT, SupplierField: utils.META_DEFAULT} extra3DC := &utils.DerivedCharger{RunID: "extra3", RequestTypeField: "^" + utils.META_PSEUDOPREPAID, DirectionField: utils.META_DEFAULT, TenantField: utils.META_DEFAULT, CategoryField: "^0", AccountField: "^minu", SubjectField: "^rif", DestinationField: "^0256", SetupTimeField: utils.META_DEFAULT, PDDField: utils.META_DEFAULT, AnswerTimeField: utils.META_DEFAULT, UsageField: utils.META_DEFAULT, SupplierField: utils.META_DEFAULT, DisconnectCauseField: utils.META_DEFAULT} charger1 := &utils.DerivedChargers{Chargers: []*utils.DerivedCharger{extra1DC, extra2DC, extra3DC}} if err := ratingStorage.SetDerivedChargers(keyCharger1, charger1); err != nil { t.Error("Error on setting DerivedChargers", err.Error()) } ratingStorage.CacheRatingAll("TestResponderGetSessionRuns") sesRuns := make([]*SessionRun, 0) eSRuns := []*SessionRun{ &SessionRun{DerivedCharger: extra1DC, CallDescriptor: &CallDescriptor{CgrID: utils.Sha1("dsafdsaf", time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC).String()), RunID: "extra1", Direction: "*out", Category: "0", Tenant: "vdf", Subject: "rif", Account: "minitsboy", Destination: "0256", TimeStart: time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC), TimeEnd: time.Date(2013, 11, 7, 8, 42, 36, 0, time.UTC), TOR: utils.VOICE, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}}}, &SessionRun{DerivedCharger: extra2DC, CallDescriptor: &CallDescriptor{CgrID: utils.Sha1("dsafdsaf", time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC).String()), RunID: "extra2", Direction: "*out", Category: "call", Tenant: "vdf", Subject: "ivo", Account: "ivo", Destination: "1002", TimeStart: time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC), TimeEnd: time.Date(2013, 11, 7, 8, 42, 36, 0, time.UTC), TOR: utils.VOICE, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}}}, &SessionRun{DerivedCharger: dfDC, CallDescriptor: &CallDescriptor{CgrID: utils.Sha1("dsafdsaf", time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC).String()), RunID: "*default", Direction: "*out", Category: "call", Tenant: "vdf", Subject: "dan2", Account: "dan2", Destination: "1002", TimeStart: time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC), TimeEnd: time.Date(2013, 11, 7, 8, 42, 36, 0, time.UTC), TOR: utils.VOICE, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}}}} if err := rsponder.GetSessionRuns(cdr, &sesRuns); err != nil { t.Error(err) } else if !reflect.DeepEqual(eSRuns, sesRuns) { for _, sr := range sesRuns { t.Logf("sr cd: %s", utils.ToIJSON(sr.CallDescriptor)) } t.Errorf("Expecting: %+v, received: %+v", eSRuns, sesRuns) } }
func (al *Alias) GenerateIds() []string { var result []string result = append(result, utils.ConcatenatedKey(al.Direction, al.Tenant, al.Category, al.Account, al.Subject, al.Context)) result = append(result, utils.ConcatenatedKey(al.Direction, al.Tenant, al.Category, al.Account, utils.ANY, al.Context)) result = append(result, utils.ConcatenatedKey(al.Direction, al.Tenant, al.Category, utils.ANY, utils.ANY, al.Context)) result = append(result, utils.ConcatenatedKey(al.Direction, al.Tenant, utils.ANY, utils.ANY, utils.ANY, al.Context)) result = append(result, utils.ConcatenatedKey(al.Direction, utils.ANY, utils.ANY, utils.ANY, utils.ANY, al.Context)) result = append(result, utils.ConcatenatedKey(utils.ANY, utils.ANY, utils.ANY, utils.ANY, al.Context)) return result }
func (rs *RedisStorage) SetReqFilterIndexes(dbKey string, indexes map[string]map[string]utils.StringMap) (err error) { if err = rs.Cmd("DEL", dbKey).Err; err != nil { // DELETE before set return } mp := make(map[string]string) for fldName, fldValMp := range indexes { for fldVal, strMp := range fldValMp { if encodedMp, err := rs.ms.Marshal(strMp); err != nil { return err } else { mp[utils.ConcatenatedKey(fldName, fldVal)] = string(encodedMp) } } } return rs.Cmd("HMSET", dbKey, mp).Err }
func testOnStorITCacheReverseAlias(t *testing.T) { als := &Alias{ Direction: "*out", Tenant: "itsyscom.com", Category: "call", Account: "dan", Subject: "dan", Context: "*rating", Values: AliasValues{ &AliasValue{ DestinationId: "EU", Pairs: AliasPairs{ "Account": map[string]string{ "dan": "dan1", "rif": "rif1", }, "Calling": map[string]string{ "11234": "2234", }, }, Weight: 10, }, &AliasValue{ DestinationId: "US", Pairs: AliasPairs{"Account": map[string]string{"dan": "dan2"}}, Weight: 20, }, }, } if err := onStor.SetReverseAlias(als, utils.NonTransactional); err != nil { t.Error(err) } rvAlsID := strings.Join([]string{als.Values[1].Pairs["Account"]["dan"], "Account", als.Context}, "") if _, hasIt := cache.Get(utils.REVERSE_ALIASES_PREFIX + rvAlsID); hasIt { t.Error("Already in cache") } if err := onStor.CacheDataFromDB(utils.REVERSE_ALIASES_PREFIX, []string{rvAlsID}, false); err != nil { t.Error(err) } eRvrsAls := []string{utils.ConcatenatedKey(als.GetId(), als.Values[1].DestinationId)} if itm, hasIt := cache.Get(utils.REVERSE_ALIASES_PREFIX + rvAlsID); !hasIt { t.Error("Did not cache") } else if rcv := itm.([]string); !reflect.DeepEqual(eRvrsAls, rcv) { t.Errorf("Expecting: %+v, received: %+v", eRvrsAls, rcv) } }
func (ms *MapStorage) SetReverseAlias(al *Alias, transactionID string) (err error) { cCommit := cacheCommit(transactionID) for _, value := range al.Values { for target, pairs := range value.Pairs { for _, alias := range pairs { rKey := strings.Join([]string{utils.REVERSE_ALIASES_PREFIX, alias, target, al.Context}, "") id := utils.ConcatenatedKey(al.GetId(), value.DestinationId) ms.mu.Lock() ms.dict.sadd(rKey, id, ms.ms) ms.mu.Unlock() cache.RemKey(rKey, cCommit, transactionID) } } } return }
func (self *ApierV1) EnableDisableBalance(attr *AttrAddBalance, reply *string) error { if missing := utils.MissingStructFields(attr, []string{"Tenant", "Account", "BalanceType"}); len(missing) != 0 { return utils.NewErrMandatoryIeMissing(missing...) } expTime, err := utils.ParseTimeDetectLayout(attr.ExpiryTime, self.Config.DefaultTimezone) if err != nil { *reply = err.Error() return err } accID := utils.ConcatenatedKey(attr.Tenant, attr.Account) if _, err := self.AccountDb.GetAccount(accID); err != nil { return utils.ErrNotFound } at := &engine.ActionTiming{} at.SetAccountIDs(utils.StringMap{accID: true}) at.SetActions(engine.Actions{ &engine.Action{ ActionType: engine.ENABLE_DISABLE_BALANCE, BalanceType: attr.BalanceType, Balance: &engine.Balance{ Uuid: attr.BalanceUuid, Id: attr.BalanceId, Value: attr.Value, ExpirationDate: expTime, RatingSubject: attr.RatingSubject, Categories: utils.ParseStringMap(attr.Categories), Directions: utils.ParseStringMap(attr.Directions), DestinationIds: utils.ParseStringMap(attr.DestinationIds), Weight: attr.Weight, SharedGroups: utils.ParseStringMap(attr.SharedGroups), TimingIDs: utils.ParseStringMap(attr.TimingIds), Blocker: attr.Blocker, Disabled: attr.Disabled, }, }, }) if err := at.Execute(); err != nil { *reply = err.Error() return err } *reply = OK return nil }
func (ms *MongoStorage) SetReverseAlias(al *Alias, transactionID string) (err error) { session, col := ms.conn(colRls) defer session.Close() cCommit := cacheCommit(transactionID) for _, value := range al.Values { for target, pairs := range value.Pairs { for _, alias := range pairs { rKey := strings.Join([]string{alias, target, al.Context}, "") id := utils.ConcatenatedKey(al.GetId(), value.DestinationId) _, err = col.Upsert(bson.M{"key": rKey}, bson.M{"$addToSet": bson.M{"value": id}}) if err != nil { break } cache2go.RemKey(rKey, cCommit, transactionID) } } } return }
func (ms *MongoStorage) GetAlias(key string, skipCache bool) (al *Alias, err error) { origKey := key key = utils.ALIASES_PREFIX + key if !skipCache { if x, err := cache2go.Get(key); err == nil { al = &Alias{Values: x.(AliasValues)} al.SetId(origKey) return al, nil } else { return nil, err } } var kv struct { Key string Value AliasValues } if err = ms.db.C(colAls).Find(bson.M{"key": origKey}).One(&kv); err == nil { al = &Alias{Values: kv.Value} al.SetId(origKey) if err == nil { cache2go.Cache(key, al.Values) // cache reverse alias for _, value := range al.Values { for target, pairs := range value.Pairs { for _, alias := range pairs { var existingKeys map[string]bool rKey := utils.REVERSE_ALIASES_PREFIX + alias + target + al.Context if x, err := cache2go.Get(rKey); err == nil { existingKeys = x.(map[string]bool) } else { existingKeys = make(map[string]bool) } existingKeys[utils.ConcatenatedKey(origKey, value.DestinationId)] = true cache2go.Cache(rKey, existingKeys) } } } } } return }
func (self *ApierV1) EnableDisableBalance(attr *AttrAddBalance, reply *string) error { expTime, err := utils.ParseDate(attr.ExpiryTime) if err != nil { *reply = err.Error() return err } tag := utils.ConcatenatedKey(attr.Direction, attr.Tenant, attr.Account) if _, err := self.AccountDb.GetAccount(tag); err != nil { return utils.ErrNotFound } at := &engine.ActionPlan{ AccountIds: []string{tag}, } if attr.Direction == "" { attr.Direction = utils.OUT } at.SetActions(engine.Actions{ &engine.Action{ ActionType: engine.ENABLE_DISABLE_BALANCE, BalanceType: attr.BalanceType, Direction: attr.Direction, Balance: &engine.Balance{ Uuid: attr.BalanceUuid, Id: attr.BalanceId, Value: attr.Value, ExpirationDate: expTime, RatingSubject: attr.RatingSubject, DestinationIds: attr.DestinationId, Weight: attr.Weight, SharedGroup: attr.SharedGroup, Disabled: attr.Disabled, }, }, }) if err := at.Execute(); err != nil { *reply = err.Error() return err } *reply = OK return nil }