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
}